[ENHANCEMENT] Add Adaptive Thinking support for Claude Opus 4.6 and Sonnet 4.6

[dk-d3v]

Problem (one or two sentences)

When using Claude Opus 4.6 or Sonnet 4.6, users cannot leverage Anthropic's new adaptive thinking mode. They are limited to manually setting a fixed thinking budget (budget_tokens), which is now deprecated on these models. Adaptive thinking provides better performance for bimodal tasks and agentic workflows by letting Claude dynamically determine when and how much to think.

Context (who is affected and when)

All Roo Code users who select claude-opus-4-6 or claude-sonnet-4-6 as their model via the Anthropic provider. Currently they can only use the legacy fixed-budget extended thinking, missing out on the recommended adaptive mode.

Desired behavior (conceptual, not technical)

When a user selects Claude Opus 4.6 or Sonnet 4.6, a new "Use Adaptive Thinking" checkbox should appear in the provider settings. When enabled, Claude dynamically determines when and how much to use extended thinking based on request complexity. Users should also be able to select an effort level (low/medium/high, plus "max" for Opus only) to guide how much thinking Claude does. The Max Output Tokens slider should remain visible regardless of the thinking mode chosen.

Constraints / preferences (optional)

• Adaptive thinking uses thinking: {type: "adaptive"} (separate top-level param from the effort output_config)
• "max" effort level is only available on claude-opus-4-6; should gracefully fall back to "high" on Sonnet
• The existing manual budget mode (budget_tokens) should remain available as an alternative when adaptive thinking is off
• Max Output Tokens slider must always be visible — it's independent of the thinking mode
• Localization: all UI strings should be translated across all 18 supported languages

Request checklist

• I've searched existing Issues and Discussions for duplicates
• This describes a specific problem with clear context and impact

Roo Code Task Links (optional)

No response

Acceptance criteria (optional)

Given claude-opus-4-6 or claude-sonnet-4-6 is selected as the model
When the user enables "Use Reasoning"
Then a "Use Adaptive Thinking" checkbox appears
And when checked, an effort level dropdown (low/medium/high/max) is shown
And the Max Output Tokens slider remains visible
And the Max Thinking Tokens slider is hidden (Claude manages thinking budget)
And API requests use thinking: {type: "adaptive"} with output_config: {effort: "<level>"}
But "max" effort on Sonnet gracefully falls back to "high"

Proposed approach (optional)

1. Add supportsAdaptiveThinking and supportsAdaptiveThinkingMaxEffort flags to ModelInfo
2. Add useAdaptiveThinking (boolean) and adaptiveThinkingEffort (low/medium/high/max) to ProviderSettings
3. Update ThinkingBudget.tsx to show adaptive thinking UI when model supports it
4. Update getAnthropicReasoning() to return {type: "adaptive"} and getAnthropicOutputConfig() for effort
5. Add i18n strings for all 18 languages
6. Add unit tests for the reasoning transform functions

Trade-offs / risks (optional)

• Adaptive thinking is only supported on Opus 4.6 and Sonnet 4.6; older models must continue using budget_tokens
• The "max" effort level generates significantly more thinking tokens (higher cost); clear UI labeling needed
• Switching between adaptive and manual mode breaks prompt cache breakpoints for messages

[dk-d3v]

Claiming

[roomote]

I've analyzed this issue and here's my proposed implementation plan:

Proposed Implementation Plan

1. Add supportsAdaptiveThinking and supportsAdaptiveThinkingMaxEffort flags to ModelInfo (packages/types/src/model.ts)

• Add supportsAdaptiveThinking: z.boolean().optional() to modelInfoSchema
• Add supportsAdaptiveThinkingMaxEffort: z.boolean().optional() to modelInfoSchema (for Opus-only "max" effort)

2. Add useAdaptiveThinking and adaptiveThinkingEffort to ProviderSettings (packages/types/src/provider-settings.ts)

• Add useAdaptiveThinking: z.boolean().optional() to baseProviderSettingsSchema
• Add adaptiveThinkingEffort: z.enum(["low", "medium", "high", "max"]).optional() to baseProviderSettingsSchema

3. Set flags on claude-opus-4-6 and claude-sonnet-4-6 model definitions (packages/types/src/providers/anthropic.ts)

• Add supportsAdaptiveThinking: true to both models
• Add supportsAdaptiveThinkingMaxEffort: true only to claude-opus-4-6

4. Update ThinkingBudget.tsx UI (webview-ui/src/components/settings/ThinkingBudget.tsx)

• When reasoning is enabled AND the model has supportsAdaptiveThinking:
  • Show a "Use Adaptive Thinking" checkbox
  • When checked, show an effort level dropdown (low/medium/high, plus "max" for models with supportsAdaptiveThinkingMaxEffort)
  • Hide the "Max Thinking Tokens" slider (Claude manages the thinking budget)
  • Keep the "Max Tokens" slider visible
• When adaptive thinking is off, keep the existing manual budget_tokens behavior

5. Update getAnthropicReasoning() in src/api/transform/reasoning.ts

• When settings.useAdaptiveThinking is true and the model supports it:
  • Return { type: "adaptive" } instead of { type: "enabled", budget_tokens: N }
• Add a new getAnthropicOutputConfig() function (or inline) that returns { effort: "<level>" } for the output_config top-level param
• Handle "max" effort on Sonnet by gracefully falling back to "high"

6. Update the Anthropic provider (src/api/providers/anthropic.ts)

• Pass the new output_config parameter alongside thinking in the API request when adaptive thinking is active

7. Update getModelParams() in src/api/transform/model-params.ts

• Thread the new adaptive thinking settings through the params pipeline so the Anthropic provider can access them

8. Add i18n strings (webview-ui/src/i18n/locales/)

• Add translation keys for all 18 languages:
  • settings:providers.useAdaptiveThinking - "Use Adaptive Thinking"
  • settings:providers.adaptiveThinkingEffort.label - "Thinking Effort"
  • settings:providers.adaptiveThinkingEffort.low/medium/high/max - effort level labels

9. Add unit tests

• Tests for getAnthropicReasoning() returning { type: "adaptive" } when appropriate
• Tests for effort fallback ("max" -> "high" on Sonnet)
• Tests for ThinkingBudget.tsx adaptive thinking UI behavior
• Tests for model-params pipeline threading

Key Design Decisions

• Adaptive thinking uses a separate thinking: { type: "adaptive" } param (not budget_tokens)
• output_config: { effort: "<level>" } is a separate top-level API param, not nested inside thinking
• The existing manual budget mode (budget_tokens) remains available when adaptive thinking is off
• "max" effort is Opus-only and falls back gracefully to "high" on Sonnet models

Please mention @roomote in a comment saying that you approve this plan, and I'll proceed with the implementation.

[dk-d3v]

I've already implemented this feature locally and all tests pass. I'll submit a PR shortly.

Implementation includes:

• supportsAdaptiveThinking and supportsAdaptiveThinkingMaxEffort flags on ModelInfo
• useAdaptiveThinking and adaptiveThinkingEffort in ProviderSettings
• ThinkingBudget.tsx UI with adaptive checkbox + effort dropdown
• getAnthropicReasoning() returning {type: "adaptive"} + getAnthropicOutputConfig() for effort
• Anthropic provider and model-params pipeline updates
• i18n strings for all 18 languages
• 75 unit tests passing

@roomote No need to proceed with implementation — I've already completed it.

Note: I'm unable to access Discord (blocked in my region), so I'm communicating through GitHub directly.

[roomote]

Thanks for the heads-up, @dk-d3v! I've seen your comment and will hold off on any implementation here since you've already completed the work. Looking forward to reviewing your PR when it's submitted. Appreciate you communicating through GitHub given the Discord limitation.