fix(bedrock): send adaptive thinking + output_config.effort for Claude Opus 4.7 (3.53.5)

AWS Bedrock Converse rejects the legacy 'thinking: { type: "enabled", budget_tokens }' payload for Claude Opus 4.7 with: invalid_request_error "thinking.type.enabled" is not supported for this model. Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.

Resolves the "API Streaming Failed" error that appeared whenever reasoning was enabled on Opus 4.7.

Change

- Add BEDROCK_ADAPTIVE_THINKING_MODEL_IDS in packages/types/src/providers/bedrock.ts, seeded with anthropic.claude-opus-4-7.

- bedrock.ts: compute baseModelId early, branch the thinking payload. Adaptive models emit additionalModelRequestFields.thinking = { type: 'adaptive' } plus a top-level output_config: { effort } derived from the user's reasoningEffort setting (or mapped from the budget token count: <=4096 low, <=16384 medium, >16384 high). Older Claudes keep the legacy budget_tokens path.

- Extend BedrockPayload typings to allow thinking.type 'adaptive' and top-level output_config.effort.

- bedrock-reasoning.spec.ts: cover the new Opus 4.7 behavior end-to-end (budget-derived effort, explicit reasoningEffort honored, and regression case that Sonnet 4 still uses the legacy shape).

Co-Authored-By: Oz <oz-agent@warp.dev>

Author: allquixotic

packages/types/src/providers/bedrock.ts

@@ -566,6 +566,16 @@ export const BEDROCK_1M_CONTEXT_MODEL_IDS = [
 // behavior that surfaced this issue.
 export const BEDROCK_NATIVE_1M_CONTEXT_MODEL_IDS = ["anthropic.claude-opus-4-7"] as const
 
+// Models that REJECT the legacy `thinking: { type: "enabled", budget_tokens: N }` payload
+// on the Bedrock Converse API and instead require the newer adaptive thinking format:
+//   additionalModelRequestFields.thinking       = { type: "adaptive" }
+//   payload.output_config                       = { effort: "low" | "medium" | "high" }
+//
+// Attempting to send the legacy shape results in:
+//   invalid_request_error: "thinking.type.enabled" is not supported for this model.
+//   Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.
+export const BEDROCK_ADAPTIVE_THINKING_MODEL_IDS = ["anthropic.claude-opus-4-7"] as const
+
 // Previously Claude 4.6 Sonnet/Opus auto-advertised 1M. With the new dual dropdown
 // (default-context + `:1m` variant) the UI always exposes both tiers explicitly, so
 // we no longer auto-flip any model to 1M at resolve time. The opt-in toggle + `:1m`

src/api/providers/__tests__/bedrock-reasoning.spec.ts

@@ -284,6 +284,101 @@ describe("AwsBedrockHandler - Extended Thinking", () => {
 			expect(reasoningChunks[1].text).toBe(" about this problem.")
 		})
 
+		it("should send adaptive thinking payload (not budget_tokens) for Claude Opus 4.7", async () => {
+			handler = new AwsBedrockHandler({
+				apiProvider: "bedrock",
+				apiModelId: "anthropic.claude-opus-4-7",
+				awsRegion: "us-east-1",
+				enableReasoningEffort: true,
+				modelMaxThinkingTokens: 8192,
+			})
+
+			mockSend.mockResolvedValue({
+				stream: (async function* () {
+					yield { messageStart: { role: "assistant" } }
+					yield { metadata: { usage: { inputTokens: 100, outputTokens: 50 } } }
+				})(),
+			})
+
+			const messages = [{ role: "user" as const, content: "Test message" }]
+			const stream = handler.createMessage("System prompt", messages)
+
+			for await (const _chunk of stream) {
+				// consume stream
+			}
+
+			expect(mockSend).toHaveBeenCalledTimes(1)
+			expect(capturedPayload).toBeDefined()
+
+			// Opus 4.7 must use the adaptive thinking shape.
+			expect(capturedPayload.additionalModelRequestFields).toBeDefined()
+			expect(capturedPayload.additionalModelRequestFields.thinking).toEqual({ type: "adaptive" })
+			expect(capturedPayload.additionalModelRequestFields.thinking.budget_tokens).toBeUndefined()
+
+			// output_config.effort must live at the top level of the payload.
+			expect(capturedPayload.output_config).toBeDefined()
+			expect(["low", "medium", "high"]).toContain(capturedPayload.output_config.effort)
+			// 8192 tokens falls in the "medium" bucket per mapReasoningBudgetToBedrockEffort.
+			expect(capturedPayload.output_config.effort).toBe("medium")
+		})
+
+		it("should honor explicit reasoningEffort for Claude Opus 4.7", async () => {
+			handler = new AwsBedrockHandler({
+				apiProvider: "bedrock",
+				apiModelId: "anthropic.claude-opus-4-7",
+				awsRegion: "us-east-1",
+				enableReasoningEffort: true,
+				modelMaxThinkingTokens: 4096,
+				reasoningEffort: "high" as any,
+			})
+
+			mockSend.mockResolvedValue({
+				stream: (async function* () {
+					yield { messageStart: { role: "assistant" } }
+					yield { metadata: { usage: { inputTokens: 100, outputTokens: 50 } } }
+				})(),
+			})
+
+			const messages = [{ role: "user" as const, content: "Test message" }]
+			const stream = handler.createMessage("System prompt", messages)
+
+			for await (const _chunk of stream) {
+				// consume stream
+			}
+
+			expect(capturedPayload.output_config).toEqual({ effort: "high" })
+		})
+
+		it("should still use legacy budget_tokens thinking payload for Claude Sonnet 4", async () => {
+			handler = new AwsBedrockHandler({
+				apiProvider: "bedrock",
+				apiModelId: "anthropic.claude-sonnet-4-20250514-v1:0",
+				awsRegion: "us-east-1",
+				enableReasoningEffort: true,
+				modelMaxThinkingTokens: 4096,
+			})
+
+			mockSend.mockResolvedValue({
+				stream: (async function* () {
+					yield { messageStart: { role: "assistant" } }
+					yield { metadata: { usage: { inputTokens: 100, outputTokens: 50 } } }
+				})(),
+			})
+
+			const messages = [{ role: "user" as const, content: "Test message" }]
+			const stream = handler.createMessage("System prompt", messages)
+
+			for await (const _chunk of stream) {
+				// consume stream
+			}
+
+			expect(capturedPayload.additionalModelRequestFields.thinking).toEqual({
+				type: "enabled",
+				budget_tokens: 4096,
+			})
+			expect(capturedPayload.output_config).toBeUndefined()
+		})
+
 		it("should support API key authentication", async () => {
 			handler = new AwsBedrockHandler({
 				apiProvider: "bedrock",

src/api/providers/bedrock.ts

@@ -25,6 +25,7 @@ import {
 	BEDROCK_DEFAULT_TEMPERATURE,
 	AWS_INFERENCE_PROFILE_MAPPING,
 	BEDROCK_1M_CONTEXT_MODEL_IDS,
+	BEDROCK_ADAPTIVE_THINKING_MODEL_IDS,
 	BEDROCK_GLOBAL_INFERENCE_MODEL_IDS,
 	BEDROCK_NATIVE_1M_CONTEXT_MODEL_IDS,
 	BEDROCK_SERVICE_TIER_MODEL_IDS,
@@ -62,11 +63,13 @@ interface BedrockInferenceConfig {
 
 // Define interface for Bedrock additional model request fields
 // This includes thinking configuration, 1M context beta, and other model-specific parameters
+//
+// Two shapes are supported for the `thinking` field:
+//   - Legacy (Claude Sonnet/Opus 4.x, Claude 3.7): { type: "enabled", budget_tokens: N }
+//   - Adaptive (Claude Opus 4.7+):                 { type: "adaptive" } paired with a
+//     top-level `output_config.effort` string on the payload itself.
 interface BedrockAdditionalModelFields {
-	thinking?: {
-		type: "enabled"
-		budget_tokens: number
-	}
+	thinking?: { type: "enabled"; budget_tokens: number } | { type: "adaptive" }
 	anthropic_beta?: string[]
 	[key: string]: any // Add index signature to be compatible with DocumentType
 }
@@ -80,6 +83,39 @@ interface BedrockPayload {
 	anthropic_version?: string
 	additionalModelRequestFields?: BedrockAdditionalModelFields
 	toolConfig?: ToolConfiguration
+	// Adaptive-thinking models (e.g. Claude Opus 4.7 on Bedrock) use this top-level
+	// `output_config.effort` knob instead of the legacy `thinking.budget_tokens` number.
+	output_config?: { effort: "low" | "medium" | "high" }
+}
+
+/**
+ * Map a reasoning budget (in tokens) to a coarse effort bucket for the adaptive
+ * thinking payload. Used only when invoking Bedrock models that require the newer
+ * `thinking: { type: "adaptive" }` + `output_config.effort` shape.
+ *
+ * The thresholds mirror the historical budget ranges exposed by the reasoning UI:
+ *   <=  4096 tokens → "low"
+ *   <= 16384 tokens → "medium"
+ *    > 16384 tokens → "high"
+ */
+function mapReasoningBudgetToBedrockEffort(budget: number | undefined): "low" | "medium" | "high" {
+	const b = typeof budget === "number" && Number.isFinite(budget) && budget > 0 ? budget : 0
+	if (b <= 4096) return "low"
+	if (b <= 16384) return "medium"
+	return "high"
+}
+
+/**
+ * Normalize a freeform reasoning-effort setting string to the three buckets Bedrock
+ * accepts on `output_config.effort`. Unknown or disabled values return undefined so
+ * the caller can fall back to the budget-derived mapping.
+ */
+function normalizeReasoningEffortForBedrock(value: unknown): "low" | "medium" | "high" | undefined {
+	if (typeof value !== "string") return undefined
+	const v = value.toLowerCase()
+	if (v === "low" || v === "medium" || v === "high") return v
+	if (v === "minimal") return "low"
+	return undefined
 }
 
 // Extended payload type that includes service_tier as a top-level parameter
@@ -322,6 +358,14 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 
 		let additionalModelRequestFields: BedrockAdditionalModelFields | undefined
 		let thinkingEnabled = false
+		let adaptiveThinkingEffort: "low" | "medium" | "high" | undefined
+
+		// Resolve the base model id first so the thinking branch can decide between the
+		// legacy budget_tokens payload and the newer adaptive + output_config.effort payload.
+		// parseBaseModelId strips cross-region inference prefixes (e.g. `us.`, `eu.`) and the
+		// synthetic `:1m` dropdown suffix.
+		const baseModelId = this.parseBaseModelId(modelConfig.id)
+		const requiresAdaptiveThinking = BEDROCK_ADAPTIVE_THINKING_MODEL_IDS.includes(baseModelId as any)
 
 		// Determine if thinking should be enabled
 		// metadata?.thinking?.enabled: Explicitly enabled through API metadata (direct request)
@@ -334,17 +378,42 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 
 		if ((isThinkingExplicitlyEnabled || isThinkingEnabledBySettings) && modelConfig.info.supportsReasoningBudget) {
 			thinkingEnabled = true
-			additionalModelRequestFields = {
-				thinking: {
-					type: "enabled",
-					budget_tokens: metadata?.thinking?.maxThinkingTokens || modelConfig.reasoningBudget || 4096,
-				},
+			const effectiveBudget = metadata?.thinking?.maxThinkingTokens || modelConfig.reasoningBudget || 4096
+
+			if (requiresAdaptiveThinking) {
+				// Newer Claude models on Bedrock (e.g. Opus 4.7) reject the legacy
+				// `thinking: { type: "enabled", budget_tokens: N }` shape with:
+				//   invalid_request_error: "thinking.type.enabled" is not supported for this model.
+				//   Use "thinking.type.adaptive" and "output_config.effort" to control thinking behavior.
+				// Honor that by emitting `thinking: { type: "adaptive" }` plus a top-level
+				// `output_config.effort`. Effort comes from the user's reasoningEffort setting
+				// when present, otherwise we derive it from the token budget.
+				adaptiveThinkingEffort =
+					normalizeReasoningEffortForBedrock(
+						(this.options as ProviderSettings & { reasoningEffort?: unknown }).reasoningEffort,
+					) ?? mapReasoningBudgetToBedrockEffort(effectiveBudget)
+				additionalModelRequestFields = {
+					thinking: { type: "adaptive" },
+				}
+				logger.info("Adaptive thinking enabled for Bedrock request", {
+					ctx: "bedrock",
+					modelId: modelConfig.id,
+					thinking: additionalModelRequestFields.thinking,
+					effort: adaptiveThinkingEffort,
+				})
+			} else {
+				additionalModelRequestFields = {
+					thinking: {
+						type: "enabled",
+						budget_tokens: effectiveBudget,
+					},
+				}
+				logger.info("Extended thinking enabled for Bedrock request", {
+					ctx: "bedrock",
+					modelId: modelConfig.id,
+					thinking: additionalModelRequestFields.thinking,
+				})
 			}
-			logger.info("Extended thinking enabled for Bedrock request", {
-				ctx: "bedrock",
-				modelId: modelConfig.id,
-				thinking: additionalModelRequestFields.thinking,
-			})
 		}
 
 		const inferenceConfig: BedrockInferenceConfig = {
@@ -357,8 +426,6 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 		//   - the configured target id contains the `:1m` / `[1m]` indicator (user picked the
 		//     1M variant from the dropdown), OR
 		//   - the awsBedrock1MContext opt-in toggle is set by the user.
-		// Use parseBaseModelId to handle cross-region inference prefixes.
-		const baseModelId = this.parseBaseModelId(modelConfig.id)
 		const configuredTargetForIndicator =
 			this.options.awsBedrockInvokeTarget || this.options.awsCustomArn || modelConfig.id
 		const is1MContextEnabled =
@@ -429,6 +496,9 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 			...(additionalModelRequestFields && { additionalModelRequestFields }),
 			// Add anthropic_version at top level when using thinking features
 			...(thinkingEnabled && { anthropic_version: "bedrock-2023-05-31" }),
+			// Adaptive-thinking models require the effort knob at the top level alongside
+			// `thinking: { type: "adaptive" }` inside additionalModelRequestFields.
+			...(adaptiveThinkingEffort && { output_config: { effort: adaptiveThinkingEffort } }),
 			toolConfig,
 			// Add service_tier as a top-level parameter (not inside additionalModelRequestFields)
 			...(useServiceTier && { service_tier: this.options.awsBedrockServiceTier }),

src/package.json

@@ -3,7 +3,7 @@
 	"displayName": "%extension.displayName%",
 	"description": "%extension.description%",
 	"publisher": "allquixotic",
-	"version": "3.53.4",
+	"version": "3.53.5",
 	"icon": "assets/icons/icon.png",
 	"galleryBanner": {
 		"color": "#617A91",