pi-usereq 0.7.0 → 0.10.0

package/pi.dev-src/pi-mono/ai/test/abort.test.ts

@@ -0,0 +1,260 @@
+import { describe, expect, it } from "vitest";
+import { getModel } from "../src/models.js";
+import { complete, stream } from "../src/stream.js";
+import type { Api, Context, Model, StreamOptions } from "../src/types.js";
+
+type StreamOptionsWithExtras = StreamOptions & Record<string, unknown>;
+
+import { hasAzureOpenAICredentials, resolveAzureDeploymentName } from "./azure-utils.js";
+import { hasBedrockCredentials } from "./bedrock-utils.js";
+import { resolveApiKey } from "./oauth.js";
+
+// Resolve OAuth tokens at module level (async, runs before tests)
+const [geminiCliToken, openaiCodexToken] = await Promise.all([
+	resolveApiKey("google-gemini-cli"),
+	resolveApiKey("openai-codex"),
+]);
+
+async function testAbortSignal<TApi extends Api>(llm: Model<TApi>, options: StreamOptionsWithExtras = {}) {
+	const context: Context = {
+		messages: [
+			{
+				role: "user",
+				content: "What is 15 + 27? Think step by step. Then list 50 first names.",
+				timestamp: Date.now(),
+			},
+		],
+		systemPrompt: "You are a helpful assistant.",
+	};
+
+	let abortFired = false;
+	let text = "";
+	const controller = new AbortController();
+	const response = await stream(llm, context, { ...options, signal: controller.signal });
+	for await (const event of response) {
+		if (abortFired) return;
+		if (event.type === "text_delta" || event.type === "thinking_delta") {
+			text += event.delta;
+		}
+		if (text.length >= 50) {
+			controller.abort();
+			abortFired = true;
+		}
+	}
+	const msg = await response.result();
+
+	// If we get here without throwing, the abort didn't work
+	expect(msg.stopReason).toBe("aborted");
+	expect(msg.content.length).toBeGreaterThan(0);
+
+	context.messages.push(msg);
+	context.messages.push({
+		role: "user",
+		content: "Please continue, but only generate 5 names.",
+		timestamp: Date.now(),
+	});
+
+	const followUp = await complete(llm, context, options);
+	expect(followUp.stopReason).toBe("stop");
+	expect(followUp.content.length).toBeGreaterThan(0);
+}
+
+async function testImmediateAbort<TApi extends Api>(llm: Model<TApi>, options: StreamOptionsWithExtras = {}) {
+	const controller = new AbortController();
+
+	controller.abort();
+
+	const context: Context = {
+		messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+	};
+
+	const response = await complete(llm, context, { ...options, signal: controller.signal });
+	expect(response.stopReason).toBe("aborted");
+}
+
+async function testAbortThenNewMessage<TApi extends Api>(llm: Model<TApi>, options: StreamOptionsWithExtras = {}) {
+	// First request: abort immediately before any response content arrives
+	const controller = new AbortController();
+	controller.abort();
+
+	const context: Context = {
+		messages: [{ role: "user", content: "Hello, how are you?", timestamp: Date.now() }],
+	};
+
+	const abortedResponse = await complete(llm, context, { ...options, signal: controller.signal });
+	expect(abortedResponse.stopReason).toBe("aborted");
+	// The aborted message has empty content since we aborted before anything arrived
+	expect(abortedResponse.content.length).toBe(0);
+
+	// Add the aborted assistant message to context (this is what happens in the real coding agent)
+	context.messages.push(abortedResponse);
+
+	// Second request: send a new message - this should work even with the aborted message in context
+	context.messages.push({
+		role: "user",
+		content: "What is 2 + 2?",
+		timestamp: Date.now(),
+	});
+
+	const followUp = await complete(llm, context, options);
+	expect(followUp.stopReason).toBe("stop");
+	expect(followUp.content.length).toBeGreaterThan(0);
+}
+
+describe("AI Providers Abort Tests", () => {
+	describe.skipIf(!process.env.GEMINI_API_KEY)("Google Provider Abort", () => {
+		const llm = getModel("google", "gemini-2.5-flash");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm, { thinking: { enabled: true } });
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm, { thinking: { enabled: true } });
+		});
+	});
+
+	describe.skipIf(!process.env.OPENAI_API_KEY)("OpenAI Completions Provider Abort", () => {
+		const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
+		void _compat;
+		const llm: Model<"openai-completions"> = {
+			...baseModel,
+			api: "openai-completions",
+		};
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm);
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.OPENAI_API_KEY)("OpenAI Responses Provider Abort", () => {
+		const llm = getModel("openai", "gpt-5-mini");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm);
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm);
+		});
+	});
+
+	describe.skipIf(!hasAzureOpenAICredentials())("Azure OpenAI Responses Provider Abort", () => {
+		const llm = getModel("azure-openai-responses", "gpt-4o-mini");
+		const azureDeploymentName = resolveAzureDeploymentName(llm.id);
+		const azureOptions = azureDeploymentName ? { azureDeploymentName } : {};
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm, azureOptions);
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm, azureOptions);
+		});
+	});
+
+	describe.skipIf(!process.env.ANTHROPIC_OAUTH_TOKEN)("Anthropic Provider Abort", () => {
+		const llm = getModel("anthropic", "claude-opus-4-1-20250805");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm, { thinkingEnabled: true, thinkingBudgetTokens: 2048 });
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm, { thinkingEnabled: true, thinkingBudgetTokens: 2048 });
+		});
+	});
+
+	describe.skipIf(!process.env.MISTRAL_API_KEY)("Mistral Provider Abort", () => {
+		const llm = getModel("mistral", "devstral-medium-latest");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm);
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.MINIMAX_API_KEY)("MiniMax Provider Abort", () => {
+		const llm = getModel("minimax", "MiniMax-M2.7");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm);
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.KIMI_API_KEY)("Kimi For Coding Provider Abort", () => {
+		const llm = getModel("kimi-coding", "kimi-k2-thinking");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm);
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.AI_GATEWAY_API_KEY)("Vercel AI Gateway Provider Abort", () => {
+		const llm = getModel("vercel-ai-gateway", "google/gemini-2.5-flash");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm);
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm);
+		});
+	});
+
+	// Google Gemini CLI / Antigravity share the same provider, so one test covers both
+	describe("Google Gemini CLI Provider Abort", () => {
+		it.skipIf(!geminiCliToken)("should abort mid-stream", { retry: 3 }, async () => {
+			const llm = getModel("google-gemini-cli", "gemini-2.5-flash");
+			await testAbortSignal(llm, { apiKey: geminiCliToken });
+		});
+
+		it.skipIf(!geminiCliToken)("should handle immediate abort", { retry: 3 }, async () => {
+			const llm = getModel("google-gemini-cli", "gemini-2.5-flash");
+			await testImmediateAbort(llm, { apiKey: geminiCliToken });
+		});
+	});
+
+	describe("OpenAI Codex Provider Abort", () => {
+		it.skipIf(!openaiCodexToken)("should abort mid-stream", { retry: 3 }, async () => {
+			const llm = getModel("openai-codex", "gpt-5.2-codex");
+			await testAbortSignal(llm, { apiKey: openaiCodexToken });
+		});
+
+		it.skipIf(!openaiCodexToken)("should handle immediate abort", { retry: 3 }, async () => {
+			const llm = getModel("openai-codex", "gpt-5.2-codex");
+			await testImmediateAbort(llm, { apiKey: openaiCodexToken });
+		});
+	});
+
+	describe.skipIf(!hasBedrockCredentials())("Amazon Bedrock Provider Abort", () => {
+		const llm = getModel("amazon-bedrock", "global.anthropic.claude-sonnet-4-5-20250929-v1:0");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm, { reasoning: "medium" });
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm);
+		});
+
+		it("should handle abort then new message", { retry: 3 }, async () => {
+			await testAbortThenNewMessage(llm);
+		});
+	});
+});

package/pi.dev-src/pi-mono/ai/test/anthropic-oauth.test.ts

@@ -0,0 +1,99 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { loginAnthropic, refreshAnthropicToken } from "../src/utils/oauth/anthropic.js";
+
+function jsonResponse(body: unknown, status: number = 200): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: {
+			"Content-Type": "application/json",
+		},
+	});
+}
+
+function getUrl(input: unknown): string {
+	if (typeof input === "string") {
+		return input;
+	}
+	if (input instanceof URL) {
+		return input.toString();
+	}
+	if (input instanceof Request) {
+		return input.url;
+	}
+	throw new Error(`Unsupported fetch input: ${String(input)}`);
+}
+
+function getJsonBody(init?: RequestInit): Record<string, string> {
+	if (typeof init?.body !== "string") {
+		throw new Error(`Expected string request body, got ${typeof init?.body}`);
+	}
+	return JSON.parse(init.body) as Record<string, string>;
+}
+
+describe.sequential("Anthropic OAuth", () => {
+	afterEach(() => {
+		vi.unstubAllGlobals();
+	});
+
+	it("keeps the localhost redirect_uri for manual callback login", async () => {
+		let authUrl = "";
+		const fetchMock = vi.fn(async (input: unknown, init?: RequestInit): Promise<Response> => {
+			expect(getUrl(input)).toBe("https://platform.claude.com/v1/oauth/token");
+			expect(init?.method).toBe("POST");
+			const body = getJsonBody(init);
+			expect(body.grant_type).toBe("authorization_code");
+			expect(body.code).toBe("manual-code");
+			expect(body.redirect_uri).toBe("http://localhost:53692/callback");
+			return jsonResponse({
+				access_token: "access-token",
+				refresh_token: "refresh-token",
+				expires_in: 3600,
+			});
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const credentials = await loginAnthropic({
+			onAuth: (info) => {
+				authUrl = info.url;
+			},
+			onPrompt: async () => "",
+			onManualCodeInput: async () => {
+				const url = new URL(authUrl);
+				const state = url.searchParams.get("state");
+				const redirectUri = url.searchParams.get("redirect_uri");
+				if (!state || !redirectUri) {
+					throw new Error("Missing OAuth state or redirect_uri in auth URL");
+				}
+				return `${redirectUri}?code=manual-code&state=${state}`;
+			},
+		});
+
+		expect(credentials.access).toBe("access-token");
+		expect(credentials.refresh).toBe("refresh-token");
+		expect(fetchMock).toHaveBeenCalledOnce();
+	});
+
+	it("omits scope from refresh token requests", async () => {
+		const fetchMock = vi.fn(async (input: unknown, init?: RequestInit): Promise<Response> => {
+			expect(getUrl(input)).toBe("https://platform.claude.com/v1/oauth/token");
+			expect(init?.method).toBe("POST");
+			const body = getJsonBody(init);
+			expect(body.grant_type).toBe("refresh_token");
+			expect(body.client_id).toBeTruthy();
+			expect(body.refresh_token).toBe("refresh-token");
+			expect(body).not.toHaveProperty("scope");
+			return jsonResponse({
+				access_token: "new-access-token",
+				refresh_token: "new-refresh-token",
+				expires_in: 3600,
+			});
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const credentials = await refreshAnthropicToken("refresh-token");
+
+		expect(credentials.access).toBe("new-access-token");
+		expect(credentials.refresh).toBe("new-refresh-token");
+		expect(fetchMock).toHaveBeenCalledOnce();
+	});
+});

package/pi.dev-src/pi-mono/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");
+	});
+});

package/pi.dev-src/pi-mono/ai/test/anthropic-sse-parsing.test.ts

@@ -0,0 +1,113 @@
+import type Anthropic from "@anthropic-ai/sdk";
+import { Type } from "typebox";
+import { describe, expect, it } from "vitest";
+import { getModel } from "../src/models.js";
+import { streamAnthropic } from "../src/providers/anthropic.js";
+import type { Context, ToolCall } from "../src/types.js";
+
+function createSseResponse(events: Array<{ event: string; data: string }>): Response {
+	const body = events.map(({ event, data }) => `event: ${event}\ndata: ${data}\n`).join("\n");
+	return new Response(body, {
+		status: 200,
+		headers: { "content-type": "text/event-stream" },
+	});
+}
+
+function createFakeAnthropicClient(response: Response): Anthropic {
+	return {
+		messages: {
+			create: () => ({
+				asResponse: async () => response,
+			}),
+		},
+	} as unknown as Anthropic;
+}
+
+describe("Anthropic raw SSE parsing", () => {
+	it("repairs malformed SSE JSON and malformed streamed tool JSON", async () => {
+		const model = getModel("anthropic", "claude-haiku-4-5");
+		const context: Context = {
+			messages: [{ role: "user", content: "Use the edit tool.", timestamp: Date.now() }],
+			tools: [
+				{
+					name: "edit",
+					description: "Edit a file.",
+					parameters: Type.Object({
+						path: Type.String(),
+						text: Type.String(),
+					}),
+				},
+			],
+		};
+
+		const malformedToolJsonDelta = String.raw`{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"{\"path\":\"A\H\",\"text\":\"col1	col2\"}"}}`;
+
+		const response = createSseResponse([
+			{
+				event: "message_start",
+				data: JSON.stringify({
+					type: "message_start",
+					message: {
+						id: "msg_test",
+						usage: {
+							input_tokens: 12,
+							output_tokens: 0,
+							cache_read_input_tokens: 0,
+							cache_creation_input_tokens: 0,
+						},
+					},
+				}),
+			},
+			{
+				event: "content_block_start",
+				data: JSON.stringify({
+					type: "content_block_start",
+					index: 0,
+					content_block: {
+						type: "tool_use",
+						id: "toolu_test",
+						name: "edit",
+						input: {},
+					},
+				}),
+			},
+			{ event: "content_block_delta", data: malformedToolJsonDelta },
+			{
+				event: "content_block_stop",
+				data: JSON.stringify({ type: "content_block_stop", index: 0 }),
+			},
+			{
+				event: "message_delta",
+				data: JSON.stringify({
+					type: "message_delta",
+					delta: { stop_reason: "tool_use" },
+					usage: {
+						input_tokens: 12,
+						output_tokens: 5,
+						cache_read_input_tokens: 0,
+						cache_creation_input_tokens: 0,
+					},
+				}),
+			},
+			{
+				event: "message_stop",
+				data: JSON.stringify({ type: "message_stop" }),
+			},
+		]);
+
+		const stream = streamAnthropic(model, context, {
+			client: createFakeAnthropicClient(response),
+		});
+		const result = await stream.result();
+
+		expect(result.stopReason).toBe("toolUse");
+		expect(result.errorMessage).toBeUndefined();
+
+		const toolCall = result.content.find((block): block is ToolCall => block.type === "toolCall");
+		expect(toolCall).toBeDefined();
+		expect(toolCall?.arguments).toEqual({
+			path: "A\\H",
+			text: "col1\tcol2",
+		});
+	});
+});

package/pi.dev-src/pi-mono/ai/test/anthropic-thinking-disable.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "vitest";
+import { getModel } from "../src/models.js";
+import { streamSimple } from "../src/stream.js";
+import type { Context, Model, SimpleStreamOptions } from "../src/types.js";
+
+interface AnthropicThinkingPayload {
+	thinking?: { type: string; budget_tokens?: number; display?: string };
+	output_config?: { effort?: string };
+}
+
+function makePayloadCaptureContext(): Context {
+	return {
+		messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+	};
+}
+
+async function capturePayload(
+	model: Model<"anthropic-messages">,
+	options?: SimpleStreamOptions,
+): Promise<AnthropicThinkingPayload> {
+	let capturedPayload: AnthropicThinkingPayload | undefined;
+	const payloadCaptureModel: Model<"anthropic-messages"> = {
+		...model,
+		baseUrl: "http://127.0.0.1:9",
+	};
+
+	const s = streamSimple(payloadCaptureModel, makePayloadCaptureContext(), {
+		...options,
+		apiKey: "fake-key",
+		onPayload: (payload) => {
+			capturedPayload = payload as AnthropicThinkingPayload;
+			return payload;
+		},
+	});
+
+	await s.result();
+
+	if (!capturedPayload) {
+		throw new Error("Expected payload to be captured before request failure");
+	}
+
+	return capturedPayload;
+}
+
+interface RunResult {
+	thinkingEventCount: number;
+	thinkingCharCount: number;
+	text: string;
+	contentTypes: string[];
+}
+
+function makeE2EContext(): Context {
+	return {
+		systemPrompt: "You are a precise assistant. Follow the requested output format exactly.",
+		messages: [
+			{
+				role: "user",
+				content:
+					"Before replying, carefully solve 36863 * 5279 internally. Then reply with the word pong repeated exactly 40 times, separated by single spaces. Do not add any other text.",
+				timestamp: Date.now(),
+			},
+		],
+	};
+}
+
+function countPongs(text: string): number {
+	return text.match(/\bpong\b/gi)?.length ?? 0;
+}
+
+async function runWithoutReasoning(model: Model<"anthropic-messages">): Promise<RunResult> {
+	const s = streamSimple(model, makeE2EContext(), {
+		temperature: 0,
+		maxTokens: 160,
+	});
+
+	let thinkingEventCount = 0;
+	let thinkingCharCount = 0;
+
+	for await (const event of s) {
+		if (event.type === "thinking_start" || event.type === "thinking_end") {
+			thinkingEventCount += 1;
+		}
+		if (event.type === "thinking_delta") {
+			thinkingEventCount += 1;
+			thinkingCharCount += event.delta.length;
+		}
+	}
+
+	const response = await s.result();
+	expect(response.stopReason, response.errorMessage).toBe("stop");
+
+	const text = response.content
+		.filter((block) => block.type === "text")
+		.map((block) => block.text)
+		.join("")
+		.trim();
+
+	return {
+		thinkingEventCount,
+		thinkingCharCount,
+		text,
+		contentTypes: response.content.map((block) => block.type),
+	};
+}
+
+describe("Anthropic thinking disable payload", () => {
+	it("sends thinking.type=disabled for budget-based reasoning models when thinking is off", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-sonnet-4-5"));
+
+		expect(payload.thinking).toEqual({ type: "disabled" });
+		expect(payload.output_config).toBeUndefined();
+	});
+
+	it("sends thinking.type=disabled for adaptive reasoning models when thinking is off", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-opus-4-6"));
+
+		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", display: "summarized" });
+		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", display: "summarized" });
+		expect(payload.output_config).toEqual({ effort: "xhigh" });
+	});
+});
+
+describe.skipIf(!process.env.ANTHROPIC_API_KEY)("Anthropic thinking disable E2E", () => {
+	it("disables thinking for Claude reasoning models", { retry: 2, timeout: 30000 }, async () => {
+		const result = await runWithoutReasoning(getModel("anthropic", "claude-sonnet-4-5"));
+
+		expect(result.thinkingEventCount).toBe(0);
+		expect(result.thinkingCharCount).toBe(0);
+		expect(result.contentTypes).not.toContain("thinking");
+		expect(countPongs(result.text)).toBeGreaterThanOrEqual(35);
+	});
+});