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

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?

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.

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.

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

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:

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

To stay organized issues are automatically closed after 90 days of no activity. If the issue is still relevant please open a new one.

Navigation Menu

Repository navigation

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

Question

"Preserving thinking blocks"

"Understanding thinking block caching behavior"

"Thinking block context removal"

Model difference:

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

	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,
	})

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

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

Description

Question

Activity

github-actions commented on Jan 13, 2026

skerit commented on Jan 13, 2026

skerit commented on Jan 16, 2026

skerit commented on Jan 16, 2026

"Preserving thinking blocks"

"Understanding thinking block caching behavior"

"Thinking block context removal"

Model difference:

github-actions commented on Mar 26, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions