fix: Add experimental feature to use parameters_json_schema and response_json_schema for McpTool

Co-authored-by: Xuan Yang <xygoogle@google.com>
PiperOrigin-RevId: 833144947

Author: xuanyang15

src/google/adk/models/anthropic_llm.py

@@ -22,7 +22,6 @@
 import os
 from typing import Any
 from typing import AsyncGenerator
-from typing import Generator
 from typing import Iterable
 from typing import Literal
 from typing import Optional
@@ -98,14 +97,29 @@ def part_to_message_block(
     )
   elif part.function_response:
     content = ""
-    if (
-        "result" in part.function_response.response
-        and part.function_response.response["result"]
-    ):
+    response_data = part.function_response.response
+
+    # Handle response with content array
+    if "content" in response_data and response_data["content"]:
+      content_items = []
+      for item in response_data["content"]:
+        if isinstance(item, dict):
+          # Handle text content blocks
+          if item.get("type") == "text" and "text" in item:
+            content_items.append(item["text"])
+          else:
+            # Handle other structured content
+            content_items.append(str(item))
+        else:
+          content_items.append(str(item))
+      content = "\n".join(content_items) if content_items else ""
+    # Handle traditional result format
+    elif "result" in response_data and response_data["result"]:
       # Transformation is required because the content is a list of dict.
       # ToolResultBlockParam content doesn't support list of dict. Converting
       # to str to prevent anthropic.BadRequestError from being thrown.
-      content = str(part.function_response.response["result"])
+      content = str(response_data["result"])
+
     return anthropic_types.ToolResultBlockParam(
         tool_use_id=part.function_response.id or "",
         type="tool_result",
@@ -219,23 +233,27 @@ def function_declaration_to_tool_param(
   """Converts a function declaration to an Anthropic tool param."""
   assert function_declaration.name
 
-  properties = {}
-  required_params = []
-  if function_declaration.parameters:
-    if function_declaration.parameters.properties:
-      for key, value in function_declaration.parameters.properties.items():
-        value_dict = value.model_dump(exclude_none=True)
-        _update_type_string(value_dict)
-        properties[key] = value_dict
-    if function_declaration.parameters.required:
-      required_params = function_declaration.parameters.required
-
-  input_schema = {
-      "type": "object",
-      "properties": properties,
-  }
-  if required_params:
-    input_schema["required"] = required_params
+  # Use parameters_json_schema if available, otherwise convert from parameters
+  if function_declaration.parameters_json_schema:
+    input_schema = function_declaration.parameters_json_schema
+  else:
+    properties = {}
+    required_params = []
+    if function_declaration.parameters:
+      if function_declaration.parameters.properties:
+        for key, value in function_declaration.parameters.properties.items():
+          value_dict = value.model_dump(exclude_none=True)
+          _update_type_string(value_dict)
+          properties[key] = value_dict
+      if function_declaration.parameters.required:
+        required_params = function_declaration.parameters.required
+
+    input_schema = {
+        "type": "object",
+        "properties": properties,
+    }
+    if required_params:
+      input_schema["required"] = required_params
 
   return anthropic_types.ToolParam(
       name=function_declaration.name,

src/google/adk/models/google_llm.py

@@ -364,9 +364,15 @@ def _build_function_declaration_log(
         k: v.model_dump(exclude_none=True)
         for k, v in func_decl.parameters.properties.items()
     })
+  elif func_decl.parameters_json_schema:
+    param_str = str(func_decl.parameters_json_schema)
+
   return_str = ''
   if func_decl.response:
     return_str = '-> ' + str(func_decl.response.model_dump(exclude_none=True))
+  elif func_decl.response_json_schema:
+    return_str = '-> ' + str(func_decl.response_json_schema)
+
   return f'{func_decl.name}: {param_str} {return_str}'
 
 

src/google/adk/models/lite_llm.py

@@ -660,13 +660,16 @@ def _function_declaration_to_tool_param(
       },
   }
 
+  # Handle required field from parameters
   required_fields = (
       getattr(function_declaration.parameters, "required", None)
       if function_declaration.parameters
       else None
   )
   if required_fields:
     tool_params["function"]["parameters"]["required"] = required_fields
+  # parameters_json_schema already has required field in the json schema,
+  # no need to add it separately
 
   return tool_params
 
@@ -969,9 +972,15 @@ def _build_function_declaration_log(
         k: v.model_dump(exclude_none=True)
         for k, v in func_decl.parameters.properties.items()
     })
+  elif func_decl.parameters_json_schema:
+    param_str = str(func_decl.parameters_json_schema)
+
   return_str = "None"
   if func_decl.response:
     return_str = str(func_decl.response.model_dump(exclude_none=True))
+  elif func_decl.response_json_schema:
+    return_str = str(func_decl.response_json_schema)
+
   return f"{func_decl.name}: {param_str} -> {return_str}"
 
 

src/google/adk/tools/mcp_tool/conversion_utils.py

@@ -43,10 +43,16 @@ def adk_to_mcp_tool_type(tool: BaseTool) -> mcp_types.Tool:
       print(mcp_tool)
   """
   tool_declaration = tool._get_declaration()
-  if not tool_declaration or not tool_declaration.parameters:
+  if not tool_declaration:
     input_schema = {}
-  else:
+  elif tool_declaration.parameters_json_schema:
+    # Use JSON schema directly if available
+    input_schema = tool_declaration.parameters_json_schema
+  elif tool_declaration.parameters:
+    # Convert from Schema object
     input_schema = gemini_to_json_schema(tool_declaration.parameters)
+  else:
+    input_schema = {}
   return mcp_types.Tool(
       name=tool.name,
       description=tool.description,

src/google/adk/tools/mcp_tool/mcp_tool.py

@@ -30,6 +30,8 @@
 from typing_extensions import override
 
 from ...agents.readonly_context import ReadonlyContext
+from ...features import FeatureName
+from ...features import is_feature_enabled
 from .._gemini_schema_util import _to_gemini_schema
 from .mcp_session_manager import MCPSessionManager
 from .mcp_session_manager import retry_on_closed_resource
@@ -120,12 +122,21 @@ def _get_declaration(self) -> FunctionDeclaration:
         FunctionDeclaration: The Gemini function declaration for the tool.
     """
     input_schema = self._mcp_tool.inputSchema
-    parameters = _to_gemini_schema(input_schema)
-    function_decl = FunctionDeclaration(
-        name=self.name,
-        description=self.description,
-        parameters=parameters,
-    )
+    output_schema = self._mcp_tool.outputSchema
+    if is_feature_enabled(FeatureName.JSON_SCHEMA_FOR_FUNC_DECL):
+      function_decl = FunctionDeclaration(
+          name=self.name,
+          description=self.description,
+          parameters_json_schema=input_schema,
+          response_json_schema=output_schema,
+      )
+    else:
+      parameters = _to_gemini_schema(input_schema)
+      function_decl = FunctionDeclaration(
+          name=self.name,
+          description=self.description,
+          parameters=parameters,
+      )
     return function_decl
 
   @property

tests/unittests/models/test_anthropic_llm.py

@@ -273,6 +273,45 @@ def test_supported_models():
             },
         ),
     ),
+    (
+        "function_with_parameters_json_schema",
+        types.FunctionDeclaration(
+            name="search_database",
+            description="Searches a database with given criteria.",
+            parameters_json_schema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The search query",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of results",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        anthropic_types.ToolParam(
+            name="search_database",
+            description="Searches a database with given criteria.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The search query",
+                    },
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of results",
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+    ),
 ]
 
 
@@ -346,3 +385,80 @@ async def mock_coro():
       mock_client.messages.create.assert_called_once()
       _, kwargs = mock_client.messages.create.call_args
       assert kwargs["max_tokens"] == 4096
+
+
+def test_part_to_message_block_with_content():
+  """Test that part_to_message_block handles content format."""
+  from google.adk.models.anthropic_llm import part_to_message_block
+
+  # Create a function response part with content array.
+  mcp_response_part = types.Part.from_function_response(
+      name="generate_sample_filesystem",
+      response={
+          "content": [{
+              "type": "text",
+              "text": '{"name":"root","node_type":"folder","children":[]}',
+          }]
+      },
+  )
+  mcp_response_part.function_response.id = "test_id_123"
+
+  result = part_to_message_block(mcp_response_part)
+
+  # ToolResultBlockParam is a TypedDict.
+  assert isinstance(result, dict)
+  assert result["tool_use_id"] == "test_id_123"
+  assert result["type"] == "tool_result"
+  assert not result["is_error"]
+  # Verify the content was extracted from the content format.
+  assert (
+      '{"name":"root","node_type":"folder","children":[]}' in result["content"]
+  )
+
+
+def test_part_to_message_block_with_traditional_result():
+  """Test that part_to_message_block handles traditional result format."""
+  from google.adk.models.anthropic_llm import part_to_message_block
+
+  # Create a function response part with traditional result format
+  traditional_response_part = types.Part.from_function_response(
+      name="some_tool",
+      response={
+          "result": "This is the result from the tool",
+      },
+  )
+  traditional_response_part.function_response.id = "test_id_456"
+
+  result = part_to_message_block(traditional_response_part)
+
+  # ToolResultBlockParam is a TypedDict.
+  assert isinstance(result, dict)
+  assert result["tool_use_id"] == "test_id_456"
+  assert result["type"] == "tool_result"
+  assert not result["is_error"]
+  # Verify the content was extracted from the traditional format
+  assert "This is the result from the tool" in result["content"]
+
+
+def test_part_to_message_block_with_multiple_content_items():
+  """Test content with multiple items."""
+  from google.adk.models.anthropic_llm import part_to_message_block
+
+  # Create a function response with multiple content items
+  multi_content_part = types.Part.from_function_response(
+      name="multi_response_tool",
+      response={
+          "content": [
+              {"type": "text", "text": "First part"},
+              {"type": "text", "text": "Second part"},
+          ]
+      },
+  )
+  multi_content_part.function_response.id = "test_id_789"
+
+  result = part_to_message_block(multi_content_part)
+
+  # ToolResultBlockParam is a TypedDict.
+  assert isinstance(result, dict)
+  # Multiple text items should be joined with newlines
+  assert result["content"] == "First part\nSecond part"