fix(ai): Fix a configuration bug with Opus 4.7 adaptive thinking (#3286)

packages/ai/test/anthropic-opus-4-7-smoke.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { getModel } from "../src/models.js";
+import { streamSimple } from "../src/stream.js";
+import type { Context } from "../src/types.js";
+
+interface AnthropicThinkingPayload {
+	thinking?: { type: string };
+	output_config?: { effort?: string };
+}
+
+function makeContext(): Context {
+	return {
+		systemPrompt: "You are a precise assistant. Follow the user's instructions exactly.",
+		messages: [
+			{
+				role: "user",
+				content:
+					"Compute 48291 * 7317 and 90844 - 17729, add the results, and determine whether the sum is divisible by 11. Reply with exactly this format and nothing else: sum=<sum>; divisibleBy11=<yes|no>",
+				timestamp: Date.now(),
+			},
+		],
+	};
+}
+
+describe.skipIf(!process.env.ANTHROPIC_API_KEY)("Anthropic Opus 4.7 smoke", () => {
+	it("streams Claude Opus 4.7 with reasoning enabled", { retry: 2, timeout: 30000 }, async () => {
+		const model = getModel("anthropic", "claude-opus-4-7");
+		let capturedPayload: AnthropicThinkingPayload | undefined;
+		const s = streamSimple(model, makeContext(), {
+			reasoning: "high",
+			maxTokens: 1024,
+			onPayload: (payload) => {
+				capturedPayload = payload as AnthropicThinkingPayload;
+				return payload;
+			},
+		});
+
+		let sawThinking = false;
+
+		for await (const event of s) {
+			if (event.type === "thinking_start" || event.type === "thinking_delta" || event.type === "thinking_end") {
+				sawThinking = true;
+			}
+		}
+
+		const response = await s.result();
+		expect(response.stopReason, response.errorMessage).toBe("stop");
+		expect(response.errorMessage).toBeFalsy();
+		expect(capturedPayload?.thinking).toEqual({ type: "adaptive" });
+		expect(capturedPayload?.output_config).toEqual({ effort: "high" });
+		expect(sawThinking).toBe(true);
+
+		const thinkingBlock = response.content.find((block) => block.type === "thinking");
+		expect(thinkingBlock?.type).toBe("thinking");
+		if (!thinkingBlock || thinkingBlock.type !== "thinking") {
+			throw new Error("Expected thinking block from Claude Opus 4.7");
+		}
+		expect(typeof thinkingBlock.thinkingSignature).toBe("string");
+		const thinkingSignature = thinkingBlock.thinkingSignature;
+		if (!thinkingSignature) {
+			throw new Error("Expected thinking signature from Claude Opus 4.7");
+		}
+		expect(thinkingSignature.length).toBeGreaterThan(0);
+
+		const text = response.content
+			.filter((block) => block.type === "text")
+			.map((block) => block.text)
+			.join("")
+			.trim();
+		expect(text).toBe("sum=353418362; divisibleBy11=yes");
+	});
+});

packages/ai/test/anthropic-thinking-disable.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { getModel } from "../src/models.js";
 import { streamSimple } from "../src/stream.js";
-import type { Context, Model } from "../src/types.js";
+import type { Context, Model, SimpleStreamOptions } from "../src/types.js";
 
 interface AnthropicThinkingPayload {
 	thinking?: { type: string; budget_tokens?: number };
@@ -14,7 +14,10 @@ function makePayloadCaptureContext(): Context {
 	};
 }
 
-async function capturePayload(model: Model<"anthropic-messages">): Promise<AnthropicThinkingPayload> {
+async function capturePayload(
+	model: Model<"anthropic-messages">,
+	options?: SimpleStreamOptions,
+): Promise<AnthropicThinkingPayload> {
 	let capturedPayload: AnthropicThinkingPayload | undefined;
 	const payloadCaptureModel: Model<"anthropic-messages"> = {
 		...model,
@@ -22,6 +25,7 @@ async function capturePayload(model: Model<"anthropic-messages">): Promise<Anthr
 	};
 
 	const s = streamSimple(payloadCaptureModel, makePayloadCaptureContext(), {
+		...options,
 		apiKey: "fake-key",
 		onPayload: (payload) => {
 			capturedPayload = payload as AnthropicThinkingPayload;
@@ -113,6 +117,27 @@ describe("Anthropic thinking disable payload", () => {
 		expect(payload.thinking).toEqual({ type: "disabled" });
 		expect(payload.output_config).toBeUndefined();
 	});
+
+	it("sends thinking.type=disabled for Claude Opus 4.7 when thinking is off", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-opus-4-7"));
+
+		expect(payload.thinking).toEqual({ type: "disabled" });
+		expect(payload.output_config).toBeUndefined();
+	});
+
+	it("uses adaptive thinking for Claude Opus 4.7 when reasoning is enabled", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-opus-4-7"), { reasoning: "high" });
+
+		expect(payload.thinking).toEqual({ type: "adaptive" });
+		expect(payload.output_config).toEqual({ effort: "high" });
+	});
+
+	it("maps xhigh reasoning to effort=xhigh for Claude Opus 4.7", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-opus-4-7"), { reasoning: "xhigh" });
+
+		expect(payload.thinking).toEqual({ type: "adaptive" });
+		expect(payload.output_config).toEqual({ effort: "xhigh" });
+	});
 });
 
 describe.skipIf(!process.env.ANTHROPIC_API_KEY)("Anthropic thinking disable E2E", () => {

packages/ai/test/bedrock-thinking-payload.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { getModel } from "../src/models.js";
+import { streamBedrock } from "../src/providers/amazon-bedrock.js";
+import type { Context, Model, SimpleStreamOptions } from "../src/types.js";
+
+interface BedrockThinkingPayload {
+	additionalModelRequestFields?: {
+		thinking?: { type: string; budget_tokens?: number };
+		output_config?: { effort?: string };
+		anthropic_beta?: string[];
+	};
+}
+
+function makeContext(): Context {
+	return {
+		messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+	};
+}
+
+async function capturePayload(
+	model: Model<"bedrock-converse-stream">,
+	options?: SimpleStreamOptions,
+): Promise<BedrockThinkingPayload> {
+	let capturedPayload: BedrockThinkingPayload | undefined;
+	const s = streamBedrock(model, makeContext(), {
+		...options,
+		reasoning: options?.reasoning ?? "high",
+		signal: AbortSignal.abort(),
+		onPayload: (payload) => {
+			capturedPayload = payload as BedrockThinkingPayload;
+			return payload;
+		},
+	});
+
+	for await (const event of s) {
+		if (event.type === "error") {
+			break;
+		}
+	}
+
+	if (!capturedPayload) {
+		throw new Error("Expected Bedrock payload to be captured before request abort");
+	}
+
+	return capturedPayload;
+}
+
+describe("Bedrock thinking payload", () => {
+	it("uses adaptive thinking for Claude Opus 4.7 when reasoning is enabled", async () => {
+		const baseModel = getModel("amazon-bedrock", "global.anthropic.claude-opus-4-6-v1");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			id: "global.anthropic.claude-opus-4-7-v1",
+			name: "Claude Opus 4.7 (Global)",
+		};
+
+		const payload = await capturePayload(model);
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "high" });
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
+	});
+
+	it("maps xhigh reasoning to effort=xhigh for Claude Opus 4.7", async () => {
+		const baseModel = getModel("amazon-bedrock", "global.anthropic.claude-opus-4-6-v1");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			id: "global.anthropic.claude-opus-4-7-v1",
+			name: "Claude Opus 4.7 (Global)",
+		};
+
+		const payload = await capturePayload(model, { reasoning: "xhigh" });
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "xhigh" });
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
+	});
+});

packages/ai/test/supports-xhigh.test.ts

@@ -8,6 +8,12 @@ describe("supportsXhigh", () => {
 		expect(supportsXhigh(model!)).toBe(true);
 	});
 
+	it("returns true for Anthropic Opus 4.7 on anthropic-messages API", () => {
+		const model = getModel("anthropic", "claude-opus-4-7");
+		expect(model).toBeDefined();
+		expect(supportsXhigh(model!)).toBe(true);
+	});
+
 	it("returns false for non-Opus Anthropic models", () => {
 		const model = getModel("anthropic", "claude-sonnet-4-5");
 		expect(model).toBeDefined();