Claude's current models can reason before they answer. With adaptive thinking (thinking: {"type": "adaptive"} — the recommended mode on Opus 4.8/4.7/4.6, Sonnet 5, and Sonnet 4.6, and the only mode on Claude Fable 5), the model decides per request whether and how much to deliberate. In a streamed response, that deliberation is not invisible plumbing: it occupies its own content block, with its own delta types, arriving before the text your users are waiting for. If your streaming consumer only knows about text_delta, thinking models will confuse it.
The thinking block's event sequence
Streaming responses deliver each content block as a content_block_start, one or more content_block_delta events, and a content_block_stop. For a thinking block, two delta types are involved:
| Delta type | Carries | When |
|---|---|---|
thinking_delta | The thinking text itself, incrementally | Throughout the block (when thinking is displayed) |
signature_delta | A cryptographic signature over the thinking block | Once, just before content_block_stop |
The signature matters even if you never show thinking to anyone: thinking blocks must be passed back to the API exactly as received when you continue the conversation (for example, when returning tool results), and the signature is part of that block. Accumulate it like any other field. Modifying, reordering, or filtering thinking blocks in the latest assistant turn before resending returns a 400 error.
What display: "omitted" changes
The thinking.display parameter accepts "summarized" or "omitted", and its streaming behavior is documented precisely: with display: "omitted", no thinking_delta events are sent at all — the thinking block opens, receives a single signature_delta, and closes. The full reasoning still happens on Anthropic's side; the stream just stops narrating it. Defaults are model-specific: omitted on Fable 5, Sonnet 5, Opus 4.8, and Opus 4.7; summarized on Opus 4.6 and Sonnet 4.6. The signature field is identical either way, switching values between turns is supported, and display is invalid when thinking is disabled.
Anthropic documents the latency effect directly: omitted display gives faster time-to-first-text-token when streaming — there's no thinking narration to deliver before visible output begins. But note what it doesn't change:
display: "omitted" you are still charged for the full thinking tokens generated. Omitting reduces latency and payload, not cost. The same is true of summarized display — you're billed for the thinking actually generated, not the summary shown, which is also why billed output counts won't match the tokens you can see. The authoritative number is usage.output_tokens, with usage.output_tokens_details.thinking_tokens breaking out the reasoning share.Designing the wait
Whichever display mode you choose, your stream consumer should expect a potentially long, mostly-silent opening act: with omitted display there are no deltas between the thinking block's start and its signature, and only ping events keep the wire warm (see ping events — this is exactly the quiet stretch that untuned proxies kill). A few practical consequences:
Anchor "the model is working" on block starts, not text. A content_block_start for a thinking block is your earliest reliable signal that generation is underway. UIs that show nothing until the first text_delta look hung on hard prompts.
Choose display mode by audience. Summarized thinking gives end users a progress narrative; omitted gives the fastest path to the answer and less to transport and store. Since the parameter can change per request, interactive surfaces and batch pipelines can make different choices against the same conversation history.
Remember effort shapes the wait. In adaptive mode at the default effort (high) the model almost always thinks; at lower effort it may skip thinking entirely for simple queries, collapsing this whole sequence. Latency tuning therefore spans two knobs — display for what streams, effort for how much deliberation happens at all.
Where to go next
For the full event vocabulary see streaming event types; for thinking-token budgeting and the truncation trap, thinking tokens and the max_tokens ceiling; for the feature itself, extended thinking.