fix(models): capture Anthropic thinking-block signatures during streaming

When streaming a Claude response with extended thinking enabled,
`AnthropicLlm.generate_content_async` consumed `thinking_delta` and `text_delta`
content-block deltas but ignored `signature_delta`. The aggregated thinking
`Part` was therefore assembled without its `thought_signature`.

On a follow-up request within the same turn (for example, after a tool call),
that signature-less thinking block cannot be serialized back into a valid
Anthropic `thinking` block, breaking multi-step (tool-calling) turns when
streaming is enabled. The non-streaming path is unaffected because it already
captures the signature via `content_block_to_part`.

Handle `SignatureDelta` in the streaming content-block-delta loop so the
signature is accumulated and attached to the aggregated thinking `Part`,
matching the non-streaming path. Extended-thinking + tool-use turns now
round-trip correctly under streaming.

Adds a regression test asserting that a streamed `signature_delta` lands on the
final thinking part and round-trips to a valid Anthropic thinking block.

Co-authored-by: Vishwa Murugan <vishwamurugan@google.com>
PiperOrigin-RevId: 952256615

Author: vishwa180

src/google/adk/models/anthropic_llm.py

@@ -829,6 +829,20 @@ async def _generate_content_streaming(
               ),
               partial=True,
           )
+        elif isinstance(delta, anthropic_types.SignatureDelta):
+          # Claude streams the thinking block's cryptographic signature as a
+          # separate delta near the end of the block. Accumulate it so the
+          # aggregated thinking Part below carries ``thought_signature``.
+          # Without it the reasoning block cannot round-trip back to Claude on
+          # the next request -- extended thinking + tool use requires echoing
+          # the signed thinking blocks, and re-serializing history for the
+          # follow-up call would otherwise fail. Not surfaced as a partial (the
+          # signature is opaque, not user-visible text).
+          thinking_blocks.setdefault(
+              event.index,
+              _ThinkingAccumulator(thinking="", signature=""),
+          )
+          thinking_blocks[event.index].signature += delta.signature
         elif isinstance(delta, anthropic_types.TextDelta):
           text_blocks.setdefault(event.index, "")
           text_blocks[event.index] += delta.text

tests/unittests/models/test_anthropic_llm.py

@@ -1919,6 +1919,83 @@ async def test_streaming_thinking_yields_partial_and_final():
   assert final.usage_metadata.candidates_token_count == 10
 
 
+@pytest.mark.asyncio
+async def test_streaming_thinking_captures_signature_delta():
+  """A streamed signature_delta must land on the final thinking Part.
+
+  Without this the aggregated thinking Part has no ``thought_signature`` and
+  cannot round-trip back to Claude on the follow-up request after a tool call
+  (extended thinking + tool use), which raises when re-serializing history.
+  """
+  llm = AnthropicLlm(model="claude-sonnet-4-20250514")
+
+  events = [
+      MagicMock(
+          type="message_start",
+          message=MagicMock(usage=MagicMock(input_tokens=15, output_tokens=0)),
+      ),
+      MagicMock(
+          type="content_block_start",
+          index=0,
+          content_block=anthropic_types.ThinkingBlock(
+              thinking="", signature="", type="thinking"
+          ),
+      ),
+      MagicMock(
+          type="content_block_delta",
+          index=0,
+          delta=anthropic_types.ThinkingDelta(
+              thinking="Reason.", type="thinking_delta"
+          ),
+      ),
+      MagicMock(
+          type="content_block_delta",
+          index=0,
+          delta=anthropic_types.SignatureDelta(
+              signature="sig_stream_123", type="signature_delta"
+          ),
+      ),
+      MagicMock(type="content_block_stop", index=0),
+      MagicMock(
+          type="message_delta",
+          delta=MagicMock(stop_reason="end_turn"),
+          usage=MagicMock(output_tokens=5),
+      ),
+      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="What?")])],
+      config=types.GenerateContentConfig(
+          thinking_config=types.ThinkingConfig(thinking_budget=5000),
+      ),
+  )
+
+  with mock.patch.object(llm, "_anthropic_client", mock_client):
+    responses = [
+        r async for r in llm.generate_content_async(request, stream=True)
+    ]
+
+  final = responses[-1]
+  assert not final.partial
+  thinking_part = final.content.parts[0]
+  assert thinking_part.thought
+  assert thinking_part.text == "Reason."
+  assert thinking_part.thought_signature == b"sig_stream_123"
+
+  # The aggregated Part must round-trip back to a valid Anthropic thinking
+  # block -- this is exactly what fails today (missing signature) on a
+  # tool-call turn.
+  block = part_to_message_block(thinking_part)
+  assert block["type"] == "thinking"
+  assert block["signature"] == "sig_stream_123"
+
+
 @pytest.mark.asyncio
 async def test_streaming_passes_thinking_param():
   """When thinking_config is set and stream=True, thinking kwarg is passed."""