google-adk 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

google/adk/evaluation/evaluation_generator.py

@@ -42,10 +42,10 @@ class EvaluationGenerator:
     """Returns evaluation responses for the given dataset and agent.
 
     Args:
-      eval_dataset: The dataset that needs to be scraped for resposnes.
+      eval_dataset: The dataset that needs to be scraped for responses.
       agent_module_path: Path to the module that contains the root agent.
       repeat_num: Number of time the eval dataset should be repeated. This is
-        usually done to remove uncertainity that a single run may bring.
+        usually done to remove uncertainty that a single run may bring.
       agent_name: The name of the agent that should be evaluated. This is
         usually the sub-agent.
       initial_session: Initial session for the eval data.
@@ -253,8 +253,8 @@ class EvaluationGenerator:
       all_mock_tools: set[str],
   ):
     """Recursively apply the before_tool_callback to the root agent and all its subagents."""
-    # check if the agent has tools that defined by evalset
-    # We use function name to check if tools match
+    # Check if the agent has tools that are defined by evalset.
+    # We use function names to check if tools match
     if not isinstance(agent, Agent) and not isinstance(agent, LlmAgent):
       return
 

google/adk/evaluation/response_evaluator.py

@@ -42,7 +42,7 @@ class ResponseEvaluator:
 
     A note on evaluation_criteria:
       `response_match_score`: This metric compares the agents final natural
-        language reponse with the expected final response, stored in the
+        language response with the expected final response, stored in the
         "reference" field in test/eval files. We use Rouge metric to compare the
         two responses.
 
@@ -106,9 +106,11 @@ class ResponseEvaluator:
     eval_dataset = pd.DataFrame(flattened_queries).rename(
         columns={"query": "prompt", "expected_tool_use": "reference_trajectory"}
     )
-    eval_task = EvalTask(dataset=eval_dataset, metrics=metrics)
 
-    eval_result = eval_task.evaluate()
+    eval_result = ResponseEvaluator._perform_eval(
+        dataset=eval_dataset, metrics=metrics
+    )
+
     if print_detailed_results:
       ResponseEvaluator._print_results(eval_result)
     return eval_result.summary_metrics
@@ -129,6 +131,16 @@ class ResponseEvaluator:
       metrics.append("rouge_1")
     return metrics
 
+  @staticmethod
+  def _perform_eval(dataset, metrics):
+    """This method hides away the call to external service.
+
+    Primarily helps with unit testing.
+    """
+    eval_task = EvalTask(dataset=dataset, metrics=metrics)
+
+    return eval_task.evaluate()
+
   @staticmethod
   def _print_results(eval_result):
     print("Evaluation Summary Metrics:", eval_result.summary_metrics)

google/adk/events/event.py

@@ -70,7 +70,7 @@ class Event(LlmResponse):
   agent_2, and agent_2 is the parent of agent_3.
 
   Branch is used when multiple sub-agent shouldn't see their peer agents'
-  conversaction history.
+  conversation history.
   """
 
   # The following are computed fields.
@@ -94,7 +94,7 @@ class Event(LlmResponse):
         not self.get_function_calls()
         and not self.get_function_responses()
         and not self.partial
-        and not self.has_trailing_code_exeuction_result()
+        and not self.has_trailing_code_execution_result()
     )
 
   def get_function_calls(self) -> list[types.FunctionCall]:
@@ -115,7 +115,7 @@ class Event(LlmResponse):
           func_response.append(part.function_response)
     return func_response
 
-  def has_trailing_code_exeuction_result(
+  def has_trailing_code_execution_result(
       self,
   ) -> bool:
     """Returns whether the event has a trailing code execution result."""

google/adk/flows/llm_flows/_nl_planning.py

@@ -87,15 +87,21 @@ class _NlPlanningResponse(BaseLlmResponseProcessor):
       return
 
     # Postprocess the LLM response.
+    callback_context = CallbackContext(invocation_context)
     processed_parts = planner.process_planning_response(
-        CallbackContext(invocation_context), llm_response.content.parts
+        callback_context, llm_response.content.parts
     )
     if processed_parts:
       llm_response.content.parts = processed_parts
 
-    # Maintain async generator behavior
-    if False:  # Ensures it behaves as a generator
-      yield  # This is a no-op but maintains generator structure
+    if callback_context.state.has_delta():
+      state_update_event = Event(
+          invocation_id=invocation_context.invocation_id,
+          author=invocation_context.agent.name,
+          branch=invocation_context.branch,
+          actions=callback_context._event_actions,
+      )
+      yield state_update_event
 
 
 response_processor = _NlPlanningResponse()

google/adk/flows/llm_flows/contents.py

@@ -310,7 +310,7 @@ def _merge_function_response_events(
     function_response_events: A list of function_response events.
       NOTE: function_response_events must fulfill these requirements: 1. The
         list is in increasing order of timestamp; 2. the first event is the
-        initial function_reponse event; 3. all later events should contain at
+        initial function_response event; 3. all later events should contain at
         least one function_response part that related to the function_call
         event. (Note, 3. may not be true when aync function return some
         intermediate response, there could also be some intermediate model

google/adk/models/lite_llm.py

@@ -136,54 +136,68 @@ def _safe_json_serialize(obj) -> str:
 
 def _content_to_message_param(
     content: types.Content,
-) -> Message:
-  """Converts a types.Content to a litellm Message.
+) -> Union[Message, list[Message]]:
+  """Converts a types.Content to a litellm Message or list of Messages.
+
+  Handles multipart function responses by returning a list of
+  ChatCompletionToolMessage objects if multiple function_response parts exist.
 
   Args:
     content: The content to convert.
 
   Returns:
-    The litellm Message.
+    A litellm Message, a list of litellm Messages.
   """
 
-  if content.parts and content.parts[0].function_response:
-    return ChatCompletionToolMessage(
-        role="tool",
-        tool_call_id=content.parts[0].function_response.id,
-        content=_safe_json_serialize(
-            content.parts[0].function_response.response
-        ),
-    )
+  tool_messages = []
+  for part in content.parts:
+    if part.function_response:
+      tool_messages.append(
+          ChatCompletionToolMessage(
+              role="tool",
+              tool_call_id=part.function_response.id,
+              content=_safe_json_serialize(part.function_response.response),
+          )
+      )
+  if tool_messages:
+    return tool_messages if len(tool_messages) > 1 else tool_messages[0]
 
+  # Handle user or assistant messages
   role = _to_litellm_role(content.role)
+  message_content = _get_content(content.parts) or None
 
   if role == "user":
-    return ChatCompletionUserMessage(
-        role="user", content=_get_content(content.parts)
-    )
-  else:
-
-    tool_calls = [
-        ChatCompletionMessageToolCall(
-            type="function",
-            id=part.function_call.id,
-            function=Function(
-                name=part.function_call.name,
-                arguments=part.function_call.args,
-            ),
-        )
-        for part in content.parts
-        if part.function_call
-    ]
+    return ChatCompletionUserMessage(role="user", content=message_content)
+  else:  # assistant/model
+    tool_calls = []
+    content_present = False
+    for part in content.parts:
+        if part.function_call:
+            tool_calls.append(
+                ChatCompletionMessageToolCall(
+                    type="function",
+                    id=part.function_call.id,
+                    function=Function(
+                        name=part.function_call.name,
+                        arguments=part.function_call.args,
+                    ),
+                )
+            )
+        elif part.text or part.inline_data:
+            content_present = True
+
+    final_content = message_content if content_present else None
 
     return ChatCompletionAssistantMessage(
         role=role,
-        content=_get_content(content.parts),
+        content=final_content,
         tool_calls=tool_calls or None,
     )
 
 
-def _get_content(parts: Iterable[types.Part]) -> OpenAIMessageContent | str:
+def _get_content(
+    parts: Iterable[types.Part],
+) -> Union[OpenAIMessageContent, str]:
   """Converts a list of parts to litellm content.
 
   Args:
@@ -435,10 +449,13 @@ def _get_completion_inputs(
   Returns:
     The litellm inputs (message list and tool dictionary).
   """
-  messages = [
-      _content_to_message_param(content)
-      for content in llm_request.contents or []
-  ]
+  messages = []
+  for content in llm_request.contents or []:
+    message_param_or_list = _content_to_message_param(content)
+    if isinstance(message_param_or_list, list):
+        messages.extend(message_param_or_list)
+    elif message_param_or_list: # Ensure it's not None before appending
+        messages.append(message_param_or_list)
 
   if llm_request.config.system_instruction:
     messages.insert(

google/adk/planners/plan_re_act_planner.py

@@ -31,9 +31,9 @@ FINAL_ANSWER_TAG = '/*FINAL_ANSWER*/'
 
 
 class PlanReActPlanner(BasePlanner):
-  """Plan-Re-Act planner that constraints the LLM response to generate a plan before any action/observation.
+  """Plan-Re-Act planner that constrains the LLM response to generate a plan before any action/observation.
 
-  Note: this planner does not require the model to support buil-in thinking
+  Note: this planner does not require the model to support built-in thinking
   features or setting the thinking config.
   """
 

google/adk/runners.py

@@ -108,7 +108,7 @@ class Runner:
     """Runs the agent.
 
     NOTE: This sync interface is only for local testing and convenience purpose.
-    Consider to use `run_async` for production usage.
+    Consider using `run_async` for production usage.
 
     Args:
       user_id: The user ID of the session.

google/adk/sessions/database_session_service.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import base64
 import copy
 from datetime import datetime
 import json
@@ -20,15 +21,16 @@ from typing import Any
 from typing import Optional
 import uuid
 
+from sqlalchemy import Boolean
 from sqlalchemy import delete
 from sqlalchemy import Dialect
 from sqlalchemy import ForeignKeyConstraint
 from sqlalchemy import func
-from sqlalchemy import select
 from sqlalchemy import Text
 from sqlalchemy.dialects import postgresql
 from sqlalchemy.engine import create_engine
 from sqlalchemy.engine import Engine
+from sqlalchemy.exc import ArgumentError
 from sqlalchemy.ext.mutable import MutableDict
 from sqlalchemy.inspection import inspect
 from sqlalchemy.orm import DeclarativeBase
@@ -53,6 +55,7 @@ from .base_session_service import ListSessionsResponse
 from .session import Session
 from .state import State
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -102,7 +105,7 @@ class StorageSession(Base):
       String, primary_key=True, default=lambda: str(uuid.uuid4())
   )
 
-  state: Mapped[dict] = mapped_column(
+  state: Mapped[MutableDict[str, Any]] = mapped_column(
       MutableDict.as_mutable(DynamicJSON), default={}
   )
 
@@ -133,8 +136,20 @@ class StorageEvent(Base):
   author: Mapped[str] = mapped_column(String)
   branch: Mapped[str] = mapped_column(String, nullable=True)
   timestamp: Mapped[DateTime] = mapped_column(DateTime(), default=func.now())
-  content: Mapped[dict] = mapped_column(DynamicJSON)
-  actions: Mapped[dict] = mapped_column(PickleType)
+  content: Mapped[dict[str, Any]] = mapped_column(DynamicJSON)
+  actions: Mapped[MutableDict[str, Any]] = mapped_column(PickleType)
+
+  long_running_tool_ids_json: Mapped[Optional[str]] = mapped_column(
+      Text, nullable=True
+  )
+  grounding_metadata: Mapped[dict[str, Any]] = mapped_column(
+      DynamicJSON, nullable=True
+  )
+  partial: Mapped[bool] = mapped_column(Boolean, nullable=True)
+  turn_complete: Mapped[bool] = mapped_column(Boolean, nullable=True)
+  error_code: Mapped[str] = mapped_column(String, nullable=True)
+  error_message: Mapped[str] = mapped_column(String, nullable=True)
+  interrupted: Mapped[bool] = mapped_column(Boolean, nullable=True)
 
   storage_session: Mapped[StorageSession] = relationship(
       "StorageSession",
@@ -149,13 +164,28 @@ class StorageEvent(Base):
       ),
   )
 
+  @property
+  def long_running_tool_ids(self) -> set[str]:
+    return (
+        set(json.loads(self.long_running_tool_ids_json))
+        if self.long_running_tool_ids_json
+        else set()
+    )
+
+  @long_running_tool_ids.setter
+  def long_running_tool_ids(self, value: set[str]):
+    if value is None:
+      self.long_running_tool_ids_json = None
+    else:
+      self.long_running_tool_ids_json = json.dumps(list(value))
+
 
 class StorageAppState(Base):
   """Represents an app state stored in the database."""
   __tablename__ = "app_states"
 
   app_name: Mapped[str] = mapped_column(String, primary_key=True)
-  state: Mapped[dict] = mapped_column(
+  state: Mapped[MutableDict[str, Any]] = mapped_column(
       MutableDict.as_mutable(DynamicJSON), default={}
   )
   update_time: Mapped[DateTime] = mapped_column(
@@ -169,7 +199,7 @@ class StorageUserState(Base):
 
   app_name: Mapped[str] = mapped_column(String, primary_key=True)
   user_id: Mapped[str] = mapped_column(String, primary_key=True)
-  state: Mapped[dict] = mapped_column(
+  state: Mapped[MutableDict[str, Any]] = mapped_column(
       MutableDict.as_mutable(DynamicJSON), default={}
   )
   update_time: Mapped[DateTime] = mapped_column(
@@ -189,13 +219,20 @@ class DatabaseSessionService(BaseSessionService):
     # 2. Create all tables based on schema
     # 3. Initialize all properies
 
-    supported_dialects = ["postgresql", "mysql", "sqlite"]
-    dialect = db_url.split("://")[0]
-
-    if dialect in supported_dialects:
+    try:
       db_engine = create_engine(db_url)
-    else:
-      raise ValueError(f"Unsupported database URL: {db_url}")
+    except Exception as e:
+      if isinstance(e, ArgumentError):
+        raise ValueError(
+            f"Invalid database URL format or argument '{db_url}'."
+        ) from e
+      if isinstance(e, ImportError):
+        raise ValueError(
+            f"Database related module not found for URL '{db_url}'."
+        ) from e
+      raise ValueError(
+          f"Failed to create database engine for URL '{db_url}'"
+      ) from e
 
     # Get the local timezone
     local_timezone = get_localzone()
@@ -287,7 +324,6 @@ class DatabaseSessionService(BaseSessionService):
           last_update_time=storage_session.update_time.timestamp(),
       )
       return session
-    return None
 
   @override
   def get_session(
@@ -301,7 +337,6 @@ class DatabaseSessionService(BaseSessionService):
     # 1. Get the storage session entry from session table
     # 2. Get all the events based on session id and filtering config
     # 3. Convert and return the session
-    session: Session = None
     with self.DatabaseSessionFactory() as sessionFactory:
       storage_session = sessionFactory.get(
           StorageSession, (app_name, user_id, session_id)
@@ -348,13 +383,19 @@ class DatabaseSessionService(BaseSessionService):
               author=e.author,
               branch=e.branch,
               invocation_id=e.invocation_id,
-              content=e.content,
+              content=_decode_content(e.content),
               actions=e.actions,
               timestamp=e.timestamp.timestamp(),
+              long_running_tool_ids=e.long_running_tool_ids,
+              grounding_metadata=e.grounding_metadata,
+              partial=e.partial,
+              turn_complete=e.turn_complete,
+              error_code=e.error_code,
+              error_message=e.error_message,
+              interrupted=e.interrupted,
           )
           for e in storage_events
       ]
-
     return session
 
   @override
@@ -379,7 +420,6 @@ class DatabaseSessionService(BaseSessionService):
         )
         sessions.append(session)
       return ListSessionsResponse(sessions=sessions)
-    raise ValueError("Failed to retrieve sessions.")
 
   @override
   def delete_session(
@@ -398,7 +438,7 @@ class DatabaseSessionService(BaseSessionService):
   def append_event(self, session: Session, event: Event) -> Event:
     logger.info(f"Append event: {event} to session {session.id}")
 
-    if event.partial and not event.content:
+    if event.partial:
       return event
 
     # 1. Check if timestamp is stale
@@ -447,19 +487,34 @@ class DatabaseSessionService(BaseSessionService):
       storage_user_state.state = user_state
       storage_session.state = session_state
 
-      encoded_content = event.content.model_dump(exclude_none=True)
       storage_event = StorageEvent(
           id=event.id,
           invocation_id=event.invocation_id,
           author=event.author,
           branch=event.branch,
-          content=encoded_content,
           actions=event.actions,
           session_id=session.id,
           app_name=session.app_name,
           user_id=session.user_id,
           timestamp=datetime.fromtimestamp(event.timestamp),
+          long_running_tool_ids=event.long_running_tool_ids,
+          grounding_metadata=event.grounding_metadata,
+          partial=event.partial,
+          turn_complete=event.turn_complete,
+          error_code=event.error_code,
+          error_message=event.error_message,
+          interrupted=event.interrupted,
       )
+      if event.content:
+        encoded_content = event.content.model_dump(exclude_none=True)
+        # Workaround for multimodal Content throwing JSON not serializable
+        # error with SQLAlchemy.
+        for p in encoded_content["parts"]:
+          if "inline_data" in p:
+            p["inline_data"]["data"] = (
+                base64.b64encode(p["inline_data"]["data"]).decode("utf-8"),
+            )
+        storage_event.content = encoded_content
 
       sessionFactory.add(storage_event)
 
@@ -481,8 +536,7 @@ class DatabaseSessionService(BaseSessionService):
       user_id: str,
       session_id: str,
   ) -> ListEventsResponse:
-    pass
-
+    raise NotImplementedError()
 
 def convert_event(event: StorageEvent) -> Event:
   """Converts a storage event to an event."""
@@ -497,7 +551,7 @@ def convert_event(event: StorageEvent) -> Event:
   )
 
 
-def _extract_state_delta(state: dict):
+def _extract_state_delta(state: dict[str, Any]):
   app_state_delta = {}
   user_state_delta = {}
   session_state_delta = {}
@@ -520,3 +574,10 @@ def _merge_state(app_state, user_state, session_state):
   for key in user_state.keys():
     merged_state[State.USER_PREFIX + key] = user_state[key]
   return merged_state
+
+
+def _decode_content(content: dict[str, Any]) -> dict[str, Any]:
+  for p in content["parts"]:
+    if "inline_data" in p:
+      p["inline_data"]["data"] = base64.b64decode(p["inline_data"]["data"][0])
+  return content

google/adk/sessions/state.py

@@ -49,7 +49,7 @@ class State:
     return key in self._value or key in self._delta
 
   def has_delta(self) -> bool:
-    """Whether the state has pending detla."""
+    """Whether the state has pending delta."""
     return bool(self._delta)
 
   def get(self, key: str, default: Any = None) -> Any:

google/adk/telemetry.py

@@ -16,8 +16,8 @@
 #
 #    We expect that the underlying GenAI SDK will provide a certain
 #    level of tracing and logging telemetry aligned with Open Telemetry
-#    Semantic Conventions (such as logging prompts, respones, request
-#    properties, etc.) and so the information that is recorded by the
+#    Semantic Conventions (such as logging prompts, responses,
+#    request properties, etc.) and so the information that is recorded by the
 #    Agent Development Kit should be focused on the higher-level
 #    constructs of the framework that are not observable by the SDK.
 

google/adk/tools/application_integration_tool/clients/integration_client.py

@@ -196,11 +196,12 @@ class IntegrationClient:
       action_details = connections_client.get_action_schema(action)
       input_schema = action_details["inputSchema"]
       output_schema = action_details["outputSchema"]
-      action_display_name = action_details["displayName"]
+      # Remove spaces from the display name to generate valid spec
+      action_display_name = action_details["displayName"].replace(" ", "")
       operation = "EXECUTE_ACTION"
       if action == "ExecuteCustomQuery":
         connector_spec["components"]["schemas"][
-            f"{action}_Request"
+            f"{action_display_name}_Request"
         ] = connections_client.execute_custom_query_request()
         operation = "EXECUTE_QUERY"
       else:

google/adk/tools/base_tool.py

@@ -73,7 +73,7 @@ class BaseTool(ABC):
 
     Args:
       args: The LLM-filled arguments.
-      ctx: The context of the tool.
+      tool_context: The context of the tool.
 
     Returns:
       The result of running the tool.

google/adk/tools/function_parameter_parse_util.py

@@ -53,7 +53,7 @@ def _raise_for_any_of_if_mldev(schema: types.Schema):
 
 def _update_for_default_if_mldev(schema: types.Schema):
   if schema.default is not None:
-    # TODO(kech): Remove this walkaround once mldev supports default value.
+    # TODO(kech): Remove this workaround once mldev supports default value.
     schema.default = None
     logger.warning(
         'Default value is not supported in function declaration schema for'
@@ -291,7 +291,7 @@ def _parse_schema_from_parameter(
     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'
+      ' automatic function calling. Automatic function calling works best with'
       ' simpler function signature schema,consider manually parse your'
       f' function declaration for function {func_name}.'
   )

google/adk/tools/google_api_tool/__init__.py

@@ -11,4 +11,77 @@
 # 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 .google_api_tool_sets import calendar_tool_set
+__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
+
+    case 'gmail_tool_set':
+      if _gmail_tool_set is None:
+        from .google_api_tool_sets import gmail_tool_set as gmail
+
+        _gmail_tool_set = gmail
+      return _gmail_tool_set
+
+    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