fix(models): stop a content-free thought signature from wedging a session

A part carrying only a `thought_signature` matched no branch in
`_part_to_message_block` and raised NotImplementedError. The part stays in
session history, so every later turn raised again and the session was
permanently dead.

Such a signature comes from another model, which Claude cannot verify, and the
part carries no content, so it is now dropped. A turn left with no blocks at
all is omitted rather than sent as an empty message, which Anthropic rejects.
Parts whose signature rides along with real content are unaffected.

PiperOrigin-RevId: 978081482

Author: google-genai-bot

src/google/adk/models/anthropic_llm.py

@@ -339,6 +339,34 @@ def _is_pdf_part(part: types.Part) -> bool:
   )
 
 
+# The fields that mean a part carries something to send. The rest of a Part is
+# annotation -- `part_metadata`, `video_metadata`, `media_resolution` and the
+# like -- and ADK's own A2A converter sets some of them, so asking "is anything
+# else set?" would leave the part in place and the session wedged.
+_PART_CONTENT_FIELDS = (
+    "audio_transcription",
+    "code_execution_result",
+    "executable_code",
+    "file_data",
+    "function_call",
+    "function_response",
+    "inline_data",
+    "tool_call",
+    "tool_response",
+)
+
+
+def _is_content_free_signature(part: types.Part) -> bool:
+  """Whether a part is a thought signature with nothing to send beside it.
+
+  A part that still has its `thought` flag is redacted thinking Claude issued
+  itself, and the branches in `_part_to_message_block` handle it.
+  """
+  if not part.thought_signature or part.thought or part.text:
+    return False
+  return not any(getattr(part, f, None) for f in _PART_CONTENT_FIELDS)
+
+
 def _normalize_image_media_type(mime_type: str) -> _ImageMediaType:
   normalized = mime_type.split(";", 1)[0].strip().lower()
   if normalized not in _ANTHROPIC_IMAGE_MEDIA_TYPES:
@@ -578,6 +606,12 @@ def _content_to_message_param(
       logger.warning("PDF data is not supported in Claude for assistant turns.")
       continue
 
+    # A signature with nothing to send beside it: there is no block to build
+    # from it, and it used to raise and wedge the session for good.
+    if _is_content_free_signature(part):
+      logger.warning("Dropping a thought signature from another model.")
+      continue
+
     message_block.append(_part_to_message_block(part, sanitizer))
 
   return {
@@ -995,9 +1029,17 @@ async def generate_content_async(
       self, llm_request: LlmRequest, stream: bool = False
   ) -> AsyncGenerator[LlmResponse, None]:
     sanitizer = _ToolUseIdSanitizer()
+    # A turn whose parts are all dropped above leaves no blocks behind, and
+    # Anthropic rejects a message with empty content. Sending one re-wedges the
+    # session exactly as the NotImplementedError did: the offending part stays
+    # in history, so every later turn fails the same way.
     messages = [
-        _content_to_message_param(content, sanitizer)
-        for content in llm_request.contents or []
+        message
+        for message in (
+            _content_to_message_param(content, sanitizer)
+            for content in llm_request.contents or []
+        )
+        if message["content"]
     ]
     tools: Iterable[anthropic_types.ToolUnionParam] | NotGiven = NOT_GIVEN
     function_declarations: list[types.FunctionDeclaration] = []

tests/unittests/models/test_anthropic_llm.py

@@ -1859,6 +1859,83 @@ def test_content_block_to_part_redacted_thinking():
   assert part.thought_signature == b"redacted_data"
 
 
+def test_content_to_message_param_drops_content_free_signature():
+  """A signature with no content of its own used to wedge the session.
+
+  It matched no branch in `_part_to_message_block`, so the turn raised
+  NotImplementedError. The part stays in session history, so every later turn
+  raised again and the session was dead for good. It came from another model,
+  carries nothing, and Claude cannot verify it, so it is dropped.
+  """
+  from google.adk.models.anthropic_llm import content_to_message_param
+
+  content = types.Content(
+      role="model",
+      parts=[
+          types.Part(text="", thought_signature=b"\x01\x8f=k_\xae@L"),  # binary
+          types.Part(thought_signature=b"AY89a18D"),  # and one that is text
+          types.Part(text="hello"),
+      ],
+  )
+
+  message = content_to_message_param(content)
+
+  assert [block["type"] for block in message["content"]] == ["text"]
+
+
+@pytest.mark.asyncio
+async def test_turn_of_only_dropped_parts_is_not_sent_as_empty_message():
+  """A turn that is nothing but a foreign signature must not become `content: []`.
+
+  Dropping the part is right -- there is nothing Claude can be given -- but
+  emitting the message anyway trades NotImplementedError for a 400 that
+  repeats on every later turn, which is the same permanent wedge.
+  """
+  request = _cache_test_request(
+      contents=[
+          Content(role="user", parts=[Part.from_text(text="Question")]),
+          Content(
+              role="model",
+              parts=[types.Part(thought_signature=b"\x01\x8f=k_")],
+          ),
+      ]
+  )
+
+  kwargs = await _sent_anthropic_kwargs(request)
+
+  assert all(m["content"] for m in kwargs["messages"])
+  assert [m["role"] for m in kwargs["messages"]] == ["user"]
+
+
+def test_content_to_message_param_keeps_signature_on_real_content():
+  """A signature riding along with content must not take the part with it."""
+  from google.adk.models.anthropic_llm import content_to_message_param
+
+  content = types.Content(
+      role="model",
+      parts=[
+          types.Part(
+              function_call=types.FunctionCall(id="c1", name="do_it", args={}),
+              thought_signature=b"\x01\x8f=k_",
+          ),
+          types.Part(text="hi", thought=True, thought_signature=b"sig"),
+          # Claude's own redacted thinking: no content, but the flag is intact,
+          # so it must be sent back rather than dropped.
+          types.Part(thought=True, thought_signature=b"opaque"),
+          # An annotation is not content, so this one still goes.
+          types.Part(thought_signature=b"gone", part_metadata={"a": 1}),
+      ],
+  )
+
+  message = content_to_message_param(content)
+
+  assert [block["type"] for block in message["content"]] == [
+      "tool_use",
+      "thinking",
+      "redacted_thinking",
+  ]
+
+
 def test_message_to_generate_content_response_with_thinking():
   """Message with ThinkingBlock + TextBlock yields both parts."""
   from google.adk.models.anthropic_llm import message_to_generate_content_response
@@ -3906,7 +3983,11 @@ async def test_cache_breakpoint_skips_a_reasoning_block(
 
 @pytest.mark.asyncio
 async def test_cache_breakpoint_skips_a_turn_left_with_no_blocks():
-  """An assistant turn holding only an image is dropped, so it cannot carry one."""
+  """An assistant turn holding only an image is dropped, so it cannot carry one.
+
+  It used to be sent as a message with empty content, which Anthropic rejects;
+  the turn is now left out of the request entirely.
+  """
   request = _cache_test_request(
       contents=[
           Content(role="user", parts=[Part.from_text(text="Question")]),
@@ -3921,7 +4002,8 @@ async def test_cache_breakpoint_skips_a_turn_left_with_no_blocks():
 
   kwargs = await _sent_anthropic_kwargs(request)
 
-  assert kwargs["messages"][-1]["content"] == []
+  assert [m["role"] for m in kwargs["messages"]] == ["user"]
+  assert all(m["content"] for m in kwargs["messages"])
   assert _breakpoints(kwargs) == {
       "system[0]": _EPHEMERAL,
       "tools[1]": _EPHEMERAL,