fix(models): preserve empty Anthropic thinking blocks

[Shay-Deng]

Description

Related to #7480, item 3 (empty thinking blocks).

When Claude returns a signed thinking block with an empty string, AnthropicLlm converts it back into a redacted_thinking block on the next request and uses the signature as the encrypted data. This changes the model history that should be preserved.

Distinguish an empty string from missing text when serializing thought parts. Empty and nonempty thinking blocks keep their original type, text, and signature; genuine redacted blocks, whose text is None, retain their existing representation. This patch does not address the separate sub-agent isolation and date serialization reports in #7480.

Testing Plan

• Extended the existing conversion and streaming-signature tests to cover empty thinking text and streams containing only a signature delta. Both new cases fail against unchanged main, with 173 existing tests passing. With the fix, pytest tests/unittests/models/test_anthropic_llm.py passes all 175 tests.
• Full unit suites through tox passed on Python 3.11, 3.12, 3.13, and 3.14 (macOS ARM64). Python 3.11: 18,394 passed / 89 skipped / 22 xfailed / 2 xpassed. Each of Python 3.12–3.14: 18,385 passed / 90 skipped / 22 xfailed / 2 xpassed. Every completed environment exited successfully. The lancedb installation exclusion matches repository CI; no unit tests were filtered out. The environments ran separately with one or two pytest workers to fit local memory.
• Changed-file pre-commit checks: passed.
• Built the sdist and wheel, installed the wheel into a fresh environment, and ran the offline Runner reproduction below successfully.

The E2E check uses real Runner, AnthropicLlm, AsyncAnthropic and an HTTP MockTransport, without a live model or real API credentials. One tool call produces two requests and three serialized Runner events; the second request must retain the exact signed thinking block and tool block order.

Before:

Outgoing assistant blocks: [{"data": "signed-empty-block", "type": "redacted_thinking"}, ...]
AssertionError: The second request changed the signed thinking block

After (source checkout and installed wheel):

HTTP requests: 2; actual tool executions: 1
Serialized Runner events: 3; final text: done
Outgoing assistant blocks: [{"signature": "signed-empty-block", "thinking": "", "type": "thinking"}, {"id": "toolu_clock", "input": {}, "name": "clock", "type": "tool_use"}]
PASS: empty thinking type, text, signature, and tool block order preserved

Offline Runner reproduction

Validated using Python 3.12.14, anthropic 1.13.0 and google-genai 2.29.0. Save the script below as reproduce_empty_thinking.py. In a fresh environment, run these commands from the repository root:

python -m pip install -e . "anthropic==1.13.0" "google-genai==2.29.0"
python reproduce_empty_thinking.py

To check the built wheel, replace -e . with dist/google_adk-2.11.0-py3-none-any.whl in the install command. The pinned Anthropic SDK provides the httpx2 transport used by this reproduction.

"""Offline Runner regression for ADK #7480, item 3 (empty thinking only).

The real Anthropic client uses a mock HTTP transport; no network or API key is
required. Run with the ADK checkout installed into the Python environment.
"""

import asyncio
import json

import httpx2
from anthropic import AsyncAnthropic
from google.adk.agents import LlmAgent
from google.adk.models.anthropic_llm import AnthropicLlm
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types


async def main():
    requests = []
    tool_calls = []
    model_reply = [
        {"type": "thinking", "thinking": "", "signature": "signed-empty-block"},
        {"type": "tool_use", "id": "toolu_clock", "name": "clock", "input": {}},
    ]

    async def respond(request):
        body = json.loads(request.content)
        requests.append(body)
        if len(requests) == 1:
            content, stop_reason = model_reply, "tool_use"
        elif len(requests) == 2:
            content, stop_reason = [{"type": "text", "text": "done"}], "end_turn"
        else:
            raise AssertionError("The Runner made an unexpected third request")
        return httpx2.Response(200, json={
            "id": f"msg_{len(requests)}",
            "type": "message",
            "role": "assistant",
            "model": body["model"],
            "content": content,
            "stop_reason": stop_reason,
            "stop_sequence": None,
            "usage": {"input_tokens": 1, "output_tokens": 1},
        })

    def clock() -> dict:
        """Return the current time."""
        tool_calls.append("clock")
        return {"time": "noon"}

    client = AsyncAnthropic(
        api_key="unused-offline-test-key",
        max_retries=0,
        http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(respond)),
    )
    model = AnthropicLlm(model="claude-sonnet-4-6", client=client)
    agent = LlmAgent(name="root", model=model, instruction="Call clock.", tools=[clock])
    sessions = InMemorySessionService()
    runner = Runner(app_name="empty_thinking", agent=agent, session_service=sessions)
    events = []
    try:
        await sessions.create_session(app_name="empty_thinking", user_id="u", session_id="s")
        async for event in runner.run_async(
            user_id="u",
            session_id="s",
            new_message=types.Content(role="user", parts=[types.Part(text="Hi")]),
        ):
            event.model_dump_json()
            events.append(event)
    finally:
        await runner.close()
        await client.close()

    assert len(requests) == 2, len(requests)
    assert tool_calls == ["clock"], tool_calls
    second_messages = requests[1]["messages"]
    assert second_messages[:len(requests[0]["messages"])] == requests[0]["messages"]
    assistant = second_messages[len(requests[0]["messages"])]
    tool_response = second_messages[-1]
    assert tool_response["role"] == "user", tool_response
    assert tool_response["content"][0]["type"] == "tool_result", tool_response
    assert tool_response["content"][0]["tool_use_id"] == "toolu_clock", tool_response
    final_text = "".join(
        part.text or "" for part in events[-1].content.parts if not part.thought
    )
    assert final_text == "done", final_text
    print(f"HTTP requests: {len(requests)}; actual tool executions: {len(tool_calls)}")
    print(f"Serialized Runner events: {len(events)}; final text: {final_text}")
    print("Incoming assistant blocks:", json.dumps(model_reply, sort_keys=True))
    print("Outgoing assistant blocks:", json.dumps(assistant["content"], sort_keys=True))
    expected = {"role": "assistant", "content": model_reply}
    assert assistant == expected, "The second request changed the signed thinking block"
    print("PASS: empty thinking type, text, signature, and tool block order preserved")


if __name__ == "__main__":
    asyncio.run(main())

AI assistance was used for investigation, implementation, and testing.

[google-cla]

Thanks for your pull request! It looks like this may be your first contribution to a Google open source project. Before we can look at your pull request, you'll need to sign a Contributor License Agreement (CLA).

View this failed invocation of the CLA check for more information.

For the most up to date status, view the checks section at the bottom of the pull request.