fix(streaming): stop stream_chunk_builder duplicating Anthropic thinking text

[vineethsaivs]

TLDR

Problem this solves:

• stream_chunk_builder() returns Anthropic extended-thinking reasoning twice over, so the rebuilt thinking_blocks[0]["thinking"] is the whole reasoning trace concatenated with itself
• reasoning_content on that same rebuilt response is correct, so the two fields disagree about what the model actually reasoned

How it solves it:

• Skip appending a thinking block's text when it arrives with a signature and is exactly what has already been accumulated, which is the shape the Anthropic iterator produces

Relevant issues

None open for this one. #33034 and its PR #33035 cover a different failure in the same function (thinking dropped when no signature ever arrives); this is orthogonal and the two touch different parts of the function, so they should not conflict beyond a trivial adjacency

Linear ticket

Pre-Submission checklist

Please complete all items before asking a LiteLLM maintainer to review your PR

• I have added meaningful tests
• My PR passes all CI/CD checks (e.g., lint, format, unit tests)
• My PR's scope is as isolated as possible; it only solves 1 specific problem
• I have received a Greptile Confidence Score of at least 4/5 before requesting a maintainer review (Greptile reviews automatically once the PR is opened; only comment @greptileai to re-request a review after pushing changes)

Screenshots / Proof of Fix

I could not produce the live-proxy curl output the template asks for, because I do not have an Anthropic key I am able to spend on this, so I want to be upfront about that rather than pass off a test run as proof. What follows is what I could verify offline, and below it are the exact commands to reproduce against a real key

The mechanism, driving the real ModelResponseIterator from litellm/llms/anthropic/chat/handler.py over the event sequence Anthropic sends for one thinking block, then handing the resulting chunks to ChunkProcessor:

=== normal turn, signature arrives
  expected thinking : 'Let me work through this step by step.'
  before            : 'Let me work through this step by step.Let me work through this step by step.'
  after             : 'Let me work through this step by step.'
  reasoning_content : 'Let me work through this step by step.'    (correct both ways)

Two separate signed thinking blocks in one turn stay separate and are each emitted once, before and after

To reproduce against a real key, with the proxy on localhost:4000 and a config exposing an Anthropic model with thinking enabled:

curl -sS http://localhost:4000/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
  -d '{
    "model": "claude-sonnet-4-5",
    "messages": [{"role": "user", "content": "What is 17 * 23? Think it through."}],
    "thinking": {"type": "enabled", "budget_tokens": 1024},
    "max_tokens": 2048,
    "stream": true,
    "stream_options": {"include_usage": true}
  }' > /dev/null

Then open http://localhost:4000/ui/?page=logs, click into that request, and compare the assembled response's thinking_blocks[0].thinking against reasoning_content. On litellm_internal_staging the first is the second repeated twice; with this PR they match

Type

Bug Fix

Changes

get_combined_thinking_content accumulates a block's text across chunks and flushes when a signature arrives. Anthropic streams a thinking block as N thinking_delta chunks followed by one signature_delta, and ModelResponseIterator._handle_content_block_delta builds that final chunk by joining every prior thinking delta:

signature = content_block["delta"].get("signature")
if isinstance(signature, str) and signature:
    thinking_blocks = [
        ChatCompletionThinkingBlock(
            type="thinking",
            thinking="".join(
                cast(str, block["delta"].get("thinking"))
                for block in self.content_blocks
                if isinstance(block["delta"].get("thinking"), str)
            ),
            signature=signature,
        )
    ]

So the signature chunk carries the block's whole text again rather than an increment, and appending it on top of the accumulated parts doubled the reasoning. The existing test for this function did not catch it because its fixture models the signature chunk as {"type": "thinking", "thinking": None, "signature": "sig_block1"}, which is not what the iterator emits

The guard is an exact-equality check, so it only suppresses a genuine repeat. A provider that sends the last increment alongside the signature still has that increment appended, which the second test pins

QA runbook

Beyond the curl above, worth exercising a turn that produces two separate thinking blocks and one that is cut short by max_tokens mid-thinking, since both go through this function. The truncated case still returns no thinking blocks, unchanged by this PR and left to #33035

Unit tests, tests/test_litellm/litellm_core_utils/test_streaming_chunk_builder_utils.py: 19 passed. With the fix reverted, test_get_combined_thinking_content_does_not_duplicate_resent_thinking fails and the other 18 pass. Mutating the guard so it always skips instead of skipping only exact repeats makes test_get_combined_thinking_content_keeps_a_genuine_final_increment fail and the other 18 pass, so each new test is killed by its own mutant and neither is decorative

Whole directory tests/test_litellm/litellm_core_utils/: 4 failed, 1400 passed. The same 4 fail on a clean tree with 1398 passed, so they are pre-existing (test_bedrock_converse_messages_pt_document_various_formats, test_bedrock_midstream_internal_server_error_wraps_for_fallback, test_blocks_ietf_protocol_assignments_old_oracle_metadata, test_logfire_logger_accepts_env_vars_for_base_url) and the delta is exactly the 2 tests added here

ruff 0.15.3 reports one unused-import error and one file needing reformat in these two files, both of which reproduce identically on a clean tree, so neither comes from this change. My longest added line is 99 characters

Final Attestation

• The tests check the right things, including the edge cases, and regressions in the respective real-world customer use-cases are not possible after this PR

[greptile-apps]

Registry misses bypass polling

When a cold data-plane worker returns the MCP endpoint's HTTP 404 server_not_found response, this status gate returns False before inspecting the structured error, causing await_call_tool and await_call_tool_denied to fail immediately instead of waiting for registry propagation.

[greptile-apps]

Continuous listing misses cold workers

When the load balancer routes every /v1/models poll to the same synchronized worker, this continuous-listing window succeeds even though another worker has not loaded the model, causing the next model request routed to that cold worker to fail with Invalid model name.

[greptile-apps]

Greptile Summary

This PR fixes duplicate signed thinking text during streamed-response reconstruction and also revises unrelated E2E synchronization helpers.

• Suppresses a signed thinking snapshot when it exactly matches the text already accumulated.
• Adds regression tests for resent snapshots and genuine final increments.
• Adds MCP tool-call polling and model-servability polling to the E2E harness.
• Adds per-request timeout overrides to E2E transports.

Confidence Score: 3/5

The streaming fix is sound, but both E2E synchronization helpers need correction before merging because they still release or fail callers during multi-worker propagation.

The MCP retry classifier rejects the endpoint's actual 404 registry-miss response, while the model-servability poll can repeatedly observe one hot worker and incorrectly conclude that all workers have loaded the model.

Files Needing Attention: tests/e2e/mcp/mcp_client.py, tests/e2e/proxy_client.py

Important Files Changed

Filename	Overview
litellm/litellm_core_utils/streaming_chunk_builder_utils.py	Correctly avoids appending Anthropic's repeated signed thinking snapshot while retaining distinct signed increments.
tests/test_litellm/litellm_core_utils/test_streaming_chunk_builder_utils.py	Adds focused coverage for snapshot deduplication and preservation of genuine final increments.
tests/e2e/mcp/mcp_client.py	Adds registry-lag polling, but the status gate prevents retrying the endpoint's HTTP 404 server-not-found response.
tests/e2e/proxy_client.py	Adds model-list polling whose continuous visibility window can observe only a hot worker and still release callers before every worker has synchronized.
tests/e2e/transport.py	Propagates an optional request-specific timeout through both HTTP and split transports.

_{Reviews (1): Last reviewed commit: "fix(streaming): stop stream_chunk_builde..." | Re-trigger Greptile}

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.

📢 Thoughts on this report? Let us know!

[codspeed-hq]

Merging this PR will not alter performance

✅ 31 untouched benchmarks

---

_{Comparing vineethsaivs:fix-thinking-block-duplication-stream-chunk-builder (eb30b9e) with litellm_internal_staging (c56e657)¹}

Footnotes

1. No successful run was found on litellm_internal_staging (bb76970) during the generation of this report, so c56e657 was used instead as the comparison base. There might be some changes unrelated to this pull request in this report. ↩