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

google/adk/models/base_llm.py

@@ -14,9 +14,9 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import AsyncGenerator
-from typing import TYPE_CHECKING
+from typing import AsyncGenerator, TYPE_CHECKING
 
+from google.genai import types
 from pydantic import BaseModel
 from pydantic import ConfigDict
 
@@ -32,14 +32,13 @@ class BaseLlm(BaseModel):
 
   Attributes:
     model: The name of the LLM, e.g. gemini-1.5-flash or gemini-1.5-flash-001.
-    model_config: The model config
   """
 
   model_config = ConfigDict(
       # This allows us to use arbitrary types in the model. E.g. PIL.Image.
       arbitrary_types_allowed=True,
   )
-  """The model config."""
+  """The pydantic model config."""
 
   model: str
   """The name of the LLM, e.g. gemini-1.5-flash or gemini-1.5-flash-001."""
@@ -73,6 +72,48 @@ class BaseLlm(BaseModel):
     )
     yield  # AsyncGenerator requires a yield statement in function body.
 
+  def _maybe_append_user_content(self, llm_request: LlmRequest):
+    """Appends a user content, so that model can continue to output.
+
+    Args:
+      llm_request: LlmRequest, the request to send to the Gemini model.
+    """
+    # If no content is provided, append a user content to hint model response
+    # using system instruction.
+    if not llm_request.contents:
+      llm_request.contents.append(
+          types.Content(
+              role='user',
+              parts=[
+                  types.Part(
+                      text=(
+                          'Handle the requests as specified in the System'
+                          ' Instruction.'
+                      )
+                  )
+              ],
+          )
+      )
+      return
+
+    # Insert a user content to preserve user intent and to avoid empty
+    # model response.
+    if llm_request.contents[-1].role != 'user':
+      llm_request.contents.append(
+          types.Content(
+              role='user',
+              parts=[
+                  types.Part(
+                      text=(
+                          'Continue processing previous requests as instructed.'
+                          ' Exit or provide a summary if no more outputs are'
+                          ' needed.'
+                      )
+                  )
+              ],
+          )
+      )
+
   def connect(self, llm_request: LlmRequest) -> BaseLlmConnection:
     """Creates a live connection to the LLM.
 

google/adk/models/gemini_llm_connection.py

@@ -145,7 +145,20 @@ class GeminiLlmConnection(BaseLlmConnection):
             yield self.__build_full_text_response(text)
             text = ''
           yield llm_response
-
+        if (
+            message.server_content.input_transcription
+            and message.server_content.input_transcription.text
+        ):
+            user_text = message.server_content.input_transcription.text
+            parts = [
+                types.Part.from_text(
+                    text=user_text,
+                )
+            ]
+            llm_response = LlmResponse(
+                content=types.Content(role='user', parts=parts)
+            )
+            yield llm_response
         if (
             message.server_content.output_transcription
             and message.server_content.output_transcription.text

google/adk/models/google_llm.py

@@ -210,48 +210,6 @@ class Gemini(BaseLlm):
     ) as live_session:
       yield GeminiLlmConnection(live_session)
 
-  def _maybe_append_user_content(self, llm_request: LlmRequest):
-    """Appends a user content, so that model can continue to output.
-
-    Args:
-      llm_request: LlmRequest, the request to send to the Gemini model.
-    """
-    # If no content is provided, append a user content to hint model response
-    # using system instruction.
-    if not llm_request.contents:
-      llm_request.contents.append(
-          types.Content(
-              role='user',
-              parts=[
-                  types.Part(
-                      text=(
-                          'Handle the requests as specified in the System'
-                          ' Instruction.'
-                      )
-                  )
-              ],
-          )
-      )
-      return
-
-    # Insert a user content to preserve user intent and to avoid empty
-    # model response.
-    if llm_request.contents[-1].role != 'user':
-      llm_request.contents.append(
-          types.Content(
-              role='user',
-              parts=[
-                  types.Part(
-                      text=(
-                          'Continue processing previous requests as instructed.'
-                          ' Exit or provide a summary if no more outputs are'
-                          ' needed.'
-                      )
-                  )
-              ],
-          )
-      )
-
 
 def _build_function_declaration_log(
     func_decl: types.FunctionDeclaration,

google/adk/models/lite_llm.py

@@ -172,19 +172,19 @@ def _content_to_message_param(
     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,
-                    ),
-                )
+      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
+        )
+      elif part.text or part.inline_data:
+        content_present = True
 
     final_content = message_content if content_present else None
 
@@ -453,9 +453,9 @@ def _get_completion_inputs(
   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)
+      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(
@@ -573,7 +573,6 @@ class LiteLlm(BaseLlm):
   Attributes:
     model: The name of the LiteLlm model.
     llm_client: The LLM client to use for the model.
-    model_config: The model config.
   """
 
   llm_client: LiteLLMClient = Field(default_factory=LiteLLMClient)
@@ -611,7 +610,8 @@ class LiteLlm(BaseLlm):
       LlmResponse: The model response.
     """
 
-    logger.info(_build_request_log(llm_request))
+    self._maybe_append_user_content(llm_request)
+    logger.debug(_build_request_log(llm_request))
 
     messages, tools = _get_completion_inputs(llm_request)
 

google/adk/models/llm_request.py

@@ -37,7 +37,7 @@ class LlmRequest(BaseModel):
   """
 
   model_config = ConfigDict(arbitrary_types_allowed=True)
-  """The model config."""
+  """The pydantic model config."""
 
   model: Optional[str] = None
   """The model name."""

google/adk/models/llm_response.py

@@ -41,7 +41,7 @@ class LlmResponse(BaseModel):
   """
 
   model_config = ConfigDict(extra='forbid')
-  """The model config."""
+  """The pydantic model config."""
 
   content: Optional[types.Content] = None
   """The content of the response."""

google/adk/runners.py

@@ -186,7 +186,7 @@ class Runner:
       root_agent = self.agent
 
       if new_message:
-        self._append_new_message_to_session(
+        await self._append_new_message_to_session(
             session,
             new_message,
             invocation_context,
@@ -199,7 +199,7 @@ class Runner:
           self.session_service.append_event(session=session, event=event)
         yield event
 
-  def _append_new_message_to_session(
+  async def _append_new_message_to_session(
       self,
       session: Session,
       new_message: types.Content,
@@ -225,7 +225,7 @@ class Runner:
         if part.inline_data is None:
           continue
         file_name = f'artifact_{invocation_context.invocation_id}_{i}'
-        self.artifact_service.save_artifact(
+        await self.artifact_service.save_artifact(
             app_name=self.app_name,
             user_id=session.user_id,
             session_id=session.id,
@@ -297,14 +297,14 @@ class Runner:
       self.session_service.append_event(session=session, event=event)
       yield event
 
-  def close_session(self, session: Session):
+  async def close_session(self, session: Session):
     """Closes a session and adds it to the memory service (experimental feature).
 
     Args:
         session: The session to close.
     """
     if self.memory_service:
-      self.memory_service.add_session_to_memory(session)
+      await self.memory_service.add_session_to_memory(session)
     self.session_service.close_session(session=session)
 
   def _find_agent_to_run(

google/adk/sessions/_session_util.py

@@ -0,0 +1,43 @@
+# 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.
+
+"""Utility functions for session service."""
+
+import base64
+from typing import Any, Optional
+
+from google.genai import types
+
+
+def encode_content(content: types.Content):
+  """Encodes a content object to a JSON dictionary."""
+  encoded_content = content.model_dump(exclude_none=True)
+  for p in encoded_content["parts"]:
+    if "inline_data" in p:
+      p["inline_data"]["data"] = base64.b64encode(
+          p["inline_data"]["data"]
+      ).decode("utf-8")
+  return encoded_content
+
+
+def decode_content(
+    content: Optional[dict[str, Any]],
+) -> Optional[types.Content]:
+  """Decodes a content object from a JSON dictionary."""
+  if not content:
+    return None
+  for p in content["parts"]:
+    if "inline_data" in p:
+      p["inline_data"]["data"] = base64.b64decode(p["inline_data"]["data"])
+  return types.Content.model_validate(content)

google/adk/sessions/base_session_service.py

@@ -26,6 +26,7 @@ from .state import State
 
 class GetSessionConfig(BaseModel):
   """The configuration of getting a session."""
+
   num_recent_events: Optional[int] = None
   after_timestamp: Optional[float] = None
 
@@ -35,11 +36,13 @@ class ListSessionsResponse(BaseModel):
 
   The events and states are not set within each Session object.
   """
+
   sessions: list[Session] = Field(default_factory=list)
 
 
 class ListEventsResponse(BaseModel):
   """The response of listing events in a session."""
+
   events: list[Event] = Field(default_factory=list)
   next_page_token: Optional[str] = None
 

google/adk/sessions/database_session_service.py

@@ -11,8 +11,6 @@
 # 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 base64
 import copy
 from datetime import datetime
 import json
@@ -20,13 +18,13 @@ import logging
 from typing import Any, Optional
 import uuid
 
-from google.genai import types
 from sqlalchemy import Boolean
 from sqlalchemy import delete
 from sqlalchemy import Dialect
 from sqlalchemy import ForeignKeyConstraint
 from sqlalchemy import func
 from sqlalchemy import Text
+from sqlalchemy.dialects import mysql
 from sqlalchemy.dialects import postgresql
 from sqlalchemy.engine import create_engine
 from sqlalchemy.engine import Engine
@@ -48,6 +46,7 @@ from typing_extensions import override
 from tzlocal import get_localzone
 
 from ..events.event import Event
+from . import _session_util
 from .base_session_service import BaseSessionService
 from .base_session_service import GetSessionConfig
 from .base_session_service import ListEventsResponse
@@ -58,6 +57,9 @@ from .state import State
 
 logger = logging.getLogger(__name__)
 
+DEFAULT_MAX_KEY_LENGTH = 128
+DEFAULT_MAX_VARCHAR_LENGTH = 256
+
 
 class DynamicJSON(TypeDecorator):
   """A JSON-like type that uses JSONB on PostgreSQL and TEXT with JSON
@@ -70,15 +72,16 @@ class DynamicJSON(TypeDecorator):
   def load_dialect_impl(self, dialect: Dialect):
     if dialect.name == "postgresql":
       return dialect.type_descriptor(postgresql.JSONB)
-    else:
-      return dialect.type_descriptor(Text)  # Default to Text for other dialects
+    if dialect.name == "mysql":
+      # Use LONGTEXT for MySQL to address the data too long issue
+      return dialect.type_descriptor(mysql.LONGTEXT)
+    return dialect.type_descriptor(Text)  # Default to Text for other dialects
 
   def process_bind_param(self, value, dialect: Dialect):
     if value is not None:
       if dialect.name == "postgresql":
         return value  # JSONB handles dict directly
-      else:
-        return json.dumps(value)  # Serialize to JSON string for TEXT
+      return json.dumps(value)  # Serialize to JSON string for TEXT
     return value
 
   def process_result_value(self, value, dialect: Dialect):
@@ -92,17 +95,25 @@ class DynamicJSON(TypeDecorator):
 
 class Base(DeclarativeBase):
   """Base class for database tables."""
+
   pass
 
 
 class StorageSession(Base):
   """Represents a session stored in the database."""
+
   __tablename__ = "sessions"
 
-  app_name: Mapped[str] = mapped_column(String, primary_key=True)
-  user_id: Mapped[str] = mapped_column(String, primary_key=True)
+  app_name: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  user_id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
   id: Mapped[str] = mapped_column(
-      String, primary_key=True, default=lambda: str(uuid.uuid4())
+      String(DEFAULT_MAX_KEY_LENGTH),
+      primary_key=True,
+      default=lambda: str(uuid.uuid4()),
   )
 
   state: Mapped[MutableDict[str, Any]] = mapped_column(
@@ -125,16 +136,27 @@ class StorageSession(Base):
 
 class StorageEvent(Base):
   """Represents an event stored in the database."""
+
   __tablename__ = "events"
 
-  id: Mapped[str] = mapped_column(String, primary_key=True)
-  app_name: Mapped[str] = mapped_column(String, primary_key=True)
-  user_id: Mapped[str] = mapped_column(String, primary_key=True)
-  session_id: Mapped[str] = mapped_column(String, primary_key=True)
+  id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  app_name: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  user_id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  session_id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
 
-  invocation_id: Mapped[str] = mapped_column(String)
-  author: Mapped[str] = mapped_column(String)
-  branch: Mapped[str] = mapped_column(String, nullable=True)
+  invocation_id: Mapped[str] = mapped_column(String(DEFAULT_MAX_VARCHAR_LENGTH))
+  author: Mapped[str] = mapped_column(String(DEFAULT_MAX_VARCHAR_LENGTH))
+  branch: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_VARCHAR_LENGTH), nullable=True
+  )
   timestamp: Mapped[DateTime] = mapped_column(DateTime(), default=func.now())
   content: Mapped[dict[str, Any]] = mapped_column(DynamicJSON, nullable=True)
   actions: Mapped[MutableDict[str, Any]] = mapped_column(PickleType)
@@ -147,8 +169,10 @@ class StorageEvent(Base):
   )
   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)
+  error_code: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_VARCHAR_LENGTH), nullable=True
+  )
+  error_message: Mapped[str] = mapped_column(String(1024), nullable=True)
   interrupted: Mapped[bool] = mapped_column(Boolean, nullable=True)
 
   storage_session: Mapped[StorageSession] = relationship(
@@ -182,9 +206,12 @@ class StorageEvent(Base):
 
 class StorageAppState(Base):
   """Represents an app state stored in the database."""
+
   __tablename__ = "app_states"
 
-  app_name: Mapped[str] = mapped_column(String, primary_key=True)
+  app_name: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
   state: Mapped[MutableDict[str, Any]] = mapped_column(
       MutableDict.as_mutable(DynamicJSON), default={}
   )
@@ -195,10 +222,15 @@ class StorageAppState(Base):
 
 class StorageUserState(Base):
   """Represents a user state stored in the database."""
+
   __tablename__ = "user_states"
 
-  app_name: Mapped[str] = mapped_column(String, primary_key=True)
-  user_id: Mapped[str] = mapped_column(String, primary_key=True)
+  app_name: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
+  user_id: Mapped[str] = mapped_column(
+      String(DEFAULT_MAX_KEY_LENGTH), primary_key=True
+  )
   state: Mapped[MutableDict[str, Any]] = mapped_column(
       MutableDict.as_mutable(DynamicJSON), default={}
   )
@@ -353,6 +385,7 @@ class DatabaseSessionService(BaseSessionService):
               else True
           )
           .limit(config.num_recent_events if config else None)
+          .order_by(StorageEvent.timestamp.asc())
           .all()
       )
 
@@ -383,7 +416,7 @@ class DatabaseSessionService(BaseSessionService):
               author=e.author,
               branch=e.branch,
               invocation_id=e.invocation_id,
-              content=_decode_content(e.content),
+              content=_session_util.decode_content(e.content),
               actions=e.actions,
               timestamp=e.timestamp.timestamp(),
               long_running_tool_ids=e.long_running_tool_ids,
@@ -451,9 +484,11 @@ class DatabaseSessionService(BaseSessionService):
 
       if storage_session.update_time.timestamp() > session.last_update_time:
         raise ValueError(
-            f"Session last_update_time {session.last_update_time} is later than"
-            f" the upate_time in storage {storage_session.update_time}"
-        )
+          f"Session last_update_time "
+          f"{datetime.fromtimestamp(session.last_update_time):%Y-%m-%d %H:%M:%S} "
+          f"is later than the update_time in storage "
+          f"{storage_session.update_time:%Y-%m-%d %H:%M:%S}"
+      )
 
       # Fetch states from storage
       storage_app_state = sessionFactory.get(
@@ -506,15 +541,7 @@ class DatabaseSessionService(BaseSessionService):
           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
+        storage_event.content = _session_util.encode_content(event.content)
 
       sessionFactory.add(storage_event)
 
@@ -538,6 +565,7 @@ class DatabaseSessionService(BaseSessionService):
   ) -> ListEventsResponse:
     raise NotImplementedError()
 
+
 def convert_event(event: StorageEvent) -> Event:
   """Converts a storage event to an event."""
   return Event(
@@ -574,14 +602,3 @@ 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: Optional[dict[str, Any]],
-) -> Optional[types.Content]:
-  if not content:
-    return None
-  for p in content["parts"]:
-    if "inline_data" in p:
-      p["inline_data"]["data"] = base64.b64decode(p["inline_data"]["data"][0])
-  return types.Content.model_validate(content)

google/adk/sessions/in_memory_session_service.py

@@ -95,14 +95,14 @@ class InMemorySessionService(BaseSessionService):
         copied_session.events = copied_session.events[
             -config.num_recent_events :
         ]
-      elif config.after_timestamp:
-        i = len(session.events) - 1
+      if config.after_timestamp:
+        i = len(copied_session.events) - 1
         while i >= 0:
           if copied_session.events[i].timestamp < config.after_timestamp:
             break
           i -= 1
         if i >= 0:
-          copied_session.events = copied_session.events[i:]
+          copied_session.events = copied_session.events[i + 1:]
 
     return self._merge_state(app_name, user_id, copied_session)
 

google/adk/sessions/session.py

@@ -38,6 +38,7 @@ class Session(BaseModel):
       extra='forbid',
       arbitrary_types_allowed=True,
   )
+  """The pydantic model config."""
 
   id: str
   """The unique identifier of the session."""

google/adk/sessions/vertex_ai_session_service.py

@@ -14,21 +14,23 @@
 import logging
 import re
 import time
-from typing import Any
-from typing import Optional
+from typing import Any, Optional
 
-from dateutil.parser import isoparse
+from dateutil import parser
 from google import genai
 from typing_extensions import override
 
 from ..events.event import Event
 from ..events.event_actions import EventActions
+from . import _session_util
 from .base_session_service import BaseSessionService
 from .base_session_service import GetSessionConfig
 from .base_session_service import ListEventsResponse
 from .base_session_service import ListSessionsResponse
 from .session import Session
 
+
+isoparse = parser.isoparse
 logger = logging.getLogger(__name__)
 
 
@@ -289,7 +291,7 @@ def _convert_event_to_json(event: Event):
     }
     event_json['actions'] = actions_json
   if event.content:
-    event_json['content'] = event.content.model_dump(exclude_none=True)
+    event_json['content'] = _session_util.encode_content(event.content)
   if event.error_code:
     event_json['error_code'] = event.error_code
   if event.error_message:
@@ -316,7 +318,7 @@ def _from_api_event(api_event: dict) -> Event:
       invocation_id=api_event['invocationId'],
       author=api_event['author'],
       actions=event_actions,
-      content=api_event.get('content', None),
+      content=_session_util.decode_content(api_event.get('content', None)),
       timestamp=isoparse(api_event['timestamp']).timestamp(),
       error_code=api_event.get('errorCode', None),
       error_message=api_event.get('errorMessage', None),

google/adk/tools/agent_tool.py

@@ -146,18 +146,21 @@ class AgentTool(BaseTool):
 
     if runner.artifact_service:
       # Forward all artifacts to parent session.
-      for artifact_name in runner.artifact_service.list_artifact_keys(
+      artifact_names = await runner.artifact_service.list_artifact_keys(
           app_name=session.app_name,
           user_id=session.user_id,
           session_id=session.id,
-      ):
-        if artifact := runner.artifact_service.load_artifact(
+      )
+      for artifact_name in artifact_names:
+        if artifact := await runner.artifact_service.load_artifact(
             app_name=session.app_name,
             user_id=session.user_id,
             session_id=session.id,
             filename=artifact_name,
         ):
-          tool_context.save_artifact(filename=artifact_name, artifact=artifact)
+          await tool_context.save_artifact(
+              filename=artifact_name, artifact=artifact
+          )
 
     if (
         not last_event