Does OpenCode send back all previous reasoning blocks to Claude (or any provider)?

[skerit]

Question

So I was under the impression that thinking blocks were ephemeral. That older thinking blocks are not used to generate a new response.

But I don't see any sort of "pruning" happening in the OpenCode code, so it seems as if the entire conversation with all the reasoning blocks gets sent back all the time?

Here's where the conversation gets made, right?

opencode/packages/opencode/src/session/prompt.ts

Lines 591 to 610 in ddd9c71

	const result = await processor.process({
	user: lastUser,
	agent,
	abort,
	sessionID,
	system: [...(await SystemPrompt.environment()), ...(await SystemPrompt.custom())],
	messages: [
	...MessageV2.toModelMessage(sessionMessages),
	...(isLastStep
	? [
	{
	role: "assistant" as const,
	content: MAX_STEPS,
	},
	]
	: []),
	],
	tools,
	model,
	})

And here is the explicit line in MessageV2.toModelMessage that includes reasoning blocks:

opencode/packages/opencode/src/session/message-v2.ts

Lines 537 to 544 in ddd9c71

	if (part.type === "reasoning") {
	assistantMessage.parts.push({
	type: "reasoning",
	text: part.text,
	providerMetadata: part.metadata,
	})
	}
	}

Is this how it is supposed to work?

Or do providers like Anthropic filter these out on their end?

[github-actions]

This issue might be a duplicate of existing issues. Please check:

• DeepSeek V3.2 : reasoning_content not cleared from message history on new turns, causing excess token usage and violating API spec #5577: DeepSeek V3.2: reasoning_content not cleared from message history on new turns, causing excess token usage and violating API spec - directly addresses the concern that reasoning blocks are being retained and resent in conversations
• WebUI: thinking/reasoning blocks hidden after response completion, no way to show them #7866: WebUI thinking/reasoning blocks hidden after response completion - discusses visibility and handling of reasoning blocks in the interface
• Expected thinking or redacted_thinking but found tool_use #8010: Expected thinking or redacted_thinking but found tool_use - related issue about thinking blocks being sent with Claude models with extended thinking enabled

Feel free to ignore if none of these address your specific case.

[skerit]

I don't think those existing issues match this question.
Issue #5577 is most interesting here, it seems as if it would be most logical to filter out thinking blocks in this file:

opencode/packages/opencode/src/provider/transform.ts

Line 19 in ddd9c71

function normalizeMessages(msgs: ModelMessage[], model: Provider.Model): ModelMessage[] {

But as far as I understand it, it does not.

[skerit]

To be clear: I'm not asking if its wrong or forbidden to keep all previous thinking blocks in the conversation all the time, I'm asking if this is optimal use of the context.

Anthropic's documentation says:

• That thinking blocks are ephemeral
• The AI SDK provides pruneMessages({ reasoning: 'before-last-message' }) specifically for this

[skerit]

Alright, so I dove a bit deeper into the extended-thinking docs:
https://platform.claude.com/docs/en/build-with-claude/extended-thinking

I found some important notes here:

"Preserving thinking blocks"

"While you can omit thinking blocks from prior assistant role turns, we suggest always passing back all thinking blocks to the API for any multi-turn conversation. The API will:

• Automatically filter the provided thinking blocks
• Use the relevant thinking blocks necessary to preserve the model's reasoning
• Only bill for the input tokens for the blocks shown to Claude"

"Understanding thinking block caching behavior"

"When a non-tool-result user block is included, all previous thinking blocks are ignored and stripped from context"

"Thinking block context removal"

• Thinking blocks from previous turns are removed from context, which can affect cache breakpoints
• When continuing conversations with tool use, thinking blocks are cached and count as input tokens when read from cache
• This creates a tradeoff: while thinking blocks don't consume context window space visually, they still count toward your input token usage when cached
• If thinking becomes disabled, requests will fail if you pass thinking content in the current tool use turn. In other contexts, thinking content passed to the API is simply ignored

Model difference:

"For Claude Opus 4.5 and later, all previous thinking blocks are kept by default. For older models, because a non-tool-result user block was included, all previous thinking blocks are ignored."

So I guess this is official Anthropic documentation confirming:

1. You can omit old thinking blocks (but they recommend sending them)
2. The API automatically strips old thinking blocks, but only for pre-4.5 models?
3. Claude Opus 4.5+ keeps thinking blocks by default