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

google/adk/tools/google_api_tool/google_api_toolset.py

@@ -0,0 +1,126 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import inspect
+import os
+from typing import Any
+from typing import List
+from typing import Optional
+from typing import Type
+from typing import Union
+
+from typing_extensions import override
+
+from ...agents.readonly_context import ReadonlyContext
+from ...auth import OpenIdConnectWithConfig
+from ...tools.base_toolset import BaseToolset
+from ...tools.base_toolset import ToolPredicate
+from ..openapi_tool import OpenAPIToolset
+from .google_api_tool import GoogleApiTool
+from .googleapi_to_openapi_converter import GoogleApiToOpenApiConverter
+
+
+class GoogleApiToolset(BaseToolset):
+  """Google API Toolset contains tools for interacting with Google APIs.
+
+  Usually one toolsets will contains tools only related to one Google API, e.g.
+  Google Bigquery API toolset will contains tools only related to Google
+  Bigquery API, like list dataset tool, list table tool etc.
+  """
+
+  def __init__(
+      self,
+      api_name: str,
+      api_version: str,
+      client_id: Optional[str] = None,
+      client_secret: Optional[str] = None,
+      tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+  ):
+    self.api_name = api_name
+    self.api_version = api_version
+    self._client_id = client_id
+    self._client_secret = client_secret
+    self._openapi_toolset = self._load_toolset_with_oidc_auth()
+    self.tool_filter = tool_filter
+
+  def _is_tool_selected(
+      self, tool: GoogleApiTool, readonly_context: ReadonlyContext
+  ) -> bool:
+    if not self.tool_filter:
+      return True
+
+    if isinstance(self.tool_filter, ToolPredicate):
+      return self.tool_filter(tool, readonly_context)
+
+    if isinstance(self.tool_filter, list):
+      return tool.name in self.tool_filter
+
+    return False
+
+  @override
+  async def get_tools(
+      self, readonly_context: Optional[ReadonlyContext] = None
+  ) -> List[GoogleApiTool]:
+    """Get all tools in the toolset."""
+    tools = []
+
+    return [
+        GoogleApiTool(tool, self._client_id, self._client_secret)
+        for tool in await self._openapi_toolset.get_tools(readonly_context)
+        if self._is_tool_selected(tool, readonly_context)
+    ]
+
+  def set_tool_filter(self, tool_filter: Union[ToolPredicate, List[str]]):
+    self.tool_filter = tool_filter
+
+  def _load_toolset_with_oidc_auth(self) -> OpenAPIToolset:
+    spec_dict = GoogleApiToOpenApiConverter(
+        self.api_name, self.api_version
+    ).convert()
+    scope = list(
+        spec_dict['components']['securitySchemes']['oauth2']['flows'][
+            'authorizationCode'
+        ]['scopes'].keys()
+    )[0]
+    return OpenAPIToolset(
+        spec_dict=spec_dict,
+        spec_str_type='yaml',
+        auth_scheme=OpenIdConnectWithConfig(
+            authorization_endpoint=(
+                'https://accounts.google.com/o/oauth2/v2/auth'
+            ),
+            token_endpoint='https://oauth2.googleapis.com/token',
+            userinfo_endpoint=(
+                'https://openidconnect.googleapis.com/v1/userinfo'
+            ),
+            revocation_endpoint='https://oauth2.googleapis.com/revoke',
+            token_endpoint_auth_methods_supported=[
+                'client_secret_post',
+                'client_secret_basic',
+            ],
+            grant_types_supported=['authorization_code'],
+            scopes=[scope],
+        ),
+    )
+
+  def configure_auth(self, client_id: str, client_secret: str):
+    self._client_id = client_id
+    self._client_secret = client_secret
+
+  @override
+  async def close(self):
+    if self._openapi_toolset:
+      await self._openapi_toolset.close()

google/adk/tools/google_api_tool/google_api_toolsets.py

@@ -0,0 +1,102 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import logging
+from typing import List
+from typing import Optional
+from typing import Union
+
+from google.adk.tools.base_toolset import ToolPredicate
+
+from .google_api_toolset import GoogleApiToolset
+
+logger = logging.getLogger("google_adk." + __name__)
+
+
+class BigQueryToolset(GoogleApiToolset):
+
+  def __init__(
+      self,
+      client_id: str = None,
+      client_secret: str = None,
+      tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+  ):
+    super().__init__("bigquery", "v2", client_id, client_secret, tool_filter)
+
+
+class CalendarToolset(GoogleApiToolset):
+
+  def __init__(
+      self,
+      client_id: str = None,
+      client_secret: str = None,
+      tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+  ):
+    super().__init__("calendar", "v3", client_id, client_secret, tool_filter)
+
+
+class GmailToolset(GoogleApiToolset):
+
+  def __init__(
+      self,
+      client_id: str = None,
+      client_secret: str = None,
+      tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+  ):
+    super().__init__("gmail", "v1", client_id, client_secret, tool_filter)
+
+
+class YoutubeToolset(GoogleApiToolset):
+
+  def __init__(
+      self,
+      client_id: str = None,
+      client_secret: str = None,
+      tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+  ):
+    super().__init__("youtube", "v3", client_id, client_secret, tool_filter)
+
+
+class SlidesToolset(GoogleApiToolset):
+
+  def __init__(
+      self,
+      client_id: str = None,
+      client_secret: str = None,
+      tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+  ):
+    super().__init__("slides", "v1", client_id, client_secret, tool_filter)
+
+
+class SheetsToolset(GoogleApiToolset):
+
+  def __init__(
+      self,
+      client_id: str = None,
+      client_secret: str = None,
+      tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+  ):
+    super().__init__("sheets", "v4", client_id, client_secret, tool_filter)
+
+
+class DocsToolset(GoogleApiToolset):
+
+  def __init__(
+      self,
+      client_id: str = None,
+      client_secret: str = None,
+      tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+  ):
+    super().__init__("docs", "v1", client_id, client_secret, tool_filter)

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_artifacts_tool.py

@@ -69,14 +69,14 @@ class LoadArtifactsTool(BaseTool):
         tool_context=tool_context,
         llm_request=llm_request,
     )
-    self._append_artifacts_to_llm_request(
+    await self._append_artifacts_to_llm_request(
         tool_context=tool_context, llm_request=llm_request
     )
 
-  def _append_artifacts_to_llm_request(
+  async def _append_artifacts_to_llm_request(
       self, *, tool_context: ToolContext, llm_request: LlmRequest
   ):
-    artifact_names = tool_context.list_artifacts()
+    artifact_names = await tool_context.list_artifacts()
     if not artifact_names:
       return
 
@@ -96,7 +96,7 @@ class LoadArtifactsTool(BaseTool):
       if function_response and function_response.name == 'load_artifacts':
         artifact_names = function_response.response['artifact_names']
         for artifact_name in artifact_names:
-          artifact = tool_context.load_artifact(artifact_name)
+          artifact = await tool_context.load_artifact(artifact_name)
           llm_request.contents.append(
               types.Content(
                   role='user',

google/adk/tools/load_memory_tool.py

@@ -17,17 +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
 
 
-def load_memory(query: str, tool_context: ToolContext) -> 'list[MemoryResult]':
+class LoadMemoryResponse(BaseModel):
+  memories: list[MemoryEntry] = Field(default_factory=list)
+
+
+async def load_memory(
+    query: str, tool_context: ToolContext
+) -> LoadMemoryResponse:
   """Loads the memory for the current user.
 
   Args:
@@ -36,12 +44,15 @@ def load_memory(query: str, tool_context: ToolContext) -> 'list[MemoryResult]':
   Returns:
     A list of memory results.
   """
-  response = 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)