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

google/adk/tools/function_parameter_parse_util.py

@@ -35,7 +35,7 @@ _py_builtin_type_to_schema_type = {
     dict: types.Type.OBJECT,
 }
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('google_adk.' + __name__)
 
 
 def _is_builtin_primitive_or_compound(
@@ -289,10 +289,17 @@ def _parse_schema_from_parameter(
       )
     _raise_if_schema_unsupported(variant, schema)
     return schema
+  if param.annotation is None:
+    # https://swagger.io/docs/specification/v3_0/data-models/data-types/#null
+    # null is not a valid type in schema, use object instead.
+    schema.type = types.Type.OBJECT
+    schema.nullable = True
+    _raise_if_schema_unsupported(variant, schema)
+    return schema
   raise ValueError(
       f'Failed to parse the parameter {param} of function {func_name} for'
       ' automatic function calling. Automatic function calling works best with'
-      ' simpler function signature schema,consider manually parse your'
+      ' simpler function signature schema, consider manually parsing your'
       f' function declaration for function {func_name}.'
   )
 

google/adk/tools/function_tool.py

@@ -33,8 +33,31 @@ class FunctionTool(BaseTool):
   """
 
   def __init__(self, func: Callable[..., Any]):
-    super().__init__(name=func.__name__, description=func.__doc__)
+    """Extract metadata from a callable object."""
+    name = ''
+    doc = ''
+    # Handle different types of callables
+    if hasattr(func, '__name__'):
+      # Regular functions, unbound methods, etc.
+      name = func.__name__
+    elif hasattr(func, '__class__'):
+      # Callable objects, bound methods, etc.
+      name = func.__class__.__name__
+
+    # Get documentation (prioritize direct __doc__ if available)
+    if hasattr(func, '__doc__') and func.__doc__:
+      doc = func.__doc__
+    elif (
+        hasattr(func, '__call__')
+        and hasattr(func.__call__, '__doc__')
+        and func.__call__.__doc__
+    ):
+      # For callable objects, try to get docstring from __call__ method
+      doc = func.__call__.__doc__
+
+    super().__init__(name=name, description=doc)
     self.func = func
+    self._ignore_params = ['tool_context', 'input_stream']
 
   @override
   def _get_declaration(self) -> Optional[types.FunctionDeclaration]:
@@ -43,7 +66,7 @@ class FunctionTool(BaseTool):
             func=self.func,
             # The model doesn't understand the function context.
             # input_stream is for streaming tool
-            ignore_params=['tool_context', 'input_stream'],
+            ignore_params=self._ignore_params,
             variant=self._api_variant,
         )
     )
@@ -76,7 +99,14 @@ class FunctionTool(BaseTool):
 You could retry calling this tool, but it is IMPORTANT for you to provide all the mandatory parameters."""
       return {'error': error_str}
 
-    if inspect.iscoroutinefunction(self.func):
+    # Functions are callable objects, but not all callable objects are functions
+    # checking coroutine function is not enough. We also need to check whether
+    # Callable's __call__ function is a coroutine funciton
+    if (
+        inspect.iscoroutinefunction(self.func)
+        or hasattr(self.func, '__call__')
+        and inspect.iscoroutinefunction(self.func.__call__)
+    ):
       return await self.func(**args_to_call) or {}
     else:
       return self.func(**args_to_call) or {}

google/adk/tools/get_user_choice_tool.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from typing import Optional
+
 from .long_running_tool import LongRunningFunctionTool
 from .tool_context import ToolContext
 

google/adk/tools/google_api_tool/__init__.py

@@ -11,77 +11,31 @@
 # 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.
-__all__ = [
-    'bigquery_tool_set',
-    'calendar_tool_set',
-    'gmail_tool_set',
-    'youtube_tool_set',
-    'slides_tool_set',
-    'sheets_tool_set',
-    'docs_tool_set',
-]
-
-# Nothing is imported here automatically
-# Each tool set will only be imported when accessed
-
-_bigquery_tool_set = None
-_calendar_tool_set = None
-_gmail_tool_set = None
-_youtube_tool_set = None
-_slides_tool_set = None
-_sheets_tool_set = None
-_docs_tool_set = None
-
-
-def __getattr__(name):
-  global _bigquery_tool_set, _calendar_tool_set, _gmail_tool_set, _youtube_tool_set, _slides_tool_set, _sheets_tool_set, _docs_tool_set
-
-  match name:
-    case 'bigquery_tool_set':
-      if _bigquery_tool_set is None:
-        from .google_api_tool_sets import bigquery_tool_set as bigquery
-
-        _bigquery_tool_set = bigquery
-      return _bigquery_tool_set
-
-    case 'calendar_tool_set':
-      if _calendar_tool_set is None:
-        from .google_api_tool_sets import calendar_tool_set as calendar
 
-        _calendar_tool_set = calendar
-      return _calendar_tool_set
+"""Auto-generated tools and toolsets for Google APIs.
 
-    case 'gmail_tool_set':
-      if _gmail_tool_set is None:
-        from .google_api_tool_sets import gmail_tool_set as gmail
+These tools and toolsets are auto-generated based on the API specifications
+provided by the Google API Discovery API.
+"""
 
-        _gmail_tool_set = gmail
-      return _gmail_tool_set
+from .google_api_tool import GoogleApiTool
+from .google_api_toolset import GoogleApiToolset
+from .google_api_toolsets import BigQueryToolset
+from .google_api_toolsets import CalendarToolset
+from .google_api_toolsets import DocsToolset
+from .google_api_toolsets import GmailToolset
+from .google_api_toolsets import SheetsToolset
+from .google_api_toolsets import SlidesToolset
+from .google_api_toolsets import YoutubeToolset
 
-    case 'youtube_tool_set':
-      if _youtube_tool_set is None:
-        from .google_api_tool_sets import youtube_tool_set as youtube
-
-        _youtube_tool_set = youtube
-      return _youtube_tool_set
-
-    case 'slides_tool_set':
-      if _slides_tool_set is None:
-        from .google_api_tool_sets import slides_tool_set as slides
-
-        _slides_tool_set = slides
-      return _slides_tool_set
-
-    case 'sheets_tool_set':
-      if _sheets_tool_set is None:
-        from .google_api_tool_sets import sheets_tool_set as sheets
-
-        _sheets_tool_set = sheets
-      return _sheets_tool_set
-
-    case 'docs_tool_set':
-      if _docs_tool_set is None:
-        from .google_api_tool_sets import docs_tool_set as docs
-
-        _docs_tool_set = docs
-      return _docs_tool_set
+__all__ = [
+    'BigQueryToolset',
+    'CalendarToolset',
+    'GmailToolset',
+    'YoutubeToolset',
+    'SlidesToolset',
+    'SheetsToolset',
+    'DocsToolset',
+    'GoogleApiToolset',
+    'GoogleApiTool',
+]

google/adk/tools/google_api_tool/google_api_tool.py

@@ -19,38 +19,44 @@ from typing import Optional
 from google.genai.types import FunctionDeclaration
 from typing_extensions import override
 
+from .. import BaseTool
 from ...auth import AuthCredential
 from ...auth import AuthCredentialTypes
 from ...auth import OAuth2Auth
-from .. import BaseTool
 from ..openapi_tool import RestApiTool
 from ..tool_context import ToolContext
 
 
 class GoogleApiTool(BaseTool):
 
-  def __init__(self, rest_api_tool: RestApiTool):
+  def __init__(
+      self,
+      rest_api_tool: RestApiTool,
+      client_id: Optional[str] = None,
+      client_secret: Optional[str] = None,
+  ):
     super().__init__(
         name=rest_api_tool.name,
         description=rest_api_tool.description,
         is_long_running=rest_api_tool.is_long_running,
     )
-    self.rest_api_tool = rest_api_tool
+    self._rest_api_tool = rest_api_tool
+    self.configure_auth(client_id, client_secret)
 
   @override
   def _get_declaration(self) -> FunctionDeclaration:
-    return self.rest_api_tool._get_declaration()
+    return self._rest_api_tool._get_declaration()
 
   @override
   async def run_async(
       self, *, args: dict[str, Any], tool_context: Optional[ToolContext]
   ) -> Dict[str, Any]:
-    return await self.rest_api_tool.run_async(
+    return await self._rest_api_tool.run_async(
         args=args, tool_context=tool_context
     )
 
   def configure_auth(self, client_id: str, client_secret: str):
-    self.rest_api_tool.auth_credential = AuthCredential(
+    self._rest_api_tool.auth_credential = AuthCredential(
         auth_type=AuthCredentialTypes.OPEN_ID_CONNECT,
         oauth2=OAuth2Auth(
             client_id=client_id,

google/adk/tools/google_api_tool/{google_api_tool_set.py → google_api_toolset.py}

@@ -17,56 +17,72 @@ from __future__ import annotations
 import inspect
 import os
 from typing import Any
-from typing import Final
 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 ..openapi_tool import RestApiTool
 from .google_api_tool import GoogleApiTool
 from .googleapi_to_openapi_converter import GoogleApiToOpenApiConverter
 
 
-class GoogleApiToolSet:
-  """Google API Tool Set."""
+class GoogleApiToolset(BaseToolset):
+  """Google API Toolset contains tools for interacting with Google APIs.
 
-  def __init__(self, tools: List[RestApiTool]):
-    self.tools: Final[List[GoogleApiTool]] = [
-        GoogleApiTool(tool) for tool in tools
-    ]
+  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 get_tools(self) -> List[GoogleApiTool]:
+  @override
+  async def get_tools(
+      self, readonly_context: Optional[ReadonlyContext] = None
+  ) -> List[GoogleApiTool]:
     """Get all tools in the toolset."""
-    return self.tools
+    tools = []
 
-  def get_tool(self, tool_name: str) -> Optional[GoogleApiTool]:
-    """Get a tool by name."""
-    matching_tool = filter(lambda t: t.name == tool_name, self.tools)
-    return next(matching_tool, None)
+    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
 
-  @staticmethod
-  def _load_tool_set_with_oidc_auth(
-      spec_file: Optional[str] = None,
-      spec_dict: Optional[dict[str, Any]] = None,
-      scopes: Optional[list[str]] = None,
-  ) -> OpenAPIToolset:
-    spec_str = None
-    if spec_file:
-      # Get the frame of the caller
-      caller_frame = inspect.stack()[1]
-      # Get the filename of the caller
-      caller_filename = caller_frame.filename
-      # Get the directory of the caller
-      caller_dir = os.path.dirname(os.path.abspath(caller_filename))
-      # Join the directory path with the filename
-      yaml_path = os.path.join(caller_dir, spec_file)
-      with open(yaml_path, 'r', encoding='utf-8') as file:
-        spec_str = file.read()
-    tool_set = OpenAPIToolset(
+  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=spec_str,
         spec_str_type='yaml',
         auth_scheme=OpenIdConnectWithConfig(
             authorization_endpoint=(
@@ -82,29 +98,15 @@ class GoogleApiToolSet:
                 'client_secret_basic',
             ],
             grant_types_supported=['authorization_code'],
-            scopes=scopes,
+            scopes=[scope],
         ),
     )
-    return tool_set
 
   def configure_auth(self, client_id: str, client_secret: str):
-    for tool in self.tools:
-      tool.configure_auth(client_id, client_secret)
+    self._client_id = client_id
+    self._client_secret = client_secret
 
-  @classmethod
-  def load_tool_set(
-      cls: Type[GoogleApiToolSet],
-      api_name: str,
-      api_version: str,
-  ) -> GoogleApiToolSet:
-    spec_dict = GoogleApiToOpenApiConverter(api_name, api_version).convert()
-    scope = list(
-        spec_dict['components']['securitySchemes']['oauth2']['flows'][
-            'authorizationCode'
-        ]['scopes'].keys()
-    )[0]
-    return cls(
-        cls._load_tool_set_with_oidc_auth(
-            spec_dict=spec_dict, scopes=[scope]
-        ).get_tools()
-    )
+  @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,108 @@
+# 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 ..base_toolset import ToolPredicate
+from .google_api_toolset import GoogleApiToolset
+
+logger = logging.getLogger("google_adk." + __name__)
+
+
+class BigQueryToolset(GoogleApiToolset):
+  """Auto-generated Bigquery toolset based on Google BigQuery API v2 spec exposed by Google API discovery API"""
+
+  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):
+  """Auto-generated Calendar toolset based on Google Calendar API v3 spec exposed by Google API discovery API"""
+
+  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):
+  """Auto-generated Gmail toolset based on Google Gmail API v1 spec exposed by Google API discovery API"""
+
+  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):
+  """Auto-generated Youtube toolset based on Youtube API v3 spec exposed by Google API discovery API"""
+
+  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):
+  """Auto-generated Slides toolset based on Google Slides API v1 spec exposed by Google API discovery API"""
+
+  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):
+  """Auto-generated Sheets toolset based on Google Sheets API v4 spec exposed by Google API discovery API"""
+
+  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):
+  """Auto-generated Docs toolset based on Google Docs API v1 spec exposed by Google API discovery API"""
+
+  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)