Merge branch 'main' into fix/stream-reasoning-engine-stopiteration

Author: rohityan

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

@@ -52,7 +52,9 @@ jobs:
         uses: actions/cache/restore@v4
         with:
           path: contributing/samples/adk_team/adk_documentation/adk_release_analyzer/sessions.db
-          key: analyzer-session-db
+          key: analyzer-session-db-${{ github.run_id }}-${{ github.run_attempt }}
+          restore-keys: |
+            analyzer-session-db-
 
       - name: Run Analyzing Script
         env:
@@ -88,4 +90,4 @@ jobs:
         uses: actions/cache/save@v4
         with:
           path: contributing/samples/adk_team/adk_documentation/adk_release_analyzer/sessions.db
-          key: analyzer-session-db
+          key: analyzer-session-db-${{ github.run_id }}-${{ github.run_attempt }}

CONTRIBUTING.md

@@ -133,7 +133,7 @@ part before or alongside your code PR.
 1. **Clone the repository:**
 
    ```shell
-   gh repo clone google/adk-python -- -b v2
+   gh repo clone google/adk-python
    cd adk-python
    ```
 

contributing/samples/mcp/mcp_sse_mtls_agent/generate_mtls_certs.sh

@@ -1,4 +1,18 @@
 #!/bin/bash
+# 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.
+
 set -e
 
 # Directory where this script is located

src/google/adk/a2a/executor/a2a_agent_executor.py

@@ -251,8 +251,10 @@ async def _handle_request(
     )
 
     task_result_aggregator = TaskResultAggregator()
+    last_adk_event = None
     async with Aclosing(runner.run_async(**vars(run_request))) as agen:
       async for adk_event in agen:
+        last_adk_event = adk_event
         for a2a_event in self._config.event_converter(
             adk_event,
             invocation_context,
@@ -270,6 +272,22 @@ async def _handle_request(
             task_result_aggregator.process_event(e)
             await event_queue.enqueue_event(e)
 
+    # Build metadata for final event to preserve invocation_id and event_id.
+    final_metadata = {
+        _get_adk_metadata_key('app_name'): runner.app_name,
+        _get_adk_metadata_key('user_id'): run_request.user_id,
+        _get_adk_metadata_key('session_id'): run_request.session_id,
+    }
+    if last_adk_event:
+      for key, attr in [
+          ('invocation_id', 'invocation_id'),
+          ('author', 'author'),
+          ('event_id', 'id'),
+      ]:
+        val = getattr(last_adk_event, attr, None)
+        if val is not None:
+          final_metadata[_get_adk_metadata_key(key)] = val
+
     # publish the task result event - this is final
     if (
         task_result_aggregator.task_state == TaskState.working
@@ -287,6 +305,7 @@ async def _handle_request(
                   artifact_id=platform_uuid.new_uuid(),
                   parts=task_result_aggregator.task_status_message.parts,
               ),
+              metadata=final_metadata,
           )
       )
       # public the final status update event
@@ -299,6 +318,7 @@ async def _handle_request(
               ).isoformat(),
           ),
           context_id=context.context_id,
+          metadata=final_metadata,
           final=True,
       )
     else:
@@ -312,6 +332,7 @@ async def _handle_request(
               message=task_result_aggregator.task_status_message,
           ),
           context_id=context.context_id,
+          metadata=final_metadata,
           final=True,
       )
 

src/google/adk/apps/compaction.py

@@ -266,13 +266,7 @@ def _events_to_compact_for_token_threshold(
         event_retention_size=event_retention_size,
     )
     events_to_compact = candidate_events[:split_index]
-  pending_ids = _pending_function_call_ids(events)
-  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)
-  )
+  events_to_compact = _longest_self_contained_prefix(events_to_compact)
   if not events_to_compact:
     return []
 
@@ -313,76 +307,28 @@ def _event_function_response_ids(event: Event) -> set[str]:
   return function_response_ids
 
 
-def _pending_function_call_ids(events: list[Event]) -> set[str]:
-  """Returns function call IDs that have no matching response in the session.
+def _longest_self_contained_prefix(events: list[Event]) -> list[Event]:
+  """Returns the longest prefix of `events` that is safe to compact.
 
-  Scans the session once, collecting function call IDs and response IDs, then
-  returns the call IDs that are not covered by any response. Events containing
-  these IDs represent pending (unanswered) function calls that must not be
-  compacted.
+  Performs a single left-to-right pass tracking "open" obligations keyed by call
+  id: a function call or a tool-confirmation / auth request opens one, and a
+  function response with the same id closes it. Responses are applied before
+  opens within each event so a response only closes an obligation opened by an
+  earlier event. The prefix is safe to summarize only at points where no
+  obligation is open, so the longest prefix ending at such a balanced point is
+  returned (empty if the window never reaches a balanced point).
   """
-  all_call_ids: set[str] = set()
-  all_response_ids: set[str] = set()
-  for event in events:
-    all_call_ids.update(_event_function_call_ids(event))
-    all_response_ids.update(_event_function_response_ids(event))
-
-  return all_call_ids - all_response_ids
-
-
-def _has_pending_function_call(event: Event, pending_ids: set[str]) -> bool:
-  """Returns True if the event contains any pending function call."""
-  call_ids = _event_function_call_ids(event)
-  return bool(call_ids and not call_ids.isdisjoint(pending_ids))
-
-
-def _truncate_events_before_pending_function_call(
-    events: list[Event], pending_ids: set[str]
-) -> list[Event]:
-  """Returns the leading contiguous events that avoid pending function calls."""
-  for index, event in enumerate(events):
-    if _has_pending_function_call(event, pending_ids):
-      return events[:index]
-  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()
+  open_ids: set[str] = set()
+  safe_length = 0
   for index, event in enumerate(events):
+    open_ids -= _event_function_response_ids(event)
+    open_ids |= _event_function_call_ids(event)
     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
+      open_ids |= set(event.actions.requested_tool_confirmations)
+      open_ids |= set(event.actions.requested_auth_configs)
+    if not open_ids:
+      safe_length = index + 1
+  return events[:safe_length]
 
 
 def _safe_token_compaction_split_index(
@@ -664,13 +610,7 @@ async def _run_compaction_for_sliding_window(
       events_to_compact = [
           e for e in events_to_compact if not e.actions.compaction
       ]
-      pending_ids = _pending_function_call_ids(events)
-      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)
-      )
+      events_to_compact = _longest_self_contained_prefix(events_to_compact)
 
   if not events_to_compact:
     return None

src/google/adk/flows/llm_flows/contents.py

@@ -108,7 +108,6 @@ def _rearrange_events_for_async_function_responses_in_history(
     events: list[Event],
 ) -> list[Event]:
   """Rearrange the async function_response events in the history."""
-
   function_call_id_to_response_events_index: dict[str, int] = {}
   for i, event in enumerate(events):
     function_responses = event.get_function_responses()
@@ -117,6 +116,9 @@ def _rearrange_events_for_async_function_responses_in_history(
         function_call_id = function_response.id
         function_call_id_to_response_events_index[function_call_id] = i
 
+  if not function_call_id_to_response_events_index:
+    return events
+
   result_events: list[Event] = []
   for event in events:
     if event.get_function_responses():

src/google/adk/models/anthropic_llm.py

@@ -553,11 +553,14 @@ async def generate_content_async(
         else NOT_GIVEN
     )
     thinking = _build_anthropic_thinking_param(llm_request.config)
+    system = NOT_GIVEN
+    if llm_request.config.system_instruction is not None:
+      system = llm_request.config.system_instruction
 
     if not stream:
       message = await self._anthropic_client.messages.create(
           model=model_to_use,
-          system=llm_request.config.system_instruction,
+          system=system,
           messages=messages,
           tools=tools,
           tool_choice=tool_choice,
@@ -567,14 +570,15 @@ async def generate_content_async(
       yield message_to_generate_content_response(message)
     else:
       async for response in self._generate_content_streaming(
-          llm_request, messages, tools, tool_choice, thinking
+          llm_request, messages, system, tools, tool_choice, thinking
       ):
         yield response
 
   async def _generate_content_streaming(
       self,
       llm_request: LlmRequest,
       messages: list[anthropic_types.MessageParam],
+      system: Union[str, types.Content, NotGiven],
       tools: Union[Iterable[anthropic_types.ToolUnionParam], NotGiven],
       tool_choice: Union[anthropic_types.ToolChoiceParam, NotGiven],
       thinking: Union[
@@ -591,7 +595,7 @@ async def _generate_content_streaming(
     model_to_use = self._resolve_model_name(llm_request.model)
     raw_stream = await self._anthropic_client.messages.create(
         model=model_to_use,
-        system=llm_request.config.system_instruction,
+        system=system,
         messages=messages,
         tools=tools,
         tool_choice=tool_choice,

tests/unittests/a2a/executor/test_a2a_agent_executor.py

@@ -1072,3 +1072,79 @@ async def mock_run_async(**kwargs):
     assert (
         modified_a2a_event in enqueued_events
     ), "The modified event should have been enqueued"
+
+  @pytest.mark.asyncio
+  async def test_handle_request_preserves_metadata_in_final_events(
+      self,
+  ) -> None:
+    """Test that final events preserve invocation_id, author, and event_id in metadata."""
+    # Setup context with task_id
+    self.mock_context.task_id = "test-task-id"
+    self.mock_context.context_id = "test-context-id"
+
+    # Setup detailed mocks
+    self.mock_request_converter.return_value = AgentRunRequest(
+        user_id="test-user",
+        session_id="test-session",
+        new_message=Mock(spec=Content),
+        run_config=Mock(spec=RunConfig),
+    )
+
+    # Mock session service
+    mock_session = Mock()
+    mock_session.id = "test-session"
+    self.mock_runner.session_service.get_session = AsyncMock(
+        return_value=mock_session
+    )
+
+    # Mock invocation context
+    mock_invocation_context = Mock()
+    self.mock_runner._new_invocation_context.return_value = (
+        mock_invocation_context
+    )
+
+    # Mock ADK event with specific metadata to preserve
+    mock_adk_event = Mock(spec=Event)
+    mock_adk_event.invocation_id = "test-invocation-id"
+    mock_adk_event.author = "test-author"
+    mock_adk_event.id = "test-event-id"
+
+    # Configure run_async to yield our mock ADK event
+    async def mock_run_async(**kwargs):
+      async for item in self._create_async_generator([mock_adk_event]):
+        yield item
+
+    self.mock_runner.run_async = mock_run_async
+    self.mock_event_converter.return_value = [Mock()]
+
+    with patch(
+        "google.adk.a2a.executor.a2a_agent_executor.TaskResultAggregator"
+    ) as mock_aggregator_class:
+      mock_aggregator = Mock()
+      mock_aggregator.task_state = TaskState.completed
+      mock_aggregator.task_status_message = Mock(spec=Message)
+      mock_aggregator_class.return_value = mock_aggregator
+
+      # Execute
+      await self.executor._handle_request(
+          self.mock_context, self.mock_event_queue
+      )
+
+      # Verify final status event was published and has correct metadata
+      final_events = [
+          call[0][0]
+          for call in self.mock_event_queue.enqueue_event.call_args_list
+          if hasattr(call[0][0], "final") and call[0][0].final == True
+      ]
+      assert len(final_events) >= 1
+      final_event = final_events[-1]
+
+      assert final_event.metadata is not None
+      assert (
+          final_event.metadata.get("adk_invocation_id") == "test-invocation-id"
+      )
+      assert final_event.metadata.get("adk_author") == "test-author"
+      assert final_event.metadata.get("adk_event_id") == "test-event-id"
+      assert final_event.metadata.get("adk_app_name") == "test-app"
+      assert final_event.metadata.get("adk_user_id") == "test-user"
+      assert final_event.metadata.get("adk_session_id") == "test-session"