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

google/adk/sessions/in_memory_session_service.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import copy
+import logging
 import time
 from typing import Any
 from typing import Optional
@@ -23,17 +24,19 @@ from typing_extensions import override
 from ..events.event import Event
 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
 from .state import State
 
+logger = logging.getLogger('google_adk.' + __name__)
+
 
 class InMemorySessionService(BaseSessionService):
   """An in-memory implementation of the session service."""
 
   def __init__(self):
-    # A map from app name to a map from user ID to a map from session ID to session.
+    # A map from app name to a map from user ID to a map from session ID to
+    # session.
     self.sessions: dict[str, dict[str, dict[str, Session]]] = {}
     # A map from app name to a map from user ID to a map from key to the value.
     self.user_state: dict[str, dict[str, dict[str, Any]]] = {}
@@ -41,7 +44,38 @@ class InMemorySessionService(BaseSessionService):
     self.app_state: dict[str, dict[str, Any]] = {}
 
   @override
-  def create_session(
+  async def create_session(
+      self,
+      *,
+      app_name: str,
+      user_id: str,
+      state: Optional[dict[str, Any]] = None,
+      session_id: Optional[str] = None,
+  ) -> Session:
+    return self._create_session_impl(
+        app_name=app_name,
+        user_id=user_id,
+        state=state,
+        session_id=session_id,
+    )
+
+  def create_session_sync(
+      self,
+      *,
+      app_name: str,
+      user_id: str,
+      state: Optional[dict[str, Any]] = None,
+      session_id: Optional[str] = None,
+  ) -> Session:
+    logger.warning('Deprecated. Please migrate to the async method.')
+    return self._create_session_impl(
+        app_name=app_name,
+        user_id=user_id,
+        state=state,
+        session_id=session_id,
+    )
+
+  def _create_session_impl(
       self,
       *,
       app_name: str,
@@ -72,14 +106,45 @@ class InMemorySessionService(BaseSessionService):
     return self._merge_state(app_name, user_id, copied_session)
 
   @override
-  def get_session(
+  async def get_session(
       self,
       *,
       app_name: str,
       user_id: str,
       session_id: str,
       config: Optional[GetSessionConfig] = None,
-  ) -> Session:
+  ) -> Optional[Session]:
+    return self._get_session_impl(
+        app_name=app_name,
+        user_id=user_id,
+        session_id=session_id,
+        config=config,
+    )
+
+  def get_session_sync(
+      self,
+      *,
+      app_name: str,
+      user_id: str,
+      session_id: str,
+      config: Optional[GetSessionConfig] = None,
+  ) -> Optional[Session]:
+    logger.warning('Deprecated. Please migrate to the async method.')
+    return self._get_session_impl(
+        app_name=app_name,
+        user_id=user_id,
+        session_id=session_id,
+        config=config,
+    )
+
+  def _get_session_impl(
+      self,
+      *,
+      app_name: str,
+      user_id: str,
+      session_id: str,
+      config: Optional[GetSessionConfig] = None,
+  ) -> Optional[Session]:
     if app_name not in self.sessions:
       return None
     if user_id not in self.sessions[app_name]:
@@ -102,11 +167,13 @@ class InMemorySessionService(BaseSessionService):
             break
           i -= 1
         if i >= 0:
-          copied_session.events = copied_session.events[i + 1:]
+          copied_session.events = copied_session.events[i + 1 :]
 
     return self._merge_state(app_name, user_id, copied_session)
 
-  def _merge_state(self, app_name: str, user_id: str, copied_session: Session):
+  def _merge_state(
+      self, app_name: str, user_id: str, copied_session: Session
+  ) -> Session:
     # Merge app state
     if app_name in self.app_state:
       for key in self.app_state[app_name].keys():
@@ -128,7 +195,18 @@ class InMemorySessionService(BaseSessionService):
     return copied_session
 
   @override
-  def list_sessions(
+  async def list_sessions(
+      self, *, app_name: str, user_id: str
+  ) -> ListSessionsResponse:
+    return self._list_sessions_impl(app_name=app_name, user_id=user_id)
+
+  def list_sessions_sync(
+      self, *, app_name: str, user_id: str
+  ) -> ListSessionsResponse:
+    logger.warning('Deprecated. Please migrate to the async method.')
+    return self._list_sessions_impl(app_name=app_name, user_id=user_id)
+
+  def _list_sessions_impl(
       self, *, app_name: str, user_id: str
   ) -> ListSessionsResponse:
     empty_response = ListSessionsResponse()
@@ -145,12 +223,26 @@ class InMemorySessionService(BaseSessionService):
       sessions_without_events.append(copied_session)
     return ListSessionsResponse(sessions=sessions_without_events)
 
-  @override
-  def delete_session(
+  async def delete_session(
+      self, *, app_name: str, user_id: str, session_id: str
+  ) -> None:
+    self._delete_session_impl(
+        app_name=app_name, user_id=user_id, session_id=session_id
+    )
+
+  def delete_session_sync(
+      self, *, app_name: str, user_id: str, session_id: str
+  ) -> None:
+    logger.warning('Deprecated. Please migrate to the async method.')
+    self._delete_session_impl(
+        app_name=app_name, user_id=user_id, session_id=session_id
+    )
+
+  def _delete_session_impl(
       self, *, app_name: str, user_id: str, session_id: str
   ) -> None:
     if (
-        self.get_session(
+        self._get_session_impl(
             app_name=app_name, user_id=user_id, session_id=session_id
         )
         is None
@@ -160,9 +252,9 @@ class InMemorySessionService(BaseSessionService):
     self.sessions[app_name][user_id].pop(session_id)
 
   @override
-  def append_event(self, session: Session, event: Event) -> Event:
+  async def append_event(self, session: Session, event: Event) -> Event:
     # Update the in-memory session.
-    super().append_event(session=session, event=event)
+    await super().append_event(session=session, event=event)
     session.last_update_time = event.timestamp
 
     # Update the storage session
@@ -189,18 +281,8 @@ class InMemorySessionService(BaseSessionService):
           ] = event.actions.state_delta[key]
 
     storage_session = self.sessions[app_name][user_id].get(session_id)
-    super().append_event(session=storage_session, event=event)
+    await super().append_event(session=storage_session, event=event)
 
     storage_session.last_update_time = event.timestamp
 
     return event
-
-  @override
-  def list_events(
-      self,
-      *,
-      app_name: str,
-      user_id: str,
-      session_id: str,
-  ) -> ListEventsResponse:
-    raise NotImplementedError()

google/adk/sessions/session.py

@@ -14,6 +14,7 @@
 
 from typing import Any
 
+from pydantic import alias_generators
 from pydantic import BaseModel
 from pydantic import ConfigDict
 from pydantic import Field
@@ -37,6 +38,8 @@ class Session(BaseModel):
   model_config = ConfigDict(
       extra='forbid',
       arbitrary_types_allowed=True,
+      alias_generator=alias_generators.to_camel,
+      populate_by_name=True,
   )
   """The pydantic model config."""
 

google/adk/sessions/vertex_ai_session_service.py

@@ -11,27 +11,27 @@
 # 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 asyncio
 import logging
 import re
-import time
-from typing import Any, Optional
+from typing import Any
+from typing import Optional
 
 from dateutil import parser
-from google import genai
 from typing_extensions import override
 
+from google import genai
+
+from . import _session_util
 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__)
+logger = logging.getLogger('google_adk.' + __name__)
 
 
 class VertexAiSessionService(BaseSessionService):
@@ -49,7 +49,7 @@ class VertexAiSessionService(BaseSessionService):
     self.api_client = client._api_client
 
   @override
-  def create_session(
+  async def create_session(
       self,
       *,
       app_name: str,
@@ -57,13 +57,20 @@ class VertexAiSessionService(BaseSessionService):
       state: Optional[dict[str, Any]] = None,
       session_id: Optional[str] = None,
   ) -> Session:
+    if session_id:
+      raise ValueError(
+          'User-provided Session id is not supported for'
+          ' VertexAISessionService.'
+      )
+
     reasoning_engine_id = _parse_reasoning_engine_id(app_name)
 
     session_json_dict = {'user_id': user_id}
     if state:
       session_json_dict['session_state'] = state
 
-    api_response = self.api_client.request(
+    api_client = _get_api_client(self.project, self.location)
+    api_response = await api_client.async_request(
         http_method='POST',
         path=f'reasoningEngines/{reasoning_engine_id}/sessions',
         request_dict=session_json_dict,
@@ -75,7 +82,7 @@ class VertexAiSessionService(BaseSessionService):
 
     max_retry_attempt = 5
     while max_retry_attempt >= 0:
-      lro_response = self.api_client.request(
+      lro_response = await api_client.async_request(
           http_method='GET',
           path=f'operations/{operation_id}',
           request_dict={},
@@ -84,11 +91,11 @@ class VertexAiSessionService(BaseSessionService):
       if lro_response.get('done', None):
         break
 
-      time.sleep(1)
+      await asyncio.sleep(1)
       max_retry_attempt -= 1
 
     # Get session resource
-    get_session_api_response = self.api_client.request(
+    get_session_api_response = await api_client.async_request(
         http_method='GET',
         path=f'reasoningEngines/{reasoning_engine_id}/sessions/{session_id}',
         request_dict={},
@@ -107,18 +114,19 @@ class VertexAiSessionService(BaseSessionService):
     return session
 
   @override
-  def get_session(
+  async def get_session(
       self,
       *,
       app_name: str,
       user_id: str,
       session_id: str,
       config: Optional[GetSessionConfig] = None,
-  ) -> Session:
+  ) -> Optional[Session]:
     reasoning_engine_id = _parse_reasoning_engine_id(app_name)
 
     # Get session resource
-    get_session_api_response = self.api_client.request(
+    api_client = _get_api_client(self.project, self.location)
+    get_session_api_response = await api_client.async_request(
         http_method='GET',
         path=f'reasoningEngines/{reasoning_engine_id}/sessions/{session_id}',
         request_dict={},
@@ -136,7 +144,7 @@ class VertexAiSessionService(BaseSessionService):
         last_update_time=update_timestamp,
     )
 
-    list_events_api_response = self.api_client.request(
+    list_events_api_response = await api_client.async_request(
         http_method='GET',
         path=f'reasoningEngines/{reasoning_engine_id}/sessions/{session_id}/events',
         request_dict={},
@@ -170,12 +178,13 @@ class VertexAiSessionService(BaseSessionService):
     return session
 
   @override
-  def list_sessions(
+  async def list_sessions(
       self, *, app_name: str, user_id: str
   ) -> ListSessionsResponse:
     reasoning_engine_id = _parse_reasoning_engine_id(app_name)
 
-    api_response = self.api_client.request(
+    api_client = _get_api_client(self.project, self.location)
+    api_response = await api_client.async_request(
         http_method='GET',
         path=f'reasoningEngines/{reasoning_engine_id}/sessions?filter=user_id={user_id}',
         request_dict={},
@@ -197,58 +206,42 @@ class VertexAiSessionService(BaseSessionService):
       sessions.append(session)
     return ListSessionsResponse(sessions=sessions)
 
-  def delete_session(
+  async def delete_session(
       self, *, app_name: str, user_id: str, session_id: str
   ) -> None:
     reasoning_engine_id = _parse_reasoning_engine_id(app_name)
-    self.api_client.request(
+    api_client = _get_api_client(self.project, self.location)
+    await api_client.async_request(
         http_method='DELETE',
         path=f'reasoningEngines/{reasoning_engine_id}/sessions/{session_id}',
         request_dict={},
     )
 
   @override
-  def list_events(
-      self,
-      *,
-      app_name: str,
-      user_id: str,
-      session_id: str,
-  ) -> ListEventsResponse:
-    reasoning_engine_id = _parse_reasoning_engine_id(app_name)
-    api_response = self.api_client.request(
-        http_method='GET',
-        path=f'reasoningEngines/{reasoning_engine_id}/sessions/{session_id}/events',
-        request_dict={},
-    )
-
-    logger.info(f'List events response {api_response}')
-
-    # Handles empty response case
-    if api_response.get('httpHeaders', None):
-      return ListEventsResponse()
-
-    session_events = api_response['sessionEvents']
-
-    return ListEventsResponse(
-        events=[_from_api_event(event) for event in session_events]
-    )
-
-  @override
-  def append_event(self, session: Session, event: Event) -> Event:
+  async def append_event(self, session: Session, event: Event) -> Event:
     # Update the in-memory session.
-    super().append_event(session=session, event=event)
+    await super().append_event(session=session, event=event)
 
     reasoning_engine_id = _parse_reasoning_engine_id(session.app_name)
-    self.api_client.request(
+    api_client = _get_api_client(self.project, self.location)
+    await api_client.async_request(
         http_method='POST',
         path=f'reasoningEngines/{reasoning_engine_id}/sessions/{session.id}:appendEvent',
         request_dict=_convert_event_to_json(event),
     )
-
     return event
 
 
+def _get_api_client(project: str, location: str):
+  """Instantiates an API client for the given project and location.
+
+  It needs to be instantiated inside each request so that the event loop
+  management.
+  """
+  client = genai.Client(vertexai=True, project=project, location=location)
+  return client._api_client
+
+
 def _convert_event_to_json(event: Event):
   metadata_json = {
       'partial': event.partial,

google/adk/telemetry.py

@@ -32,7 +32,6 @@ from .events.event import Event
 from .models.llm_request import LlmRequest
 from .models.llm_response import LlmResponse
 
-
 tracer = trace.get_tracer('gcp.vertex.agent')
 
 
@@ -111,11 +110,17 @@ def trace_call_llm(
   span.set_attribute(
       'gcp.vertex.agent.invocation_id', invocation_context.invocation_id
   )
+  span.set_attribute(
+      'gcp.vertex.agent.session_id', invocation_context.session.id
+  )
   span.set_attribute('gcp.vertex.agent.event_id', event_id)
   # Consider removing once GenAI SDK provides a way to record this info.
   span.set_attribute(
       'gcp.vertex.agent.llm_request',
-      json.dumps(_build_llm_request_for_trace(llm_request)),
+      json.dumps(
+          _build_llm_request_for_trace(llm_request),
+          default=lambda o: '<not serializable>',
+      ),
   )
   # Consider removing once GenAI SDK provides a way to record this info.
   span.set_attribute(

google/adk/tools/__init__.py

@@ -11,31 +11,28 @@
 # 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.
-# pylint: disable=g-bad-import-order
-from .base_tool import BaseTool
+
 
 from ..auth.auth_tool import AuthToolArguments
 from .apihub_tool.apihub_toolset import APIHubToolset
-from .built_in_code_execution_tool import built_in_code_execution
-from .google_search_tool import google_search
-from .vertex_ai_search_tool import VertexAiSearchTool
+from .base_tool import BaseTool
 from .example_tool import ExampleTool
 from .exit_loop_tool import exit_loop
 from .function_tool import FunctionTool
 from .get_user_choice_tool import get_user_choice_tool as get_user_choice
+from .google_search_tool import google_search
 from .load_artifacts_tool import load_artifacts_tool as load_artifacts
 from .load_memory_tool import load_memory_tool as load_memory
 from .long_running_tool import LongRunningFunctionTool
 from .preload_memory_tool import preload_memory_tool as preload_memory
 from .tool_context import ToolContext
 from .transfer_to_agent_tool import transfer_to_agent
-
+from .vertex_ai_search_tool import VertexAiSearchTool
 
 __all__ = [
     'APIHubToolset',
     'AuthToolArguments',
     'BaseTool',
-    'built_in_code_execution',
     'google_search',
     'VertexAiSearchTool',
     'ExampleTool',

google/adk/tools/_memory_entry_utils.py

@@ -0,0 +1,30 @@
+# 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.
+
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+  from ..memory.memory_entry import MemoryEntry
+
+
+def extract_text(memory: MemoryEntry, splitter: str = ' ') -> str:
+  """Extracts the text from the memory entry."""
+  if not memory.content.parts:
+    return ''
+  return splitter.join(
+      [part.text for part in memory.content.parts if part.text]
+  )

google/adk/tools/agent_tool.py

@@ -21,10 +21,10 @@ from google.genai import types
 from pydantic import model_validator
 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 . import _automatic_function_calling_util
 from .base_tool import BaseTool
 from .tool_context import ToolContext
 
@@ -129,7 +129,7 @@ class AgentTool(BaseTool):
         session_service=InMemorySessionService(),
         memory_service=InMemoryMemoryService(),
     )
-    session = runner.session_service.create_session(
+    session = await runner.session_service.create_session(
         app_name=self.agent.name,
         user_id='tmp_user',
         state=tool_context.state.to_dict(),
@@ -162,17 +162,17 @@ class AgentTool(BaseTool):
               filename=artifact_name, artifact=artifact
           )
 
-    if (
-        not last_event
-        or not last_event.content
-        or not last_event.content.parts
-        or not last_event.content.parts[0].text
-    ):
+    if not last_event or not last_event.content or not last_event.content.parts:
       return ''
     if isinstance(self.agent, LlmAgent) and self.agent.output_schema:
+      merged_text = '\n'.join(
+          [p.text for p in last_event.content.parts if p.text]
+      )
       tool_result = self.agent.output_schema.model_validate_json(
-          last_event.content.parts[0].text
+          merged_text
       ).model_dump(exclude_none=True)
     else:
-      tool_result = last_event.content.parts[0].text
+      tool_result = '\n'.join(
+          [p.text for p in last_event.content.parts if p.text]
+      )
     return tool_result