How to convert Swagger JSON to FunctionTool?

[easonktsai]

How can I dynamically convert a Swagger JSON into FunctionTool?

In Autogen 0.2, I convert swagger json by this snippet for function calling.

def create_api_function(*args, **kwargs):
    auth = kwargs.get("Authorization")
    plugin = kwargs.get("plugin")

    def function_template(*args, **kwargs):
        # skip...
        if "GET" in method.upper():
            payload = {}
            format_url += "?"
            for attr, value in kwargs.items():
                format_url += f"{attr}={value}&"
        elif "POST" in method.upper():
            payload = json.dumps(kwargs.get("payload") or kwargs.get("requestBody") or kwargs)
        headers = {"Content-Type": "application/json"}
        auth_headers = build_auth_header(plugin=plugin, Authorization=auth)
        headers.update(auth_headers)

        response = requests.request(method, format_url, headers=headers, data=payload)
        retrun response

    url = kwargs.get("url")
    method = kwargs.get("method")
    function_template.__name__ = kwargs.get("name")
    return function_template

How to migrate to v0.4 for tool using?

async def get_weather(location: str) -> str:
    return f"The weather in {location} is sunny."

tool_list = FunctionTool(create_api_function, name=function_name, description=desc)

assistant = AssistantAgent(
    "Assistant",
    model_client=model_client,
    tools=[get_weather, tool_list],
)
termination = TextMentionTermination("TERMINATE")
team = RoundRobinGroupChat([assistant], termination_condition=termination)
await Console(team.run_stream(task="What's the weather in New York?"))

And error message:
KeyError('args')

[ekzhu]

You need to pass an instance of the returned function from create_api_function to FunctionTool.

But what you did is quite interesting and potentially useful as a separate wrapper class, e.g., APITool, or OpenAPITool.

@EItanya, what do you think about this?

[EItanya]

Yea this is definitely interesting, and I think these offer 2 more ways to accomplish the task I was mentioning, in a way that may be even more flexible than MCP. They also offer 2 different levels of complexity/customizability.

I think both APITool and OpenAPITool` could offer a ton of benefit, but would probably function slightly differently.

In my mind APITool would be a generic way to configure a "function" call which calls an HTTP endpoint with a set configuration. For example:

class APITool(BaseModel):
    schema: JsonSchema
    host: str
    port: int
    path: str
    method: str
    headers: Optional[Dict[str, str]] = None
    auth: Auth

The user would be responsible for providing the json schema and all of the information for connecting to the http endpoint. Btw I think this would be very useful but pretty verbose on a per tool basis.

By contrast an OpenAPITool could look more like:

class OpenAPITool(BaseModel):
    host: str
    port: int
    headers: Optional[Dict[str, str]] = None
    auth: Auth

After initializing the OpenAPITool base, the code could reach out to the discovery endpoint and pull the available "methods" and make those "tools" available. Obviously some of these definitions would have too many methods and would need some sort of filtering, but at a high level it would work like that.

In theory this would actually be very very simple to an MCPTool:

class MCPTool(BaseModel):
    server_params: mcp.ServerParams

And then again the flow of this would be to reach out to the MCP servers to get the available tools, and then decide on the tools you want to use from the list which is available from this particular server.

Does that make sense @ekzhu, wondering your thoughts

[Ben-xiang]

@ekzhu
Hi! Sorry, we’re a bit unclear about what you mean by "to pass an instance of the returned function from create_api_function". Since the instance seems to be executed immediately and receives a response that the API failed, could you share some examples to help clarify? Thanks!

@EItanya
Hi! I was wondering if APITool and OpenAPITool have been released yet? If not, is there a way we can check their availability? Also, could you share any tips on how to avoid the 255~264 check? Thank you!

[ekzhu]

@Ben-xiang you can join the discussion in #5170 -- you may be interested in that one.

I am actually a bit confused by your question. Do you mean:

(1) Convert a Swagger JSON schema for an API into a function that can be used by an agent, or
(2) Give the agent the ability to generate new functions from Swagger JSON?

I thought you meant (1). For that, I think you may need a new implementation of autogen_core.tools.BaseTool. I am not sure if the wrapper function approach you used can return a function that has well defined argument lists that can be used by FunctionTool to automatically generate the tool schema. So you need to code up the logic for generating the argument types and return types, by subclassing BaseTool.

If you have a solution for this, would be a great contribution to the framework.