google-adk 1.6.1__py3-none-any.whl → 1.8.0__py3-none-any.whl

google/adk/tools/google_api_tool/google_api_tool.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
 from typing import Optional
@@ -23,7 +25,9 @@ from .. import BaseTool
 from ...auth import AuthCredential
 from ...auth import AuthCredentialTypes
 from ...auth import OAuth2Auth
+from ...auth.auth_credential import ServiceAccount
 from ..openapi_tool import RestApiTool
+from ..openapi_tool.auth.auth_helpers import service_account_scheme_credential
 from ..tool_context import ToolContext
 
 
@@ -34,6 +38,7 @@ class GoogleApiTool(BaseTool):
       rest_api_tool: RestApiTool,
       client_id: Optional[str] = None,
       client_secret: Optional[str] = None,
+      service_account: Optional[ServiceAccount] = None,
   ):
     super().__init__(
         name=rest_api_tool.name,
@@ -41,7 +46,10 @@ class GoogleApiTool(BaseTool):
         is_long_running=rest_api_tool.is_long_running,
     )
     self._rest_api_tool = rest_api_tool
-    self.configure_auth(client_id, client_secret)
+    if service_account is not None:
+      self.configure_sa_auth(service_account)
+    else:
+      self.configure_auth(client_id, client_secret)
 
   @override
   def _get_declaration(self) -> FunctionDeclaration:
@@ -63,3 +71,10 @@ class GoogleApiTool(BaseTool):
             client_secret=client_secret,
         ),
     )
+
+  def configure_sa_auth(self, service_account: ServiceAccount):
+    auth_scheme, auth_credential = service_account_scheme_credential(
+        service_account
+    )
+    self._rest_api_tool.auth_scheme = auth_scheme
+    self._rest_api_tool.auth_credential = auth_credential

google/adk/tools/google_api_tool/google_api_toolset.py

@@ -14,18 +14,15 @@
 
 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 ...auth.auth_credential import ServiceAccount
 from ...tools.base_toolset import BaseToolset
 from ...tools.base_toolset import ToolPredicate
 from ..openapi_tool import OpenAPIToolset
@@ -48,11 +45,13 @@ class GoogleApiToolset(BaseToolset):
       client_id: Optional[str] = None,
       client_secret: Optional[str] = None,
       tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+      service_account: Optional[ServiceAccount] = None,
   ):
     self.api_name = api_name
     self.api_version = api_version
     self._client_id = client_id
     self._client_secret = client_secret
+    self._service_account = service_account
     self._openapi_toolset = self._load_toolset_with_oidc_auth()
     self.tool_filter = tool_filter
 
@@ -61,10 +60,10 @@ class GoogleApiToolset(BaseToolset):
       self, readonly_context: Optional[ReadonlyContext] = None
   ) -> List[GoogleApiTool]:
     """Get all tools in the toolset."""
-    tools = []
-
     return [
-        GoogleApiTool(tool, self._client_id, self._client_secret)
+        GoogleApiTool(
+            tool, self._client_id, self._client_secret, self._service_account
+        )
         for tool in await self._openapi_toolset.get_tools(readonly_context)
         if self._is_tool_selected(tool, readonly_context)
     ]
@@ -106,6 +105,9 @@ class GoogleApiToolset(BaseToolset):
     self._client_id = client_id
     self._client_secret = client_secret
 
+  def configure_sa_auth(self, service_account: ServiceAccount):
+    self._service_account = service_account
+
   @override
   async def close(self):
     if self._openapi_toolset:

google/adk/tools/google_api_tool/google_api_toolsets.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 import logging
 from typing import List
 from typing import Optional
 from typing import Union
 
+from ...auth.auth_credential import ServiceAccount
 from ..base_toolset import ToolPredicate
 from .google_api_toolset import GoogleApiToolset
 
@@ -29,11 +31,14 @@ class BigQueryToolset(GoogleApiToolset):
 
   def __init__(
       self,
-      client_id: str = None,
-      client_secret: str = None,
+      client_id: Optional[str] = None,
+      client_secret: Optional[str] = None,
       tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+      service_account: Optional[ServiceAccount] = None,
   ):
-    super().__init__("bigquery", "v2", client_id, client_secret, tool_filter)
+    super().__init__(
+        "bigquery", "v2", client_id, client_secret, tool_filter, service_account
+    )
 
 
 class CalendarToolset(GoogleApiToolset):
@@ -41,11 +46,14 @@ class CalendarToolset(GoogleApiToolset):
 
   def __init__(
       self,
-      client_id: str = None,
-      client_secret: str = None,
+      client_id: Optional[str] = None,
+      client_secret: Optional[str] = None,
       tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+      service_account: Optional[ServiceAccount] = None,
   ):
-    super().__init__("calendar", "v3", client_id, client_secret, tool_filter)
+    super().__init__(
+        "calendar", "v3", client_id, client_secret, tool_filter, service_account
+    )
 
 
 class GmailToolset(GoogleApiToolset):
@@ -53,11 +61,14 @@ class GmailToolset(GoogleApiToolset):
 
   def __init__(
       self,
-      client_id: str = None,
-      client_secret: str = None,
+      client_id: Optional[str] = None,
+      client_secret: Optional[str] = None,
       tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+      service_account: Optional[ServiceAccount] = None,
   ):
-    super().__init__("gmail", "v1", client_id, client_secret, tool_filter)
+    super().__init__(
+        "gmail", "v1", client_id, client_secret, tool_filter, service_account
+    )
 
 
 class YoutubeToolset(GoogleApiToolset):
@@ -65,11 +76,14 @@ class YoutubeToolset(GoogleApiToolset):
 
   def __init__(
       self,
-      client_id: str = None,
-      client_secret: str = None,
+      client_id: Optional[str] = None,
+      client_secret: Optional[str] = None,
       tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+      service_account: Optional[ServiceAccount] = None,
   ):
-    super().__init__("youtube", "v3", client_id, client_secret, tool_filter)
+    super().__init__(
+        "youtube", "v3", client_id, client_secret, tool_filter, service_account
+    )
 
 
 class SlidesToolset(GoogleApiToolset):
@@ -77,11 +91,14 @@ class SlidesToolset(GoogleApiToolset):
 
   def __init__(
       self,
-      client_id: str = None,
-      client_secret: str = None,
+      client_id: Optional[str] = None,
+      client_secret: Optional[str] = None,
       tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+      service_account: Optional[ServiceAccount] = None,
   ):
-    super().__init__("slides", "v1", client_id, client_secret, tool_filter)
+    super().__init__(
+        "slides", "v1", client_id, client_secret, tool_filter, service_account
+    )
 
 
 class SheetsToolset(GoogleApiToolset):
@@ -89,9 +106,10 @@ class SheetsToolset(GoogleApiToolset):
 
   def __init__(
       self,
-      client_id: str = None,
-      client_secret: str = None,
+      client_id: Optional[str] = None,
+      client_secret: Optional[str] = None,
       tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+      service_account: Optional[ServiceAccount] = None,
   ):
     super().__init__("sheets", "v4", client_id, client_secret, tool_filter)
 
@@ -101,8 +119,11 @@ class DocsToolset(GoogleApiToolset):
 
   def __init__(
       self,
-      client_id: str = None,
-      client_secret: str = None,
+      client_id: Optional[str] = None,
+      client_secret: Optional[str] = None,
       tool_filter: Optional[Union[ToolPredicate, List[str]]] = None,
+      service_account: Optional[ServiceAccount] = None,
   ):
-    super().__init__("docs", "v1", client_id, client_secret, tool_filter)
+    super().__init__(
+        "docs", "v1", client_id, client_secret, tool_filter, service_account
+    )

google/adk/tools/google_search_tool.py

@@ -19,6 +19,8 @@ from typing import TYPE_CHECKING
 from google.genai import types
 from typing_extensions import override
 
+from ..utils.model_name_utils import is_gemini_1_model
+from ..utils.model_name_utils import is_gemini_model
 from .base_tool import BaseTool
 from .tool_context import ToolContext
 
@@ -46,7 +48,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 'gemini-1' in llm_request.model:
+    if is_gemini_1_model(llm_request.model):
       if llm_request.config.tools:
         raise ValueError(
             'Google search tool can not be used with other tools in Gemini 1.x.'
@@ -54,7 +56,7 @@ class GoogleSearchTool(BaseTool):
       llm_request.config.tools.append(
           types.Tool(google_search_retrieval=types.GoogleSearchRetrieval())
       )
-    elif llm_request.model and 'gemini-' in llm_request.model:
+    elif is_gemini_model(llm_request.model):
       llm_request.config.tools.append(
           types.Tool(google_search=types.GoogleSearch())
       )

google/adk/tools/langchain_tool.py

@@ -41,14 +41,13 @@ class LangchainTool(FunctionTool):
       name: Optional override for the tool's name
       description: Optional override for the tool's description
 
-  Examples:
-      ```python
+  Examples::
+
       from langchain.tools import DuckDuckGoSearchTool
       from google.genai.tools import LangchainTool
 
       search_tool = DuckDuckGoSearchTool()
       wrapped_tool = LangchainTool(search_tool)
-      ```
   """
 
   _langchain_tool: Union[BaseTool, object]
@@ -60,15 +59,26 @@ class LangchainTool(FunctionTool):
       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")
+      raise ValueError(
+          "Tool must be a Langchain tool, have a 'run' or '_run' method."
+      )
 
     # Determine which function to use
     if isinstance(tool, StructuredTool):
       func = tool.func
-    else:
+      # For async tools, func might be None but coroutine exists
+      if func is None and hasattr(tool, 'coroutine') and tool.coroutine:
+        func = tool.coroutine
+    elif hasattr(tool, '_run') or hasattr(tool, 'run'):
       func = tool._run if hasattr(tool, '_run') else tool.run
+    else:
+      raise ValueError(
+          "This is not supported. Tool must be a Langchain tool, have a 'run'"
+          " or '_run' method. The tool is: ",
+          type(tool),
+      )
+
     super().__init__(func)
     # run_manager is a special parameter for langchain tool
     self._ignore_params.append('run_manager')

google/adk/tools/long_running_tool.py

@@ -12,7 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Callable
+from typing import Optional
+
+from google.genai import types
+from typing_extensions import override
 
 from .function_tool import FunctionTool
 
@@ -37,3 +43,18 @@ class LongRunningFunctionTool(FunctionTool):
   def __init__(self, func: Callable):
     super().__init__(func)
     self.is_long_running = True
+
+  @override
+  def _get_declaration(self) -> Optional[types.FunctionDeclaration]:
+    declaration = super()._get_declaration()
+    if declaration:
+      instruction = (
+          "\n\nNOTE: This is a long-running operation. Do not call this tool"
+          " again if it has already returned some intermediate or pending"
+          " status."
+      )
+      if declaration.description:
+        declaration.description += instruction
+      else:
+        declaration.description = instruction.lstrip()
+    return declaration

google/adk/tools/mcp_tool/mcp_toolset.py

@@ -61,28 +61,27 @@ class MCPToolset(BaseToolset):
   that can be used by an agent. It properly implements the BaseToolset
   interface for easy integration with the agent framework.
 
-  Usage:
-  ```python
-  toolset = MCPToolset(
-      connection_params=StdioServerParameters(
-          command='npx',
-          args=["-y", "@modelcontextprotocol/server-filesystem"],
-      ),
-      tool_filter=['read_file', 'list_directory']  # Optional: filter specific tools
-  )
-
-  # Use in an agent
-  agent = LlmAgent(
-      model='gemini-2.0-flash',
-      name='enterprise_assistant',
-      instruction='Help user accessing their file systems',
-      tools=[toolset],
-  )
-
-  # Cleanup is handled automatically by the agent framework
-  # But you can also manually close if needed:
-  # await toolset.close()
-  ```
+  Usage::
+
+    toolset = MCPToolset(
+        connection_params=StdioServerParameters(
+            command='npx',
+            args=["-y", "@modelcontextprotocol/server-filesystem"],
+        ),
+        tool_filter=['read_file', 'list_directory']  # Optional: filter specific tools
+    )
+
+    # Use in an agent
+    agent = LlmAgent(
+        model='gemini-2.0-flash',
+        name='enterprise_assistant',
+        instruction='Help user accessing their file systems',
+        tools=[toolset],
+    )
+
+    # Cleanup is handled automatically by the agent framework
+    # But you can also manually close if needed:
+    # await toolset.close()
   """
 
   def __init__(
@@ -103,12 +102,12 @@ class MCPToolset(BaseToolset):
 
     Args:
       connection_params: The connection parameters to the MCP server. Can be:
-        `StdioConnectionParams` for using local mcp server (e.g. using `npx` or
-        `python3`); or `SseConnectionParams` for a local/remote SSE server; or
-        `StreamableHTTPConnectionParams` for local/remote Streamable http
-        server. Note, `StdioServerParameters` is also supported for using local
-        mcp server (e.g. using `npx` or `python3` ), but it does not support
-        timeout, and we recommend to use `StdioConnectionParams` instead when
+        ``StdioConnectionParams`` for using local mcp server (e.g. using ``npx`` or
+        ``python3``); or ``SseConnectionParams`` for a local/remote SSE server; or
+        ``StreamableHTTPConnectionParams`` for local/remote Streamable http
+        server. Note, ``StdioServerParameters`` is also supported for using local
+        mcp server (e.g. using ``npx`` or ``python3`` ), but it does not support
+        timeout, and we recommend to use ``StdioConnectionParams`` instead when
         timeout is needed.
       tool_filter: Optional filter to select specific tools. Can be either: - A
         list of tool names to include - A ToolPredicate function for custom

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

@@ -111,6 +111,11 @@ class OpenApiSpecParser:
         if operation_dict is None:
           continue
 
+        # Append path-level parameters
+        operation_dict["parameters"] = operation_dict.get(
+            "parameters", []
+        ) + path_item.get("parameters", [])
+
         # If operation ID is missing, assign an operation id based on path
         # and method
         if "operationId" not in operation_dict:

google/adk/tools/openapi_tool/openapi_spec_parser/openapi_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 json
 import logging
 from typing import Any
@@ -39,8 +41,8 @@ logger = logging.getLogger("google_adk." + __name__)
 class OpenAPIToolset(BaseToolset):
   """Class for parsing OpenAPI spec into a list of RestApiTool.
 
-  Usage:
-  ```
+  Usage::
+
     # Initialize OpenAPI toolset from a spec string.
     openapi_toolset = OpenAPIToolset(spec_str=openapi_spec_str,
       spec_str_type="json")
@@ -55,7 +57,6 @@ class OpenAPIToolset(BaseToolset):
     agent = Agent(
       tools=[openapi_toolset.get_tool('tool_name')]
     )
-  ```
   """
 
   def __init__(
@@ -70,8 +71,8 @@ class OpenAPIToolset(BaseToolset):
   ):
     """Initializes the OpenAPIToolset.
 
-    Usage:
-    ```
+    Usage::
+
       # Initialize OpenAPI toolset from a spec string.
       openapi_toolset = OpenAPIToolset(spec_str=openapi_spec_str,
         spec_str_type="json")
@@ -86,7 +87,6 @@ class OpenAPIToolset(BaseToolset):
       agent = Agent(
         tools=[openapi_toolset.get_tool('tool_name')]
       )
-    ```
 
     Args:
       spec_dict: The OpenAPI spec dictionary. If provided, it will be used
@@ -96,10 +96,10 @@ class OpenAPIToolset(BaseToolset):
       spec_str_type: The type of the OpenAPI spec string. Can be "json" or
         "yaml".
       auth_scheme: The auth scheme to use for all tools. Use AuthScheme or use
-        helpers in `google.adk.tools.openapi_tool.auth.auth_helpers`
+        helpers in ``google.adk.tools.openapi_tool.auth.auth_helpers``
       auth_credential: The auth credential to use for all tools. Use
         AuthCredential or use helpers in
-        `google.adk.tools.openapi_tool.auth.auth_helpers`
+        ``google.adk.tools.openapi_tool.auth.auth_helpers``
       tool_filter: The filter used to filter the tools in the toolset. It can be
         either a tool predicate or a list of tool names of the tools to expose.
     """

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

@@ -70,13 +70,12 @@ class RestApiTool(BaseTool):
   * Generates request params and body
   * Attaches auth credentials to API call.
 
-  Example:
-  ```
+  Example::
+
     # Each API operation in the spec will be turned into its own tool
     # Name of the tool is the operationId of that operation, in snake case
     operations = OperationGenerator().parse(openapi_spec_dict)
     tool = [RestApiTool.from_parsed_operation(o) for o in operations]
-  ```
   """
 
   def __init__(
@@ -92,13 +91,12 @@ class RestApiTool(BaseTool):
     """Initializes the RestApiTool with the given parameters.
 
     To generate RestApiTool from OpenAPI Specs, use OperationGenerator.
-    Example:
-    ```
+    Example::
+
       # Each API operation in the spec will be turned into its own tool
       # Name of the tool is the operationId of that operation, in snake case
       operations = OperationGenerator().parse(openapi_spec_dict)
       tool = [RestApiTool.from_parsed_operation(o) for o in operations]
-    ```
 
     Hint: Use google.adk.tools.openapi_tool.auth.auth_helpers to construct
     auth_scheme and auth_credential.

google/adk/tools/retrieval/vertex_ai_rag_retrieval.py

@@ -24,11 +24,12 @@ from google.genai import types
 from typing_extensions import override
 from vertexai.preview import rag
 
+from ...utils.model_name_utils import is_gemini_2_model
 from ..tool_context import ToolContext
 from .base_retrieval_tool import BaseRetrievalTool
 
 if TYPE_CHECKING:
-  from ...models.llm_request import LlmRequest
+  from ...models import LlmRequest
 
 logger = logging.getLogger('google_adk.' + __name__)
 
@@ -62,7 +63,7 @@ class VertexAiRagRetrieval(BaseRetrievalTool):
       llm_request: LlmRequest,
   ) -> None:
     # Use Gemini built-in Vertex AI RAG tool for Gemini 2 models.
-    if llm_request.model and llm_request.model.startswith('gemini-2'):
+    if is_gemini_2_model(llm_request.model):
       llm_request.config = (
           types.GenerateContentConfig()
           if not llm_request.config

google/adk/tools/tool_context.py

@@ -69,16 +69,6 @@ class ToolContext(CallbackContext):
   def get_auth_response(self, auth_config: AuthConfig) -> AuthCredential:
     return AuthHandler(auth_config).get_auth_response(self.state)
 
-  async def list_artifacts(self) -> list[str]:
-    """Lists the filenames of the artifacts attached to the current session."""
-    if self._invocation_context.artifact_service is None:
-      raise ValueError('Artifact service is not initialized.')
-    return await self._invocation_context.artifact_service.list_artifact_keys(
-        app_name=self._invocation_context.app_name,
-        user_id=self._invocation_context.user_id,
-        session_id=self._invocation_context.session.id,
-    )
-
   async def search_memory(self, query: str) -> SearchMemoryResponse:
     """Searches the memory of the current user."""
     if self._invocation_context.memory_service is None:

google/adk/tools/url_context_tool.py

@@ -19,6 +19,8 @@ from typing import TYPE_CHECKING
 from google.genai import types
 from typing_extensions import override
 
+from ..utils.model_name_utils import is_gemini_1_model
+from ..utils.model_name_utils import is_gemini_2_model
 from .base_tool import BaseTool
 from .tool_context import ToolContext
 
@@ -46,9 +48,9 @@ class UrlContextTool(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 'gemini-1' in llm_request.model:
+    if is_gemini_1_model(llm_request.model):
       raise ValueError('Url context tool can not be used in Gemini 1.x.')
-    elif llm_request.model and 'gemini-2' in llm_request.model:
+    elif is_gemini_2_model(llm_request.model):
       llm_request.config.tools.append(
           types.Tool(url_context=types.UrlContext())
       )

google/adk/tools/vertex_ai_search_tool.py

@@ -20,6 +20,8 @@ from typing import TYPE_CHECKING
 from google.genai import types
 from typing_extensions import override
 
+from ..utils.model_name_utils import is_gemini_1_model
+from ..utils.model_name_utils import is_gemini_model
 from .base_tool import BaseTool
 from .tool_context import ToolContext
 
@@ -86,8 +88,8 @@ class VertexAiSearchTool(BaseTool):
       tool_context: ToolContext,
       llm_request: LlmRequest,
   ) -> None:
-    if llm_request.model and 'gemini-' in llm_request.model:
-      if 'gemini-1' in llm_request.model and llm_request.config.tools:
+    if is_gemini_model(llm_request.model):
+      if is_gemini_1_model(llm_request.model) and llm_request.config.tools:
         raise ValueError(
             'Vertex AI search tool can not be used with other tools in Gemini'
             ' 1.x.'