pi-usereq 0.48.0 → 0.50.0

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

@@ -1,260 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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);
-	});
-});