Merge branch 'main' into codex/artifact-ref-scope

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
    ```
 

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/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"

tests/unittests/flows/llm_flows/test_contents.py

@@ -1306,3 +1306,37 @@ def test_get_contents_live_history_rebuild():
 
   assert result[1].role == "user"
   assert "returned result" in result[1].parts[1].text
+
+
+def test_rearrange_async_function_responses_early_returns_when_no_responses():
+  """Rearrangement is a no-op when no event carries function_responses."""
+  events = [
+      Event(
+          invocation_id="inv1",
+          author="user",
+          content=types.UserContent("hi"),
+      ),
+      Event(
+          invocation_id="inv2",
+          author="test_agent",
+          content=types.ModelContent("hello"),
+      ),
+      Event(
+          invocation_id="inv3",
+          author="test_agent",
+          content=types.Content(
+              role="model",
+              parts=[
+                  types.Part(
+                      function_call=types.FunctionCall(
+                          id="adk-1", name="tool", args={}
+                      )
+                  )
+              ],
+          ),
+      ),
+  ]
+  result = contents._rearrange_events_for_async_function_responses_in_history(  # pylint: disable=protected-access
+      events
+  )
+  assert result is events

tests/unittests/models/test_anthropic_llm.py

@@ -21,6 +21,7 @@
 from unittest.mock import AsyncMock
 from unittest.mock import MagicMock
 
+from anthropic import NOT_GIVEN
 from anthropic import types as anthropic_types
 from google.adk import version as adk_version
 from google.adk.models import anthropic_llm
@@ -2134,3 +2135,93 @@ async def test_generate_content_async_pairs_invalid_tool_ids(
   ]
   assert len(set(use_ids)) == expected_unique
   assert set(use_ids) == set(result_ids)
+
+
+@pytest.mark.asyncio
+async def test_non_streaming_no_system_instruction_passes_not_given():
+  """system=NOT_GIVEN when LlmRequest has no system_instruction."""
+  llm = AnthropicLlm(model="claude-sonnet-4-20250514")
+
+  mock_message = anthropic_types.Message(
+      id="msg_test",
+      content=[
+          anthropic_types.TextBlock(text="ok", type="text", citations=None)
+      ],
+      model="claude-sonnet-4-20250514",
+      role="assistant",
+      stop_reason="end_turn",
+      stop_sequence=None,
+      type="message",
+      usage=anthropic_types.Usage(
+          input_tokens=1,
+          output_tokens=1,
+          cache_creation_input_tokens=0,
+          cache_read_input_tokens=0,
+          server_tool_use=None,
+          service_tier=None,
+      ),
+  )
+
+  mock_client = MagicMock()
+  mock_client.messages.create = AsyncMock(return_value=mock_message)
+
+  request = LlmRequest(
+      model="claude-sonnet-4-20250514",
+      contents=[Content(role="user", parts=[Part.from_text(text="Hi")])],
+  )
+  assert request.config.system_instruction is None
+
+  with mock.patch.object(llm, "_anthropic_client", mock_client):
+    _ = [r async for r in llm.generate_content_async(request, stream=False)]
+
+  mock_client.messages.create.assert_called_once()
+  _, kwargs = mock_client.messages.create.call_args
+  assert kwargs["system"] is NOT_GIVEN
+
+
+@pytest.mark.asyncio
+async def test_streaming_no_system_instruction_passes_not_given():
+  """system=NOT_GIVEN on the streaming path when no system_instruction."""
+  llm = AnthropicLlm(model="claude-sonnet-4-20250514")
+
+  events = [
+      MagicMock(
+          type="message_start",
+          message=MagicMock(usage=MagicMock(input_tokens=1, output_tokens=0)),
+      ),
+      MagicMock(
+          type="content_block_start",
+          index=0,
+          content_block=anthropic_types.TextBlock(text="", type="text"),
+      ),
+      MagicMock(
+          type="content_block_delta",
+          index=0,
+          delta=anthropic_types.TextDelta(text="ok", type="text_delta"),
+      ),
+      MagicMock(type="content_block_stop", index=0),
+      MagicMock(
+          type="message_delta",
+          delta=MagicMock(stop_reason="end_turn"),
+          usage=MagicMock(output_tokens=1),
+      ),
+      MagicMock(type="message_stop"),
+  ]
+
+  mock_client = MagicMock()
+  mock_client.messages.create = AsyncMock(
+      return_value=_make_mock_stream_events(events)
+  )
+
+  request = LlmRequest(
+      model="claude-sonnet-4-20250514",
+      contents=[Content(role="user", parts=[Part.from_text(text="Hi")])],
+  )
+  assert request.config.system_instruction is None
+
+  with mock.patch.object(llm, "_anthropic_client", mock_client):
+    _ = [r async for r in llm.generate_content_async(request, stream=True)]
+
+  mock_client.messages.create.assert_called_once()
+  _, kwargs = mock_client.messages.create.call_args
+  assert kwargs["system"] is NOT_GIVEN