google-adk 0.5.0__py3-none-any.whl → 1.1.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/google_search_tool.py

@@ -46,7 +46,7 @@ class GoogleSearchTool(BaseTool):
   ) -> None:
     llm_request.config = llm_request.config or types.GenerateContentConfig()
     llm_request.config.tools = llm_request.config.tools or []
-    if llm_request.model and llm_request.model.startswith('gemini-1'):
+    if llm_request.model and 'gemini-1' in llm_request.model:
       if llm_request.config.tools:
         print(llm_request.config.tools)
         raise ValueError(
@@ -55,7 +55,7 @@ class GoogleSearchTool(BaseTool):
       llm_request.config.tools.append(
           types.Tool(google_search_retrieval=types.GoogleSearchRetrieval())
       )
-    elif llm_request.model and llm_request.model.startswith('gemini-2'):
+    elif llm_request.model and 'gemini-2' in llm_request.model:
       llm_request.config.tools.append(
           types.Tool(google_search=types.GoogleSearch())
       )

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/conversion_utils.py

@@ -12,9 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict
-from google.genai.types import Schema, Type
+from typing import Any
+from typing import Dict
+
+from google.genai.types import Schema
+from google.genai.types import Type
 import mcp.types as mcp_types
+
 from ..base_tool import BaseTool