google-adk 0.5.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

google/adk/tools/google_api_tool/googleapi_to_openapi_converter.py

@@ -18,19 +18,13 @@ import logging
 from typing import Any
 from typing import Dict
 from typing import List
-from typing import Optional
-from typing import Union
 
 # Google API client
 from googleapiclient.discovery import build
-from googleapiclient.discovery import Resource
 from googleapiclient.errors import HttpError
 
 # Configure logging
-logging.basicConfig(
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-)
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("google_adk." + __name__)
 
 
 class GoogleApiToOpenApiConverter:
@@ -43,11 +37,11 @@ class GoogleApiToOpenApiConverter:
         api_name: The name of the Google API (e.g., "calendar")
         api_version: The version of the API (e.g., "v3")
     """
-    self.api_name = api_name
-    self.api_version = api_version
-    self.google_api_resource = None
-    self.google_api_spec = None
-    self.openapi_spec = {
+    self._api_name = api_name
+    self._api_version = api_version
+    self._google_api_resource = None
+    self._google_api_spec = None
+    self._openapi_spec = {
         "openapi": "3.0.0",
         "info": {},
         "servers": [],
@@ -59,18 +53,20 @@ class GoogleApiToOpenApiConverter:
     """Fetches the Google API specification using discovery service."""
     try:
       logger.info(
-          "Fetching Google API spec for %s %s", self.api_name, self.api_version
+          "Fetching Google API spec for %s %s",
+          self._api_name,
+          self._api_version,
       )
       # Build a resource object for the specified API
-      self.google_api_resource = build(self.api_name, self.api_version)
+      self._google_api_resource = build(self._api_name, self._api_version)
 
       # Access the underlying API discovery document
-      self.google_api_spec = self.google_api_resource._rootDesc
+      self._google_api_spec = self._google_api_resource._rootDesc
 
-      if not self.google_api_spec:
+      if not self._google_api_spec:
         raise ValueError("Failed to retrieve API specification")
 
-      logger.info("Successfully fetched %s API specification", self.api_name)
+      logger.info("Successfully fetched %s API specification", self._api_name)
     except HttpError as e:
       logger.error("HTTP Error: %s", e)
       raise
@@ -84,7 +80,7 @@ class GoogleApiToOpenApiConverter:
     Returns:
         Dict containing the converted OpenAPI v3 specification
     """
-    if not self.google_api_spec:
+    if not self._google_api_spec:
       self.fetch_google_api_spec()
 
     # Convert basic API information
@@ -100,49 +96,49 @@ class GoogleApiToOpenApiConverter:
     self._convert_schemas()
 
     # Convert endpoints/paths
-    self._convert_resources(self.google_api_spec.get("resources", {}))
+    self._convert_resources(self._google_api_spec.get("resources", {}))
 
     # Convert top-level methods, if any
-    self._convert_methods(self.google_api_spec.get("methods", {}), "/")
+    self._convert_methods(self._google_api_spec.get("methods", {}), "/")
 
-    return self.openapi_spec
+    return self._openapi_spec
 
   def _convert_info(self) -> None:
     """Convert basic API information."""
-    self.openapi_spec["info"] = {
-        "title": self.google_api_spec.get("title", f"{self.api_name} API"),
-        "description": self.google_api_spec.get("description", ""),
-        "version": self.google_api_spec.get("version", self.api_version),
+    self._openapi_spec["info"] = {
+        "title": self._google_api_spec.get("title", f"{self._api_name} API"),
+        "description": self._google_api_spec.get("description", ""),
+        "version": self._google_api_spec.get("version", self._api_version),
         "contact": {},
-        "termsOfService": self.google_api_spec.get("documentationLink", ""),
+        "termsOfService": self._google_api_spec.get("documentationLink", ""),
     }
 
     # Add documentation links if available
-    docs_link = self.google_api_spec.get("documentationLink")
+    docs_link = self._google_api_spec.get("documentationLink")
     if docs_link:
-      self.openapi_spec["externalDocs"] = {
+      self._openapi_spec["externalDocs"] = {
           "description": "API Documentation",
           "url": docs_link,
       }
 
   def _convert_servers(self) -> None:
     """Convert server information."""
-    base_url = self.google_api_spec.get(
+    base_url = self._google_api_spec.get(
         "rootUrl", ""
-    ) + self.google_api_spec.get("servicePath", "")
+    ) + self._google_api_spec.get("servicePath", "")
 
     # Remove trailing slash if present
     if base_url.endswith("/"):
       base_url = base_url[:-1]
 
-    self.openapi_spec["servers"] = [{
+    self._openapi_spec["servers"] = [{
         "url": base_url,
-        "description": f"{self.api_name} {self.api_version} API",
+        "description": f"{self._api_name} {self._api_version} API",
     }]
 
   def _convert_security_schemes(self) -> None:
     """Convert authentication and authorization schemes."""
-    auth = self.google_api_spec.get("auth", {})
+    auth = self._google_api_spec.get("auth", {})
     oauth2 = auth.get("oauth2", {})
 
     if oauth2:
@@ -153,7 +149,7 @@ class GoogleApiToOpenApiConverter:
       for scope, scope_info in scopes.items():
         formatted_scopes[scope] = scope_info.get("description", "")
 
-      self.openapi_spec["components"]["securitySchemes"]["oauth2"] = {
+      self._openapi_spec["components"]["securitySchemes"]["oauth2"] = {
           "type": "oauth2",
           "description": "OAuth 2.0 authentication",
           "flows": {
@@ -168,7 +164,7 @@ class GoogleApiToOpenApiConverter:
       }
 
     # Add API key authentication (most Google APIs support this)
-    self.openapi_spec["components"]["securitySchemes"]["apiKey"] = {
+    self._openapi_spec["components"]["securitySchemes"]["apiKey"] = {
         "type": "apiKey",
         "in": "query",
         "name": "key",
@@ -176,18 +172,20 @@ class GoogleApiToOpenApiConverter:
     }
 
     # Create global security requirement
-    self.openapi_spec["security"] = [
+    self._openapi_spec["security"] = [
         {"oauth2": list(formatted_scopes.keys())} if oauth2 else {},
         {"apiKey": []},
     ]
 
   def _convert_schemas(self) -> None:
     """Convert schema definitions (models)."""
-    schemas = self.google_api_spec.get("schemas", {})
+    schemas = self._google_api_spec.get("schemas", {})
 
     for schema_name, schema_def in schemas.items():
       converted_schema = self._convert_schema_object(schema_def)
-      self.openapi_spec["components"]["schemas"][schema_name] = converted_schema
+      self._openapi_spec["components"]["schemas"][
+          schema_name
+      ] = converted_schema
 
   def _convert_schema_object(
       self, schema_def: Dict[str, Any]
@@ -320,11 +318,11 @@ class GoogleApiToOpenApiConverter:
       path_params = self._extract_path_parameters(rest_path)
 
       # Create path entry if it doesn't exist
-      if rest_path not in self.openapi_spec["paths"]:
-        self.openapi_spec["paths"][rest_path] = {}
+      if rest_path not in self._openapi_spec["paths"]:
+        self._openapi_spec["paths"][rest_path] = {}
 
       # Add the operation for this method
-      self.openapi_spec["paths"][rest_path][http_method] = (
+      self._openapi_spec["paths"][rest_path][http_method] = (
           self._convert_operation(method_data, path_params)
       )
 
@@ -478,7 +476,7 @@ class GoogleApiToOpenApiConverter:
         output_path: Path where the OpenAPI spec should be saved
     """
     with open(output_path, "w", encoding="utf-8") as f:
-      json.dump(self.openapi_spec, f, indent=2)
+      json.dump(self._openapi_spec, f, indent=2)
     logger.info("OpenAPI specification saved to %s", output_path)
 
 

google/adk/tools/langchain_tool.py

@@ -13,10 +13,12 @@
 # limitations under the License.
 
 from typing import Any
-from typing import Callable
+from typing import Optional
+from typing import Union
 
 from google.genai import types
-from pydantic import model_validator
+from langchain.agents import Tool
+from langchain_core.tools import BaseTool
 from typing_extensions import override
 
 from . import _automatic_function_calling_util
@@ -24,63 +26,108 @@ from .function_tool import FunctionTool
 
 
 class LangchainTool(FunctionTool):
-  """Use this class to wrap a langchain tool.
+  """Adapter class that wraps a Langchain tool for use with ADK.
 
-  If the original tool name and description are not suitable, you can override
-  them in the constructor.
+  This adapter converts Langchain tools into a format compatible with Google's
+  generative AI function calling interface. It preserves the tool's name,
+  description, and functionality while adapting its schema.
+
+  The original tool's name and description can be overridden if needed.
+
+  Args:
+      tool: A Langchain tool to wrap (BaseTool or a tool with a .run method)
+      name: Optional override for the tool's name
+      description: Optional override for the tool's description
+
+  Examples:
+      ```python
+      from langchain.tools import DuckDuckGoSearchTool
+      from google.genai.tools import LangchainTool
+
+      search_tool = DuckDuckGoSearchTool()
+      wrapped_tool = LangchainTool(search_tool)
+      ```
   """
 
-  tool: Any
+  _langchain_tool: Union[BaseTool, object]
   """The wrapped langchain tool."""
 
-  def __init__(self, tool: Any):
-    super().__init__(tool._run)
-    self.tool = tool
-    if tool.name:
+  def __init__(
+      self,
+      tool: Union[BaseTool, object],
+      name: Optional[str] = None,
+      description: Optional[str] = None,
+  ):
+    # Check if the tool has a 'run' method
+    if not hasattr(tool, 'run') and not hasattr(tool, '_run'):
+      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
+    super().__init__(func)
+
+    self._langchain_tool = tool
+
+    # Set name: priority is 1) explicitly provided name, 2) tool's name, 3) default
+    if name is not None:
+      self.name = name
+    elif hasattr(tool, 'name') and tool.name:
       self.name = tool.name
-    if tool.description:
-      self.description = tool.description
+    # else: keep default from FunctionTool
 
-  @model_validator(mode='before')
-  @classmethod
-  def populate_name(cls, data: Any) -> Any:
-    # Override this to not use function's signature name as it's
-    # mostly "run" or "invoke" for thir-party tools.
-    return data
+    # Set description: similar priority
+    if description is not None:
+      self.description = description
+    elif hasattr(tool, 'description') and tool.description:
+      self.description = tool.description
+    # else: keep default from FunctionTool
 
   @override
   def _get_declaration(self) -> types.FunctionDeclaration:
-    """Build the function declaration for the tool."""
-    from langchain.agents import Tool
-    from langchain_core.tools import BaseTool
-
-    # There are two types of tools:
-    # 1. BaseTool: the tool is defined in langchain.tools.
-    # 2. Other tools: the tool doesn't inherit any class but follow some
-    #    conventions, like having a "run" method.
-    if isinstance(self.tool, BaseTool):
-      tool_wrapper = Tool(
-          name=self.name,
-          func=self.func,
-          description=self.description,
-      )
-      if self.tool.args_schema:
-        tool_wrapper.args_schema = self.tool.args_schema
-      function_declaration = _automatic_function_calling_util.build_function_declaration_for_langchain(
-          False,
-          self.name,
-          self.description,
-          tool_wrapper.func,
-          tool_wrapper.args,
-      )
-      return function_declaration
-    else:
+    """Build the function declaration for the tool.
+
+    Returns:
+        A FunctionDeclaration object that describes the tool's interface.
+
+    Raises:
+        ValueError: If the tool schema cannot be correctly parsed.
+    """
+    try:
+      # There are two types of tools:
+      # 1. BaseTool: the tool is defined in langchain_core.tools.
+      # 2. Other tools: the tool doesn't inherit any class but follow some
+      #    conventions, like having a "run" method.
+      # Handle BaseTool type (preferred Langchain approach)
+      if isinstance(self._langchain_tool, BaseTool):
+        tool_wrapper = Tool(
+            name=self.name,
+            func=self.func,
+            description=self.description,
+        )
+
+        # Add schema if available
+        if (
+            hasattr(self._langchain_tool, 'args_schema')
+            and self._langchain_tool.args_schema
+        ):
+          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),
+        )
+
       # 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.
-      function_declaration = (
-          _automatic_function_calling_util.build_function_declaration(
-              func=self.tool.run,
-          )
+      # may not meet users' needs
+      return _automatic_function_calling_util.build_function_declaration(
+          func=self._langchain_tool.run,
       )
-      return function_declaration
+
+    except Exception as e:
+      raise ValueError(
+          f'Failed to build function declaration for Langchain tool: {e}'
+      ) from e

google/adk/tools/load_memory_tool.py

@@ -17,19 +17,25 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from google.genai import types
+from pydantic import BaseModel
+from pydantic import Field
 from typing_extensions import override
 
+from ..memory.memory_entry import MemoryEntry
 from .function_tool import FunctionTool
 from .tool_context import ToolContext
 
 if TYPE_CHECKING:
-  from ..memory.base_memory_service import MemoryResult
   from ..models import LlmRequest
 
 
+class LoadMemoryResponse(BaseModel):
+  memories: list[MemoryEntry] = Field(default_factory=list)
+
+
 async def load_memory(
     query: str, tool_context: ToolContext
-) -> 'list[MemoryResult]':
+) -> LoadMemoryResponse:
   """Loads the memory for the current user.
 
   Args:
@@ -38,12 +44,15 @@ async def load_memory(
   Returns:
     A list of memory results.
   """
-  response = await tool_context.search_memory(query)
-  return response.memories
+  search_memory_response = await tool_context.search_memory(query)
+  return LoadMemoryResponse(memories=search_memory_response.memories)
 
 
 class LoadMemoryTool(FunctionTool):
-  """A tool that loads the memory for the current user."""
+  """A tool that loads the memory for the current user.
+
+  NOTE: Currently this tool only uses text part from the memory.
+  """
 
   def __init__(self):
     super().__init__(load_memory)

google/adk/tools/mcp_tool/__init__.py

@@ -15,7 +15,8 @@
 __all__ = []
 
 try:
-  from .conversion_utils import adk_to_mcp_tool_type, gemini_to_json_schema
+  from .conversion_utils import adk_to_mcp_tool_type
+  from .conversion_utils import gemini_to_json_schema
   from .mcp_tool import MCPTool
   from .mcp_toolset import MCPToolset
 
@@ -30,7 +31,7 @@ except ImportError as e:
   import logging
   import sys
 
-  logger = logging.getLogger(__name__)
+  logger = logging.getLogger('google_adk.' + __name__)
 
   if sys.version_info < (3, 10):
     logger.warning(

google/adk/tools/mcp_tool/mcp_session_manager.py

@@ -12,15 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
+from contextlib import asynccontextmanager
 from contextlib import AsyncExitStack
 import functools
+import logging
 import sys
-from typing import Any, TextIO
+from typing import Any
+from typing import Optional
+from typing import TextIO
+
 import anyio
 from pydantic import BaseModel
 
 try:
-  from mcp import ClientSession, StdioServerParameters
+  from mcp import ClientSession
+  from mcp import StdioServerParameters
   from mcp.client.sse import sse_client
   from mcp.client.stdio import stdio_client
 except ImportError as e:
@@ -34,6 +41,8 @@ except ImportError as e:
   else:
     raise e
 
+logger = logging.getLogger('google_adk.' + __name__)
+
 
 class SseServerParams(BaseModel):
   """Parameters for the MCP SSE connection.
@@ -108,6 +117,45 @@ def retry_on_closed_resource(async_reinit_func_name: str):
   return decorator
 
 
+@asynccontextmanager
+async def tracked_stdio_client(server, errlog, process=None):
+  """A wrapper around stdio_client that ensures proper process tracking and cleanup."""
+  our_process = process
+
+  # If no process was provided, create one
+  if our_process is None:
+    our_process = await asyncio.create_subprocess_exec(
+        server.command,
+        *server.args,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=errlog,
+    )
+
+  # Use the original stdio_client, but ensure process cleanup
+  try:
+    async with stdio_client(server=server, errlog=errlog) as client:
+      yield client, our_process
+  finally:
+    # Ensure the process is properly terminated if it still exists
+    if our_process and our_process.returncode is None:
+      try:
+        logger.info(
+            f'Terminating process {our_process.pid} from tracked_stdio_client'
+        )
+        our_process.terminate()
+        try:
+          await asyncio.wait_for(our_process.wait(), timeout=3.0)
+        except asyncio.TimeoutError:
+          # Force kill if it doesn't terminate quickly
+          if our_process.returncode is None:
+            logger.warning(f'Forcing kill of process {our_process.pid}')
+            our_process.kill()
+      except ProcessLookupError:
+        # Process already gone, that's fine
+        logger.info(f'Process {our_process.pid} already terminated')
+
+
 class MCPSessionManager:
   """Manages MCP client sessions.
 
@@ -120,7 +168,7 @@ class MCPSessionManager:
       connection_params: StdioServerParameters | SseServerParams,
       exit_stack: AsyncExitStack,
       errlog: TextIO = sys.stderr,
-  ) -> ClientSession:
+  ):
     """Initializes the MCP session manager.
 
     Example usage:
@@ -138,25 +186,39 @@ class MCPSessionManager:
         errlog: (Optional) TextIO stream for error logging. Use only for
           initializing a local stdio MCP session.
     """
-    self.connection_params = connection_params
-    self.exit_stack = exit_stack
-    self.errlog = errlog
-
-  async def create_session(self) -> ClientSession:
-    return await MCPSessionManager.initialize_session(
-        connection_params=self.connection_params,
-        exit_stack=self.exit_stack,
-        errlog=self.errlog,
+
+    self._connection_params = connection_params
+    self._exit_stack = exit_stack
+    self._errlog = errlog
+    self._process = None  # Track the subprocess
+    self._active_processes = set()  # Track all processes created
+    self._active_file_handles = set()  # Track file handles
+
+  async def create_session(
+      self,
+  ) -> tuple[ClientSession, Optional[asyncio.subprocess.Process]]:
+    """Creates a new MCP session and tracks the associated process."""
+    session, process = await self._initialize_session(
+        connection_params=self._connection_params,
+        exit_stack=self._exit_stack,
+        errlog=self._errlog,
     )
+    self._process = process  # Store reference to process
+
+    # Track the process
+    if process:
+      self._active_processes.add(process)
+
+    return session, process
 
   @classmethod
-  async def initialize_session(
+  async def _initialize_session(
       cls,
       *,
       connection_params: StdioServerParameters | SseServerParams,
       exit_stack: AsyncExitStack,
       errlog: TextIO = sys.stderr,
-  ) -> ClientSession:
+  ) -> tuple[ClientSession, Optional[asyncio.subprocess.Process]]:
     """Initializes an MCP client session.
 
     Args:
@@ -168,9 +230,17 @@ class MCPSessionManager:
     Returns:
         ClientSession: The initialized MCP client session.
     """
+    process = None
+
     if isinstance(connection_params, StdioServerParameters):
-      client = stdio_client(server=connection_params, errlog=errlog)
+      # For stdio connections, we need to track the subprocess
+      client, process = await cls._create_stdio_client(
+          server=connection_params,
+          errlog=errlog,
+          exit_stack=exit_stack,
+      )
     elif isinstance(connection_params, SseServerParams):
+      # For SSE connections, create the client without a subprocess
       client = sse_client(
           url=connection_params.url,
           headers=connection_params.headers,
@@ -184,7 +254,74 @@ class MCPSessionManager:
           f' {connection_params}'
       )
 
+    # Create the session with the client
     transports = await exit_stack.enter_async_context(client)
     session = await exit_stack.enter_async_context(ClientSession(*transports))
     await session.initialize()
-    return session
+
+    return session, process
+
+  @staticmethod
+  async def _create_stdio_client(
+      server: StdioServerParameters,
+      errlog: TextIO,
+      exit_stack: AsyncExitStack,
+  ) -> tuple[Any, asyncio.subprocess.Process]:
+    """Create stdio client and return both the client and process.
+
+    This implementation adapts to how the MCP stdio_client is created.
+    The actual implementation may need to be adjusted based on the MCP library
+    structure.
+    """
+    # Create the subprocess directly so we can track it
+    process = await asyncio.create_subprocess_exec(
+        server.command,
+        *server.args,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=errlog,
+    )
+
+    # Create the stdio client using the MCP library
+    try:
+      # Method 1: Try using the existing process if stdio_client supports it
+      client = stdio_client(server=server, errlog=errlog, process=process)
+    except TypeError:
+      # Method 2: If the above doesn't work, let stdio_client create its own process
+      # and we'll need to terminate both processes later
+      logger.warning(
+          'Using stdio_client with its own process - may lead to duplicate'
+          ' processes'
+      )
+      client = stdio_client(server=server, errlog=errlog)
+
+    return client, process
+
+  async def _emergency_cleanup(self):
+    """Perform emergency cleanup of resources when normal cleanup fails."""
+    logger.info('Performing emergency cleanup of MCPSessionManager resources')
+
+    # Clean up any tracked processes
+    for proc in list(self._active_processes):
+      try:
+        if proc and proc.returncode is None:
+          logger.info(f'Emergency termination of process {proc.pid}')
+          proc.terminate()
+          try:
+            await asyncio.wait_for(proc.wait(), timeout=1.0)
+          except asyncio.TimeoutError:
+            logger.warning(f"Process {proc.pid} didn't terminate, forcing kill")
+            proc.kill()
+        self._active_processes.remove(proc)
+      except Exception as e:
+        logger.error(f'Error during process cleanup: {e}')
+
+    # Clean up any tracked file handles
+    for handle in list(self._active_file_handles):
+      try:
+        if not handle.closed:
+          logger.info('Closing file handle')
+          handle.close()
+        self._active_file_handles.remove(handle)
+      except Exception as e:
+        logger.error(f'Error closing file handle: {e}')