google-adk 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

google/adk/tools/langchain_tool.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any
+from __future__ import annotations
+
 from typing import Optional
 from typing import Union
 
 from google.genai import types
 from langchain.agents import Tool
 from langchain_core.tools import BaseTool
+from langchain_core.tools.structured import StructuredTool
 from typing_extensions import override
 
 from . import _automatic_function_calling_util
@@ -63,9 +65,13 @@ class LangchainTool(FunctionTool):
       raise ValueError("Langchain tool must have a 'run' or '_run' method")
 
     # Determine which function to use
-    func = tool._run if hasattr(tool, '_run') else tool.run
+    if isinstance(tool, StructuredTool):
+      func = tool.func
+    else:
+      func = tool._run if hasattr(tool, '_run') else tool.run
     super().__init__(func)
-
+    # run_manager is a special parameter for langchain tool
+    self._ignore_params.append('run_manager')
     self._langchain_tool = tool
 
     # Set name: priority is 1) explicitly provided name, 2) tool's name, 3) default
@@ -112,20 +118,21 @@ class LangchainTool(FunctionTool):
         ):
           tool_wrapper.args_schema = self._langchain_tool.args_schema
 
-        return _automatic_function_calling_util.build_function_declaration_for_langchain(
-            False,
-            self.name,
-            self.description,
-            tool_wrapper.func,
-            getattr(tool_wrapper, 'args', None),
-        )
+          return _automatic_function_calling_util.build_function_declaration_for_langchain(
+              False,
+              self.name,
+              self.description,
+              tool_wrapper.func,
+              tool_wrapper.args,
+          )
 
       # Need to provide a way to override the function names and descriptions
       # as the original function names are mostly ".run" and the descriptions
       # may not meet users' needs
-      return _automatic_function_calling_util.build_function_declaration(
-          func=self._langchain_tool.run,
-      )
+      function_decl = super()._get_declaration()
+      function_decl.name = self.name
+      function_decl.description = self.description
+      return function_decl
 
     except Exception as e:
       raise ValueError(

google/adk/tools/load_memory_tool.py

@@ -69,6 +69,7 @@ class LoadMemoryTool(FunctionTool):
                     type=types.Type.STRING,
                 )
             },
+            required=['query'],
         ),
     )
 

google/adk/tools/mcp_tool/conversion_utils.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Any
 from typing import Dict
 
@@ -41,10 +43,10 @@ def adk_to_mcp_tool_type(tool: BaseTool) -> mcp_types.Tool:
       print(mcp_tool)
   """
   tool_declaration = tool._get_declaration()
-  if not tool_declaration:
+  if not tool_declaration or not tool_declaration.parameters:
     input_schema = {}
   else:
-    input_schema = gemini_to_json_schema(tool._get_declaration().parameters)
+    input_schema = gemini_to_json_schema(tool_declaration.parameters)
   return mcp_types.Tool(
       name=tool.name,
       description=tool.description,

google/adk/tools/mcp_tool/mcp_session_manager.py

@@ -12,14 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 from contextlib import AsyncExitStack
+from datetime import timedelta
 import functools
 import logging
 import sys
 from typing import Any
 from typing import Optional
 from typing import TextIO
+from typing import Union
 
 import anyio
 from pydantic import BaseModel
@@ -29,6 +32,7 @@ try:
   from mcp import StdioServerParameters
   from mcp.client.sse import sse_client
   from mcp.client.stdio import stdio_client
+  from mcp.client.streamable_http import streamablehttp_client
 except ImportError as e:
   import sys
 
@@ -56,6 +60,20 @@ class SseServerParams(BaseModel):
   sse_read_timeout: float = 60 * 5
 
 
+class StreamableHTTPServerParams(BaseModel):
+  """Parameters for the MCP SSE connection.
+
+  See MCP SSE Client documentation for more details.
+  https://github.com/modelcontextprotocol/python-sdk/blob/main/src/mcp/client/streamable_http.py
+  """
+
+  url: str
+  headers: dict[str, Any] | None = None
+  timeout: float = 5
+  sse_read_timeout: float = 60 * 5
+  terminate_on_close: bool = True
+
+
 def retry_on_closed_resource(async_reinit_func_name: str):
   """Decorator to automatically reinitialize session and retry action.
 
@@ -123,13 +141,17 @@ class MCPSessionManager:
 
   def __init__(
       self,
-      connection_params: StdioServerParameters | SseServerParams,
+      connection_params: Union[
+          StdioServerParameters, SseServerParams, StreamableHTTPServerParams
+      ],
       errlog: TextIO = sys.stderr,
   ):
     """Initializes the MCP session manager.
 
     Args:
-        connection_params: Parameters for the MCP connection (Stdio or SSE).
+        connection_params: Parameters for the MCP connection (Stdio, SSE or
+          Streamable HTTP). Stdio by default also has a 5s read timeout as other
+          parameters but it's not configurable for now.
         errlog: (Optional) TextIO stream for error logging. Use only for
           initializing a local stdio MCP session.
     """
@@ -153,6 +175,9 @@ class MCPSessionManager:
 
     try:
       if isinstance(self._connection_params, StdioServerParameters):
+        # So far timeout is not configurable. Given MCP is still evolving, we
+        # would expect stdio_client to evolve to accept timeout parameter like
+        # other client.
         client = stdio_client(
             server=self._connection_params, errlog=self._errlog
         )
@@ -163,6 +188,16 @@ class MCPSessionManager:
             timeout=self._connection_params.timeout,
             sse_read_timeout=self._connection_params.sse_read_timeout,
         )
+      elif isinstance(self._connection_params, StreamableHTTPServerParams):
+        client = streamablehttp_client(
+            url=self._connection_params.url,
+            headers=self._connection_params.headers,
+            timeout=timedelta(seconds=self._connection_params.timeout),
+            sse_read_timeout=timedelta(
+                seconds=self._connection_params.sse_read_timeout
+            ),
+            terminate_on_close=self._connection_params.terminate_on_close,
+        )
       else:
         raise ValueError(
             'Unable to initialize connection. Connection should be'
@@ -171,9 +206,32 @@ class MCPSessionManager:
         )
 
       transports = await self._exit_stack.enter_async_context(client)
-      session = await self._exit_stack.enter_async_context(
-          ClientSession(*transports)
-      )
+      # The streamable http client returns a GetSessionCallback in addition to the read/write MemoryObjectStreams
+      # needed to build the ClientSession, we limit then to the two first values to be compatible with all clients.
+      # The StdioServerParameters does not provide a timeout parameter for the
+      # session, so we need to set a default timeout for it. Other clients
+      # (SseServerParams and StreamableHTTPServerParams) already provide a
+      # timeout parameter in their configuration.
+      if isinstance(self._connection_params, StdioServerParameters):
+        # Default timeout for MCP session is 5 seconds, same as SseServerParams
+        # and StreamableHTTPServerParams.
+        # TODO :
+        #   1. make timeout configurable
+        #   2. Add StdioConnectionParams to include StdioServerParameters as a
+        #      field and rename other two params to XXXXConnetionParams. Ohter
+        #      two params are actually connection params, while stdio is
+        #      special, stdio_client takes the resposibility of starting the
+        #      server and working as a client.
+        session = await self._exit_stack.enter_async_context(
+            ClientSession(
+                *transports[:2],
+                read_timeout_seconds=timedelta(seconds=5),
+            )
+        )
+      else:
+        session = await self._exit_stack.enter_async_context(
+            ClientSession(*transports[:2])
+        )
       await session.initialize()
 
       self._session = session

google/adk/tools/mcp_tool/mcp_tool.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 import logging
 from typing import Optional
@@ -19,6 +20,7 @@ from typing import Optional
 from google.genai.types import FunctionDeclaration
 from typing_extensions import override
 
+from .._gemini_schema_util import _to_gemini_schema
 from .mcp_session_manager import MCPSessionManager
 from .mcp_session_manager import retry_on_closed_resource
 
@@ -41,7 +43,6 @@ except ImportError as e:
 from ...auth.auth_credential import AuthCredential
 from ...auth.auth_schemes import AuthScheme
 from ..base_tool import BaseTool
-from ..openapi_tool.openapi_spec_parser.rest_api_tool import to_gemini_schema
 from ..tool_context import ToolContext
 
 logger = logging.getLogger("google_adk." + __name__)
@@ -98,7 +99,7 @@ class MCPTool(BaseTool):
         FunctionDeclaration: The Gemini function declaration for the tool.
     """
     schema_dict = self._mcp_tool.inputSchema
-    parameters = to_gemini_schema(schema_dict)
+    parameters = _to_gemini_schema(schema_dict)
     function_decl = FunctionDeclaration(
         name=self.name, description=self.description, parameters=parameters
     )

google/adk/tools/mcp_tool/mcp_toolset.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import logging
 import sys
 from typing import List
@@ -26,6 +28,7 @@ from ..base_toolset import ToolPredicate
 from .mcp_session_manager import MCPSessionManager
 from .mcp_session_manager import retry_on_closed_resource
 from .mcp_session_manager import SseServerParams
+from .mcp_session_manager import StreamableHTTPServerParams
 
 # Attempt to import MCP Tool from the MCP library, and hints user to upgrade
 # their Python version to 3.10 if it fails.
@@ -82,20 +85,23 @@ class MCPToolset(BaseToolset):
   def __init__(
       self,
       *,
-      connection_params: StdioServerParameters | SseServerParams,
+      connection_params: (
+          StdioServerParameters | SseServerParams | StreamableHTTPServerParams
+      ),
       tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
       errlog: TextIO = sys.stderr,
   ):
     """Initializes the MCPToolset.
 
     Args:
-        connection_params: The connection parameters to the MCP server. Can be:
-            `StdioServerParameters` for using local mcp server (e.g. using `npx` or
-            `python3`); or `SseServerParams` for a local/remote SSE server.
-        tool_filter: Optional filter to select specific tools. Can be either:
-            - A list of tool names to include
-            - A ToolPredicate function for custom filtering logic
-        errlog: TextIO stream for error logging.
+      connection_params: The connection parameters to the MCP server. Can be:
+        `StdioServerParameters` for using local mcp server (e.g. using `npx` or
+        `python3`); or `SseServerParams` for a local/remote SSE server; or
+        `StreamableHTTPServerParams` for local/remote Streamable http server.
+      tool_filter: Optional filter to select specific tools. Can be either:
+        - A list of tool names to include
+        - A ToolPredicate function for custom filtering logic
+      errlog: TextIO stream for error logging.
     """
     super().__init__(tool_filter=tool_filter)
 
@@ -110,6 +116,7 @@ class MCPToolset(BaseToolset):
         connection_params=self._connection_params,
         errlog=self._errlog,
     )
+
     self._session = None
 
   @retry_on_closed_resource("_reinitialize_session")

google/adk/tools/openapi_tool/common/common.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import keyword
-import re
 from typing import Any
 from typing import Dict
 from typing import List
@@ -26,47 +27,7 @@ from pydantic import BaseModel
 from pydantic import Field
 from pydantic import model_serializer
 
-
-def to_snake_case(text: str) -> str:
-  """Converts a string into snake_case.
-
-  Handles lowerCamelCase, UpperCamelCase, or space-separated case, acronyms
-  (e.g., "REST API") and consecutive uppercase letters correctly.  Also handles
-  mixed cases with and without spaces.
-
-  Examples:
-  ```
-  to_snake_case('camelCase') -> 'camel_case'
-  to_snake_case('UpperCamelCase') -> 'upper_camel_case'
-  to_snake_case('space separated') -> 'space_separated'
-  ```
-
-  Args:
-      text: The input string.
-
-  Returns:
-      The snake_case version of the string.
-  """
-
-  # Handle spaces and non-alphanumeric characters (replace with underscores)
-  text = re.sub(r'[^a-zA-Z0-9]+', '_', text)
-
-  # Insert underscores before uppercase letters (handling both CamelCases)
-  text = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', text)  # lowerCamelCase
-  text = re.sub(
-      r'([A-Z]+)([A-Z][a-z])', r'\1_\2', text
-  )  # UpperCamelCase and acronyms
-
-  # Convert to lowercase
-  text = text.lower()
-
-  # Remove consecutive underscores (clean up extra underscores)
-  text = re.sub(r'_+', '_', text)
-
-  # Remove leading and trailing underscores
-  text = text.strip('_')
-
-  return text
+from ..._gemini_schema_util import _to_snake_case
 
 
 def rename_python_keywords(s: str, prefix: str = 'param_') -> str:
@@ -106,7 +67,7 @@ class ApiParameter(BaseModel):
     self.py_name = (
         self.py_name
         if self.py_name
-        else rename_python_keywords(to_snake_case(self.original_name))
+        else rename_python_keywords(_to_snake_case(self.original_name))
     )
     if isinstance(self.param_schema, str):
       self.param_schema = Schema.model_validate_json(self.param_schema)

google/adk/tools/openapi_tool/openapi_spec_parser/__init__.py

@@ -20,7 +20,6 @@ from .operation_parser import OperationParser
 from .rest_api_tool import AuthPreparationState
 from .rest_api_tool import RestApiTool
 from .rest_api_tool import snake_to_lower_camel
-from .rest_api_tool import to_gemini_schema
 from .tool_auth_handler import ToolAuthHandler
 
 __all__ = [
@@ -30,7 +29,6 @@ __all__ = [
     'OpenAPIToolset',
     'OperationParser',
     'RestApiTool',
-    'to_gemini_schema',
     'snake_to_lower_camel',
     'AuthPreparationState',
     'ToolAuthHandler',

google/adk/tools/openapi_tool/openapi_spec_parser/openapi_spec_parser.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import copy
 from typing import Any
 from typing import Dict
@@ -23,8 +25,8 @@ from pydantic import BaseModel
 
 from ....auth.auth_credential import AuthCredential
 from ....auth.auth_schemes import AuthScheme
+from ..._gemini_schema_util import _to_snake_case
 from ..common.common import ApiParameter
-from ..common.common import to_snake_case
 from .operation_parser import OperationParser
 
 
@@ -112,7 +114,7 @@ class OpenApiSpecParser:
         # If operation ID is missing, assign an operation id based on path
         # and method
         if "operationId" not in operation_dict:
-          temp_id = to_snake_case(f"{path}_{method}")
+          temp_id = _to_snake_case(f"{path}_{method}")
           operation_dict["operationId"] = temp_id
 
         url = OperationEndpoint(base_url=base_url, path=path, method=method)

google/adk/tools/openapi_tool/openapi_spec_parser/operation_parser.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import inspect
 from textwrap import dedent
 from typing import Any
@@ -25,9 +27,9 @@ from fastapi.openapi.models import Operation
 from fastapi.openapi.models import Parameter
 from fastapi.openapi.models import Schema
 
+from ..._gemini_schema_util import _to_snake_case
 from ..common.common import ApiParameter
 from ..common.common import PydocHelper
-from ..common.common import to_snake_case
 
 
 class OperationParser:
@@ -189,7 +191,7 @@ class OperationParser:
     operation_id = self._operation.operationId
     if not operation_id:
       raise ValueError('Operation ID is missing')
-    return to_snake_case(operation_id)[:60]
+    return _to_snake_case(operation_id)[:60]
 
   def get_return_type_hint(self) -> str:
     """Returns the return type hint string (like 'str', 'int', etc.)."""

google/adk/tools/openapi_tool/openapi_spec_parser/rest_api_tool.py

@@ -12,45 +12,36 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Any
 from typing import Dict
 from typing import List
 from typing import Literal
 from typing import Optional
-from typing import Sequence
 from typing import Tuple
 from typing import Union
 
 from fastapi.openapi.models import Operation
 from google.genai.types import FunctionDeclaration
-from google.genai.types import Schema
 import requests
 from typing_extensions import override
 
 from ....auth.auth_credential import AuthCredential
 from ....auth.auth_schemes import AuthScheme
-from ....tools.base_tool import BaseTool
+from ..._gemini_schema_util import _to_gemini_schema
+from ..._gemini_schema_util import _to_snake_case
+from ...base_tool import BaseTool
 from ...tool_context import ToolContext
 from ..auth.auth_helpers import credential_to_param
 from ..auth.auth_helpers import dict_to_auth_scheme
 from ..auth.credential_exchangers.auto_auth_credential_exchanger import AutoAuthCredentialExchanger
 from ..common.common import ApiParameter
-from ..common.common import to_snake_case
 from .openapi_spec_parser import OperationEndpoint
 from .openapi_spec_parser import ParsedOperation
 from .operation_parser import OperationParser
 from .tool_auth_handler import ToolAuthHandler
 
-# Not supported by the Gemini API
-_OPENAPI_SCHEMA_IGNORE_FIELDS = (
-    "title",
-    "default",
-    "format",
-    "additional_properties",
-    "ref",
-    "def",
-)
-
 
 def snake_to_lower_camel(snake_case_string: str):
   """Converts a snake_case string to a lower_camel_case string.
@@ -70,117 +61,6 @@ def snake_to_lower_camel(snake_case_string: str):
   ])
 
 
-# TODO: Switch to Gemini `from_json_schema` util when it is released
-# in Gemini SDK.
-def normalize_json_schema_type(
-    json_schema_type: Optional[Union[str, Sequence[str]]],
-) -> tuple[Optional[str], bool]:
-  """Converts a JSON Schema Type into Gemini Schema type.
-
-  Adopted and modified from Gemini SDK. This gets the first available schema
-  type from JSON Schema, and use it to mark Gemini schema type. If JSON Schema
-  contains a list of types, the first non null type is used.
-
-  Remove this after switching to Gemini `from_json_schema`.
-  """
-  if json_schema_type is None:
-    return None, False
-  if isinstance(json_schema_type, str):
-    if json_schema_type == "null":
-      return None, True
-    return json_schema_type, False
-
-  non_null_types = []
-  nullable = False
-  # If json schema type is an array, pick the first non null type.
-  for type_value in json_schema_type:
-    if type_value == "null":
-      nullable = True
-    else:
-      non_null_types.append(type_value)
-  non_null_type = non_null_types[0] if non_null_types else None
-  return non_null_type, nullable
-
-
-# TODO: Switch to Gemini `from_json_schema` util when it is released
-# in Gemini SDK.
-def to_gemini_schema(openapi_schema: Optional[Dict[str, Any]] = None) -> Schema:
-  """Converts an OpenAPI schema dictionary to a Gemini Schema object.
-
-  Args:
-      openapi_schema: The OpenAPI schema dictionary.
-
-  Returns:
-      A Pydantic Schema object.  Returns None if input is None.
-      Raises TypeError if input is not a dict.
-  """
-  if openapi_schema is None:
-    return None
-
-  if not isinstance(openapi_schema, dict):
-    raise TypeError("openapi_schema must be a dictionary")
-
-  pydantic_schema_data = {}
-
-  # Adding this to force adding a type to an empty dict
-  # This avoid "... one_of or any_of must specify a type" error
-  if not openapi_schema.get("type"):
-    openapi_schema["type"] = "object"
-
-  for key, value in openapi_schema.items():
-    snake_case_key = to_snake_case(key)
-    # Check if the snake_case_key exists in the Schema model's fields.
-    if snake_case_key in Schema.model_fields:
-      if snake_case_key in _OPENAPI_SCHEMA_IGNORE_FIELDS:
-        # Ignore these fields as Gemini backend doesn't recognize them, and will
-        # throw exception if they appear in the schema.
-        # Format: properties[expiration].format: only 'enum' and 'date-time' are
-        # supported for STRING type
-        continue
-      elif snake_case_key == "type":
-        schema_type, nullable = normalize_json_schema_type(
-            openapi_schema.get("type", None)
-        )
-        # Adding this to force adding a type to an empty dict
-        # This avoid "... one_of or any_of must specify a type" error
-        pydantic_schema_data["type"] = schema_type if schema_type else "object"
-        pydantic_schema_data["type"] = pydantic_schema_data["type"].upper()
-        if nullable:
-          pydantic_schema_data["nullable"] = True
-      elif snake_case_key == "properties" and isinstance(value, dict):
-        pydantic_schema_data[snake_case_key] = {
-            k: to_gemini_schema(v) for k, v in value.items()
-        }
-      elif snake_case_key == "items" and isinstance(value, dict):
-        pydantic_schema_data[snake_case_key] = to_gemini_schema(value)
-      elif snake_case_key == "any_of" and isinstance(value, list):
-        pydantic_schema_data[snake_case_key] = [
-            to_gemini_schema(item) for item in value
-        ]
-      # Important:  Handle cases where the OpenAPI schema might contain lists
-      # or other structures that need to be recursively processed.
-      elif isinstance(value, list) and snake_case_key not in (
-          "enum",
-          "required",
-          "property_ordering",
-      ):
-        new_list = []
-        for item in value:
-          if isinstance(item, dict):
-            new_list.append(to_gemini_schema(item))
-          else:
-            new_list.append(item)
-        pydantic_schema_data[snake_case_key] = new_list
-      elif isinstance(value, dict) and snake_case_key not in ("properties"):
-        # Handle dictionary which is neither properties or items
-        pydantic_schema_data[snake_case_key] = to_gemini_schema(value)
-      else:
-        # Simple value assignment (int, str, bool, etc.)
-        pydantic_schema_data[snake_case_key] = value
-
-  return Schema(**pydantic_schema_data)
-
-
 AuthPreparationState = Literal["pending", "done"]
 
 
@@ -273,7 +153,7 @@ class RestApiTool(BaseTool):
         parsed.operation, parsed.parameters, parsed.return_value
     )
 
-    tool_name = to_snake_case(operation_parser.get_function_name())
+    tool_name = _to_snake_case(operation_parser.get_function_name())
     generated = cls(
         name=tool_name,
         description=parsed.operation.description
@@ -306,7 +186,7 @@ class RestApiTool(BaseTool):
   def _get_declaration(self) -> FunctionDeclaration:
     """Returns the function declaration in the Gemini Schema format."""
     schema_dict = self._operation_parser.get_json_schema()
-    parameters = to_gemini_schema(schema_dict)
+    parameters = _to_gemini_schema(schema_dict)
     function_decl = FunctionDeclaration(
         name=self.name, description=self.description, parameters=parameters
     )

google/adk/tools/openapi_tool/openapi_spec_parser/tool_auth_handler.py

@@ -185,7 +185,7 @@ class ToolAuthHandler:
       )
       self.credential_store.store_credential(key, auth_credential)
 
-  def _reqeust_credential(self) -> None:
+  def _request_credential(self) -> None:
     """Handles the case where an OpenID Connect or OAuth2 authentication request is needed."""
     if self.auth_scheme.type_ in (
         AuthSchemeType.openIdConnect,
@@ -223,11 +223,6 @@ class ToolAuthHandler:
         )
     )
 
-  def _request_credential(self, auth_config: AuthConfig):
-    if not self.tool_context:
-      return
-    self.tool_context.request_credential(auth_config)
-
   def prepare_auth_credentials(
       self,
   ) -> AuthPreparationResult:
@@ -260,7 +255,7 @@ class ToolAuthHandler:
           auth_credential=exchanged_credential,
       )
     else:
-      self._reqeust_credential()
+      self._request_credential()
       return AuthPreparationResult(
           state="pending",
           auth_scheme=self.auth_scheme,