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

google/adk/flows/llm_flows/functions.py

@@ -153,37 +153,67 @@ async def handle_function_calls_async(
       # do not use "args" as the variable name, because it is a reserved keyword
       # in python debugger.
       function_args = function_call.args or {}
-      function_response: Optional[dict] = None
 
-      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
+      # Step 1: Check if plugin before_tool_callback overrides the function
+      # response.
+      function_response = (
+          await invocation_context.plugin_manager.run_before_tool_callback(
+              tool=tool, tool_args=function_args, tool_context=tool_context
+          )
+      )
 
-      if not function_response:
+      # Step 2: If no overrides are provided from the plugins, further run the
+      # canonical callback.
+      if function_response is None:
+        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
+
+      # Step 3: Otherwise, proceed calling the tool normally.
+      if function_response is None:
         function_response = await __call_tool_async(
             tool, args=function_args, tool_context=tool_context
         )
 
-      for callback in agent.canonical_after_tool_callbacks:
-        altered_function_response = callback(
-            tool=tool,
-            args=function_args,
-            tool_context=tool_context,
-            tool_response=function_response,
-        )
-        if inspect.isawaitable(altered_function_response):
-          altered_function_response = await altered_function_response
-        if altered_function_response is not None:
-          function_response = altered_function_response
-          break
+      # Step 4: Check if plugin after_tool_callback overrides the function
+      # response.
+      altered_function_response = (
+          await invocation_context.plugin_manager.run_after_tool_callback(
+              tool=tool,
+              tool_args=function_args,
+              tool_context=tool_context,
+              result=function_response,
+          )
+      )
+
+      # Step 5: If no overrides are provided from the plugins, further run the
+      # canonical after_tool_callbacks.
+      if altered_function_response is None:
+        for callback in agent.canonical_after_tool_callbacks:
+          altered_function_response = callback(
+              tool=tool,
+              args=function_args,
+              tool_context=tool_context,
+              tool_response=function_response,
+          )
+          if inspect.isawaitable(altered_function_response):
+            altered_function_response = await altered_function_response
+          if altered_function_response:
+            break
+
+      # Step 6: If alternative response exists from after_tool_callback, use it
+      # instead of the original function response.
+      if altered_function_response is not None:
+        function_response = altered_function_response
 
       if tool.is_long_running:
-        # Allow long running function to return None to not provide function response.
+        # Allow long running function to return None to not provide function
+        # response.
         if not function_response:
           continue
 
@@ -264,6 +294,7 @@ async def handle_function_calls_live(
       #   )
       #   if new_response:
       #     function_response = new_response
+      altered_function_response = None
       if agent.after_tool_callback:
         altered_function_response = agent.after_tool_callback(
             tool=tool,
@@ -273,8 +304,8 @@ async def handle_function_calls_live(
         )
         if inspect.isawaitable(altered_function_response):
           altered_function_response = await altered_function_response
-        if altered_function_response is not None:
-          function_response = altered_function_response
+      if altered_function_response is not None:
+        function_response = altered_function_response
 
       if tool.is_long_running:
         # Allow async function to return None to not provide function response.
@@ -480,6 +511,16 @@ def __build_response_event(
   return function_response_event
 
 
+def deep_merge_dicts(d1: dict, d2: dict) -> dict:
+  """Recursively merges d2 into d1."""
+  for key, value in d2.items():
+    if key in d1 and isinstance(d1[key], dict) and isinstance(value, dict):
+      d1[key] = deep_merge_dicts(d1[key], value)
+    else:
+      d1[key] = value
+  return d1
+
+
 def merge_parallel_function_response_events(
     function_response_events: list['Event'],
 ) -> 'Event':
@@ -498,15 +539,17 @@ def merge_parallel_function_response_events(
   base_event = function_response_events[0]
 
   # Merge actions from all events
-
-  merged_actions = EventActions()
-  merged_requested_auth_configs = {}
+  merged_actions_data = {}
   for event in function_response_events:
-    merged_requested_auth_configs.update(event.actions.requested_auth_configs)
-    merged_actions = merged_actions.model_copy(
-        update=event.actions.model_dump()
-    )
-  merged_actions.requested_auth_configs = merged_requested_auth_configs
+    if event.actions:
+      # Use `by_alias=True` because it converts the model to a dictionary while respecting field aliases, ensuring that the enum fields are correctly handled without creating a duplicate.
+      merged_actions_data = deep_merge_dicts(
+          merged_actions_data,
+          event.actions.model_dump(exclude_none=True, by_alias=True),
+      )
+
+  merged_actions = EventActions.model_validate(merged_actions_data)
+
   # Create the new merged event
   merged_event = Event(
       invocation_id=Event.new_id(),

google/adk/memory/in_memory_memory_service.py

@@ -14,6 +14,7 @@
 from __future__ import annotations
 
 import re
+import threading
 from typing import TYPE_CHECKING
 
 from typing_extensions import override
@@ -42,38 +43,43 @@ class InMemoryMemoryService(BaseMemoryService):
 
   Uses keyword matching instead of semantic search.
 
-  It is not suitable for multi-threaded production environments. Use it for
-  testing and development only.
+  This class is thread-safe, however, it should be used for testing and
+  development only.
   """
 
   def __init__(self):
+    self._lock = threading.Lock()
+
     self._session_events: dict[str, dict[str, list[Event]]] = {}
-    """Keys are app_name/user_id, session_id. Values are session event lists."""
+    """Keys are "{app_name}/{user_id}". Values are dicts of session_id to
+    session event lists.
+    """
 
   @override
   async def add_session_to_memory(self, session: Session):
     user_key = _user_key(session.app_name, session.user_id)
-    self._session_events[user_key] = self._session_events.get(
-        _user_key(session.app_name, session.user_id), {}
-    )
-    self._session_events[user_key][session.id] = [
-        event
-        for event in session.events
-        if event.content and event.content.parts
-    ]
+
+    with self._lock:
+      self._session_events[user_key] = self._session_events.get(user_key, {})
+      self._session_events[user_key][session.id] = [
+          event
+          for event in session.events
+          if event.content and event.content.parts
+      ]
 
   @override
   async def search_memory(
       self, *, app_name: str, user_id: str, query: str
   ) -> SearchMemoryResponse:
     user_key = _user_key(app_name, user_id)
-    if user_key not in self._session_events:
-      return SearchMemoryResponse()
+
+    with self._lock:
+      session_event_lists = self._session_events.get(user_key, {})
 
     words_in_query = set(query.lower().split())
     response = SearchMemoryResponse()
 
-    for session_events in self._session_events[user_key].values():
+    for session_events in session_event_lists.values():
       for event in session_events:
         if not event.content or not event.content.parts:
           continue

google/adk/models/anthropic_llm.py

@@ -16,6 +16,7 @@
 
 from __future__ import annotations
 
+import base64
 from functools import cached_property
 import logging
 import os
@@ -45,7 +46,7 @@ __all__ = ["Claude"]
 
 logger = logging.getLogger("google_adk." + __name__)
 
-MAX_TOKEN = 1024
+MAX_TOKEN = 8192
 
 
 class ClaudeRequest(BaseModel):
@@ -70,6 +71,14 @@ def to_google_genai_finish_reason(
   return "FINISH_REASON_UNSPECIFIED"
 
 
+def _is_image_part(part: types.Part) -> bool:
+  return (
+      part.inline_data
+      and part.inline_data.mime_type
+      and part.inline_data.mime_type.startswith("image")
+  )
+
+
 def part_to_message_block(
     part: types.Part,
 ) -> Union[
@@ -80,7 +89,7 @@ def part_to_message_block(
 ]:
   if part.text:
     return anthropic_types.TextBlockParam(text=part.text, type="text")
-  if part.function_call:
+  elif part.function_call:
     assert part.function_call.name
 
     return anthropic_types.ToolUseBlockParam(
@@ -89,7 +98,7 @@ def part_to_message_block(
         input=part.function_call.args,
         type="tool_use",
     )
-  if part.function_response:
+  elif part.function_response:
     content = ""
     if (
         "result" in part.function_response.response
@@ -105,15 +114,45 @@ def part_to_message_block(
         content=content,
         is_error=False,
     )
-  raise NotImplementedError("Not supported yet.")
+  elif _is_image_part(part):
+    data = base64.b64encode(part.inline_data.data).decode()
+    return anthropic_types.ImageBlockParam(
+        type="image",
+        source=dict(
+            type="base64", media_type=part.inline_data.mime_type, data=data
+        ),
+    )
+  elif part.executable_code:
+    return anthropic_types.TextBlockParam(
+        type="text",
+        text="Code:```python\n" + part.executable_code.code + "\n```",
+    )
+  elif part.code_execution_result:
+    return anthropic_types.TextBlockParam(
+        text="Execution Result:```code_output\n"
+        + part.code_execution_result.output
+        + "\n```",
+        type="text",
+    )
+
+  raise NotImplementedError(f"Not supported yet: {part}")
 
 
 def content_to_message_param(
     content: types.Content,
 ) -> anthropic_types.MessageParam:
+  message_block = []
+  for part in content.parts or []:
+    # Image data is not supported in Claude for model turns.
+    if _is_image_part(part):
+      logger.warning("Image data is not supported in Claude for model turns.")
+      continue
+
+    message_block.append(part_to_message_block(part))
+
   return {
       "role": to_claude_role(content.role),
-      "content": [part_to_message_block(part) for part in content.parts or []],
+      "content": message_block,
   }
 
 

google/adk/models/google_llm.py

@@ -27,6 +27,7 @@ from typing import Union
 
 from google.genai import Client
 from google.genai import types
+from google.genai.types import FinishReason
 from typing_extensions import override
 
 from .. import version
@@ -150,12 +151,10 @@ class Gemini(BaseLlm):
           thought_text = ''
           text = ''
         yield llm_response
-      if (
-          (text or thought_text)
-          and response
-          and response.candidates
-          and response.candidates[0].finish_reason == types.FinishReason.STOP
-      ):
+
+      # generate an aggregated content at the end regardless the
+      # response.candidates[0].finish_reason
+      if (text or thought_text) and response and response.candidates:
         parts = []
         if thought_text:
           parts.append(types.Part(text=thought_text, thought=True))
@@ -163,6 +162,12 @@ class Gemini(BaseLlm):
           parts.append(types.Part.from_text(text=text))
         yield LlmResponse(
             content=types.ModelContent(parts=parts),
+            error_code=None
+            if response.candidates[0].finish_reason == FinishReason.STOP
+            else response.candidates[0].finish_reason,
+            error_message=None
+            if response.candidates[0].finish_reason == FinishReason.STOP
+            else response.candidates[0].finish_message,
             usage_metadata=usage_metadata,
         )
 

google/adk/models/lite_llm.py

@@ -35,11 +35,14 @@ from litellm import acompletion
 from litellm import ChatCompletionAssistantMessage
 from litellm import ChatCompletionAssistantToolCall
 from litellm import ChatCompletionDeveloperMessage
+from litellm import ChatCompletionFileObject
+from litellm import ChatCompletionImageObject
 from litellm import ChatCompletionImageUrlObject
 from litellm import ChatCompletionMessageToolCall
 from litellm import ChatCompletionTextObject
 from litellm import ChatCompletionToolMessage
 from litellm import ChatCompletionUserMessage
+from litellm import ChatCompletionVideoObject
 from litellm import ChatCompletionVideoUrlObject
 from litellm import completion
 from litellm import CustomStreamWrapper
@@ -249,17 +252,31 @@ def _get_content(
       data_uri = f"data:{part.inline_data.mime_type};base64,{base64_string}"
 
       if part.inline_data.mime_type.startswith("image"):
+        # Extract format from mime type (e.g., "image/png" -> "png")
+        format_type = part.inline_data.mime_type.split("/")[-1]
         content_objects.append(
-            ChatCompletionImageUrlObject(
+            ChatCompletionImageObject(
                 type="image_url",
-                image_url=data_uri,
+                image_url=ChatCompletionImageUrlObject(
+                    url=data_uri, format=format_type
+                ),
             )
         )
       elif part.inline_data.mime_type.startswith("video"):
+        # Extract format from mime type (e.g., "video/mp4" -> "mp4")
+        format_type = part.inline_data.mime_type.split("/")[-1]
         content_objects.append(
-            ChatCompletionVideoUrlObject(
+            ChatCompletionVideoObject(
                 type="video_url",
-                video_url=data_uri,
+                video_url=ChatCompletionVideoUrlObject(
+                    url=data_uri, format=format_type
+                ),
+            )
+        )
+      elif part.inline_data.mime_type == "application/pdf":
+        content_objects.append(
+            ChatCompletionFileObject(
+                type="file", file={"file_data": data_uri, "format": "pdf"}
             )
         )
       else:

google/adk/plugins/__init__.py

@@ -0,0 +1,17 @@
+# 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 in 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 .base_plugin import BasePlugin
+
+__all__ = ['BasePlugin']