Merge branch 'main' into fix/non-vertex-live-resumption

Author: rohityan

pyproject.toml

@@ -166,7 +166,7 @@ scripts.adk = "google.adk.cli:main"
 
 [tool.flit.sdist]
 include = [ 'src/**/*', 'README.md', 'pyproject.toml', 'LICENSE' ]
-exclude = [ 'src/**/*.sh' ]
+exclude = [ 'src/**/*.sh', 'src/**/README.md' ]
 
 [tool.flit.module]
 name = "google.adk"

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

@@ -570,7 +570,10 @@ def convert_event_to_a2a_events(
 
     # Handle regular message content
     message = convert_event_to_a2a_message(
-        event, invocation_context, part_converter=part_converter
+        event,
+        invocation_context,
+        part_converter=part_converter,
+        role=Role.user if event.author == "user" else Role.agent,
     )
     if message:
       running_event = _create_status_update_event(

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

@@ -35,6 +35,7 @@
 from ...runners import Runner
 from ...sessions.in_memory_session_service import InMemorySessionService
 from ..executor.a2a_agent_executor import A2aAgentExecutor
+from ..executor.config import A2aAgentExecutorConfig
 from ..experimental import a2a_experimental
 from .agent_card_builder import AgentCardBuilder
 
@@ -86,6 +87,7 @@ def to_a2a(
     task_store: TaskStore | None = None,
     runner: Runner | None = None,
     lifespan: Callable[[Starlette], AsyncIterator[None]] | None = None,
+    agent_executor_factory: Callable[[Runner], A2aAgentExecutor] | None = None,
 ) -> Starlette:
   """Convert an ADK agent to a A2A Starlette application.
 
@@ -95,20 +97,21 @@ def to_a2a(
       port: The port for the A2A RPC URL (default: 8000)
       protocol: The protocol for the A2A RPC URL (default: "http")
       agent_card: Optional pre-built AgentCard object or path to agent card
-                  JSON. If not provided, will be built automatically from the
-                  agent.
+        JSON. If not provided, will be built automatically from the agent.
       push_config_store: Optional A2A push notification config store. If not
-        provided, an in-memory store will be created so push-notification
-        config RPC methods are supported.
+        provided, an in-memory store will be created so push-notification config
+        RPC methods are supported.
       task_store: Optional A2A task store for persisting task state. If not
         provided, an in-memory store will be created.
       runner: Optional pre-built Runner object. If not provided, a default
-              runner will be created using in-memory services.
-      lifespan: Optional async context manager for Starlette lifespan
-        events. Use this to run startup/shutdown logic (e.g. initializing
-        database connections or loading resources). The context manager
-        receives the Starlette app instance and can set state on
-        ``app.state``.
+        runner will be created using in-memory services.
+      lifespan: Optional async context manager for Starlette lifespan events.
+        Use this to run startup/shutdown logic (e.g. initializing database
+        connections or loading resources). The context manager receives the
+        Starlette app instance and can set state on ``app.state``.
+      agent_executor_factory: Optional factory function that creates an instance
+        of A2aAgentExecutor. If not provided, a default A2aAgentExecutor will be
+        created.
 
   Returns:
       A Starlette application that can be run with uvicorn
@@ -148,7 +151,7 @@ async def lifespan(app):
   adk_logger = logging.getLogger("google_adk")
   adk_logger.setLevel(logging.INFO)
 
-  async def create_runner() -> Runner:
+  def create_runner() -> Runner:
     """Create a runner for the agent."""
     return Runner(
         app_name=agent.name or "adk_agent",
@@ -164,8 +167,10 @@ async def create_runner() -> Runner:
   if task_store is None:
     task_store = InMemoryTaskStore()
 
-  agent_executor = A2aAgentExecutor(
-      runner=runner or create_runner,
+  agent_executor = (
+      agent_executor_factory(runner or create_runner())
+      if agent_executor_factory is not None
+      else A2aAgentExecutor(runner=runner or create_runner)
   )
 
   if push_config_store is None:

src/google/adk/agents/invocation_context.py

@@ -25,8 +25,8 @@
 from pydantic import Field
 from pydantic import PrivateAttr
 
-from ..apps.app import EventsCompactionConfig
-from ..apps.app import ResumabilityConfig
+from ..apps._configs import EventsCompactionConfig
+from ..apps._configs import ResumabilityConfig
 from ..artifacts.base_artifact_service import BaseArtifactService
 from ..auth.auth_credential import AuthCredential
 from ..auth.credential_service.base_credential_service import BaseCredentialService

src/google/adk/apps/__init__.py

@@ -12,10 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .app import App
-from .app import ResumabilityConfig
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+  from ._configs import ResumabilityConfig
+  from .app import App
 
 __all__ = [
     'App',
     'ResumabilityConfig',
 ]
+
+_LAZY_MEMBERS: dict[str, str] = {
+    'App': 'app',
+    'ResumabilityConfig': '_configs',
+}
+
+
+def __getattr__(name: str):
+  if name in _LAZY_MEMBERS:
+    module = importlib.import_module(f'{__name__}.{_LAZY_MEMBERS[name]}')
+    return vars(module)[name]
+  raise AttributeError(f'module {__name__!r} has no attribute {name!r}')

src/google/adk/apps/_configs.py

@@ -0,0 +1,95 @@
+# 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 __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from pydantic import Field
+from pydantic import model_validator
+
+from ..utils.feature_decorator import experimental
+from .base_events_summarizer import BaseEventsSummarizer
+
+
+@experimental
+class ResumabilityConfig(BaseModel):
+  """The config of the resumability for an application.
+
+  The "resumability" in ADK refers to the ability to:
+  1. pause an invocation upon a long-running function call.
+  2. resume an invocation from the last event, if it's paused or failed midway
+  through.
+
+  Note: ADK resumes the invocation in a best-effort manner:
+  1. Tool call to resume needs to be idempotent because we only guarantee
+  an at-least-once behavior once resumed.
+  2. Any temporary / in-memory state will be lost upon resumption.
+  """
+
+  is_resumable: bool = False
+  """Whether the app supports agent resumption.
+  If enabled, the feature will be enabled for all agents in the app.
+  """
+
+
+@experimental
+class EventsCompactionConfig(BaseModel):
+  """The config of event compaction for an application."""
+
+  model_config = ConfigDict(
+      arbitrary_types_allowed=True,
+      extra="forbid",
+  )
+
+  summarizer: Optional[BaseEventsSummarizer] = None
+  """The event summarizer to use for compaction."""
+
+  compaction_interval: int
+  """The number of *new* user-initiated invocations that, once
+  fully represented in the session's events, will trigger a compaction."""
+
+  overlap_size: int
+  """The number of preceding invocations to include from the
+  end of the last compacted range. This creates an overlap between consecutive
+  compacted summaries, maintaining context."""
+
+  token_threshold: Optional[int] = Field(
+      default=None,
+      gt=0,
+  )
+  """Post-invocation token threshold trigger.
+
+  If set, ADK will attempt a post-invocation compaction when the most recently
+  observed prompt token count meets or exceeds this threshold.
+  """
+
+  event_retention_size: Optional[int] = Field(default=None, ge=0)
+  """Post-invocation raw event retention size.
+
+  If token-based post-invocation compaction is triggered, this keeps the last N
+  raw events un-compacted.
+  """
+
+  @model_validator(mode="after")
+  def _validate_token_params(self) -> EventsCompactionConfig:
+    token_threshold_set = self.token_threshold is not None
+    retention_size_set = self.event_retention_size is not None
+    if token_threshold_set != retention_size_set:
+      raise ValueError(
+          "token_threshold and event_retention_size must be set together."
+      )
+    return self

src/google/adk/apps/app.py

@@ -22,9 +22,16 @@
 
 from ..agents.base_agent import BaseAgent
 from ..agents.context_cache_config import ContextCacheConfig
-from ..apps.base_events_summarizer import BaseEventsSummarizer
 from ..plugins.base_plugin import BasePlugin
-from ..utils.feature_decorator import experimental
+from ._configs import EventsCompactionConfig
+from ._configs import ResumabilityConfig
+
+__all__ = [
+    "App",
+    "EventsCompactionConfig",
+    "ResumabilityConfig",
+    "validate_app_name",
+]
 
 
 def validate_app_name(name: str) -> None:
@@ -38,76 +45,6 @@ def validate_app_name(name: str) -> None:
     raise ValueError("App name cannot be 'user'; reserved for end-user input.")
 
 
-@experimental
-class ResumabilityConfig(BaseModel):
-  """The config of the resumability for an application.
-
-  The "resumability" in ADK refers to the ability to:
-  1. pause an invocation upon a long-running function call.
-  2. resume an invocation from the last event, if it's paused or failed midway
-  through.
-
-  Note: ADK resumes the invocation in a best-effort manner:
-  1. Tool call to resume needs to be idempotent because we only guarantee
-  an at-least-once behavior once resumed.
-  2. Any temporary / in-memory state will be lost upon resumption.
-  """
-
-  is_resumable: bool = False
-  """Whether the app supports agent resumption.
-  If enabled, the feature will be enabled for all agents in the app.
-  """
-
-
-@experimental
-class EventsCompactionConfig(BaseModel):
-  """The config of event compaction for an application."""
-
-  model_config = ConfigDict(
-      arbitrary_types_allowed=True,
-      extra="forbid",
-  )
-
-  summarizer: Optional[BaseEventsSummarizer] = None
-  """The event summarizer to use for compaction."""
-
-  compaction_interval: int
-  """The number of *new* user-initiated invocations that, once
-  fully represented in the session's events, will trigger a compaction."""
-
-  overlap_size: int
-  """The number of preceding invocations to include from the
-  end of the last compacted range. This creates an overlap between consecutive
-  compacted summaries, maintaining context."""
-
-  token_threshold: Optional[int] = Field(
-      default=None,
-      gt=0,
-  )
-  """Post-invocation token threshold trigger.
-
-  If set, ADK will attempt a post-invocation compaction when the most recently
-  observed prompt token count meets or exceeds this threshold.
-  """
-
-  event_retention_size: Optional[int] = Field(default=None, ge=0)
-  """Post-invocation raw event retention size.
-
-  If token-based post-invocation compaction is triggered, this keeps the last N
-  raw events un-compacted.
-  """
-
-  @model_validator(mode="after")
-  def _validate_token_params(self) -> EventsCompactionConfig:
-    token_threshold_set = self.token_threshold is not None
-    retention_size_set = self.event_retention_size is not None
-    if token_threshold_set != retention_size_set:
-      raise ValueError(
-          "token_threshold and event_retention_size must be set together."
-      )
-    return self
-
-
 class App(BaseModel):
   """Represents an LLM-backed agentic application.
 

src/google/adk/apps/compaction.py

@@ -270,6 +270,9 @@ def _events_to_compact_for_token_threshold(
   events_to_compact = _truncate_events_before_pending_function_call(
       events_to_compact, pending_ids
   )
+  events_to_compact = _truncate_events_before_hitl_signal(
+      events_to_compact, _resolved_hitl_call_ids(events)
+  )
   if not events_to_compact:
     return []
 
@@ -344,6 +347,45 @@ def _truncate_events_before_pending_function_call(
   return events
 
 
+def _resolved_hitl_call_ids(events: list[Event]) -> set[str]:
+  """Returns HITL call ids resolved by a later function_response in `events`."""
+  hitl_position: dict[str, int] = {}
+  resolved: set[str] = set()
+  for index, event in enumerate(events):
+    if event.actions:
+      for call_id in event.actions.requested_tool_confirmations:
+        hitl_position.setdefault(call_id, index)
+      for call_id in event.actions.requested_auth_configs:
+        hitl_position.setdefault(call_id, index)
+    for resp_id in _event_function_response_ids(event):
+      hitl_pos = hitl_position.get(resp_id)
+      if hitl_pos is not None and index > hitl_pos:
+        resolved.add(resp_id)
+  return resolved
+
+
+def _is_pending_hitl(event: Event, resolved_call_ids: set[str]) -> bool:
+  """Returns True if the event has an HITL request not in `resolved_call_ids`."""
+  if not event.actions:
+    return False
+  requested = set(event.actions.requested_tool_confirmations) | set(
+      event.actions.requested_auth_configs
+  )
+  if not requested:
+    return False
+  return bool(requested - resolved_call_ids)
+
+
+def _truncate_events_before_hitl_signal(
+    events: list[Event], resolved_call_ids: set[str]
+) -> list[Event]:
+  """Returns the leading contiguous events before any pending HITL request."""
+  for index, event in enumerate(events):
+    if _is_pending_hitl(event, resolved_call_ids):
+      return events[:index]
+  return events
+
+
 def _safe_token_compaction_split_index(
     *,
     candidate_events: list[Event],
@@ -631,6 +673,9 @@ async def _run_compaction_for_sliding_window(
       events_to_compact = _truncate_events_before_pending_function_call(
           events_to_compact, pending_ids
       )
+      events_to_compact = _truncate_events_before_hitl_signal(
+          events_to_compact, _resolved_hitl_call_ids(events)
+      )
 
   if not events_to_compact:
     return None