Add files using upload-large-folder tool

packages/ai/src/providers/anthropic.ts

@@ -0,0 +1,59 @@
+import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.ts";
+import { lazyOAuth } from "../auth/helpers.ts";
+import { loadAnthropicOAuth } from "../auth/oauth/load.ts";
+import type { ApiKeyAuth } from "../auth/types.ts";
+import { ANTHROPIC_API_KEY_ENV, ANTHROPIC_AUTH_TOKEN_ENV, ANTHROPIC_OAUTH_TOKEN_ENV } from "../env-api-keys.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { ANTHROPIC_MODELS } from "./anthropic.models.ts";
+
+function anthropicApiKeyAuth(): ApiKeyAuth {
+	return {
+		name: "Anthropic API key",
+		login: async (interaction) => {
+			interaction.signal.throwIfAborted();
+			const key = await interaction.prompt({ type: "secret", message: "Enter Anthropic API key" });
+			interaction.signal.throwIfAborted();
+			return { type: "api_key", key };
+		},
+		resolve: async ({ ctx, credential, signal }) => {
+			signal.throwIfAborted();
+			if (credential?.key) {
+				return { auth: { apiKey: credential.key }, env: credential.env, source: "stored credential" };
+			}
+
+			const authToken = await ctx.env(ANTHROPIC_AUTH_TOKEN_ENV);
+			signal.throwIfAborted();
+			if (authToken) {
+				return {
+					auth: { headers: { Authorization: `Bearer ${authToken}` } },
+					source: ANTHROPIC_AUTH_TOKEN_ENV,
+				};
+			}
+
+			for (const envVar of [ANTHROPIC_OAUTH_TOKEN_ENV, ANTHROPIC_API_KEY_ENV]) {
+				const apiKey = await ctx.env(envVar);
+				signal.throwIfAborted();
+				if (apiKey) return { auth: { apiKey }, source: envVar };
+			}
+			return undefined;
+		},
+	};
+}
+
+export function anthropicProvider(): Provider<"anthropic-messages"> {
+	return createProvider({
+		id: "anthropic",
+		name: "Anthropic",
+		baseUrl: "https://api.anthropic.com",
+		auth: {
+			apiKey: anthropicApiKeyAuth(),
+			oauth: lazyOAuth({
+				name: "Anthropic (Claude Pro/Max)",
+				isSubscription: true,
+				load: loadAnthropicOAuth,
+			}),
+		},
+		models: Object.values(ANTHROPIC_MODELS),
+		api: anthropicMessagesApi(),
+	});
+}

packages/ai/src/providers/baseten.ts

@@ -0,0 +1,15 @@
+import { openAICompletionsApi } from "../api/openai-completions.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { BASETEN_MODELS } from "./baseten.models.ts";
+
+export function basetenProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "baseten",
+		name: "Baseten",
+		baseUrl: "https://inference.baseten.co/v1",
+		auth: { apiKey: envApiKeyAuth("Baseten API key", ["BASETEN_API_KEY"]) },
+		models: Object.values(BASETEN_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

packages/ai/src/providers/cerebras.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/cerebras.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const CEREBRAS_MODELS: ModelCatalog<typeof values, "cerebras"> =
+	flattenModelCatalog("cerebras", values);

packages/ai/src/providers/cloudflare-ai-gateway.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/cloudflare-ai-gateway.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const CLOUDFLARE_AI_GATEWAY_MODELS: ModelCatalog<typeof values, "cloudflare-ai-gateway"> =
+	flattenModelCatalog("cloudflare-ai-gateway", values);

packages/ai/src/providers/data-json.d.ts

@@ -0,0 +1,4 @@
+declare module "*.json" {
+	const value: unknown;
+	export default value;
+}

packages/ai/src/providers/deepseek.ts

@@ -0,0 +1,15 @@
+import { openAICompletionsApi } from "../api/openai-completions.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { DEEPSEEK_MODELS } from "./deepseek.models.ts";
+
+export function deepseekProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "deepseek",
+		name: "DeepSeek",
+		baseUrl: "https://api.deepseek.com",
+		auth: { apiKey: envApiKeyAuth("DeepSeek API key", ["DEEPSEEK_API_KEY"]) },
+		models: Object.values(DEEPSEEK_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

packages/ai/src/providers/fireworks.ts

@@ -0,0 +1,19 @@
+import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.ts";
+import { openAICompletionsApi } from "../api/openai-completions.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { FIREWORKS_MODELS } from "./fireworks.models.ts";
+
+export function fireworksProvider(): Provider<"anthropic-messages" | "openai-completions"> {
+	return createProvider({
+		id: "fireworks",
+		name: "Fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		auth: { apiKey: envApiKeyAuth("Fireworks API key", ["FIREWORKS_API_KEY"]) },
+		models: Object.values(FIREWORKS_MODELS),
+		api: {
+			"anthropic-messages": anthropicMessagesApi(),
+			"openai-completions": openAICompletionsApi(),
+		},
+	});
+}

packages/ai/src/providers/google-vertex.ts

@@ -0,0 +1,100 @@
+import { googleVertexApi } from "../api/google-vertex.lazy.ts";
+import type { ApiKeyAuth } from "../auth/types.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { GOOGLE_VERTEX_MODELS } from "./google-vertex.models.ts";
+
+const VERTEX_ADC_PATH = "~/.config/gcloud/application_default_credentials.json";
+
+/**
+ * Vertex accepts an explicit API key or Application Default Credentials
+ * (`gcloud auth application-default login`). ADC additionally requires
+ * project and location env vars, which the implementation reads itself.
+ */
+const vertexAuth: ApiKeyAuth = {
+	name: "Google Cloud credentials",
+	login: async (interaction) => {
+		interaction.signal.throwIfAborted();
+		const method = await interaction.prompt({
+			type: "select",
+			message: "Select Google Vertex AI authentication method:",
+			options: [
+				{ id: "api-key", label: "Google Cloud API key" },
+				{ id: "adc", label: "Application Default Credentials" },
+				{ id: "service-account", label: "Service account credentials file" },
+			],
+		});
+		interaction.signal.throwIfAborted();
+		if (method === "api-key") {
+			return {
+				type: "api_key",
+				key: await interaction.prompt({ type: "secret", message: "Enter Google Cloud API key" }),
+			};
+		}
+		if (method !== "adc" && method !== "service-account") {
+			throw new Error(`Unknown Google Vertex AI auth method: ${method}`);
+		}
+		interaction.notify({
+			type: "info",
+			message:
+				method === "adc"
+					? "Run `gcloud auth application-default login`, then provide the project and location."
+					: "Provide a service account credentials file, project, and location.",
+			links: [
+				{
+					label: "Application Default Credentials",
+					url: "https://cloud.google.com/docs/authentication/provide-credentials-adc",
+				},
+			],
+		});
+		const project = await interaction.prompt({ type: "text", message: "Enter Google Cloud project ID" });
+		const location = await interaction.prompt({ type: "text", message: "Enter Google Cloud location" });
+		const credentialsPath =
+			method === "service-account"
+				? await interaction.prompt({ type: "text", message: "Enter service account credentials file path" })
+				: undefined;
+		return {
+			type: "api_key",
+			env: {
+				GOOGLE_CLOUD_PROJECT: project,
+				GOOGLE_CLOUD_LOCATION: location,
+				...(credentialsPath ? { GOOGLE_APPLICATION_CREDENTIALS: credentialsPath } : {}),
+			},
+		};
+	},
+	resolve: async ({ ctx, credential, signal }) => {
+		const env = async (name: string) => {
+			signal.throwIfAborted();
+			const value = await ctx.env(name);
+			signal.throwIfAborted();
+			return value;
+		};
+		const key = credential?.key ?? (await env("GOOGLE_CLOUD_API_KEY"));
+		if (key) return { auth: { apiKey: key }, source: credential?.key ? "stored credential" : "GOOGLE_CLOUD_API_KEY" };
+
+		const adcPath = credential?.env?.GOOGLE_APPLICATION_CREDENTIALS ?? (await env("GOOGLE_APPLICATION_CREDENTIALS"));
+		signal.throwIfAborted();
+		const hasCredentials = await ctx.fileExists(adcPath ?? VERTEX_ADC_PATH);
+		signal.throwIfAborted();
+		const project =
+			credential?.env?.GOOGLE_CLOUD_PROJECT ?? (await env("GOOGLE_CLOUD_PROJECT")) ?? (await env("GCLOUD_PROJECT"));
+		const location = credential?.env?.GOOGLE_CLOUD_LOCATION ?? (await env("GOOGLE_CLOUD_LOCATION"));
+		if (hasCredentials && project && location) {
+			return {
+				auth: {},
+				env: credential?.env,
+				source: credential ? "stored credential" : "gcloud application default credentials",
+			};
+		}
+		return undefined;
+	},
+};
+
+export function googleVertexProvider(): Provider<"google-vertex"> {
+	return createProvider({
+		id: "google-vertex",
+		name: "Google Vertex AI",
+		auth: { apiKey: vertexAuth },
+		models: Object.values(GOOGLE_VERTEX_MODELS),
+		api: googleVertexApi(),
+	});
+}

packages/ai/src/providers/huggingface.ts

@@ -0,0 +1,15 @@
+import { openAICompletionsApi } from "../api/openai-completions.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { HUGGINGFACE_MODELS } from "./huggingface.models.ts";
+
+export function huggingfaceProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "huggingface",
+		name: "Hugging Face",
+		baseUrl: "https://router.huggingface.co/v1",
+		auth: { apiKey: envApiKeyAuth("Hugging Face token", ["HF_TOKEN"]) },
+		models: Object.values(HUGGINGFACE_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

packages/ai/src/providers/minimax.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/minimax.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const MINIMAX_MODELS: ModelCatalog<typeof values, "minimax"> =
+	flattenModelCatalog("minimax", values);

packages/ai/src/providers/mistral.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/mistral.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const MISTRAL_MODELS: ModelCatalog<typeof values, "mistral"> =
+	flattenModelCatalog("mistral", values);

packages/ai/src/providers/moonshotai-cn.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/moonshotai-cn.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const MOONSHOTAI_CN_MODELS: ModelCatalog<typeof values, "moonshotai-cn"> =
+	flattenModelCatalog("moonshotai-cn", values);

packages/ai/src/providers/openai-codex.ts

@@ -0,0 +1,22 @@
+import { openAICodexResponsesApi } from "../api/openai-codex-responses.lazy.ts";
+import { lazyOAuth } from "../auth/helpers.ts";
+import { loadOpenAICodexOAuth } from "../auth/oauth/load.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { OPENAI_CODEX_MODELS } from "./openai-codex.models.ts";
+
+export function openaiCodexProvider(): Provider<"openai-codex-responses"> {
+	return createProvider({
+		id: "openai-codex",
+		name: "OpenAI Codex",
+		baseUrl: "https://chatgpt.com/backend-api",
+		auth: {
+			oauth: lazyOAuth({
+				name: "OpenAI (ChatGPT Plus/Pro)",
+				isSubscription: true,
+				load: loadOpenAICodexOAuth,
+			}),
+		},
+		models: Object.values(OPENAI_CODEX_MODELS),
+		api: openAICodexResponsesApi(),
+	});
+}

packages/ai/src/providers/openai.ts

@@ -0,0 +1,15 @@
+import { openAIResponsesApi } from "../api/openai-responses.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { OPENAI_MODELS } from "./openai.models.ts";
+
+export function openaiProvider(): Provider<"openai-responses"> {
+	return createProvider({
+		id: "openai",
+		name: "OpenAI",
+		baseUrl: "https://api.openai.com/v1",
+		auth: { apiKey: envApiKeyAuth("OpenAI API key", ["OPENAI_API_KEY"]) },
+		models: Object.values(OPENAI_MODELS),
+		api: openAIResponsesApi(),
+	});
+}

packages/ai/src/providers/opencode-go.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/opencode-go.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const OPENCODE_GO_MODELS: ModelCatalog<typeof values, "opencode-go"> =
+	flattenModelCatalog("opencode-go", values);

packages/ai/src/providers/openrouter.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/openrouter.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const OPENROUTER_MODELS: ModelCatalog<typeof values, "openrouter"> =
+	flattenModelCatalog("openrouter", values);

packages/ai/src/providers/qwen-token-plan-individual.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/qwen-token-plan-individual.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const QWEN_TOKEN_PLAN_INDIVIDUAL_MODELS: ModelCatalog<typeof values, "qwen-token-plan-individual"> =
+	flattenModelCatalog("qwen-token-plan-individual", values);

packages/ai/src/providers/qwen-token-plan.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/qwen-token-plan.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const QWEN_TOKEN_PLAN_MODELS: ModelCatalog<typeof values, "qwen-token-plan"> =
+	flattenModelCatalog("qwen-token-plan", values);

packages/ai/src/providers/radius.ts

@@ -0,0 +1,82 @@
+import { piMessagesApi } from "../api/pi-messages.lazy.ts";
+import { envApiKeyAuth, lazyOAuth } from "../auth/helpers.ts";
+import { loadRadiusOAuth } from "../auth/oauth/load.ts";
+import type { Provider } from "../models.ts";
+import {
+	DEFAULT_RADIUS_GATEWAY,
+	getRadiusModels,
+	getRadiusModelsFromConfig,
+	loadRadiusGatewayConfig,
+	normalizeRadiusGatewayUrl,
+} from "./radius-config.ts";
+
+export interface RadiusProviderOptions {
+	id?: string;
+	name?: string;
+	gateway?: string;
+}
+
+/** Radius gateway provider with a persisted, dynamically refreshed catalog. */
+export function radiusProvider(options: RadiusProviderOptions = {}): Provider<"pi-messages"> {
+	const id = options.id ?? "radius";
+	const name = options.name ?? "Radius";
+	const gateway = normalizeRadiusGatewayUrl(options.gateway ?? DEFAULT_RADIUS_GATEWAY);
+	let models = getRadiusModels(id, undefined);
+	const streams = piMessagesApi();
+
+	return {
+		id,
+		name,
+		auth: {
+			apiKey: envApiKeyAuth("Radius API key", ["RADIUS_API_KEY"]),
+			oauth: lazyOAuth({ name, load: () => loadRadiusOAuth({ name, gateway }) }),
+		},
+		getModels: () => models,
+		refreshModels: async (context) => {
+			const stored = context.stored;
+			if (stored) {
+				const restored = stored.models.filter((model) => model.provider === id) as typeof models;
+				if (
+					!(await context.publish({
+						update: () => {
+							models = restored;
+						},
+					}))
+				) {
+					return;
+				}
+			}
+
+			// Import catalogs cached by the pre-ModelsStore Radius implementation.
+			if (!stored && context.credential?.type === "oauth") {
+				const legacy = getRadiusModels(id, context.credential);
+				if (legacy.length > 0) {
+					if (
+						!(await context.publish({
+							persist: { models: legacy, checkedAt: Date.now() },
+							update: () => {
+								models = legacy;
+							},
+						}))
+					) {
+						return;
+					}
+				}
+			}
+
+			if (!context.allowNetwork || context.signal.aborted) return;
+			const apiKey = context.credential?.type === "oauth" ? context.credential.access : context.credential?.key;
+			const config = await loadRadiusGatewayConfig(gateway, apiKey, context.signal);
+			if (context.signal.aborted) return;
+			const refreshed = getRadiusModelsFromConfig(id, config);
+			await context.publish({
+				persist: { models: refreshed, checkedAt: Date.now() },
+				update: () => {
+					models = refreshed;
+				},
+			});
+		},
+		stream: (model, context, streamOptions) => streams.stream(model, context, streamOptions),
+		streamSimple: (model, context, streamOptions) => streams.streamSimple(model, context, streamOptions),
+	};
+}

packages/ai/src/providers/xai.ts

@@ -0,0 +1,24 @@
+import { openAIResponsesApi } from "../api/openai-responses.lazy.ts";
+import { envApiKeyAuth, lazyOAuth } from "../auth/helpers.ts";
+import { loadXaiOAuth } from "../auth/oauth/load.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { XAI_MODELS } from "./xai.models.ts";
+
+export function xaiProvider(): Provider<"openai-responses"> {
+	return createProvider({
+		id: "xai",
+		name: "xAI",
+		baseUrl: "https://api.x.ai/v1",
+		auth: {
+			apiKey: envApiKeyAuth("xAI API key", ["XAI_API_KEY"]),
+			oauth: lazyOAuth({
+				name: "xAI (Grok/X subscription)",
+				isSubscription: true,
+				loginLabel: "Sign in with SuperGrok or X Premium",
+				load: loadXaiOAuth,
+			}),
+		},
+		models: Object.values(XAI_MODELS),
+		api: openAIResponsesApi(),
+	});
+}

packages/ai/src/providers/xiaomi-token-plan-cn.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/xiaomi-token-plan-cn.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const XIAOMI_TOKEN_PLAN_CN_MODELS: ModelCatalog<typeof values, "xiaomi-token-plan-cn"> =
+	flattenModelCatalog("xiaomi-token-plan-cn", values);

packages/ai/src/providers/xiaomi-token-plan-sgp.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/xiaomi-token-plan-sgp.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const XIAOMI_TOKEN_PLAN_SGP_MODELS: ModelCatalog<typeof values, "xiaomi-token-plan-sgp"> =
+	flattenModelCatalog("xiaomi-token-plan-sgp", values);

packages/ai/src/providers/xiaomi.ts

@@ -0,0 +1,15 @@
+import { openAICompletionsApi } from "../api/openai-completions.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { XIAOMI_MODELS } from "./xiaomi.models.ts";
+
+export function xiaomiProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "xiaomi",
+		name: "Xiaomi",
+		baseUrl: "https://api.xiaomimimo.com/v1",
+		auth: { apiKey: envApiKeyAuth("Xiaomi API key", ["XIAOMI_API_KEY"]) },
+		models: Object.values(XIAOMI_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

packages/ai/src/providers/zai-coding-cn.models.ts

@@ -0,0 +1,8 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import values from "./data/zai-coding-cn.json" with { type: "json" };
+import { flattenModelCatalog, type ModelCatalog } from "../model-catalog.ts";
+
+export const ZAI_CODING_CN_MODELS: ModelCatalog<typeof values, "zai-coding-cn"> =
+	flattenModelCatalog("zai-coding-cn", values);

packages/ai/test/abort.test.ts

@@ -0,0 +1,351 @@
+import { describe, expect, it } from "vitest";
+import { complete, getModel, stream } from "../src/compat.ts";
+import type { Api, Context, Model, StreamOptions } from "../src/types.ts";
+
+type StreamOptionsWithExtras = StreamOptions & Record<string, unknown>;
+
+import { hasAzureOpenAICredentials, resolveAzureDeploymentName } from "./azure-utils.ts";
+import { hasBedrockCredentials } from "./bedrock-utils.ts";
+import { resolveApiKey } from "./oauth.ts";
+
+// Resolve OAuth tokens at module level (async, runs before tests)
+const [openaiCodexToken] = await Promise.all([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-sonnet-4-6");
+
+		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.TOGETHER_API_KEY)("Together AI Provider Abort", () => {
+		const llm = getModel("together", "moonshotai/Kimi-K2.6");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm, { reasoningEffort: "high" });
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm, { reasoningEffort: "high" });
+		});
+	});
+
+	describe.skipIf(!process.env.BASETEN_API_KEY)("Baseten Provider Abort", () => {
+		const llm = getModel("baseten", "zai-org/GLM-5.2");
+
+		it("should abort mid-stream", { retry: 3 }, async () => {
+			await testAbortSignal(llm, { reasoningEffort: "high" });
+		});
+
+		it("should handle immediate abort", { retry: 3 }, async () => {
+			await testImmediateAbort(llm, { reasoningEffort: "high" });
+		});
+	});
+
+	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.XIAOMI_API_KEY)("Xiaomi MiMo (API billing) Provider Abort", () => {
+		const llm = getModel("xiaomi", "mimo-v2.5-pro");
+
+		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.XIAOMI_TOKEN_PLAN_CN_API_KEY)("Xiaomi MiMo Token Plan (CN) Provider Abort", () => {
+		const llm = getModel("xiaomi-token-plan-cn", "mimo-v2.5-pro");
+
+		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.XIAOMI_TOKEN_PLAN_AMS_API_KEY)("Xiaomi MiMo Token Plan (AMS) Provider Abort", () => {
+		const llm = getModel("xiaomi-token-plan-ams", "mimo-v2.5-pro");
+
+		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.XIAOMI_TOKEN_PLAN_SGP_API_KEY)("Xiaomi MiMo Token Plan (SGP) Provider Abort", () => {
+		const llm = getModel("xiaomi-token-plan-sgp", "mimo-v2.5-pro");
+
+		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.QWEN_TOKEN_PLAN_API_KEY)("Qwen Token Plan Provider Abort", () => {
+		const llm = getModel("qwen-token-plan", "qwen3.7-max");
+
+		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.QWEN_TOKEN_PLAN_API_KEY)("Qwen Token Plan Individual Provider Abort", () => {
+		const llm = getModel("qwen-token-plan-individual", "qwen3.8-max");
+
+		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.QWEN_TOKEN_PLAN_CN_API_KEY)("Qwen Token Plan (CN) Provider Abort", () => {
+		const llm = getModel("qwen-token-plan-cn", "qwen3.7-max");
+
+		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-for-coding");
+
+		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);
+		});
+	});
+
+	describe("OpenAI Codex Provider Abort", () => {
+		it.skipIf(!openaiCodexToken)("should abort mid-stream", { retry: 3 }, async () => {
+			const llm = getModel("openai-codex", "gpt-5.5");
+			await testAbortSignal(llm, { apiKey: openaiCodexToken });
+		});
+
+		it.skipIf(!openaiCodexToken)("should handle immediate abort", { retry: 3 }, async () => {
+			const llm = getModel("openai-codex", "gpt-5.5");
+			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);
+		});
+	});
+});

packages/ai/test/anthropic-cache-write-1h-cost.test.ts

@@ -0,0 +1,86 @@
+import type Anthropic from "@anthropic-ai/sdk";
+import { describe, expect, it } from "vitest";
+import { stream as streamAnthropic } from "../src/api/anthropic-messages.ts";
+import { getModel } from "../src/compat.ts";
+import type { Context } from "../src/types.ts";
+
+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 {
+		beta: { messages: { create: () => ({ asResponse: async () => response }) } },
+	} as unknown as Anthropic;
+}
+
+function eventsWithCacheCreation(
+	cacheCreation: Record<string, number> | undefined,
+): Array<{ event: string; data: string }> {
+	const startUsage: Record<string, unknown> = {
+		input_tokens: 100,
+		output_tokens: 0,
+		cache_read_input_tokens: 0,
+		cache_creation_input_tokens: 1_000_000,
+	};
+	if (cacheCreation) startUsage.cache_creation = cacheCreation;
+	return [
+		{
+			event: "message_start",
+			data: JSON.stringify({ type: "message_start", message: { id: "msg_test", usage: startUsage } }),
+		},
+		{
+			event: "content_block_start",
+			data: JSON.stringify({ type: "content_block_start", index: 0, content_block: { type: "text", text: "" } }),
+		},
+		{
+			event: "content_block_delta",
+			data: JSON.stringify({ type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Hi" } }),
+		},
+		{ 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: "end_turn" },
+				usage: {
+					input_tokens: 100,
+					output_tokens: 5,
+					cache_read_input_tokens: 0,
+					cache_creation_input_tokens: 1_000_000,
+				},
+			}),
+		},
+		{ event: "message_stop", data: JSON.stringify({ type: "message_stop" }) },
+	];
+}
+
+// claude-opus-4-8: input 5, cacheWrite (5m) 6.25 per Mtok. 1h write = 2x input = 10.
+const context: Context = { messages: [{ role: "user", content: "hi", timestamp: Date.now() }] };
+
+describe("Anthropic 1h cache write cost", () => {
+	it("prices the 1h portion at 2x input and the rest at the 5m rate", async () => {
+		const model = getModel("anthropic", "claude-opus-4-8");
+		const response = createSseResponse(
+			eventsWithCacheCreation({ ephemeral_5m_input_tokens: 600_000, ephemeral_1h_input_tokens: 400_000 }),
+		);
+		const result = await streamAnthropic(model, context, { client: createFakeAnthropicClient(response) }).result();
+
+		expect(result.usage.cacheWrite).toBe(1_000_000);
+		expect(result.usage.cacheWrite1h).toBe(400_000);
+		// 600k * 6.25/Mtok + 400k * 10/Mtok = 3.75 + 4.0 = 7.75
+		expect(result.usage.cost.cacheWrite).toBeCloseTo(7.75, 10);
+	});
+
+	it("falls back to the 5m rate when no breakdown is reported", async () => {
+		const model = getModel("anthropic", "claude-opus-4-8");
+		const response = createSseResponse(eventsWithCacheCreation(undefined));
+		const result = await streamAnthropic(model, context, { client: createFakeAnthropicClient(response) }).result();
+
+		expect(result.usage.cacheWrite).toBe(1_000_000);
+		expect(result.usage.cacheWrite1h ?? 0).toBe(0);
+		// 1M * 6.25/Mtok = 6.25
+		expect(result.usage.cost.cacheWrite).toBeCloseTo(6.25, 10);
+	});
+});

packages/ai/test/anthropic-long-cache-retention-e2e.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from "vitest";
+import { type BuiltinProvider, complete, getModels, getProviders } from "../src/compat.ts";
+import { getEnvApiKey } from "../src/env-api-keys.ts";
+import type { Api, KnownProvider, Model, ProviderStreamOptions } from "../src/types.ts";
+import { resolveApiKey } from "./oauth.ts";
+
+const githubCopilotToken = await resolveApiKey("github-copilot");
+
+interface AnthropicLongCacheRetentionE2ECase {
+	name: string;
+	provider: BuiltinProvider;
+	model: Model<"anthropic-messages">;
+	apiKey: string | undefined;
+}
+
+function getE2EApiKey(provider: KnownProvider): string | undefined {
+	if (provider === "github-copilot") {
+		return githubCopilotToken;
+	}
+	return getEnvApiKey(provider);
+}
+
+function getAnthropicMessagesModels(provider: BuiltinProvider): Model<"anthropic-messages">[] {
+	const models = getModels(provider) as Model<Api>[];
+	return models.filter((model) => model.api === "anthropic-messages") as Model<"anthropic-messages">[];
+}
+
+const anthropicMessagesCases: AnthropicLongCacheRetentionE2ECase[] = getProviders().flatMap((provider) =>
+	getAnthropicMessagesModels(provider).map((model) => ({
+		name: `${provider}/${model.id}`,
+		provider,
+		model,
+		apiKey: getE2EApiKey(provider),
+	})),
+);
+
+function getProbePriority(model: Model<"anthropic-messages">): number {
+	const modelId = model.id.toLowerCase();
+	const cost = model.cost.input + model.cost.output;
+	let priority = cost;
+
+	if (modelId.includes("haiku") && (modelId.includes("4-5") || modelId.includes("4.5"))) {
+		priority -= 1000;
+	} else if (modelId.includes("sonnet") && (modelId.includes("4-") || modelId.includes("4."))) {
+		priority -= 750;
+	} else if (modelId.includes("claude") && (modelId.includes("4-") || modelId.includes("4."))) {
+		priority -= 500;
+	}
+
+	return priority;
+}
+
+function selectOneCasePerProvider(cases: AnthropicLongCacheRetentionE2ECase[]): AnthropicLongCacheRetentionE2ECase[] {
+	const byProvider = new Map<BuiltinProvider, AnthropicLongCacheRetentionE2ECase[]>();
+	for (const testCase of cases) {
+		const providerCases = byProvider.get(testCase.provider) ?? [];
+		providerCases.push(testCase);
+		byProvider.set(testCase.provider, providerCases);
+	}
+
+	return Array.from(byProvider.values()).map(
+		(providerCases) =>
+			providerCases.sort(
+				(a, b) => getProbePriority(a.model) - getProbePriority(b.model) || a.model.id.localeCompare(b.model.id),
+			)[0],
+	);
+}
+
+const probeCases = selectOneCasePerProvider(anthropicMessagesCases);
+
+function withLongCacheRetention(model: Model<"anthropic-messages">): Model<"anthropic-messages"> {
+	return {
+		...model,
+		compat: {
+			...model.compat,
+			supportsLongCacheRetention: true,
+		},
+	};
+}
+
+async function expectLongCacheRetentionAccepted(
+	model: Model<"anthropic-messages">,
+	apiKey: string | undefined,
+): Promise<void> {
+	const options: ProviderStreamOptions = {
+		apiKey,
+		cacheRetention: "long",
+		maxTokens: 128,
+		thinkingEnabled: false,
+	};
+	const response = await complete(
+		model,
+		{
+			systemPrompt: "You are a concise assistant.",
+			messages: [
+				{
+					role: "user",
+					content: "Reply with exactly: long cache retention accepted",
+					timestamp: Date.now(),
+				},
+			],
+		},
+		options,
+	);
+
+	expect(response.errorMessage, response.errorMessage).toBeFalsy();
+	expect(response.stopReason, response.errorMessage).not.toBe("error");
+}
+
+describe("Anthropic Messages long cache retention E2E", () => {
+	it("covers every generated anthropic-messages model", () => {
+		const expectedModels = getProviders().flatMap((provider) =>
+			getAnthropicMessagesModels(provider).map((model) => `${provider}/${model.id}`),
+		);
+		expect(anthropicMessagesCases.map((testCase) => testCase.name).sort()).toEqual(expectedModels.sort());
+	});
+
+	describe("forced long cache retention probe", () => {
+		for (const testCase of probeCases) {
+			const model = withLongCacheRetention(testCase.model);
+
+			it.skipIf(!testCase.apiKey)(`${testCase.name} accepts long cache retention`, { retry: 2 }, async () => {
+				await expectLongCacheRetentionAccepted(model, testCase.apiKey);
+			});
+		}
+	});
+});

packages/ai/test/anthropic-mid-conversation-effort.test.ts

@@ -0,0 +1,212 @@
+import { describe, expect, it } from "vitest";
+import { stream } from "../src/api/anthropic-messages.ts";
+import { getModel } from "../src/compat.ts";
+import type { AssistantMessage, Context, Model } from "../src/types.ts";
+
+interface WireMessage {
+	role: string;
+	content: unknown;
+	output_config?: { effort?: string };
+}
+
+interface CapturedPayload {
+	messages: WireMessage[];
+	thinking?: {
+		type: string;
+		display?: string;
+		block_binding?: { prefix_mismatch_behavior?: string };
+	};
+	output_config?: { effort?: string };
+	fallbacks?: Array<{ model: string }>;
+}
+
+function managedModel(provider = "anthropic"): Model<"anthropic-messages"> {
+	return {
+		id: "claude-fable-5-1",
+		name: "Claude Fable 5.1",
+		api: "anthropic-messages",
+		provider,
+		baseUrl: "http://127.0.0.1:9",
+		reasoning: true,
+		thinkingLevelMap: { off: null, minimal: "low", low: "low", medium: "medium", high: "high", max: "max" },
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 200000,
+		maxTokens: 32000,
+		compat: { forceAdaptiveThinking: true, supportsMidConvoEffort: true },
+	};
+}
+
+function assistant(model: Model<"anthropic-messages">, level?: string): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [
+			{ type: "thinking", thinking: "reasoning", thinkingSignature: "signature" },
+			{ type: "text", text: "answer" },
+		],
+		api: "anthropic-messages",
+		provider: model.provider,
+		model: model.id,
+		...(level === undefined ? {} : { providerThinkingLevel: level }),
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: 1,
+	};
+}
+
+async function capture(
+	model: Model<"anthropic-messages">,
+	context: Context,
+	effort?: "low" | "medium" | "high" | "xhigh" | "max",
+): Promise<{ payload: CapturedPayload; message: AssistantMessage }> {
+	let payload: CapturedPayload | undefined;
+	const result = stream(model, context, {
+		apiKey: "test-key",
+		cacheRetention: "none",
+		thinkingEnabled: true,
+		effort,
+		onPayload: (value) => {
+			payload = value as CapturedPayload;
+			throw new Error("payload captured");
+		},
+	});
+	const message = await result.result();
+	if (!payload) throw new Error("Expected payload capture");
+	return { payload, message };
+}
+
+const user = (text: string, timestamp: number) => ({ role: "user" as const, content: text, timestamp });
+
+function effortMessages(payload: CapturedPayload): WireMessage[] {
+	return payload.messages.filter((message) => message.role === "system");
+}
+
+describe("Anthropic mid-conversation effort", () => {
+	it("reconstructs an exact historical marker prefix and appends the current marker", async () => {
+		const model = managedModel();
+		const first = await capture(model, { messages: [user("one", 1)] }, "low");
+		const second = await capture(
+			model,
+			{ messages: [user("one", 1), assistant(model, "low"), user("two", 2)] },
+			"high",
+		);
+
+		expect(first.payload.messages).toEqual([
+			{ role: "user", content: "one" },
+			{ role: "system", content: [], output_config: { effort: "low" } },
+		]);
+		expect(second.payload.messages.slice(0, first.payload.messages.length)).toEqual(first.payload.messages);
+		expect(second.payload.messages.at(-1)).toEqual({
+			role: "system",
+			content: [],
+			output_config: { effort: "high" },
+		});
+		expect(first.payload.output_config).toEqual({ effort: "high" });
+		expect(second.payload.output_config).toEqual({ effort: "high" });
+		expect(second.payload.thinking).toEqual({
+			type: "adaptive",
+			display: "summarized",
+			block_binding: { prefix_mismatch_behavior: "drop_block" },
+		});
+		expect(first.message.providerThinkingLevel).toBe("low");
+	});
+
+	it.each(["low", "medium", "high", "xhigh", "max"] as const)("preserves native effort %s", async (effort) => {
+		const model = managedModel();
+		const { payload, message } = await capture(model, { messages: [user("one", 1)] }, effort);
+		expect(effortMessages(payload)).toEqual([{ role: "system", content: [], output_config: { effort } }]);
+		expect(message.providerThinkingLevel).toBe(effort);
+	});
+
+	it("defaults omitted effort to high and still enables drop_block", async () => {
+		const { payload, message } = await capture(managedModel(), { messages: [user("one", 1)] });
+		expect(payload.messages.at(-1)).toEqual({
+			role: "system",
+			content: [],
+			output_config: { effort: "high" },
+		});
+		expect(payload.thinking?.block_binding?.prefix_mismatch_behavior).toBe("drop_block");
+		expect(message.providerThinkingLevel).toBe("high");
+	});
+
+	it("does not invent markers for legacy or other-provider assistants", async () => {
+		const model = managedModel();
+		const legacy = assistant(model);
+		const otherProvider = { ...assistant(model, "low"), provider: "other-provider" };
+		const { payload } = await capture(
+			model,
+			{ messages: [user("one", 1), legacy, user("two", 2), otherProvider, user("three", 3)] },
+			"medium",
+		);
+		expect(effortMessages(payload)).toEqual([{ role: "system", content: [], output_config: { effort: "medium" } }]);
+	});
+
+	it("leaves unsupported models on top-level effort", async () => {
+		const model = managedModel();
+		model.compat = { forceAdaptiveThinking: true };
+		const { payload, message } = await capture(model, { messages: [user("one", 1)] }, "low");
+		expect(payload.messages).toEqual([{ role: "user", content: "one" }]);
+		expect(payload.output_config).toEqual({ effort: "low" });
+		expect(payload.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		expect(message.providerThinkingLevel).toBeUndefined();
+	});
+
+	it("sends the effort and binding beta headers", async () => {
+		let betaHeader: string | null = null;
+		const events = [
+			{
+				type: "message_start",
+				message: {
+					id: "msg_test",
+					model: "claude-fable-5-1",
+					usage: { input_tokens: 1, output_tokens: 0 },
+				},
+			},
+			{
+				type: "message_delta",
+				delta: { stop_reason: "end_turn" },
+				usage: { input_tokens: 1, output_tokens: 1 },
+			},
+			{ type: "message_stop" },
+		];
+		const body = events.map((event) => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join("");
+		const fetchImpl: typeof fetch = async (input, init) => {
+			const request = input instanceof Request ? input : new Request(input, init);
+			betaHeader = request.headers.get("anthropic-beta");
+			return new Response(body, { status: 200, headers: { "content-type": "text/event-stream" } });
+		};
+		const result = await stream(
+			managedModel(),
+			{ messages: [user("one", 1)] },
+			{
+				apiKey: "test-key",
+				cacheRetention: "none",
+				fetch: fetchImpl,
+			},
+		).result();
+
+		expect(result.stopReason).toBe("stop");
+		expect(betaHeader).toContain("mid-conversation-output-config-2026-07-01");
+		expect(betaHeader).toContain("thinking-binding-controls-2026-08-01");
+	});
+
+	it("generates exact model and transport gates", () => {
+		const direct = getModel("anthropic", "claude-fable-5-1");
+		const openRouter = getModel("openrouter", "anthropic/claude-fable-5.1");
+		const unsupported = getModel("anthropic", "claude-opus-4-8");
+		expect(direct.compat?.supportsMidConvoEffort).toBe(true);
+		expect(direct.thinkingLevelMap?.off).toBeNull();
+		expect(openRouter.api).toBe("anthropic-messages");
+		expect(openRouter.baseUrl).toBe("https://openrouter.ai/api");
+		expect(openRouter.compat?.supportsMidConvoEffort).toBe(true);
+		expect(unsupported.compat?.supportsMidConvoEffort).toBeUndefined();
+		expect(getModel("anthropic", "claude-opus-5").compat?.allowedFallbackModels).toBeUndefined();
+	});
+});

packages/ai/test/anthropic-oauth.test.ts

@@ -0,0 +1,144 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { anthropicOAuth } from "../src/auth/oauth/anthropic.ts";
+import type { AuthEvent, AuthPrompt } from "../src/auth/types.ts";
+
+const neverAbortedSignal = new AbortController().signal;
+
+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 anthropicOAuth.login({
+			signal: neverAbortedSignal,
+			notify: (event) => {
+				if (event.type === "auth_url") authUrl = event.url;
+			},
+			prompt: async (prompt) => {
+				if (prompt.type !== "manual_code") throw new Error(`Unexpected prompt: ${prompt.type}`);
+				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 anthropicOAuth.refresh(
+			{
+				type: "oauth",
+				access: "old-access-token",
+				refresh: "refresh-token",
+				expires: 0,
+			},
+			neverAbortedSignal,
+		);
+
+		expect(credentials.access).toBe("new-access-token");
+		expect(credentials.refresh).toBe("new-refresh-token");
+		expect(fetchMock).toHaveBeenCalledOnce();
+	});
+
+	it("anthropicOAuth.login resolves through the manual_code prompt and aborts it after settling", async () => {
+		const fetchMock = vi.fn(async (input: unknown): Promise<Response> => {
+			const url = typeof input === "string" ? input : String(input);
+			if (url.includes("/oauth/token")) {
+				return jsonResponse({ access_token: "access", refresh_token: "refresh", expires_in: 3600 });
+			}
+			throw new Error(`Unexpected fetch: ${url}`);
+		});
+		vi.stubGlobal("fetch", fetchMock);
+
+		const events: AuthEvent[] = [];
+		const prompts: AuthPrompt[] = [];
+		let manualSignal: AbortSignal | undefined;
+
+		const credential = await anthropicOAuth.login({
+			signal: neverAbortedSignal,
+			notify: (event) => events.push(event),
+			prompt: async (prompt) => {
+				prompts.push(prompt);
+				if (prompt.type === "manual_code") {
+					manualSignal = prompt.signal;
+					return "the-code";
+				}
+				throw new Error(`Unexpected prompt: ${prompt.type}`);
+			},
+		});
+
+		expect(credential.type).toBe("oauth");
+		expect(credential.access).toBe("access");
+		expect(events.some((e) => e.type === "auth_url")).toBe(true);
+		expect(prompts.some((p) => p.type === "manual_code")).toBe(true);
+		// the prompt's signal is aborted once login settles, so UIs can dismiss it
+		expect(manualSignal?.aborted).toBe(true);
+	});
+});

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

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { getModel, streamSimple } from "../src/compat.ts";
+import type { Context } from "../src/types.ts";
+
+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.8 smoke", () => {
+	it("streams Claude Opus 4.8 with reasoning enabled", { retry: 2, timeout: 30000 }, async () => {
+		const model = getModel("anthropic", "claude-opus-4-8");
+		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.8");
+		}
+		expect(typeof thinkingBlock.thinkingSignature).toBe("string");
+		const thinkingSignature = thinkingBlock.thinkingSignature;
+		if (!thinkingSignature) {
+			throw new Error("Expected thinking signature from Claude Opus 4.8");
+		}
+		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-sse-parsing.test.ts

@@ -0,0 +1,585 @@
+import type Anthropic from "@anthropic-ai/sdk";
+import { Type } from "typebox";
+import { describe, expect, it } from "vitest";
+import { stream as streamAnthropic } from "../src/api/anthropic-messages.ts";
+import { getModel } from "../src/compat.ts";
+import type { Context, ToolCall } from "../src/types.ts";
+
+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" },
+	});
+}
+
+const minimalAnthropicEvents = [
+	{
+		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: "text", text: "" },
+		}),
+	},
+	{
+		event: "content_block_delta",
+		data: JSON.stringify({
+			type: "content_block_delta",
+			index: 0,
+			delta: { type: "text_delta", text: "Hello" },
+		}),
+	},
+	{
+		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: "end_turn" },
+			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" }),
+	},
+];
+
+function createFakeAnthropicClient(response: Response): Anthropic {
+	return {
+		beta: {
+			messages: {
+				create: () => ({
+					asResponse: async () => response,
+				}),
+			},
+		},
+	} as unknown as Anthropic;
+}
+
+describe("Anthropic raw SSE parsing", () => {
+	it("fails safely when Anthropic falls back after output begins", async () => {
+		const model = getModel("anthropic", "claude-opus-5");
+		const response = createSseResponse([
+			{
+				event: "message_start",
+				data: JSON.stringify({
+					type: "message_start",
+					message: {
+						id: "msg_fallback",
+						model: "claude-opus-5",
+						usage: { input_tokens: 1, output_tokens: 0 },
+					},
+				}),
+			},
+			{
+				event: "content_block_start",
+				data: JSON.stringify({
+					type: "content_block_start",
+					index: 0,
+					content_block: { type: "text", text: "partial" },
+				}),
+			},
+			{ event: "content_block_stop", data: JSON.stringify({ type: "content_block_stop", index: 0 }) },
+			{
+				event: "content_block_start",
+				data: JSON.stringify({
+					type: "content_block_start",
+					index: 1,
+					content_block: {
+						type: "fallback",
+						from: { model: "claude-opus-5" },
+						to: { model: "claude-opus-4-8" },
+					},
+				}),
+			},
+		]);
+
+		const result = await streamAnthropic(
+			model,
+			{ messages: [{ role: "user", content: "Hello", timestamp: 1 }] },
+			{ client: createFakeAnthropicClient(response) },
+		).result();
+
+		expect(result.stopReason).toBe("error");
+		expect(result.errorMessage).toContain("unsupported mid-output model fallback");
+	});
+
+	it("forces streaming after an onPayload replacement", async () => {
+		let streaming: boolean | undefined;
+		const client = {
+			beta: {
+				messages: {
+					create: (params: { stream?: boolean }) => {
+						streaming = params.stream;
+						return { asResponse: async () => createSseResponse(minimalAnthropicEvents) };
+					},
+				},
+			},
+		} as unknown as Anthropic;
+
+		await streamAnthropic(
+			getModel("anthropic", "claude-fable-5-1"),
+			{ messages: [{ role: "user", content: "Hello", timestamp: 1 }] },
+			{
+				client,
+				onPayload: (payload) => ({ ...(payload as Record<string, unknown>), stream: false }),
+			},
+		).result();
+
+		expect(streaming).toBe(true);
+	});
+
+	it("omits the interleaved-thinking beta when thinking is disabled", async () => {
+		let betaFeatures: string[] | undefined;
+		const client = {
+			beta: {
+				messages: {
+					create: (params: { betas?: string[] }) => {
+						betaFeatures = params.betas;
+						return { asResponse: async () => createSseResponse(minimalAnthropicEvents) };
+					},
+				},
+			},
+		} as unknown as Anthropic;
+
+		await streamAnthropic(
+			getModel("openrouter", "anthropic/claude-3-haiku"),
+			{ messages: [{ role: "user", content: "Hello", timestamp: 1 }] },
+			{ client, thinkingEnabled: false },
+		).result();
+
+		expect(betaFeatures ?? []).not.toContain("interleaved-thinking-2025-05-14");
+	});
+
+	it("passes managed beta features to injected clients", async () => {
+		let betaFeatures: string[] | undefined;
+		const client = {
+			beta: {
+				messages: {
+					create: (params: { betas?: string[] }) => {
+						betaFeatures = params.betas;
+						return { asResponse: async () => createSseResponse(minimalAnthropicEvents) };
+					},
+				},
+			},
+		} as unknown as Anthropic;
+
+		const result = await streamAnthropic(
+			getModel("anthropic", "claude-fable-5-1"),
+			{ messages: [{ role: "user", content: "Hello", timestamp: 1 }] },
+			{ client },
+		).result();
+
+		expect(result.stopReason).toBe("stop");
+		expect(betaFeatures).toContain("mid-conversation-output-config-2026-07-01");
+		expect(betaFeatures).toContain("thinking-binding-controls-2026-08-01");
+	});
+
+	it("uses the serving model input transformations from the final stream event", async () => {
+		const events = minimalAnthropicEvents.map((event) => ({ ...event }));
+		events[0].data = JSON.stringify({
+			type: "message_start",
+			message: {
+				id: "msg_transformations",
+				model: "claude-fable-5-1",
+				usage: { input_tokens: 12, output_tokens: 0 },
+				input_transformations: [
+					{ type: "thinking_dropped", path: "messages.1.content.0", reason: "prefix_binding_mismatch" },
+				],
+			},
+		});
+		const delta = JSON.parse(events[4].data) as Record<string, unknown>;
+		delta.input_transformations = [
+			{ type: "thinking_dropped", path: "messages.3.content.0", reason: "model_binding_mismatch" },
+		];
+		events[4].data = JSON.stringify(delta);
+
+		const result = await streamAnthropic(
+			getModel("anthropic", "claude-fable-5-1"),
+			{ messages: [{ role: "user", content: "Hello", timestamp: 1 }] },
+			{ client: createFakeAnthropicClient(createSseResponse(events)) },
+		).result();
+
+		expect(result.diagnostics).toEqual([
+			{
+				type: "anthropic_input_transformations",
+				timestamp: expect.any(Number),
+				details: {
+					transformations: [
+						{
+							type: "thinking_dropped",
+							path: "messages.3.content.0",
+							reason: "model_binding_mismatch",
+						},
+					],
+				},
+			},
+		]);
+	});
+	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",
+		});
+	});
+
+	it("preserves content from content_block_start events", async () => {
+		const model = getModel("anthropic", "claude-haiku-4-5");
+		const context: Context = {
+			messages: [{ role: "user", content: "Say hello.", timestamp: Date.now() }],
+		};
+		const response = createSseResponse([
+			{
+				event: "message_start",
+				data: JSON.stringify({
+					type: "message_start",
+					message: {
+						id: "msg_initial_content",
+						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: "text", text: "Initial text" },
+				}),
+			},
+			{
+				event: "content_block_delta",
+				data: JSON.stringify({
+					type: "content_block_delta",
+					index: 0,
+					delta: { type: "text_delta", text: " plus delta" },
+				}),
+			},
+			{ event: "content_block_stop", data: JSON.stringify({ type: "content_block_stop", index: 0 }) },
+			{
+				event: "content_block_start",
+				data: JSON.stringify({
+					type: "content_block_start",
+					index: 1,
+					content_block: {
+						type: "thinking",
+						thinking: "Initial thinking",
+						signature: "initial signature",
+					},
+				}),
+			},
+			{
+				event: "content_block_delta",
+				data: JSON.stringify({
+					type: "content_block_delta",
+					index: 1,
+					delta: { type: "thinking_delta", thinking: " plus delta" },
+				}),
+			},
+			{
+				event: "content_block_delta",
+				data: JSON.stringify({
+					type: "content_block_delta",
+					index: 1,
+					delta: { type: "signature_delta", signature: " plus delta" },
+				}),
+			},
+			{ event: "content_block_stop", data: JSON.stringify({ type: "content_block_stop", index: 1 }) },
+			{
+				event: "message_delta",
+				data: JSON.stringify({
+					type: "message_delta",
+					delta: { stop_reason: "end_turn" },
+					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.content).toEqual([
+			{ type: "text", text: "Initial text plus delta" },
+			{
+				type: "thinking",
+				thinking: "Initial thinking plus delta",
+				thinkingSignature: "initial signature plus delta",
+			},
+		]);
+	});
+
+	it("preserves refusal stop details from message_delta", async () => {
+		const model = getModel("anthropic", "claude-fable-5");
+		const context: Context = {
+			messages: [{ role: "user", content: "blocked request", timestamp: Date.now() }],
+		};
+		const explanation =
+			"This request triggered restrictions on violative cyber content and was blocked under Anthropic's Usage Policy. To learn more, provide feedback, or request an exemption based on how you use Claude, visit our help center: https://support.claude.com/en/articles/14604842-real-time-cyber-safeguards-on-claude.";
+		const response = createSseResponse([
+			{
+				event: "message_start",
+				data: JSON.stringify({
+					type: "message_start",
+					message: {
+						id: "msg_01XFUDYJgAACzvnptvVoYEL",
+						usage: {
+							input_tokens: 412,
+							output_tokens: 0,
+							cache_read_input_tokens: 0,
+							cache_creation_input_tokens: 0,
+						},
+					},
+				}),
+			},
+			{
+				event: "message_delta",
+				data: JSON.stringify({
+					type: "message_delta",
+					delta: {
+						stop_reason: "refusal",
+						stop_details: {
+							type: "refusal",
+							category: "cyber",
+							explanation,
+						},
+					},
+					usage: {
+						input_tokens: 412,
+						output_tokens: 0,
+						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("error");
+		expect(result.rawStopReason).toBe("refusal");
+		expect(result.errorMessage).toBe(explanation);
+	});
+
+	it("preserves sensitive stop reasons with a descriptive error message", async () => {
+		const model = getModel("anthropic", "claude-haiku-4-5");
+		const context: Context = {
+			messages: [{ role: "user", content: "blocked request", timestamp: Date.now() }],
+		};
+		const response = createSseResponse([
+			{
+				event: "message_start",
+				data: JSON.stringify({
+					type: "message_start",
+					message: {
+						id: "msg_sensitive",
+						usage: {
+							input_tokens: 12,
+							output_tokens: 0,
+							cache_read_input_tokens: 0,
+							cache_creation_input_tokens: 0,
+						},
+					},
+				}),
+			},
+			{
+				event: "message_delta",
+				data: JSON.stringify({
+					type: "message_delta",
+					delta: { stop_reason: "sensitive" },
+					usage: {
+						input_tokens: 12,
+						output_tokens: 0,
+						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("error");
+		expect(result.rawStopReason).toBe("sensitive");
+		expect(result.errorMessage).toBe("Provider stopped with: sensitive");
+	});
+
+	it("treats message_delta without usage as a no-op for usage accumulation", async () => {
+		const model = getModel("anthropic", "claude-haiku-4-5");
+		const context: Context = {
+			messages: [{ role: "user", content: "Say hello.", timestamp: Date.now() }],
+		};
+		const response = createSseResponse(
+			minimalAnthropicEvents.map((event) =>
+				event.event === "message_delta"
+					? {
+							event: "message_delta",
+							data: JSON.stringify({ type: "message_delta", delta: { stop_reason: "end_turn" } }),
+						}
+					: event,
+			),
+		);
+
+		const stream = streamAnthropic(model, context, {
+			client: createFakeAnthropicClient(response),
+		});
+		const result = await stream.result();
+
+		expect(result.stopReason).toBe("stop");
+		expect(result.errorMessage).toBeUndefined();
+		expect(result.content).toEqual([{ type: "text", text: "Hello" }]);
+		expect(result.usage.input).toBe(12);
+		expect(result.usage.totalTokens).toBe(12);
+	});
+
+	it("ignores unknown SSE events after message_stop", async () => {
+		const model = getModel("anthropic", "claude-haiku-4-5");
+		const context: Context = {
+			messages: [{ role: "user", content: "Say hello.", timestamp: Date.now() }],
+		};
+		const response = createSseResponse([
+			...minimalAnthropicEvents,
+			{ event: "done", data: "[DONE]" },
+			{ event: "proxy.stats", data: "not json" },
+		]);
+
+		const stream = streamAnthropic(model, context, {
+			client: createFakeAnthropicClient(response),
+		});
+		const result = await stream.result();
+
+		expect(result.stopReason).toBe("stop");
+		expect(result.errorMessage).toBeUndefined();
+		expect(result.content).toEqual([{ type: "text", text: "Hello" }]);
+	});
+});

packages/ai/test/anthropic-thinking-binding-e2e.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { stream } from "../src/api/anthropic-messages.ts";
+import { getModel } from "../src/compat.ts";
+import type { AssistantMessage, Context } from "../src/types.ts";
+
+const enabled = Boolean(process.env.ANTHROPIC_API_KEY);
+const model = getModel("anthropic", "claude-fable-5-1");
+const user = (content: string, timestamp: number) => ({ role: "user" as const, content, timestamp });
+
+function strictBinding(payload: unknown): unknown {
+	const params = payload as {
+		thinking?: {
+			block_binding?: { prefix_mismatch_behavior?: "drop_block" | "error" };
+		};
+	};
+	if (params.thinking?.block_binding) {
+		params.thinking.block_binding.prefix_mismatch_behavior = "error";
+	}
+	return params;
+}
+
+async function request(context: Context, effort: "low" | "high"): Promise<AssistantMessage> {
+	return stream(model, context, {
+		apiKey: process.env.ANTHROPIC_API_KEY,
+		cacheRetention: "none",
+		maxTokens: 1536,
+		thinkingEnabled: true,
+		thinkingDisplay: "summarized",
+		effort,
+		onPayload: strictBinding,
+	}).result();
+}
+
+describe.skipIf(!enabled)("Anthropic thinking binding conformance", () => {
+	it("replays managed effort markers required by signed Fable thinking", { timeout: 120000 }, async () => {
+		const firstUser = user("Compute 982451653 multiplied by 961748941. Return only the integer.", 1);
+		const first = await request({ messages: [firstUser] }, "low");
+		expect(first.stopReason, first.errorMessage).toBe("stop");
+		expect(
+			first.content.some(
+				(block) =>
+					block.type === "thinking" &&
+					typeof block.thinkingSignature === "string" &&
+					block.thinkingSignature.length > 0,
+			),
+		).toBe(true);
+		expect(first.providerThinkingLevel).toBe("low");
+
+		const secondUser = user("Reply with exactly: ok", 2);
+		const exact = await request({ messages: [firstUser, first, secondUser] }, "high");
+		expect(exact.stopReason, exact.errorMessage).toBe("stop");
+
+		const unmanagedHistory: AssistantMessage = { ...first };
+		delete unmanagedHistory.providerThinkingLevel;
+		const missingMarker = await request({ messages: [firstUser, unmanagedHistory, secondUser] }, "high");
+		expect(missingMarker.stopReason).toBe("error");
+		expect(missingMarker.errorMessage).toContain("Invalid `signature`");
+	});
+});

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

@@ -0,0 +1,172 @@
+import { describe, expect, it } from "vitest";
+import { getModel, streamSimple } from "../src/compat.ts";
+import type { Context, Model, SimpleStreamOptions } from "../src/types.ts";
+
+interface AnthropicThinkingPayload {
+	thinking?: { type: string; budget_tokens?: number; display?: string };
+	output_config?: { effort?: string };
+}
+
+class PayloadCaptured extends Error {
+	constructor() {
+		super("payload captured");
+		this.name = "PayloadCaptured";
+	}
+}
+
+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;
+			throw new PayloadCaptured();
+		},
+	});
+
+	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.8 when thinking is off", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-opus-4-8"));
+
+		expect(payload.thinking).toEqual({ type: "disabled" });
+		expect(payload.output_config).toBeUndefined();
+	});
+
+	it("omits thinking.type=disabled for Claude Fable 5 when thinking is off", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-fable-5"));
+
+		expect(payload.thinking).toBeUndefined();
+		expect(payload.output_config).toBeUndefined();
+	});
+
+	it("uses adaptive thinking for Claude Opus 4.8 when reasoning is enabled", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-opus-4-8"), { reasoning: "high" });
+
+		expect(payload.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		expect(payload.output_config).toEqual({ effort: "high" });
+	});
+
+	it("uses adaptive thinking for Claude Sonnet 5 when reasoning is enabled", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-sonnet-5"), { 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.8", async () => {
+		const payload = await capturePayload(getModel("anthropic", "claude-opus-4-8"), { 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);
+	});
+});

packages/ai/test/assistant-message-frame.test.ts

@@ -0,0 +1,606 @@
+import type { ResponseStreamEvent } from "openai/resources/responses/responses.js";
+import { describe, expect, it } from "vitest";
+import { processResponsesStream } from "../src/api/openai-responses-shared.ts";
+import {
+	type AssistantMessage,
+	type AssistantMessageEvent,
+	type AssistantMessageFrame,
+	AssistantMessageFrameEncoder,
+	type Model,
+	reduceAssistantMessageFrames,
+} from "../src/index.ts";
+import { AssistantMessageEventStream } from "../src/utils/event-stream.ts";
+
+function seed(): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [],
+		api: "test-api",
+		provider: "test-provider",
+		model: "test-model",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "pending",
+		timestamp: 1,
+	};
+}
+
+function frame(encoder: AssistantMessageFrameEncoder, event: AssistantMessageEvent): AssistantMessageFrame {
+	const converted = encoder.encode(event);
+	if (!converted) throw new Error(`Expected ${event.type} event to produce a frame`);
+	return converted;
+}
+
+describe("assistant message frames", () => {
+	it("uses authoritative text end content and signature", () => {
+		const partial = seed();
+		const encoder = new AssistantMessageFrameEncoder();
+		const frames: AssistantMessageFrame[] = [frame(encoder, { type: "start", partial })];
+		partial.content.push({ type: "text", text: "Hello " });
+		frames.push(frame(encoder, { type: "text_start", contentIndex: 0, partial }));
+		partial.content[0] = { type: "text", text: "Hello world", textSignature: "sig-text" };
+		frames.push(
+			frame(encoder, { type: "text_delta", contentIndex: 0, delta: "incorrect", partial }),
+			frame(encoder, { type: "text_end", contentIndex: 0, content: "Hello world", partial }),
+		);
+
+		expect(frames.at(-1)).toEqual({
+			type: "text_end",
+			contentIndex: 0,
+			content: "Hello world",
+			textSignature: "sig-text",
+		});
+		expect(reduceAssistantMessageFrames(frames)?.content).toEqual([
+			{ type: "text", text: "Hello world", textSignature: "sig-text" },
+		]);
+	});
+
+	it("preserves provider thinking level from the stream start", () => {
+		const partial = seed();
+		partial.providerThinkingLevel = "high";
+		const encoder = new AssistantMessageFrameEncoder();
+		const start = frame(encoder, { type: "start", partial });
+
+		expect(start).toMatchObject({ type: "start", partial: { providerThinkingLevel: "high" } });
+		expect(reduceAssistantMessageFrames([start])?.providerThinkingLevel).toBe("high");
+	});
+
+	it("preserves initial and final thinking metadata, including redaction", () => {
+		const partial = seed();
+		const encoder = new AssistantMessageFrameEncoder();
+		const frames: AssistantMessageFrame[] = [frame(encoder, { type: "start", partial })];
+		partial.content.push({
+			type: "thinking",
+			thinking: "[redacted]",
+			thinkingSignature: "encrypted-start",
+			redacted: true,
+		});
+		frames.push(frame(encoder, { type: "thinking_start", contentIndex: 0, partial }));
+		partial.content[0] = {
+			type: "thinking",
+			thinking: "[redacted]",
+			thinkingSignature: "encrypted-final",
+			redacted: true,
+		};
+		frames.push(frame(encoder, { type: "thinking_end", contentIndex: 0, content: "[redacted]", partial }));
+
+		expect(frames.at(-1)).toEqual({
+			type: "thinking_end",
+			contentIndex: 0,
+			content: "[redacted]",
+			thinkingSignature: "encrypted-final",
+			redacted: true,
+		});
+		expect(reduceAssistantMessageFrames(frames)?.content[0]).toEqual({
+			type: "thinking",
+			thinking: "[redacted]",
+			thinkingSignature: "encrypted-final",
+			redacted: true,
+		});
+	});
+
+	it("parses unfinished tool JSON once and uses authoritative completed arguments", () => {
+		const initialFrames: AssistantMessageFrame[] = [
+			{ type: "start", partial: seed() },
+			{
+				type: "toolcall_start",
+				contentIndex: 0,
+				toolCall: { type: "toolCall", id: "initial-id", name: "write", arguments: {} },
+			},
+			{ type: "toolcall_delta", contentIndex: 0, delta: '{"path":"READ' },
+		];
+
+		expect(reduceAssistantMessageFrames(initialFrames)?.content[0]).toMatchObject({
+			type: "toolCall",
+			arguments: { path: "READ" },
+		});
+
+		const completeFrames: AssistantMessageFrame[] = [
+			...initialFrames,
+			{ type: "toolcall_delta", contentIndex: 0, delta: 'ME.md","lines":[1,2]}' },
+			{
+				type: "toolcall_end",
+				contentIndex: 0,
+				id: "final-id",
+				name: "write_file",
+				arguments: { path: "final.md", lines: [3] },
+				thoughtSignature: "thought",
+				namespace: "files",
+			},
+		];
+		expect(reduceAssistantMessageFrames(completeFrames)?.content[0]).toEqual({
+			type: "toolCall",
+			id: "final-id",
+			name: "write_file",
+			arguments: { path: "final.md", lines: [3] },
+			thoughtSignature: "thought",
+			namespace: "files",
+		});
+	});
+
+	it("round-trips OpenAI Responses content supplied only by authoritative end events", async () => {
+		const output = seed();
+		output.api = "openai-responses";
+		output.provider = "openai";
+		const model: Model<"openai-responses"> = {
+			id: output.model,
+			name: "Test",
+			api: "openai-responses",
+			provider: "openai",
+			baseUrl: "https://api.openai.com/v1",
+			reasoning: false,
+			input: ["text"],
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+			contextWindow: 1000,
+			maxTokens: 100,
+		};
+		const events: ResponseStreamEvent[] = [
+			{
+				type: "response.output_item.added",
+				sequence_number: 0,
+				output_index: 0,
+				item: { type: "message", id: "msg", role: "assistant", status: "in_progress", content: [] },
+			} as ResponseStreamEvent,
+			{
+				type: "response.output_item.done",
+				sequence_number: 1,
+				output_index: 0,
+				item: {
+					type: "message",
+					id: "msg",
+					role: "assistant",
+					status: "completed",
+					content: [{ type: "output_text", text: "final text", annotations: [] }],
+				},
+			} as ResponseStreamEvent,
+			{
+				type: "response.output_item.added",
+				sequence_number: 2,
+				output_index: 1,
+				item: {
+					type: "function_call",
+					id: "fc",
+					call_id: "call",
+					name: "lookup",
+					arguments: "",
+				},
+			} as ResponseStreamEvent,
+			{
+				type: "response.output_item.done",
+				sequence_number: 3,
+				output_index: 1,
+				item: {
+					type: "function_call",
+					id: "fc",
+					call_id: "call",
+					name: "lookup",
+					arguments: '{"query":"pi"}',
+				},
+			} as ResponseStreamEvent,
+			{
+				type: "response.completed",
+				sequence_number: 4,
+				response: { id: "response", status: "completed", output: [] },
+			} as unknown as ResponseStreamEvent,
+		];
+		async function* source(): AsyncGenerator<ResponseStreamEvent> {
+			for (const event of events) yield event;
+		}
+
+		const encoder = new AssistantMessageFrameEncoder();
+		const frames: AssistantMessageFrame[] = [frame(encoder, { type: "start", partial: output })];
+		const stream = new AssistantMessageEventStream();
+		const push = stream.push.bind(stream);
+		stream.push = (event) => {
+			const converted = encoder.encode(event);
+			if (converted) frames.push(converted);
+			push(event);
+		};
+		await processResponsesStream(source(), output, stream, model);
+
+		expect(reduceAssistantMessageFrames(frames)?.content).toEqual(output.content);
+	});
+
+	it("reconciles queued text events against one advanced live partial without duplicate content", () => {
+		const partial = seed();
+		const events: AssistantMessageEvent[] = [{ type: "start", partial }];
+		const text = { type: "text" as const, text: "" };
+		partial.content.push(text);
+		events.push({ type: "text_start", contentIndex: 0, partial });
+		for (const delta of ["Hel", "lo", " ", "world"]) {
+			text.text += delta;
+			events.push({ type: "text_delta", contentIndex: 0, delta, partial });
+		}
+
+		const encoder = new AssistantMessageFrameEncoder();
+		const frames = events.flatMap((event) => {
+			const encoded = encoder.encode(event);
+			return encoded === undefined ? [] : [encoded];
+		});
+
+		expect(frames.map((item) => item.type)).toEqual(["start", "text_start"]);
+		expect(frames[0]).toMatchObject({ type: "start", partial: { content: [], stopReason: "pending" } });
+		expect(reduceAssistantMessageFrames(frames)?.content).toEqual([{ type: "text", text: "Hello world" }]);
+	});
+
+	it("trims only the covered prefix when a start snapshot lands inside a delta", () => {
+		const partial = seed();
+		const encoder = new AssistantMessageFrameEncoder();
+		const frames: AssistantMessageFrame[] = [frame(encoder, { type: "start", partial })];
+		const text = { type: "text" as const, text: "Hel" };
+		partial.content.push(text);
+		frames.push(frame(encoder, { type: "text_start", contentIndex: 0, partial }));
+		expect(encoder.encode({ type: "text_delta", contentIndex: 0, delta: "He", partial })).toBeUndefined();
+		const remainder = encoder.encode({ type: "text_delta", contentIndex: 0, delta: "llo", partial });
+		if (remainder === undefined) throw new Error("Expected uncovered text delta");
+		frames.push(remainder);
+
+		expect(remainder).toEqual({ type: "text_delta", contentIndex: 0, delta: "lo" });
+		expect(reduceAssistantMessageFrames(frames)?.content).toEqual([{ type: "text", text: "Hello" }]);
+	});
+
+	it("checkpoints queued tool JSON without replaying covered deltas", () => {
+		const partial = seed();
+		const toolCall = { type: "toolCall" as const, id: "call", name: "write", arguments: {} };
+		const events: AssistantMessageEvent[] = [{ type: "start", partial }];
+		partial.content.push(toolCall);
+		events.push({ type: "toolcall_start", contentIndex: 0, partial });
+		toolCall.arguments = { path: "README.md" };
+		events.push(
+			{ type: "toolcall_delta", contentIndex: 0, delta: '{"path":"READ', partial },
+			{ type: "toolcall_delta", contentIndex: 0, delta: 'ME.md"}', partial },
+		);
+
+		const encoder = new AssistantMessageFrameEncoder();
+		const frames = events.flatMap((event) => {
+			const encoded = encoder.encode(event);
+			return encoded === undefined ? [] : [encoded];
+		});
+		expect(frames.map((item) => item.type)).toEqual(["start", "toolcall_start", "toolcall_checkpoint"]);
+		expect(frames.at(-1)).toEqual({
+			type: "toolcall_checkpoint",
+			contentIndex: 0,
+			json: '{"path":"README.md"}',
+		});
+		expect(reduceAssistantMessageFrames(frames)?.content).toEqual([
+			{ type: "toolCall", id: "call", name: "write", arguments: { path: "README.md" } },
+		]);
+	});
+
+	it("resumes legacy grammar tool JSON from initial arguments", () => {
+		const partial = seed();
+		const encoder = new AssistantMessageFrameEncoder();
+		const frames: AssistantMessageFrame[] = [frame(encoder, { type: "start", partial })];
+		const toolCall = { type: "toolCall" as const, id: "call", name: "bash", arguments: { input: "a" } };
+		partial.content.push(toolCall);
+		frames.push(frame(encoder, { type: "toolcall_start", contentIndex: 0, partial }));
+		toolCall.arguments = { input: "ab" };
+		frames.push(
+			frame(encoder, {
+				type: "toolcall_delta",
+				contentIndex: 0,
+				delta: '{"input":"ab',
+				partial,
+			}),
+		);
+		toolCall.arguments = { input: "abc" };
+		frames.push(
+			frame(encoder, {
+				type: "toolcall_delta",
+				contentIndex: 0,
+				delta: 'c"}',
+				partial,
+			}),
+		);
+
+		expect(frames.slice(2)).toEqual([
+			{ type: "toolcall_checkpoint", contentIndex: 0, json: '{"input":"ab' },
+			{ type: "toolcall_delta", contentIndex: 0, delta: 'c"}' },
+		]);
+		expect(reduceAssistantMessageFrames(frames)?.content).toEqual([
+			{ type: "toolCall", id: "call", name: "bash", arguments: { input: "abc" } },
+		]);
+	});
+
+	it("streams tool JSON compactly from an empty argument start", () => {
+		const partial = seed();
+		const encoder = new AssistantMessageFrameEncoder();
+		const frames: AssistantMessageFrame[] = [frame(encoder, { type: "start", partial })];
+		const toolCall = { type: "toolCall" as const, id: "call", name: "bash", arguments: {} };
+		partial.content.push(toolCall);
+		frames.push(frame(encoder, { type: "toolcall_start", contentIndex: 0, partial }));
+		toolCall.arguments = { command: "ls -la /tmp" };
+		frames.push(
+			frame(encoder, {
+				type: "toolcall_delta",
+				contentIndex: 0,
+				delta: '{"command":"ls -la /tmp"}',
+				partial,
+			}),
+		);
+
+		expect(frames.at(-1)).toEqual({
+			type: "toolcall_delta",
+			contentIndex: 0,
+			delta: '{"command":"ls -la /tmp"}',
+		});
+		expect(reduceAssistantMessageFrames(frames)?.content[0]).toMatchObject({
+			type: "toolCall",
+			arguments: { command: "ls -la /tmp" },
+		});
+	});
+
+	it("accepts a pre-generation error but rejects success or updates before start", () => {
+		const failed = seed();
+		failed.stopReason = "error";
+		failed.errorMessage = "setup failed";
+		expect(
+			new AssistantMessageFrameEncoder().encode({ type: "error", reason: "error", error: failed }),
+		).toBeUndefined();
+
+		const completed = seed();
+		completed.stopReason = "stop";
+		expect(() =>
+			new AssistantMessageFrameEncoder().encode({ type: "done", reason: "stop", message: completed }),
+		).toThrow("done event appears before start");
+		expect(() =>
+			new AssistantMessageFrameEncoder().encode({
+				type: "text_delta",
+				contentIndex: 0,
+				delta: "x",
+				partial: seed(),
+			}),
+		).toThrow("text_delta event appears before start");
+	});
+
+	it("treats end signature metadata, including absence, as authoritative", () => {
+		const frames: AssistantMessageFrame[] = [
+			{ type: "start", partial: seed() },
+			{
+				type: "text_start",
+				contentIndex: 0,
+				content: { type: "text", text: "", textSignature: "stale-text" },
+			},
+			{ type: "text_end", contentIndex: 0, content: "" },
+			{
+				type: "thinking_start",
+				contentIndex: 1,
+				content: {
+					type: "thinking",
+					thinking: "",
+					thinkingSignature: "stale-thinking",
+					redacted: true,
+				},
+			},
+			{ type: "thinking_end", contentIndex: 1, content: "", thinkingSignature: "", redacted: false },
+			{
+				type: "toolcall_start",
+				contentIndex: 2,
+				toolCall: {
+					type: "toolCall",
+					id: "call",
+					name: "read",
+					arguments: {},
+					thoughtSignature: "stale-tool",
+					namespace: "stale-namespace",
+				},
+			},
+			{ type: "toolcall_end", contentIndex: 2, id: "call", name: "read", arguments: {} },
+		];
+
+		expect(reduceAssistantMessageFrames(frames)?.content).toEqual([
+			{ type: "text", text: "" },
+			{ type: "thinking", thinking: "", thinkingSignature: "", redacted: false },
+			{ type: "toolCall", id: "call", name: "read", arguments: {} },
+		]);
+	});
+
+	it("stores authoritative final arguments in toolcall_end frames", () => {
+		const partial = seed();
+		const toolCall = {
+			type: "toolCall" as const,
+			id: "call-1",
+			name: "read",
+			arguments: { path: "README.md" },
+			thoughtSignature: "thought",
+			namespace: "files",
+		};
+		partial.content.push(toolCall);
+
+		const encoder = new AssistantMessageFrameEncoder();
+		frame(encoder, { type: "start", partial });
+		frame(encoder, { type: "toolcall_start", contentIndex: 0, partial });
+		const end = frame(encoder, { type: "toolcall_end", contentIndex: 0, toolCall, partial });
+		expect(end).toEqual({
+			type: "toolcall_end",
+			contentIndex: 0,
+			id: "call-1",
+			name: "read",
+			arguments: { path: "README.md" },
+			thoughtSignature: "thought",
+			namespace: "files",
+		});
+	});
+
+	it("whitelists public block fields from provider-shaped partials", () => {
+		const partial = seed();
+		const text = { type: "text" as const, text: "visible", textSignature: "text-sig", index: 4 };
+		const thinking = {
+			type: "thinking" as const,
+			thinking: "reasoning",
+			thinkingSignature: "thinking-sig",
+			redacted: false,
+			index: 5,
+		};
+		const toolCall = {
+			type: "toolCall" as const,
+			id: "call",
+			name: "run",
+			arguments: { value: 1 },
+			thoughtSignature: "tool-sig",
+			namespace: "tools",
+			partialJson: '{"value":',
+			streamIndex: 6,
+		};
+		partial.content.push(text, thinking, toolCall);
+		const partialWithScratch = partial as AssistantMessage & { outputIndex?: number };
+		partialWithScratch.outputIndex = 3;
+
+		const encoder = new AssistantMessageFrameEncoder();
+		const start = frame(encoder, { type: "start", partial });
+		const textStart = frame(encoder, { type: "text_start", contentIndex: 0, partial });
+		const thinkingStart = frame(encoder, { type: "thinking_start", contentIndex: 1, partial });
+		const toolStart = frame(encoder, { type: "toolcall_start", contentIndex: 2, partial });
+
+		expect(start.type === "start" && start.partial.content).toEqual([]);
+		expect(start).not.toHaveProperty("partial.outputIndex");
+		expect(textStart).not.toHaveProperty("content.index");
+		expect(thinkingStart).not.toHaveProperty("content.index");
+		expect(toolStart).not.toHaveProperty("toolCall.partialJson");
+		expect(toolStart).not.toHaveProperty("toolCall.streamIndex");
+	});
+
+	it("supports interleaved streams by contentIndex", () => {
+		const frames: AssistantMessageFrame[] = [
+			{ type: "start", partial: seed() },
+			{ type: "text_start", contentIndex: 0, content: { type: "text", text: "" } },
+			{
+				type: "toolcall_start",
+				contentIndex: 1,
+				toolCall: { type: "toolCall", id: "call", name: "lookup", arguments: {} },
+			},
+			{ type: "thinking_start", contentIndex: 2, content: { type: "thinking", thinking: "" } },
+			{ type: "text_delta", contentIndex: 0, delta: "answer" },
+			{ type: "toolcall_delta", contentIndex: 1, delta: '{"query":"pi"}' },
+			{ type: "thinking_delta", contentIndex: 2, delta: "check" },
+			{ type: "toolcall_end", contentIndex: 1, id: "call", name: "lookup", arguments: { query: "pi" } },
+			{ type: "text_end", contentIndex: 0, content: "answer" },
+			{ type: "thinking_end", contentIndex: 2, content: "check" },
+		];
+
+		expect(reduceAssistantMessageFrames(frames)?.content).toEqual([
+			{ type: "text", text: "answer" },
+			{ type: "toolCall", id: "call", name: "lookup", arguments: { query: "pi" } },
+			{ type: "thinking", thinking: "check" },
+		]);
+	});
+
+	it("snapshots mutable event data and keeps reduction pure", () => {
+		const partial = seed();
+		partial.diagnostics = [{ type: "test", timestamp: 2, details: { value: "original" } }];
+		const encoder = new AssistantMessageFrameEncoder();
+		const start = frame(encoder, { type: "start", partial });
+		partial.diagnostics[0]!.details!.value = "mutated";
+		partial.usage.cost.total = 99;
+
+		partial.content.push({
+			type: "toolCall",
+			id: "call",
+			name: "run",
+			arguments: { nested: { value: "original" } },
+		});
+		const toolStart = frame(encoder, { type: "toolcall_start", contentIndex: 0, partial });
+		const sourceTool = partial.content[0];
+		if (sourceTool?.type !== "toolCall") throw new Error("Expected source tool call");
+		(sourceTool.arguments.nested as Record<string, unknown>).value = "mutated";
+
+		const reduced = reduceAssistantMessageFrames([start, toolStart]);
+		expect(reduced?.diagnostics?.[0]?.details?.value).toBe("original");
+		expect(reduced?.usage.cost.total).toBe(0);
+		expect(reduced?.content[0]).toMatchObject({ arguments: { nested: { value: "original" } } });
+
+		if (reduced?.content[0]?.type !== "toolCall") throw new Error("Expected reduced tool call");
+		reduced.content[0].arguments.nested = "changed-output";
+		expect(toolStart.type === "toolcall_start" && toolStart.toolCall.arguments.nested).toEqual({
+			value: "original",
+		});
+	});
+
+	it("omits terminal events because settlement is separate", () => {
+		const message = seed();
+		const completed = new AssistantMessageFrameEncoder();
+		completed.encode({ type: "start", partial: message });
+		message.stopReason = "stop";
+		expect(completed.encode({ type: "done", reason: "stop", message })).toBeUndefined();
+		message.stopReason = "error";
+		message.errorMessage = "failed";
+		expect(
+			new AssistantMessageFrameEncoder().encode({ type: "error", reason: "error", error: message }),
+		).toBeUndefined();
+	});
+
+	it("returns undefined when there is no start frame", () => {
+		expect(reduceAssistantMessageFrames([])).toBeUndefined();
+		expect(reduceAssistantMessageFrames([{ type: "text_delta", contentIndex: 0, delta: "x" }])).toBeUndefined();
+	});
+
+	it("rejects frames before start, wrong block kinds, duplicate ends, and index gaps", () => {
+		expect(() =>
+			reduceAssistantMessageFrames([
+				{ type: "text_delta", contentIndex: 0, delta: "x" },
+				{ type: "start", partial: seed() },
+			]),
+		).toThrow("before the start frame");
+		expect(() =>
+			reduceAssistantMessageFrames([
+				{ type: "start", partial: seed() },
+				{
+					type: "toolcall_start",
+					contentIndex: 0,
+					toolCall: { type: "toolCall", id: "call", name: "run", arguments: {} },
+				},
+				{ type: "text_delta", contentIndex: 0, delta: "wrong" },
+			]),
+		).toThrow("expected text block");
+		expect(() =>
+			reduceAssistantMessageFrames([
+				{ type: "start", partial: seed() },
+				{ type: "text_start", contentIndex: 0, content: { type: "text", text: "" } },
+				{ type: "text_end", contentIndex: 0, content: "" },
+				{ type: "text_end", contentIndex: 0, content: "" },
+			]),
+		).toThrow("follows the end");
+		expect(() =>
+			reduceAssistantMessageFrames([
+				{ type: "start", partial: seed() },
+				{ type: "text_start", contentIndex: 1, content: { type: "text", text: "" } },
+			]),
+		).toThrow("would leave a gap");
+	});
+
+	it("rejects conversion events whose contentIndex points to the wrong block kind", () => {
+		const partial = seed();
+		const encoder = new AssistantMessageFrameEncoder();
+		encoder.encode({ type: "start", partial });
+		partial.content.push({ type: "thinking", thinking: "" });
+		expect(() => encoder.encode({ type: "text_start", contentIndex: 0, partial })).toThrow(
+			"text_start event points to thinking block",
+		);
+	});
+});

packages/ai/test/azure-openai-base-url.test.ts

@@ -0,0 +1,227 @@
+import { arch, platform, release } from "node:os";
+import { Type } from "typebox";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { stream as streamAzureOpenAIResponses } from "../src/api/azure-openai-responses.ts";
+import { getModel } from "../src/compat.ts";
+import type { Context, Model } from "../src/types.ts";
+
+interface CapturedAzureClientOptions {
+	apiKey: string;
+	apiVersion: string;
+	dangerouslyAllowBrowser: boolean;
+	defaultHeaders?: Record<string, string>;
+	baseURL: string;
+}
+
+interface CapturedAzureResponsesPayload {
+	prompt_cache_key?: string;
+	store?: boolean;
+	tools?: Array<{ strict?: boolean }>;
+}
+
+const azureMock = vi.hoisted(() => ({
+	constructorCalls: [] as CapturedAzureClientOptions[],
+	lastParams: undefined as CapturedAzureResponsesPayload | undefined,
+}));
+
+vi.mock("openai", () => {
+	class AzureOpenAI {
+		responses = {
+			create: (params: CapturedAzureResponsesPayload) => {
+				azureMock.lastParams = params;
+				throw new Error("mock create");
+			},
+		};
+
+		constructor(config: CapturedAzureClientOptions) {
+			azureMock.constructorCalls.push(config);
+		}
+	}
+
+	return { AzureOpenAI };
+});
+
+const PI_USER_AGENT = `pi (${platform()} ${release()}; ${arch()})`;
+
+const context: Context = {
+	messages: [{ role: "user", content: "hello", timestamp: Date.now() }],
+};
+
+const originalAzureOpenAIBaseUrl = process.env.AZURE_OPENAI_BASE_URL;
+const originalAzureOpenAIResourceName = process.env.AZURE_OPENAI_RESOURCE_NAME;
+const originalAzureOpenAIApiVersion = process.env.AZURE_OPENAI_API_VERSION;
+const originalAzureOpenAIApiKey = process.env.AZURE_OPENAI_API_KEY;
+
+beforeEach(() => {
+	azureMock.constructorCalls.length = 0;
+	azureMock.lastParams = undefined;
+	delete process.env.AZURE_OPENAI_BASE_URL;
+	delete process.env.AZURE_OPENAI_RESOURCE_NAME;
+	delete process.env.AZURE_OPENAI_API_VERSION;
+	delete process.env.AZURE_OPENAI_API_KEY;
+});
+
+afterEach(() => {
+	if (originalAzureOpenAIBaseUrl === undefined) {
+		delete process.env.AZURE_OPENAI_BASE_URL;
+	} else {
+		process.env.AZURE_OPENAI_BASE_URL = originalAzureOpenAIBaseUrl;
+	}
+
+	if (originalAzureOpenAIResourceName === undefined) {
+		delete process.env.AZURE_OPENAI_RESOURCE_NAME;
+	} else {
+		process.env.AZURE_OPENAI_RESOURCE_NAME = originalAzureOpenAIResourceName;
+	}
+
+	if (originalAzureOpenAIApiVersion === undefined) {
+		delete process.env.AZURE_OPENAI_API_VERSION;
+	} else {
+		process.env.AZURE_OPENAI_API_VERSION = originalAzureOpenAIApiVersion;
+	}
+
+	if (originalAzureOpenAIApiKey === undefined) {
+		delete process.env.AZURE_OPENAI_API_KEY;
+	} else {
+		process.env.AZURE_OPENAI_API_KEY = originalAzureOpenAIApiKey;
+	}
+});
+
+async function captureClientBaseUrl(baseUrl: string): Promise<string> {
+	process.env.AZURE_OPENAI_BASE_URL = baseUrl;
+	const model = getModel("azure-openai-responses", "gpt-4o-mini");
+	await streamAzureOpenAIResponses(model, context, { apiKey: "test-api-key" }).result();
+	expect(azureMock.constructorCalls).toHaveLength(1);
+	return azureMock.constructorCalls[0].baseURL;
+}
+
+async function captureClientHeaders(headers?: Record<string, string>): Promise<Record<string, string>> {
+	const model = getModel("azure-openai-responses", "gpt-4o-mini");
+	await streamAzureOpenAIResponses(model, context, {
+		apiKey: "test-api-key",
+		azureBaseUrl: "https://my-resource.openai.azure.com",
+		headers,
+	}).result();
+	expect(azureMock.constructorCalls).toHaveLength(1);
+	return azureMock.constructorCalls[0].defaultHeaders ?? {};
+}
+
+describe("azure-openai-responses base URL normalization", () => {
+	it("normalizes Cognitive Services root endpoints to /openai/v1", async () => {
+		const baseURL = await captureClientBaseUrl("https://marc-quicktests-resource.cognitiveservices.azure.com");
+		expect(baseURL).toBe("https://marc-quicktests-resource.cognitiveservices.azure.com/openai/v1");
+	});
+
+	it("normalizes Microsoft Foundry root endpoints to /openai/v1", async () => {
+		const baseURL = await captureClientBaseUrl("https://marc-quicktests-resource.ai.azure.com");
+		expect(baseURL).toBe("https://marc-quicktests-resource.ai.azure.com/openai/v1");
+	});
+
+	it("normalizes Azure OpenAI root endpoints to /openai/v1", async () => {
+		const baseURL = await captureClientBaseUrl("https://my-resource.openai.azure.com");
+		expect(baseURL).toBe("https://my-resource.openai.azure.com/openai/v1");
+	});
+
+	it("normalizes /openai to /openai/v1", async () => {
+		const baseURL = await captureClientBaseUrl("https://my-resource.cognitiveservices.azure.com/openai");
+		expect(baseURL).toBe("https://my-resource.cognitiveservices.azure.com/openai/v1");
+	});
+
+	it("preserves /openai/v1 endpoints", async () => {
+		const baseURL = await captureClientBaseUrl("https://my-resource.cognitiveservices.azure.com/openai/v1");
+		expect(baseURL).toBe("https://my-resource.cognitiveservices.azure.com/openai/v1");
+	});
+
+	it("normalizes /openai/v1/responses to /openai/v1", async () => {
+		const baseURL = await captureClientBaseUrl("https://my-resource.services.ai.azure.com/openai/v1/responses");
+		expect(baseURL).toBe("https://my-resource.services.ai.azure.com/openai/v1");
+	});
+
+	it("preserves explicit non-Azure proxy paths", async () => {
+		const baseURL = await captureClientBaseUrl("https://my-proxy.example.com/v1");
+		expect(baseURL).toBe("https://my-proxy.example.com/v1");
+	});
+
+	it("strips query params when normalizing Azure host URLs", async () => {
+		const baseURL = await captureClientBaseUrl("https://my-resource.openai.azure.com/openai?api-version=2024-12-01");
+		expect(baseURL).toBe("https://my-resource.openai.azure.com/openai/v1");
+	});
+
+	it("preserves query params on non-Azure proxy URLs", async () => {
+		const baseURL = await captureClientBaseUrl("https://my-proxy.example.com/v1?custom=true");
+		expect(baseURL).toBe("https://my-proxy.example.com/v1?custom=true");
+	});
+
+	it("throws on invalid URLs", async () => {
+		process.env.AZURE_OPENAI_BASE_URL = "not-a-url";
+		const model = getModel("azure-openai-responses", "gpt-4o-mini");
+		const result = await streamAzureOpenAIResponses(model, context, { apiKey: "test-api-key" }).result();
+		expect(result.stopReason).toBe("error");
+		expect(result.errorMessage).toContain("Invalid Azure OpenAI base URL");
+	});
+
+	it("clamps prompt_cache_key to OpenAI's 64-character limit", async () => {
+		const model = getModel("azure-openai-responses", "gpt-4o-mini");
+		await streamAzureOpenAIResponses(model, context, {
+			apiKey: "test-api-key",
+			azureBaseUrl: "https://my-resource.openai.azure.com",
+			sessionId: "x".repeat(67),
+		}).result();
+
+		expect(azureMock.lastParams?.prompt_cache_key).toBe("x".repeat(64));
+	});
+
+	it("disables server-side response storage", async () => {
+		const model = getModel("azure-openai-responses", "gpt-4o-mini");
+		await streamAzureOpenAIResponses(model, context, {
+			apiKey: "test-api-key",
+			azureBaseUrl: "https://my-resource.openai.azure.com",
+		}).result();
+
+		expect(azureMock.lastParams?.store).toBe(false);
+	});
+
+	it("honors supportsStrictMode: false", async () => {
+		const baseModel = getModel("azure-openai-responses", "gpt-4o-mini");
+		const model: Model<"azure-openai-responses"> = {
+			...baseModel,
+			compat: { ...baseModel.compat, supportsStrictMode: false },
+		};
+
+		await streamAzureOpenAIResponses(
+			model,
+			{
+				...context,
+				tools: [
+					{
+						name: "preferred",
+						description: "Preferred constrained tool",
+						parameters: Type.Object({ value: Type.String() }),
+						constrainedSampling: { type: "json_schema", strict: "prefer" },
+					},
+				],
+			},
+			{ apiKey: "test-api-key", azureBaseUrl: "https://my-resource.openai.azure.com" },
+		).result();
+
+		expect(azureMock.lastParams?.tools?.[0]).not.toHaveProperty("strict");
+	});
+
+	it("builds correct default URL from AZURE_OPENAI_RESOURCE_NAME", async () => {
+		process.env.AZURE_OPENAI_RESOURCE_NAME = "my-resource";
+		const model = getModel("azure-openai-responses", "gpt-4o-mini");
+		await streamAzureOpenAIResponses(model, context, { apiKey: "test-api-key" }).result();
+		expect(azureMock.constructorCalls).toHaveLength(1);
+		expect(azureMock.constructorCalls[0].baseURL).toBe("https://my-resource.openai.azure.com/openai/v1");
+	});
+});
+
+describe("azure-openai-responses user agent", () => {
+	it("uses pi's User-Agent by default", async () => {
+		expect((await captureClientHeaders())["User-Agent"]).toBe(PI_USER_AGENT);
+	});
+
+	it("lets explicit headers override the default User-Agent", async () => {
+		expect((await captureClientHeaders({ "User-Agent": "custom-agent" }))["User-Agent"]).toBe("custom-agent");
+	});
+});

packages/ai/test/azure-openai-tool-choice.test.ts

@@ -0,0 +1,79 @@
+import { Type } from "typebox";
+import { describe, expect, it } from "vitest";
+import { stream, streamSimple } from "../src/api/azure-openai-responses.ts";
+import type { Model } from "../src/types.ts";
+
+const model: Model<"azure-openai-responses"> = {
+	id: "test-deployment",
+	name: "Test Deployment",
+	api: "azure-openai-responses",
+	provider: "azure-openai-responses",
+	baseUrl: "http://127.0.0.1:9/openai/v1",
+	reasoning: false,
+	input: ["text"],
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	contextWindow: 10_000,
+	maxTokens: 1_000,
+};
+
+describe("Azure OpenAI tool choice", () => {
+	it("forwards provider-specific tool choice while preserving tool definitions", async () => {
+		let payload: unknown;
+		const result = stream(
+			model,
+			{
+				messages: [{ role: "user", content: "Summarize this", timestamp: 1 }],
+				tools: [
+					{
+						name: "read",
+						description: "Read a file",
+						parameters: Type.Object({ path: Type.String() }),
+					},
+				],
+			},
+			{
+				apiKey: "test-key",
+				toolChoice: "required",
+				onPayload: (requestPayload) => {
+					payload = requestPayload;
+					throw new Error("payload captured");
+				},
+			},
+		);
+
+		await result.result();
+
+		expect(payload).toMatchObject({ tool_choice: "required" });
+		expect((payload as { tools?: unknown[] }).tools).toHaveLength(1);
+	});
+
+	it("forwards provider-neutral tool choice from simple options", async () => {
+		let payload: unknown;
+		const result = streamSimple(
+			model,
+			{
+				messages: [{ role: "user", content: "Summarize this", timestamp: 1 }],
+				tools: [
+					{
+						name: "read",
+						description: "Read a file",
+						parameters: Type.Object({ path: Type.String() }),
+					},
+				],
+			},
+			{
+				apiKey: "test-key",
+				toolChoice: "none",
+				onPayload: (requestPayload) => {
+					payload = requestPayload;
+					throw new Error("payload captured");
+				},
+			},
+		);
+
+		await result.result();
+
+		expect(payload).toMatchObject({ tool_choice: "none" });
+		expect((payload as { tools?: unknown[] }).tools).toHaveLength(1);
+	});
+});

packages/ai/test/azure-utils.ts

@@ -0,0 +1,28 @@
+/**
+ * Utility functions for Azure OpenAI tests
+ */
+
+function parseDeploymentNameMap(value: string | undefined): Map<string, string> {
+	const map = new Map<string, string>();
+	if (!value) return map;
+	for (const entry of value.split(",")) {
+		const trimmed = entry.trim();
+		if (!trimmed) continue;
+		const [modelId, deploymentName] = trimmed.split("=", 2);
+		if (!modelId || !deploymentName) continue;
+		map.set(modelId.trim(), deploymentName.trim());
+	}
+	return map;
+}
+
+export function hasAzureOpenAICredentials(): boolean {
+	const hasKey = !!process.env.AZURE_OPENAI_API_KEY;
+	const hasBaseUrl = !!(process.env.AZURE_OPENAI_BASE_URL || process.env.AZURE_OPENAI_RESOURCE_NAME);
+	return hasKey && hasBaseUrl;
+}
+
+export function resolveAzureDeploymentName(modelId: string): string | undefined {
+	const mapValue = process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP;
+	if (!mapValue) return undefined;
+	return parseDeploymentNameMap(mapValue).get(modelId);
+}

packages/ai/test/baseten-models.test.ts

@@ -0,0 +1,106 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { getModel, streamSimple } from "../src/compat.ts";
+import { findEnvKeys, getEnvApiKey } from "../src/env-api-keys.ts";
+import { getSupportedThinkingLevels } from "../src/models.ts";
+
+const originalBasetenApiKey = process.env.BASETEN_API_KEY;
+
+afterEach(() => {
+	if (originalBasetenApiKey === undefined) {
+		delete process.env.BASETEN_API_KEY;
+	} else {
+		process.env.BASETEN_API_KEY = originalBasetenApiKey;
+	}
+});
+
+describe("Baseten models", () => {
+	it("keeps both GLM 5.2 endpoints text-only", () => {
+		expect(getModel("baseten", "zai-org/GLM-5.2").input).toEqual(["text"]);
+		expect(getModel("baseten", "zai-org/GLM-5.2-Fast").input).toEqual(["text"]);
+	});
+
+	it("models Kimi K2.6 reasoning as an explicit off/on toggle", async () => {
+		const model = getModel("baseten", "moonshotai/Kimi-K2.6");
+		let payload: Record<string, unknown> | undefined;
+
+		expect(model.thinkingLevelMap).toEqual({
+			off: "off",
+			minimal: null,
+			low: null,
+			medium: null,
+			high: "high",
+			xhigh: null,
+			max: null,
+		});
+		expect(model.compat).toMatchObject({
+			supportsReasoningEffort: false,
+			thinkingFormat: "baseten",
+			chatTemplateArgs: { enable_thinking: { $var: "thinking.enabled" } },
+		});
+		expect(getSupportedThinkingLevels(model)).toEqual(["off", "high"]);
+
+		await streamSimple(
+			model,
+			{ messages: [{ role: "user", content: "test", timestamp: 0 }] },
+			{
+				apiKey: "test-baseten-key",
+				reasoning: "high",
+				onPayload: (value) => {
+					payload = value as Record<string, unknown>;
+					throw new Error("payload captured");
+				},
+			},
+		).result();
+
+		expect(payload?.chat_template_args).toEqual({ enable_thinking: true });
+		expect(payload?.reasoning_effort).toBeUndefined();
+	});
+
+	it("sends Baseten chat_template_args with reasoning effort", async () => {
+		const model = getModel("baseten", "zai-org/GLM-5.2");
+		let payload: Record<string, unknown> | undefined;
+
+		await streamSimple(
+			model,
+			{ messages: [{ role: "user", content: "test", timestamp: 0 }] },
+			{
+				apiKey: "test-baseten-key",
+				reasoning: "high",
+				onPayload: (value) => {
+					payload = value as Record<string, unknown>;
+					throw new Error("payload captured");
+				},
+			},
+		).result();
+
+		expect(payload?.chat_template_args).toEqual({ enable_thinking: true });
+		expect(payload?.reasoning_effort).toBe("high");
+	});
+
+	it("disables Baseten opt-in reasoning when thinking is off", async () => {
+		const model = getModel("baseten", "zai-org/GLM-5.2");
+		let payload: Record<string, unknown> | undefined;
+
+		await streamSimple(
+			model,
+			{ messages: [{ role: "user", content: "test", timestamp: 0 }] },
+			{
+				apiKey: "test-baseten-key",
+				onPayload: (value) => {
+					payload = value as Record<string, unknown>;
+					throw new Error("payload captured");
+				},
+			},
+		).result();
+
+		expect(payload?.chat_template_args).toEqual({ enable_thinking: false });
+		expect(payload?.reasoning_effort).toBe("none");
+	});
+
+	it("resolves BASETEN_API_KEY from the environment", () => {
+		process.env.BASETEN_API_KEY = "test-baseten-key";
+
+		expect(findEnvKeys("baseten")).toEqual(["BASETEN_API_KEY"]);
+		expect(getEnvApiKey("baseten")).toBe("test-baseten-key");
+	});
+});

packages/ai/test/bedrock-credentials.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const bedrockMock = vi.hoisted(() => ({
+	constructorCalls: [] as Array<Record<string, unknown>>,
+}));
+
+vi.mock("@aws-sdk/client-bedrock-runtime", () => {
+	class BedrockRuntimeServiceException extends Error {}
+
+	class BedrockRuntimeClient {
+		constructor(config: Record<string, unknown>) {
+			bedrockMock.constructorCalls.push(config);
+		}
+
+		send(): Promise<never> {
+			return Promise.reject(new Error("mock send"));
+		}
+	}
+
+	class ConverseStreamCommand {
+		readonly input: unknown;
+
+		constructor(input: unknown) {
+			this.input = input;
+		}
+	}
+
+	return {
+		BedrockRuntimeClient,
+		BedrockRuntimeServiceException,
+		ConverseStreamCommand,
+		StopReason: {
+			END_TURN: "end_turn",
+			STOP_SEQUENCE: "stop_sequence",
+			MAX_TOKENS: "max_tokens",
+			MODEL_CONTEXT_WINDOW_EXCEEDED: "model_context_window_exceeded",
+			TOOL_USE: "tool_use",
+		},
+		CachePointType: { DEFAULT: "default" },
+		CacheTTL: { ONE_HOUR: "ONE_HOUR" },
+		ConversationRole: { ASSISTANT: "assistant", USER: "user" },
+		ImageFormat: { JPEG: "jpeg", PNG: "png", GIF: "gif", WEBP: "webp" },
+		ToolResultStatus: { ERROR: "error", SUCCESS: "success" },
+	};
+});
+
+import type { BedrockOptions } from "../src/api/bedrock-converse-stream.ts";
+import { stream as streamBedrock } from "../src/compat.ts";
+import { getBuiltinModel } from "../src/providers/all.ts";
+import type { Context, Model } from "../src/types.ts";
+
+const context: Context = {
+	messages: [{ role: "user", content: "hello", timestamp: Date.now() }],
+};
+
+async function captureClientConfig(
+	model: Model<"bedrock-converse-stream">,
+	options: BedrockOptions = {},
+): Promise<Record<string, unknown>> {
+	bedrockMock.constructorCalls.length = 0;
+	await streamBedrock(model, context, { cacheRetention: "none", ...options }).result();
+	expect(bedrockMock.constructorCalls).toHaveLength(1);
+	return bedrockMock.constructorCalls[0];
+}
+
+describe("bedrock credential priority", () => {
+	afterEach(() => {
+		vi.unstubAllEnvs();
+	});
+
+	it("prefers explicit and scoped profiles over ambient AWS access keys", async () => {
+		vi.stubEnv("AWS_ACCESS_KEY_ID", "AKIAEXAMPLE");
+		vi.stubEnv("AWS_SECRET_ACCESS_KEY", "secretexample");
+		const model = getBuiltinModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+
+		let config = await captureClientConfig(model, { profile: "explicit-profile" });
+
+		expect(config.profile).toBe("explicit-profile");
+		expect(config.credentials).toBeUndefined();
+
+		config = await captureClientConfig(model, { env: { AWS_PROFILE: "scoped-profile" } });
+
+		expect(config.profile).toBe("scoped-profile");
+		expect(config.credentials).toBeUndefined();
+	});
+
+	it("uses ambient AWS access keys when no profile is configured", async () => {
+		vi.stubEnv("AWS_ACCESS_KEY_ID", "AKIAEXAMPLE");
+		vi.stubEnv("AWS_SECRET_ACCESS_KEY", "secretexample");
+		const model = getBuiltinModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+
+		const config = await captureClientConfig(model);
+
+		expect(config.profile).toBeUndefined();
+		expect(config.credentials).toEqual({
+			accessKeyId: "AKIAEXAMPLE",
+			secretAccessKey: "secretexample",
+		});
+	});
+
+	it("uses ambient AWS access keys when only an ambient profile is set", async () => {
+		vi.stubEnv("AWS_ACCESS_KEY_ID", "AKIAEXAMPLE");
+		vi.stubEnv("AWS_SECRET_ACCESS_KEY", "secretexample");
+		vi.stubEnv("AWS_PROFILE", "ambient-profile");
+		const model = getBuiltinModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+
+		const config = await captureClientConfig(model);
+
+		expect(config.profile).toBe("ambient-profile");
+		expect(config.credentials).toEqual({
+			accessKeyId: "AKIAEXAMPLE",
+			secretAccessKey: "secretexample",
+		});
+	});
+});

packages/ai/test/bedrock-custom-headers.test.ts

@@ -0,0 +1,202 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+type MiddlewareHandler = (next: (args: unknown) => Promise<unknown>) => (args: unknown) => Promise<unknown>;
+
+const bedrockMock = vi.hoisted(() => ({
+	middlewareRegistrations: [] as Array<{
+		handler: MiddlewareHandler;
+		opts: { step?: string; name?: string; priority?: string };
+	}>,
+}));
+
+vi.mock("@aws-sdk/client-bedrock-runtime", () => {
+	class BedrockRuntimeServiceException extends Error {}
+
+	class BedrockRuntimeClient {
+		middlewareStack = {
+			add: (handler: MiddlewareHandler, opts: { step?: string; name?: string; priority?: string }) => {
+				bedrockMock.middlewareRegistrations.push({ handler, opts });
+			},
+		};
+
+		send(): Promise<never> {
+			return Promise.reject(new Error("mock send"));
+		}
+	}
+
+	class ConverseStreamCommand {
+		readonly input: unknown;
+
+		constructor(input: unknown) {
+			this.input = input;
+		}
+	}
+
+	return {
+		BedrockRuntimeClient,
+		BedrockRuntimeServiceException,
+		ConverseStreamCommand,
+		StopReason: {
+			END_TURN: "end_turn",
+			STOP_SEQUENCE: "stop_sequence",
+			MAX_TOKENS: "max_tokens",
+			MODEL_CONTEXT_WINDOW_EXCEEDED: "model_context_window_exceeded",
+			TOOL_USE: "tool_use",
+		},
+		CachePointType: { DEFAULT: "default" },
+		CacheTTL: { ONE_HOUR: "ONE_HOUR" },
+		ConversationRole: { ASSISTANT: "assistant", USER: "user" },
+		ImageFormat: { JPEG: "jpeg", PNG: "png", GIF: "gif", WEBP: "webp" },
+		ToolResultStatus: { ERROR: "error", SUCCESS: "success" },
+	};
+});
+
+import type { BedrockOptions } from "../src/api/bedrock-converse-stream.ts";
+import { stream as streamBedrock, streamSimple as streamSimpleBedrock } from "../src/api/bedrock-converse-stream.ts";
+import { getModel } from "../src/compat.ts";
+import type { Context, Model } from "../src/types.ts";
+
+const context: Context = {
+	messages: [{ role: "user", content: "hello", timestamp: Date.now() }],
+};
+
+const MIDDLEWARE_NAME = "pi-ai-custom-headers";
+
+function getModelFixture(): Model<"bedrock-converse-stream"> {
+	return getModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+}
+
+/**
+ * Drive a stream to completion so the middleware (registered before `client.send`)
+ * is captured even though the mocked `send()` rejects. Errors are swallowed because
+ * the rejecting mock is expected — we only care about the recorded registrations.
+ */
+async function driveBedrock(options: BedrockOptions): Promise<void> {
+	await streamBedrock(getModelFixture(), context, options)
+		.result()
+		.catch(() => undefined);
+}
+
+function findCustomHeadersRegistration() {
+	const matches = bedrockMock.middlewareRegistrations.filter((r) => r.opts.name === MIDDLEWARE_NAME);
+	return matches;
+}
+
+beforeEach(() => {
+	bedrockMock.middlewareRegistrations.length = 0;
+});
+
+describe("bedrock custom headers middleware", () => {
+	it("VC1: registers a build-step middleware that injects the caller header (happy path)", async () => {
+		await driveBedrock({ cacheRetention: "none", headers: { "x-custom": "v" } });
+
+		const registrations = findCustomHeadersRegistration();
+		expect(registrations).toHaveLength(1);
+
+		const [reg] = registrations;
+		expect(reg.opts.step).toBe("build");
+		expect(reg.opts.priority).toBe("low");
+		expect(reg.opts.name).toBe(MIDDLEWARE_NAME);
+
+		const nextSpy = vi.fn(async (a: unknown) => a);
+		const fakeArgs = { request: { headers: {} as Record<string, string> } };
+		await reg.handler(nextSpy)(fakeArgs);
+
+		expect(fakeArgs.request.headers["x-custom"]).toBe("v");
+		expect(nextSpy).toHaveBeenCalledTimes(1);
+		expect(nextSpy).toHaveBeenCalledWith(fakeArgs);
+	});
+
+	it("VC2: skips reserved headers case-insensitively while applying allowed ones", async () => {
+		await driveBedrock({
+			cacheRetention: "none",
+			headers: {
+				authorization: "evil",
+				"x-amz-date": "evil",
+				"x-allowed": "ok",
+				Authorization: "evil2",
+				"X-Amz-Date": "evil2",
+				HOST: "evil3",
+			},
+		});
+
+		const [reg] = findCustomHeadersRegistration();
+		expect(reg).toBeDefined();
+
+		const nextSpy = vi.fn(async (a: unknown) => a);
+		const fakeArgs = {
+			request: {
+				headers: {
+					authorization: "real-auth",
+					"x-amz-date": "real-date",
+					host: "real-host",
+				} as Record<string, string>,
+			},
+		};
+		await reg.handler(nextSpy)(fakeArgs);
+
+		expect(fakeArgs.request.headers.authorization).toBe("real-auth");
+		expect(fakeArgs.request.headers["x-amz-date"]).toBe("real-date");
+		expect(fakeArgs.request.headers.host).toBe("real-host");
+		expect(fakeArgs.request.headers["x-allowed"]).toBe("ok");
+		// Mixed-case reserved keys must be skipped too: a case-sensitive guard would
+		// add them back as distinct capitalised keys. Assert no such leak occurred and
+		// that the only new key beyond the three pre-existing ones is `x-allowed`.
+		expect(fakeArgs.request.headers.Authorization).toBeUndefined();
+		expect(fakeArgs.request.headers["X-Amz-Date"]).toBeUndefined();
+		expect(fakeArgs.request.headers.HOST).toBeUndefined();
+		expect(Object.keys(fakeArgs.request.headers).sort()).toEqual(
+			["authorization", "host", "x-allowed", "x-amz-date"].sort(),
+		);
+		expect(nextSpy).toHaveBeenCalledTimes(1);
+	});
+
+	it("VC3: registers no middleware when headers is undefined", async () => {
+		await driveBedrock({ cacheRetention: "none" });
+
+		expect(findCustomHeadersRegistration()).toHaveLength(0);
+	});
+
+	it("VC3: registers no middleware when headers is empty", async () => {
+		await driveBedrock({ cacheRetention: "none", headers: {} });
+
+		expect(findCustomHeadersRegistration()).toHaveLength(0);
+	});
+
+	it("VC3 (structural guard): passes through unchanged when the request has no headers", async () => {
+		await driveBedrock({ cacheRetention: "none", headers: { "x-custom": "v" } });
+
+		const [reg] = findCustomHeadersRegistration();
+		expect(reg).toBeDefined();
+
+		const nextSpy = vi.fn(async (a: unknown) => a);
+
+		const argsNoHeaders = { request: {} };
+		await expect(reg.handler(nextSpy)(argsNoHeaders)).resolves.toBeDefined();
+		expect(nextSpy).toHaveBeenCalledWith(argsNoHeaders);
+
+		const argsUndefinedRequest = { request: undefined };
+		await expect(reg.handler(nextSpy)(argsUndefinedRequest)).resolves.toBeDefined();
+		expect(nextSpy).toHaveBeenCalledWith(argsUndefinedRequest);
+
+		expect(nextSpy).toHaveBeenCalledTimes(2);
+	});
+
+	it("VC4: streamSimpleBedrock forwards headers end-to-end (regression guard)", async () => {
+		await streamSimpleBedrock(getModelFixture(), context, { headers: { "x-custom": "v" } })
+			.result()
+			.catch(() => undefined);
+
+		const registrations = findCustomHeadersRegistration();
+		expect(registrations).toHaveLength(1);
+
+		const [reg] = registrations;
+		expect(reg.opts.step).toBe("build");
+
+		const nextSpy = vi.fn(async (a: unknown) => a);
+		const fakeArgs = { request: { headers: {} as Record<string, string> } };
+		await reg.handler(nextSpy)(fakeArgs);
+
+		expect(fakeArgs.request.headers["x-custom"]).toBe("v");
+	});
+});

packages/ai/test/bedrock-endpoint-resolution.test.ts

@@ -0,0 +1,208 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const bedrockMock = vi.hoisted(() => ({
+	constructorCalls: [] as Array<Record<string, unknown>>,
+}));
+
+vi.mock("@aws-sdk/client-bedrock-runtime", () => {
+	class BedrockRuntimeServiceException extends Error {}
+
+	class BedrockRuntimeClient {
+		constructor(config: Record<string, unknown>) {
+			bedrockMock.constructorCalls.push(config);
+		}
+
+		send(): Promise<never> {
+			return Promise.reject(new Error("mock send"));
+		}
+	}
+
+	class ConverseStreamCommand {
+		readonly input: unknown;
+
+		constructor(input: unknown) {
+			this.input = input;
+		}
+	}
+
+	return {
+		BedrockRuntimeClient,
+		BedrockRuntimeServiceException,
+		ConverseStreamCommand,
+		StopReason: {
+			END_TURN: "end_turn",
+			STOP_SEQUENCE: "stop_sequence",
+			MAX_TOKENS: "max_tokens",
+			MODEL_CONTEXT_WINDOW_EXCEEDED: "model_context_window_exceeded",
+			TOOL_USE: "tool_use",
+		},
+		CachePointType: { DEFAULT: "default" },
+		CacheTTL: { ONE_HOUR: "ONE_HOUR" },
+		ConversationRole: { ASSISTANT: "assistant", USER: "user" },
+		ImageFormat: { JPEG: "jpeg", PNG: "png", GIF: "gif", WEBP: "webp" },
+		ToolResultStatus: { ERROR: "error", SUCCESS: "success" },
+	};
+});
+
+import type { BedrockOptions } from "../src/api/bedrock-converse-stream.ts";
+import { getModel, stream as streamBedrock } from "../src/compat.ts";
+import type { Context, Model } from "../src/types.ts";
+
+const context: Context = {
+	messages: [{ role: "user", content: "hello", timestamp: Date.now() }],
+};
+
+const originalAwsRegion = process.env.AWS_REGION;
+const originalAwsDefaultRegion = process.env.AWS_DEFAULT_REGION;
+const originalAwsProfile = process.env.AWS_PROFILE;
+
+beforeEach(() => {
+	bedrockMock.constructorCalls.length = 0;
+	delete process.env.AWS_REGION;
+	delete process.env.AWS_DEFAULT_REGION;
+	delete process.env.AWS_PROFILE;
+});
+
+afterEach(() => {
+	if (originalAwsRegion === undefined) {
+		delete process.env.AWS_REGION;
+	} else {
+		process.env.AWS_REGION = originalAwsRegion;
+	}
+
+	if (originalAwsDefaultRegion === undefined) {
+		delete process.env.AWS_DEFAULT_REGION;
+	} else {
+		process.env.AWS_DEFAULT_REGION = originalAwsDefaultRegion;
+	}
+
+	if (originalAwsProfile === undefined) {
+		delete process.env.AWS_PROFILE;
+	} else {
+		process.env.AWS_PROFILE = originalAwsProfile;
+	}
+});
+
+async function captureClientConfig(
+	model: Model<"bedrock-converse-stream">,
+	options: BedrockOptions = {},
+): Promise<Record<string, unknown>> {
+	bedrockMock.constructorCalls.length = 0;
+	await streamBedrock(model, context, { cacheRetention: "none", ...options }).result();
+	expect(bedrockMock.constructorCalls).toHaveLength(1);
+	return bedrockMock.constructorCalls[0];
+}
+
+describe("bedrock endpoint resolution", () => {
+	it("assigns eu-central-1 runtime URLs to built-in EU inference profiles", () => {
+		const model = getModel("amazon-bedrock", "eu.anthropic.claude-sonnet-4-5-20250929-v1:0");
+
+		expect(model.baseUrl).toBe("https://bedrock-runtime.eu-central-1.amazonaws.com");
+	});
+
+	it("does not pin standard AWS endpoints when AWS_REGION is configured", async () => {
+		process.env.AWS_REGION = "us-east-2";
+		const model = getModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+
+		const config = await captureClientConfig(model);
+
+		expect(config.region).toBe("us-east-2");
+		expect(config.endpoint).toBeUndefined();
+	});
+
+	it("derives region from a built-in EU endpoint when no region or profile is configured", async () => {
+		const model = getModel("amazon-bedrock", "eu.anthropic.claude-sonnet-4-5-20250929-v1:0");
+
+		const config = await captureClientConfig(model);
+
+		expect(config.endpoint).toBe("https://bedrock-runtime.eu-central-1.amazonaws.com");
+		expect(config.region).toBe("eu-central-1");
+	});
+
+	it("handles missing regions for explicit, scoped, and ambient profiles", async () => {
+		const model = getModel("amazon-bedrock", "eu.anthropic.claude-sonnet-4-5-20250929-v1:0");
+
+		let config = await captureClientConfig(model, { profile: "bedrock-profile" });
+
+		expect(config.profile).toBe("bedrock-profile");
+		expect(config.endpoint).toBe("https://bedrock-runtime.eu-central-1.amazonaws.com");
+		expect(config.region).toBe("eu-central-1");
+
+		config = await captureClientConfig(model, { env: { AWS_PROFILE: "scoped-bedrock-profile" } });
+
+		expect(config.profile).toBe("scoped-bedrock-profile");
+		expect(config.endpoint).toBe("https://bedrock-runtime.eu-central-1.amazonaws.com");
+		expect(config.region).toBe("eu-central-1");
+
+		process.env.AWS_PROFILE = "ambient-bedrock-profile";
+		config = await captureClientConfig(model);
+
+		expect(config.profile).toBe("ambient-bedrock-profile");
+		expect(config.endpoint).toBeUndefined();
+		expect(config.region).toBeUndefined();
+	});
+
+	it("still passes custom Bedrock endpoints through to the SDK client", async () => {
+		process.env.AWS_REGION = "us-west-2";
+		const baseModel = getModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			baseUrl: "https://bedrock-vpc.example.com",
+		};
+
+		const config = await captureClientConfig(model);
+
+		expect(config.endpoint).toBe("https://bedrock-vpc.example.com");
+		expect(config.region).toBe("us-west-2");
+	});
+
+	it("extracts region from inference profile ARN regardless of AWS_REGION", async () => {
+		process.env.AWS_REGION = "us-east-1";
+		const baseModel = getModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			id: "arn:aws:bedrock:us-west-2:123456789012:application-inference-profile/abc123",
+		};
+
+		const config = await captureClientConfig(model);
+
+		expect(config.region).toBe("us-west-2");
+	});
+
+	it("extracts region from GovCloud inference profile ARN", async () => {
+		process.env.AWS_REGION = "us-east-1";
+		const baseModel = getModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			id: "arn:aws-us-gov:bedrock:us-gov-west-1:123456789012:application-inference-profile/abc123",
+		};
+
+		const config = await captureClientConfig(model);
+
+		expect(config.region).toBe("us-gov-west-1");
+	});
+
+	it("preserves ambient AWS auth for custom model IDs through compat dispatch", async () => {
+		process.env.AWS_PROFILE = "bedrock-profile";
+		const baseModel = getModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			id: "arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/example",
+		};
+
+		const config = await captureClientConfig(model);
+
+		expect(config.profile).toBe("bedrock-profile");
+		expect(config.token).toBeUndefined();
+		expect(config.authSchemePreference).toBeUndefined();
+	});
+
+	it("uses the generic API key option as a Bedrock bearer token", async () => {
+		const model = getModel("amazon-bedrock", "us.anthropic.claude-opus-4-8");
+
+		const config = await captureClientConfig(model, { apiKey: "bedrock-api-key" });
+
+		expect(config.token).toEqual({ token: "bedrock-api-key" });
+		expect(config.authSchemePreference).toEqual(["httpBearerAuth"]);
+	});
+});

packages/ai/test/bedrock-models.test.ts

@@ -0,0 +1,70 @@
+/**
+ * A test suite to ensure all configured Amazon Bedrock models are usable.
+ *
+ * This is here to make sure we got correct model identifiers from models.dev and other sources.
+ * Because Amazon Bedrock requires cross-region inference in some models,
+ * plain model identifiers are not always usable and it requires tweaking of model identifiers to use cross-region inference.
+ * See https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html#inference-profiles-support-system for more details.
+ *
+ * This test suite is not enabled by default unless AWS credentials and `BEDROCK_EXTENSIVE_MODEL_TEST` environment variables are set.
+ * This test suite takes ~2 minutes to run. Because not all models are available in all regions,
+ * it's recommended to use `us-west-2` region for best coverage for running this test suite.
+ *
+ * You can run this test suite with:
+ * ```bash
+ * $ AWS_REGION=us-west-2 BEDROCK_EXTENSIVE_MODEL_TEST=1 AWS_PROFILE=... npm test -- ./test/bedrock-models.test.ts
+ * ```
+ */
+
+import { describe, expect, it } from "vitest";
+import { complete, getModels } from "../src/compat.ts";
+import type { Context } from "../src/types.ts";
+import { hasBedrockCredentials } from "./bedrock-utils.ts";
+
+describe("Amazon Bedrock Models", () => {
+	const models = getModels("amazon-bedrock");
+
+	it("should get all available Bedrock models", () => {
+		expect(models.length).toBeGreaterThan(0);
+		console.log(`Found ${models.length} Bedrock models`);
+	});
+
+	it("exposes Claude Opus 5 through an inference profile only", () => {
+		expect(models.some((model) => model.id === "global.anthropic.claude-opus-5")).toBe(true);
+		expect(models.some((model) => model.id === "anthropic.claude-opus-5")).toBe(false);
+	});
+
+	if (hasBedrockCredentials() && process.env.BEDROCK_EXTENSIVE_MODEL_TEST) {
+		for (const model of models) {
+			it(`should make a simple request with ${model.id}`, { timeout: 10_000 }, async () => {
+				const context: Context = {
+					systemPrompt: "You are a helpful assistant. Be extremely concise.",
+					messages: [
+						{
+							role: "user",
+							content: "Reply with exactly: 'OK'",
+							timestamp: Date.now(),
+						},
+					],
+				};
+
+				const response = await complete(model, context);
+
+				expect(response.role).toBe("assistant");
+				expect(response.content).toBeTruthy();
+				expect(response.content.length).toBeGreaterThan(0);
+				expect(response.usage.input + response.usage.cacheRead).toBeGreaterThan(0);
+				expect(response.usage.output).toBeGreaterThan(0);
+				expect(response.errorMessage).toBeFalsy();
+
+				const textContent = response.content
+					.filter((b) => b.type === "text")
+					.map((b) => (b.type === "text" ? b.text : ""))
+					.join("")
+					.trim();
+				expect(textContent).toBeTruthy();
+				console.log(`${model.id}: ${textContent.substring(0, 100)}`);
+			});
+		}
+	}
+});

packages/ai/test/bedrock-redacted-reasoning.test.ts

@@ -0,0 +1,274 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+/**
+ * OpenAI models served through Bedrock Converse (e.g. `global.openai.gpt-5.6-terra`)
+ * return encrypted reasoning as the opaque `redactedContent` member of
+ * `reasoningContent`, not as `reasoningText`. The AWS SDK decodes the wire blob to
+ * `Uint8Array`.
+ * @see https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlockDelta.html
+ */
+const bedrockMock = vi.hoisted(() => {
+	const redactedBase64 = "cnNuXzVaVnJpZjRKMGJYSXFtV2RsZWRqN1FJRmVOaWtSUWJF";
+	return {
+		redactedBase64,
+		redactedBytes: new Uint8Array(Buffer.from(redactedBase64, "base64")),
+		streamEvents: undefined as unknown[] | undefined,
+	};
+});
+
+vi.mock("@aws-sdk/client-bedrock-runtime", () => {
+	class BedrockRuntimeServiceException extends Error {}
+
+	class BedrockRuntimeClient {
+		send(): Promise<unknown> {
+			if (bedrockMock.streamEvents) {
+				const events = bedrockMock.streamEvents;
+				return Promise.resolve({
+					$metadata: { httpStatusCode: 200 },
+					stream: (async function* () {
+						yield* events;
+					})(),
+				});
+			}
+			return Promise.reject(new Error("mock send"));
+		}
+	}
+
+	class ConverseStreamCommand {
+		readonly input: unknown;
+
+		constructor(input: unknown) {
+			this.input = input;
+		}
+	}
+
+	return {
+		BedrockRuntimeClient,
+		BedrockRuntimeServiceException,
+		ConverseStreamCommand,
+		StopReason: {
+			END_TURN: "end_turn",
+			STOP_SEQUENCE: "stop_sequence",
+			MAX_TOKENS: "max_tokens",
+			MODEL_CONTEXT_WINDOW_EXCEEDED: "model_context_window_exceeded",
+			TOOL_USE: "tool_use",
+		},
+		CachePointType: { DEFAULT: "default" },
+		CacheTTL: { ONE_HOUR: "ONE_HOUR" },
+		ConversationRole: { ASSISTANT: "assistant", USER: "user" },
+		ImageFormat: { JPEG: "jpeg", PNG: "png", GIF: "gif", WEBP: "webp" },
+		ToolResultStatus: { ERROR: "error", SUCCESS: "success" },
+	};
+});
+
+import { stream as streamBedrock } from "../src/api/bedrock-converse-stream.ts";
+import type { Context, Message, Model, ThinkingContent } from "../src/types.ts";
+
+const gptModel: Model<"bedrock-converse-stream"> = {
+	id: "global.openai.gpt-5.6-terra",
+	name: "GPT-5.6 Terra (Global)",
+	api: "bedrock-converse-stream",
+	provider: "amazon-bedrock",
+	baseUrl: "https://bedrock-runtime.ap-northeast-1.amazonaws.com",
+	reasoning: true,
+	input: ["text"],
+	cost: { input: 1.25, output: 10, cacheRead: 0.125, cacheWrite: 0 },
+	contextWindow: 400000,
+	maxTokens: 128000,
+};
+
+const emptyUsage = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+/** Mirrors the ConverseStream frames GPT-5.6 emits: encrypted reasoning, then text. */
+function redactedReasoningEvents(): unknown[] {
+	return [
+		{ messageStart: { role: "assistant" } },
+		{
+			contentBlockDelta: {
+				contentBlockIndex: 0,
+				delta: { reasoningContent: { redactedContent: bedrockMock.redactedBytes } },
+			},
+		},
+		{ contentBlockStop: { contentBlockIndex: 0 } },
+		{ contentBlockDelta: { contentBlockIndex: 1, delta: { text: "done" } } },
+		{ contentBlockStop: { contentBlockIndex: 1 } },
+		{ messageStop: { stopReason: "end_turn" } },
+	];
+}
+
+interface BedrockRequestPayload {
+	messages: Array<{ role: string; content: Array<Record<string, unknown>> }>;
+}
+
+async function capturePayload(context: Context): Promise<BedrockRequestPayload> {
+	let capturedPayload: BedrockRequestPayload | undefined;
+	const s = streamBedrock(gptModel, context, {
+		cacheRetention: "none",
+		signal: AbortSignal.abort(),
+		onPayload: (payload) => {
+			capturedPayload = payload as BedrockRequestPayload;
+			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 redacted reasoning", () => {
+	beforeEach(() => {
+		bedrockMock.streamEvents = undefined;
+	});
+
+	it("does not fail the stream when reasoning arrives as redactedContent", async () => {
+		bedrockMock.streamEvents = redactedReasoningEvents();
+
+		const response = await streamBedrock(gptModel, {
+			messages: [{ role: "user", content: "hello", timestamp: Date.now() }],
+		}).result();
+
+		expect(response.stopReason, response.errorMessage).not.toBe("error");
+		// Reasoning precedes the answer, matching the order Bedrock streamed it.
+		expect(response.content.map((c) => c.type)).toEqual(["thinking", "text"]);
+		expect(response.content[1]).toEqual({ type: "text", text: "done" });
+	});
+
+	it("preserves the encrypted reasoning payload on the assistant message", async () => {
+		bedrockMock.streamEvents = redactedReasoningEvents();
+
+		const response = await streamBedrock(gptModel, {
+			messages: [{ role: "user", content: "hello", timestamp: Date.now() }],
+		}).result();
+
+		const thinking = response.content.find((c): c is ThinkingContent => c.type === "thinking");
+		expect(thinking).toBeDefined();
+		// Same representation Anthropic redacted thinking already uses: the opaque
+		// payload rides in `thinkingSignature` with `redacted: true`.
+		expect(thinking?.redacted).toBe(true);
+		expect(thinking?.thinkingSignature).toBe(bedrockMock.redactedBase64);
+		// The byte buffer is streaming scratch state: persisting it would bloat the
+		// session, since a Uint8Array serializes to an index-keyed object.
+		expect("redactedChunks" in thinking!).toBe(false);
+	});
+
+	it("encodes the payload when the stream never sends contentBlockStop", async () => {
+		bedrockMock.streamEvents = [
+			{ messageStart: { role: "assistant" } },
+			{
+				contentBlockDelta: {
+					contentBlockIndex: 0,
+					delta: { reasoningContent: { redactedContent: bedrockMock.redactedBytes } },
+				},
+			},
+			{ messageStop: { stopReason: "end_turn" } },
+		];
+
+		const response = await streamBedrock(gptModel, {
+			messages: [{ role: "user", content: "hello", timestamp: Date.now() }],
+		}).result();
+
+		const thinking = response.content.find((c): c is ThinkingContent => c.type === "thinking");
+		expect(thinking?.thinkingSignature).toBe(bedrockMock.redactedBase64);
+		// Streaming scratch state must not survive into the persisted message.
+		expect("redactedChunks" in thinking!).toBe(false);
+		expect("index" in thinking!).toBe(false);
+	});
+
+	it("joins encrypted reasoning split across deltas", async () => {
+		const [head, tail] = [bedrockMock.redactedBytes.slice(0, 7), bedrockMock.redactedBytes.slice(7)];
+		bedrockMock.streamEvents = [
+			{ messageStart: { role: "assistant" } },
+			{ contentBlockDelta: { contentBlockIndex: 0, delta: { reasoningContent: { redactedContent: head } } } },
+			{ contentBlockDelta: { contentBlockIndex: 0, delta: { reasoningContent: { redactedContent: tail } } } },
+			{ contentBlockStop: { contentBlockIndex: 0 } },
+			{ messageStop: { stopReason: "end_turn" } },
+		];
+
+		const response = await streamBedrock(gptModel, {
+			messages: [{ role: "user", content: "hello", timestamp: Date.now() }],
+		}).result();
+
+		const thinking = response.content.find((c): c is ThinkingContent => c.type === "thinking");
+		expect(thinking?.thinkingSignature).toBe(bedrockMock.redactedBase64);
+		// The placeholder marks the block once, not once per delta.
+		expect(thinking?.thinking).toBe("[Reasoning redacted]");
+	});
+
+	it("replays redacted reasoning as reasoningContent.redactedContent", async () => {
+		const messages: Message[] = [
+			{ role: "user", content: "hello", timestamp: Date.now() },
+			{
+				role: "assistant",
+				content: [
+					{ type: "thinking", thinking: "", thinkingSignature: bedrockMock.redactedBase64, redacted: true },
+					{ type: "text", text: "done" },
+				],
+				api: "bedrock-converse-stream",
+				provider: "amazon-bedrock",
+				model: gptModel.id,
+				usage: emptyUsage,
+				stopReason: "stop",
+				timestamp: Date.now(),
+			},
+			{ role: "user", content: "continue", timestamp: Date.now() },
+		];
+
+		const payload = await capturePayload({ messages });
+
+		const assistant = payload.messages.find((m: any) => m.role === "assistant");
+		expect(assistant).toBeDefined();
+		expect(assistant!.content).toEqual([
+			{ reasoningContent: { redactedContent: bedrockMock.redactedBytes } },
+			{ text: "done" },
+		]);
+	});
+
+	it("replays redacted reasoning before the toolUse block it belongs to", async () => {
+		// Bedrock rejects a tool continuation whose reasoning block is missing or
+		// reordered, so the opaque payload must land ahead of the matching toolUse.
+		const messages: Message[] = [
+			{ role: "user", content: "read the file", timestamp: Date.now() },
+			{
+				role: "assistant",
+				content: [
+					{ type: "thinking", thinking: "", thinkingSignature: bedrockMock.redactedBase64, redacted: true },
+					{ type: "toolCall", id: "tool-1", name: "read", arguments: { path: "/tmp/a.txt" } },
+				],
+				api: "bedrock-converse-stream",
+				provider: "amazon-bedrock",
+				model: gptModel.id,
+				usage: emptyUsage,
+				stopReason: "toolUse",
+				timestamp: Date.now(),
+			},
+			{
+				role: "toolResult",
+				toolCallId: "tool-1",
+				toolName: "read",
+				content: [{ type: "text", text: "file body" }],
+				isError: false,
+				timestamp: Date.now(),
+			},
+		];
+
+		const payload = await capturePayload({ messages });
+
+		const assistant = payload.messages.find((m: any) => m.role === "assistant");
+		expect(assistant).toBeDefined();
+		expect(assistant!.content).toEqual([
+			{ reasoningContent: { redactedContent: bedrockMock.redactedBytes } },
+			{ toolUse: { toolUseId: "tool-1", name: "read", input: { path: "/tmp/a.txt" } } },
+		]);
+	});
+});

packages/ai/test/bedrock-response-headers.test.ts

@@ -0,0 +1,63 @@
+import { createServer, type Server } from "node:http";
+import { afterEach, describe, expect, it } from "vitest";
+import { stream as streamBedrock } from "../src/api/bedrock-converse-stream.ts";
+import { getModel } from "../src/compat.ts";
+import type { Model, ProviderResponse } from "../src/types.ts";
+
+const MODEL_ID = "us.anthropic.claude-haiku-4-5-20251001-v1:0";
+
+let server: Server | undefined;
+
+afterEach(async () => {
+	if (!server) return;
+	await new Promise<void>((resolve, reject) => {
+		server?.close((error) => (error ? reject(error) : resolve()));
+	});
+	server = undefined;
+});
+
+async function startBedrockResponseServer(): Promise<string> {
+	server = createServer((_req, res) => {
+		res.writeHead(200, {
+			"content-type": "application/vnd.amazon.eventstream",
+			"x-bifrost-provider": "bedrock",
+			"x-bifrost-resolved-model": MODEL_ID,
+			"x-amzn-requestid": "req-123",
+		});
+		res.end();
+	});
+
+	await new Promise<void>((resolve) => server?.listen(0, "127.0.0.1", resolve));
+	const address = server.address();
+	if (!address || typeof address === "string") throw new Error("Expected TCP test server address");
+	return `http://127.0.0.1:${address.port}`;
+}
+
+describe("bedrock response headers", () => {
+	it("forwards raw Smithy response headers to onResponse", async () => {
+		const baseModel = getModel("amazon-bedrock", MODEL_ID) as Model<"bedrock-converse-stream">;
+		const model = { ...baseModel, baseUrl: await startBedrockResponseServer() };
+		const responses: ProviderResponse[] = [];
+
+		const result = await streamBedrock(
+			model,
+			{ messages: [{ role: "user", content: "hello", timestamp: Date.now() }] },
+			{
+				cacheRetention: "none",
+				env: { AWS_BEDROCK_FORCE_HTTP1: "1", AWS_BEDROCK_SKIP_AUTH: "1" },
+				onResponse: (response) => {
+					responses.push(response);
+				},
+			},
+		).result();
+
+		// The fake server intentionally returns an empty event stream; this assertion
+		// documents that the header callback still fires before stream consumption.
+		expect(result.stopReason).toBe("error");
+		expect(responses).toHaveLength(1);
+		expect(responses[0].status).toBe(200);
+		expect(responses[0].headers["x-amzn-requestid"]).toBe("req-123");
+		expect(responses[0].headers["x-bifrost-provider"]).toBe("bedrock");
+		expect(responses[0].headers["x-bifrost-resolved-model"]).toBe(MODEL_ID);
+	});
+});

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

@@ -0,0 +1,266 @@
+import { describe, expect, it } from "vitest";
+import { type BedrockOptions, stream as streamBedrock } from "../src/api/bedrock-converse-stream.ts";
+import { getModel } from "../src/compat.ts";
+import type { Context, Model } from "../src/types.ts";
+import { hasBedrockCredentials } from "./bedrock-utils.ts";
+
+interface BedrockThinkingPayload {
+	additionalModelRequestFields?: {
+		thinking?: { type: string; budget_tokens?: number; display?: string };
+		output_config?: { effort?: string };
+		anthropic_beta?: string[];
+	};
+}
+
+class PayloadCaptured extends Error {
+	constructor() {
+		super("payload captured");
+		this.name = "PayloadCaptured";
+	}
+}
+
+function makeContext(): Context {
+	return {
+		messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+	};
+}
+
+async function capturePayload(
+	model: Model<"bedrock-converse-stream">,
+	options?: BedrockOptions,
+): Promise<BedrockThinkingPayload> {
+	let capturedPayload: BedrockThinkingPayload | undefined;
+	const s = streamBedrock(model, makeContext(), {
+		...options,
+		reasoning: options?.reasoning ?? "high",
+		onPayload: (payload) => {
+			capturedPayload = payload as BedrockThinkingPayload;
+			throw new PayloadCaptured();
+		},
+	});
+
+	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.8 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-8-v1",
+			name: "Claude Opus 4.8 (Global)",
+		};
+
+		const payload = await capturePayload(model);
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		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.8", 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-8-v1",
+			name: "Claude Opus 4.8 (Global)",
+		};
+
+		const payload = await capturePayload(model, { reasoning: "xhigh" });
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "xhigh" });
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
+	});
+
+	it("uses adaptive thinking for Claude Fable 5 when reasoning is enabled", async () => {
+		const model = getModel("amazon-bedrock", "global.anthropic.claude-fable-5");
+
+		const payload = await capturePayload(model);
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "high" });
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
+	});
+
+	it("uses adaptive thinking for Claude Sonnet 5 when reasoning is enabled", async () => {
+		const model = getModel("amazon-bedrock", "global.anthropic.claude-sonnet-5");
+
+		const payload = await capturePayload(model);
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "high" });
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
+	});
+
+	it("uses adaptive thinking for Claude Opus 5 when reasoning is enabled", async () => {
+		const model = getModel("amazon-bedrock", "global.anthropic.claude-opus-5");
+
+		const payload = await capturePayload(model);
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "high" });
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
+	});
+
+	it("maps xhigh reasoning to effort=xhigh for Claude Opus 5", async () => {
+		const model = getModel("amazon-bedrock", "global.anthropic.claude-opus-5");
+
+		const payload = await capturePayload(model, { reasoning: "xhigh" });
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "xhigh" });
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
+	});
+
+	it("maps xhigh reasoning to effort=xhigh for Claude Fable 5", async () => {
+		const model = getModel("amazon-bedrock", "global.anthropic.claude-fable-5");
+
+		const payload = await capturePayload(model, { reasoning: "xhigh" });
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "xhigh" });
+	});
+
+	it("omits display for GovCloud model ids on non-adaptive Claude thinking", async () => {
+		const baseModel = getModel("amazon-bedrock", "us.anthropic.claude-sonnet-4-5-20250929-v1:0");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			id: "us-gov.anthropic.claude-sonnet-4-5-20250929-v1:0",
+			name: "Claude Sonnet 4.5 (GovCloud)",
+		};
+
+		const payload = await capturePayload(model);
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "enabled", budget_tokens: 16384 });
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toEqual(["interleaved-thinking-2025-05-14"]);
+	});
+
+	it("omits display for GovCloud regions on adaptive Claude thinking", 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-8-v1",
+			name: "Claude Opus 4.8 (Global)",
+		};
+
+		const payload = await capturePayload(model, { region: "us-gov-west-1" });
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "high" });
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
+	});
+});
+
+describe.skipIf(!hasBedrockCredentials())("Bedrock Claude max tokens E2E", () => {
+	it(
+		"uses the model maxTokens cap instead of Bedrock's 4096-token default for adaptive Claude models",
+		{ retry: 2, timeout: 180000 },
+		async () => {
+			const baseModel = getModel("amazon-bedrock", "global.anthropic.claude-sonnet-4-6");
+			const model: Model<"bedrock-converse-stream"> = {
+				...baseModel,
+				maxTokens: 6000,
+			};
+
+			const response = await streamBedrock(
+				model,
+				{
+					systemPrompt: "You are a deterministic text generator. Follow the requested output format exactly.",
+					messages: [
+						{
+							role: "user",
+							content:
+								"Output exactly 5200 repetitions of the token alpha, separated by single spaces. Do not number them. Do not use markdown. Do not add any other text.",
+							timestamp: Date.now(),
+						},
+					],
+				},
+				{ reasoning: "low" },
+			).result();
+
+			expect(response.stopReason, response.errorMessage).not.toBe("error");
+			expect(response.usage.output).toBeGreaterThan(4096);
+		},
+	);
+});
+
+describe("Application inference profile support", () => {
+	it("uses adaptive thinking when model.name contains the model name but ARN does not", async () => {
+		const baseModel = getModel("amazon-bedrock", "global.anthropic.claude-opus-4-6-v1");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			id: "arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/my-profile",
+			name: "Claude Opus 4.6",
+		};
+
+		const payload = await capturePayload(model);
+
+		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
+		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "high" });
+	});
+
+	it("injects cache points when model.name identifies a supported Claude model", async () => {
+		const baseModel = getModel("amazon-bedrock", "global.anthropic.claude-opus-4-6-v1");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			id: "arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/my-profile",
+			name: "Claude Sonnet 4.6",
+		};
+
+		let capturedPayload: any;
+		const s = streamBedrock(
+			model,
+			{
+				systemPrompt: "You are helpful.",
+				messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
+			},
+			{
+				onPayload: (payload) => {
+					capturedPayload = payload;
+					throw new PayloadCaptured();
+				},
+			},
+		);
+
+		for await (const event of s) {
+			if (event.type === "error") break;
+		}
+
+		// System prompt should have a cache point
+		expect(capturedPayload.system).toHaveLength(2);
+		expect(capturedPayload.system[1]).toHaveProperty("cachePoint");
+
+		// Last user message should have a cache point
+		const lastMsg = capturedPayload.messages[capturedPayload.messages.length - 1];
+		const lastContent = lastMsg.content[lastMsg.content.length - 1];
+		expect(lastContent).toHaveProperty("cachePoint");
+	});
+
+	it("falls back to fixed-budget thinking for non-adaptive Claude via model.name", async () => {
+		const baseModel = getModel("amazon-bedrock", "us.anthropic.claude-sonnet-4-5-20250929-v1:0");
+		const model: Model<"bedrock-converse-stream"> = {
+			...baseModel,
+			id: "arn:aws:bedrock:us-east-1:123456789012:application-inference-profile/my-profile",
+			name: "Claude Sonnet 4.5",
+		};
+
+		const payload = await capturePayload(model);
+
+		expect(payload.additionalModelRequestFields?.thinking).toMatchObject({
+			type: "enabled",
+			budget_tokens: expect.any(Number),
+		});
+		expect(payload.additionalModelRequestFields?.anthropic_beta).toEqual(["interleaved-thinking-2025-05-14"]);
+	});
+});

packages/ai/test/cloudflare-utils.ts

@@ -0,0 +1,9 @@
+export function hasCloudflareWorkersAICredentials(): boolean {
+	return !!process.env.CLOUDFLARE_API_KEY && !!process.env.CLOUDFLARE_ACCOUNT_ID;
+}
+
+export function hasCloudflareAiGatewayCredentials(): boolean {
+	return (
+		!!process.env.CLOUDFLARE_API_KEY && !!process.env.CLOUDFLARE_ACCOUNT_ID && !!process.env.CLOUDFLARE_GATEWAY_ID
+	);
+}

packages/ai/test/compat-env.test.ts

@@ -0,0 +1,74 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { complete, registerApiProvider, resetApiProviders } from "../src/compat.ts";
+import type { AssistantMessage, Context, Model } from "../src/types.ts";
+import { AssistantMessageEventStream } from "../src/utils/event-stream.ts";
+
+const context: Context = { messages: [{ role: "user", content: "hi", timestamp: Date.now() }] };
+
+const model: Model<"openai-responses"> = {
+	id: "test-model",
+	name: "Test Model",
+	api: "openai-responses",
+	provider: "custom-openai",
+	baseUrl: "https://example.test/v1",
+	reasoning: false,
+	input: ["text"],
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	contextWindow: 128000,
+	maxTokens: 4096,
+};
+
+function message(): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [{ type: "text", text: "ok" }],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: Date.now(),
+	};
+}
+
+describe("compat legacy API fallback", () => {
+	afterEach(() => {
+		resetApiProviders();
+	});
+
+	it("dispatches unknown providers through the legacy API registry", async () => {
+		let capturedApiKey: string | undefined;
+		registerApiProvider({
+			api: "openai-responses",
+			stream: (_model, _context, options) => {
+				capturedApiKey = options?.apiKey;
+				const stream = new AssistantMessageEventStream();
+				const output = message();
+				stream.push({ type: "start", partial: output });
+				stream.push({ type: "done", reason: "stop", message: output });
+				stream.end(output);
+				return stream;
+			},
+			streamSimple: (_model, _context, options) => {
+				capturedApiKey = options?.apiKey;
+				const stream = new AssistantMessageEventStream();
+				const output = message();
+				stream.push({ type: "start", partial: output });
+				stream.push({ type: "done", reason: "stop", message: output });
+				stream.end(output);
+				return stream;
+			},
+		});
+
+		await complete(model, context, { apiKey: "request-key" });
+
+		expect(capturedApiKey).toBe("request-key");
+	});
+});

packages/ai/test/cross-provider-handoff.test.ts

@@ -0,0 +1,522 @@
+/**
+ * Cross-Provider Handoff Test
+ *
+ * Tests that contexts generated by one provider/model can be consumed by another.
+ * This catches issues like:
+ * - Tool call ID format incompatibilities (e.g., OpenAI Codex pipe characters)
+ * - Thinking block transformation issues
+ * - Message format incompatibilities
+ *
+ * Strategy:
+ * 1. beforeAll: For each provider/model, generate a "small context" (if not cached):
+ *    - User message asking to use a tool
+ *    - Assistant response with thinking + tool call
+ *    - Tool result
+ *    - Final assistant response
+ *
+ * 2. Test: For each target provider/model:
+ *    - Concatenate ALL other contexts into one
+ *    - Ask the model to "say hi"
+ *    - If it fails, there's a compatibility issue
+ *
+ * Fixtures are generated fresh on each run.
+ */
+
+import { writeFileSync } from "fs";
+import { Type } from "typebox";
+import { beforeAll, describe, expect, it } from "vitest";
+import { completeSimple, getEnvApiKey, getModel } from "../src/compat.ts";
+import type { Api, AssistantMessage, Message, Model, Tool, ToolResultMessage } from "../src/types.ts";
+import { hasAzureOpenAICredentials } from "./azure-utils.ts";
+import { hasCloudflareAiGatewayCredentials, hasCloudflareWorkersAICredentials } from "./cloudflare-utils.ts";
+import { resolveApiKey } from "./oauth.ts";
+
+// Simple tool for testing
+const testToolSchema = Type.Object({
+	value: Type.Number({ description: "A number to double" }),
+});
+
+const testTool: Tool<typeof testToolSchema> = {
+	name: "double_number",
+	description: "Doubles a number and returns the result",
+	parameters: testToolSchema,
+};
+
+// Provider/model pairs to test
+interface ProviderModelPair {
+	provider: string;
+	model: string;
+	label: string;
+	apiOverride?: Api;
+	upstreamApiKeyEnv?: string;
+}
+
+const PROVIDER_MODEL_PAIRS: ProviderModelPair[] = [
+	// Anthropic
+	{ provider: "anthropic", model: "claude-sonnet-4-5", label: "anthropic-claude-sonnet-4-5" },
+	// Google
+	{ provider: "google", model: "gemini-3-flash-preview", label: "google-gemini-3-flash-preview" },
+	// OpenAI
+	{
+		provider: "openai",
+		model: "gpt-4o-mini",
+		label: "openai-completions-gpt-4o-mini",
+		apiOverride: "openai-completions",
+	},
+	{ provider: "openai", model: "gpt-5-mini", label: "openai-responses-gpt-5-mini" },
+	{ provider: "azure-openai-responses", model: "gpt-4o-mini", label: "azure-openai-responses-gpt-4o-mini" },
+	// OpenAI Codex
+	{ provider: "openai-codex", model: "gpt-5.5", label: "openai-codex-gpt-5.5" },
+	// GitHub Copilot
+	{ provider: "github-copilot", model: "claude-sonnet-4.5", label: "copilot-claude-sonnet-4.5" },
+	{ provider: "github-copilot", model: "gpt-5.1-codex", label: "copilot-gpt-5.1-codex" },
+	{ provider: "github-copilot", model: "gemini-3-flash-preview", label: "copilot-gemini-3-flash-preview" },
+	{ provider: "github-copilot", model: "grok-code-fast-1", label: "copilot-grok-code-fast-1" },
+	// Amazon Bedrock
+	{
+		provider: "amazon-bedrock",
+		model: "global.anthropic.claude-sonnet-4-5-20250929-v1:0",
+		label: "bedrock-claude-sonnet-4-5",
+	},
+	// xAI
+	{ provider: "xai", model: "grok-4.3", label: "xai-grok-4.3" },
+	// Cerebras
+	{ provider: "cerebras", model: "zai-glm-4.7", label: "cerebras-zai-glm-4.7" },
+	// Cloudflare Workers AI
+	{ provider: "cloudflare-workers-ai", model: "@cf/moonshotai/kimi-k2.6", label: "cloudflare-kimi-k2.6" },
+	// Cloudflare AI Gateway
+	{
+		provider: "cloudflare-ai-gateway",
+		model: "workers-ai/@cf/moonshotai/kimi-k2.6",
+		label: "cloudflare-gateway-kimi-k2.6",
+	},
+	{
+		provider: "cloudflare-ai-gateway",
+		model: "claude-sonnet-4-5",
+		label: "cloudflare-gateway-claude-sonnet-4-5",
+		upstreamApiKeyEnv: "ANTHROPIC_API_KEY",
+	},
+	{
+		provider: "cloudflare-ai-gateway",
+		model: "gpt-5.1",
+		label: "cloudflare-gateway-gpt-5.1",
+		upstreamApiKeyEnv: "OPENAI_API_KEY",
+	},
+	// Groq
+	{ provider: "groq", model: "openai/gpt-oss-120b", label: "groq-gpt-oss-120b" },
+	// Hugging Face
+	{ provider: "huggingface", model: "moonshotai/Kimi-K2.5", label: "huggingface-kimi-k2.5" },
+	// Together AI
+	{ provider: "together", model: "moonshotai/Kimi-K2.6", label: "together-kimi-k2.6" },
+	// Baseten
+	{ provider: "baseten", model: "zai-org/GLM-5.2", label: "baseten-glm-5.2" },
+	// Kimi For Coding
+	{ provider: "kimi-coding", model: "kimi-for-coding", label: "kimi-for-coding" },
+	// Mistral
+	{ provider: "mistral", model: "devstral-medium-latest", label: "mistral-devstral-medium" },
+	// MiniMax
+	{ provider: "minimax", model: "MiniMax-M2.7", label: "minimax-m2.7" },
+	{ provider: "minimax-cn", model: "MiniMax-M2.7", label: "minimax-m2.7" },
+	// OpenCode Zen
+	{ provider: "opencode", model: "big-pickle", label: "zen-big-pickle" },
+	{ provider: "opencode", model: "claude-sonnet-4-5", label: "zen-claude-sonnet-4-5" },
+	{ provider: "opencode", model: "gemini-3-flash", label: "zen-gemini-3-flash" },
+	{ provider: "opencode", model: "glm-4.7-free", label: "zen-glm-4.7-free" },
+	{ provider: "opencode", model: "gpt-5.2-codex", label: "zen-gpt-5.2-codex" },
+	{ provider: "opencode", model: "minimax-m2.1-free", label: "zen-minimax-m2.1-free" },
+	// OpenCode Go
+	{ provider: "opencode-go", model: "kimi-k2.5", label: "go-kimi-k2.5" },
+	{ provider: "opencode-go", model: "minimax-m2.5", label: "go-minimax-m2.5" },
+	// Xiaomi MiMo
+	{ provider: "xiaomi", model: "mimo-v2.5-pro", label: "xiaomi-mimo-v2.5-pro" },
+	{ provider: "xiaomi-token-plan-cn", model: "mimo-v2.5-pro", label: "xiaomi-token-plan-cn-mimo-v2.5-pro" },
+	{ provider: "xiaomi-token-plan-ams", model: "mimo-v2.5-pro", label: "xiaomi-token-plan-ams-mimo-v2.5-pro" },
+	{ provider: "xiaomi-token-plan-sgp", model: "mimo-v2.5-pro", label: "xiaomi-token-plan-sgp-mimo-v2.5-pro" },
+	// Qwen Token Plan
+	{ provider: "qwen-token-plan", model: "qwen3.7-max", label: "qwen-token-plan-qwen3.7-max" },
+	{ provider: "qwen-token-plan-cn", model: "qwen3.7-max", label: "qwen-token-plan-cn-qwen3.7-max" },
+	{
+		provider: "qwen-token-plan-individual",
+		model: "qwen3.8-max",
+		label: "qwen-token-plan-individual-qwen3.8-max",
+	},
+	{
+		provider: "qwen-token-plan-individual",
+		model: "deepseek-v4-flash-0731",
+		label: "qwen-token-plan-individual-deepseek-v4-flash-0731",
+	},
+	{
+		provider: "qwen-token-plan-individual",
+		model: "glm-5.2",
+		label: "qwen-token-plan-individual-glm-5.2",
+	},
+];
+
+// Cached context structure
+interface CachedContext {
+	label: string;
+	provider: string;
+	model: string;
+	api: Api;
+	messages: Message[];
+	generatedAt: string;
+}
+
+/**
+ * Get API key for provider - checks OAuth storage first, then env vars
+ */
+async function getApiKey(provider: string): Promise<string | undefined> {
+	const oauthKey = await resolveApiKey(provider);
+	if (oauthKey) return oauthKey;
+	return getEnvApiKey(provider);
+}
+
+/**
+ * Synchronous check for API key availability (env vars only, for skipIf)
+ */
+function hasApiKey(pair: ProviderModelPair): boolean {
+	if (pair.provider === "azure-openai-responses") {
+		return hasAzureOpenAICredentials();
+	}
+	if (pair.provider === "cloudflare-workers-ai") {
+		return hasCloudflareWorkersAICredentials();
+	}
+	if (pair.provider === "cloudflare-ai-gateway") {
+		if (!hasCloudflareAiGatewayCredentials()) return false;
+		return pair.upstreamApiKeyEnv ? !!process.env[pair.upstreamApiKeyEnv] : true;
+	}
+	return !!getEnvApiKey(pair.provider);
+}
+
+function getHeaders(pair: ProviderModelPair): Record<string, string> | undefined {
+	if (!pair.upstreamApiKeyEnv) return undefined;
+	const upstreamApiKey = process.env[pair.upstreamApiKeyEnv];
+	return upstreamApiKey ? { Authorization: `Bearer ${upstreamApiKey}` } : undefined;
+}
+
+/**
+ * Check if any provider has API keys available (for skipIf at describe level)
+ */
+function hasAnyApiKey(): boolean {
+	return PROVIDER_MODEL_PAIRS.some((pair) => hasApiKey(pair));
+}
+
+function dumpFailurePayload(params: { label: string; error: string; payload?: unknown; messages: Message[] }): void {
+	const filename = `/tmp/pi-handoff-${params.label}-${Date.now()}.json`;
+	const body = {
+		label: params.label,
+		error: params.error,
+		payload: params.payload,
+		messages: params.messages,
+	};
+	writeFileSync(filename, JSON.stringify(body, null, 2));
+	console.log(`Wrote failure payload to ${filename}`);
+}
+
+/**
+ * Generate a context from a provider/model pair.
+ * Makes a real API call to get authentic tool call IDs and thinking blocks.
+ */
+async function generateContext(
+	pair: ProviderModelPair,
+	apiKey: string,
+): Promise<{ messages: Message[]; api: Api } | null> {
+	const baseModel = (getModel as (p: string, m: string) => Model<Api> | undefined)(pair.provider, pair.model);
+	if (!baseModel) {
+		console.log(`  Model not found: ${pair.provider}/${pair.model}`);
+		return null;
+	}
+
+	const model: Model<Api> = pair.apiOverride ? { ...baseModel, api: pair.apiOverride } : baseModel;
+
+	const userMessage: Message = {
+		role: "user",
+		content: "Please double the number 21 using the double_number tool.",
+		timestamp: Date.now(),
+	};
+
+	const supportsReasoning = model.reasoning === true;
+	const headers = getHeaders(pair);
+	let lastPayload: unknown;
+	let assistantResponse: AssistantMessage;
+	try {
+		assistantResponse = await completeSimple(
+			model,
+			{
+				systemPrompt: "You are a helpful assistant. Use the provided tool to complete the task.",
+				messages: [userMessage],
+				tools: [testTool],
+			},
+			{
+				apiKey,
+				reasoning: supportsReasoning ? "high" : undefined,
+				headers,
+				onPayload: (payload) => {
+					lastPayload = payload;
+				},
+			},
+		);
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.log(`  Initial request failed: ${msg}`);
+		dumpFailurePayload({
+			label: `${pair.label}-initial`,
+			error: msg,
+			payload: lastPayload,
+			messages: [userMessage],
+		});
+		return null;
+	}
+
+	if (assistantResponse.stopReason === "error") {
+		console.log(`  Initial request error: ${assistantResponse.errorMessage}`);
+		dumpFailurePayload({
+			label: `${pair.label}-initial`,
+			error: assistantResponse.errorMessage || "Unknown error",
+			payload: lastPayload,
+			messages: [userMessage],
+		});
+		return null;
+	}
+
+	const toolCall = assistantResponse.content.find((c) => c.type === "toolCall");
+	if (!toolCall || toolCall.type !== "toolCall") {
+		console.log(`  No tool call in response (stopReason: ${assistantResponse.stopReason})`);
+		return {
+			messages: [userMessage, assistantResponse],
+			api: model.api,
+		};
+	}
+
+	console.log(`  Tool call ID: ${toolCall.id}`);
+
+	const toolResult: ToolResultMessage = {
+		role: "toolResult",
+		toolCallId: toolCall.id,
+		toolName: toolCall.name,
+		content: [{ type: "text", text: "42" }],
+		isError: false,
+		timestamp: Date.now(),
+	};
+
+	let finalResponse: AssistantMessage;
+	const messagesForFinal = [userMessage, assistantResponse, toolResult];
+	try {
+		finalResponse = await completeSimple(
+			model,
+			{
+				systemPrompt: "You are a helpful assistant.",
+				messages: messagesForFinal,
+				tools: [testTool],
+			},
+			{
+				apiKey,
+				reasoning: supportsReasoning ? "high" : undefined,
+				headers,
+				onPayload: (payload) => {
+					lastPayload = payload;
+				},
+			},
+		);
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		console.log(`  Final request failed: ${msg}`);
+		dumpFailurePayload({
+			label: `${pair.label}-final`,
+			error: msg,
+			payload: lastPayload,
+			messages: messagesForFinal,
+		});
+		return null;
+	}
+
+	if (finalResponse.stopReason === "error") {
+		console.log(`  Final request error: ${finalResponse.errorMessage}`);
+		dumpFailurePayload({
+			label: `${pair.label}-final`,
+			error: finalResponse.errorMessage || "Unknown error",
+			payload: lastPayload,
+			messages: messagesForFinal,
+		});
+		return null;
+	}
+
+	return {
+		messages: [userMessage, assistantResponse, toolResult, finalResponse],
+		api: model.api,
+	};
+}
+
+describe.skipIf(!hasAnyApiKey())("Cross-Provider Handoff", () => {
+	let contexts: Record<string, CachedContext>;
+	let availablePairs: ProviderModelPair[];
+
+	beforeAll(async () => {
+		contexts = {};
+		availablePairs = [];
+
+		console.log("\n=== Generating Fixtures ===\n");
+
+		for (const pair of PROVIDER_MODEL_PAIRS) {
+			const apiKey = await getApiKey(pair.provider);
+			if (!apiKey || !hasApiKey(pair)) {
+				console.log(`[${pair.label}] Skipping - no auth for ${pair.provider}`);
+				continue;
+			}
+
+			console.log(`[${pair.label}] Generating fixture...`);
+			const result = await generateContext(pair, apiKey);
+
+			if (!result || result.messages.length < 4) {
+				console.log(`[${pair.label}] Failed to generate fixture, skipping`);
+				continue;
+			}
+
+			contexts[pair.label] = {
+				label: pair.label,
+				provider: pair.provider,
+				model: pair.model,
+				api: result.api,
+				messages: result.messages,
+				generatedAt: new Date().toISOString(),
+			};
+			availablePairs.push(pair);
+			console.log(`[${pair.label}] Generated ${result.messages.length} messages`);
+		}
+
+		console.log(`\n=== ${availablePairs.length}/${PROVIDER_MODEL_PAIRS.length} contexts available ===\n`);
+	}, 300000);
+
+	it.skipIf(!hasAnyApiKey())("should have at least 2 fixtures to test handoffs", () => {
+		expect(Object.keys(contexts).length).toBeGreaterThanOrEqual(2);
+	});
+
+	it.skipIf(!hasAnyApiKey())(
+		"should handle cross-provider handoffs for each target",
+		async () => {
+			const contextLabels = Object.keys(contexts);
+
+			if (contextLabels.length < 2) {
+				console.log("Not enough fixtures for handoff test, skipping");
+				return;
+			}
+
+			console.log("\n=== Testing Cross-Provider Handoffs ===\n");
+
+			const results: { target: string; success: boolean; error?: string }[] = [];
+
+			for (const targetPair of availablePairs) {
+				const apiKey = await getApiKey(targetPair.provider);
+				if (!apiKey || !hasApiKey(targetPair)) {
+					console.log(`[Target: ${targetPair.label}] Skipping - no auth`);
+					continue;
+				}
+
+				// Collect messages from ALL OTHER contexts
+				const otherMessages: Message[] = [];
+				for (const [label, ctx] of Object.entries(contexts)) {
+					if (label === targetPair.label) continue;
+					otherMessages.push(...ctx.messages);
+				}
+
+				if (otherMessages.length === 0) {
+					console.log(`[Target: ${targetPair.label}] Skipping - no other contexts`);
+					continue;
+				}
+
+				const allMessages: Message[] = [
+					...otherMessages,
+					{
+						role: "user",
+						content:
+							"Great, thanks for all that help! Now just say 'Hello, handoff successful!' to confirm you received everything.",
+						timestamp: Date.now(),
+					},
+				];
+
+				const baseModel = (getModel as (p: string, m: string) => Model<Api> | undefined)(
+					targetPair.provider,
+					targetPair.model,
+				);
+				if (!baseModel) {
+					console.log(`[Target: ${targetPair.label}] Model not found`);
+					continue;
+				}
+
+				const model: Model<Api> = targetPair.apiOverride
+					? { ...baseModel, api: targetPair.apiOverride }
+					: baseModel;
+				const supportsReasoning = model.reasoning === true;
+				const headers = getHeaders(targetPair);
+
+				console.log(
+					`[Target: ${targetPair.label}] Testing with ${otherMessages.length} messages from other providers...`,
+				);
+
+				let lastPayload: unknown;
+				try {
+					const response = await completeSimple(
+						model,
+						{
+							systemPrompt: "You are a helpful assistant.",
+							messages: allMessages,
+							tools: [testTool],
+						},
+						{
+							apiKey,
+							reasoning: supportsReasoning ? "high" : undefined,
+							headers,
+							onPayload: (payload) => {
+								lastPayload = payload;
+							},
+						},
+					);
+
+					if (response.stopReason === "error") {
+						console.log(`[Target: ${targetPair.label}] FAILED: ${response.errorMessage}`);
+						dumpFailurePayload({
+							label: targetPair.label,
+							error: response.errorMessage || "Unknown error",
+							payload: lastPayload,
+							messages: allMessages,
+						});
+						results.push({ target: targetPair.label, success: false, error: response.errorMessage });
+					} else {
+						const text = response.content
+							.filter((c) => c.type === "text")
+							.map((c) => c.text)
+							.join(" ");
+						const preview = text.slice(0, 100).replace(/\n/g, " ");
+						console.log(`[Target: ${targetPair.label}] SUCCESS: ${preview}...`);
+						results.push({ target: targetPair.label, success: true });
+					}
+				} catch (error) {
+					const msg = error instanceof Error ? error.message : String(error);
+					console.log(`[Target: ${targetPair.label}] EXCEPTION: ${msg}`);
+					dumpFailurePayload({
+						label: targetPair.label,
+						error: msg,
+						payload: lastPayload,
+						messages: allMessages,
+					});
+					results.push({ target: targetPair.label, success: false, error: msg });
+				}
+			}
+
+			console.log("\n=== Results Summary ===\n");
+			const successes = results.filter((r) => r.success);
+			const failures = results.filter((r) => !r.success);
+
+			console.log(`Passed: ${successes.length}/${results.length}`);
+			if (failures.length > 0) {
+				console.log("\nFailures:");
+				for (const f of failures) {
+					console.log(`  - ${f.target}: ${f.error}`);
+				}
+			}
+
+			expect(failures.length).toBe(0);
+		},
+		600000,
+	);
+});

packages/ai/test/deferred-tools.test.ts

@@ -0,0 +1,550 @@
+import { Type } from "typebox";
+import { describe, expect, it } from "vitest";
+import { convertMessages } from "../src/api/openai-completions.ts";
+import { getModel, streamSimple } from "../src/compat.ts";
+import type { Api, AssistantMessage, Context, Model, Tool, ToolResultMessage, UserMessage } from "../src/types.ts";
+import { estimateContextTokens } from "../src/utils/estimate.ts";
+
+interface AnthropicToolPayload {
+	name: string;
+	description?: string;
+	defer_loading?: boolean;
+}
+
+interface AnthropicContentBlock {
+	type: string;
+	text?: string;
+	tool_use_id?: string;
+	content?: string | Array<{ type: string; tool_name?: string }>;
+	source?: {
+		type: string;
+		media_type: string;
+		data: string;
+	};
+}
+
+interface AnthropicPayload {
+	tools?: AnthropicToolPayload[];
+	messages: Array<{
+		content: string | AnthropicContentBlock[];
+	}>;
+}
+
+interface OpenAIToolSearchCall {
+	type: "tool_search_call";
+	call_id?: string | null;
+	execution?: string;
+	status?: string | null;
+}
+
+interface OpenAIToolSearchOutput {
+	type: "tool_search_output";
+	call_id?: string | null;
+	execution?: string;
+	status?: string | null;
+	tools: Array<{ type: string; name: string; defer_loading?: boolean }>;
+}
+
+interface OpenAIAdditionalTools {
+	type: "additional_tools";
+	role: "developer";
+	tools: Array<{ type: string; name: string; defer_loading?: boolean }>;
+}
+
+interface OpenAIPayload {
+	tools?: Array<{ name?: string; function?: { name: string } }>;
+	input?: Array<
+		OpenAIAdditionalTools | OpenAIToolSearchCall | OpenAIToolSearchOutput | { type?: string; name?: string }
+	>;
+}
+
+interface KimiTool {
+	type: "function";
+	function: {
+		name: string;
+		description?: string;
+		parameters?: Record<string, unknown>;
+	};
+}
+
+interface KimiMessage {
+	role: string;
+	content?: unknown;
+	tools?: KimiTool[];
+}
+
+interface KimiPayload {
+	tools?: KimiTool[];
+	messages: KimiMessage[];
+}
+
+class PayloadCaptured extends Error {}
+
+function makeTool(name: string): Tool {
+	return {
+		name,
+		description: `The ${name} tool`,
+		parameters: Type.Object({ value: Type.String() }),
+	};
+}
+
+function makeUserMessage(timestamp: number): UserMessage {
+	return { role: "user", content: "Hello", timestamp };
+}
+
+function makeAssistantToolCall(): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [{ type: "toolCall", id: "call_1", name: "base_tool", arguments: {} }],
+		api: "anthropic-messages",
+		provider: "anthropic",
+		model: "claude-opus-4-6",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "toolUse",
+		timestamp: 2,
+	};
+}
+
+function makeToolResult(addedToolNames: string[]): ToolResultMessage {
+	return {
+		role: "toolResult",
+		toolCallId: "call_1",
+		toolName: "base_tool",
+		content: [{ type: "text", text: "done" }],
+		addedToolNames,
+		isError: false,
+		timestamp: 3,
+	};
+}
+
+function makeContext(tools: Tool[], addedToolNames = ["late_tool"]): Context {
+	return {
+		messages: [makeUserMessage(1), makeAssistantToolCall(), makeToolResult(addedToolNames), makeUserMessage(4)],
+		tools,
+	};
+}
+
+function makeKimiModel(deferredToolsMode?: "kimi"): Model<"openai-completions"> {
+	return {
+		id: "deferred-tools-model",
+		name: "Deferred Tools Model",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "http://127.0.0.1:9/v1",
+		reasoning: false,
+		input: ["text"],
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		contextWindow: 128000,
+		maxTokens: 4096,
+		compat: deferredToolsMode ? { deferredToolsMode } : undefined,
+	};
+}
+
+async function capturePayload<T>(model: Model<Api>, context: Context, apiKey = "fake-key"): Promise<T> {
+	let captured: T | undefined;
+	const stream = streamSimple({ ...model, baseUrl: "http://127.0.0.1:9" }, context, {
+		apiKey,
+		onPayload: (payload) => {
+			captured = payload as T;
+			throw new PayloadCaptured();
+		},
+	});
+	await stream.result();
+	if (!captured) throw new Error("Expected payload capture");
+	return captured;
+}
+
+function findAnthropicToolResultContent(payload: AnthropicPayload): AnthropicContentBlock[] {
+	for (const message of payload.messages) {
+		if (typeof message.content !== "string" && message.content.some((block) => block.type === "tool_result")) {
+			return message.content;
+		}
+	}
+	throw new Error("No tool result in payload");
+}
+
+function findAnthropicToolResult(payload: AnthropicPayload): AnthropicContentBlock {
+	const result = findAnthropicToolResultContent(payload).find((block) => block.type === "tool_result");
+	if (!result) throw new Error("No tool result in payload");
+	return result;
+}
+
+function openAIToolNames(payload: OpenAIPayload): string[] {
+	return (payload.tools ?? []).map((tool) => tool.name ?? tool.function?.name ?? "");
+}
+
+function makeCodexToken(): string {
+	return `header.${btoa(JSON.stringify({ "https://api.openai.com/auth": { chatgpt_account_id: "account" } }))}.signature`;
+}
+
+describe("deferred tools", () => {
+	it("loads an Anthropic tool at its tool-result marker", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const payload = await capturePayload<AnthropicPayload>(getModel("anthropic", "claude-opus-4-6"), context);
+
+		expect(payload.tools).toMatchObject([{ name: "base_tool" }, { name: "late_tool", defer_loading: true }]);
+		expect(findAnthropicToolResult(payload).content).toEqual([{ type: "tool_reference", tool_name: "late_tool" }]);
+	});
+
+	it("preserves tool output as sibling content after emitting references", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const assistant = context.messages[1] as AssistantMessage;
+		assistant.content = [
+			{ type: "toolCall", id: "call_1", name: "base_tool", arguments: {} },
+			{ type: "toolCall", id: "call_2", name: "base_tool", arguments: {} },
+		];
+		const firstResult = context.messages[2] as ToolResultMessage;
+		firstResult.content = [
+			{ type: "text", text: "work completed" },
+			{ type: "image", mimeType: "image/png", data: "aW1hZ2U=" },
+		];
+		context.messages.splice(3, 0, {
+			...makeToolResult([]),
+			toolCallId: "call_2",
+			content: [{ type: "text", text: "second result" }],
+		});
+
+		const payload = await capturePayload<AnthropicPayload>(getModel("anthropic", "claude-opus-4-6"), context);
+
+		expect(findAnthropicToolResultContent(payload)).toMatchObject([
+			{
+				type: "tool_result",
+				tool_use_id: "call_1",
+				content: [{ type: "tool_reference", tool_name: "late_tool" }],
+			},
+			{ type: "tool_result", tool_use_id: "call_2", content: "second result" },
+			{ type: "text", text: "work completed" },
+			{
+				type: "image",
+				source: { type: "base64", media_type: "image/png", data: "aW1hZ2U=" },
+			},
+		]);
+	});
+
+	it("loads a tool introduced by OpenAI history after switching to Anthropic", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const assistant = context.messages[1] as AssistantMessage;
+		assistant.api = "openai-responses";
+		assistant.provider = "openai";
+		assistant.model = "gpt-5.4";
+
+		const payload = await capturePayload<AnthropicPayload>(getModel("anthropic", "claude-opus-4-8"), context);
+
+		expect(payload.tools).toMatchObject([{ name: "base_tool" }, { name: "late_tool", defer_loading: true }]);
+		expect(findAnthropicToolResult(payload).content).toEqual([{ type: "tool_reference", tool_name: "late_tool" }]);
+	});
+
+	it("does not resurrect a marked tool missing from Context.tools", async () => {
+		const context = makeContext([makeTool("base_tool")]);
+		const payload = await capturePayload<AnthropicPayload>(getModel("anthropic", "claude-opus-4-6"), context);
+
+		expect(payload.tools?.map((tool) => tool.name)).toEqual(["base_tool"]);
+		const content = findAnthropicToolResult(payload).content;
+		expect(Array.isArray(content) && content.some((block) => block.type === "tool_reference")).toBe(false);
+	});
+
+	it("keeps a tool immediate when it was used before its marker", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const assistant = context.messages[1] as AssistantMessage;
+		assistant.content = [{ type: "toolCall", id: "call_1", name: "late_tool", arguments: {} }];
+		const payload = await capturePayload<AnthropicPayload>(getModel("anthropic", "claude-opus-4-6"), context);
+
+		expect(payload.tools?.map((tool) => tool.name)).toEqual(["base_tool", "late_tool"]);
+		expect(payload.tools?.every((tool) => !tool.defer_loading)).toBe(true);
+	});
+
+	it("normalizes OAuth names before checking prior tool usage", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("read")], ["read"]);
+		const assistant = context.messages[1] as AssistantMessage;
+		assistant.content = [{ type: "toolCall", id: "call_1", name: "Read", arguments: {} }];
+		const payload = await capturePayload<AnthropicPayload>(
+			getModel("anthropic", "claude-opus-4-6"),
+			context,
+			"sk-ant-oat-fake",
+		);
+
+		expect(payload.tools?.map((tool) => tool.name)).toEqual(["base_tool", "Read"]);
+		expect(payload.tools?.every((tool) => !tool.defer_loading)).toBe(true);
+		const content = findAnthropicToolResult(payload).content;
+		expect(Array.isArray(content) && content.some((block) => block.type === "tool_reference")).toBe(false);
+	});
+
+	it("matches OAuth-canonicalized markers to active tools", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("read")], ["Read"]);
+		const payload = await capturePayload<AnthropicPayload>(
+			getModel("anthropic", "claude-opus-4-6"),
+			context,
+			"sk-ant-oat-fake",
+		);
+
+		expect(payload.tools).toMatchObject([{ name: "base_tool" }, { name: "Read", defer_loading: true }]);
+		const content = findAnthropicToolResult(payload).content;
+		expect(
+			Array.isArray(content) &&
+				content.some((block) => block.type === "tool_reference" && block.tool_name === "Read"),
+		).toBe(true);
+	});
+
+	it("deduplicates active tools after OAuth canonicalization", async () => {
+		const context: Context = {
+			messages: [makeUserMessage(1)],
+			tools: [makeTool("read"), { ...makeTool("Read"), description: "Canonical definition" }],
+		};
+		const payload = await capturePayload<AnthropicPayload>(
+			getModel("anthropic", "claude-opus-4-6"),
+			context,
+			"sk-ant-oat-fake",
+		);
+
+		expect(payload.tools).toMatchObject([{ name: "Read", description: "Canonical definition" }]);
+	});
+
+	it("uses the normal tool list when Anthropic tool references are unsupported", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const models: Model<"anthropic-messages">[] = [
+			getModel("anthropic", "claude-haiku-4-5"),
+			{ ...getModel("anthropic", "claude-opus-4-6"), id: "claude-sonnet-4-20250514" },
+		];
+
+		for (const model of models) {
+			const payload = await capturePayload<AnthropicPayload>(model, context);
+			expect(payload.tools?.map((tool) => tool.name)).toEqual(["base_tool", "late_tool"]);
+			expect(payload.tools?.every((tool) => !tool.defer_loading)).toBe(true);
+		}
+	});
+
+	it("keeps one immediate Anthropic tool when every current tool is marked", async () => {
+		const context = makeContext([makeTool("late_tool")]);
+		const payload = await capturePayload<AnthropicPayload>(getModel("anthropic", "claude-opus-4-6"), context);
+
+		expect(payload.tools).toMatchObject([{ name: "late_tool" }]);
+		expect(payload.tools?.[0]?.defer_loading).toBeUndefined();
+		const content = findAnthropicToolResult(payload).content;
+		expect(Array.isArray(content) && content.some((block) => block.type === "tool_reference")).toBe(false);
+	});
+
+	it("supports explicit Anthropic compatibility overrides", async () => {
+		const model: Model<"anthropic-messages"> = {
+			...getModel("anthropic", "claude-opus-4-6"),
+			provider: "anthropic-proxy",
+			compat: { supportsToolReferences: true },
+		};
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const payload = await capturePayload<AnthropicPayload>(model, context);
+
+		expect(payload.tools?.find((tool) => tool.name === "late_tool")?.defer_loading).toBe(true);
+	});
+
+	it("serializes Kimi deferred tools as system tool definitions", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const payload = await capturePayload<KimiPayload>(makeKimiModel("kimi"), context);
+
+		expect(payload.tools?.map((tool) => tool.function.name)).toEqual(["base_tool"]);
+		const toolResultIndex = payload.messages.findIndex((message) => message.role === "tool");
+		const systemToolIndex = payload.messages.findIndex((message) => message.tools !== undefined);
+		expect(toolResultIndex).toBeGreaterThanOrEqual(0);
+		expect(systemToolIndex).toBeGreaterThan(toolResultIndex);
+		expect(payload.messages[systemToolIndex]?.tools?.map((tool) => tool.function.name)).toEqual(["late_tool"]);
+	});
+
+	it("emits Kimi deferred schemas after all tool results in a batch", () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool"), makeTool("later_tool")]);
+		context.messages.splice(3, 0, {
+			...makeToolResult(["later_tool"]),
+			toolCallId: "call_2",
+		});
+
+		const messages = convertMessages(makeKimiModel("kimi"), context, {
+			supportsStore: false,
+			supportsDeveloperRole: false,
+			supportsReasoningEffort: false,
+			supportsUsageInStreaming: true,
+			supportsFinishReason: true,
+			maxTokensField: "max_tokens",
+			requiresToolResultName: false,
+			requiresAssistantAfterToolResult: false,
+			requiresThinkingAsText: false,
+			requiresReasoningContentOnAssistantMessages: false,
+			thinkingFormat: "openai",
+			openRouterRouting: {},
+			vercelGatewayRouting: {},
+			chatTemplateKwargs: {},
+			chatTemplateArgs: {},
+			zaiToolStream: false,
+			supportsStrictMode: false,
+			supportsOpenAIGrammarTools: false,
+			cacheControlFormat: undefined,
+			sendSessionAffinityHeaders: false,
+			deferredToolsMode: "kimi",
+			sessionAffinityFormat: "openai",
+			supportsLongCacheRetention: false,
+		});
+
+		expect(messages.map((message) => message.role)).toEqual(["user", "assistant", "tool", "tool", "system", "user"]);
+		expect((messages[4] as { tools?: KimiTool[] }).tools?.map((tool) => tool.function.name)).toEqual([
+			"late_tool",
+			"later_tool",
+		]);
+	});
+
+	it("leaves OpenAI Completions tools unchanged without Kimi mode", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const payload = await capturePayload<KimiPayload>(makeKimiModel(), context);
+
+		expect(payload.tools?.map((tool) => tool.function.name)).toEqual(["base_tool", "late_tool"]);
+		expect(payload.messages.some((message) => message.tools !== undefined)).toBe(false);
+	});
+
+	it("loads an OpenAI Responses tool through additional_tools", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const payload = await capturePayload<OpenAIPayload>(getModel("openai", "gpt-5.4"), context);
+		const additionalTools = payload.input?.find(
+			(item): item is OpenAIAdditionalTools => item.type === "additional_tools",
+		);
+
+		expect(openAIToolNames(payload)).toEqual(["base_tool"]);
+		expect(additionalTools).toMatchObject({ role: "developer" });
+		expect(additionalTools?.tools).toMatchObject([{ type: "function", name: "late_tool" }]);
+		expect(additionalTools?.tools.every((tool) => tool.defer_loading === undefined)).toBe(true);
+		expect(payload.input?.some((item) => item.type === "tool_search_call")).toBe(false);
+		expect(payload.input?.some((item) => item.type === "tool_search_output")).toBe(false);
+	});
+
+	it("preserves an additional_tools marker after the loaded tool is used", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const lateCall: AssistantMessage = {
+			...makeAssistantToolCall(),
+			content: [{ type: "toolCall", id: "call_late|fc_late", name: "late_tool", arguments: {} }],
+			api: "openai-responses",
+			provider: "openai",
+			model: "gpt-5.4",
+		};
+		context.messages.splice(3, 0, lateCall, {
+			...makeToolResult(["late_tool"]),
+			toolCallId: "call_late|fc_late",
+			toolName: "late_tool",
+		});
+
+		const payload = await capturePayload<OpenAIPayload>(getModel("openai", "gpt-5.4"), context);
+		const additionalToolIndexes = (payload.input ?? []).flatMap((item, index) =>
+			item.type === "additional_tools" ? [index] : [],
+		);
+		const lateCallIndex = (payload.input ?? []).findIndex(
+			(item) => item.type === "function_call" && item.name === "late_tool",
+		);
+
+		expect(additionalToolIndexes).toHaveLength(1);
+		expect(additionalToolIndexes[0]).toBeLessThan(lateCallIndex);
+		expect(openAIToolNames(payload)).toEqual(["base_tool"]);
+	});
+
+	it("falls back to client tool search when additional_tools is unsupported", async () => {
+		const model: Model<"openai-responses"> = {
+			...getModel("openai", "gpt-5.4"),
+			provider: "openai-proxy",
+			compat: { supportsAdditionalTools: false, supportsToolSearch: true },
+		};
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const payload = await capturePayload<OpenAIPayload>(model, context);
+		const searchCall = payload.input?.find((item): item is OpenAIToolSearchCall => item.type === "tool_search_call");
+		const searchOutput = payload.input?.find(
+			(item): item is OpenAIToolSearchOutput => item.type === "tool_search_output",
+		);
+
+		expect(openAIToolNames(payload)).toEqual(["base_tool"]);
+		expect(searchCall).toMatchObject({ execution: "client", status: "completed" });
+		expect(searchOutput?.call_id).toBe(searchCall?.call_id);
+		expect(searchOutput?.tools).toMatchObject([{ type: "function", name: "late_tool", defer_loading: true }]);
+		expect(payload.input?.some((item) => item.type === "additional_tools")).toBe(false);
+	});
+
+	it.each(["gpt-5.2", "gpt-5.4-nano", "gpt-5.5-pro"] as const)(
+		"uses the normal tool list for unsupported OpenAI model %s",
+		async (modelId) => {
+			const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+			const payload = await capturePayload<OpenAIPayload>(getModel("openai", modelId), context);
+
+			expect(openAIToolNames(payload)).toEqual(["base_tool", "late_tool"]);
+			expect(payload.input?.some((item) => item.type === "tool_search_output")).toBe(false);
+		},
+	);
+
+	it("uses the normal tool list when OpenAI tool search is explicitly disabled", async () => {
+		const model: Model<"openai-responses"> = {
+			...getModel("openai", "gpt-5.4"),
+			provider: "openai-proxy",
+			compat: { supportsToolSearch: false },
+		};
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const payload = await capturePayload<OpenAIPayload>(model, context);
+
+		expect(openAIToolNames(payload)).toEqual(["base_tool", "late_tool"]);
+		expect(payload.input?.some((item) => item.type === "tool_search_output")).toBe(false);
+	});
+
+	it("selects additional tools, tool search, or top-level tools for Codex models", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const additionalTools = await capturePayload<OpenAIPayload>(
+			getModel("openai-codex", "gpt-5.6-sol"),
+			context,
+			makeCodexToken(),
+		);
+		const toolSearch = await capturePayload<OpenAIPayload>(
+			getModel("openai-codex", "gpt-5.5"),
+			context,
+			makeCodexToken(),
+		);
+		const topLevel = await capturePayload<OpenAIPayload>(
+			getModel("openai-codex", "gpt-5.3-codex-spark"),
+			context,
+			makeCodexToken(),
+		);
+
+		expect(openAIToolNames(additionalTools)).toEqual(["base_tool"]);
+		expect(additionalTools.input?.some((item) => item.type === "additional_tools")).toBe(true);
+		expect(additionalTools.input?.some((item) => item.type === "tool_search_output")).toBe(false);
+		expect(openAIToolNames(toolSearch)).toEqual(["base_tool"]);
+		expect(toolSearch.input?.some((item) => item.type === "tool_search_output")).toBe(true);
+		expect(openAIToolNames(topLevel)).toEqual(["base_tool", "late_tool"]);
+		expect(topLevel.input?.some((item) => item.type === "additional_tools")).toBe(false);
+		expect(topLevel.input?.some((item) => item.type === "tool_search_output")).toBe(false);
+	});
+
+	it("leaves providers without deferred loading unchanged", async () => {
+		const context = makeContext([makeTool("base_tool"), makeTool("late_tool")]);
+		const payload = await capturePayload<OpenAIPayload>(getModel("groq", "llama-3.3-70b-versatile"), context);
+		expect(openAIToolNames(payload)).toEqual(["base_tool", "late_tool"]);
+	});
+
+	it("counts definitions marked after the latest usage checkpoint", () => {
+		const assistant: AssistantMessage = {
+			...makeAssistantToolCall(),
+			content: [{ type: "text", text: "done" }],
+			usage: {
+				input: 50,
+				output: 50,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 100,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+			},
+			stopReason: "stop",
+		};
+		const plain = estimateContextTokens({ messages: [assistant, makeUserMessage(4)], tools: [] });
+		const lateTool = { ...makeTool("late_tool"), description: "x".repeat(4000) };
+		const marked = estimateContextTokens({
+			messages: [assistant, makeToolResult(["late_tool"])],
+			tools: [lateTool],
+		});
+
+		expect(marked.tokens).toBeGreaterThan(plain.tokens + 500);
+		expect(marked.trailingTokens).toBeGreaterThan(plain.trailingTokens + 500);
+	});
+});

packages/ai/test/empty.test.ts

@@ -0,0 +1,822 @@
+import { describe, expect, it } from "vitest";
+import { complete, getModel } from "../src/compat.ts";
+import type { Api, AssistantMessage, Context, Model, StreamOptions, UserMessage } from "../src/types.ts";
+
+type StreamOptionsWithExtras = StreamOptions & Record<string, unknown>;
+
+import { hasAzureOpenAICredentials, resolveAzureDeploymentName } from "./azure-utils.ts";
+import { hasBedrockCredentials } from "./bedrock-utils.ts";
+import { hasCloudflareAiGatewayCredentials, hasCloudflareWorkersAICredentials } from "./cloudflare-utils.ts";
+import { resolveApiKey } from "./oauth.ts";
+
+// Resolve OAuth tokens at module level (async, runs before tests)
+const oauthTokens = await Promise.all([
+	resolveApiKey("anthropic"),
+	resolveApiKey("github-copilot"),
+	resolveApiKey("openai-codex"),
+]);
+const [anthropicOAuthToken, githubCopilotToken, openaiCodexToken] = oauthTokens;
+
+async function testEmptyMessage<TApi extends Api>(llm: Model<TApi>, options: StreamOptionsWithExtras = {}) {
+	// Test with completely empty content array
+	const emptyMessage: UserMessage = {
+		role: "user",
+		content: [],
+		timestamp: Date.now(),
+	};
+
+	const context: Context = {
+		messages: [emptyMessage],
+	};
+
+	const response = await complete(llm, context, options);
+
+	// Should either handle gracefully or return an error
+	expect(response).toBeDefined();
+	expect(response.role).toBe("assistant");
+	// Should handle empty string gracefully
+	if (response.stopReason === "error") {
+		expect(response.errorMessage).toBeDefined();
+	} else {
+		expect(response.content).toBeDefined();
+	}
+}
+
+async function testEmptyStringMessage<TApi extends Api>(llm: Model<TApi>, options: StreamOptionsWithExtras = {}) {
+	// Test with empty string content
+	const context: Context = {
+		messages: [
+			{
+				role: "user",
+				content: "",
+				timestamp: Date.now(),
+			},
+		],
+	};
+
+	const response = await complete(llm, context, options);
+
+	expect(response).toBeDefined();
+	expect(response.role).toBe("assistant");
+
+	// Should handle empty string gracefully
+	if (response.stopReason === "error") {
+		expect(response.errorMessage).toBeDefined();
+	} else {
+		expect(response.content).toBeDefined();
+	}
+}
+
+async function testWhitespaceOnlyMessage<TApi extends Api>(llm: Model<TApi>, options: StreamOptionsWithExtras = {}) {
+	// Test with whitespace-only content
+	const context: Context = {
+		messages: [
+			{
+				role: "user",
+				content: "   \n\t  ",
+				timestamp: Date.now(),
+			},
+		],
+	};
+
+	const response = await complete(llm, context, options);
+
+	expect(response).toBeDefined();
+	expect(response.role).toBe("assistant");
+
+	// Should handle whitespace-only gracefully
+	if (response.stopReason === "error") {
+		expect(response.errorMessage).toBeDefined();
+	} else {
+		expect(response.content).toBeDefined();
+	}
+}
+
+async function testEmptyAssistantMessage<TApi extends Api>(llm: Model<TApi>, options: StreamOptionsWithExtras = {}) {
+	// Test with empty assistant message in conversation flow
+	// User -> Empty Assistant -> User
+	const emptyAssistant: AssistantMessage = {
+		role: "assistant",
+		content: [],
+		api: llm.api,
+		provider: llm.provider,
+		model: llm.id,
+		usage: {
+			input: 10,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 10,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: Date.now(),
+	};
+
+	const context: Context = {
+		messages: [
+			{
+				role: "user",
+				content: "Hello, how are you?",
+				timestamp: Date.now(),
+			},
+			emptyAssistant,
+			{
+				role: "user",
+				content: "Please respond this time.",
+				timestamp: Date.now(),
+			},
+		],
+	};
+
+	const response = await complete(llm, context, options);
+
+	expect(response).toBeDefined();
+	expect(response.role).toBe("assistant");
+
+	// Should handle empty assistant message in context gracefully
+	if (response.stopReason === "error") {
+		expect(response.errorMessage).toBeDefined();
+	} else {
+		expect(response.content).toBeDefined();
+		expect(response.content.length).toBeGreaterThan(0);
+	}
+}
+
+describe("AI Providers Empty Message Tests", () => {
+	describe.skipIf(!process.env.GEMINI_API_KEY)("Google Provider Empty Messages", () => {
+		const llm = getModel("google", "gemini-2.5-flash");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.OPENAI_API_KEY)("OpenAI Completions Provider Empty Messages", () => {
+		const llm = getModel("openai", "gpt-4o-mini");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.OPENAI_API_KEY)("OpenAI Responses Provider Empty Messages", () => {
+		const llm = getModel("openai", "gpt-5-mini");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!hasAzureOpenAICredentials())("Azure OpenAI Responses Provider Empty Messages", () => {
+		const llm = getModel("azure-openai-responses", "gpt-4o-mini");
+		const azureDeploymentName = resolveAzureDeploymentName(llm.id);
+		const azureOptions = azureDeploymentName ? { azureDeploymentName } : {};
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm, azureOptions);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm, azureOptions);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm, azureOptions);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm, azureOptions);
+		});
+	});
+
+	describe.skipIf(!process.env.ANTHROPIC_API_KEY)("Anthropic Provider Empty Messages", () => {
+		const llm = getModel("anthropic", "claude-haiku-4-5");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.XAI_API_KEY)("xAI Provider Empty Messages", () => {
+		const llm = getModel("xai", "grok-4.3");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.GROQ_API_KEY)("Groq Provider Empty Messages", () => {
+		const llm = getModel("groq", "openai/gpt-oss-20b");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.CEREBRAS_API_KEY)("Cerebras Provider Empty Messages", () => {
+		const llm = getModel("cerebras", "gpt-oss-120b");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!hasCloudflareWorkersAICredentials())("Cloudflare Workers AI Provider Empty Messages", () => {
+		const llm = getModel("cloudflare-workers-ai", "@cf/moonshotai/kimi-k2.6");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!hasCloudflareAiGatewayCredentials())("Cloudflare AI Gateway Provider Empty Messages", () => {
+		const llm = getModel("cloudflare-ai-gateway", "workers-ai/@cf/moonshotai/kimi-k2.6");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.HF_TOKEN)("Hugging Face Provider Empty Messages", () => {
+		const llm = getModel("huggingface", "moonshotai/Kimi-K2.5");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.TOGETHER_API_KEY)("Together AI Provider Empty Messages", () => {
+		const llm = getModel("together", "moonshotai/Kimi-K2.6");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.BASETEN_API_KEY)("Baseten Provider Empty Messages", () => {
+		const llm = getModel("baseten", "zai-org/GLM-5.2");
+		const options = { reasoningEffort: "high" } satisfies StreamOptionsWithExtras;
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm, options);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm, options);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm, options);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm, options);
+		});
+	});
+
+	describe.skipIf(!process.env.ZAI_API_KEY)("zAI Provider Empty Messages", () => {
+		const llm = getModel("zai", "glm-5.2");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.MISTRAL_API_KEY)("Mistral Provider Empty Messages", () => {
+		const llm = getModel("mistral", "devstral-medium-latest");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.MINIMAX_API_KEY)("MiniMax Provider Empty Messages", () => {
+		const llm = getModel("minimax", "MiniMax-M2.7");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.XIAOMI_API_KEY)("Xiaomi MiMo (API billing) Provider Empty Messages", () => {
+		const llm = getModel("xiaomi", "mimo-v2.5-pro");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.XIAOMI_TOKEN_PLAN_CN_API_KEY)(
+		"Xiaomi MiMo Token Plan (CN) Provider Empty Messages",
+		() => {
+			const llm = getModel("xiaomi-token-plan-cn", "mimo-v2.5-pro");
+
+			it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+				await testEmptyMessage(llm);
+			});
+
+			it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+				await testEmptyStringMessage(llm);
+			});
+
+			it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+				await testWhitespaceOnlyMessage(llm);
+			});
+
+			it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+				await testEmptyAssistantMessage(llm);
+			});
+		},
+	);
+
+	describe.skipIf(!process.env.XIAOMI_TOKEN_PLAN_AMS_API_KEY)(
+		"Xiaomi MiMo Token Plan (AMS) Provider Empty Messages",
+		() => {
+			const llm = getModel("xiaomi-token-plan-ams", "mimo-v2.5-pro");
+
+			it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+				await testEmptyMessage(llm);
+			});
+
+			it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+				await testEmptyStringMessage(llm);
+			});
+
+			it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+				await testWhitespaceOnlyMessage(llm);
+			});
+
+			it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+				await testEmptyAssistantMessage(llm);
+			});
+		},
+	);
+
+	describe.skipIf(!process.env.XIAOMI_TOKEN_PLAN_SGP_API_KEY)(
+		"Xiaomi MiMo Token Plan (SGP) Provider Empty Messages",
+		() => {
+			const llm = getModel("xiaomi-token-plan-sgp", "mimo-v2.5-pro");
+
+			it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+				await testEmptyMessage(llm);
+			});
+
+			it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+				await testEmptyStringMessage(llm);
+			});
+
+			it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+				await testWhitespaceOnlyMessage(llm);
+			});
+
+			it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+				await testEmptyAssistantMessage(llm);
+			});
+		},
+	);
+
+	describe.skipIf(!process.env.QWEN_TOKEN_PLAN_API_KEY)("Qwen Token Plan Provider Empty Messages", () => {
+		const llm = getModel("qwen-token-plan", "qwen3.7-max");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.QWEN_TOKEN_PLAN_API_KEY)("Qwen Token Plan Individual Provider Empty Messages", () => {
+		const llm = getModel("qwen-token-plan-individual", "qwen3.8-max");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.QWEN_TOKEN_PLAN_CN_API_KEY)("Qwen Token Plan (CN) Provider Empty Messages", () => {
+		const llm = getModel("qwen-token-plan-cn", "qwen3.7-max");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.KIMI_API_KEY)("Kimi For Coding Provider Empty Messages", () => {
+		const llm = getModel("kimi-coding", "kimi-for-coding");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!process.env.AI_GATEWAY_API_KEY)("Vercel AI Gateway Provider Empty Messages", () => {
+		const llm = getModel("vercel-ai-gateway", "google/gemini-2.5-flash");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	describe.skipIf(!hasBedrockCredentials())("Amazon Bedrock Provider Empty Messages", () => {
+		const llm = getModel("amazon-bedrock", "global.anthropic.claude-sonnet-4-5-20250929-v1:0");
+
+		it("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm);
+		});
+
+		it("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm);
+		});
+
+		it("should handle whitespace-only content", { retry: 3, timeout: 30000 }, async () => {
+			await testWhitespaceOnlyMessage(llm);
+		});
+
+		it("should handle empty assistant message in conversation", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyAssistantMessage(llm);
+		});
+	});
+
+	// =========================================================================
+	// OAuth-based providers (credentials from ~/.pi/agent/oauth.json)
+	// =========================================================================
+
+	describe("Anthropic OAuth Provider Empty Messages", () => {
+		const llm = getModel("anthropic", "claude-haiku-4-5");
+
+		it.skipIf(!anthropicOAuthToken)("should handle empty content array", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyMessage(llm, { apiKey: anthropicOAuthToken });
+		});
+
+		it.skipIf(!anthropicOAuthToken)("should handle empty string content", { retry: 3, timeout: 30000 }, async () => {
+			await testEmptyStringMessage(llm, { apiKey: anthropicOAuthToken });
+		});
+
+		it.skipIf(!anthropicOAuthToken)(
+			"should handle whitespace-only content",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				await testWhitespaceOnlyMessage(llm, { apiKey: anthropicOAuthToken });
+			},
+		);
+
+		it.skipIf(!anthropicOAuthToken)(
+			"should handle empty assistant message in conversation",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				await testEmptyAssistantMessage(llm, { apiKey: anthropicOAuthToken });
+			},
+		);
+	});
+
+	describe("GitHub Copilot Provider Empty Messages", () => {
+		it.skipIf(!githubCopilotToken)(
+			"claude-haiku-4.5 - should handle empty content array",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("github-copilot", "claude-haiku-4.5");
+				await testEmptyMessage(llm, { apiKey: githubCopilotToken });
+			},
+		);
+
+		it.skipIf(!githubCopilotToken)(
+			"claude-haiku-4.5 - should handle empty string content",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("github-copilot", "claude-haiku-4.5");
+				await testEmptyStringMessage(llm, { apiKey: githubCopilotToken });
+			},
+		);
+
+		it.skipIf(!githubCopilotToken)(
+			"claude-haiku-4.5 - should handle whitespace-only content",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("github-copilot", "claude-haiku-4.5");
+				await testWhitespaceOnlyMessage(llm, { apiKey: githubCopilotToken });
+			},
+		);
+
+		it.skipIf(!githubCopilotToken)(
+			"claude-haiku-4.5 - should handle empty assistant message in conversation",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("github-copilot", "claude-haiku-4.5");
+				await testEmptyAssistantMessage(llm, { apiKey: githubCopilotToken });
+			},
+		);
+
+		it.skipIf(!githubCopilotToken)(
+			"claude-sonnet-4 - should handle empty content array",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("github-copilot", "claude-sonnet-4.6");
+				await testEmptyMessage(llm, { apiKey: githubCopilotToken });
+			},
+		);
+
+		it.skipIf(!githubCopilotToken)(
+			"claude-sonnet-4 - should handle empty string content",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("github-copilot", "claude-sonnet-4.6");
+				await testEmptyStringMessage(llm, { apiKey: githubCopilotToken });
+			},
+		);
+
+		it.skipIf(!githubCopilotToken)(
+			"claude-sonnet-4 - should handle whitespace-only content",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("github-copilot", "claude-sonnet-4.6");
+				await testWhitespaceOnlyMessage(llm, { apiKey: githubCopilotToken });
+			},
+		);
+
+		it.skipIf(!githubCopilotToken)(
+			"claude-sonnet-4 - should handle empty assistant message in conversation",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("github-copilot", "claude-sonnet-4.6");
+				await testEmptyAssistantMessage(llm, { apiKey: githubCopilotToken });
+			},
+		);
+	});
+
+	describe("OpenAI Codex Provider Empty Messages", () => {
+		it.skipIf(!openaiCodexToken)(
+			"gpt-5.5 - should handle empty content array",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("openai-codex", "gpt-5.5");
+				await testEmptyMessage(llm, { apiKey: openaiCodexToken });
+			},
+		);
+
+		it.skipIf(!openaiCodexToken)(
+			"gpt-5.5 - should handle empty string content",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("openai-codex", "gpt-5.5");
+				await testEmptyStringMessage(llm, { apiKey: openaiCodexToken });
+			},
+		);
+
+		it.skipIf(!openaiCodexToken)(
+			"gpt-5.5 - should handle whitespace-only content",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("openai-codex", "gpt-5.5");
+				await testWhitespaceOnlyMessage(llm, { apiKey: openaiCodexToken });
+			},
+		);
+
+		it.skipIf(!openaiCodexToken)(
+			"gpt-5.5 - should handle empty assistant message in conversation",
+			{ retry: 3, timeout: 30000 },
+			async () => {
+				const llm = getModel("openai-codex", "gpt-5.5");
+				await testEmptyAssistantMessage(llm, { apiKey: openaiCodexToken });
+			},
+		);
+	});
+});