fix: preserve function call IDs for Anthropic models

Function call IDs are now preserved during session replay for Anthropic
models, matching the behavior of Gemini models using the interactions API.

Co-authored-by: George Weale <gweale@google.com>
PiperOrigin-RevId: 905250493

Author: GWeale

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

@@ -47,10 +47,22 @@ async def run_async(
     preserve_function_call_ids = False
     if hasattr(agent, 'canonical_model'):
       canonical_model = agent.canonical_model
-      preserve_function_call_ids = (
+      if (
           isinstance(canonical_model, Gemini)
           and canonical_model.use_interactions_api
-      )
+      ):
+        preserve_function_call_ids = True
+      else:
+        # Anthropic pairs tool_use/tool_result by id, so `adk-*` fallback
+        # ids must survive replay.
+        try:
+          from ...models.anthropic_llm import AnthropicLlm
+        except ImportError:
+          AnthropicLlm = None
+        if AnthropicLlm is not None and isinstance(
+            canonical_model, AnthropicLlm
+        ):
+          preserve_function_call_ids = True
 
     # Preserve all contents that were added by instruction processor
     # (since llm_request.contents will be completely reassigned below)

tests/unittests/flows/llm_flows/test_contents.py

@@ -1070,6 +1070,80 @@ async def test_adk_function_call_ids_preserved_for_interactions_model():
   assert user_fr_part.function_response.id == function_call_id
 
 
+@pytest.mark.asyncio
+async def test_adk_function_call_ids_preserved_for_anthropic_model():
+  """Anthropic ids must round-trip through replay so Claude can match
+  tool_use blocks with their tool_result blocks (issue #5074).
+  """
+  from google.adk.models.anthropic_llm import AnthropicLlm
+
+  agent = Agent(
+      model=AnthropicLlm(model="claude-sonnet-4-20250514"),
+      name="test_agent",
+  )
+  llm_request = LlmRequest(model="claude-sonnet-4-20250514")
+  invocation_context = await testing_utils.create_invocation_context(
+      agent=agent
+  )
+
+  # ADK fallback ids look like ``adk-<uuid>`` and would previously be
+  # stripped to None for non-Gemini models on the replay path.
+  function_call_id = "adk-test-call-id"
+  events = [
+      Event(
+          invocation_id="inv1",
+          author="user",
+          content=types.UserContent("Call the tool"),
+      ),
+      Event(
+          invocation_id="inv2",
+          author="test_agent",
+          content=types.Content(
+              role="model",
+              parts=[
+                  types.Part(
+                      function_call=types.FunctionCall(
+                          id=function_call_id,
+                          name="test_tool",
+                          args={"x": 1},
+                      )
+                  )
+              ],
+          ),
+      ),
+      Event(
+          invocation_id="inv3",
+          author="test_agent",
+          content=types.Content(
+              role="user",
+              parts=[
+                  types.Part(
+                      function_response=types.FunctionResponse(
+                          id=function_call_id,
+                          name="test_tool",
+                          response={"result": 2},
+                      )
+                  )
+              ],
+          ),
+      ),
+  ]
+  invocation_context.session.events = events
+
+  async for _ in contents.request_processor.run_async(
+      invocation_context, llm_request
+  ):
+    pass
+
+  model_fc_part = llm_request.contents[1].parts[0]
+  assert model_fc_part.function_call is not None
+  assert model_fc_part.function_call.id == function_call_id
+
+  user_fr_part = llm_request.contents[2].parts[0]
+  assert user_fr_part.function_response is not None
+  assert user_fr_part.function_response.id == function_call_id
+
+
 def test_is_other_agent_reply_live_session():
   """Test _is_other_agent_reply when live_session_id is present."""
   event = Event(author="another_agent", live_session_id="session_123")

tests/unittests/models/test_anthropic_llm.py

@@ -1350,3 +1350,54 @@ async def test_non_streaming_does_not_pass_stream_param():
   mock_client.messages.create.assert_called_once()
   _, kwargs = mock_client.messages.create.call_args
   assert "stream" not in kwargs
+
+
+def test_part_to_message_block_function_call_preserves_valid_id():
+  """Valid Anthropic ids must round-trip byte-for-byte."""
+  part = types.Part.from_function_call(name="test_tool", args={"k": "v"})
+  part.function_call.id = "toolu_01abc"
+
+  result = part_to_message_block(part)
+
+  assert result["id"] == "toolu_01abc"
+
+
+def test_part_to_message_block_function_response_preserves_valid_id():
+  """function_response ids must round-trip byte-for-byte to tool_use_id."""
+  part = types.Part.from_function_response(
+      name="test_tool", response={"result": "ok"}
+  )
+  part.function_response.id = "toolu_01abc"
+
+  result = part_to_message_block(part)
+
+  assert result["tool_use_id"] == "toolu_01abc"
+
+
+def test_part_to_message_block_preserves_adk_fallback_id():
+  """ADK-generated ``adk-<uuid>`` ids match Anthropic's regex and round-trip.
+
+  This is the path exercised by the contents.py fix: when Vertex Claude
+  returns id=None, ``populate_client_function_call_id`` writes ``adk-<uuid>``,
+  and contents.py preserves it through replay. ``part_to_message_block`` must
+  pass it through to Anthropic unchanged so call/response stay paired.
+  """
+  call_part = types.Part.from_function_call(name="t", args={"a": 1})
+  call_part.function_call.id = "adk-12345678-1234-1234-1234-123456789012"
+  response_part = types.Part.from_function_response(
+      name="t", response={"result": "ok"}
+  )
+  response_part.function_response.id = (
+      "adk-12345678-1234-1234-1234-123456789012"
+  )
+
+  call_result = part_to_message_block(call_part)
+  response_result = part_to_message_block(response_part)
+
+  assert call_result["id"] == "adk-12345678-1234-1234-1234-123456789012"
+  assert (
+      response_result["tool_use_id"]
+      == "adk-12345678-1234-1234-1234-123456789012"
+  )
+  # The pair must remain matched after conversion.
+  assert call_result["id"] == response_result["tool_use_id"]