feat(tools): use { input_schema, output_schema } for ToolDefinition

llama_stack/providers/utils/inference/openai_compat.py

@@ -127,7 +127,6 @@ from llama_stack.models.llama.datatypes import (
     StopReason,
     ToolCall,
     ToolDefinition,
-    ToolParamDefinition,
 )
 from llama_stack.providers.utils.inference.prompt_adapter import (
     convert_image_content_to_url,
@@ -747,14 +746,8 @@ def convert_tooldef_to_openai_tool(tool: ToolDefinition) -> dict:
     ToolDefinition:
         tool_name: str | BuiltinTool
         description: Optional[str]
-        parameters: Optional[Dict[str, ToolParamDefinition]]
-
-    ToolParamDefinition:
-        param_type: str
-        description: Optional[str]
-        required: Optional[bool]
-        default: Optional[Any]
-
+        input_schema: Optional[Dict[str, Any]]  # JSON Schema
+        output_schema: Optional[Dict[str, Any]]  # JSON Schema (not used by OpenAI)
 
     OpenAI spec -
 
@@ -763,20 +756,11 @@ def convert_tooldef_to_openai_tool(tool: ToolDefinition) -> dict:
         "function": {
             "name": tool_name,
             "description": description,
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    param_name: {
-                        "type": param_type,
-                        "description": description,
-                        "default": default,
-                    },
-                    ...
-                },
-                "required": [param_name, ...],
-            },
+            "parameters": {<JSON Schema>},
         },
     }
+
+    NOTE: OpenAI does not support output_schema, so it is dropped here.
     """
     out = {
         "type": "function",
@@ -785,37 +769,19 @@ def convert_tooldef_to_openai_tool(tool: ToolDefinition) -> dict:
     function = out["function"]
 
     if isinstance(tool.tool_name, BuiltinTool):
-        function.update(name=tool.tool_name.value)  # TODO(mf): is this sufficient?
+        function["name"] = tool.tool_name.value
     else:
-        function.update(name=tool.tool_name)
+        function["name"] = tool.tool_name
 
     if tool.description:
-        function.update(description=tool.description)
+        function["description"] = tool.description
 
-    if tool.parameters:
-        parameters = {
-            "type": "object",
-            "properties": {},
-        }
-        properties = parameters["properties"]
-        required = []
-        for param_name, param in tool.parameters.items():
-            properties[param_name] = to_openai_param_type(param.param_type)
-            if param.description:
-                properties[param_name].update(description=param.description)
-            if param.default:
-                properties[param_name].update(default=param.default)
-            if param.items:
-                properties[param_name].update(items=param.items)
-            if param.title:
-                properties[param_name].update(title=param.title)
-            if param.required:
-                required.append(param_name)
+    if tool.input_schema:
+        # Pass through the entire JSON Schema as-is
+        function["parameters"] = tool.input_schema
 
-        if required:
-            parameters.update(required=required)
-
-        function.update(parameters=parameters)
+    # NOTE: OpenAI does not support output_schema, so we drop it here
+    # It's stored in LlamaStack for validation and other provider usage
 
     return out
 
@@ -876,22 +842,12 @@ def _convert_openai_request_tools(tools: list[dict[str, Any]] | None = None) ->
         tool_fn = tool.get("function", {})
         tool_name = tool_fn.get("name", None)
         tool_desc = tool_fn.get("description", None)
-
         tool_params = tool_fn.get("parameters", None)
-        lls_tool_params = {}
-        if tool_params is not None:
-            tool_param_properties = tool_params.get("properties", {})
-            for tool_param_key, tool_param_value in tool_param_properties.items():
-                tool_param_def = ToolParamDefinition(
-                    param_type=str(tool_param_value.get("type", None)),
-                    description=tool_param_value.get("description", None),
-                )
-                lls_tool_params[tool_param_key] = tool_param_def
 
         lls_tool = ToolDefinition(
             tool_name=tool_name,
             description=tool_desc,
-            parameters=lls_tool_params,
+            input_schema=tool_params,  # Pass through entire JSON Schema
         )
         lls_tools.append(lls_tool)
     return lls_tools

llama_stack/providers/utils/tools/mcp.py

@@ -20,7 +20,6 @@ from llama_stack.apis.tools import (
     ListToolDefsResponse,
     ToolDef,
     ToolInvocationResult,
-    ToolParameter,
 )
 from llama_stack.core.datatypes import AuthenticationRequiredError
 from llama_stack.log import get_logger
@@ -113,24 +112,12 @@ async def list_mcp_tools(endpoint: str, headers: dict[str, str]) -> ListToolDefs
     async with client_wrapper(endpoint, headers) as session:
         tools_result = await session.list_tools()
         for tool in tools_result.tools:
-            parameters = []
-            for param_name, param_schema in tool.inputSchema.get("properties", {}).items():
-                parameters.append(
-                    ToolParameter(
-                        name=param_name,
-                        parameter_type=param_schema.get("type", "string"),
-                        description=param_schema.get("description", ""),
-                        required="default" not in param_schema,
-                        items=param_schema.get("items", None),
-                        title=param_schema.get("title", None),
-                        default=param_schema.get("default", None),
-                    )
-                )
             tools.append(
                 ToolDef(
                     name=tool.name,
                     description=tool.description,
-                    parameters=parameters,
+                    input_schema=tool.inputSchema,
+                    output_schema=getattr(tool, "outputSchema", None),
                     metadata={
                         "endpoint": endpoint,
                     },