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

google/adk/flows/llm_flows/functions.py

@@ -267,36 +267,27 @@ async def handle_function_calls_live(
       # in python debugger.
       function_args = function_call.args or {}
       function_response = None
-      # # Calls the tool if before_tool_callback does not exist or returns None.
-      # if agent.before_tool_callback:
-      #   function_response = agent.before_tool_callback(
-      #       tool, function_args, tool_context
-      #   )
-      if agent.before_tool_callback:
-        function_response = agent.before_tool_callback(
+
+      # Handle before_tool_callbacks - iterate through the canonical callback
+      # list
+      for callback in agent.canonical_before_tool_callbacks:
+        function_response = callback(
             tool=tool, args=function_args, tool_context=tool_context
         )
         if inspect.isawaitable(function_response):
           function_response = await function_response
+        if function_response:
+          break
 
-      if not function_response:
+      if function_response is None:
         function_response = await _process_function_live_helper(
             tool, tool_context, function_call, function_args, invocation_context
         )
 
       # Calls after_tool_callback if it exists.
-      # if agent.after_tool_callback:
-      #   new_response = agent.after_tool_callback(
-      #       tool,
-      #       function_args,
-      #       tool_context,
-      #       function_response,
-      #   )
-      #   if new_response:
-      #     function_response = new_response
       altered_function_response = None
-      if agent.after_tool_callback:
-        altered_function_response = agent.after_tool_callback(
+      for callback in agent.canonical_after_tool_callbacks:
+        altered_function_response = callback(
             tool=tool,
             args=function_args,
             tool_context=tool_context,
@@ -304,6 +295,9 @@ async def handle_function_calls_live(
         )
         if inspect.isawaitable(altered_function_response):
           altered_function_response = await altered_function_response
+        if altered_function_response:
+          break
+
       if altered_function_response is not None:
         function_response = altered_function_response
 

google/adk/memory/in_memory_memory_service.py

@@ -76,7 +76,7 @@ class InMemoryMemoryService(BaseMemoryService):
     with self._lock:
       session_event_lists = self._session_events.get(user_key, {})
 
-    words_in_query = set(query.lower().split())
+    words_in_query = _extract_words_lower(query)
     response = SearchMemoryResponse()
 
     for session_events in session_event_lists.values():

google/adk/memory/vertex_ai_memory_bank_service.py

@@ -16,13 +16,15 @@ from __future__ import annotations
 
 import json
 import logging
+from typing import Any
+from typing import Dict
 from typing import Optional
 from typing import TYPE_CHECKING
 
+from google.genai import Client
+from google.genai import types
 from typing_extensions import override
 
-from google import genai
-
 from .base_memory_service import BaseMemoryService
 from .base_memory_service import SearchMemoryResponse
 from .memory_entry import MemoryEntry
@@ -84,7 +86,8 @@ class VertexAiMemoryBankService(BaseMemoryService):
           path=f'reasoningEngines/{self._agent_engine_id}/memories:generate',
           request_dict=request_dict,
       )
-      logger.info(f'Generate memory response: {api_response}')
+      logger.info('Generate memory response received.')
+      logger.debug('Generate memory response: %s', api_response)
     else:
       logger.info('No events to add to memory.')
 
@@ -106,7 +109,8 @@ class VertexAiMemoryBankService(BaseMemoryService):
         },
     )
     api_response = _convert_api_response(api_response)
-    logger.info(f'Search memory response: {api_response}')
+    logger.info('Search memory response received.')
+    logger.debug('Search memory response: %s', api_response)
 
     if not api_response or not api_response.get('retrievedMemories', None):
       return SearchMemoryResponse()
@@ -117,10 +121,8 @@ class VertexAiMemoryBankService(BaseMemoryService):
       memory_events.append(
           MemoryEntry(
               author='user',
-              content=genai.types.Content(
-                  parts=[
-                      genai.types.Part(text=memory.get('memory').get('fact'))
-                  ],
+              content=types.Content(
+                  parts=[types.Part(text=memory.get('memory').get('fact'))],
                   role='user',
               ),
               timestamp=memory.get('updateTime'),
@@ -137,13 +139,13 @@ class VertexAiMemoryBankService(BaseMemoryService):
     Returns:
       An API client for the given project and location.
     """
-    client = genai.Client(
+    client = Client(
         vertexai=True, project=self._project, location=self._location
     )
     return client._api_client
 
 
-def _convert_api_response(api_response):
+def _convert_api_response(api_response) -> Dict[str, Any]:
   """Converts the API response to a JSON object based on the type."""
   if hasattr(api_response, 'body'):
     return json.loads(api_response.body)

google/adk/models/anthropic_llm.py

@@ -174,7 +174,8 @@ def content_block_to_part(
 def message_to_generate_content_response(
     message: anthropic_types.Message,
 ) -> LlmResponse:
-  logger.info(
+  logger.info("Received response from Claude.")
+  logger.debug(
       "Claude response: %s",
       message.model_dump_json(indent=2, exclude_none=True),
   )

google/adk/models/base_llm_connection.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from abc import abstractmethod
 from typing import AsyncGenerator
 

google/adk/models/gemini_llm_connection.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import logging
 from typing import AsyncGenerator
+from typing import Union
 
 from google.genai import live
 from google.genai import types
@@ -25,6 +26,8 @@ from .llm_response import LlmResponse
 
 logger = logging.getLogger('google_adk.' + __name__)
 
+RealtimeInput = Union[types.Blob, types.ActivityStart, types.ActivityEnd]
+
 
 class GeminiLlmConnection(BaseLlmConnection):
   """The Gemini model connection."""
@@ -93,16 +96,24 @@ class GeminiLlmConnection(BaseLlmConnection):
           )
       )
 
-  async def send_realtime(self, blob: types.Blob):
+  async def send_realtime(self, input: RealtimeInput):
     """Sends a chunk of audio or a frame of video to the model in realtime.
 
     Args:
-      blob: The blob to send to the model.
+      input: The input to send to the model.
     """
-
-    input_blob = blob.model_dump()
-    logger.debug('Sending LLM Blob: %s', input_blob)
-    await self._gemini_session.send(input=input_blob)
+    if isinstance(input, types.Blob):
+      input_blob = input.model_dump()
+      logger.debug('Sending LLM Blob: %s', input_blob)
+      await self._gemini_session.send(input=input_blob)
+    elif isinstance(input, types.ActivityStart):
+      logger.debug('Sending LLM activity start signal')
+      await self._gemini_session.send_realtime_input(activity_start=input)
+    elif isinstance(input, types.ActivityEnd):
+      logger.debug('Sending LLM activity end signal')
+      await self._gemini_session.send_realtime_input(activity_end=input)
+    else:
+      raise ValueError('Unsupported input type: %s' % type(input))
 
   def __build_full_text_response(self, text: str):
     """Builds a full text response.

google/adk/models/google_llm.py

@@ -68,6 +68,8 @@ class Gemini(BaseLlm):
 
     return [
         r'gemini-.*',
+        # model optimizer pattern
+        r'model-optimizer-.*',
         # fine-tuned vertex endpoint pattern
         r'projects\/.+\/locations\/.+\/endpoints\/.+',
         # vertex gemini long name
@@ -86,7 +88,7 @@ class Gemini(BaseLlm):
     Yields:
       LlmResponse: The model response.
     """
-    self._preprocess_request(llm_request)
+    await self._preprocess_request(llm_request)
     self._maybe_append_user_content(llm_request)
     logger.info(
         'Sending out request, model: %s, backend: %s, stream: %s',
@@ -94,7 +96,7 @@ class Gemini(BaseLlm):
         self._api_backend,
         stream,
     )
-    logger.info(_build_request_log(llm_request))
+    logger.debug(_build_request_log(llm_request))
 
     # add tracking headers to custom headers given it will override the headers
     # set in the api client constructor
@@ -119,7 +121,7 @@ class Gemini(BaseLlm):
       # previous partial content. The only difference is bidi rely on
       # complete_turn flag to detect end while sse depends on finish_reason.
       async for response in responses:
-        logger.info(_build_response_log(response))
+        logger.debug(_build_response_log(response))
         llm_response = LlmResponse.create(response)
         usage_metadata = llm_response.usage_metadata
         if (
@@ -177,7 +179,8 @@ class Gemini(BaseLlm):
           contents=llm_request.contents,
           config=llm_request.config,
       )
-      logger.info(_build_response_log(response))
+      logger.info('Response received from the model.')
+      logger.debug(_build_response_log(response))
       yield LlmResponse.create(response)
 
   @cached_property
@@ -267,7 +270,22 @@ class Gemini(BaseLlm):
     ) as live_session:
       yield GeminiLlmConnection(live_session)
 
-  def _preprocess_request(self, llm_request: LlmRequest) -> None:
+  async def _adapt_computer_use_tool(self, llm_request: LlmRequest) -> None:
+    """Adapt the google computer use predefined functions to the adk computer use toolset."""
+
+    from ..tools.computer_use.computer_use_toolset import ComputerUseToolset
+
+    async def convert_wait_to_wait_5_seconds(wait_func):
+      async def wait_5_seconds():
+        return await wait_func(5)
+
+      return wait_5_seconds
+
+    await ComputerUseToolset.adapt_computer_use_tool(
+        'wait', convert_wait_to_wait_5_seconds, llm_request
+    )
+
+  async def _preprocess_request(self, llm_request: LlmRequest) -> None:
 
     if self._api_backend == GoogleLLMVariant.GEMINI_API:
       # Using API key from Google AI Studio to call model doesn't support labels.
@@ -282,6 +300,18 @@ class Gemini(BaseLlm):
             _remove_display_name_if_present(part.inline_data)
             _remove_display_name_if_present(part.file_data)
 
+    # Initialize config if needed
+    if llm_request.config and llm_request.config.tools:
+      # Check if computer use is configured
+      for tool in llm_request.config.tools:
+        if (
+            isinstance(tool, (types.Tool, types.ToolDict))
+            and hasattr(tool, 'computer_use')
+            and tool.computer_use
+        ):
+          llm_request.config.system_instruction = None
+          await self._adapt_computer_use_tool(llm_request)
+
 
 def _build_function_declaration_log(
     func_decl: types.FunctionDeclaration,

google/adk/models/lite_llm.py

@@ -311,7 +311,9 @@ TYPE_LABELS = {
 
 
 def _schema_to_dict(schema: types.Schema) -> dict:
-  """Recursively converts a types.Schema to a dictionary.
+  """
+  Recursively converts a types.Schema to a pure-python dict
+  with all enum values written as lower-case strings.
 
   Args:
     schema: The schema to convert.
@@ -319,29 +321,40 @@ def _schema_to_dict(schema: types.Schema) -> dict:
   Returns:
     The dictionary representation of the schema.
   """
-
+  # Dump without json encoding so we still get Enum members
   schema_dict = schema.model_dump(exclude_none=True)
+
+  # ---- normalise this level ------------------------------------------------
   if "type" in schema_dict:
-    schema_dict["type"] = schema_dict["type"].lower()
+    # schema_dict["type"] can be an Enum or a str
+    t = schema_dict["type"]
+    schema_dict["type"] = (t.value if isinstance(t, types.Type) else t).lower()
+
+  # ---- recurse into `items` -----------------------------------------------
   if "items" in schema_dict:
-    if isinstance(schema_dict["items"], dict):
-      schema_dict["items"] = _schema_to_dict(
-          types.Schema.model_validate(schema_dict["items"])
-      )
-    elif isinstance(schema_dict["items"]["type"], types.Type):
-      schema_dict["items"]["type"] = TYPE_LABELS[
-          schema_dict["items"]["type"].value
-      ]
+    schema_dict["items"] = _schema_to_dict(
+        schema.items
+        if isinstance(schema.items, types.Schema)
+        else types.Schema.model_validate(schema_dict["items"])
+    )
+
+  # ---- recurse into `properties` ------------------------------------------
   if "properties" in schema_dict:
-    properties = {}
+    new_props = {}
     for key, value in schema_dict["properties"].items():
-      if isinstance(value, types.Schema):
-        properties[key] = _schema_to_dict(value)
+      # value is a dict → rebuild a Schema object and recurse
+      if isinstance(value, dict):
+        new_props[key] = _schema_to_dict(types.Schema.model_validate(value))
+      # value is already a Schema instance
+      elif isinstance(value, types.Schema):
+        new_props[key] = _schema_to_dict(value)
+      # plain dict without nested schemas
       else:
-        properties[key] = value
-        if "type" in properties[key]:
-          properties[key]["type"] = properties[key]["type"].lower()
-    schema_dict["properties"] = properties
+        new_props[key] = value
+        if "type" in new_props[key]:
+          new_props[key]["type"] = new_props[key]["type"].lower()
+    schema_dict["properties"] = new_props
+
   return schema_dict
 
 

google/adk/sessions/database_session_service.py

@@ -160,6 +160,26 @@ class StorageSession(Base):
       return self.update_time.replace(tzinfo=timezone.utc).timestamp()
     return self.update_time.timestamp()
 
+  def to_session(
+      self,
+      state: dict[str, Any] | None = None,
+      events: list[Event] | None = None,
+  ) -> Session:
+    """Converts the storage session to a session object."""
+    if state is None:
+      state = {}
+    if events is None:
+      events = []
+
+    return Session(
+        app_name=self.app_name,
+        user_id=self.user_id,
+        id=self.id,
+        state=state,
+        events=events,
+        last_update_time=self.update_timestamp_tz,
+    )
+
 
 class StorageEvent(Base):
   """Represents an event stored in the database."""
@@ -423,14 +443,8 @@ class DatabaseSessionService(BaseSessionService):
 
       # Merge states for response
       merged_state = _merge_state(app_state, user_state, session_state)
-      session = Session(
-          app_name=str(storage_session.app_name),
-          user_id=str(storage_session.user_id),
-          id=str(storage_session.id),
-          state=merged_state,
-          last_update_time=storage_session.update_timestamp_tz,
-      )
-      return session
+      session = storage_session.to_session(state=merged_state)
+    return session
 
   @override
   async def get_session(
@@ -486,14 +500,8 @@ class DatabaseSessionService(BaseSessionService):
       merged_state = _merge_state(app_state, user_state, session_state)
 
       # Convert storage session to session
-      session = Session(
-          app_name=app_name,
-          user_id=user_id,
-          id=session_id,
-          state=merged_state,
-          last_update_time=storage_session.update_timestamp_tz,
-      )
-      session.events = [e.to_event() for e in reversed(storage_events)]
+      events = [e.to_event() for e in reversed(storage_events)]
+      session = storage_session.to_session(state=merged_state, events=events)
     return session
 
   @override
@@ -509,14 +517,7 @@ class DatabaseSessionService(BaseSessionService):
       )
       sessions = []
       for storage_session in results:
-        session = Session(
-            app_name=app_name,
-            user_id=user_id,
-            id=storage_session.id,
-            state={},
-            last_update_time=storage_session.update_timestamp_tz,
-        )
-        sessions.append(session)
+        sessions.append(storage_session.to_session())
       return ListSessionsResponse(sessions=sessions)
 
   @override

google/adk/sessions/vertex_ai_session_service.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 from __future__ import annotations
 
-import asyncio
 import json
 import logging
 import os
@@ -110,7 +109,8 @@ class VertexAiSessionService(BaseSessionService):
         request_dict=session_json_dict,
     )
     api_response = _convert_api_response(api_response)
-    logger.info(f'Create Session response {api_response}')
+    logger.info('Create session response received.')
+    logger.debug('Create session response: %s', api_response)
 
     session_id = api_response['name'].split('/')[-3]
     operation_id = api_response['name'].split('/')[-1]
@@ -351,16 +351,24 @@ class VertexAiSessionService(BaseSessionService):
 
     return match.groups()[-1]
 
+  def _api_client_http_options_override(
+      self,
+  ) -> Optional[genai.types.HttpOptions]:
+    return None
+
   def _get_api_client(self):
     """Instantiates an API client for the given project and location.
 
     It needs to be instantiated inside each request so that the event loop
     management can be properly propagated.
     """
-    client = genai.Client(
+    api_client = genai.Client(
         vertexai=True, project=self._project, location=self._location
-    )
-    return client._api_client
+    )._api_client
+
+    if new_options := self._api_client_http_options_override():
+      api_client._http_options = new_options
+    return api_client
 
 
 def _is_vertex_express_mode(

google/adk/tools/__init__.py

@@ -14,6 +14,7 @@
 
 
 from ..auth.auth_tool import AuthToolArguments
+from .agent_tool import AgentTool
 from .apihub_tool.apihub_toolset import APIHubToolset
 from .base_tool import BaseTool
 from .example_tool import ExampleTool
@@ -31,6 +32,7 @@ from .url_context_tool import url_context
 from .vertex_ai_search_tool import VertexAiSearchTool
 
 __all__ = [
+    'AgentTool',
     'APIHubToolset',
     'AuthToolArguments',
     'BaseTool',

google/adk/tools/_automatic_function_calling_util.py

@@ -20,7 +20,6 @@ import typing
 from typing import Any
 from typing import Callable
 from typing import Dict
-from typing import Literal
 from typing import Optional
 from typing import Union
 
@@ -329,7 +328,26 @@ def from_function_with_options(
     return declaration
 
   return_annotation = inspect.signature(func).return_annotation
-  if return_annotation is inspect._empty:
+
+  # Handle functions with no return annotation or that return None
+  if (
+      return_annotation is inspect._empty
+      or return_annotation is None
+      or return_annotation is type(None)
+  ):
+    # Create a response schema for None/null return
+    return_value = inspect.Parameter(
+        'return_value',
+        inspect.Parameter.POSITIONAL_OR_KEYWORD,
+        annotation=None,
+    )
+    declaration.response = (
+        _function_parameter_parse_util._parse_schema_from_parameter(
+            variant,
+            return_value,
+            func.__name__,
+        )
+    )
     return declaration
 
   return_value = inspect.Parameter(

google/adk/tools/agent_tool.py

@@ -23,15 +23,12 @@ from typing_extensions import override
 
 from . import _automatic_function_calling_util
 from ..memory.in_memory_memory_service import InMemoryMemoryService
-from ..runners import Runner
-from ..sessions.in_memory_session_service import InMemorySessionService
 from ._forwarding_artifact_service import ForwardingArtifactService
 from .base_tool import BaseTool
 from .tool_context import ToolContext
 
 if TYPE_CHECKING:
   from ..agents.base_agent import BaseAgent
-  from ..agents.llm_agent import LlmAgent
 
 
 class AgentTool(BaseTool):
@@ -61,6 +58,7 @@ class AgentTool(BaseTool):
   @override
   def _get_declaration(self) -> types.FunctionDeclaration:
     from ..agents.llm_agent import LlmAgent
+    from ..utils.variant_utils import GoogleLLMVariant
 
     if isinstance(self.agent, LlmAgent) and self.agent.input_schema:
       result = _automatic_function_calling_util.build_function_declaration(
@@ -80,6 +78,17 @@ class AgentTool(BaseTool):
           description=self.agent.description,
           name=self.name,
       )
+
+    # Set response schema for non-GEMINI_API variants
+    if self._api_variant != GoogleLLMVariant.GEMINI_API:
+      # Determine response type based on agent's output schema
+      if isinstance(self.agent, LlmAgent) and self.agent.output_schema:
+        # Agent has structured output schema - response is an object
+        result.response = types.Schema(type=types.Type.OBJECT)
+      else:
+        # Agent returns text - response is a string
+        result.response = types.Schema(type=types.Type.STRING)
+
     result.name = self.name
     return result
 
@@ -91,6 +100,8 @@ class AgentTool(BaseTool):
       tool_context: ToolContext,
   ) -> Any:
     from ..agents.llm_agent import LlmAgent
+    from ..runners import Runner
+    from ..sessions.in_memory_session_service import InMemorySessionService
 
     if self.skip_summarization:
       tool_context.actions.skip_summarization = True

google/adk/tools/base_toolset.py

@@ -20,11 +20,16 @@ from typing import List
 from typing import Optional
 from typing import Protocol
 from typing import runtime_checkable
+from typing import TYPE_CHECKING
 from typing import Union
 
 from ..agents.readonly_context import ReadonlyContext
 from .base_tool import BaseTool
 
+if TYPE_CHECKING:
+  from ..models.llm_request import LlmRequest
+  from .tool_context import ToolContext
+
 
 @runtime_checkable
 class ToolPredicate(Protocol):
@@ -96,3 +101,20 @@ class BaseToolset(ABC):
       return tool.name in self.tool_filter
 
     return False
+
+  async def process_llm_request(
+      self, *, tool_context: ToolContext, llm_request: LlmRequest
+  ) -> None:
+    """Processes the outgoing LLM request for this toolset. This method will be
+    called before each tool processes the llm request.
+
+    Use cases:
+    - Instead of let each tool process the llm request, we can let the toolset
+      process the llm request. e.g. ComputerUseToolset can add computer use
+      tool to the llm request.
+
+    Args:
+      tool_context: The context of the tool.
+      llm_request: The outgoing LLM request, mutable this method.
+    """
+    pass

google/adk/tools/bigquery/metadata_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 google.auth.credentials import Credentials
 from google.cloud import bigquery
 

google/adk/tools/bigquery/query_tool.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import functools
+import json
 import types
 from typing import Callable
 
@@ -159,7 +162,18 @@ def execute_sql(
         project=project_id,
         max_results=MAX_DOWNLOADED_QUERY_RESULT_ROWS,
     )
-    rows = [{key: val for key, val in row.items()} for row in row_iterator]
+    rows = []
+    for row in row_iterator:
+      row_values = {}
+      for key, val in row.items():
+        try:
+          # if the json serialization of the value succeeds, use it as is
+          json.dumps(val)
+        except:
+          val = str(val)
+        row_values[key] = val
+      rows.append(row_values)
+
     result = {"status": "SUCCESS", "rows": rows}
     if (
         MAX_DOWNLOADED_QUERY_RESULT_ROWS is not None

google/adk/tools/computer_use/__init__.py

@@ -0,0 +1,13 @@
+# 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.