fix(sessions): use UTC consistently in append_event for all DB backends

The append_event method had inconsistent timezone handling: SQLite
converted event.timestamp to UTC before stripping tzinfo, while all
other backends (including PostgreSQL) used datetime.fromtimestamp()
which produces naive datetimes in the server's local timezone.

On non-UTC servers, this caused PostgreSQL to store update_time values
offset by hours from SQLite, leading to incorrect staleness checks.

Now all backends first convert to UTC, then strip tzinfo only for
SQLite and PostgreSQL (which require naive datetimes).

https://claude.ai/code/session_01TNMxZwEdKgsQJvWtJhzQiQ

.github/workflows/analyze-releases-for-adk-docs-updates.yml

@@ -24,7 +24,7 @@ jobs:
           python-version: '3.11'
 
       - name: Load adk-bot SSH Private Key
-        uses: webfactory/ssh-agent@v0.9.0
+        uses: webfactory/ssh-agent@v0.9.1
         with:
           ssh-private-key: ${{ secrets.ADK_BOT_SSH_PRIVATE_KEY }}
 

.github/workflows/mypy-new-errors.yml

@@ -15,17 +15,17 @@ jobs:
         python-version: ['3.10', '3.11', '3.12', '3.13',]
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v7
 
       - name: Generate Baseline (Main)
         run: |

.github/workflows/mypy.yml

@@ -14,13 +14,13 @@ jobs:
         python-version: ['3.10', '3.11', '3.12', '3.13',]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v1
+        uses: astral-sh/setup-uv@v7
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
 

.github/workflows/python-unit-tests.yml

@@ -37,7 +37,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
 
     - name: Install the latest version of uv
-      uses: astral-sh/setup-uv@v6
+      uses: astral-sh/setup-uv@v7
 
     - name: Install dependencies
       run: |

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.24.1](https://github.com/google/adk-python/compare/v1.24.0...v1.24.1) (2026-02-06)
+
+### Bug Fixes
+
+* Add back deprecated eval endpoint for web until we migrate([ae993e8](https://github.com/google/adk-python/commit/ae993e884f44db276a4116ebb7a11a2fb586dbfe))
+* Update eval dialog colors, and fix a2ui component types ([3686a3a](https://github.com/google/adk-python/commit/3686a3a98f46738549cd7a999f3773b7a6fd1182))
+
 ## [1.24.0](https://github.com/google/adk-python/compare/v1.23.0...v1.24.0) (2026-02-04)
 
 ### ⚠ BREAKING CHANGES

contributing/samples/bigquery/README.md

@@ -119,6 +119,39 @@ type.
 
 1. Set `CREDENTIALS_TYPE=AuthCredentialTypes.OAUTH2` in `agent.py` and run the agent
 
+### With Agent Engine and Gemini Enterprise
+
+This mode is useful when you deploy the agent to Vertex AI Agent Engine and
+want to make it available in Gemini Enterprise, allowing the agent to access
+BigQuery on behalf of the end-user. This setup uses OAuth 2.0 managed by
+Gemini Enterprise.
+
+1. Create an Authorization resource in Gemini Enterprise by following the guide at
+[Register and manage ADK agents hosted on Vertex AI Agent Engine](https://docs.cloud.google.com/gemini/enterprise/docs/register-and-manage-an-adk-agent) to:
+  * Create OAuth 2.0 credentials in your Google Cloud project.
+  * Create an Authorization resource in Gemini Enterprise, linking it to your
+    OAuth 2.0 credentials. When creating this resource, you will define a
+    unique identifier (`AUTH_ID`).
+
+2. Prepare the sample agent for consuming the access token provided by Gemini
+Enterprise and deploy to Vertex AI Agent Engine.
+  * Set `CREDENTIALS_TYPE=AuthCredentialTypes.HTTP` in `agent.py`. This
+configures the agent to use access tokens provided by Gemini Enterprise and
+provided by Agent Engine via the tool context.
+  * Replace `AUTH_ID` in `agent.py` with your authorization resource identifier
+    from step 1.
+  * [Deploy your agent to Vertex AI Agent Engine](https://google.github.io/adk-docs/deploy/agent-engine/).
+
+3. [Register your deployed agent with Gemini Enterprise](https://docs.cloud.google.com/gemini/enterprise/docs/register-and-manage-an-adk-agent#register-an-adk-agent), attaching the
+Authorization resource `AUTH_ID`. When this agent is invoked through Gemini
+Enterprise, an access token obtained using these OAuth credentials will be
+passed to the agent and made available in the ADK `tool_context` under the key
+`AUTH_ID`, which `agent.py` is configured to use.
+
+Once registered, users interacting with your agent via Gemini Enterprise will
+go through an OAuth consent flow, and Agent Engine will provide the agent with
+the necessary access tokens to call BigQuery APIs on their behalf.
+
 ## Sample prompts
 
 * which weather datasets exist in bigquery public data?

contributing/samples/bigquery/agent.py

@@ -56,6 +56,17 @@ elif CREDENTIALS_TYPE == AuthCredentialTypes.SERVICE_ACCOUNT:
   # https://cloud.google.com/iam/docs/service-account-creds#user-managed-keys
   creds, _ = google.auth.load_credentials_from_file("service_account_key.json")
   credentials_config = BigQueryCredentialsConfig(credentials=creds)
+elif CREDENTIALS_TYPE == AuthCredentialTypes.HTTP:
+  # Initialize the tools to use the externally provided access token. One such
+  # use case is creating an authorization resource `AUTH_ID` in Gemini
+  # Enterprise and using it to register an ADK agent deployed to Vertex AI
+  # Agent Engine with Gemini Enterprise. See for more details:
+  # https://docs.cloud.google.com/gemini/enterprise/docs/register-and-manage-an-adk-agent.
+  # This access token will be passed to the agent via the tool context, with
+  # the key `AUTH_ID`.
+  credentials_config = BigQueryCredentialsConfig(
+      external_access_token_key="AUTH_ID"
+  )
 else:
   # Initialize the tools to use the application default credentials.
   # https://cloud.google.com/docs/authentication/provide-credentials-adc

contributing/samples/gepa/adk_agent.py

@@ -159,7 +159,7 @@ def _adk_agent(
 
 
 class _UserAgent(base_agent.BaseAgent):
-  """An agent that wraps the provided environment and simulates an user."""
+  """An agent that wraps the provided environment and simulates a user."""
 
   env: Env
 

contributing/samples/gepa/tau_bench_agent.py

@@ -103,7 +103,7 @@ class _ADKAgent(tool_calling_agent.ToolCallingAgent):
       max_num_steps: The maximum number of steps to run the agent.
 
     Returns:
-      The result of the solve.
+      The result of the solve function.
 
     Raises:
       - ValueError: If the LLM inference failed.

contributing/samples/mcp_progress_callback_agent/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2026 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 . import agent

contributing/samples/mcp_progress_callback_agent/agent.py

@@ -0,0 +1,166 @@
+# Copyright 2026 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.
+
+"""Sample agent demonstrating MCP progress callback feature.
+
+This sample shows how to use the progress_callback parameter in McpToolset
+to receive progress notifications from MCP servers during long-running tool
+executions.
+
+There are two ways to use progress callbacks:
+
+1. Simple callback (shared by all tools):
+   Pass a ProgressFnT callback that receives (progress, total, message).
+
+2. Factory function (per-tool callbacks with runtime context):
+   Pass a ProgressCallbackFactory that takes (tool_name, callback_context, **kwargs)
+   and returns a ProgressFnT or None. This allows different tools to have different
+   progress handling logic, and the factory can access and modify session state
+   via the CallbackContext. The **kwargs ensures forward compatibility for future
+   parameters.
+
+IMPORTANT: Progress callbacks only work when the MCP server actually sends
+progress notifications. Most simple MCP servers (like the filesystem server)
+do not send progress updates. This sample uses a mock server that demonstrates
+progress reporting.
+
+Usage:
+  adk run contributing/samples/mcp_progress_callback_agent
+
+Then try:
+  "Run the long running task with 5 steps"
+  "Process these items: apple, banana, cherry"
+"""
+
+import os
+import sys
+from typing import Any
+
+from google.adk.agents.callback_context import CallbackContext
+from google.adk.agents.llm_agent import LlmAgent
+from google.adk.tools.mcp_tool import McpToolset
+from google.adk.tools.mcp_tool import StdioConnectionParams
+from mcp import StdioServerParameters
+from mcp.shared.session import ProgressFnT
+
+_current_dir = os.path.dirname(os.path.abspath(__file__))
+_mock_server_path = os.path.join(_current_dir, "mock_progress_server.py")
+
+
+# Option 1: Simple shared callback
+async def simple_progress_callback(
+    progress: float,
+    total: float | None,
+    message: str | None,
+) -> None:
+  """Handle progress notifications from MCP server.
+
+  This callback is shared by all tools in the toolset.
+  """
+  if total is not None:
+    percentage = (progress / total) * 100
+    bar_length = 20
+    filled = int(bar_length * progress / total)
+    bar = "=" * filled + "-" * (bar_length - filled)
+    print(f"[{bar}] {percentage:.0f}% ({progress}/{total}) {message or ''}")
+  else:
+    print(f"Progress: {progress} {f'- {message}' if message else ''}")
+
+
+# Option 2: Factory function for per-tool callbacks with runtime context
+def progress_callback_factory(
+    tool_name: str,
+    *,
+    callback_context: CallbackContext | None = None,
+    **kwargs: Any,
+) -> ProgressFnT | None:
+  """Create a progress callback for a specific tool.
+
+  This factory allows different tools to have different progress handling.
+  It receives a CallbackContext for accessing and modifying runtime information
+  like session state. The **kwargs parameter ensures forward compatibility.
+
+  Args:
+    tool_name: The name of the MCP tool.
+    callback_context: The callback context providing access to session,
+      state, artifacts, and other runtime information. Allows modifying
+      state via ctx.state['key'] = value. May be None if not available.
+    **kwargs: Additional keyword arguments for future extensibility.
+
+  Returns:
+    A progress callback function, or None if no callback is needed.
+  """
+  # Example: Access session info from context (if available)
+  session_id = "unknown"
+  if callback_context and callback_context.session:
+    session_id = callback_context.session.id
+
+  async def callback(
+      progress: float,
+      total: float | None,
+      message: str | None,
+  ) -> None:
+    # Include tool name and session info in the progress output
+    prefix = f"[{tool_name}][session:{session_id}]"
+    if total is not None:
+      percentage = (progress / total) * 100
+      bar_length = 20
+      filled = int(bar_length * progress / total)
+      bar = "=" * filled + "-" * (bar_length - filled)
+      print(f"{prefix} [{bar}] {percentage:.0f}% {message or ''}")
+      # Example: Store progress in state (callback_context allows modification)
+      if callback_context:
+        callback_context.state["last_progress"] = progress
+        callback_context.state["last_total"] = total
+    else:
+      print(
+          f"{prefix} Progress: {progress} {f'- {message}' if message else ''}"
+      )
+
+  return callback
+
+
+root_agent = LlmAgent(
+    model="gemini-2.5-flash",
+    name="progress_demo_agent",
+    instruction="""\
+You are a helpful assistant that can run long-running tasks.
+
+Available tools:
+- long_running_task: Simulates a task with multiple steps. You can specify
+  the number of steps and delay between them.
+- process_items: Processes a list of items one by one with progress updates.
+
+When the user asks you to run a task, use these tools and the progress
+will be logged automatically.
+
+Example requests:
+- "Run a long task with 5 steps"
+- "Process these items: apple, banana, cherry, date"
+    """,
+    tools=[
+        McpToolset(
+            connection_params=StdioConnectionParams(
+                server_params=StdioServerParameters(
+                    command=sys.executable,  # Use current Python interpreter
+                    args=[_mock_server_path],
+                ),
+                timeout=60,
+            ),
+            # Use factory function for per-tool callbacks (Option 2)
+            # Or use simple_progress_callback for shared callback (Option 1)
+            progress_callback=progress_callback_factory,
+        )
+    ],
+)

contributing/samples/mcp_progress_callback_agent/mock_progress_server.py

@@ -0,0 +1,161 @@
+# Copyright 2026 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.
+
+"""Mock MCP server that sends progress notifications.
+
+This server demonstrates how MCP servers can send progress updates
+during long-running tool execution.
+
+Run this server directly:
+  python mock_progress_server.py
+
+Or use it with the sample agent:
+  See agent_with_mock_server.py
+"""
+
+import asyncio
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent
+from mcp.types import Tool
+
+server = Server("mock-progress-server")
+
+
+@server.list_tools()
+async def list_tools() -> list[Tool]:
+  """List available tools."""
+  return [
+      Tool(
+          name="long_running_task",
+          description=(
+              "A simulated long-running task that reports progress. "
+              "Use this to test progress callback functionality."
+          ),
+          inputSchema={
+              "type": "object",
+              "properties": {
+                  "steps": {
+                      "type": "integer",
+                      "description": "Number of steps to simulate (default: 5)",
+                      "default": 5,
+                  },
+                  "delay": {
+                      "type": "number",
+                      "description": (
+                          "Delay in seconds between steps (default: 0.5)"
+                      ),
+                      "default": 0.5,
+                  },
+              },
+          },
+      ),
+      Tool(
+          name="process_items",
+          description="Process a list of items with progress reporting.",
+          inputSchema={
+              "type": "object",
+              "properties": {
+                  "items": {
+                      "type": "array",
+                      "items": {"type": "string"},
+                      "description": "List of items to process",
+                  },
+              },
+              "required": ["items"],
+          },
+      ),
+  ]
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+  """Handle tool calls with progress reporting."""
+  ctx = server.request_context
+
+  if name == "long_running_task":
+    steps = arguments.get("steps", 5)
+    delay = arguments.get("delay", 0.5)
+
+    # Get progress token from request metadata
+    progress_token = None
+    if ctx.meta and hasattr(ctx.meta, "progressToken"):
+      progress_token = ctx.meta.progressToken
+
+    for i in range(steps):
+      # Simulate work
+      await asyncio.sleep(delay)
+
+      # Send progress notification if client supports it
+      if progress_token is not None:
+        await ctx.session.send_progress_notification(
+            progress_token=progress_token,
+            progress=i + 1,
+            total=steps,
+            message=f"Completed step {i + 1} of {steps}",
+        )
+
+    return [
+        TextContent(
+            type="text",
+            text=f"Successfully completed {steps} steps!",
+        )
+    ]
+
+  elif name == "process_items":
+    items = arguments.get("items", [])
+    total = len(items)
+
+    progress_token = None
+    if ctx.meta and hasattr(ctx.meta, "progressToken"):
+      progress_token = ctx.meta.progressToken
+
+    results = []
+    for i, item in enumerate(items):
+      # Simulate processing
+      await asyncio.sleep(0.3)
+      results.append(f"Processed: {item}")
+
+      # Send progress
+      if progress_token is not None:
+        await ctx.session.send_progress_notification(
+            progress_token=progress_token,
+            progress=i + 1,
+            total=total,
+            message=f"Processing item: {item}",
+        )
+
+    return [
+        TextContent(
+            type="text",
+            text="\n".join(results),
+        )
+    ]
+
+  return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+
+async def main():
+  """Run the MCP server."""
+  async with stdio_server() as (read_stream, write_stream):
+    await server.run(
+        read_stream,
+        write_stream,
+        server.create_initialization_options(),
+    )
+
+
+if __name__ == "__main__":
+  asyncio.run(main())

contributing/samples/mcp_streamablehttp_agent/agent.py

@@ -52,6 +52,7 @@ Allowed directory: {_allowed_path}
                 'get_file_info',
                 'list_allowed_directories',
             ],
+            use_mcp_resources=True,
         )
     ],
 )

contributing/samples/mcp_streamablehttp_agent/filesystem_server.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import asyncio
+import json
 import os
 from pathlib import Path
 import sys
@@ -45,6 +46,24 @@ def get_cwd() -> str:
   return str(Path.cwd())
 
 
+# Add a resource for testing with JSON data
+@mcp.resource(
+    name="sample_data",
+    uri="file:///sample_data.json",
+    mime_type="application/json",
+)
+def sample_data() -> str:
+  data = {
+      "users": [
+          {"id": 1, "name": "Alice", "role": "admin"},
+          {"id": 2, "name": "Bob", "role": "user"},
+          {"id": 3, "name": "Charlie", "role": "user"},
+      ],
+      "settings": {"theme": "dark", "notifications": True},
+  }
+  return json.dumps(data, indent=2)
+
+
 # Graceful shutdown handler
 async def shutdown(signal, loop):
   """Cleanup tasks tied to the service's shutdown."""

contributing/samples/skills_agent/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2026 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 . import agent

contributing/samples/skills_agent/agent.py

@@ -0,0 +1,54 @@
+# Copyright 2026 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.
+
+"""Example agent demonstrating the use of SkillToolset."""
+
+import inspect
+
+from google.adk import Agent
+from google.adk.skills import models
+from google.adk.tools import skill_toolset
+
+greeting_skill = models.Skill(
+    frontmatter=models.Frontmatter(
+        name="greeting-skill",
+        description=(
+            "A friendly greeting skill that can say hello to a specific person."
+        ),
+    ),
+    instructions=(
+        "Step 1: Read the 'references/hello_world.txt' file to understand how"
+        " to greet the user. Step 2: Return a greeting based on the reference."
+    ),
+    resources=models.Resources(
+        references={
+            "hello_world.txt": "Hello! 👋👋👋 So glad to have you here! ✨✨✨",
+            "example.md": "This is an example reference.",
+        },
+    ),
+)
+
+my_skill_toolset = skill_toolset.SkillToolset(skills=[greeting_skill])
+
+root_agent = Agent(
+    model="gemini-2.5-flash",
+    name="skill_user_agent",
+    description="An agent that can use specialized skills.",
+    instruction=(
+        "You are a helpful assistant that can leverage skills to perform tasks."
+    ),
+    tools=[
+        my_skill_toolset,
+    ],
+)

pyproject.toml

@@ -143,7 +143,7 @@ docs = [
   "autodoc_pydantic",
   "furo",
   "myst-parser",
-  "sphinx",
+  "sphinx<9.0.0",
   "sphinx-autodoc-typehints",
   "sphinx-rtd-theme",
 ]
@@ -219,7 +219,6 @@ asyncio_mode = "auto"
 python_version = "3.10"
 exclude = ["tests/", "contributing/samples/"]
 plugins = ["pydantic.mypy"]
-# Start with non-strict mode, and swtich to strict mode later.
 strict = true
 disable_error_code = ["import-not-found", "import-untyped", "unused-ignore"]
 follow_imports = "skip"

src/google/adk/a2a/converters/utils.py

@@ -59,7 +59,9 @@ def _to_a2a_context_id(app_name: str, user_id: str, session_id: str) -> str:
   )
 
 
-def _from_a2a_context_id(context_id: str) -> tuple[str, str, str]:
+def _from_a2a_context_id(
+    context_id: str | None,
+) -> tuple[str, str, str] | tuple[None, None, None]:
   """Converts an A2A context id to app name, user id and session id.
   if context_id is None, return None, None, None
   if context_id is not None, but not in the format of
@@ -69,7 +71,7 @@ def _from_a2a_context_id(context_id: str) -> tuple[str, str, str]:
     context_id: The A2A context id.
 
   Returns:
-    The app name, user id and session id.
+    The app name, user id and session id, or (None, None, None) if invalid.
   """
   if not context_id:
     return None, None, None

src/google/adk/agents/callback_context.py

@@ -14,6 +14,8 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
+from collections.abc import Sequence
 from typing import Any
 from typing import Optional
 from typing import TYPE_CHECKING
@@ -28,6 +30,7 @@ if TYPE_CHECKING:
   from ..artifacts.base_artifact_service import ArtifactVersion
   from ..auth.auth_credential import AuthCredential
   from ..auth.auth_tool import AuthConfig
+  from ..events.event import Event
   from ..events.event_actions import EventActions
   from ..sessions.state import State
   from .invocation_context import InvocationContext
@@ -219,3 +222,32 @@ class CallbackContext(ReadonlyContext):
     await self._invocation_context.memory_service.add_session_to_memory(
         self._invocation_context.session
     )
+
+  async def add_events_to_memory(
+      self,
+      *,
+      events: Sequence[Event],
+      custom_metadata: Mapping[str, object] | None = None,
+  ) -> None:
+    """Adds an explicit list of events to the memory service.
+
+    Uses this callback's current session identifiers as memory scope.
+
+    Args:
+      events: Explicit events to add to memory.
+      custom_metadata: Optional standard metadata for memory generation.
+
+    Raises:
+      ValueError: If memory service is not available.
+    """
+    if self._invocation_context.memory_service is None:
+      raise ValueError(
+          "Cannot add events to memory: memory service is not available."
+      )
+    await self._invocation_context.memory_service.add_events_to_memory(
+        app_name=self._invocation_context.session.app_name,
+        user_id=self._invocation_context.session.user_id,
+        session_id=self._invocation_context.session.id,
+        events=events,
+        custom_metadata=custom_metadata,
+    )

src/google/adk/agents/llm_agent.py

@@ -469,7 +469,7 @@ class LlmAgent(BaseAgent):
         self.__maybe_save_output_to_state(event)
         yield event
         if ctx.should_pause_invocation(event):
-          # Do not pause immediately, wait until the long running tool call is
+          # Do not pause immediately, wait until the long-running tool call is
           # executed.
           should_pause = True
     if should_pause:
@@ -479,7 +479,7 @@ class LlmAgent(BaseAgent):
       events = ctx._get_events(current_invocation=True, current_branch=True)
       if events and any(ctx.should_pause_invocation(e) for e in events[-2:]):
         return
-      # Only yield an end state if the last event is no longer a long running
+      # Only yield an end state if the last event is no longer a long-running
       # tool call.
       ctx.set_agent_state(self.name, end_of_agent=True)
       yield self._create_agent_state_event(ctx)