Merge model-registry into main

packages/ai/src/api/anthropic-messages.lazy.ts

@@ -0,0 +1,4 @@
+import type { ProviderStreams } from "../types.ts";
+import { lazyApi } from "./lazy.ts";
+
+export const anthropicMessagesApi = (): ProviderStreams => lazyApi(() => import("./anthropic-messages.ts"));

packages/ai/src/api/azure-openai-responses.lazy.ts

@@ -0,0 +1,4 @@
+import type { ProviderStreams } from "../types.ts";
+import { lazyApi } from "./lazy.ts";
+
+export const azureOpenAIResponsesApi = (): ProviderStreams => lazyApi(() => import("./azure-openai-responses.ts"));

packages/ai/src/api/azure-openai-responses.ts

@@ -0,0 +1,299 @@
+import { AzureOpenAI } from "openai";
+import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+import { clampThinkingLevel } from "../models.ts";
+import type {
+	Api,
+	AssistantMessage,
+	Context,
+	Model,
+	SimpleStreamOptions,
+	StreamFunction,
+	StreamOptions,
+} from "../types.ts";
+import { AssistantMessageEventStream } from "../utils/event-stream.ts";
+import { headersToRecord } from "../utils/headers.ts";
+import { getProviderEnvValue } from "../utils/provider-env.ts";
+import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.ts";
+import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.ts";
+import { buildBaseOptions } from "./simple-options.ts";
+
+const DEFAULT_AZURE_API_VERSION = "v1";
+const AZURE_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode", "azure-openai-responses"]);
+
+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;
+}
+
+function resolveDeploymentName(model: Model<"azure-openai-responses">, options?: AzureOpenAIResponsesOptions): string {
+	if (options?.azureDeploymentName) {
+		return options.azureDeploymentName;
+	}
+	const mappedDeployment = parseDeploymentNameMap(
+		getProviderEnvValue("AZURE_OPENAI_DEPLOYMENT_NAME_MAP", options?.env),
+	).get(model.id);
+	return mappedDeployment || model.id;
+}
+
+function formatAzureOpenAIError(error: unknown): string {
+	if (error instanceof Error) {
+		const status = (error as Error & { status?: unknown }).status;
+		const statusCode = typeof status === "number" ? status : undefined;
+		if (statusCode !== undefined) {
+			return `Azure OpenAI API error (${statusCode}): ${error.message}`;
+		}
+		return error.message;
+	}
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+
+// Azure OpenAI Responses-specific options
+export interface AzureOpenAIResponsesOptions extends StreamOptions {
+	reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
+	reasoningSummary?: "auto" | "detailed" | "concise" | null;
+	azureApiVersion?: string;
+	azureResourceName?: string;
+	azureBaseUrl?: string;
+	azureDeploymentName?: string;
+}
+
+/**
+ * Generate function for Azure OpenAI Responses API
+ */
+export const stream: StreamFunction<"azure-openai-responses", AzureOpenAIResponsesOptions> = (
+	model: Model<"azure-openai-responses">,
+	context: Context,
+	options?: AzureOpenAIResponsesOptions,
+): AssistantMessageEventStream => {
+	const stream = new AssistantMessageEventStream();
+
+	// Start async processing
+	(async () => {
+		const deploymentName = resolveDeploymentName(model, options);
+
+		const output: AssistantMessage = {
+			role: "assistant",
+			content: [],
+			api: "azure-openai-responses" as 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(),
+		};
+
+		try {
+			// Create Azure OpenAI client
+			const apiKey = options?.apiKey;
+			if (!apiKey) {
+				throw new Error(`No API key for provider: ${model.provider}`);
+			}
+			const client = createClient(model, apiKey, options);
+			let params = buildParams(model, context, options, deploymentName);
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== undefined) {
+				params = nextParams as ResponseCreateParamsStreaming;
+			}
+			const requestOptions = {
+				...(options?.signal ? { signal: options.signal } : {}),
+				...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+				maxRetries: options?.maxRetries ?? 0,
+			};
+			const { data: openaiStream, response } = await client.responses.create(params, requestOptions).withResponse();
+			await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
+			stream.push({ type: "start", partial: output });
+
+			await processResponsesStream(openaiStream, output, stream, model);
+
+			if (options?.signal?.aborted) {
+				throw new Error("Request was aborted");
+			}
+
+			if (output.stopReason === "aborted" || output.stopReason === "error") {
+				throw new Error("An unknown error occurred");
+			}
+
+			stream.push({ type: "done", reason: output.stopReason, message: output });
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) {
+				delete (block as { index?: number }).index;
+				// partialJson is only a streaming scratch buffer; never persist it.
+				delete (block as { partialJson?: string }).partialJson;
+			}
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = formatAzureOpenAIError(error);
+			stream.push({ type: "error", reason: output.stopReason, error: output });
+			stream.end();
+		}
+	})();
+
+	return stream;
+};
+
+export const streamSimple: StreamFunction<"azure-openai-responses", SimpleStreamOptions> = (
+	model: Model<"azure-openai-responses">,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream => {
+	const apiKey = options?.apiKey;
+	if (!apiKey) {
+		throw new Error(`No API key for provider: ${model.provider}`);
+	}
+
+	const base = buildBaseOptions(model, options, apiKey);
+	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+	const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
+
+	return stream(model, context, {
+		...base,
+		reasoningEffort,
+	} satisfies AzureOpenAIResponsesOptions);
+};
+
+function normalizeAzureBaseUrl(baseUrl: string): string {
+	const trimmed = baseUrl.trim().replace(/\/+$/, "");
+	let url: URL;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		throw new Error(`Invalid Azure OpenAI base URL: ${baseUrl}`);
+	}
+
+	const isAzureHost =
+		url.hostname.endsWith(".openai.azure.com") || url.hostname.endsWith(".cognitiveservices.azure.com");
+	const normalizedPath = url.pathname.replace(/\/+$/, "");
+
+	// Ensure Azure hosts have /openai/v1 as base path so the AzureOpenAI SDK
+	// can append /deployments/<model>/... and ?api-version=v1 correctly.
+	if (isAzureHost && (normalizedPath === "" || normalizedPath === "/" || normalizedPath === "/openai")) {
+		url.pathname = "/openai/v1";
+		url.search = "";
+	}
+
+	return url.toString().replace(/\/+$/, "");
+}
+
+function buildDefaultBaseUrl(resourceName: string): string {
+	return `https://${resourceName}.openai.azure.com/openai/v1`;
+}
+
+function resolveAzureConfig(
+	model: Model<"azure-openai-responses">,
+	options?: AzureOpenAIResponsesOptions,
+): { baseUrl: string; apiVersion: string } {
+	const apiVersion =
+		options?.azureApiVersion ||
+		getProviderEnvValue("AZURE_OPENAI_API_VERSION", options?.env) ||
+		DEFAULT_AZURE_API_VERSION;
+
+	const baseUrl =
+		options?.azureBaseUrl?.trim() || getProviderEnvValue("AZURE_OPENAI_BASE_URL", options?.env)?.trim() || undefined;
+	const resourceName = options?.azureResourceName || getProviderEnvValue("AZURE_OPENAI_RESOURCE_NAME", options?.env);
+
+	let resolvedBaseUrl = baseUrl;
+
+	if (!resolvedBaseUrl && resourceName) {
+		resolvedBaseUrl = buildDefaultBaseUrl(resourceName);
+	}
+
+	if (!resolvedBaseUrl && model.baseUrl) {
+		resolvedBaseUrl = model.baseUrl;
+	}
+
+	if (!resolvedBaseUrl) {
+		throw new Error(
+			"Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or pass azureBaseUrl, azureResourceName, or model.baseUrl.",
+		);
+	}
+
+	return {
+		baseUrl: normalizeAzureBaseUrl(resolvedBaseUrl),
+		apiVersion,
+	};
+}
+
+function createClient(model: Model<"azure-openai-responses">, apiKey: string, options?: AzureOpenAIResponsesOptions) {
+	const headers = { ...model.headers };
+
+	if (options?.headers) {
+		Object.assign(headers, options.headers);
+	}
+
+	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
+
+	return new AzureOpenAI({
+		apiKey,
+		apiVersion,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: headers,
+		baseURL: baseUrl,
+	});
+}
+
+function buildParams(
+	model: Model<"azure-openai-responses">,
+	context: Context,
+	options: AzureOpenAIResponsesOptions | undefined,
+	deploymentName: string,
+) {
+	const messages = convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS);
+
+	const params: ResponseCreateParamsStreaming = {
+		model: deploymentName,
+		input: messages,
+		stream: true,
+		prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
+		store: false,
+	};
+
+	if (options?.maxTokens) {
+		params.max_output_tokens = options?.maxTokens;
+	}
+
+	if (options?.temperature !== undefined) {
+		params.temperature = options?.temperature;
+	}
+
+	if (context.tools && context.tools.length > 0) {
+		params.tools = convertResponsesTools(context.tools);
+	}
+
+	if (model.reasoning) {
+		if (options?.reasoningEffort || options?.reasoningSummary) {
+			const effort = options?.reasoningEffort
+				? (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort)
+				: "medium";
+			params.reasoning = {
+				effort: effort as NonNullable<typeof params.reasoning>["effort"],
+				summary: options?.reasoningSummary || "auto",
+			};
+			params.include = ["reasoning.encrypted_content"];
+		} else if (model.thinkingLevelMap?.off !== null) {
+			params.reasoning = {
+				effort: (model.thinkingLevelMap?.off ?? "none") as NonNullable<typeof params.reasoning>["effort"],
+			};
+		}
+	}
+
+	return params;
+}

packages/ai/src/api/bedrock-converse-stream.lazy.ts

@@ -0,0 +1,30 @@
+import type { ProviderStreams } from "../types.ts";
+import { lazyApi } from "./lazy.ts";
+
+/**
+ * Loads the bedrock implementation through a variable specifier so bundlers
+ * (browser smoke, Bun compile) cannot follow the import into the Node-only
+ * AWS SDK. The `.ts`/`.js` rewrite keeps the trick working from both source
+ * and built output.
+ */
+const importNodeOnlyApi = (specifier: string): Promise<unknown> => {
+	const runtimeSpecifier = import.meta.url.endsWith(".js") ? specifier.replace(/\.ts$/, ".js") : specifier;
+	return import(runtimeSpecifier);
+};
+
+let bedrockModuleOverride: ProviderStreams | undefined;
+
+/**
+ * Overrides the dynamically imported bedrock implementation. Used by the Bun
+ * binary build, where the variable-specifier import cannot be bundled; the
+ * build registers a statically imported module instead.
+ */
+export function setBedrockProviderModule(module: ProviderStreams): void {
+	bedrockModuleOverride = module;
+}
+
+export const bedrockConverseStreamApi = (): ProviderStreams =>
+	lazyApi(
+		async () =>
+			bedrockModuleOverride ?? ((await importNodeOnlyApi("./bedrock-converse-stream.ts")) as ProviderStreams),
+	);

packages/ai/src/api/google-generative-ai.lazy.ts

@@ -0,0 +1,4 @@
+import type { ProviderStreams } from "../types.ts";
+import { lazyApi } from "./lazy.ts";
+
+export const googleGenerativeAIApi = (): ProviderStreams => lazyApi(() => import("./google-generative-ai.ts"));

packages/ai/src/api/google-generative-ai.ts

@@ -0,0 +1,504 @@
+import {
+	type GenerateContentConfig,
+	type GenerateContentParameters,
+	GoogleGenAI,
+	type ThinkingConfig,
+} from "@google/genai";
+import { calculateCost, clampThinkingLevel } from "../models.ts";
+import type {
+	Api,
+	AssistantMessage,
+	Context,
+	Model,
+	SimpleStreamOptions,
+	StreamFunction,
+	StreamOptions,
+	TextContent,
+	ThinkingBudgets,
+	ThinkingContent,
+	ThinkingLevel,
+	ToolCall,
+} from "../types.ts";
+import { AssistantMessageEventStream } from "../utils/event-stream.ts";
+import { sanitizeSurrogates } from "../utils/sanitize-unicode.ts";
+import type { GoogleThinkingLevel } from "./google-shared.ts";
+import {
+	convertMessages,
+	convertTools,
+	isThinkingPart,
+	mapStopReason,
+	mapToolChoice,
+	retainThoughtSignature,
+} from "./google-shared.ts";
+import { buildBaseOptions } from "./simple-options.ts";
+
+export interface GoogleOptions extends StreamOptions {
+	toolChoice?: "auto" | "none" | "any";
+	thinking?: {
+		enabled: boolean;
+		budgetTokens?: number; // -1 for dynamic, 0 to disable
+		level?: GoogleThinkingLevel;
+	};
+}
+
+// Counter for generating unique tool call IDs
+let toolCallCounter = 0;
+
+export const stream: StreamFunction<"google-generative-ai", GoogleOptions> = (
+	model: Model<"google-generative-ai">,
+	context: Context,
+	options?: GoogleOptions,
+): AssistantMessageEventStream => {
+	const stream = new AssistantMessageEventStream();
+
+	(async () => {
+		const output: AssistantMessage = {
+			role: "assistant",
+			content: [],
+			api: "google-generative-ai" as 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(),
+		};
+
+		try {
+			const apiKey = options?.apiKey;
+			if (!apiKey) {
+				throw new Error(`No API key for provider: ${model.provider}`);
+			}
+			const client = createClient(model, apiKey, options?.headers);
+			let params = buildParams(model, context, options);
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== undefined) {
+				params = nextParams as GenerateContentParameters;
+			}
+			const googleStream = await client.models.generateContentStream(params);
+
+			stream.push({ type: "start", partial: output });
+			let currentBlock: TextContent | ThinkingContent | null = null;
+			const blocks = output.content;
+			const blockIndex = () => blocks.length - 1;
+			for await (const chunk of googleStream) {
+				// @google/genai documents GenerateContentResponse.responseId as an output-only field
+				// used to identify each response. Keep the first non-empty one from the stream.
+				output.responseId ||= chunk.responseId;
+				const candidate = chunk.candidates?.[0];
+				if (candidate?.content?.parts) {
+					for (const part of candidate.content.parts) {
+						if (part.text !== undefined) {
+							const isThinking = isThinkingPart(part);
+							if (
+								!currentBlock ||
+								(isThinking && currentBlock.type !== "thinking") ||
+								(!isThinking && currentBlock.type !== "text")
+							) {
+								if (currentBlock) {
+									if (currentBlock.type === "text") {
+										stream.push({
+											type: "text_end",
+											contentIndex: blocks.length - 1,
+											content: currentBlock.text,
+											partial: output,
+										});
+									} else {
+										stream.push({
+											type: "thinking_end",
+											contentIndex: blockIndex(),
+											content: currentBlock.thinking,
+											partial: output,
+										});
+									}
+								}
+								if (isThinking) {
+									currentBlock = { type: "thinking", thinking: "", thinkingSignature: undefined };
+									output.content.push(currentBlock);
+									stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
+								} else {
+									currentBlock = { type: "text", text: "" };
+									output.content.push(currentBlock);
+									stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+								}
+							}
+							if (currentBlock.type === "thinking") {
+								currentBlock.thinking += part.text;
+								currentBlock.thinkingSignature = retainThoughtSignature(
+									currentBlock.thinkingSignature,
+									part.thoughtSignature,
+								);
+								stream.push({
+									type: "thinking_delta",
+									contentIndex: blockIndex(),
+									delta: part.text,
+									partial: output,
+								});
+							} else {
+								currentBlock.text += part.text;
+								currentBlock.textSignature = retainThoughtSignature(
+									currentBlock.textSignature,
+									part.thoughtSignature,
+								);
+								stream.push({
+									type: "text_delta",
+									contentIndex: blockIndex(),
+									delta: part.text,
+									partial: output,
+								});
+							}
+						}
+
+						if (part.functionCall) {
+							if (currentBlock) {
+								if (currentBlock.type === "text") {
+									stream.push({
+										type: "text_end",
+										contentIndex: blockIndex(),
+										content: currentBlock.text,
+										partial: output,
+									});
+								} else {
+									stream.push({
+										type: "thinking_end",
+										contentIndex: blockIndex(),
+										content: currentBlock.thinking,
+										partial: output,
+									});
+								}
+								currentBlock = null;
+							}
+
+							// Generate unique ID if not provided or if it's a duplicate
+							const providedId = part.functionCall.id;
+							const needsNewId =
+								!providedId || output.content.some((b) => b.type === "toolCall" && b.id === providedId);
+							const toolCallId = needsNewId
+								? `${part.functionCall.name}_${Date.now()}_${++toolCallCounter}`
+								: providedId;
+
+							const toolCall: ToolCall = {
+								type: "toolCall",
+								id: toolCallId,
+								name: part.functionCall.name || "",
+								arguments: (part.functionCall.args as Record<string, any>) ?? {},
+								...(part.thoughtSignature && { thoughtSignature: part.thoughtSignature }),
+							};
+
+							output.content.push(toolCall);
+							stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+							stream.push({
+								type: "toolcall_delta",
+								contentIndex: blockIndex(),
+								delta: JSON.stringify(toolCall.arguments),
+								partial: output,
+							});
+							stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
+						}
+					}
+				}
+
+				if (candidate?.finishReason) {
+					output.stopReason = mapStopReason(candidate.finishReason);
+					if (output.content.some((b) => b.type === "toolCall")) {
+						output.stopReason = "toolUse";
+					}
+				}
+
+				if (chunk.usageMetadata) {
+					output.usage = {
+						input:
+							(chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
+						output:
+							(chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
+						cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
+						cacheWrite: 0,
+						totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+						cost: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							total: 0,
+						},
+					};
+					calculateCost(model, output.usage);
+				}
+			}
+
+			if (currentBlock) {
+				if (currentBlock.type === "text") {
+					stream.push({
+						type: "text_end",
+						contentIndex: blockIndex(),
+						content: currentBlock.text,
+						partial: output,
+					});
+				} else {
+					stream.push({
+						type: "thinking_end",
+						contentIndex: blockIndex(),
+						content: currentBlock.thinking,
+						partial: output,
+					});
+				}
+			}
+
+			if (options?.signal?.aborted) {
+				throw new Error("Request was aborted");
+			}
+
+			if (output.stopReason === "aborted" || output.stopReason === "error") {
+				throw new Error("An unknown error occurred");
+			}
+
+			stream.push({ type: "done", reason: output.stopReason, message: output });
+			stream.end();
+		} catch (error) {
+			// Remove internal index property used during streaming
+			for (const block of output.content) {
+				if ("index" in block) {
+					delete (block as { index?: number }).index;
+				}
+			}
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			stream.push({ type: "error", reason: output.stopReason, error: output });
+			stream.end();
+		}
+	})();
+
+	return stream;
+};
+
+export const streamSimple: StreamFunction<"google-generative-ai", SimpleStreamOptions> = (
+	model: Model<"google-generative-ai">,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream => {
+	const apiKey = options?.apiKey;
+	if (!apiKey) {
+		throw new Error(`No API key for provider: ${model.provider}`);
+	}
+
+	const base = buildBaseOptions(model, options, apiKey);
+	if (!options?.reasoning) {
+		return stream(model, context, { ...base, thinking: { enabled: false } } satisfies GoogleOptions);
+	}
+
+	const clampedReasoning = clampThinkingLevel(model, options.reasoning);
+	const effort = (clampedReasoning === "off" ? "high" : clampedReasoning) as ClampedThinkingLevel;
+	const googleModel = model as Model<"google-generative-ai">;
+
+	if (isGemini3ProModel(googleModel) || isGemini3FlashModel(googleModel) || isGemma4Model(googleModel)) {
+		return stream(model, context, {
+			...base,
+			thinking: {
+				enabled: true,
+				level: getThinkingLevel(effort, googleModel),
+			},
+		} satisfies GoogleOptions);
+	}
+
+	return stream(model, context, {
+		...base,
+		thinking: {
+			enabled: true,
+			budgetTokens: getGoogleBudget(googleModel, effort, options.thinkingBudgets),
+		},
+	} satisfies GoogleOptions);
+};
+
+function createClient(
+	model: Model<"google-generative-ai">,
+	apiKey?: string,
+	optionsHeaders?: Record<string, string>,
+): GoogleGenAI {
+	const httpOptions: { baseUrl?: string; apiVersion?: string; headers?: Record<string, string> } = {};
+	if (model.baseUrl) {
+		httpOptions.baseUrl = model.baseUrl;
+		httpOptions.apiVersion = ""; // baseUrl already includes version path, don't append
+	}
+	if (model.headers || optionsHeaders) {
+		httpOptions.headers = { ...model.headers, ...optionsHeaders };
+	}
+
+	return new GoogleGenAI({
+		apiKey,
+		httpOptions: Object.keys(httpOptions).length > 0 ? httpOptions : undefined,
+	});
+}
+
+function buildParams(
+	model: Model<"google-generative-ai">,
+	context: Context,
+	options: GoogleOptions = {},
+): GenerateContentParameters {
+	const contents = convertMessages(model, context);
+
+	const generationConfig: GenerateContentConfig = {};
+	if (options.temperature !== undefined) {
+		generationConfig.temperature = options.temperature;
+	}
+	if (options.maxTokens !== undefined) {
+		generationConfig.maxOutputTokens = options.maxTokens;
+	}
+
+	const config: GenerateContentConfig = {
+		...(Object.keys(generationConfig).length > 0 && generationConfig),
+		...(context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) }),
+		...(context.tools && context.tools.length > 0 && { tools: convertTools(context.tools) }),
+	};
+
+	if (context.tools && context.tools.length > 0 && options.toolChoice) {
+		config.toolConfig = {
+			functionCallingConfig: {
+				mode: mapToolChoice(options.toolChoice),
+			},
+		};
+	} else {
+		config.toolConfig = undefined;
+	}
+
+	if (options.thinking?.enabled && model.reasoning) {
+		const thinkingConfig: ThinkingConfig = { includeThoughts: true };
+		if (options.thinking.level !== undefined) {
+			// Cast to any since our GoogleThinkingLevel mirrors Google's ThinkingLevel enum values
+			thinkingConfig.thinkingLevel = options.thinking.level as any;
+		} else if (options.thinking.budgetTokens !== undefined) {
+			thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
+		}
+		config.thinkingConfig = thinkingConfig;
+	} else if (model.reasoning && options.thinking && !options.thinking.enabled) {
+		config.thinkingConfig = getDisabledThinkingConfig(model);
+	}
+
+	if (options.signal) {
+		if (options.signal.aborted) {
+			throw new Error("Request aborted");
+		}
+		config.abortSignal = options.signal;
+	}
+
+	const params: GenerateContentParameters = {
+		model: model.id,
+		contents,
+		config,
+	};
+
+	return params;
+}
+
+type ClampedThinkingLevel = Exclude<ThinkingLevel, "xhigh">;
+
+function isGemma4Model(model: Model<"google-generative-ai">): boolean {
+	return /gemma-?4/.test(model.id.toLowerCase());
+}
+
+function isGemini3ProModel(model: Model<"google-generative-ai">): boolean {
+	return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
+}
+
+function isGemini3FlashModel(model: Model<"google-generative-ai">): boolean {
+	const id = model.id.toLowerCase();
+	return /gemini-3(?:\.\d+)?-flash/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest";
+}
+
+function getDisabledThinkingConfig(model: Model<"google-generative-ai">): ThinkingConfig {
+	// Google docs: Gemini 3.1 Pro cannot disable thinking, and Gemini 3 Flash / Flash-Lite
+	// do not support full thinking-off either. For Gemini 3 models, use the lowest supported
+	// thinkingLevel without includeThoughts so hidden thinking remains invisible to pi.
+	if (isGemini3ProModel(model)) {
+		return { thinkingLevel: "LOW" as any };
+	}
+	if (isGemini3FlashModel(model)) {
+		return { thinkingLevel: "MINIMAL" as any };
+	}
+	if (isGemma4Model(model)) {
+		return { thinkingLevel: "MINIMAL" as any };
+	}
+
+	// Gemini 2.x supports disabling via thinkingBudget = 0.
+	return { thinkingBudget: 0 };
+}
+
+function getThinkingLevel(effort: ClampedThinkingLevel, model: Model<"google-generative-ai">): GoogleThinkingLevel {
+	if (isGemini3ProModel(model)) {
+		switch (effort) {
+			case "minimal":
+			case "low":
+				return "LOW";
+			case "medium":
+			case "high":
+				return "HIGH";
+		}
+	}
+	if (isGemma4Model(model)) {
+		switch (effort) {
+			case "minimal":
+			case "low":
+				return "MINIMAL";
+			case "medium":
+			case "high":
+				return "HIGH";
+		}
+	}
+	switch (effort) {
+		case "minimal":
+			return "MINIMAL";
+		case "low":
+			return "LOW";
+		case "medium":
+			return "MEDIUM";
+		case "high":
+			return "HIGH";
+	}
+}
+
+function getGoogleBudget(
+	model: Model<"google-generative-ai">,
+	effort: ClampedThinkingLevel,
+	customBudgets?: ThinkingBudgets,
+): number {
+	if (customBudgets?.[effort] !== undefined) {
+		return customBudgets[effort]!;
+	}
+
+	if (model.id.includes("2.5-pro")) {
+		const budgets: Record<ClampedThinkingLevel, number> = {
+			minimal: 128,
+			low: 2048,
+			medium: 8192,
+			high: 32768,
+		};
+		return budgets[effort];
+	}
+
+	if (model.id.includes("2.5-flash-lite")) {
+		const budgets: Record<ClampedThinkingLevel, number> = {
+			minimal: 512,
+			low: 2048,
+			medium: 8192,
+			high: 24576,
+		};
+		return budgets[effort];
+	}
+
+	if (model.id.includes("2.5-flash")) {
+		const budgets: Record<ClampedThinkingLevel, number> = {
+			minimal: 128,
+			low: 2048,
+			medium: 8192,
+			high: 24576,
+		};
+		return budgets[effort];
+	}
+
+	return -1;
+}

packages/ai/src/api/google-vertex.lazy.ts

@@ -0,0 +1,4 @@
+import type { ProviderStreams } from "../types.ts";
+import { lazyApi } from "./lazy.ts";
+
+export const googleVertexApi = (): ProviderStreams => lazyApi(() => import("./google-vertex.ts"));

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

@@ -0,0 +1,582 @@
+import {
+	type GenerateContentConfig,
+	type GenerateContentParameters,
+	GoogleGenAI,
+	type HttpOptions,
+	ResourceScope,
+	type ThinkingConfig,
+	ThinkingLevel,
+} from "@google/genai";
+import { calculateCost, clampThinkingLevel } from "../models.ts";
+import type {
+	Api,
+	AssistantMessage,
+	Context,
+	Model,
+	ThinkingLevel as PiThinkingLevel,
+	ProviderEnv,
+	SimpleStreamOptions,
+	StreamFunction,
+	StreamOptions,
+	TextContent,
+	ThinkingBudgets,
+	ThinkingContent,
+	ToolCall,
+} from "../types.ts";
+import { AssistantMessageEventStream } from "../utils/event-stream.ts";
+import { getProviderEnvValue } from "../utils/provider-env.ts";
+import { sanitizeSurrogates } from "../utils/sanitize-unicode.ts";
+import type { GoogleThinkingLevel } from "./google-shared.ts";
+import {
+	convertMessages,
+	convertTools,
+	isThinkingPart,
+	mapStopReason,
+	mapToolChoice,
+	retainThoughtSignature,
+} from "./google-shared.ts";
+import { buildBaseOptions } from "./simple-options.ts";
+
+export interface GoogleVertexOptions extends StreamOptions {
+	toolChoice?: "auto" | "none" | "any";
+	thinking?: {
+		enabled: boolean;
+		budgetTokens?: number; // -1 for dynamic, 0 to disable
+		level?: GoogleThinkingLevel;
+	};
+	project?: string;
+	location?: string;
+}
+
+const API_VERSION = "v1";
+const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+
+const THINKING_LEVEL_MAP: Record<GoogleThinkingLevel, ThinkingLevel> = {
+	THINKING_LEVEL_UNSPECIFIED: ThinkingLevel.THINKING_LEVEL_UNSPECIFIED,
+	MINIMAL: ThinkingLevel.MINIMAL,
+	LOW: ThinkingLevel.LOW,
+	MEDIUM: ThinkingLevel.MEDIUM,
+	HIGH: ThinkingLevel.HIGH,
+};
+
+// Counter for generating unique tool call IDs
+let toolCallCounter = 0;
+
+export const stream: StreamFunction<"google-vertex", GoogleVertexOptions> = (
+	model: Model<"google-vertex">,
+	context: Context,
+	options?: GoogleVertexOptions,
+): AssistantMessageEventStream => {
+	const stream = new AssistantMessageEventStream();
+
+	(async () => {
+		const output: AssistantMessage = {
+			role: "assistant",
+			content: [],
+			api: "google-vertex" as 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(),
+		};
+
+		try {
+			const apiKey = resolveApiKey(options);
+			// Create the client using either a Vertex API key, if provided, or ADC with project and location
+			const client = apiKey
+				? createClientWithApiKey(model, apiKey, options?.headers)
+				: createClient(model, resolveProject(options), resolveLocation(options), options?.headers, options?.env);
+			let params = buildParams(model, context, options);
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== undefined) {
+				params = nextParams as GenerateContentParameters;
+			}
+			const googleStream = await client.models.generateContentStream(params);
+
+			stream.push({ type: "start", partial: output });
+			let currentBlock: TextContent | ThinkingContent | null = null;
+			const blocks = output.content;
+			const blockIndex = () => blocks.length - 1;
+			for await (const chunk of googleStream) {
+				// Vertex uses the same @google/genai GenerateContentResponse type as Gemini.
+				// responseId is documented there as an output-only identifier for each response.
+				output.responseId ||= chunk.responseId;
+				const candidate = chunk.candidates?.[0];
+				if (candidate?.content?.parts) {
+					for (const part of candidate.content.parts) {
+						if (part.text !== undefined) {
+							const isThinking = isThinkingPart(part);
+							if (
+								!currentBlock ||
+								(isThinking && currentBlock.type !== "thinking") ||
+								(!isThinking && currentBlock.type !== "text")
+							) {
+								if (currentBlock) {
+									if (currentBlock.type === "text") {
+										stream.push({
+											type: "text_end",
+											contentIndex: blocks.length - 1,
+											content: currentBlock.text,
+											partial: output,
+										});
+									} else {
+										stream.push({
+											type: "thinking_end",
+											contentIndex: blockIndex(),
+											content: currentBlock.thinking,
+											partial: output,
+										});
+									}
+								}
+								if (isThinking) {
+									currentBlock = { type: "thinking", thinking: "", thinkingSignature: undefined };
+									output.content.push(currentBlock);
+									stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
+								} else {
+									currentBlock = { type: "text", text: "" };
+									output.content.push(currentBlock);
+									stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+								}
+							}
+							if (currentBlock.type === "thinking") {
+								currentBlock.thinking += part.text;
+								currentBlock.thinkingSignature = retainThoughtSignature(
+									currentBlock.thinkingSignature,
+									part.thoughtSignature,
+								);
+								stream.push({
+									type: "thinking_delta",
+									contentIndex: blockIndex(),
+									delta: part.text,
+									partial: output,
+								});
+							} else {
+								currentBlock.text += part.text;
+								currentBlock.textSignature = retainThoughtSignature(
+									currentBlock.textSignature,
+									part.thoughtSignature,
+								);
+								stream.push({
+									type: "text_delta",
+									contentIndex: blockIndex(),
+									delta: part.text,
+									partial: output,
+								});
+							}
+						}
+
+						if (part.functionCall) {
+							if (currentBlock) {
+								if (currentBlock.type === "text") {
+									stream.push({
+										type: "text_end",
+										contentIndex: blockIndex(),
+										content: currentBlock.text,
+										partial: output,
+									});
+								} else {
+									stream.push({
+										type: "thinking_end",
+										contentIndex: blockIndex(),
+										content: currentBlock.thinking,
+										partial: output,
+									});
+								}
+								currentBlock = null;
+							}
+
+							const providedId = part.functionCall.id;
+							const needsNewId =
+								!providedId || output.content.some((b) => b.type === "toolCall" && b.id === providedId);
+							const toolCallId = needsNewId
+								? `${part.functionCall.name}_${Date.now()}_${++toolCallCounter}`
+								: providedId;
+
+							const toolCall: ToolCall = {
+								type: "toolCall",
+								id: toolCallId,
+								name: part.functionCall.name || "",
+								arguments: (part.functionCall.args as Record<string, any>) ?? {},
+								...(part.thoughtSignature && { thoughtSignature: part.thoughtSignature }),
+							};
+
+							output.content.push(toolCall);
+							stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
+							stream.push({
+								type: "toolcall_delta",
+								contentIndex: blockIndex(),
+								delta: JSON.stringify(toolCall.arguments),
+								partial: output,
+							});
+							stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
+						}
+					}
+				}
+
+				if (candidate?.finishReason) {
+					output.stopReason = mapStopReason(candidate.finishReason);
+					if (output.content.some((b) => b.type === "toolCall")) {
+						output.stopReason = "toolUse";
+					}
+				}
+
+				if (chunk.usageMetadata) {
+					output.usage = {
+						input:
+							(chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
+						output:
+							(chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
+						cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
+						cacheWrite: 0,
+						totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+						cost: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							total: 0,
+						},
+					};
+					calculateCost(model, output.usage);
+				}
+			}
+
+			if (currentBlock) {
+				if (currentBlock.type === "text") {
+					stream.push({
+						type: "text_end",
+						contentIndex: blockIndex(),
+						content: currentBlock.text,
+						partial: output,
+					});
+				} else {
+					stream.push({
+						type: "thinking_end",
+						contentIndex: blockIndex(),
+						content: currentBlock.thinking,
+						partial: output,
+					});
+				}
+			}
+
+			if (options?.signal?.aborted) {
+				throw new Error("Request was aborted");
+			}
+
+			if (output.stopReason === "aborted" || output.stopReason === "error") {
+				throw new Error("An unknown error occurred");
+			}
+
+			stream.push({ type: "done", reason: output.stopReason, message: output });
+			stream.end();
+		} catch (error) {
+			// Remove internal index property used during streaming
+			for (const block of output.content) {
+				if ("index" in block) {
+					delete (block as { index?: number }).index;
+				}
+			}
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			stream.push({ type: "error", reason: output.stopReason, error: output });
+			stream.end();
+		}
+	})();
+
+	return stream;
+};
+
+export const streamSimple: StreamFunction<"google-vertex", SimpleStreamOptions> = (
+	model: Model<"google-vertex">,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream => {
+	const base = buildBaseOptions(model, options, undefined);
+	if (!options?.reasoning) {
+		return stream(model, context, {
+			...base,
+			thinking: { enabled: false },
+		} satisfies GoogleVertexOptions);
+	}
+
+	const clampedReasoning = clampThinkingLevel(model, options.reasoning);
+	const effort = (clampedReasoning === "off" ? "high" : clampedReasoning) as ClampedThinkingLevel;
+	const geminiModel = model as unknown as Model<"google-generative-ai">;
+
+	if (isGemini3ProModel(geminiModel) || isGemini3FlashModel(geminiModel)) {
+		return stream(model, context, {
+			...base,
+			thinking: {
+				enabled: true,
+				level: getGemini3ThinkingLevel(effort, geminiModel),
+			},
+		} satisfies GoogleVertexOptions);
+	}
+
+	return stream(model, context, {
+		...base,
+		thinking: {
+			enabled: true,
+			budgetTokens: getGoogleBudget(geminiModel, effort, options.thinkingBudgets),
+		},
+	} satisfies GoogleVertexOptions);
+};
+
+function createClient(
+	model: Model<"google-vertex">,
+	project: string,
+	location: string,
+	optionsHeaders?: Record<string, string>,
+	env?: ProviderEnv,
+): GoogleGenAI {
+	const googleAuthOptions = buildGoogleAuthOptions(env);
+	return new GoogleGenAI({
+		vertexai: true,
+		project,
+		location,
+		apiVersion: API_VERSION,
+		...(googleAuthOptions ? { googleAuthOptions } : {}),
+		httpOptions: buildHttpOptions(model, optionsHeaders),
+	});
+}
+
+function createClientWithApiKey(
+	model: Model<"google-vertex">,
+	apiKey: string,
+	optionsHeaders?: Record<string, string>,
+): GoogleGenAI {
+	return new GoogleGenAI({
+		vertexai: true,
+		apiKey,
+		apiVersion: API_VERSION,
+		httpOptions: buildHttpOptions(model, optionsHeaders),
+	});
+}
+
+function buildHttpOptions(
+	model: Model<"google-vertex">,
+	optionsHeaders?: Record<string, string>,
+): HttpOptions | undefined {
+	const httpOptions: HttpOptions = {};
+	const baseUrl = resolveCustomBaseUrl(model.baseUrl);
+	if (baseUrl) {
+		httpOptions.baseUrl = baseUrl;
+		httpOptions.baseUrlResourceScope = ResourceScope.COLLECTION;
+		if (baseUrlIncludesApiVersion(baseUrl)) {
+			httpOptions.apiVersion = "";
+		}
+	}
+
+	if (model.headers || optionsHeaders) {
+		httpOptions.headers = { ...model.headers, ...optionsHeaders };
+	}
+
+	return Object.keys(httpOptions).length > 0 ? httpOptions : undefined;
+}
+
+function resolveCustomBaseUrl(baseUrl: string): string | undefined {
+	const trimmed = baseUrl.trim();
+	if (!trimmed || trimmed.includes("{location}")) {
+		return undefined;
+	}
+	return trimmed;
+}
+
+function baseUrlIncludesApiVersion(baseUrl: string): boolean {
+	try {
+		const url = new URL(baseUrl);
+		return url.pathname.split("/").some((part) => /^v\d+(?:beta\d*)?$/.test(part));
+	} catch {
+		return /(?:^|\/)v\d+(?:beta\d*)?(?:\/|$)/.test(baseUrl);
+	}
+}
+
+function buildGoogleAuthOptions(env?: ProviderEnv): { keyFilename: string } | undefined {
+	const keyFilename = getProviderEnvValue("GOOGLE_APPLICATION_CREDENTIALS", env);
+	return keyFilename ? { keyFilename } : undefined;
+}
+
+function resolveApiKey(options?: GoogleVertexOptions): string | undefined {
+	const apiKey = options?.apiKey?.trim();
+	if (!apiKey || apiKey === GCP_VERTEX_CREDENTIALS_MARKER || isPlaceholderApiKey(apiKey)) {
+		return undefined;
+	}
+	return apiKey;
+}
+
+function isPlaceholderApiKey(apiKey: string): boolean {
+	return /^<[^>]+>$/.test(apiKey);
+}
+
+function resolveProject(options?: GoogleVertexOptions): string {
+	const project =
+		options?.project ||
+		getProviderEnvValue("GOOGLE_CLOUD_PROJECT", options?.env) ||
+		getProviderEnvValue("GCLOUD_PROJECT", options?.env);
+	if (!project) {
+		throw new Error(
+			"Vertex AI requires a project ID. Set GOOGLE_CLOUD_PROJECT/GCLOUD_PROJECT or pass project in options.",
+		);
+	}
+	return project;
+}
+
+function resolveLocation(options?: GoogleVertexOptions): string {
+	const location = options?.location || getProviderEnvValue("GOOGLE_CLOUD_LOCATION", options?.env);
+	if (!location) {
+		throw new Error("Vertex AI requires a location. Set GOOGLE_CLOUD_LOCATION or pass location in options.");
+	}
+	return location;
+}
+
+function buildParams(
+	model: Model<"google-vertex">,
+	context: Context,
+	options: GoogleVertexOptions = {},
+): GenerateContentParameters {
+	const contents = convertMessages(model, context);
+
+	const generationConfig: GenerateContentConfig = {};
+	if (options.temperature !== undefined) {
+		generationConfig.temperature = options.temperature;
+	}
+	if (options.maxTokens !== undefined) {
+		generationConfig.maxOutputTokens = options.maxTokens;
+	}
+
+	const config: GenerateContentConfig = {
+		...(Object.keys(generationConfig).length > 0 && generationConfig),
+		...(context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) }),
+		...(context.tools && context.tools.length > 0 && { tools: convertTools(context.tools) }),
+	};
+
+	if (context.tools && context.tools.length > 0 && options.toolChoice) {
+		config.toolConfig = {
+			functionCallingConfig: {
+				mode: mapToolChoice(options.toolChoice),
+			},
+		};
+	} else {
+		config.toolConfig = undefined;
+	}
+
+	if (options.thinking?.enabled && model.reasoning) {
+		const thinkingConfig: ThinkingConfig = { includeThoughts: true };
+		if (options.thinking.level !== undefined) {
+			thinkingConfig.thinkingLevel = THINKING_LEVEL_MAP[options.thinking.level];
+		} else if (options.thinking.budgetTokens !== undefined) {
+			thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
+		}
+		config.thinkingConfig = thinkingConfig;
+	} else if (model.reasoning && options.thinking && !options.thinking.enabled) {
+		config.thinkingConfig = getDisabledThinkingConfig(model);
+	}
+
+	if (options.signal) {
+		if (options.signal.aborted) {
+			throw new Error("Request aborted");
+		}
+		config.abortSignal = options.signal;
+	}
+
+	const params: GenerateContentParameters = {
+		model: model.id,
+		contents,
+		config,
+	};
+
+	return params;
+}
+
+type ClampedThinkingLevel = Exclude<PiThinkingLevel, "xhigh">;
+
+function isGemini3ProModel(model: Model<"google-generative-ai">): boolean {
+	return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
+}
+
+function isGemini3FlashModel(model: Model<"google-generative-ai">): boolean {
+	const id = model.id.toLowerCase();
+	return /gemini-3(?:\.\d+)?-flash/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest";
+}
+
+function getDisabledThinkingConfig(model: Model<"google-vertex">): ThinkingConfig {
+	// Google docs: Gemini 3.1 Pro cannot disable thinking, and Gemini 3 Flash / Flash-Lite
+	// do not support full thinking-off either. For Gemini 3 models, use the lowest supported
+	// thinkingLevel without includeThoughts so hidden thinking remains invisible to pi.
+	const geminiModel = model as unknown as Model<"google-generative-ai">;
+	if (isGemini3ProModel(geminiModel)) {
+		return { thinkingLevel: ThinkingLevel.LOW };
+	}
+	if (isGemini3FlashModel(geminiModel)) {
+		return { thinkingLevel: ThinkingLevel.MINIMAL };
+	}
+
+	// Gemini 2.x supports disabling via thinkingBudget = 0.
+	return { thinkingBudget: 0 };
+}
+
+function getGemini3ThinkingLevel(
+	effort: ClampedThinkingLevel,
+	model: Model<"google-generative-ai">,
+): GoogleThinkingLevel {
+	if (isGemini3ProModel(model)) {
+		switch (effort) {
+			case "minimal":
+			case "low":
+				return "LOW";
+			case "medium":
+			case "high":
+				return "HIGH";
+		}
+	}
+	switch (effort) {
+		case "minimal":
+			return "MINIMAL";
+		case "low":
+			return "LOW";
+		case "medium":
+			return "MEDIUM";
+		case "high":
+			return "HIGH";
+	}
+}
+
+function getGoogleBudget(
+	model: Model<"google-generative-ai">,
+	effort: ClampedThinkingLevel,
+	customBudgets?: ThinkingBudgets,
+): number {
+	if (customBudgets?.[effort] !== undefined) {
+		return customBudgets[effort]!;
+	}
+
+	if (model.id.includes("2.5-pro")) {
+		const budgets: Record<ClampedThinkingLevel, number> = {
+			minimal: 128,
+			low: 2048,
+			medium: 8192,
+			high: 32768,
+		};
+		return budgets[effort];
+	}
+
+	if (model.id.includes("2.5-flash")) {
+		const budgets: Record<ClampedThinkingLevel, number> = {
+			minimal: 128,
+			low: 2048,
+			medium: 8192,
+			high: 24576,
+		};
+		return budgets[effort];
+	}
+
+	return -1;
+}

packages/ai/src/api/lazy.ts

@@ -0,0 +1,70 @@
+import type { Api, AssistantMessage, AssistantMessageEvent, Model, ProviderStreams } from "../types.ts";
+import { AssistantMessageEventStream } from "../utils/event-stream.ts";
+
+function createSetupErrorMessage(model: Model<Api>, error: unknown): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [],
+		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: "error",
+		errorMessage: error instanceof Error ? error.message : String(error),
+		timestamp: Date.now(),
+	};
+}
+
+function forwardStream(target: AssistantMessageEventStream, source: AsyncIterable<AssistantMessageEvent>): void {
+	(async () => {
+		for await (const event of source) {
+			target.push(event);
+		}
+		target.end();
+	})();
+}
+
+/**
+ * Returns a stream synchronously while running async setup (auth resolution,
+ * lazy module loading) behind it. Setup failures terminate the stream with an
+ * error event.
+ */
+export function lazyStream(
+	model: Model<Api>,
+	setup: () => Promise<AsyncIterable<AssistantMessageEvent>>,
+): AssistantMessageEventStream {
+	const outer = new AssistantMessageEventStream();
+
+	setup()
+		.then((inner) => {
+			forwardStream(outer, inner);
+		})
+		.catch((error) => {
+			const message = createSetupErrorMessage(model, error);
+			outer.push({ type: "error", reason: "error", error: message });
+			outer.end(message);
+		});
+
+	return outer;
+}
+
+/**
+ * Wraps a dynamically imported API implementation module as `ProviderStreams`.
+ * The module loads on first stream call; the host's import cache deduplicates
+ * loads. Load failures terminate the returned stream with an error event.
+ */
+export function lazyApi(load: () => Promise<ProviderStreams>): ProviderStreams {
+	return {
+		stream: (model, context, options) =>
+			lazyStream(model, async () => (await load()).stream(model, context, options)),
+		streamSimple: (model, context, options) =>
+			lazyStream(model, async () => (await load()).streamSimple(model, context, options)),
+	};
+}

packages/ai/src/api/mistral-conversations.lazy.ts

@@ -0,0 +1,4 @@
+import type { ProviderStreams } from "../types.ts";
+import { lazyApi } from "./lazy.ts";
+
+export const mistralConversationsApi = (): ProviderStreams => lazyApi(() => import("./mistral-conversations.ts"));

packages/ai/src/api/mistral-conversations.ts

@@ -0,0 +1,664 @@
+import { Mistral } from "@mistralai/mistralai";
+import type {
+	ChatCompletionStreamRequest,
+	ChatCompletionStreamRequestMessage,
+	CompletionEvent,
+	ContentChunk,
+	FunctionTool,
+} from "@mistralai/mistralai/models/components";
+import { calculateCost, clampThinkingLevel } from "../models.ts";
+import type {
+	AssistantMessage,
+	Context,
+	Message,
+	Model,
+	SimpleStreamOptions,
+	StopReason,
+	StreamFunction,
+	StreamOptions,
+	TextContent,
+	ThinkingContent,
+	Tool,
+	ToolCall,
+} from "../types.ts";
+import { AssistantMessageEventStream } from "../utils/event-stream.ts";
+import { shortHash } from "../utils/hash.ts";
+import { parseStreamingJson } from "../utils/json-parse.ts";
+import { sanitizeSurrogates } from "../utils/sanitize-unicode.ts";
+import { buildBaseOptions } from "./simple-options.ts";
+import { transformMessages } from "./transform-messages.ts";
+
+const MISTRAL_TOOL_CALL_ID_LENGTH = 9;
+const MAX_MISTRAL_ERROR_BODY_CHARS = 4000;
+
+/**
+ * Provider-specific options for the Mistral API.
+ */
+type MistralReasoningEffort = "none" | "high";
+
+export interface MistralOptions extends StreamOptions {
+	toolChoice?: "auto" | "none" | "any" | "required" | { type: "function"; function: { name: string } };
+	promptMode?: "reasoning";
+	reasoningEffort?: MistralReasoningEffort;
+}
+
+/**
+ * Stream responses from Mistral using `chat.stream`.
+ */
+export const stream: StreamFunction<"mistral-conversations", MistralOptions> = (
+	model: Model<"mistral-conversations">,
+	context: Context,
+	options?: MistralOptions,
+): AssistantMessageEventStream => {
+	const stream = new AssistantMessageEventStream();
+
+	(async () => {
+		const output = createOutput(model);
+
+		try {
+			const apiKey = options?.apiKey;
+			if (!apiKey) {
+				throw new Error(`No API key for provider: ${model.provider}`);
+			}
+
+			// Intentionally per-request: avoids shared SDK mutable state across concurrent consumers.
+			const mistral = new Mistral({
+				apiKey,
+				serverURL: model.baseUrl,
+			});
+
+			const normalizeMistralToolCallId = createMistralToolCallIdNormalizer();
+			const transformedMessages = transformMessages(context.messages, model, (id) => normalizeMistralToolCallId(id));
+
+			let payload = buildChatPayload(model, context, transformedMessages, options);
+			const nextPayload = await options?.onPayload?.(payload, model);
+			if (nextPayload !== undefined) {
+				payload = nextPayload as ChatCompletionStreamRequest;
+			}
+			const mistralStream = await mistral.chat.stream(payload, buildRequestOptions(model, options));
+			stream.push({ type: "start", partial: output });
+			await consumeChatStream(model, output, stream, mistralStream);
+
+			if (options?.signal?.aborted) {
+				throw new Error("Request was aborted");
+			}
+
+			if (output.stopReason === "aborted" || output.stopReason === "error") {
+				throw new Error("An unknown error occurred");
+			}
+
+			stream.push({ type: "done", reason: output.stopReason, message: output });
+			stream.end();
+		} catch (error) {
+			for (const block of output.content) {
+				// partialArgs is only a streaming scratch buffer; never persist it.
+				delete (block as { partialArgs?: string }).partialArgs;
+			}
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = formatMistralError(error);
+			stream.push({ type: "error", reason: output.stopReason, error: output });
+			stream.end();
+		}
+	})();
+
+	return stream;
+};
+
+/**
+ * Maps provider-agnostic `SimpleStreamOptions` to Mistral options.
+ */
+export const streamSimple: StreamFunction<"mistral-conversations", SimpleStreamOptions> = (
+	model: Model<"mistral-conversations">,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream => {
+	const apiKey = options?.apiKey;
+	if (!apiKey) {
+		throw new Error(`No API key for provider: ${model.provider}`);
+	}
+
+	const base = buildBaseOptions(model, options, apiKey);
+	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
+	const reasoning = clampedReasoning === "off" ? undefined : clampedReasoning;
+	const shouldUseReasoning = model.reasoning && reasoning !== undefined;
+
+	return stream(model, context, {
+		...base,
+		promptMode: shouldUseReasoning && usesPromptModeReasoning(model) ? "reasoning" : undefined,
+		reasoningEffort:
+			shouldUseReasoning && usesReasoningEffort(model) ? mapReasoningEffort(model, reasoning) : undefined,
+	} satisfies MistralOptions);
+};
+
+function createOutput(model: Model<"mistral-conversations">): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [],
+		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(),
+	};
+}
+
+function createMistralToolCallIdNormalizer(): (id: string) => string {
+	const idMap = new Map<string, string>();
+	const reverseMap = new Map<string, string>();
+
+	return (id: string): string => {
+		const existing = idMap.get(id);
+		if (existing) return existing;
+
+		let attempt = 0;
+		while (true) {
+			const candidate = deriveMistralToolCallId(id, attempt);
+			const owner = reverseMap.get(candidate);
+			if (!owner || owner === id) {
+				idMap.set(id, candidate);
+				reverseMap.set(candidate, id);
+				return candidate;
+			}
+			attempt++;
+		}
+	};
+}
+
+function deriveMistralToolCallId(id: string, attempt: number): string {
+	const normalized = id.replace(/[^a-zA-Z0-9]/g, "");
+	if (attempt === 0 && normalized.length === MISTRAL_TOOL_CALL_ID_LENGTH) return normalized;
+	const seedBase = normalized || id;
+	const seed = attempt === 0 ? seedBase : `${seedBase}:${attempt}`;
+	return shortHash(seed)
+		.replace(/[^a-zA-Z0-9]/g, "")
+		.slice(0, MISTRAL_TOOL_CALL_ID_LENGTH);
+}
+
+function formatMistralError(error: unknown): string {
+	if (error instanceof Error) {
+		const sdkError = error as Error & { statusCode?: unknown; body?: unknown };
+		const statusCode = typeof sdkError.statusCode === "number" ? sdkError.statusCode : undefined;
+		const bodyText = typeof sdkError.body === "string" ? sdkError.body.trim() : undefined;
+		if (statusCode !== undefined && bodyText) {
+			return `Mistral API error (${statusCode}): ${truncateErrorText(bodyText, MAX_MISTRAL_ERROR_BODY_CHARS)}`;
+		}
+		if (statusCode !== undefined) return `Mistral API error (${statusCode}): ${error.message}`;
+		return error.message;
+	}
+	return safeJsonStringify(error);
+}
+
+function truncateErrorText(text: string, maxChars: number): string {
+	if (text.length <= maxChars) return text;
+	return `${text.slice(0, maxChars)}... [truncated ${text.length - maxChars} chars]`;
+}
+
+function safeJsonStringify(value: unknown): string {
+	try {
+		const serialized = JSON.stringify(value);
+		return serialized === undefined ? String(value) : serialized;
+	} catch {
+		return String(value);
+	}
+}
+
+function buildRequestOptions(model: Model<"mistral-conversations">, options?: MistralOptions) {
+	const requestOptions: {
+		signal?: AbortSignal;
+		retries: { strategy: "none" };
+		headers?: Record<string, string>;
+	} = {
+		retries: { strategy: "none" },
+	};
+	if (options?.signal) requestOptions.signal = options.signal;
+
+	const headers: Record<string, string> = {};
+	if (model.headers) Object.assign(headers, model.headers);
+	if (options?.headers) Object.assign(headers, options.headers);
+
+	// Mistral infrastructure uses `x-affinity` for KV-cache reuse (prefix caching).
+	// Respect explicit caller-provided header values.
+	if (shouldUsePromptCaching(options) && !headers["x-affinity"]) {
+		headers["x-affinity"] = options.sessionId;
+	}
+
+	if (Object.keys(headers).length > 0) {
+		requestOptions.headers = headers;
+	}
+
+	return requestOptions;
+}
+
+function buildChatPayload(
+	model: Model<"mistral-conversations">,
+	context: Context,
+	messages: Message[],
+	options?: MistralOptions,
+): ChatCompletionStreamRequest {
+	const payload: ChatCompletionStreamRequest = {
+		model: model.id,
+		stream: true,
+		messages: toChatMessages(messages, model.input.includes("image")),
+	};
+
+	if (context.tools?.length) payload.tools = toFunctionTools(context.tools);
+	if (options?.temperature !== undefined) payload.temperature = options.temperature;
+	if (options?.maxTokens !== undefined) payload.maxTokens = options.maxTokens;
+	if (options?.toolChoice) payload.toolChoice = mapToolChoice(options.toolChoice);
+	if (options?.promptMode) payload.promptMode = options.promptMode;
+	if (options?.reasoningEffort) payload.reasoningEffort = options.reasoningEffort;
+	if (shouldUsePromptCaching(options)) payload.promptCacheKey = options.sessionId;
+
+	if (context.systemPrompt) {
+		payload.messages.unshift({
+			role: "system",
+			content: sanitizeSurrogates(context.systemPrompt),
+		});
+	}
+
+	return payload;
+}
+
+function shouldUsePromptCaching(options?: MistralOptions): options is MistralOptions & { sessionId: string } {
+	return options?.cacheRetention !== "none" && !!options?.sessionId;
+}
+
+function getMistralCachedPromptTokens(usage: unknown, promptTokens: number): number {
+	const rawUsage = usage as {
+		promptTokensDetails?: { cachedTokens?: unknown } | null;
+		prompt_tokens_details?: { cached_tokens?: unknown } | null;
+		promptTokenDetails?: { cachedTokens?: unknown } | null;
+		prompt_token_details?: { cached_tokens?: unknown } | null;
+		numCachedTokens?: unknown;
+		num_cached_tokens?: unknown;
+	};
+	const rawCachedTokens =
+		rawUsage.promptTokensDetails?.cachedTokens ??
+		rawUsage.prompt_tokens_details?.cached_tokens ??
+		rawUsage.promptTokenDetails?.cachedTokens ??
+		rawUsage.prompt_token_details?.cached_tokens ??
+		rawUsage.numCachedTokens ??
+		rawUsage.num_cached_tokens ??
+		0;
+	const cachedTokens = typeof rawCachedTokens === "number" && Number.isFinite(rawCachedTokens) ? rawCachedTokens : 0;
+	return Math.min(promptTokens, Math.max(0, cachedTokens));
+}
+
+async function consumeChatStream(
+	model: Model<"mistral-conversations">,
+	output: AssistantMessage,
+	stream: AssistantMessageEventStream,
+	mistralStream: AsyncIterable<CompletionEvent>,
+): Promise<void> {
+	let currentBlock: TextContent | ThinkingContent | null = null;
+	const blocks = output.content;
+	const blockIndex = () => blocks.length - 1;
+	const toolBlocksByKey = new Map<string, number>();
+
+	const finishCurrentBlock = (block?: typeof currentBlock) => {
+		if (!block) return;
+		if (block.type === "text") {
+			stream.push({
+				type: "text_end",
+				contentIndex: blockIndex(),
+				content: block.text,
+				partial: output,
+			});
+			return;
+		}
+		if (block.type === "thinking") {
+			stream.push({
+				type: "thinking_end",
+				contentIndex: blockIndex(),
+				content: block.thinking,
+				partial: output,
+			});
+		}
+	};
+
+	for await (const event of mistralStream) {
+		const chunk = event.data;
+		// Mistral's streamed CompletionChunk carries an id field. Keep the first non-empty one,
+		// mirroring how OpenAI-style streaming exposes a stable response identifier per stream.
+		output.responseId ||= chunk.id;
+
+		if (chunk.usage) {
+			const promptTokens = chunk.usage.promptTokens || 0;
+			const cachedPromptTokens = getMistralCachedPromptTokens(chunk.usage, promptTokens);
+
+			output.usage.input = Math.max(0, promptTokens - cachedPromptTokens);
+			output.usage.output = chunk.usage.completionTokens || 0;
+			output.usage.cacheRead = cachedPromptTokens;
+			output.usage.cacheWrite = 0;
+			output.usage.totalTokens =
+				chunk.usage.totalTokens ||
+				output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+			calculateCost(model, output.usage);
+		}
+
+		const choice = chunk.choices[0];
+		if (!choice) continue;
+
+		if (choice.finishReason) {
+			output.stopReason = mapChatStopReason(choice.finishReason);
+		}
+
+		const delta = choice.delta;
+		if (delta.content !== null && delta.content !== undefined) {
+			const contentItems = typeof delta.content === "string" ? [delta.content] : delta.content;
+			for (const item of contentItems) {
+				if (typeof item === "string") {
+					const textDelta = sanitizeSurrogates(item);
+					if (!currentBlock || currentBlock.type !== "text") {
+						finishCurrentBlock(currentBlock);
+						currentBlock = { type: "text", text: "" };
+						output.content.push(currentBlock);
+						stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+					}
+					currentBlock.text += textDelta;
+					stream.push({
+						type: "text_delta",
+						contentIndex: blockIndex(),
+						delta: textDelta,
+						partial: output,
+					});
+					continue;
+				}
+
+				if (item.type === "thinking") {
+					const deltaText = item.thinking
+						.map((part) => ("text" in part ? part.text : ""))
+						.filter((text) => text.length > 0)
+						.join("");
+					const thinkingDelta = sanitizeSurrogates(deltaText);
+					if (!thinkingDelta) continue;
+					if (!currentBlock || currentBlock.type !== "thinking") {
+						finishCurrentBlock(currentBlock);
+						currentBlock = { type: "thinking", thinking: "" };
+						output.content.push(currentBlock);
+						stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
+					}
+					currentBlock.thinking += thinkingDelta;
+					stream.push({
+						type: "thinking_delta",
+						contentIndex: blockIndex(),
+						delta: thinkingDelta,
+						partial: output,
+					});
+					continue;
+				}
+
+				if (item.type === "text") {
+					const textDelta = sanitizeSurrogates(item.text);
+					if (!currentBlock || currentBlock.type !== "text") {
+						finishCurrentBlock(currentBlock);
+						currentBlock = { type: "text", text: "" };
+						output.content.push(currentBlock);
+						stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
+					}
+					currentBlock.text += textDelta;
+					stream.push({
+						type: "text_delta",
+						contentIndex: blockIndex(),
+						delta: textDelta,
+						partial: output,
+					});
+				}
+			}
+		}
+
+		const toolCalls = delta.toolCalls || [];
+		for (const toolCall of toolCalls) {
+			if (currentBlock) {
+				finishCurrentBlock(currentBlock);
+				currentBlock = null;
+			}
+			const callId =
+				toolCall.id && toolCall.id !== "null"
+					? toolCall.id
+					: deriveMistralToolCallId(`toolcall:${toolCall.index ?? 0}`, 0);
+			const key = `${callId}:${toolCall.index || 0}`;
+			const existingIndex = toolBlocksByKey.get(key);
+			let block: (ToolCall & { partialArgs?: string }) | undefined;
+
+			if (existingIndex !== undefined) {
+				const existing = output.content[existingIndex];
+				if (existing?.type === "toolCall") {
+					block = existing as ToolCall & { partialArgs?: string };
+				}
+			}
+
+			if (!block) {
+				block = {
+					type: "toolCall",
+					id: callId,
+					name: toolCall.function.name,
+					arguments: {},
+					partialArgs: "",
+				};
+				output.content.push(block);
+				toolBlocksByKey.set(key, output.content.length - 1);
+				stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
+			}
+
+			const argsDelta =
+				typeof toolCall.function.arguments === "string"
+					? toolCall.function.arguments
+					: JSON.stringify(toolCall.function.arguments || {});
+			block.partialArgs = (block.partialArgs || "") + argsDelta;
+			block.arguments = parseStreamingJson<Record<string, unknown>>(block.partialArgs);
+			stream.push({
+				type: "toolcall_delta",
+				contentIndex: toolBlocksByKey.get(key)!,
+				delta: argsDelta,
+				partial: output,
+			});
+		}
+	}
+
+	finishCurrentBlock(currentBlock);
+	for (const index of toolBlocksByKey.values()) {
+		const block = output.content[index];
+		if (block.type !== "toolCall") continue;
+		const toolBlock = block as ToolCall & { partialArgs?: string };
+		toolBlock.arguments = parseStreamingJson<Record<string, unknown>>(toolBlock.partialArgs);
+		// Finalize in-place and strip the scratch buffer so replay only
+		// carries parsed arguments.
+		delete toolBlock.partialArgs;
+		stream.push({
+			type: "toolcall_end",
+			contentIndex: index,
+			toolCall: toolBlock,
+			partial: output,
+		});
+	}
+}
+
+function toFunctionTools(tools: Tool[]): Array<FunctionTool & { type: "function" }> {
+	return tools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: stripSymbolKeys(tool.parameters) as Record<string, unknown>,
+			strict: false,
+		},
+	}));
+}
+
+function stripSymbolKeys(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map((item) => stripSymbolKeys(item));
+	}
+
+	if (value && typeof value === "object") {
+		const result: Record<string, unknown> = {};
+		for (const [key, entry] of Object.entries(value)) {
+			result[key] = stripSymbolKeys(entry);
+		}
+		return result;
+	}
+
+	return value;
+}
+
+function toChatMessages(messages: Message[], supportsImages: boolean): ChatCompletionStreamRequestMessage[] {
+	const result: ChatCompletionStreamRequestMessage[] = [];
+
+	for (const msg of messages) {
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") {
+				result.push({ role: "user", content: sanitizeSurrogates(msg.content) });
+				continue;
+			}
+			const hadImages = msg.content.some((item) => item.type === "image");
+			const content: ContentChunk[] = msg.content
+				.filter((item) => item.type === "text" || supportsImages)
+				.map((item) => {
+					if (item.type === "text") return { type: "text", text: sanitizeSurrogates(item.text) };
+					return { type: "image_url", imageUrl: `data:${item.mimeType};base64,${item.data}` };
+				});
+			if (content.length > 0) {
+				result.push({ role: "user", content });
+				continue;
+			}
+			if (hadImages && !supportsImages) {
+				result.push({ role: "user", content: "(image omitted: model does not support images)" });
+			}
+			continue;
+		}
+
+		if (msg.role === "assistant") {
+			const contentParts: ContentChunk[] = [];
+			const toolCalls: Array<{ id: string; type: "function"; function: { name: string; arguments: string } }> = [];
+
+			for (const block of msg.content) {
+				if (block.type === "text") {
+					if (block.text.trim().length > 0) {
+						contentParts.push({ type: "text", text: sanitizeSurrogates(block.text) });
+					}
+					continue;
+				}
+				if (block.type === "thinking") {
+					if (block.thinking.trim().length > 0) {
+						contentParts.push({
+							type: "thinking",
+							thinking: [{ type: "text", text: sanitizeSurrogates(block.thinking) }],
+						});
+					}
+					continue;
+				}
+				toolCalls.push({
+					id: block.id,
+					type: "function",
+					function: { name: block.name, arguments: JSON.stringify(block.arguments || {}) },
+				});
+			}
+
+			const assistantMessage: ChatCompletionStreamRequestMessage = { role: "assistant" };
+			if (contentParts.length > 0) assistantMessage.content = contentParts;
+			if (toolCalls.length > 0) assistantMessage.toolCalls = toolCalls;
+			if (contentParts.length > 0 || toolCalls.length > 0) result.push(assistantMessage);
+			continue;
+		}
+
+		const toolContent: ContentChunk[] = [];
+		const textResult = msg.content
+			.filter((part) => part.type === "text")
+			.map((part) => (part.type === "text" ? sanitizeSurrogates(part.text) : ""))
+			.join("\n");
+		const hasImages = msg.content.some((part) => part.type === "image");
+		const toolText = buildToolResultText(textResult, hasImages, supportsImages, msg.isError);
+		toolContent.push({ type: "text", text: toolText });
+		for (const part of msg.content) {
+			if (!supportsImages) continue;
+			if (part.type !== "image") continue;
+			toolContent.push({
+				type: "image_url",
+				imageUrl: `data:${part.mimeType};base64,${part.data}`,
+			});
+		}
+		result.push({
+			role: "tool",
+			toolCallId: msg.toolCallId,
+			name: msg.toolName,
+			content: toolContent,
+		});
+	}
+
+	return result;
+}
+
+function buildToolResultText(text: string, hasImages: boolean, supportsImages: boolean, isError: boolean): string {
+	const trimmed = text.trim();
+	const errorPrefix = isError ? "[tool error] " : "";
+
+	if (trimmed.length > 0) {
+		const imageSuffix = hasImages && !supportsImages ? "\n[tool image omitted: model does not support images]" : "";
+		return `${errorPrefix}${trimmed}${imageSuffix}`;
+	}
+
+	if (hasImages) {
+		if (supportsImages) {
+			return isError ? "[tool error] (see attached image)" : "(see attached image)";
+		}
+		return isError
+			? "[tool error] (image omitted: model does not support images)"
+			: "(image omitted: model does not support images)";
+	}
+
+	return isError ? "[tool error] (no tool output)" : "(no tool output)";
+}
+
+function usesReasoningEffort(model: Model<"mistral-conversations">): boolean {
+	return model.id === "mistral-small-2603" || model.id === "mistral-small-latest" || model.id === "mistral-medium-3.5";
+}
+
+function usesPromptModeReasoning(model: Model<"mistral-conversations">): boolean {
+	return model.reasoning && !usesReasoningEffort(model);
+}
+
+function mapReasoningEffort(
+	model: Model<"mistral-conversations">,
+	level: Exclude<SimpleStreamOptions["reasoning"], undefined>,
+): MistralReasoningEffort {
+	return (model.thinkingLevelMap?.[level] ?? "high") as MistralReasoningEffort;
+}
+
+function mapToolChoice(
+	choice: MistralOptions["toolChoice"],
+): "auto" | "none" | "any" | "required" | { type: "function"; function: { name: string } } | undefined {
+	if (!choice) return undefined;
+	if (choice === "auto" || choice === "none" || choice === "any" || choice === "required") {
+		return choice as any;
+	}
+	return {
+		type: "function",
+		function: { name: choice.function.name },
+	};
+}
+
+function mapChatStopReason(reason: string | null): StopReason {
+	if (reason === null) return "stop";
+	switch (reason) {
+		case "stop":
+			return "stop";
+		case "length":
+		case "model_length":
+			return "length";
+		case "tool_calls":
+			return "toolUse";
+		case "error":
+			return "error";
+		default:
+			return "stop";
+	}
+}

packages/ai/src/api/openai-codex-responses.lazy.ts

@@ -0,0 +1,4 @@
+import type { ProviderStreams } from "../types.ts";
+import { lazyApi } from "./lazy.ts";
+
+export const openAICodexResponsesApi = (): ProviderStreams => lazyApi(() => import("./openai-codex-responses.ts"));

packages/ai/src/api/openai-codex-responses.ts

@@ -195,7 +195,7 @@ function createSSEHeaderTimeout(): { signal: AbortSignal; clear: () => void; err
 // Main Stream Function
 // ============================================================================
 
-export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses", OpenAICodexResponsesOptions> = (
+export const stream: StreamFunction<"openai-codex-responses", OpenAICodexResponsesOptions> = (
 	model: Model<"openai-codex-responses">,
 	context: Context,
 	options?: OpenAICodexResponsesOptions,
@@ -408,7 +408,7 @@ export const streamOpenAICodexResponses: StreamFunction<"openai-codex-responses"
 	return stream;
 };
 
-export const streamSimpleOpenAICodexResponses: StreamFunction<"openai-codex-responses", SimpleStreamOptions> = (
+export const streamSimple: StreamFunction<"openai-codex-responses", SimpleStreamOptions> = (
 	model: Model<"openai-codex-responses">,
 	context: Context,
 	options?: SimpleStreamOptions,
@@ -422,7 +422,7 @@ export const streamSimpleOpenAICodexResponses: StreamFunction<"openai-codex-resp
 	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
 	const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
 
-	return streamOpenAICodexResponses(model, context, {
+	return stream(model, context, {
 		...base,
 		reasoningEffort,
 	} satisfies OpenAICodexResponsesOptions);

packages/ai/src/api/openai-completions.lazy.ts

@@ -0,0 +1,4 @@
+import type { ProviderStreams } from "../types.ts";
+import { lazyApi } from "./lazy.ts";
+
+export const openAICompletionsApi = (): ProviderStreams => lazyApi(() => import("./openai-completions.ts"));

packages/ai/src/api/openai-completions.ts

@@ -133,7 +133,7 @@ function resolveCacheRetention(cacheRetention?: CacheRetention, env?: ProviderEn
 	return "short";
 }
 
-export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenAICompletionsOptions> = (
+export const stream: StreamFunction<"openai-completions", OpenAICompletionsOptions> = (
 	model: Model<"openai-completions">,
 	context: Context,
 	options?: OpenAICompletionsOptions,
@@ -463,7 +463,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions", OpenA
 	return stream;
 };
 
-export const streamSimpleOpenAICompletions: StreamFunction<"openai-completions", SimpleStreamOptions> = (
+export const streamSimple: StreamFunction<"openai-completions", SimpleStreamOptions> = (
 	model: Model<"openai-completions">,
 	context: Context,
 	options?: SimpleStreamOptions,
@@ -478,7 +478,7 @@ export const streamSimpleOpenAICompletions: StreamFunction<"openai-completions",
 	const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
 	const toolChoice = (options as OpenAICompletionsOptions | undefined)?.toolChoice;
 
-	return streamOpenAICompletions(model, context, {
+	return stream(model, context, {
 		...base,
 		reasoningEffort,
 		toolChoice,

packages/ai/src/api/openai-responses.lazy.ts

@@ -0,0 +1,4 @@
+import type { ProviderStreams } from "../types.ts";
+import { lazyApi } from "./lazy.ts";
+
+export const openAIResponsesApi = (): ProviderStreams => lazyApi(() => import("./openai-responses.ts"));

packages/ai/src/api/openai-responses.ts

@@ -80,7 +80,7 @@ export interface OpenAIResponsesOptions extends StreamOptions {
 /**
  * Generate function for OpenAI Responses API
  */
-export const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIResponsesOptions> = (
+export const stream: StreamFunction<"openai-responses", OpenAIResponsesOptions> = (
 	model: Model<"openai-responses">,
 	context: Context,
 	options?: OpenAIResponsesOptions,
@@ -161,7 +161,7 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIRes
 	return stream;
 };
 
-export const streamSimpleOpenAIResponses: StreamFunction<"openai-responses", SimpleStreamOptions> = (
+export const streamSimple: StreamFunction<"openai-responses", SimpleStreamOptions> = (
 	model: Model<"openai-responses">,
 	context: Context,
 	options?: SimpleStreamOptions,
@@ -175,7 +175,7 @@ export const streamSimpleOpenAIResponses: StreamFunction<"openai-responses", Sim
 	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
 	const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
 
-	return streamOpenAIResponses(model, context, {
+	return stream(model, context, {
 		...base,
 		reasoningEffort,
 	} satisfies OpenAIResponsesOptions);

packages/ai/src/api/openrouter-images.lazy.ts

@@ -0,0 +1,10 @@
+import type { ImagesModel, ProviderImages } from "../types.ts";
+
+export const openrouterImagesApi = (): ProviderImages => ({
+	generateImages: async (model, context, options) =>
+		(await import("./openrouter-images.ts")).generateImages(
+			model as ImagesModel<"openrouter-images">,
+			context,
+			options,
+		),
+});

packages/ai/src/api/openrouter-images.ts

@@ -14,9 +14,9 @@ import type {
 	ImagesModel,
 	ImagesOptions,
 	TextContent,
-} from "../../types.ts";
-import { headersToRecord } from "../../utils/headers.ts";
-import { sanitizeSurrogates } from "../../utils/sanitize-unicode.ts";
+} from "../types.ts";
+import { headersToRecord } from "../utils/headers.ts";
+import { sanitizeSurrogates } from "../utils/sanitize-unicode.ts";
 
 interface OpenRouterGeneratedImage {
 	image_url?: string | { url?: string };
@@ -34,7 +34,7 @@ type OpenRouterImageGenerationResponse = ChatCompletion & {
 	choices: OpenRouterImageGenerationChoice[];
 };
 
-export const generateImagesOpenRouter: ImagesFunction<"openrouter-images", ImagesOptions> = async (
+export const generateImages: ImagesFunction<"openrouter-images", ImagesOptions> = async (
 	model: ImagesModel<"openrouter-images">,
 	context: ImagesContext,
 	options?: ImagesOptions,

packages/ai/src/auth/context.ts

@@ -0,0 +1,45 @@
+import type { AuthContext } from "./types.ts";
+
+interface NodeFsModule {
+	access(path: string): Promise<void>;
+}
+
+interface NodeOsModule {
+	homedir(): string;
+}
+
+// Variable specifier so browser bundlers do not try to resolve node builtins.
+const importNodeModule = (specifier: string): Promise<unknown> => import(specifier);
+
+function getProcessEnv(): Record<string, string | undefined> | undefined {
+	const proc = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process;
+	return proc?.env;
+}
+
+/**
+ * Default auth context: env vars from `process.env` (undefined in browsers),
+ * file existence via node:fs (always false in browsers).
+ */
+export function defaultProviderAuthContext(): AuthContext {
+	return {
+		async env(name: string): Promise<string | undefined> {
+			const value = getProcessEnv()?.[name];
+			return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+		},
+
+		async fileExists(path: string): Promise<boolean> {
+			try {
+				const fs = (await importNodeModule("node:fs/promises")) as NodeFsModule;
+				let resolved = path;
+				if (resolved.startsWith("~")) {
+					const os = (await importNodeModule("node:os")) as NodeOsModule;
+					resolved = os.homedir() + resolved.slice(1);
+				}
+				await fs.access(resolved);
+				return true;
+			} catch {
+				return false;
+			}
+		},
+	};
+}

packages/ai/src/auth/credential-store.ts

@@ -0,0 +1,47 @@
+import type { Credential, CredentialStore } from "./types.ts";
+
+/**
+ * Default in-memory credential store. Apps inject persistent stores.
+ * Keyed by `Provider.id`, one credential per provider; see `CredentialStore`.
+ * Writes are serialized per provider through a promise chain.
+ */
+export class InMemoryCredentialStore implements CredentialStore {
+	private credentials = new Map<string, Credential>();
+	private chains = new Map<string, Promise<unknown>>();
+
+	/** Serialize tasks per provider id. */
+	private enqueue<T>(providerId: string, task: () => Promise<T>): Promise<T> {
+		const previous = this.chains.get(providerId) ?? Promise.resolve();
+		const next = (async () => {
+			await previous.catch(() => {});
+			return task();
+		})();
+		this.chains.set(
+			providerId,
+			next.catch(() => {}),
+		);
+		return next;
+	}
+
+	async read(providerId: string): Promise<Credential | undefined> {
+		return this.credentials.get(providerId);
+	}
+
+	modify(
+		providerId: string,
+		fn: (current: Credential | undefined) => Promise<Credential | undefined>,
+	): Promise<Credential | undefined> {
+		return this.enqueue(providerId, async () => {
+			const current = this.credentials.get(providerId);
+			const next = await fn(current);
+			if (next !== undefined) this.credentials.set(providerId, next);
+			return next ?? current;
+		});
+	}
+
+	delete(providerId: string): Promise<void> {
+		return this.enqueue(providerId, async () => {
+			this.credentials.delete(providerId);
+		});
+	}
+}

packages/ai/src/auth/helpers.ts

@@ -0,0 +1,46 @@
+import type { ApiKeyAuth, OAuthAuth } from "./types.ts";
+
+/**
+ * Standard api-key auth: a stored credential key wins, otherwise the first
+ * set env var resolves. Includes a `login` that prompts for the key.
+ * Providers with non-standard resolution (metadata, ambient files, IAM)
+ * write their own `ApiKeyAuth`.
+ */
+export function envApiKeyAuth(name: string, envVars: readonly string[]): ApiKeyAuth {
+	return {
+		name,
+		login: async (callbacks) => {
+			const key = await callbacks.prompt({ type: "secret", message: `Enter ${name}` });
+			return { type: "api-key", key };
+		},
+		resolve: async ({ ctx, credential }) => {
+			if (credential?.key) return { auth: { apiKey: credential.key }, source: "stored credential" };
+			for (const envVar of envVars) {
+				const value = await ctx.env(envVar);
+				if (value) return { auth: { apiKey: value }, source: envVar };
+			}
+			return undefined;
+		},
+	};
+}
+
+/**
+ * Wraps a dynamically imported `OAuthAuth` so provider definitions can
+ * advertise OAuth without importing the implementation. The flow loads on
+ * first `login`/`refresh`/`toAuth` call; callers keep Node-only flow code out
+ * of bundles by loading through a bundler-opaque dynamic import (variable
+ * specifier, see the bedrock lazy wrapper).
+ */
+export function lazyOAuth(input: { name: string; load: () => Promise<OAuthAuth> }): OAuthAuth {
+	let promise: Promise<OAuthAuth> | undefined;
+	const loaded = () => {
+		promise ??= input.load();
+		return promise;
+	};
+	return {
+		name: input.name,
+		login: async (callbacks) => (await loaded()).login(callbacks),
+		refresh: async (credential) => (await loaded()).refresh(credential),
+		toAuth: async (credential) => (await loaded()).toAuth(credential),
+	};
+}

packages/ai/src/auth/resolve.ts

@@ -0,0 +1,117 @@
+import type { Api, ImagesApi, ImagesModel, Model } from "../types.ts";
+import type {
+	ApiKeyAuth,
+	ApiKeyCredential,
+	AuthContext,
+	AuthResult,
+	Credential,
+	CredentialStore,
+	OAuthAuth,
+	OAuthCredential,
+	ProviderAuth,
+} from "./types.ts";
+
+export type ModelsErrorCode = "model_source" | "model_validation" | "provider" | "stream" | "auth" | "oauth";
+
+export class ModelsError extends Error {
+	readonly code: ModelsErrorCode;
+
+	constructor(code: ModelsErrorCode, message: string, options?: { cause?: unknown }) {
+		super(message, options);
+		this.name = "ModelsError";
+		this.code = code;
+	}
+}
+
+/** Model shape auth resolution receives: chat or image-generation models. */
+export type AuthModel = Model<Api> | ImagesModel<ImagesApi>;
+
+/**
+ * Auth resolution shared by the `Models` and `ImagesModels` collections.
+ * A stored credential owns the provider: ambient/env is consulted only when
+ * nothing is stored. No silent env fallback after a failed refresh or for a
+ * credential type without a matching handler.
+ */
+export async function resolveProviderAuth(
+	provider: { id: string; auth: ProviderAuth },
+	model: AuthModel,
+	credentials: CredentialStore,
+	authContext: AuthContext,
+): Promise<AuthResult | undefined> {
+	const stored = await readCredential(credentials, provider.id);
+	if (stored) {
+		if (stored.type === "oauth" && provider.auth.oauth) {
+			return resolveStoredOAuth(credentials, provider.id, provider.auth.oauth, stored);
+		}
+		if (stored.type === "api-key" && provider.auth.apiKey) {
+			return resolveApiKey(authContext, provider.auth.apiKey, model, stored);
+		}
+		return undefined;
+	}
+
+	// Ambient (env vars, AWS profiles, ADC files).
+	return provider.auth.apiKey ? resolveApiKey(authContext, provider.auth.apiKey, model, undefined) : undefined;
+}
+
+/**
+ * OAuth resolution with double-checked locking (same pattern as today's
+ * AuthStorage): valid tokens cost zero locks; expired tokens lock, re-check
+ * expiry under the lock, refresh once globally, and persist the rotated
+ * credential before release.
+ */
+async function resolveStoredOAuth(
+	credentials: CredentialStore,
+	providerId: string,
+	oauth: OAuthAuth,
+	stored: OAuthCredential,
+): Promise<AuthResult | undefined> {
+	let credential = stored;
+
+	if (Date.now() >= credential.expires) {
+		// Optimistic check said expired; the authoritative check runs under the lock.
+		let post: Credential | undefined;
+		try {
+			post = await credentials.modify(providerId, async (current) => {
+				if (current?.type !== "oauth") return undefined; // logged out meanwhile
+				if (Date.now() < current.expires) return undefined; // another process/request refreshed
+				try {
+					return await oauth.refresh(current);
+				} catch (error) {
+					throw new ModelsError("oauth", `OAuth refresh failed for ${providerId}`, { cause: error });
+				}
+			});
+		} catch (error) {
+			if (error instanceof ModelsError) throw error;
+			throw new ModelsError("auth", `Credential store modify failed for ${providerId}`, { cause: error });
+		}
+		if (post?.type !== "oauth") return undefined; // logged out meanwhile
+		credential = post;
+	}
+
+	try {
+		return { auth: await oauth.toAuth(credential), source: "OAuth" };
+	} catch (error) {
+		throw new ModelsError("oauth", `OAuth auth derivation failed for ${providerId}`, { cause: error });
+	}
+}
+
+async function resolveApiKey(
+	authContext: AuthContext,
+	apiKey: ApiKeyAuth,
+	model: AuthModel,
+	credential: ApiKeyCredential | undefined,
+): Promise<AuthResult | undefined> {
+	try {
+		return await apiKey.resolve({ model, ctx: authContext, credential });
+	} catch (error) {
+		throw new ModelsError("auth", `API key auth failed for provider ${model.provider}`, { cause: error });
+	}
+}
+
+async function readCredential(credentials: CredentialStore, providerId: string): Promise<Credential | undefined> {
+	try {
+		return await credentials.read(providerId);
+	} catch (error) {
+		throw new ModelsError("auth", `Credential store read failed for ${providerId}`, { cause: error });
+	}
+}

packages/ai/src/auth/types.ts

@@ -0,0 +1,180 @@
+import type { Api, ImagesApi, ImagesModel, Model } from "../types.ts";
+import type { OAuthCredentials } from "../utils/oauth/types.ts";
+
+/**
+ * Request auth for a single model request. If a value cannot be expressed as
+ * `apiKey`, `headers`, or `baseUrl`, it is provider config, not auth.
+ */
+export interface ModelAuth {
+	apiKey?: string;
+	headers?: Record<string, string>;
+	baseUrl?: string;
+}
+
+/**
+ * Stored api-key credential. `metadata` holds non-key values such as
+ * Cloudflare account/gateway ids.
+ */
+export interface ApiKeyCredential {
+	type: "api-key";
+	key?: string;
+	metadata?: Record<string, string>;
+}
+
+/** Stored OAuth credential (`access`, `refresh`, `expires` from OAuthCredentials). */
+export interface OAuthCredential extends OAuthCredentials {
+	type: "oauth";
+}
+
+/** One type-tagged credential per provider — the shape of today's auth.json. */
+export type Credential = ApiKeyCredential | OAuthCredential;
+
+/**
+ * App-owned credential storage, keyed by `Provider.id`, one credential per
+ * provider. `modify` is the only write path, so every mutation is a
+ * serialized read-modify-write; `Models.getAuth()` runs OAuth refresh inside
+ * `modify` so concurrent requests cannot double-refresh a rotated token. The
+ * app persists a credential after login via
+ * `modify(provider.id, async () => credential)`. Login/logout orchestration
+ * is app-owned.
+ *
+ * Error semantics: `read` resolves `undefined` for missing entries. Methods
+ * reject only on storage failure; `Models` wraps such rejections in
+ * `ModelsError` with code "auth". Best-effort stores that serve an in-memory
+ * view and record persistence errors internally (like coding-agent's
+ * AuthStorage) are valid implementations.
+ */
+export interface CredentialStore {
+	/**
+	 * Read the stored credential, possibly expired. Display/status use;
+	 * resolved request auth comes from `Models.getAuth()`.
+	 */
+	read(providerId: string): Promise<Credential | undefined>;
+
+	/**
+	 * Serialized write — the only write path. `fn` sees the current credential
+	 * because correct writes (refresh, login-during-refresh) depend on it;
+	 * return the new credential, or undefined to leave the entry unchanged.
+	 * Mutual exclusion per provider id, cross-process too where the backing
+	 * store supports it (e.g. a file lock). Resolves with the post-write
+	 * credential. Rejections from `fn` propagate.
+	 */
+	modify(
+		providerId: string,
+		fn: (current: Credential | undefined) => Promise<Credential | undefined>,
+	): Promise<Credential | undefined>;
+
+	/** Remove a credential (logout). Implementations serialize this against `modify`. */
+	delete(providerId: string): Promise<void>;
+}
+
+/** Environment access for auth resolution. Injectable for tests and browsers. */
+export interface AuthContext {
+	env(name: string): Promise<string | undefined>;
+	/** Check whether a file exists. Supports a leading `~`. Always false in browsers. */
+	fileExists(path: string): Promise<boolean>;
+}
+
+/** Result of resolving auth for a model. */
+export interface AuthResult {
+	auth: ModelAuth;
+	/** Human-readable label for status UI: "ANTHROPIC_API_KEY", "OAuth", "~/.aws/credentials". */
+	source?: string;
+}
+
+/**
+ * Prompt shown to the user during login. `signal` lets the flow cancel a
+ * pending prompt when an out-of-band event resolves the step, e.g. a
+ * `manual_code` prompt raced against a callback server, aborted when the
+ * callback wins.
+ */
+export type AuthPrompt = { signal?: AbortSignal } & (
+	| { type: "text"; message: string; placeholder?: string }
+	| { type: "secret"; message: string; placeholder?: string }
+	| { type: "select"; message: string; options: readonly { id: string; label: string; description?: string }[] }
+	| { type: "manual_code"; message: string; placeholder?: string }
+);
+
+export type AuthEvent =
+	| { type: "auth_url"; url: string; instructions?: string }
+	| {
+			type: "device_code";
+			userCode: string;
+			verificationUri: string;
+			intervalSeconds?: number;
+			expiresInSeconds?: number;
+	  }
+	| { type: "progress"; message: string };
+
+/**
+ * Login interaction callbacks serving both api-key and OAuth flows.
+ *
+ * `prompt()` returns the entered/selected string (`select` returns the option
+ * id). Rejects on cancel/abort. `signal` aborts the whole login flow;
+ * per-prompt cancellation uses `AuthPrompt.signal`.
+ */
+export interface AuthLoginCallbacks {
+	signal?: AbortSignal;
+
+	prompt(prompt: AuthPrompt): Promise<string>;
+	notify(event: AuthEvent): void;
+}
+
+/**
+ * Api-key auth: stored key/metadata plus ambient sources (env vars, AWS
+ * profiles, ADC files). Ambient-only providers omit `login`.
+ */
+export interface ApiKeyAuth {
+	/** Display name, e.g. "Anthropic API key". */
+	name: string;
+
+	/** Interactive setup (prompt for key/metadata). Absent = ambient-only. */
+	login?(callbacks: AuthLoginCallbacks): Promise<ApiKeyCredential>;
+
+	/**
+	 * Resolve auth from the stored credential and/or ambient sources, merging
+	 * per field (`credential.key ?? env("...")`, `metadata.accountId ?? env("...")`).
+	 * undefined = not configured. Receives the chat or image-generation model
+	 * the request is for (both carry `provider` and `baseUrl`).
+	 */
+	resolve(input: {
+		model: Model<Api> | ImagesModel<ImagesApi>;
+		ctx: AuthContext;
+		credential?: ApiKeyCredential;
+	}): Promise<AuthResult | undefined>;
+}
+
+/**
+ * OAuth auth. The `refresh`/`toAuth` split lets `Models` own the locked
+ * refresh pattern: `refresh` produces a credential, `toAuth` derives request
+ * auth from whatever credential ends up stored.
+ */
+export interface OAuthAuth {
+	/** Display name, e.g. "Anthropic (Claude Pro/Max)". */
+	name: string;
+
+	login(callbacks: AuthLoginCallbacks): Promise<OAuthCredential>;
+
+	/**
+	 * Exchange the refresh token. Network call; throws on failure
+	 * (invalid_grant etc.). `Models` runs this under the store lock.
+	 */
+	refresh(credential: OAuthCredential): Promise<OAuthCredential>;
+
+	/**
+	 * Side-effect-free derivation of request auth from a valid credential.
+	 * Covers per-credential baseUrl (GitHub Copilot). Async so lazy wrappers
+	 * can load the implementation on first use.
+	 */
+	toAuth(credential: OAuthCredential): Promise<ModelAuth>;
+}
+
+/**
+ * Provider auth. At least one of `apiKey`/`oauth` must be present: even
+ * ambient-credential providers and keyless local servers provide `apiKey`
+ * auth whose `resolve()` reports whether the provider is configured.
+ */
+export interface ProviderAuth {
+	apiKey?: ApiKeyAuth;
+	oauth?: OAuthAuth;
+}

packages/ai/src/bedrock-provider.ts

@@ -1,6 +1,6 @@
-import { streamBedrock, streamSimpleBedrock } from "./providers/amazon-bedrock.ts";
+import { stream, streamSimple } from "./api/bedrock-converse-stream.ts";
 
 export const bedrockProviderModule = {
-	streamBedrock,
-	streamSimpleBedrock,
+	stream,
+	streamSimple,
 };

packages/ai/src/compat.ts

@@ -0,0 +1,150 @@
+/**
+ * Temporary compatibility entrypoint preserving the old global pi-ai API
+ * surface: api-dispatch `stream()`/`complete()` with env API key injection,
+ * the api-registry, generated catalog reads (`getModel`/`getModels`/
+ * `getProviders`), per-API lazy stream wrappers, and image generation.
+ *
+ * Existing apps switch imports from "@earendil-works/pi-ai" to
+ * "@earendil-works/pi-ai/compat" unchanged; new code uses `createModels()`
+ * and the provider factories. This module is deleted with the coding-agent
+ * ModelManager migration.
+ */
+
+export * from "./api/anthropic-messages.lazy.ts";
+export * from "./api/azure-openai-responses.lazy.ts";
+export * from "./api/bedrock-converse-stream.lazy.ts";
+export * from "./api/google-generative-ai.lazy.ts";
+export * from "./api/google-vertex.lazy.ts";
+export * from "./api/mistral-conversations.lazy.ts";
+export * from "./api/openai-codex-responses.lazy.ts";
+export * from "./api/openai-completions.lazy.ts";
+export * from "./api/openai-responses.lazy.ts";
+export * from "./api-registry.ts";
+export * from "./env-api-keys.ts";
+export * from "./image-models.ts";
+export * from "./images.ts";
+export * from "./images-api-registry.ts";
+export * from "./index.ts";
+export * from "./providers/images/register-builtins.ts";
+
+import { anthropicMessagesApi } from "./api/anthropic-messages.lazy.ts";
+import { azureOpenAIResponsesApi } from "./api/azure-openai-responses.lazy.ts";
+import { bedrockConverseStreamApi } from "./api/bedrock-converse-stream.lazy.ts";
+import { googleGenerativeAIApi } from "./api/google-generative-ai.lazy.ts";
+import { googleVertexApi } from "./api/google-vertex.lazy.ts";
+import { mistralConversationsApi } from "./api/mistral-conversations.lazy.ts";
+import { openAICodexResponsesApi } from "./api/openai-codex-responses.lazy.ts";
+import { openAICompletionsApi } from "./api/openai-completions.lazy.ts";
+import { openAIResponsesApi } from "./api/openai-responses.lazy.ts";
+import { clearApiProviders, getApiProvider, registerApiProvider } from "./api-registry.ts";
+import { getEnvApiKey } from "./env-api-keys.ts";
+import { getBuiltinModel, getBuiltinModels, getBuiltinProviders } from "./providers/all.ts";
+import type {
+	Api,
+	AssistantMessage,
+	AssistantMessageEventStream,
+	Context,
+	Model,
+	ProviderStreamOptions,
+	ProviderStreams,
+	SimpleStreamOptions,
+	StreamOptions,
+} from "./types.ts";
+
+/** @deprecated Static catalog read. Use `getBuiltinModel` from "@earendil-works/pi-ai/providers/all" or `Models.getModel()`. */
+export const getModel = getBuiltinModel;
+
+/** @deprecated Static catalog read. Use `getBuiltinModels` from "@earendil-works/pi-ai/providers/all" or `Models.getModels()`. */
+export const getModels = getBuiltinModels;
+
+/** @deprecated Static catalog read. Use `getBuiltinProviders` from "@earendil-works/pi-ai/providers/all" or `Models.getProviders()`. */
+export const getProviders = getBuiltinProviders;
+
+const BUILTIN_APIS: [Api, ProviderStreams][] = [
+	["anthropic-messages", anthropicMessagesApi()],
+	["openai-completions", openAICompletionsApi()],
+	["openai-responses", openAIResponsesApi()],
+	["openai-codex-responses", openAICodexResponsesApi()],
+	["azure-openai-responses", azureOpenAIResponsesApi()],
+	["google-generative-ai", googleGenerativeAIApi()],
+	["google-vertex", googleVertexApi()],
+	["mistral-conversations", mistralConversationsApi()],
+	["bedrock-converse-stream", bedrockConverseStreamApi()],
+];
+
+/**
+ * Registers the builtin API implementations into the api-registry without
+ * clobbering existing entries: compat may load after a test or extension has
+ * already registered an override for a builtin api id.
+ */
+export function registerBuiltInApiProviders(): void {
+	for (const [api, streams] of BUILTIN_APIS) {
+		if (getApiProvider(api)) continue;
+		registerApiProvider({ api, stream: streams.stream, streamSimple: streams.streamSimple });
+	}
+}
+
+export function resetApiProviders(): void {
+	clearApiProviders();
+	registerBuiltInApiProviders();
+}
+
+registerBuiltInApiProviders();
+
+function hasExplicitApiKey(apiKey: string | undefined): apiKey is string {
+	return typeof apiKey === "string" && apiKey.trim().length > 0;
+}
+
+function withEnvApiKey<TOptions extends StreamOptions>(
+	model: Model<Api>,
+	options: TOptions | undefined,
+): TOptions | undefined {
+	if (hasExplicitApiKey(options?.apiKey)) return options;
+	const apiKey = getEnvApiKey(model.provider);
+	if (!apiKey) return options;
+	return { ...options, apiKey } as TOptions;
+}
+
+function resolveApiProvider(api: Api) {
+	const provider = getApiProvider(api);
+	if (!provider) {
+		throw new Error(`No API provider registered for api: ${api}`);
+	}
+	return provider;
+}
+
+export function stream<TApi extends Api>(
+	model: Model<TApi>,
+	context: Context,
+	options?: ProviderStreamOptions,
+): AssistantMessageEventStream {
+	const provider = resolveApiProvider(model.api);
+	return provider.stream(model, context, withEnvApiKey(model, options) as StreamOptions);
+}
+
+export async function complete<TApi extends Api>(
+	model: Model<TApi>,
+	context: Context,
+	options?: ProviderStreamOptions,
+): Promise<AssistantMessage> {
+	const s = stream(model, context, options);
+	return s.result();
+}
+
+export function streamSimple<TApi extends Api>(
+	model: Model<TApi>,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+	const provider = resolveApiProvider(model.api);
+	return provider.streamSimple(model, context, withEnvApiKey(model, options));
+}
+
+export async function completeSimple<TApi extends Api>(
+	model: Model<TApi>,
+	context: Context,
+	options?: SimpleStreamOptions,
+): Promise<AssistantMessage> {
+	const s = streamSimple(model, context, options);
+	return s.result();
+}

packages/ai/src/images-models.ts

@@ -0,0 +1,262 @@
+import { defaultProviderAuthContext as defaultAuthContext } from "./auth/context.ts";
+import { InMemoryCredentialStore } from "./auth/credential-store.ts";
+import { ModelsError, resolveProviderAuth } from "./auth/resolve.ts";
+import type { AuthContext, AuthResult, CredentialStore, ProviderAuth } from "./auth/types.ts";
+import type { CreateModelsOptions } from "./models.ts";
+import type { AssistantImages, ImagesApi, ImagesContext, ImagesModel, ImagesOptions, ProviderImages } from "./types.ts";
+
+/**
+ * An image-generation provider: the image-side counterpart of `Provider`.
+ * Owns id/name metadata, auth, model listing, and generation behavior.
+ */
+export interface ImagesProvider {
+	readonly id: string;
+	readonly name: string;
+
+	/**
+	 * Required: at least one of `apiKey`/`oauth`. Same semantics as chat
+	 * providers; `ImagesModels.getAuth()` returns undefined when the provider
+	 * is unconfigured.
+	 */
+	readonly auth: ProviderAuth;
+
+	/**
+	 * Current known models, sync. Static providers return their catalog;
+	 * dynamic providers return the list as of the last `refreshModels()`
+	 * (empty before the first). Must not throw; `ImagesModels` treats a
+	 * throwing implementation as having no models.
+	 */
+	getModels(): readonly ImagesModel<ImagesApi>[];
+
+	/**
+	 * Dynamic providers only: fetch and update the model list. May reject
+	 * (network); on rejection the model list stays at its last-known state
+	 * and a later call retries.
+	 */
+	refreshModels?(): Promise<void>;
+
+	generateImages(
+		model: ImagesModel<ImagesApi>,
+		context: ImagesContext,
+		options?: ImagesOptions,
+	): Promise<AssistantImages>;
+}
+
+/**
+ * Runtime collection of image-generation providers plus auth application and
+ * generation convenience: the image-side counterpart of `Models`.
+ */
+export interface ImagesModels {
+	getProviders(): readonly ImagesProvider[];
+	getProvider(id: string): ImagesProvider | undefined;
+
+	/**
+	 * Sync read of last-known models from one provider or all providers.
+	 * Best-effort: a provider whose `getModels()` throws yields no models.
+	 */
+	getModels(provider?: string): readonly ImagesModel<ImagesApi>[];
+
+	/** Sync runtime model lookup against last-known lists. */
+	getModel(provider: string, id: string): ImagesModel<ImagesApi> | undefined;
+
+	/**
+	 * Ask dynamic providers to re-fetch their model lists. With a provider id,
+	 * rejects with `ModelsError` ("model_source") on that provider's fetch
+	 * failure; without one, refreshes all providers concurrently best-effort.
+	 * Static providers (no `refreshModels`) are no-ops.
+	 */
+	refresh(provider?: string): Promise<void>;
+
+	/**
+	 * Resolve request auth for an image model. Same contract as
+	 * `Models.getAuth()`: undefined when unknown/unconfigured, rejects with
+	 * `ModelsError` ("oauth"/"auth") on real failures.
+	 */
+	getAuth(model: ImagesModel<ImagesApi>): Promise<AuthResult | undefined>;
+
+	/**
+	 * Generate images through the owning provider with auth resolved and
+	 * merged (explicit options win per field). Never rejects; failures are
+	 * returned as an `AssistantImages` with `stopReason: "error"`.
+	 */
+	generateImages(
+		model: ImagesModel<ImagesApi>,
+		context: ImagesContext,
+		options?: ImagesOptions,
+	): Promise<AssistantImages>;
+}
+
+export interface MutableImagesModels extends ImagesModels {
+	/** Upsert/replace by provider.id. Provider ids are unique. */
+	setProvider(provider: ImagesProvider): void;
+	deleteProvider(id: string): void;
+	clearProviders(): void;
+}
+
+class ImagesModelsImpl implements MutableImagesModels {
+	private providers = new Map<string, ImagesProvider>();
+	private credentials: CredentialStore;
+	private authContext: AuthContext;
+
+	constructor(options?: CreateModelsOptions) {
+		this.credentials = options?.credentials ?? new InMemoryCredentialStore();
+		this.authContext = options?.authContext ?? defaultAuthContext();
+	}
+
+	setProvider(provider: ImagesProvider): void {
+		this.providers.set(provider.id, provider);
+	}
+
+	deleteProvider(id: string): void {
+		this.providers.delete(id);
+	}
+
+	clearProviders(): void {
+		this.providers.clear();
+	}
+
+	getProviders(): readonly ImagesProvider[] {
+		return Array.from(this.providers.values());
+	}
+
+	getProvider(id: string): ImagesProvider | undefined {
+		return this.providers.get(id);
+	}
+
+	getModels(provider?: string): readonly ImagesModel<ImagesApi>[] {
+		if (provider !== undefined) {
+			const entry = this.providers.get(provider);
+			if (!entry) return [];
+			try {
+				return entry.getModels();
+			} catch {
+				return [];
+			}
+		}
+
+		const models: ImagesModel<ImagesApi>[] = [];
+		for (const entry of this.providers.values()) {
+			try {
+				models.push(...entry.getModels());
+			} catch {
+				// Best-effort: ill-behaved providers yield no models.
+			}
+		}
+		return models;
+	}
+
+	getModel(provider: string, id: string): ImagesModel<ImagesApi> | undefined {
+		return this.getModels(provider).find((model) => model.id === id);
+	}
+
+	async refresh(provider?: string): Promise<void> {
+		if (provider !== undefined) {
+			const entry = this.providers.get(provider);
+			if (!entry?.refreshModels) return;
+			try {
+				await entry.refreshModels();
+			} catch (error) {
+				if (error instanceof ModelsError) throw error;
+				throw new ModelsError("model_source", `Model refresh failed for ${provider}`, { cause: error });
+			}
+			return;
+		}
+
+		// Cannot reject: the async mapper turns even sync throws from ill-behaved
+		// providers into rejections, and allSettled captures all of them.
+		await Promise.allSettled(Array.from(this.providers.values(), async (entry) => entry.refreshModels?.()));
+	}
+
+	async getAuth(model: ImagesModel<ImagesApi>): Promise<AuthResult | undefined> {
+		const provider = this.providers.get(model.provider);
+		if (!provider) return undefined;
+		return resolveProviderAuth(provider, model, this.credentials, this.authContext);
+	}
+
+	async generateImages(
+		model: ImagesModel<ImagesApi>,
+		context: ImagesContext,
+		options?: ImagesOptions,
+	): Promise<AssistantImages> {
+		try {
+			const provider = this.providers.get(model.provider);
+			if (!provider) {
+				throw new ModelsError("provider", `Unknown provider: ${model.provider}`);
+			}
+
+			const resolution = await this.getAuth(model);
+			const auth = resolution?.auth;
+			if (!auth) {
+				return provider.generateImages(model, context, options);
+			}
+
+			const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+
+			// Explicit request options win per-field; headers merge per header.
+			const apiKey = options?.apiKey ?? auth.apiKey;
+			const headers = auth.headers || options?.headers ? { ...auth.headers, ...options?.headers } : undefined;
+
+			return await provider.generateImages(requestModel, context, { ...options, apiKey, headers });
+		} catch (error) {
+			return {
+				api: model.api,
+				provider: model.provider,
+				model: model.id,
+				output: [],
+				stopReason: "error",
+				errorMessage: error instanceof Error ? error.message : String(error),
+				timestamp: Date.now(),
+			};
+		}
+	}
+}
+
+export function createImagesModels(options?: CreateModelsOptions): MutableImagesModels {
+	return new ImagesModelsImpl(options);
+}
+
+export interface CreateImagesProviderOptions {
+	id: string;
+	/** Display name. Default: `id`. */
+	name?: string;
+	/** Required — every provider has auth semantics, even ambient/keyless ones. */
+	auth: ProviderAuth;
+	/** Initial model list (empty for purely dynamic providers). */
+	models: readonly ImagesModel<ImagesApi>[];
+	/**
+	 * Dynamic providers: fetch the current list. Stored on success; concurrent
+	 * calls share one in-flight fetch. May reject: the stored list then stays
+	 * at its last-known state, the rejection propagates to the caller of
+	 * `refreshModels()` (wrapped as ModelsError "model_source" by
+	 * `ImagesModels.refresh(provider)`), and a later call retries.
+	 */
+	refreshModels?: () => Promise<readonly ImagesModel<ImagesApi>[]>;
+	api: ProviderImages;
+}
+
+/** Builds an image-generation provider from parts. */
+export function createImagesProvider(input: CreateImagesProviderOptions): ImagesProvider {
+	let models = input.models;
+	let inflightRefresh: Promise<void> | undefined;
+	const refreshModels = input.refreshModels;
+
+	return {
+		id: input.id,
+		name: input.name ?? input.id,
+		auth: input.auth,
+		getModels: () => models,
+		refreshModels: refreshModels
+			? () => {
+					inflightRefresh ??= (async () => {
+						try {
+							models = await refreshModels();
+						} finally {
+							inflightRefresh = undefined;
+						}
+					})();
+					return inflightRefresh;
+				}
+			: undefined,
+		generateImages: (model, context, options) => input.api.generateImages(model, context, options),
+	};
+}

packages/ai/src/index.ts

@@ -1,30 +1,30 @@
 export type { Static, TSchema } from "typebox";
 export { Type } from "typebox";
 
-export * from "./api-registry.ts";
-export * from "./env-api-keys.ts";
-export * from "./image-models.ts";
-export * from "./images.ts";
-export * from "./images-api-registry.ts";
+// Core only, side-effect free: no generated catalogs, no provider factories,
+// no api-registry, no OAuth implementations, no compat. Provider factories
+// live under "@earendil-works/pi-ai/providers/*", API implementations under
+// "@earendil-works/pi-ai/api/*", the old global API under
+// "@earendil-works/pi-ai/compat".
+export type { AnthropicEffort, AnthropicOptions, AnthropicThinkingDisplay } from "./api/anthropic-messages.ts";
+export type { AzureOpenAIResponsesOptions } from "./api/azure-openai-responses.ts";
+export type { BedrockOptions, BedrockThinkingDisplay } from "./api/bedrock-converse-stream.ts";
+export type { GoogleOptions } from "./api/google-generative-ai.ts";
+export type { GoogleThinkingLevel } from "./api/google-shared.ts";
+export type { GoogleVertexOptions } from "./api/google-vertex.ts";
+export * from "./api/lazy.ts";
+export type { MistralOptions } from "./api/mistral-conversations.ts";
+export type { OpenAICodexResponsesOptions, OpenAICodexWebSocketDebugStats } from "./api/openai-codex-responses.ts";
+export type { OpenAICompletionsOptions } from "./api/openai-completions.ts";
+export type { OpenAIResponsesOptions } from "./api/openai-responses.ts";
+export * from "./auth/context.ts";
+export * from "./auth/credential-store.ts";
+export * from "./auth/helpers.ts";
+export * from "./auth/types.ts";
+export * from "./images-models.ts";
 export * from "./models.ts";
-export type { BedrockOptions, BedrockThinkingDisplay } from "./providers/amazon-bedrock.ts";
-export type { AnthropicEffort, AnthropicOptions, AnthropicThinkingDisplay } from "./providers/anthropic.ts";
-export type { AzureOpenAIResponsesOptions } from "./providers/azure-openai-responses.ts";
 export * from "./providers/faux.ts";
-export type { GoogleOptions } from "./providers/google.ts";
-export type { GoogleThinkingLevel } from "./providers/google-shared.ts";
-export type { GoogleVertexOptions } from "./providers/google-vertex.ts";
-export * from "./providers/images/register-builtins.ts";
-export type { MistralOptions } from "./providers/mistral.ts";
-export type {
-	OpenAICodexResponsesOptions,
-	OpenAICodexWebSocketDebugStats,
-} from "./providers/openai-codex-responses.ts";
-export type { OpenAICompletionsOptions } from "./providers/openai-completions.ts";
-export type { OpenAIResponsesOptions } from "./providers/openai-responses.ts";
-export * from "./providers/register-builtins.ts";
 export * from "./session-resources.ts";
-export * from "./stream.ts";
 export * from "./types.ts";
 export * from "./utils/diagnostics.ts";
 export * from "./utils/event-stream.ts";

packages/ai/src/models.ts

@@ -1,39 +1,374 @@
-import { MODELS } from "./models.generated.ts";
-import type { Api, KnownProvider, Model, ModelThinkingLevel, Usage } from "./types.ts";
+import { lazyStream } from "./api/lazy.ts";
+import { defaultProviderAuthContext as defaultAuthContext } from "./auth/context.ts";
+import { InMemoryCredentialStore } from "./auth/credential-store.ts";
+import { ModelsError, resolveProviderAuth } from "./auth/resolve.ts";
+import type { AuthContext, AuthResult, CredentialStore, ProviderAuth } from "./auth/types.ts";
+import type {
+	Api,
+	ApiStreamOptions,
+	AssistantMessage,
+	AssistantMessageEventStream,
+	Context,
+	Model,
+	ModelThinkingLevel,
+	ProviderStreams,
+	SimpleStreamOptions,
+	StreamOptions,
+	Usage,
+} from "./types.ts";
 
-const modelRegistry: Map<string, Map<string, Model<Api>>> = new Map();
+export { type AuthModel, ModelsError, type ModelsErrorCode } from "./auth/resolve.ts";
 
-// Initialize registry from MODELS on module load
-for (const [provider, models] of Object.entries(MODELS)) {
-	const providerModels = new Map<string, Model<Api>>();
-	for (const [id, model] of Object.entries(models)) {
-		providerModels.set(id, model as Model<Api>);
+/**
+ * A provider is the concrete runtime unit. It owns id/name/base metadata,
+ * auth methods, model listing, and stream behavior.
+ *
+ * `TApi` lets concrete provider factories declare which APIs their models
+ * use (e.g. `openaiProvider(): Provider<"openai-responses" | "openai-completions">`),
+ * giving typed model lists to direct factory users. Inside a `Models`
+ * collection providers are held as `Provider<Api>`.
+ */
+export interface Provider<TApi extends Api = Api> {
+	readonly id: string;
+	readonly name: string;
+
+	readonly baseUrl?: string;
+	readonly headers?: Record<string, string>;
+
+	/**
+	 * Required: at least one of `apiKey`/`oauth`. Every provider has auth
+	 * semantics — even providers with only ambient credentials (env vars, AWS
+	 * profiles, ADC files) and keyless local servers provide `apiKey` auth
+	 * whose `resolve()` reports whether the provider is configured.
+	 * `Models.getAuth()` returns undefined when the provider is unconfigured.
+	 */
+	readonly auth: ProviderAuth;
+
+	/**
+	 * Current known models, sync. Static providers return their catalog;
+	 * dynamic providers return the list as of the last `refreshModels()`
+	 * (empty before the first). Must not throw; `Models` treats a throwing
+	 * implementation as having no models.
+	 */
+	getModels(): readonly Model<TApi>[];
+
+	/**
+	 * Dynamic providers only: fetch and update the model list. Side-effect-free
+	 * discovery (no loading/downloading); provider-specific model lifecycle
+	 * belongs in app commands. Concurrent calls share one in-flight fetch.
+	 * May reject (network); on rejection the model list stays at its last-known
+	 * state and a later call retries.
+	 */
+	refreshModels?(): Promise<void>;
+
+	stream<T extends TApi>(
+		model: Model<T>,
+		context: Context,
+		options?: ApiStreamOptions<T>,
+	): AssistantMessageEventStream;
+
+	streamSimple(model: Model<TApi>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
+}
+
+/**
+ * Runtime collection of providers plus auth application and stream
+ * convenience. Providers own stream behavior; `Models` resolves auth and
+ * delegates each request to the provider that owns the model.
+ */
+export interface Models {
+	getProviders(): readonly Provider[];
+	getProvider(id: string): Provider | undefined;
+
+	/**
+	 * Sync read of last-known models from one provider or all providers.
+	 * Best-effort: a provider whose `getModels()` throws yields no models.
+	 */
+	getModels(provider?: string): readonly Model<Api>[];
+
+	/**
+	 * Sync runtime model lookup against last-known lists. Dynamic model lists
+	 * are typed as `Model<Api>`; narrow with the `hasApi()` type guard.
+	 */
+	getModel(provider: string, id: string): Model<Api> | undefined;
+
+	/**
+	 * Ask dynamic providers to re-fetch their model lists. With a provider id,
+	 * rejects with `ModelsError` ("model_source") on that provider's fetch
+	 * failure; without one, refreshes all providers concurrently best-effort.
+	 * Static providers (no `refreshModels`) are no-ops.
+	 */
+	refresh(provider?: string): Promise<void>;
+
+	/**
+	 * Resolve request auth for a model. Includes a source label for status UI.
+	 * Resolves `undefined` when the provider is unknown or unconfigured.
+	 * Rejects with `ModelsError`: code "oauth" when a token refresh fails (the
+	 * stored credential is preserved for retry; re-login fixes it), code "auth"
+	 * when api-key resolution or the credential store fails. Request paths
+	 * surface rejections as stream errors; status/availability UIs catch them
+	 * and render "needs re-login" instead of treating them as unconfigured.
+	 */
+	getAuth(model: Model<Api>): Promise<AuthResult | undefined>;
+
+	stream<TApi extends Api>(
+		model: Model<TApi>,
+		context: Context,
+		options?: ApiStreamOptions<TApi>,
+	): AssistantMessageEventStream;
+
+	complete<TApi extends Api>(
+		model: Model<TApi>,
+		context: Context,
+		options?: ApiStreamOptions<TApi>,
+	): Promise<AssistantMessage>;
+
+	streamSimple(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
+	completeSimple(model: Model<Api>, context: Context, options?: SimpleStreamOptions): Promise<AssistantMessage>;
+}
+
+export interface MutableModels extends Models {
+	/** Upsert/replace by provider.id. Provider ids are unique. */
+	setProvider(provider: Provider): void;
+	deleteProvider(id: string): void;
+	clearProviders(): void;
+}
+
+export interface CreateModelsOptions {
+	credentials?: CredentialStore;
+	authContext?: AuthContext;
+}
+
+class ModelsImpl implements MutableModels {
+	private providers = new Map<string, Provider>();
+	private credentials: CredentialStore;
+	private authContext: AuthContext;
+
+	constructor(options?: CreateModelsOptions) {
+		this.credentials = options?.credentials ?? new InMemoryCredentialStore();
+		this.authContext = options?.authContext ?? defaultAuthContext();
+	}
+
+	setProvider(provider: Provider): void {
+		this.providers.set(provider.id, provider);
+	}
+
+	deleteProvider(id: string): void {
+		this.providers.delete(id);
+	}
+
+	clearProviders(): void {
+		this.providers.clear();
+	}
+
+	getProviders(): readonly Provider[] {
+		return Array.from(this.providers.values());
+	}
+
+	getProvider(id: string): Provider | undefined {
+		return this.providers.get(id);
+	}
+
+	getModels(provider?: string): readonly Model<Api>[] {
+		if (provider !== undefined) {
+			const entry = this.providers.get(provider);
+			if (!entry) return [];
+			try {
+				return entry.getModels();
+			} catch {
+				return [];
+			}
+		}
+
+		const models: Model<Api>[] = [];
+		for (const entry of this.providers.values()) {
+			try {
+				models.push(...entry.getModels());
+			} catch {
+				// Best-effort: ill-behaved providers yield no models.
+			}
+		}
+		return models;
+	}
+
+	getModel(provider: string, id: string): Model<Api> | undefined {
+		return this.getModels(provider).find((model) => model.id === id);
+	}
+
+	async refresh(provider?: string): Promise<void> {
+		if (provider !== undefined) {
+			const entry = this.providers.get(provider);
+			if (!entry?.refreshModels) return;
+			try {
+				await entry.refreshModels();
+			} catch (error) {
+				if (error instanceof ModelsError) throw error;
+				throw new ModelsError("model_source", `Model refresh failed for ${provider}`, { cause: error });
+			}
+			return;
+		}
+
+		// Cannot reject: the async mapper turns even sync throws from ill-behaved
+		// providers into rejections, and allSettled captures all of them.
+		await Promise.allSettled(Array.from(this.providers.values(), async (entry) => entry.refreshModels?.()));
+	}
+
+	async getAuth(model: Model<Api>): Promise<AuthResult | undefined> {
+		const provider = this.providers.get(model.provider);
+		if (!provider) return undefined;
+		return resolveProviderAuth(provider, model, this.credentials, this.authContext);
+	}
+
+	private requireProvider(model: Model<Api>): Provider {
+		const provider = this.providers.get(model.provider);
+		if (!provider) {
+			throw new ModelsError("provider", `Unknown provider: ${model.provider}`);
+		}
+		return provider;
+	}
+
+	private async applyAuth<TOptions extends StreamOptions>(
+		model: Model<Api>,
+		options: TOptions | undefined,
+	): Promise<{ requestModel: Model<Api>; requestOptions: TOptions | undefined }> {
+		const resolution = await this.getAuth(model);
+		const auth = resolution?.auth;
+		if (!auth) return { requestModel: model, requestOptions: options };
+
+		const requestModel = auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model;
+
+		// Explicit request options win per-field; headers merge per header.
+		const apiKey = options?.apiKey ?? auth.apiKey;
+		const headers = auth.headers || options?.headers ? { ...auth.headers, ...options?.headers } : undefined;
+		const requestOptions = { ...options, apiKey, headers } as TOptions;
+
+		return { requestModel, requestOptions };
+	}
+
+	stream<TApi extends Api>(
+		model: Model<TApi>,
+		context: Context,
+		options?: ApiStreamOptions<TApi>,
+	): AssistantMessageEventStream {
+		return lazyStream(model, async () => {
+			const provider = this.requireProvider(model);
+			const { requestModel, requestOptions } = await this.applyAuth(model, options as StreamOptions | undefined);
+			return provider.stream(requestModel as Model<TApi>, context, requestOptions as ApiStreamOptions<TApi>);
+		});
+	}
+
+	async complete<TApi extends Api>(
+		model: Model<TApi>,
+		context: Context,
+		options?: ApiStreamOptions<TApi>,
+	): Promise<AssistantMessage> {
+		return this.stream(model, context, options).result();
+	}
+
+	streamSimple(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream {
+		return lazyStream(model, async () => {
+			const provider = this.requireProvider(model);
+			const { requestModel, requestOptions } = await this.applyAuth(model, options);
+			return provider.streamSimple(requestModel, context, requestOptions);
+		});
+	}
+
+	async completeSimple(model: Model<Api>, context: Context, options?: SimpleStreamOptions): Promise<AssistantMessage> {
+		return this.streamSimple(model, context, options).result();
 	}
-	modelRegistry.set(provider, providerModels);
 }
 
-type ModelApi<
-	TProvider extends KnownProvider,
-	TModelId extends keyof (typeof MODELS)[TProvider],
-> = (typeof MODELS)[TProvider][TModelId] extends { api: infer TApi } ? (TApi extends Api ? TApi : never) : never;
-
-export function getModel<TProvider extends KnownProvider, TModelId extends keyof (typeof MODELS)[TProvider]>(
-	provider: TProvider,
-	modelId: TModelId,
-): Model<ModelApi<TProvider, TModelId>> {
-	const providerModels = modelRegistry.get(provider);
-	return providerModels?.get(modelId as string) as Model<ModelApi<TProvider, TModelId>>;
+export function createModels(options?: CreateModelsOptions): MutableModels {
+	return new ModelsImpl(options);
 }
 
-export function getProviders(): KnownProvider[] {
-	return Array.from(modelRegistry.keys()) as KnownProvider[];
+export interface CreateProviderOptions<TApi extends Api = Api> {
+	id: string;
+	/** Display name. Default: `id`. */
+	name?: string;
+	baseUrl?: string;
+	headers?: Record<string, string>;
+	/** Required — every provider has auth semantics, even ambient/keyless ones. */
+	auth: ProviderAuth;
+	/** Initial model list (empty for purely dynamic providers). */
+	models: readonly Model<TApi>[];
+	/**
+	 * Dynamic providers: fetch the current list. Stored on success; concurrent
+	 * calls share one in-flight fetch. May reject: the stored list then stays
+	 * at its last-known state, the rejection propagates to the caller of
+	 * `refreshModels()` (wrapped as ModelsError "model_source" by
+	 * `Models.refresh(provider)`), and a later call retries.
+	 */
+	refreshModels?: () => Promise<readonly Model<TApi>[]>;
+	/** Single implementation, or map keyed by `model.api` for mixed-API providers. */
+	api: ProviderStreams | Partial<Record<TApi, ProviderStreams>>;
 }
 
-export function getModels<TProvider extends KnownProvider>(
-	provider: TProvider,
-): Model<ModelApi<TProvider, keyof (typeof MODELS)[TProvider]>>[] {
-	const models = modelRegistry.get(provider);
-	return models ? (Array.from(models.values()) as Model<ModelApi<TProvider, keyof (typeof MODELS)[TProvider]>>[]) : [];
+/**
+ * Builds a provider from parts. Built-in provider factories and models.json
+ * custom providers both go through this. A single `api` streams all models;
+ * an `api` map dispatches on `model.api`, and a model whose api has no entry
+ * produces a stream error.
+ */
+export function createProvider<TApi extends Api = Api>(input: CreateProviderOptions<TApi>): Provider<TApi> {
+	let models = input.models;
+	let inflightRefresh: Promise<void> | undefined;
+	const refreshModels = input.refreshModels;
+	const single =
+		typeof (input.api as ProviderStreams).stream === "function" ? (input.api as ProviderStreams) : undefined;
+	const byApi = single ? undefined : (input.api as Partial<Record<string, ProviderStreams>>);
+
+	const apiFor = (model: Model<Api>): ProviderStreams | undefined => single ?? byApi?.[model.api];
+
+	const dispatch = (
+		model: Model<Api>,
+		run: (streams: ProviderStreams) => AssistantMessageEventStream,
+	): AssistantMessageEventStream => {
+		const streams = apiFor(model);
+		if (!streams) {
+			return lazyStream(model, async () => {
+				throw new ModelsError("stream", `Provider ${input.id} has no API implementation for "${model.api}"`);
+			});
+		}
+		return run(streams);
+	};
+
+	return {
+		id: input.id,
+		name: input.name ?? input.id,
+		baseUrl: input.baseUrl,
+		headers: input.headers,
+		auth: input.auth,
+		getModels: () => models,
+		refreshModels: refreshModels
+			? () => {
+					inflightRefresh ??= (async () => {
+						try {
+							models = await refreshModels();
+						} finally {
+							inflightRefresh = undefined;
+						}
+					})();
+					return inflightRefresh;
+				}
+			: undefined,
+		stream: (model, context, options) => dispatch(model, (streams) => streams.stream(model, context, options)),
+		streamSimple: (model, context, options) =>
+			dispatch(model, (streams) => streams.streamSimple(model, context, options)),
+	};
+}
+
+/**
+ * Runtime-checked narrowing for dynamically looked-up models:
+ *
+ * ```ts
+ * const model = models.getModel("anthropic", "claude-opus-4-7");
+ * if (model && hasApi(model, "anthropic-messages")) {
+ *   // model: Model<"anthropic-messages">, stream options fully typed
+ * }
+ * ```
+ */
+export function hasApi<TApi extends Api>(model: Model<Api>, api: TApi): model is Model<TApi> {
+	return model.api === api;
 }
 
 export function calculateCost<TApi extends Api>(model: Model<TApi>, usage: Usage): Usage["cost"] {

packages/ai/src/providers/all.ts

@@ -0,0 +1,131 @@
+import { createImagesModels, type ImagesProvider, type MutableImagesModels } from "../images-models.ts";
+import { MODELS } from "../models.generated.ts";
+import { type CreateModelsOptions, createModels, type MutableModels, type Provider } from "../models.ts";
+import type { Api, KnownProvider, Model } from "../types.ts";
+import { amazonBedrockProvider } from "./amazon-bedrock.ts";
+import { antLingProvider } from "./ant-ling.ts";
+import { anthropicProvider } from "./anthropic.ts";
+import { azureOpenAIResponsesProvider } from "./azure-openai-responses.ts";
+import { cerebrasProvider } from "./cerebras.ts";
+import { cloudflareAIGatewayProvider } from "./cloudflare-ai-gateway.ts";
+import { cloudflareWorkersAIProvider } from "./cloudflare-workers-ai.ts";
+import { deepseekProvider } from "./deepseek.ts";
+import { fireworksProvider } from "./fireworks.ts";
+import { githubCopilotProvider } from "./github-copilot.ts";
+import { googleProvider } from "./google.ts";
+import { googleVertexProvider } from "./google-vertex.ts";
+import { groqProvider } from "./groq.ts";
+import { huggingfaceProvider } from "./huggingface.ts";
+import { kimiCodingProvider } from "./kimi-coding.ts";
+import { minimaxProvider } from "./minimax.ts";
+import { minimaxCnProvider } from "./minimax-cn.ts";
+import { mistralProvider } from "./mistral.ts";
+import { moonshotaiProvider } from "./moonshotai.ts";
+import { moonshotaiCnProvider } from "./moonshotai-cn.ts";
+import { nvidiaProvider } from "./nvidia.ts";
+import { openaiProvider } from "./openai.ts";
+import { openaiCodexProvider } from "./openai-codex.ts";
+import { opencodeProvider } from "./opencode.ts";
+import { opencodeGoProvider } from "./opencode-go.ts";
+import { openrouterProvider } from "./openrouter.ts";
+import { openrouterImagesProvider } from "./openrouter-images.ts";
+import { togetherProvider } from "./together.ts";
+import { vercelAIGatewayProvider } from "./vercel-ai-gateway.ts";
+import { xaiProvider } from "./xai.ts";
+import { xiaomiProvider } from "./xiaomi.ts";
+import { xiaomiTokenPlanAmsProvider } from "./xiaomi-token-plan-ams.ts";
+import { xiaomiTokenPlanCnProvider } from "./xiaomi-token-plan-cn.ts";
+import { xiaomiTokenPlanSgpProvider } from "./xiaomi-token-plan-sgp.ts";
+import { zaiProvider } from "./zai.ts";
+import { zaiCodingCnProvider } from "./zai-coding-cn.ts";
+
+type BuiltinModelApi<
+	TProvider extends KnownProvider,
+	TModelId extends keyof (typeof MODELS)[TProvider],
+> = (typeof MODELS)[TProvider][TModelId] extends { api: infer TApi } ? (TApi extends Api ? TApi : never) : never;
+
+/** Typed read of the generated built-in catalog. */
+export function getBuiltinModel<TProvider extends KnownProvider, TModelId extends keyof (typeof MODELS)[TProvider]>(
+	provider: TProvider,
+	modelId: TModelId,
+): Model<BuiltinModelApi<TProvider, TModelId>> {
+	const models = MODELS[provider] as Record<string, Model<Api>> | undefined;
+	return models?.[modelId as string] as Model<BuiltinModelApi<TProvider, TModelId>>;
+}
+
+export function getBuiltinProviders(): KnownProvider[] {
+	return Object.keys(MODELS) as KnownProvider[];
+}
+
+export function getBuiltinModels<TProvider extends KnownProvider>(
+	provider: TProvider,
+): Model<BuiltinModelApi<TProvider, keyof (typeof MODELS)[TProvider]>>[] {
+	const models = MODELS[provider] as Record<string, Model<Api>> | undefined;
+	return models
+		? (Object.values(models) as Model<BuiltinModelApi<TProvider, keyof (typeof MODELS)[TProvider]>>[])
+		: [];
+}
+
+/** All built-in providers, freshly constructed. */
+export function builtinProviders(): Provider[] {
+	return [
+		amazonBedrockProvider(),
+		antLingProvider(),
+		anthropicProvider(),
+		azureOpenAIResponsesProvider(),
+		cerebrasProvider(),
+		cloudflareAIGatewayProvider(),
+		cloudflareWorkersAIProvider(),
+		deepseekProvider(),
+		fireworksProvider(),
+		githubCopilotProvider(),
+		googleProvider(),
+		googleVertexProvider(),
+		groqProvider(),
+		huggingfaceProvider(),
+		kimiCodingProvider(),
+		minimaxProvider(),
+		minimaxCnProvider(),
+		mistralProvider(),
+		moonshotaiProvider(),
+		moonshotaiCnProvider(),
+		nvidiaProvider(),
+		openaiProvider(),
+		openaiCodexProvider(),
+		opencodeProvider(),
+		opencodeGoProvider(),
+		openrouterProvider(),
+		togetherProvider(),
+		vercelAIGatewayProvider(),
+		xaiProvider(),
+		xiaomiProvider(),
+		xiaomiTokenPlanAmsProvider(),
+		xiaomiTokenPlanCnProvider(),
+		xiaomiTokenPlanSgpProvider(),
+		zaiProvider(),
+		zaiCodingCnProvider(),
+	];
+}
+
+/** A `Models` collection with every built-in provider registered. */
+export function builtinModels(options?: CreateModelsOptions): MutableModels {
+	const models = createModels(options);
+	for (const provider of builtinProviders()) {
+		models.setProvider(provider);
+	}
+	return models;
+}
+
+/** All built-in image-generation providers, freshly constructed. */
+export function builtinImagesProviders(): ImagesProvider[] {
+	return [openrouterImagesProvider()];
+}
+
+/** An `ImagesModels` collection with every built-in image-generation provider registered. */
+export function builtinImagesModels(options?: CreateModelsOptions): MutableImagesModels {
+	const models = createImagesModels(options);
+	for (const provider of builtinImagesProviders()) {
+		models.setProvider(provider);
+	}
+	return models;
+}

packages/ai/src/providers/ant-ling.models.ts

@@ -0,0 +1,62 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const ANT_LING_MODELS = {
+	"Ling-2.6-1T": {
+		id: "Ling-2.6-1T",
+		name: "Ling 2.6 1T",
+		api: "openai-completions",
+		provider: "ant-ling",
+		baseUrl: "https://api.ant-ling.com/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.06,
+			output: 0.25,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"Ling-2.6-flash": {
+		id: "Ling-2.6-flash",
+		name: "Ling 2.6 Flash",
+		api: "openai-completions",
+		provider: "ant-ling",
+		baseUrl: "https://api.ant-ling.com/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.01,
+			output: 0.02,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"Ring-2.6-1T": {
+		id: "Ring-2.6-1T",
+		name: "Ring 2.6 1T",
+		api: "openai-completions",
+		provider: "ant-ling",
+		baseUrl: "https://api.ant-ling.com/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsLongCacheRetention":false,"thinkingFormat":"ant-ling"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":null,"medium":null,"high":"high","xhigh":"xhigh"},
+		input: ["text"],
+		cost: {
+			input: 0.06,
+			output: 0.25,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+} as const;

packages/ai/src/providers/ant-ling.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 { ANT_LING_MODELS } from "./ant-ling.models.ts";
+
+export function antLingProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "ant-ling",
+		name: "Ant Ling",
+		baseUrl: "https://api.ant-ling.com/v1",
+		auth: { apiKey: envApiKeyAuth("Ant Ling API key", ["ANT_LING_API_KEY"]) },
+		models: Object.values(ANT_LING_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

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

@@ -0,0 +1,441 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const ANTHROPIC_MODELS = {
+	"claude-3-5-haiku-20241022": {
+		id: "claude-3-5-haiku-20241022",
+		name: "Claude Haiku 3.5",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.8,
+			output: 4,
+			cacheRead: 0.08,
+			cacheWrite: 1,
+		},
+		contextWindow: 200000,
+		maxTokens: 8192,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-5-haiku-latest": {
+		id: "claude-3-5-haiku-latest",
+		name: "Claude Haiku 3.5 (latest)",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.8,
+			output: 4,
+			cacheRead: 0.08,
+			cacheWrite: 1,
+		},
+		contextWindow: 200000,
+		maxTokens: 8192,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-5-sonnet-20240620": {
+		id: "claude-3-5-sonnet-20240620",
+		name: "Claude Sonnet 3.5",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 8192,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-5-sonnet-20241022": {
+		id: "claude-3-5-sonnet-20241022",
+		name: "Claude Sonnet 3.5 v2",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 8192,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-7-sonnet-20250219": {
+		id: "claude-3-7-sonnet-20250219",
+		name: "Claude Sonnet 3.7",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-haiku-20240307": {
+		id: "claude-3-haiku-20240307",
+		name: "Claude Haiku 3",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 1.25,
+			cacheRead: 0.03,
+			cacheWrite: 0.3,
+		},
+		contextWindow: 200000,
+		maxTokens: 4096,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-opus-20240229": {
+		id: "claude-3-opus-20240229",
+		name: "Claude Opus 3",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 75,
+			cacheRead: 1.5,
+			cacheWrite: 18.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 4096,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-sonnet-20240229": {
+		id: "claude-3-sonnet-20240229",
+		name: "Claude Sonnet 3",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 0.3,
+		},
+		contextWindow: 200000,
+		maxTokens: 4096,
+	} satisfies Model<"anthropic-messages">,
+	"claude-fable-5": {
+		id: "claude-fable-5",
+		name: "Claude Fable 5",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 10,
+			output: 50,
+			cacheRead: 1,
+			cacheWrite: 12.5,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-haiku-4-5": {
+		id: "claude-haiku-4-5",
+		name: "Claude Haiku 4.5 (latest)",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1,
+			output: 5,
+			cacheRead: 0.1,
+			cacheWrite: 1.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-haiku-4-5-20251001": {
+		id: "claude-haiku-4-5-20251001",
+		name: "Claude Haiku 4.5",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1,
+			output: 5,
+			cacheRead: 0.1,
+			cacheWrite: 1.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-0": {
+		id: "claude-opus-4-0",
+		name: "Claude Opus 4 (latest)",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 75,
+			cacheRead: 1.5,
+			cacheWrite: 18.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-1": {
+		id: "claude-opus-4-1",
+		name: "Claude Opus 4.1 (latest)",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 75,
+			cacheRead: 1.5,
+			cacheWrite: 18.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-1-20250805": {
+		id: "claude-opus-4-1-20250805",
+		name: "Claude Opus 4.1",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 75,
+			cacheRead: 1.5,
+			cacheWrite: 18.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-20250514": {
+		id: "claude-opus-4-20250514",
+		name: "Claude Opus 4",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 75,
+			cacheRead: 1.5,
+			cacheWrite: 18.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-5": {
+		id: "claude-opus-4-5",
+		name: "Claude Opus 4.5 (latest)",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-5-20251101": {
+		id: "claude-opus-4-5-20251101",
+		name: "Claude Opus 4.5",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-6": {
+		id: "claude-opus-4-6",
+		name: "Claude Opus 4.6",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"max"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-7": {
+		id: "claude-opus-4-7",
+		name: "Claude Opus 4.7",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		compat: {"forceAdaptiveThinking":true,"supportsTemperature":false},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-8": {
+		id: "claude-opus-4-8",
+		name: "Claude Opus 4.8",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		compat: {"forceAdaptiveThinking":true,"supportsTemperature":false},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4-0": {
+		id: "claude-sonnet-4-0",
+		name: "Claude Sonnet 4 (latest)",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4-20250514": {
+		id: "claude-sonnet-4-20250514",
+		name: "Claude Sonnet 4",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4-5": {
+		id: "claude-sonnet-4-5",
+		name: "Claude Sonnet 4.5 (latest)",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4-5-20250929": {
+		id: "claude-sonnet-4-5-20250929",
+		name: "Claude Sonnet 4.5",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4-6": {
+		id: "claude-sonnet-4-6",
+		name: "Claude Sonnet 4.6",
+		api: "anthropic-messages",
+		provider: "anthropic",
+		baseUrl: "https://api.anthropic.com",
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 1000000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+} as const;

packages/ai/src/providers/azure-openai-responses.models.ts

@@ -0,0 +1,745 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const AZURE_OPENAI_RESPONSES_MODELS = {
+	"gpt-4": {
+		id: "gpt-4",
+		name: "GPT-4",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 30,
+			output: 60,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 8192,
+		maxTokens: 8192,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-4-turbo": {
+		id: "gpt-4-turbo",
+		name: "GPT-4 Turbo",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 10,
+			output: 30,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 4096,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-4.1": {
+		id: "gpt-4.1",
+		name: "GPT-4.1",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 1047576,
+		maxTokens: 32768,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-4.1-mini": {
+		id: "gpt-4.1-mini",
+		name: "GPT-4.1 mini",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.4,
+			output: 1.6,
+			cacheRead: 0.1,
+			cacheWrite: 0,
+		},
+		contextWindow: 1047576,
+		maxTokens: 32768,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-4.1-nano": {
+		id: "gpt-4.1-nano",
+		name: "GPT-4.1 nano",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.1,
+			output: 0.4,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 1047576,
+		maxTokens: 32768,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-4o": {
+		id: "gpt-4o",
+		name: "GPT-4o",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 10,
+			cacheRead: 1.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-4o-2024-05-13": {
+		id: "gpt-4o-2024-05-13",
+		name: "GPT-4o (2024-05-13)",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 15,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 4096,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-4o-2024-08-06": {
+		id: "gpt-4o-2024-08-06",
+		name: "GPT-4o (2024-08-06)",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 10,
+			cacheRead: 1.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-4o-2024-11-20": {
+		id: "gpt-4o-2024-11-20",
+		name: "GPT-4o (2024-11-20)",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 10,
+			cacheRead: 1.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-4o-mini": {
+		id: "gpt-4o-mini",
+		name: "GPT-4o mini",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.15,
+			output: 0.6,
+			cacheRead: 0.075,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5": {
+		id: "gpt-5",
+		name: "GPT-5",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5-chat-latest": {
+		id: "gpt-5-chat-latest",
+		name: "GPT-5 Chat Latest",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5-codex": {
+		id: "gpt-5-codex",
+		name: "GPT-5-Codex",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5-mini": {
+		id: "gpt-5-mini",
+		name: "GPT-5 Mini",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 2,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5-nano": {
+		id: "gpt-5-nano",
+		name: "GPT-5 Nano",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.05,
+			output: 0.4,
+			cacheRead: 0.005,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5-pro": {
+		id: "gpt-5-pro",
+		name: "GPT-5 Pro",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 120,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.1": {
+		id: "gpt-5.1",
+		name: "GPT-5.1",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.1-chat-latest": {
+		id: "gpt-5.1-chat-latest",
+		name: "GPT-5.1 Chat",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.1-codex": {
+		id: "gpt-5.1-codex",
+		name: "GPT-5.1 Codex",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.1-codex-max": {
+		id: "gpt-5.1-codex-max",
+		name: "GPT-5.1 Codex Max",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.1-codex-mini": {
+		id: "gpt-5.1-codex-mini",
+		name: "GPT-5.1 Codex mini",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 2,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.2": {
+		id: "gpt-5.2",
+		name: "GPT-5.2",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.2-chat-latest": {
+		id: "gpt-5.2-chat-latest",
+		name: "GPT-5.2 Chat",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.2-codex": {
+		id: "gpt-5.2-codex",
+		name: "GPT-5.2 Codex",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.2-pro": {
+		id: "gpt-5.2-pro",
+		name: "GPT-5.2 Pro",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 21,
+			output: 168,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.3-chat-latest": {
+		id: "gpt-5.3-chat-latest",
+		name: "GPT-5.3 Chat (latest)",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: false,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.3-codex": {
+		id: "gpt-5.3-codex",
+		name: "GPT-5.3 Codex",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.3-codex-spark": {
+		id: "gpt-5.3-codex-spark",
+		name: "GPT-5.3 Codex Spark",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 32000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.4": {
+		id: "gpt-5.4",
+		name: "GPT-5.4",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 15,
+			cacheRead: 0.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.4-mini": {
+		id: "gpt-5.4-mini",
+		name: "GPT-5.4 mini",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.75,
+			output: 4.5,
+			cacheRead: 0.075,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.4-nano": {
+		id: "gpt-5.4-nano",
+		name: "GPT-5.4 nano",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.2,
+			output: 1.25,
+			cacheRead: 0.02,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.4-pro": {
+		id: "gpt-5.4-pro",
+		name: "GPT-5.4 Pro",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 30,
+			output: 180,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.5": {
+		id: "gpt-5.5",
+		name: "GPT-5.5",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 30,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"gpt-5.5-pro": {
+		id: "gpt-5.5-pro",
+		name: "GPT-5.5 Pro",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh","minimal":null,"low":null},
+		input: ["text", "image"],
+		cost: {
+			input: 30,
+			output: 180,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"azure-openai-responses">,
+	"o1": {
+		id: "o1",
+		name: "o1",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 60,
+			cacheRead: 7.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"azure-openai-responses">,
+	"o1-pro": {
+		id: "o1-pro",
+		name: "o1-pro",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 150,
+			output: 600,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"azure-openai-responses">,
+	"o3": {
+		id: "o3",
+		name: "o3",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"azure-openai-responses">,
+	"o3-deep-research": {
+		id: "o3-deep-research",
+		name: "o3-deep-research",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 10,
+			output: 40,
+			cacheRead: 2.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"azure-openai-responses">,
+	"o3-mini": {
+		id: "o3-mini",
+		name: "o3-mini",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.1,
+			output: 4.4,
+			cacheRead: 0.55,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"azure-openai-responses">,
+	"o3-pro": {
+		id: "o3-pro",
+		name: "o3-pro",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 20,
+			output: 80,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"azure-openai-responses">,
+	"o4-mini": {
+		id: "o4-mini",
+		name: "o4-mini",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.1,
+			output: 4.4,
+			cacheRead: 0.275,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"azure-openai-responses">,
+	"o4-mini-deep-research": {
+		id: "o4-mini-deep-research",
+		name: "o4-mini-deep-research",
+		api: "azure-openai-responses",
+		provider: "azure-openai-responses",
+		baseUrl: "",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"azure-openai-responses">,
+} as const;

packages/ai/src/providers/azure-openai-responses.ts

@@ -1,299 +1,14 @@
-import { AzureOpenAI } from "openai";
-import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
-import { clampThinkingLevel } from "../models.ts";
-import type {
-	Api,
-	AssistantMessage,
-	Context,
-	Model,
-	SimpleStreamOptions,
-	StreamFunction,
-	StreamOptions,
-} from "../types.ts";
-import { AssistantMessageEventStream } from "../utils/event-stream.ts";
-import { headersToRecord } from "../utils/headers.ts";
-import { getProviderEnvValue } from "../utils/provider-env.ts";
-import { clampOpenAIPromptCacheKey } from "./openai-prompt-cache.ts";
-import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.ts";
-import { buildBaseOptions } from "./simple-options.ts";
+import { azureOpenAIResponsesApi } from "../api/azure-openai-responses.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { AZURE_OPENAI_RESPONSES_MODELS } from "./azure-openai-responses.models.ts";
 
-const DEFAULT_AZURE_API_VERSION = "v1";
-const AZURE_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode", "azure-openai-responses"]);
-
-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;
-}
-
-function resolveDeploymentName(model: Model<"azure-openai-responses">, options?: AzureOpenAIResponsesOptions): string {
-	if (options?.azureDeploymentName) {
-		return options.azureDeploymentName;
-	}
-	const mappedDeployment = parseDeploymentNameMap(
-		getProviderEnvValue("AZURE_OPENAI_DEPLOYMENT_NAME_MAP", options?.env),
-	).get(model.id);
-	return mappedDeployment || model.id;
-}
-
-function formatAzureOpenAIError(error: unknown): string {
-	if (error instanceof Error) {
-		const status = (error as Error & { status?: unknown }).status;
-		const statusCode = typeof status === "number" ? status : undefined;
-		if (statusCode !== undefined) {
-			return `Azure OpenAI API error (${statusCode}): ${error.message}`;
-		}
-		return error.message;
-	}
-	try {
-		return JSON.stringify(error);
-	} catch {
-		return String(error);
-	}
-}
-
-// Azure OpenAI Responses-specific options
-export interface AzureOpenAIResponsesOptions extends StreamOptions {
-	reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh";
-	reasoningSummary?: "auto" | "detailed" | "concise" | null;
-	azureApiVersion?: string;
-	azureResourceName?: string;
-	azureBaseUrl?: string;
-	azureDeploymentName?: string;
-}
-
-/**
- * Generate function for Azure OpenAI Responses API
- */
-export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses", AzureOpenAIResponsesOptions> = (
-	model: Model<"azure-openai-responses">,
-	context: Context,
-	options?: AzureOpenAIResponsesOptions,
-): AssistantMessageEventStream => {
-	const stream = new AssistantMessageEventStream();
-
-	// Start async processing
-	(async () => {
-		const deploymentName = resolveDeploymentName(model, options);
-
-		const output: AssistantMessage = {
-			role: "assistant",
-			content: [],
-			api: "azure-openai-responses" as 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(),
-		};
-
-		try {
-			// Create Azure OpenAI client
-			const apiKey = options?.apiKey;
-			if (!apiKey) {
-				throw new Error(`No API key for provider: ${model.provider}`);
-			}
-			const client = createClient(model, apiKey, options);
-			let params = buildParams(model, context, options, deploymentName);
-			const nextParams = await options?.onPayload?.(params, model);
-			if (nextParams !== undefined) {
-				params = nextParams as ResponseCreateParamsStreaming;
-			}
-			const requestOptions = {
-				...(options?.signal ? { signal: options.signal } : {}),
-				...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
-				maxRetries: options?.maxRetries ?? 0,
-			};
-			const { data: openaiStream, response } = await client.responses.create(params, requestOptions).withResponse();
-			await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
-			stream.push({ type: "start", partial: output });
-
-			await processResponsesStream(openaiStream, output, stream, model);
-
-			if (options?.signal?.aborted) {
-				throw new Error("Request was aborted");
-			}
-
-			if (output.stopReason === "aborted" || output.stopReason === "error") {
-				throw new Error("An unknown error occurred");
-			}
-
-			stream.push({ type: "done", reason: output.stopReason, message: output });
-			stream.end();
-		} catch (error) {
-			for (const block of output.content) {
-				delete (block as { index?: number }).index;
-				// partialJson is only a streaming scratch buffer; never persist it.
-				delete (block as { partialJson?: string }).partialJson;
-			}
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = formatAzureOpenAIError(error);
-			stream.push({ type: "error", reason: output.stopReason, error: output });
-			stream.end();
-		}
-	})();
-
-	return stream;
-};
-
-export const streamSimpleAzureOpenAIResponses: StreamFunction<"azure-openai-responses", SimpleStreamOptions> = (
-	model: Model<"azure-openai-responses">,
-	context: Context,
-	options?: SimpleStreamOptions,
-): AssistantMessageEventStream => {
-	const apiKey = options?.apiKey;
-	if (!apiKey) {
-		throw new Error(`No API key for provider: ${model.provider}`);
-	}
-
-	const base = buildBaseOptions(model, options, apiKey);
-	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
-	const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
-
-	return streamAzureOpenAIResponses(model, context, {
-		...base,
-		reasoningEffort,
-	} satisfies AzureOpenAIResponsesOptions);
-};
-
-function normalizeAzureBaseUrl(baseUrl: string): string {
-	const trimmed = baseUrl.trim().replace(/\/+$/, "");
-	let url: URL;
-	try {
-		url = new URL(trimmed);
-	} catch {
-		throw new Error(`Invalid Azure OpenAI base URL: ${baseUrl}`);
-	}
-
-	const isAzureHost =
-		url.hostname.endsWith(".openai.azure.com") || url.hostname.endsWith(".cognitiveservices.azure.com");
-	const normalizedPath = url.pathname.replace(/\/+$/, "");
-
-	// Ensure Azure hosts have /openai/v1 as base path so the AzureOpenAI SDK
-	// can append /deployments/<model>/... and ?api-version=v1 correctly.
-	if (isAzureHost && (normalizedPath === "" || normalizedPath === "/" || normalizedPath === "/openai")) {
-		url.pathname = "/openai/v1";
-		url.search = "";
-	}
-
-	return url.toString().replace(/\/+$/, "");
-}
-
-function buildDefaultBaseUrl(resourceName: string): string {
-	return `https://${resourceName}.openai.azure.com/openai/v1`;
-}
-
-function resolveAzureConfig(
-	model: Model<"azure-openai-responses">,
-	options?: AzureOpenAIResponsesOptions,
-): { baseUrl: string; apiVersion: string } {
-	const apiVersion =
-		options?.azureApiVersion ||
-		getProviderEnvValue("AZURE_OPENAI_API_VERSION", options?.env) ||
-		DEFAULT_AZURE_API_VERSION;
-
-	const baseUrl =
-		options?.azureBaseUrl?.trim() || getProviderEnvValue("AZURE_OPENAI_BASE_URL", options?.env)?.trim() || undefined;
-	const resourceName = options?.azureResourceName || getProviderEnvValue("AZURE_OPENAI_RESOURCE_NAME", options?.env);
-
-	let resolvedBaseUrl = baseUrl;
-
-	if (!resolvedBaseUrl && resourceName) {
-		resolvedBaseUrl = buildDefaultBaseUrl(resourceName);
-	}
-
-	if (!resolvedBaseUrl && model.baseUrl) {
-		resolvedBaseUrl = model.baseUrl;
-	}
-
-	if (!resolvedBaseUrl) {
-		throw new Error(
-			"Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or pass azureBaseUrl, azureResourceName, or model.baseUrl.",
-		);
-	}
-
-	return {
-		baseUrl: normalizeAzureBaseUrl(resolvedBaseUrl),
-		apiVersion,
-	};
-}
-
-function createClient(model: Model<"azure-openai-responses">, apiKey: string, options?: AzureOpenAIResponsesOptions) {
-	const headers = { ...model.headers };
-
-	if (options?.headers) {
-		Object.assign(headers, options.headers);
-	}
-
-	const { baseUrl, apiVersion } = resolveAzureConfig(model, options);
-
-	return new AzureOpenAI({
-		apiKey,
-		apiVersion,
-		dangerouslyAllowBrowser: true,
-		defaultHeaders: headers,
-		baseURL: baseUrl,
+export function azureOpenAIResponsesProvider(): Provider<"azure-openai-responses"> {
+	return createProvider({
+		id: "azure-openai-responses",
+		name: "Azure OpenAI",
+		auth: { apiKey: envApiKeyAuth("Azure OpenAI API key", ["AZURE_OPENAI_API_KEY"]) },
+		models: Object.values(AZURE_OPENAI_RESPONSES_MODELS),
+		api: azureOpenAIResponsesApi(),
 	});
 }
-
-function buildParams(
-	model: Model<"azure-openai-responses">,
-	context: Context,
-	options: AzureOpenAIResponsesOptions | undefined,
-	deploymentName: string,
-) {
-	const messages = convertResponsesMessages(model, context, AZURE_TOOL_CALL_PROVIDERS);
-
-	const params: ResponseCreateParamsStreaming = {
-		model: deploymentName,
-		input: messages,
-		stream: true,
-		prompt_cache_key: clampOpenAIPromptCacheKey(options?.sessionId),
-		store: false,
-	};
-
-	if (options?.maxTokens) {
-		params.max_output_tokens = options?.maxTokens;
-	}
-
-	if (options?.temperature !== undefined) {
-		params.temperature = options?.temperature;
-	}
-
-	if (context.tools && context.tools.length > 0) {
-		params.tools = convertResponsesTools(context.tools);
-	}
-
-	if (model.reasoning) {
-		if (options?.reasoningEffort || options?.reasoningSummary) {
-			const effort = options?.reasoningEffort
-				? (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort)
-				: "medium";
-			params.reasoning = {
-				effort: effort as NonNullable<typeof params.reasoning>["effort"],
-				summary: options?.reasoningSummary || "auto",
-			};
-			params.include = ["reasoning.encrypted_content"];
-		} else if (model.thinkingLevelMap?.off !== null) {
-			params.reasoning = {
-				effort: (model.thinkingLevelMap?.off ?? "none") as NonNullable<typeof params.reasoning>["effort"],
-			};
-		}
-	}
-
-	return params;
-}

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

@@ -0,0 +1,41 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const CEREBRAS_MODELS = {
+	"gpt-oss-120b": {
+		id: "gpt-oss-120b",
+		name: "GPT OSS 120B",
+		api: "openai-completions",
+		provider: "cerebras",
+		baseUrl: "https://api.cerebras.ai/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.35,
+			output: 0.75,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 40960,
+	} satisfies Model<"openai-completions">,
+	"zai-glm-4.7": {
+		id: "zai-glm-4.7",
+		name: "Z.AI GLM-4.7",
+		api: "openai-completions",
+		provider: "cerebras",
+		baseUrl: "https://api.cerebras.ai/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 2.25,
+			output: 2.75,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 40960,
+	} satisfies Model<"openai-completions">,
+} as const;

packages/ai/src/providers/cerebras.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 { CEREBRAS_MODELS } from "./cerebras.models.ts";
+
+export function cerebrasProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "cerebras",
+		name: "Cerebras",
+		baseUrl: "https://api.cerebras.ai/v1",
+		auth: { apiKey: envApiKeyAuth("Cerebras API key", ["CEREBRAS_API_KEY"]) },
+		models: Object.values(CEREBRAS_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

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

@@ -0,0 +1,656 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const CLOUDFLARE_AI_GATEWAY_MODELS = {
+	"claude-3-5-haiku": {
+		id: "claude-3-5-haiku",
+		name: "Claude Haiku 3.5 (latest)",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.8,
+			output: 4,
+			cacheRead: 0.08,
+			cacheWrite: 1,
+		},
+		contextWindow: 200000,
+		maxTokens: 8192,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-haiku": {
+		id: "claude-3-haiku",
+		name: "Claude Haiku 3",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 1.25,
+			cacheRead: 0.03,
+			cacheWrite: 0.3,
+		},
+		contextWindow: 200000,
+		maxTokens: 4096,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-opus": {
+		id: "claude-3-opus",
+		name: "Claude Opus 3",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 75,
+			cacheRead: 1.5,
+			cacheWrite: 18.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 4096,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3-sonnet": {
+		id: "claude-3-sonnet",
+		name: "Claude Sonnet 3",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 0.3,
+		},
+		contextWindow: 200000,
+		maxTokens: 4096,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3.5-haiku": {
+		id: "claude-3.5-haiku",
+		name: "Claude Haiku 3.5 (latest)",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.8,
+			output: 4,
+			cacheRead: 0.08,
+			cacheWrite: 1,
+		},
+		contextWindow: 200000,
+		maxTokens: 8192,
+	} satisfies Model<"anthropic-messages">,
+	"claude-3.5-sonnet": {
+		id: "claude-3.5-sonnet",
+		name: "Claude Sonnet 3.5 v2",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 8192,
+	} satisfies Model<"anthropic-messages">,
+	"claude-fable-5": {
+		id: "claude-fable-5",
+		name: "Claude Fable 5",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 10,
+			output: 50,
+			cacheRead: 1,
+			cacheWrite: 12.5,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-haiku-4-5": {
+		id: "claude-haiku-4-5",
+		name: "Claude Haiku 4.5 (latest)",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1,
+			output: 5,
+			cacheRead: 0.1,
+			cacheWrite: 1.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4": {
+		id: "claude-opus-4",
+		name: "Claude Opus 4 (latest)",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 75,
+			cacheRead: 1.5,
+			cacheWrite: 18.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-1": {
+		id: "claude-opus-4-1",
+		name: "Claude Opus 4.1 (latest)",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 75,
+			cacheRead: 1.5,
+			cacheWrite: 18.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-5": {
+		id: "claude-opus-4-5",
+		name: "Claude Opus 4.5 (latest)",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-6": {
+		id: "claude-opus-4-6",
+		name: "Claude Opus 4.6 (latest)",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"max"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-7": {
+		id: "claude-opus-4-7",
+		name: "Claude Opus 4.7",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		compat: {"forceAdaptiveThinking":true,"supportsTemperature":false},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-8": {
+		id: "claude-opus-4-8",
+		name: "Claude Opus 4.8",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		compat: {"forceAdaptiveThinking":true,"supportsTemperature":false},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4": {
+		id: "claude-sonnet-4",
+		name: "Claude Sonnet 4 (latest)",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4-5": {
+		id: "claude-sonnet-4-5",
+		name: "Claude Sonnet 4.5 (latest)",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4-6": {
+		id: "claude-sonnet-4-6",
+		name: "Claude Sonnet 4.6",
+		api: "anthropic-messages",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/anthropic",
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 1000000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"gpt-4": {
+		id: "gpt-4",
+		name: "GPT-4",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 30,
+			output: 60,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 8192,
+		maxTokens: 8192,
+	} satisfies Model<"openai-responses">,
+	"gpt-4-turbo": {
+		id: "gpt-4-turbo",
+		name: "GPT-4 Turbo",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 10,
+			output: 30,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 4096,
+	} satisfies Model<"openai-responses">,
+	"gpt-4o": {
+		id: "gpt-4o",
+		name: "GPT-4o",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 10,
+			cacheRead: 1.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-4o-mini": {
+		id: "gpt-4o-mini",
+		name: "GPT-4o mini",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.15,
+			output: 0.6,
+			cacheRead: 0.08,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1": {
+		id: "gpt-5.1",
+		name: "GPT-5.1",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.13,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1-codex": {
+		id: "gpt-5.1-codex",
+		name: "GPT-5.1 Codex",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2": {
+		id: "gpt-5.2",
+		name: "GPT-5.2",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2-codex": {
+		id: "gpt-5.2-codex",
+		name: "GPT-5.2 Codex",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.3-codex": {
+		id: "gpt-5.3-codex",
+		name: "GPT-5.3 Codex",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4": {
+		id: "gpt-5.4",
+		name: "GPT-5.4",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 15,
+			cacheRead: 0.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.5": {
+		id: "gpt-5.5",
+		name: "GPT-5.5",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 30,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"o1": {
+		id: "o1",
+		name: "o1",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 60,
+			cacheRead: 7.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o3": {
+		id: "o3",
+		name: "o3",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o3-mini": {
+		id: "o3-mini",
+		name: "o3-mini",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.1,
+			output: 4.4,
+			cacheRead: 0.55,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o3-pro": {
+		id: "o3-pro",
+		name: "o3-pro",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 20,
+			output: 80,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o4-mini": {
+		id: "o4-mini",
+		name: "o4-mini",
+		api: "openai-responses",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/openai",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.1,
+			output: 4.4,
+			cacheRead: 0.28,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"workers-ai/@cf/moonshotai/kimi-k2.5": {
+		id: "workers-ai/@cf/moonshotai/kimi-k2.5",
+		name: "Kimi K2.5",
+		api: "openai-completions",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/compat",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.6,
+			output: 3,
+			cacheRead: 0.1,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 256000,
+	} satisfies Model<"openai-completions">,
+	"workers-ai/@cf/moonshotai/kimi-k2.6": {
+		id: "workers-ai/@cf/moonshotai/kimi-k2.6",
+		name: "Kimi K2.6",
+		api: "openai-completions",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/compat",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.16,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 256000,
+	} satisfies Model<"openai-completions">,
+	"workers-ai/@cf/nvidia/nemotron-3-120b-a12b": {
+		id: "workers-ai/@cf/nvidia/nemotron-3-120b-a12b",
+		name: "Nemotron 3 Super 120B",
+		api: "openai-completions",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/compat",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.5,
+			output: 1.5,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 256000,
+	} satisfies Model<"openai-completions">,
+	"workers-ai/@cf/zai-org/glm-4.7-flash": {
+		id: "workers-ai/@cf/zai-org/glm-4.7-flash",
+		name: "GLM-4.7-Flash",
+		api: "openai-completions",
+		provider: "cloudflare-ai-gateway",
+		baseUrl: "https://gateway.ai.cloudflare.com/v1/{CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}/compat",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.06,
+			output: 0.4,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+} as const;

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

@@ -0,0 +1,22 @@
+import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.ts";
+import { openAICompletionsApi } from "../api/openai-completions.lazy.ts";
+import { openAIResponsesApi } from "../api/openai-responses.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { CLOUDFLARE_AI_GATEWAY_MODELS } from "./cloudflare-ai-gateway.models.ts";
+
+export function cloudflareAIGatewayProvider(): Provider<
+	"anthropic-messages" | "openai-completions" | "openai-responses"
+> {
+	return createProvider({
+		id: "cloudflare-ai-gateway",
+		name: "Cloudflare AI Gateway",
+		auth: { apiKey: envApiKeyAuth("Cloudflare API key", ["CLOUDFLARE_API_KEY"]) },
+		models: Object.values(CLOUDFLARE_AI_GATEWAY_MODELS),
+		api: {
+			"anthropic-messages": anthropicMessagesApi(),
+			"openai-completions": openAICompletionsApi(),
+			"openai-responses": openAIResponsesApi(),
+		},
+	});
+}

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

@@ -0,0 +1,241 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const CLOUDFLARE_WORKERS_AI_MODELS = {
+	"@cf/google/gemma-4-26b-a4b-it": {
+		id: "@cf/google/gemma-4-26b-a4b-it",
+		name: "Gemma 4 26B A4B IT",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.1,
+			output: 0.3,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"@cf/ibm-granite/granite-4.0-h-micro": {
+		id: "@cf/ibm-granite/granite-4.0-h-micro",
+		name: "Granite 4.0 H Micro",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.017,
+			output: 0.112,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131000,
+		maxTokens: 131000,
+	} satisfies Model<"openai-completions">,
+	"@cf/meta/llama-3.3-70b-instruct-fp8-fast": {
+		id: "@cf/meta/llama-3.3-70b-instruct-fp8-fast",
+		name: "Llama 3.3 70B Instruct fp8 Fast",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.293,
+			output: 2.253,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 24000,
+		maxTokens: 24000,
+	} satisfies Model<"openai-completions">,
+	"@cf/meta/llama-4-scout-17b-16e-instruct": {
+		id: "@cf/meta/llama-4-scout-17b-16e-instruct",
+		name: "Llama 4 Scout 17B 16E Instruct",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.27,
+			output: 0.85,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"@cf/mistralai/mistral-small-3.1-24b-instruct": {
+		id: "@cf/mistralai/mistral-small-3.1-24b-instruct",
+		name: "Mistral Small 3.1 24B Instruct",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.351,
+			output: 0.555,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-completions">,
+	"@cf/moonshotai/kimi-k2.6": {
+		id: "@cf/moonshotai/kimi-k2.6",
+		name: "Kimi K2.6",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.16,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 256000,
+	} satisfies Model<"openai-completions">,
+	"@cf/moonshotai/kimi-k2.7-code": {
+		id: "@cf/moonshotai/kimi-k2.7-code",
+		name: "Kimi K2.7 Code",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.19,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"@cf/nvidia/nemotron-3-120b-a12b": {
+		id: "@cf/nvidia/nemotron-3-120b-a12b",
+		name: "Nemotron 3 Super 120B",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.5,
+			output: 1.5,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 256000,
+	} satisfies Model<"openai-completions">,
+	"@cf/openai/gpt-oss-120b": {
+		id: "@cf/openai/gpt-oss-120b",
+		name: "GPT OSS 120B",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.35,
+			output: 0.75,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"@cf/openai/gpt-oss-20b": {
+		id: "@cf/openai/gpt-oss-20b",
+		name: "GPT OSS 20B",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.2,
+			output: 0.3,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"@cf/qwen/qwen3-30b-a3b-fp8": {
+		id: "@cf/qwen/qwen3-30b-a3b-fp8",
+		name: "Qwen3 30B A3b fp8",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.0509,
+			output: 0.335,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 32768,
+		maxTokens: 32768,
+	} satisfies Model<"openai-completions">,
+	"@cf/zai-org/glm-4.7-flash": {
+		id: "@cf/zai-org/glm-4.7-flash",
+		name: "GLM-4.7-Flash",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.0605,
+			output: 0.4,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"@cf/zai-org/glm-5.2": {
+		id: "@cf/zai-org/glm-5.2",
+		name: "Glm 5.2",
+		api: "openai-completions",
+		provider: "cloudflare-workers-ai",
+		baseUrl: "https://api.cloudflare.com/client/v4/accounts/{CLOUDFLARE_ACCOUNT_ID}/ai/v1",
+		compat: {"sendSessionAffinityHeaders":true},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.4,
+			output: 4.4,
+			cacheRead: 0.26,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+} as const;

packages/ai/src/providers/cloudflare-workers-ai.ts

@@ -0,0 +1,14 @@
+import { openAICompletionsApi } from "../api/openai-completions.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { CLOUDFLARE_WORKERS_AI_MODELS } from "./cloudflare-workers-ai.models.ts";
+
+export function cloudflareWorkersAIProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "cloudflare-workers-ai",
+		name: "Cloudflare Workers AI",
+		auth: { apiKey: envApiKeyAuth("Cloudflare API key", ["CLOUDFLARE_API_KEY"]) },
+		models: Object.values(CLOUDFLARE_WORKERS_AI_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

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

@@ -0,0 +1,45 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const DEEPSEEK_MODELS = {
+	"deepseek-v4-flash": {
+		id: "deepseek-v4-flash",
+		name: "DeepSeek V4 Flash",
+		api: "openai-completions",
+		provider: "deepseek",
+		baseUrl: "https://api.deepseek.com",
+		compat: {"requiresReasoningContentOnAssistantMessages":true,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null,"high":"high","xhigh":"max"},
+		input: ["text"],
+		cost: {
+			input: 0.14,
+			output: 0.28,
+			cacheRead: 0.0028,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 384000,
+	} satisfies Model<"openai-completions">,
+	"deepseek-v4-pro": {
+		id: "deepseek-v4-pro",
+		name: "DeepSeek V4 Pro",
+		api: "openai-completions",
+		provider: "deepseek",
+		baseUrl: "https://api.deepseek.com",
+		compat: {"requiresReasoningContentOnAssistantMessages":true,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null,"high":"high","xhigh":"max"},
+		input: ["text"],
+		cost: {
+			input: 0.435,
+			output: 0.87,
+			cacheRead: 0.003625,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 384000,
+	} satisfies Model<"openai-completions">,
+} as const;

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/faux.ts

@@ -1,4 +1,5 @@
 import { registerApiProvider, unregisterApiProviders } from "../api-registry.ts";
+import { createProvider, type Provider } from "../models.ts";
 import type {
 	AssistantMessage,
 	AssistantMessageEventStream,
@@ -125,6 +126,18 @@ export interface FauxProviderRegistration {
 	unregister: () => void;
 }
 
+export interface FauxProviderHandle {
+	provider: Provider;
+	api: string;
+	models: [Model<string>, ...Model<string>[]];
+	getModel(): Model<string>;
+	getModel(modelId: string): Model<string> | undefined;
+	state: { callCount: number };
+	setResponses: (responses: FauxResponseStep[]) => void;
+	appendResponses: (responses: FauxResponseStep[]) => void;
+	getPendingResponseCount: () => number;
+}
+
 function estimateTokens(text: string): number {
 	return Math.ceil(text.length / 4);
 }
@@ -388,10 +401,9 @@ async function streamWithDeltas(
 	stream.end(message);
 }
 
-export function registerFauxProvider(options: RegisterFauxProviderOptions = {}): FauxProviderRegistration {
+function createFauxCore(options: RegisterFauxProviderOptions) {
 	const api = options.api ?? randomId(DEFAULT_API);
 	const provider = options.provider ?? DEFAULT_PROVIDER;
-	const sourceId = randomId("faux-provider");
 	const minTokenSize = Math.max(
 		1,
 		Math.min(options.tokenSize?.min ?? DEFAULT_MIN_TOKEN_SIZE, options.tokenSize?.max ?? DEFAULT_MAX_TOKEN_SIZE),
@@ -467,8 +479,6 @@ export function registerFauxProvider(options: RegisterFauxProviderOptions = {}):
 	const streamSimple: StreamFunction<string, SimpleStreamOptions> = (streamModel, context, streamOptions) =>
 		stream(streamModel, context, streamOptions);
 
-	registerApiProvider({ api, stream, streamSimple }, sourceId);
-
 	function getModel(): Model<string>;
 	function getModel(requestedModelId: string): Model<string> | undefined;
 	function getModel(requestedModelId?: string): Model<string> | undefined {
@@ -480,20 +490,69 @@ export function registerFauxProvider(options: RegisterFauxProviderOptions = {}):
 
 	return {
 		api,
+		provider,
 		models,
+		stream,
+		streamSimple,
 		getModel,
 		state,
-		setResponses(responses) {
+		setResponses(responses: FauxResponseStep[]) {
 			pendingResponses = [...responses];
 		},
-		appendResponses(responses) {
+		appendResponses(responses: FauxResponseStep[]) {
 			pendingResponses.push(...responses);
 		},
 		getPendingResponseCount() {
 			return pendingResponses.length;
 		},
+	};
+}
+
+/** Registers the faux api into the legacy global api-registry. */
+export function registerFauxProvider(options: RegisterFauxProviderOptions = {}): FauxProviderRegistration {
+	const core = createFauxCore(options);
+	const sourceId = randomId("faux-provider");
+	registerApiProvider({ api: core.api, stream: core.stream, streamSimple: core.streamSimple }, sourceId);
+	return {
+		api: core.api,
+		models: core.models,
+		getModel: core.getModel,
+		state: core.state,
+		setResponses: core.setResponses,
+		appendResponses: core.appendResponses,
+		getPendingResponseCount: core.getPendingResponseCount,
 		unregister() {
 			unregisterApiProviders(sourceId);
 		},
 	};
 }
+
+/**
+ * Faux provider for tests built on explicit `Models` collections:
+ *
+ * ```ts
+ * const faux = fauxProvider();
+ * const models = createModels();
+ * models.setProvider(faux.provider);
+ * faux.setResponses([fauxAssistantMessage("hi")]);
+ * ```
+ */
+export function fauxProvider(options: RegisterFauxProviderOptions = {}): FauxProviderHandle {
+	const core = createFauxCore(options);
+	const provider = createProvider({
+		id: core.provider,
+		auth: { apiKey: { name: "Faux", resolve: async () => ({ auth: {} }) } },
+		models: core.models,
+		api: { stream: core.stream, streamSimple: core.streamSimple },
+	});
+	return {
+		provider,
+		api: core.api,
+		models: core.models,
+		getModel: core.getModel,
+		state: core.state,
+		setResponses: core.setResponses,
+		appendResponses: core.appendResponses,
+		getPendingResponseCount: core.getPendingResponseCount,
+	};
+}

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

@@ -0,0 +1,278 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const FIREWORKS_MODELS = {
+	"accounts/fireworks/models/deepseek-v4-flash": {
+		id: "accounts/fireworks/models/deepseek-v4-flash",
+		name: "DeepSeek V4 Flash",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.14,
+			output: 0.28,
+			cacheRead: 0.028,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 384000,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/models/deepseek-v4-pro": {
+		id: "accounts/fireworks/models/deepseek-v4-pro",
+		name: "DeepSeek V4 Pro",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.74,
+			output: 3.48,
+			cacheRead: 0.145,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 384000,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/models/glm-5p1": {
+		id: "accounts/fireworks/models/glm-5p1",
+		name: "GLM 5.1",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.4,
+			output: 4.4,
+			cacheRead: 0.26,
+			cacheWrite: 0,
+		},
+		contextWindow: 202800,
+		maxTokens: 131072,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/models/glm-5p2": {
+		id: "accounts/fireworks/models/glm-5p2",
+		name: "GLM 5.2",
+		api: "openai-completions",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false},
+		reasoning: true,
+		thinkingLevelMap: {"off":"none","minimal":null,"low":"high","medium":"high","xhigh":"max"},
+		input: ["text"],
+		cost: {
+			input: 1.4,
+			output: 4.4,
+			cacheRead: 0.26,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"accounts/fireworks/models/gpt-oss-120b": {
+		id: "accounts/fireworks/models/gpt-oss-120b",
+		name: "GPT OSS 120B",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.15,
+			output: 0.6,
+			cacheRead: 0.015,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 32768,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/models/gpt-oss-20b": {
+		id: "accounts/fireworks/models/gpt-oss-20b",
+		name: "GPT OSS 20B",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.07,
+			output: 0.3,
+			cacheRead: 0.035,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 32768,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/models/kimi-k2p6": {
+		id: "accounts/fireworks/models/kimi-k2p6",
+		name: "Kimi K2.6",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.16,
+			cacheWrite: 0,
+		},
+		contextWindow: 262000,
+		maxTokens: 262000,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/models/kimi-k2p7-code": {
+		id: "accounts/fireworks/models/kimi-k2p7-code",
+		name: "Kimi K2.7 Code",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.19,
+			cacheWrite: 0,
+		},
+		contextWindow: 262000,
+		maxTokens: 262000,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/models/minimax-m2p7": {
+		id: "accounts/fireworks/models/minimax-m2p7",
+		name: "MiniMax-M2.7",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0,
+		},
+		contextWindow: 196608,
+		maxTokens: 196608,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/models/minimax-m3": {
+		id: "accounts/fireworks/models/minimax-m3",
+		name: "MiniMax-M3",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0,
+		},
+		contextWindow: 512000,
+		maxTokens: 512000,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/models/qwen3p7-plus": {
+		id: "accounts/fireworks/models/qwen3p7-plus",
+		name: "Qwen 3.7 Plus",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.4,
+			output: 1.6,
+			cacheRead: 0.08,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/routers/glm-5p1-fast": {
+		id: "accounts/fireworks/routers/glm-5p1-fast",
+		name: "GLM 5.1 Fast",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 2.8,
+			output: 8.8,
+			cacheRead: 0.52,
+			cacheWrite: 0,
+		},
+		contextWindow: 202800,
+		maxTokens: 131072,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/routers/kimi-k2p6-fast": {
+		id: "accounts/fireworks/routers/kimi-k2p6-fast",
+		name: "Kimi K2.6 Fast",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.3,
+			cacheWrite: 0,
+		},
+		contextWindow: 262000,
+		maxTokens: 262000,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/routers/kimi-k2p6-turbo": {
+		id: "accounts/fireworks/routers/kimi-k2p6-turbo",
+		name: "Kimi K2.6 Turbo",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.3,
+			cacheWrite: 0,
+		},
+		contextWindow: 262000,
+		maxTokens: 262000,
+	} satisfies Model<"anthropic-messages">,
+	"accounts/fireworks/routers/kimi-k2p7-code-fast": {
+		id: "accounts/fireworks/routers/kimi-k2p7-code-fast",
+		name: "Kimi K2.7 Code Fast",
+		api: "anthropic-messages",
+		provider: "fireworks",
+		baseUrl: "https://api.fireworks.ai/inference",
+		compat: {"sendSessionAffinityHeaders":true,"supportsEagerToolInputStreaming":false,"supportsCacheControlOnTools":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.9,
+			output: 8,
+			cacheRead: 0.38,
+			cacheWrite: 0,
+		},
+		contextWindow: 262000,
+		maxTokens: 262000,
+	} satisfies Model<"anthropic-messages">,
+} as const;

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/github-copilot.models.ts

@@ -0,0 +1,428 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const GITHUB_COPILOT_MODELS = {
+	"claude-fable-5": {
+		id: "claude-fable-5",
+		name: "Claude Fable 5",
+		api: "openai-completions",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 10,
+			output: 50,
+			cacheRead: 1,
+			cacheWrite: 12.5,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-completions">,
+	"claude-haiku-4.5": {
+		id: "claude-haiku-4.5",
+		name: "Claude Haiku 4.5 (latest)",
+		api: "anthropic-messages",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"supportsEagerToolInputStreaming":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1,
+			output: 5,
+			cacheRead: 0.1,
+			cacheWrite: 1.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4.5": {
+		id: "claude-opus-4.5",
+		name: "Claude Opus 4.5 (latest)",
+		api: "anthropic-messages",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4.6": {
+		id: "claude-opus-4.6",
+		name: "Claude Opus 4.6",
+		api: "anthropic-messages",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"max"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4.7": {
+		id: "claude-opus-4.7",
+		name: "Claude Opus 4.7",
+		api: "anthropic-messages",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"forceAdaptiveThinking":true,"supportsTemperature":false},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh","minimal":"low"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4.8": {
+		id: "claude-opus-4.8",
+		name: "Claude Opus 4.8",
+		api: "anthropic-messages",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"forceAdaptiveThinking":true,"supportsTemperature":false},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh","minimal":"low"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4": {
+		id: "claude-sonnet-4",
+		name: "Claude Sonnet 4 (latest)",
+		api: "anthropic-messages",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"supportsEagerToolInputStreaming":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 216000,
+		maxTokens: 16000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4.5": {
+		id: "claude-sonnet-4.5",
+		name: "Claude Sonnet 4.5 (latest)",
+		api: "anthropic-messages",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"supportsEagerToolInputStreaming":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4.6": {
+		id: "claude-sonnet-4.6",
+		name: "Claude Sonnet 4.6",
+		api: "anthropic-messages",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":"low","xhigh":"max"},
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 1000000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"gemini-2.5-pro": {
+		id: "gemini-2.5-pro",
+		name: "Gemini 2.5 Pro",
+		api: "openai-completions",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 64000,
+	} satisfies Model<"openai-completions">,
+	"gemini-3-flash-preview": {
+		id: "gemini-3-flash-preview",
+		name: "Gemini 3 Flash Preview",
+		api: "openai-completions",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.5,
+			output: 3,
+			cacheRead: 0.05,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 64000,
+	} satisfies Model<"openai-completions">,
+	"gemini-3.1-pro-preview": {
+		id: "gemini-3.1-pro-preview",
+		name: "Gemini 3.1 Pro Preview",
+		api: "openai-completions",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 12,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"openai-completions">,
+	"gemini-3.5-flash": {
+		id: "gemini-3.5-flash",
+		name: "Gemini 3.5 Flash",
+		api: "openai-completions",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.5,
+			output: 9,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"openai-completions">,
+	"gpt-4.1": {
+		id: "gpt-4.1",
+		name: "GPT-4.1",
+		api: "openai-completions",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false},
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"gpt-5-mini": {
+		id: "gpt-5-mini",
+		name: "GPT-5 Mini",
+		api: "openai-responses",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"low"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 2,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 264000,
+		maxTokens: 64000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2": {
+		id: "gpt-5.2",
+		name: "GPT-5.2",
+		api: "openai-responses",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"low","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2-codex": {
+		id: "gpt-5.2-codex",
+		name: "GPT-5.2 Codex",
+		api: "openai-responses",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"low","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.3-codex": {
+		id: "gpt-5.3-codex",
+		name: "GPT-5.3 Codex",
+		api: "openai-responses",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"low","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4": {
+		id: "gpt-5.4",
+		name: "GPT-5.4",
+		api: "openai-responses",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"low","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 15,
+			cacheRead: 0.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4-mini": {
+		id: "gpt-5.4-mini",
+		name: "GPT-5.4 mini",
+		api: "openai-responses",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"low","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.75,
+			output: 4.5,
+			cacheRead: 0.075,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4-nano": {
+		id: "gpt-5.4-nano",
+		name: "GPT-5.4 nano",
+		api: "openai-responses",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"low","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.2,
+			output: 1.25,
+			cacheRead: 0.02,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.5": {
+		id: "gpt-5.5",
+		name: "GPT-5.5",
+		api: "openai-responses",
+		provider: "github-copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		headers: {"User-Agent":"GitHubCopilotChat/0.35.0","Editor-Version":"vscode/1.107.0","Editor-Plugin-Version":"copilot-chat/0.35.0","Copilot-Integration-Id":"vscode-chat"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"low","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 30,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+} as const;

packages/ai/src/providers/github-copilot.ts

@@ -0,0 +1,25 @@
+import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.ts";
+import { openAICompletionsApi } from "../api/openai-completions.lazy.ts";
+import { openAIResponsesApi } from "../api/openai-responses.lazy.ts";
+import { envApiKeyAuth, lazyOAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { loadGitHubCopilotOAuth } from "../utils/oauth/load.ts";
+import { GITHUB_COPILOT_MODELS } from "./github-copilot.models.ts";
+
+export function githubCopilotProvider(): Provider<"anthropic-messages" | "openai-completions" | "openai-responses"> {
+	return createProvider({
+		id: "github-copilot",
+		name: "GitHub Copilot",
+		baseUrl: "https://api.individual.githubcopilot.com",
+		auth: {
+			apiKey: envApiKeyAuth("GitHub Copilot token", ["COPILOT_GITHUB_TOKEN"]),
+			oauth: lazyOAuth({ name: "GitHub Copilot", load: loadGitHubCopilotOAuth }),
+		},
+		models: Object.values(GITHUB_COPILOT_MODELS),
+		api: {
+			"anthropic-messages": anthropicMessagesApi(),
+			"openai-completions": openAICompletionsApi(),
+			"openai-responses": openAIResponsesApi(),
+		},
+	});
+}

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

@@ -0,0 +1,184 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const GOOGLE_VERTEX_MODELS = {
+	"gemini-2.5-flash": {
+		id: "gemini-2.5-flash",
+		name: "Gemini 2.5 Flash",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.3,
+			output: 2.5,
+			cacheRead: 0.03,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+	"gemini-2.5-flash-lite": {
+		id: "gemini-2.5-flash-lite",
+		name: "Gemini 2.5 Flash-Lite",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.1,
+			output: 0.4,
+			cacheRead: 0.01,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+	"gemini-2.5-pro": {
+		id: "gemini-2.5-pro",
+		name: "Gemini 2.5 Pro",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+	"gemini-3-flash-preview": {
+		id: "gemini-3-flash-preview",
+		name: "Gemini 3 Flash Preview",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.5,
+			output: 3,
+			cacheRead: 0.05,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+	"gemini-3.1-flash-lite": {
+		id: "gemini-3.1-flash-lite",
+		name: "Gemini 3.1 Flash Lite",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 1.5,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+	"gemini-3.1-pro-preview": {
+		id: "gemini-3.1-pro-preview",
+		name: "Gemini 3.1 Pro Preview",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":"LOW","medium":null,"high":"HIGH"},
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 12,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+	"gemini-3.1-pro-preview-customtools": {
+		id: "gemini-3.1-pro-preview-customtools",
+		name: "Gemini 3.1 Pro Preview Custom Tools",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":"LOW","medium":null,"high":"HIGH"},
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 12,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+	"gemini-3.5-flash": {
+		id: "gemini-3.5-flash",
+		name: "Gemini 3.5 Flash",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.5,
+			output: 9,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+	"gemini-flash-latest": {
+		id: "gemini-flash-latest",
+		name: "Gemini Flash Latest",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.5,
+			output: 9,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+	"gemini-flash-lite-latest": {
+		id: "gemini-flash-lite-latest",
+		name: "Gemini Flash-Lite Latest",
+		api: "google-vertex",
+		provider: "google-vertex",
+		baseUrl: "https://{location}-aiplatform.googleapis.com",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 1.5,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-vertex">,
+} as const;

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

@@ -1,582 +1,38 @@
-import {
-	type GenerateContentConfig,
-	type GenerateContentParameters,
-	GoogleGenAI,
-	type HttpOptions,
-	ResourceScope,
-	type ThinkingConfig,
-	ThinkingLevel,
-} from "@google/genai";
-import { calculateCost, clampThinkingLevel } from "../models.ts";
-import type {
-	Api,
-	AssistantMessage,
-	Context,
-	Model,
-	ThinkingLevel as PiThinkingLevel,
-	ProviderEnv,
-	SimpleStreamOptions,
-	StreamFunction,
-	StreamOptions,
-	TextContent,
-	ThinkingBudgets,
-	ThinkingContent,
-	ToolCall,
-} from "../types.ts";
-import { AssistantMessageEventStream } from "../utils/event-stream.ts";
-import { getProviderEnvValue } from "../utils/provider-env.ts";
-import { sanitizeSurrogates } from "../utils/sanitize-unicode.ts";
-import type { GoogleThinkingLevel } from "./google-shared.ts";
-import {
-	convertMessages,
-	convertTools,
-	isThinkingPart,
-	mapStopReason,
-	mapToolChoice,
-	retainThoughtSignature,
-} from "./google-shared.ts";
-import { buildBaseOptions } from "./simple-options.ts";
+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";
 
-export interface GoogleVertexOptions extends StreamOptions {
-	toolChoice?: "auto" | "none" | "any";
-	thinking?: {
-		enabled: boolean;
-		budgetTokens?: number; // -1 for dynamic, 0 to disable
-		level?: GoogleThinkingLevel;
-	};
-	project?: string;
-	location?: string;
-}
+const VERTEX_ADC_PATH = "~/.config/gcloud/application_default_credentials.json";
 
-const API_VERSION = "v1";
-const GCP_VERTEX_CREDENTIALS_MARKER = "gcp-vertex-credentials";
+/**
+ * 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",
+	resolve: async ({ ctx, credential }) => {
+		const key = credential?.key ?? (await ctx.env("GOOGLE_CLOUD_API_KEY"));
+		if (key) return { auth: { apiKey: key }, source: credential?.key ? "stored credential" : "GOOGLE_CLOUD_API_KEY" };
 
-const THINKING_LEVEL_MAP: Record<GoogleThinkingLevel, ThinkingLevel> = {
-	THINKING_LEVEL_UNSPECIFIED: ThinkingLevel.THINKING_LEVEL_UNSPECIFIED,
-	MINIMAL: ThinkingLevel.MINIMAL,
-	LOW: ThinkingLevel.LOW,
-	MEDIUM: ThinkingLevel.MEDIUM,
-	HIGH: ThinkingLevel.HIGH,
-};
-
-// Counter for generating unique tool call IDs
-let toolCallCounter = 0;
-
-export const streamGoogleVertex: StreamFunction<"google-vertex", GoogleVertexOptions> = (
-	model: Model<"google-vertex">,
-	context: Context,
-	options?: GoogleVertexOptions,
-): AssistantMessageEventStream => {
-	const stream = new AssistantMessageEventStream();
-
-	(async () => {
-		const output: AssistantMessage = {
-			role: "assistant",
-			content: [],
-			api: "google-vertex" as 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(),
-		};
-
-		try {
-			const apiKey = resolveApiKey(options);
-			// Create the client using either a Vertex API key, if provided, or ADC with project and location
-			const client = apiKey
-				? createClientWithApiKey(model, apiKey, options?.headers)
-				: createClient(model, resolveProject(options), resolveLocation(options), options?.headers, options?.env);
-			let params = buildParams(model, context, options);
-			const nextParams = await options?.onPayload?.(params, model);
-			if (nextParams !== undefined) {
-				params = nextParams as GenerateContentParameters;
-			}
-			const googleStream = await client.models.generateContentStream(params);
-
-			stream.push({ type: "start", partial: output });
-			let currentBlock: TextContent | ThinkingContent | null = null;
-			const blocks = output.content;
-			const blockIndex = () => blocks.length - 1;
-			for await (const chunk of googleStream) {
-				// Vertex uses the same @google/genai GenerateContentResponse type as Gemini.
-				// responseId is documented there as an output-only identifier for each response.
-				output.responseId ||= chunk.responseId;
-				const candidate = chunk.candidates?.[0];
-				if (candidate?.content?.parts) {
-					for (const part of candidate.content.parts) {
-						if (part.text !== undefined) {
-							const isThinking = isThinkingPart(part);
-							if (
-								!currentBlock ||
-								(isThinking && currentBlock.type !== "thinking") ||
-								(!isThinking && currentBlock.type !== "text")
-							) {
-								if (currentBlock) {
-									if (currentBlock.type === "text") {
-										stream.push({
-											type: "text_end",
-											contentIndex: blocks.length - 1,
-											content: currentBlock.text,
-											partial: output,
-										});
-									} else {
-										stream.push({
-											type: "thinking_end",
-											contentIndex: blockIndex(),
-											content: currentBlock.thinking,
-											partial: output,
-										});
-									}
-								}
-								if (isThinking) {
-									currentBlock = { type: "thinking", thinking: "", thinkingSignature: undefined };
-									output.content.push(currentBlock);
-									stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
-								} else {
-									currentBlock = { type: "text", text: "" };
-									output.content.push(currentBlock);
-									stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-								}
-							}
-							if (currentBlock.type === "thinking") {
-								currentBlock.thinking += part.text;
-								currentBlock.thinkingSignature = retainThoughtSignature(
-									currentBlock.thinkingSignature,
-									part.thoughtSignature,
-								);
-								stream.push({
-									type: "thinking_delta",
-									contentIndex: blockIndex(),
-									delta: part.text,
-									partial: output,
-								});
-							} else {
-								currentBlock.text += part.text;
-								currentBlock.textSignature = retainThoughtSignature(
-									currentBlock.textSignature,
-									part.thoughtSignature,
-								);
-								stream.push({
-									type: "text_delta",
-									contentIndex: blockIndex(),
-									delta: part.text,
-									partial: output,
-								});
-							}
-						}
-
-						if (part.functionCall) {
-							if (currentBlock) {
-								if (currentBlock.type === "text") {
-									stream.push({
-										type: "text_end",
-										contentIndex: blockIndex(),
-										content: currentBlock.text,
-										partial: output,
-									});
-								} else {
-									stream.push({
-										type: "thinking_end",
-										contentIndex: blockIndex(),
-										content: currentBlock.thinking,
-										partial: output,
-									});
-								}
-								currentBlock = null;
-							}
-
-							const providedId = part.functionCall.id;
-							const needsNewId =
-								!providedId || output.content.some((b) => b.type === "toolCall" && b.id === providedId);
-							const toolCallId = needsNewId
-								? `${part.functionCall.name}_${Date.now()}_${++toolCallCounter}`
-								: providedId;
-
-							const toolCall: ToolCall = {
-								type: "toolCall",
-								id: toolCallId,
-								name: part.functionCall.name || "",
-								arguments: (part.functionCall.args as Record<string, any>) ?? {},
-								...(part.thoughtSignature && { thoughtSignature: part.thoughtSignature }),
-							};
-
-							output.content.push(toolCall);
-							stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
-							stream.push({
-								type: "toolcall_delta",
-								contentIndex: blockIndex(),
-								delta: JSON.stringify(toolCall.arguments),
-								partial: output,
-							});
-							stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
-						}
-					}
-				}
-
-				if (candidate?.finishReason) {
-					output.stopReason = mapStopReason(candidate.finishReason);
-					if (output.content.some((b) => b.type === "toolCall")) {
-						output.stopReason = "toolUse";
-					}
-				}
-
-				if (chunk.usageMetadata) {
-					output.usage = {
-						input:
-							(chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
-						output:
-							(chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
-						cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
-						cacheWrite: 0,
-						totalTokens: chunk.usageMetadata.totalTokenCount || 0,
-						cost: {
-							input: 0,
-							output: 0,
-							cacheRead: 0,
-							cacheWrite: 0,
-							total: 0,
-						},
-					};
-					calculateCost(model, output.usage);
-				}
-			}
-
-			if (currentBlock) {
-				if (currentBlock.type === "text") {
-					stream.push({
-						type: "text_end",
-						contentIndex: blockIndex(),
-						content: currentBlock.text,
-						partial: output,
-					});
-				} else {
-					stream.push({
-						type: "thinking_end",
-						contentIndex: blockIndex(),
-						content: currentBlock.thinking,
-						partial: output,
-					});
-				}
-			}
-
-			if (options?.signal?.aborted) {
-				throw new Error("Request was aborted");
-			}
-
-			if (output.stopReason === "aborted" || output.stopReason === "error") {
-				throw new Error("An unknown error occurred");
-			}
-
-			stream.push({ type: "done", reason: output.stopReason, message: output });
-			stream.end();
-		} catch (error) {
-			// Remove internal index property used during streaming
-			for (const block of output.content) {
-				if ("index" in block) {
-					delete (block as { index?: number }).index;
-				}
-			}
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-			stream.push({ type: "error", reason: output.stopReason, error: output });
-			stream.end();
+		const adcPath = await ctx.env("GOOGLE_APPLICATION_CREDENTIALS");
+		const hasCredentials = await ctx.fileExists(adcPath ?? VERTEX_ADC_PATH);
+		const hasProject = Boolean((await ctx.env("GOOGLE_CLOUD_PROJECT")) ?? (await ctx.env("GCLOUD_PROJECT")));
+		const hasLocation = Boolean(await ctx.env("GOOGLE_CLOUD_LOCATION"));
+		if (hasCredentials && hasProject && hasLocation) {
+			return { auth: {}, source: "gcloud application default credentials" };
 		}
-	})();
-
-	return stream;
+		return undefined;
+	},
 };
 
-export const streamSimpleGoogleVertex: StreamFunction<"google-vertex", SimpleStreamOptions> = (
-	model: Model<"google-vertex">,
-	context: Context,
-	options?: SimpleStreamOptions,
-): AssistantMessageEventStream => {
-	const base = buildBaseOptions(model, options, undefined);
-	if (!options?.reasoning) {
-		return streamGoogleVertex(model, context, {
-			...base,
-			thinking: { enabled: false },
-		} satisfies GoogleVertexOptions);
-	}
-
-	const clampedReasoning = clampThinkingLevel(model, options.reasoning);
-	const effort = (clampedReasoning === "off" ? "high" : clampedReasoning) as ClampedThinkingLevel;
-	const geminiModel = model as unknown as Model<"google-generative-ai">;
-
-	if (isGemini3ProModel(geminiModel) || isGemini3FlashModel(geminiModel)) {
-		return streamGoogleVertex(model, context, {
-			...base,
-			thinking: {
-				enabled: true,
-				level: getGemini3ThinkingLevel(effort, geminiModel),
-			},
-		} satisfies GoogleVertexOptions);
-	}
-
-	return streamGoogleVertex(model, context, {
-		...base,
-		thinking: {
-			enabled: true,
-			budgetTokens: getGoogleBudget(geminiModel, effort, options.thinkingBudgets),
-		},
-	} satisfies GoogleVertexOptions);
-};
-
-function createClient(
-	model: Model<"google-vertex">,
-	project: string,
-	location: string,
-	optionsHeaders?: Record<string, string>,
-	env?: ProviderEnv,
-): GoogleGenAI {
-	const googleAuthOptions = buildGoogleAuthOptions(env);
-	return new GoogleGenAI({
-		vertexai: true,
-		project,
-		location,
-		apiVersion: API_VERSION,
-		...(googleAuthOptions ? { googleAuthOptions } : {}),
-		httpOptions: buildHttpOptions(model, optionsHeaders),
+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(),
 	});
 }
-
-function createClientWithApiKey(
-	model: Model<"google-vertex">,
-	apiKey: string,
-	optionsHeaders?: Record<string, string>,
-): GoogleGenAI {
-	return new GoogleGenAI({
-		vertexai: true,
-		apiKey,
-		apiVersion: API_VERSION,
-		httpOptions: buildHttpOptions(model, optionsHeaders),
-	});
-}
-
-function buildHttpOptions(
-	model: Model<"google-vertex">,
-	optionsHeaders?: Record<string, string>,
-): HttpOptions | undefined {
-	const httpOptions: HttpOptions = {};
-	const baseUrl = resolveCustomBaseUrl(model.baseUrl);
-	if (baseUrl) {
-		httpOptions.baseUrl = baseUrl;
-		httpOptions.baseUrlResourceScope = ResourceScope.COLLECTION;
-		if (baseUrlIncludesApiVersion(baseUrl)) {
-			httpOptions.apiVersion = "";
-		}
-	}
-
-	if (model.headers || optionsHeaders) {
-		httpOptions.headers = { ...model.headers, ...optionsHeaders };
-	}
-
-	return Object.keys(httpOptions).length > 0 ? httpOptions : undefined;
-}
-
-function resolveCustomBaseUrl(baseUrl: string): string | undefined {
-	const trimmed = baseUrl.trim();
-	if (!trimmed || trimmed.includes("{location}")) {
-		return undefined;
-	}
-	return trimmed;
-}
-
-function baseUrlIncludesApiVersion(baseUrl: string): boolean {
-	try {
-		const url = new URL(baseUrl);
-		return url.pathname.split("/").some((part) => /^v\d+(?:beta\d*)?$/.test(part));
-	} catch {
-		return /(?:^|\/)v\d+(?:beta\d*)?(?:\/|$)/.test(baseUrl);
-	}
-}
-
-function buildGoogleAuthOptions(env?: ProviderEnv): { keyFilename: string } | undefined {
-	const keyFilename = getProviderEnvValue("GOOGLE_APPLICATION_CREDENTIALS", env);
-	return keyFilename ? { keyFilename } : undefined;
-}
-
-function resolveApiKey(options?: GoogleVertexOptions): string | undefined {
-	const apiKey = options?.apiKey?.trim();
-	if (!apiKey || apiKey === GCP_VERTEX_CREDENTIALS_MARKER || isPlaceholderApiKey(apiKey)) {
-		return undefined;
-	}
-	return apiKey;
-}
-
-function isPlaceholderApiKey(apiKey: string): boolean {
-	return /^<[^>]+>$/.test(apiKey);
-}
-
-function resolveProject(options?: GoogleVertexOptions): string {
-	const project =
-		options?.project ||
-		getProviderEnvValue("GOOGLE_CLOUD_PROJECT", options?.env) ||
-		getProviderEnvValue("GCLOUD_PROJECT", options?.env);
-	if (!project) {
-		throw new Error(
-			"Vertex AI requires a project ID. Set GOOGLE_CLOUD_PROJECT/GCLOUD_PROJECT or pass project in options.",
-		);
-	}
-	return project;
-}
-
-function resolveLocation(options?: GoogleVertexOptions): string {
-	const location = options?.location || getProviderEnvValue("GOOGLE_CLOUD_LOCATION", options?.env);
-	if (!location) {
-		throw new Error("Vertex AI requires a location. Set GOOGLE_CLOUD_LOCATION or pass location in options.");
-	}
-	return location;
-}
-
-function buildParams(
-	model: Model<"google-vertex">,
-	context: Context,
-	options: GoogleVertexOptions = {},
-): GenerateContentParameters {
-	const contents = convertMessages(model, context);
-
-	const generationConfig: GenerateContentConfig = {};
-	if (options.temperature !== undefined) {
-		generationConfig.temperature = options.temperature;
-	}
-	if (options.maxTokens !== undefined) {
-		generationConfig.maxOutputTokens = options.maxTokens;
-	}
-
-	const config: GenerateContentConfig = {
-		...(Object.keys(generationConfig).length > 0 && generationConfig),
-		...(context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) }),
-		...(context.tools && context.tools.length > 0 && { tools: convertTools(context.tools) }),
-	};
-
-	if (context.tools && context.tools.length > 0 && options.toolChoice) {
-		config.toolConfig = {
-			functionCallingConfig: {
-				mode: mapToolChoice(options.toolChoice),
-			},
-		};
-	} else {
-		config.toolConfig = undefined;
-	}
-
-	if (options.thinking?.enabled && model.reasoning) {
-		const thinkingConfig: ThinkingConfig = { includeThoughts: true };
-		if (options.thinking.level !== undefined) {
-			thinkingConfig.thinkingLevel = THINKING_LEVEL_MAP[options.thinking.level];
-		} else if (options.thinking.budgetTokens !== undefined) {
-			thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
-		}
-		config.thinkingConfig = thinkingConfig;
-	} else if (model.reasoning && options.thinking && !options.thinking.enabled) {
-		config.thinkingConfig = getDisabledThinkingConfig(model);
-	}
-
-	if (options.signal) {
-		if (options.signal.aborted) {
-			throw new Error("Request aborted");
-		}
-		config.abortSignal = options.signal;
-	}
-
-	const params: GenerateContentParameters = {
-		model: model.id,
-		contents,
-		config,
-	};
-
-	return params;
-}
-
-type ClampedThinkingLevel = Exclude<PiThinkingLevel, "xhigh">;
-
-function isGemini3ProModel(model: Model<"google-generative-ai">): boolean {
-	return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
-}
-
-function isGemini3FlashModel(model: Model<"google-generative-ai">): boolean {
-	const id = model.id.toLowerCase();
-	return /gemini-3(?:\.\d+)?-flash/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest";
-}
-
-function getDisabledThinkingConfig(model: Model<"google-vertex">): ThinkingConfig {
-	// Google docs: Gemini 3.1 Pro cannot disable thinking, and Gemini 3 Flash / Flash-Lite
-	// do not support full thinking-off either. For Gemini 3 models, use the lowest supported
-	// thinkingLevel without includeThoughts so hidden thinking remains invisible to pi.
-	const geminiModel = model as unknown as Model<"google-generative-ai">;
-	if (isGemini3ProModel(geminiModel)) {
-		return { thinkingLevel: ThinkingLevel.LOW };
-	}
-	if (isGemini3FlashModel(geminiModel)) {
-		return { thinkingLevel: ThinkingLevel.MINIMAL };
-	}
-
-	// Gemini 2.x supports disabling via thinkingBudget = 0.
-	return { thinkingBudget: 0 };
-}
-
-function getGemini3ThinkingLevel(
-	effort: ClampedThinkingLevel,
-	model: Model<"google-generative-ai">,
-): GoogleThinkingLevel {
-	if (isGemini3ProModel(model)) {
-		switch (effort) {
-			case "minimal":
-			case "low":
-				return "LOW";
-			case "medium":
-			case "high":
-				return "HIGH";
-		}
-	}
-	switch (effort) {
-		case "minimal":
-			return "MINIMAL";
-		case "low":
-			return "LOW";
-		case "medium":
-			return "MEDIUM";
-		case "high":
-			return "HIGH";
-	}
-}
-
-function getGoogleBudget(
-	model: Model<"google-generative-ai">,
-	effort: ClampedThinkingLevel,
-	customBudgets?: ThinkingBudgets,
-): number {
-	if (customBudgets?.[effort] !== undefined) {
-		return customBudgets[effort]!;
-	}
-
-	if (model.id.includes("2.5-pro")) {
-		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
-			low: 2048,
-			medium: 8192,
-			high: 32768,
-		};
-		return budgets[effort];
-	}
-
-	if (model.id.includes("2.5-flash")) {
-		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
-			low: 2048,
-			medium: 8192,
-			high: 24576,
-		};
-		return budgets[effort];
-	}
-
-	return -1;
-}

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

@@ -0,0 +1,290 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const GOOGLE_MODELS = {
+	"gemini-2.0-flash": {
+		id: "gemini-2.0-flash",
+		name: "Gemini 2.0 Flash",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.1,
+			output: 0.4,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 8192,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-2.0-flash-lite": {
+		id: "gemini-2.0-flash-lite",
+		name: "Gemini 2.0 Flash-Lite",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.075,
+			output: 0.3,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 8192,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-2.5-flash": {
+		id: "gemini-2.5-flash",
+		name: "Gemini 2.5 Flash",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.3,
+			output: 2.5,
+			cacheRead: 0.03,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-2.5-flash-lite": {
+		id: "gemini-2.5-flash-lite",
+		name: "Gemini 2.5 Flash-Lite",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.1,
+			output: 0.4,
+			cacheRead: 0.01,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-2.5-pro": {
+		id: "gemini-2.5-pro",
+		name: "Gemini 2.5 Pro",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-3-flash-preview": {
+		id: "gemini-3-flash-preview",
+		name: "Gemini 3 Flash Preview",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.5,
+			output: 3,
+			cacheRead: 0.05,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-3-pro-preview": {
+		id: "gemini-3-pro-preview",
+		name: "Gemini 3 Pro Preview",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":"LOW","medium":null,"high":"HIGH"},
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 12,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-3.1-flash-lite": {
+		id: "gemini-3.1-flash-lite",
+		name: "Gemini 3.1 Flash Lite",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 1.5,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-3.1-flash-lite-preview": {
+		id: "gemini-3.1-flash-lite-preview",
+		name: "Gemini 3.1 Flash Lite Preview",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 1.5,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-3.1-pro-preview": {
+		id: "gemini-3.1-pro-preview",
+		name: "Gemini 3.1 Pro Preview",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":"LOW","medium":null,"high":"HIGH"},
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 12,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-3.1-pro-preview-customtools": {
+		id: "gemini-3.1-pro-preview-customtools",
+		name: "Gemini 3.1 Pro Preview Custom Tools",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":"LOW","medium":null,"high":"HIGH"},
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 12,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-3.5-flash": {
+		id: "gemini-3.5-flash",
+		name: "Gemini 3.5 Flash",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.5,
+			output: 9,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-flash-latest": {
+		id: "gemini-flash-latest",
+		name: "Gemini Flash Latest",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.5,
+			output: 9,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-flash-lite-latest": {
+		id: "gemini-flash-lite-latest",
+		name: "Gemini Flash-Lite Latest",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 1.5,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemma-4-26b-a4b-it": {
+		id: "gemma-4-26b-a4b-it",
+		name: "Gemma 4 26B A4B IT",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"MINIMAL","low":null,"medium":null,"high":"HIGH"},
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 32768,
+	} satisfies Model<"google-generative-ai">,
+	"gemma-4-31b-it": {
+		id: "gemma-4-31b-it",
+		name: "Gemma 4 31B IT",
+		api: "google-generative-ai",
+		provider: "google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":"MINIMAL","low":null,"medium":null,"high":"HIGH"},
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 32768,
+	} satisfies Model<"google-generative-ai">,
+} as const;

packages/ai/src/providers/google.ts

@@ -1,504 +1,15 @@
-import {
-	type GenerateContentConfig,
-	type GenerateContentParameters,
-	GoogleGenAI,
-	type ThinkingConfig,
-} from "@google/genai";
-import { calculateCost, clampThinkingLevel } from "../models.ts";
-import type {
-	Api,
-	AssistantMessage,
-	Context,
-	Model,
-	SimpleStreamOptions,
-	StreamFunction,
-	StreamOptions,
-	TextContent,
-	ThinkingBudgets,
-	ThinkingContent,
-	ThinkingLevel,
-	ToolCall,
-} from "../types.ts";
-import { AssistantMessageEventStream } from "../utils/event-stream.ts";
-import { sanitizeSurrogates } from "../utils/sanitize-unicode.ts";
-import type { GoogleThinkingLevel } from "./google-shared.ts";
-import {
-	convertMessages,
-	convertTools,
-	isThinkingPart,
-	mapStopReason,
-	mapToolChoice,
-	retainThoughtSignature,
-} from "./google-shared.ts";
-import { buildBaseOptions } from "./simple-options.ts";
+import { googleGenerativeAIApi } from "../api/google-generative-ai.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { GOOGLE_MODELS } from "./google.models.ts";
 
-export interface GoogleOptions extends StreamOptions {
-	toolChoice?: "auto" | "none" | "any";
-	thinking?: {
-		enabled: boolean;
-		budgetTokens?: number; // -1 for dynamic, 0 to disable
-		level?: GoogleThinkingLevel;
-	};
-}
-
-// Counter for generating unique tool call IDs
-let toolCallCounter = 0;
-
-export const streamGoogle: StreamFunction<"google-generative-ai", GoogleOptions> = (
-	model: Model<"google-generative-ai">,
-	context: Context,
-	options?: GoogleOptions,
-): AssistantMessageEventStream => {
-	const stream = new AssistantMessageEventStream();
-
-	(async () => {
-		const output: AssistantMessage = {
-			role: "assistant",
-			content: [],
-			api: "google-generative-ai" as 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(),
-		};
-
-		try {
-			const apiKey = options?.apiKey;
-			if (!apiKey) {
-				throw new Error(`No API key for provider: ${model.provider}`);
-			}
-			const client = createClient(model, apiKey, options?.headers);
-			let params = buildParams(model, context, options);
-			const nextParams = await options?.onPayload?.(params, model);
-			if (nextParams !== undefined) {
-				params = nextParams as GenerateContentParameters;
-			}
-			const googleStream = await client.models.generateContentStream(params);
-
-			stream.push({ type: "start", partial: output });
-			let currentBlock: TextContent | ThinkingContent | null = null;
-			const blocks = output.content;
-			const blockIndex = () => blocks.length - 1;
-			for await (const chunk of googleStream) {
-				// @google/genai documents GenerateContentResponse.responseId as an output-only field
-				// used to identify each response. Keep the first non-empty one from the stream.
-				output.responseId ||= chunk.responseId;
-				const candidate = chunk.candidates?.[0];
-				if (candidate?.content?.parts) {
-					for (const part of candidate.content.parts) {
-						if (part.text !== undefined) {
-							const isThinking = isThinkingPart(part);
-							if (
-								!currentBlock ||
-								(isThinking && currentBlock.type !== "thinking") ||
-								(!isThinking && currentBlock.type !== "text")
-							) {
-								if (currentBlock) {
-									if (currentBlock.type === "text") {
-										stream.push({
-											type: "text_end",
-											contentIndex: blocks.length - 1,
-											content: currentBlock.text,
-											partial: output,
-										});
-									} else {
-										stream.push({
-											type: "thinking_end",
-											contentIndex: blockIndex(),
-											content: currentBlock.thinking,
-											partial: output,
-										});
-									}
-								}
-								if (isThinking) {
-									currentBlock = { type: "thinking", thinking: "", thinkingSignature: undefined };
-									output.content.push(currentBlock);
-									stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
-								} else {
-									currentBlock = { type: "text", text: "" };
-									output.content.push(currentBlock);
-									stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-								}
-							}
-							if (currentBlock.type === "thinking") {
-								currentBlock.thinking += part.text;
-								currentBlock.thinkingSignature = retainThoughtSignature(
-									currentBlock.thinkingSignature,
-									part.thoughtSignature,
-								);
-								stream.push({
-									type: "thinking_delta",
-									contentIndex: blockIndex(),
-									delta: part.text,
-									partial: output,
-								});
-							} else {
-								currentBlock.text += part.text;
-								currentBlock.textSignature = retainThoughtSignature(
-									currentBlock.textSignature,
-									part.thoughtSignature,
-								);
-								stream.push({
-									type: "text_delta",
-									contentIndex: blockIndex(),
-									delta: part.text,
-									partial: output,
-								});
-							}
-						}
-
-						if (part.functionCall) {
-							if (currentBlock) {
-								if (currentBlock.type === "text") {
-									stream.push({
-										type: "text_end",
-										contentIndex: blockIndex(),
-										content: currentBlock.text,
-										partial: output,
-									});
-								} else {
-									stream.push({
-										type: "thinking_end",
-										contentIndex: blockIndex(),
-										content: currentBlock.thinking,
-										partial: output,
-									});
-								}
-								currentBlock = null;
-							}
-
-							// Generate unique ID if not provided or if it's a duplicate
-							const providedId = part.functionCall.id;
-							const needsNewId =
-								!providedId || output.content.some((b) => b.type === "toolCall" && b.id === providedId);
-							const toolCallId = needsNewId
-								? `${part.functionCall.name}_${Date.now()}_${++toolCallCounter}`
-								: providedId;
-
-							const toolCall: ToolCall = {
-								type: "toolCall",
-								id: toolCallId,
-								name: part.functionCall.name || "",
-								arguments: (part.functionCall.args as Record<string, any>) ?? {},
-								...(part.thoughtSignature && { thoughtSignature: part.thoughtSignature }),
-							};
-
-							output.content.push(toolCall);
-							stream.push({ type: "toolcall_start", contentIndex: blockIndex(), partial: output });
-							stream.push({
-								type: "toolcall_delta",
-								contentIndex: blockIndex(),
-								delta: JSON.stringify(toolCall.arguments),
-								partial: output,
-							});
-							stream.push({ type: "toolcall_end", contentIndex: blockIndex(), toolCall, partial: output });
-						}
-					}
-				}
-
-				if (candidate?.finishReason) {
-					output.stopReason = mapStopReason(candidate.finishReason);
-					if (output.content.some((b) => b.type === "toolCall")) {
-						output.stopReason = "toolUse";
-					}
-				}
-
-				if (chunk.usageMetadata) {
-					output.usage = {
-						input:
-							(chunk.usageMetadata.promptTokenCount || 0) - (chunk.usageMetadata.cachedContentTokenCount || 0),
-						output:
-							(chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
-						cacheRead: chunk.usageMetadata.cachedContentTokenCount || 0,
-						cacheWrite: 0,
-						totalTokens: chunk.usageMetadata.totalTokenCount || 0,
-						cost: {
-							input: 0,
-							output: 0,
-							cacheRead: 0,
-							cacheWrite: 0,
-							total: 0,
-						},
-					};
-					calculateCost(model, output.usage);
-				}
-			}
-
-			if (currentBlock) {
-				if (currentBlock.type === "text") {
-					stream.push({
-						type: "text_end",
-						contentIndex: blockIndex(),
-						content: currentBlock.text,
-						partial: output,
-					});
-				} else {
-					stream.push({
-						type: "thinking_end",
-						contentIndex: blockIndex(),
-						content: currentBlock.thinking,
-						partial: output,
-					});
-				}
-			}
-
-			if (options?.signal?.aborted) {
-				throw new Error("Request was aborted");
-			}
-
-			if (output.stopReason === "aborted" || output.stopReason === "error") {
-				throw new Error("An unknown error occurred");
-			}
-
-			stream.push({ type: "done", reason: output.stopReason, message: output });
-			stream.end();
-		} catch (error) {
-			// Remove internal index property used during streaming
-			for (const block of output.content) {
-				if ("index" in block) {
-					delete (block as { index?: number }).index;
-				}
-			}
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-			stream.push({ type: "error", reason: output.stopReason, error: output });
-			stream.end();
-		}
-	})();
-
-	return stream;
-};
-
-export const streamSimpleGoogle: StreamFunction<"google-generative-ai", SimpleStreamOptions> = (
-	model: Model<"google-generative-ai">,
-	context: Context,
-	options?: SimpleStreamOptions,
-): AssistantMessageEventStream => {
-	const apiKey = options?.apiKey;
-	if (!apiKey) {
-		throw new Error(`No API key for provider: ${model.provider}`);
-	}
-
-	const base = buildBaseOptions(model, options, apiKey);
-	if (!options?.reasoning) {
-		return streamGoogle(model, context, { ...base, thinking: { enabled: false } } satisfies GoogleOptions);
-	}
-
-	const clampedReasoning = clampThinkingLevel(model, options.reasoning);
-	const effort = (clampedReasoning === "off" ? "high" : clampedReasoning) as ClampedThinkingLevel;
-	const googleModel = model as Model<"google-generative-ai">;
-
-	if (isGemini3ProModel(googleModel) || isGemini3FlashModel(googleModel) || isGemma4Model(googleModel)) {
-		return streamGoogle(model, context, {
-			...base,
-			thinking: {
-				enabled: true,
-				level: getThinkingLevel(effort, googleModel),
-			},
-		} satisfies GoogleOptions);
-	}
-
-	return streamGoogle(model, context, {
-		...base,
-		thinking: {
-			enabled: true,
-			budgetTokens: getGoogleBudget(googleModel, effort, options.thinkingBudgets),
-		},
-	} satisfies GoogleOptions);
-};
-
-function createClient(
-	model: Model<"google-generative-ai">,
-	apiKey?: string,
-	optionsHeaders?: Record<string, string>,
-): GoogleGenAI {
-	const httpOptions: { baseUrl?: string; apiVersion?: string; headers?: Record<string, string> } = {};
-	if (model.baseUrl) {
-		httpOptions.baseUrl = model.baseUrl;
-		httpOptions.apiVersion = ""; // baseUrl already includes version path, don't append
-	}
-	if (model.headers || optionsHeaders) {
-		httpOptions.headers = { ...model.headers, ...optionsHeaders };
-	}
-
-	return new GoogleGenAI({
-		apiKey,
-		httpOptions: Object.keys(httpOptions).length > 0 ? httpOptions : undefined,
+export function googleProvider(): Provider<"google-generative-ai"> {
+	return createProvider({
+		id: "google",
+		name: "Google",
+		baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+		auth: { apiKey: envApiKeyAuth("Gemini API key", ["GEMINI_API_KEY"]) },
+		models: Object.values(GOOGLE_MODELS),
+		api: googleGenerativeAIApi(),
 	});
 }
-
-function buildParams(
-	model: Model<"google-generative-ai">,
-	context: Context,
-	options: GoogleOptions = {},
-): GenerateContentParameters {
-	const contents = convertMessages(model, context);
-
-	const generationConfig: GenerateContentConfig = {};
-	if (options.temperature !== undefined) {
-		generationConfig.temperature = options.temperature;
-	}
-	if (options.maxTokens !== undefined) {
-		generationConfig.maxOutputTokens = options.maxTokens;
-	}
-
-	const config: GenerateContentConfig = {
-		...(Object.keys(generationConfig).length > 0 && generationConfig),
-		...(context.systemPrompt && { systemInstruction: sanitizeSurrogates(context.systemPrompt) }),
-		...(context.tools && context.tools.length > 0 && { tools: convertTools(context.tools) }),
-	};
-
-	if (context.tools && context.tools.length > 0 && options.toolChoice) {
-		config.toolConfig = {
-			functionCallingConfig: {
-				mode: mapToolChoice(options.toolChoice),
-			},
-		};
-	} else {
-		config.toolConfig = undefined;
-	}
-
-	if (options.thinking?.enabled && model.reasoning) {
-		const thinkingConfig: ThinkingConfig = { includeThoughts: true };
-		if (options.thinking.level !== undefined) {
-			// Cast to any since our GoogleThinkingLevel mirrors Google's ThinkingLevel enum values
-			thinkingConfig.thinkingLevel = options.thinking.level as any;
-		} else if (options.thinking.budgetTokens !== undefined) {
-			thinkingConfig.thinkingBudget = options.thinking.budgetTokens;
-		}
-		config.thinkingConfig = thinkingConfig;
-	} else if (model.reasoning && options.thinking && !options.thinking.enabled) {
-		config.thinkingConfig = getDisabledThinkingConfig(model);
-	}
-
-	if (options.signal) {
-		if (options.signal.aborted) {
-			throw new Error("Request aborted");
-		}
-		config.abortSignal = options.signal;
-	}
-
-	const params: GenerateContentParameters = {
-		model: model.id,
-		contents,
-		config,
-	};
-
-	return params;
-}
-
-type ClampedThinkingLevel = Exclude<ThinkingLevel, "xhigh">;
-
-function isGemma4Model(model: Model<"google-generative-ai">): boolean {
-	return /gemma-?4/.test(model.id.toLowerCase());
-}
-
-function isGemini3ProModel(model: Model<"google-generative-ai">): boolean {
-	return /gemini-3(?:\.\d+)?-pro/.test(model.id.toLowerCase());
-}
-
-function isGemini3FlashModel(model: Model<"google-generative-ai">): boolean {
-	const id = model.id.toLowerCase();
-	return /gemini-3(?:\.\d+)?-flash/.test(id) || id === "gemini-flash-latest" || id === "gemini-flash-lite-latest";
-}
-
-function getDisabledThinkingConfig(model: Model<"google-generative-ai">): ThinkingConfig {
-	// Google docs: Gemini 3.1 Pro cannot disable thinking, and Gemini 3 Flash / Flash-Lite
-	// do not support full thinking-off either. For Gemini 3 models, use the lowest supported
-	// thinkingLevel without includeThoughts so hidden thinking remains invisible to pi.
-	if (isGemini3ProModel(model)) {
-		return { thinkingLevel: "LOW" as any };
-	}
-	if (isGemini3FlashModel(model)) {
-		return { thinkingLevel: "MINIMAL" as any };
-	}
-	if (isGemma4Model(model)) {
-		return { thinkingLevel: "MINIMAL" as any };
-	}
-
-	// Gemini 2.x supports disabling via thinkingBudget = 0.
-	return { thinkingBudget: 0 };
-}
-
-function getThinkingLevel(effort: ClampedThinkingLevel, model: Model<"google-generative-ai">): GoogleThinkingLevel {
-	if (isGemini3ProModel(model)) {
-		switch (effort) {
-			case "minimal":
-			case "low":
-				return "LOW";
-			case "medium":
-			case "high":
-				return "HIGH";
-		}
-	}
-	if (isGemma4Model(model)) {
-		switch (effort) {
-			case "minimal":
-			case "low":
-				return "MINIMAL";
-			case "medium":
-			case "high":
-				return "HIGH";
-		}
-	}
-	switch (effort) {
-		case "minimal":
-			return "MINIMAL";
-		case "low":
-			return "LOW";
-		case "medium":
-			return "MEDIUM";
-		case "high":
-			return "HIGH";
-	}
-}
-
-function getGoogleBudget(
-	model: Model<"google-generative-ai">,
-	effort: ClampedThinkingLevel,
-	customBudgets?: ThinkingBudgets,
-): number {
-	if (customBudgets?.[effort] !== undefined) {
-		return customBudgets[effort]!;
-	}
-
-	if (model.id.includes("2.5-pro")) {
-		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
-			low: 2048,
-			medium: 8192,
-			high: 32768,
-		};
-		return budgets[effort];
-	}
-
-	if (model.id.includes("2.5-flash-lite")) {
-		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 512,
-			low: 2048,
-			medium: 8192,
-			high: 24576,
-		};
-		return budgets[effort];
-	}
-
-	if (model.id.includes("2.5-flash")) {
-		const budgets: Record<ClampedThinkingLevel, number> = {
-			minimal: 128,
-			low: 2048,
-			medium: 8192,
-			high: 24576,
-		};
-		return budgets[effort];
-	}
-
-	return -1;
-}

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

@@ -0,0 +1,127 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const GROQ_MODELS = {
+	"llama-3.1-8b-instant": {
+		id: "llama-3.1-8b-instant",
+		name: "Llama 3.1 8B",
+		api: "openai-completions",
+		provider: "groq",
+		baseUrl: "https://api.groq.com/openai/v1",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.05,
+			output: 0.08,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"llama-3.3-70b-versatile": {
+		id: "llama-3.3-70b-versatile",
+		name: "Llama 3.3 70B",
+		api: "openai-completions",
+		provider: "groq",
+		baseUrl: "https://api.groq.com/openai/v1",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.59,
+			output: 0.79,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 32768,
+	} satisfies Model<"openai-completions">,
+	"meta-llama/llama-4-scout-17b-16e-instruct": {
+		id: "meta-llama/llama-4-scout-17b-16e-instruct",
+		name: "Llama 4 Scout 17B 16E",
+		api: "openai-completions",
+		provider: "groq",
+		baseUrl: "https://api.groq.com/openai/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.11,
+			output: 0.34,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 8192,
+	} satisfies Model<"openai-completions">,
+	"openai/gpt-oss-120b": {
+		id: "openai/gpt-oss-120b",
+		name: "GPT OSS 120B",
+		api: "openai-completions",
+		provider: "groq",
+		baseUrl: "https://api.groq.com/openai/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.15,
+			output: 0.6,
+			cacheRead: 0.075,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"openai/gpt-oss-20b": {
+		id: "openai/gpt-oss-20b",
+		name: "GPT OSS 20B",
+		api: "openai-completions",
+		provider: "groq",
+		baseUrl: "https://api.groq.com/openai/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.075,
+			output: 0.3,
+			cacheRead: 0.0375,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"openai/gpt-oss-safeguard-20b": {
+		id: "openai/gpt-oss-safeguard-20b",
+		name: "Safety GPT OSS 20B",
+		api: "openai-completions",
+		provider: "groq",
+		baseUrl: "https://api.groq.com/openai/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.075,
+			output: 0.3,
+			cacheRead: 0.037,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"qwen/qwen3-32b": {
+		id: "qwen/qwen3-32b",
+		name: "Qwen3-32B",
+		api: "openai-completions",
+		provider: "groq",
+		baseUrl: "https://api.groq.com/openai/v1",
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null,"high":"default"},
+		input: ["text"],
+		cost: {
+			input: 0.29,
+			output: 0.59,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 40960,
+	} satisfies Model<"openai-completions">,
+} as const;

packages/ai/src/providers/groq.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 { GROQ_MODELS } from "./groq.models.ts";
+
+export function groqProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "groq",
+		name: "Groq",
+		baseUrl: "https://api.groq.com/openai/v1",
+		auth: { apiKey: envApiKeyAuth("Groq API key", ["GROQ_API_KEY"]) },
+		models: Object.values(GROQ_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

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

@@ -0,0 +1,403 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const HUGGINGFACE_MODELS = {
+	"MiniMaxAI/MiniMax-M2.1": {
+		id: "MiniMaxAI/MiniMax-M2.1",
+		name: "MiniMax-M2.1",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"MiniMaxAI/MiniMax-M2.5": {
+		id: "MiniMaxAI/MiniMax-M2.5",
+		name: "MiniMax-M2.5",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.03,
+			cacheWrite: 0,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"MiniMaxAI/MiniMax-M2.7": {
+		id: "MiniMaxAI/MiniMax-M2.7",
+		name: "MiniMax-M2.7",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3-235B-A22B-Thinking-2507": {
+		id: "Qwen/Qwen3-235B-A22B-Thinking-2507",
+		name: "Qwen3-235B-A22B-Thinking-2507",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 3,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3-Coder-480B-A35B-Instruct": {
+		id: "Qwen/Qwen3-Coder-480B-A35B-Instruct",
+		name: "Qwen3-Coder-480B-A35B-Instruct",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 2,
+			output: 2,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 66536,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3-Coder-Next": {
+		id: "Qwen/Qwen3-Coder-Next",
+		name: "Qwen3-Coder-Next",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.2,
+			output: 1.5,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3-Next-80B-A3B-Instruct": {
+		id: "Qwen/Qwen3-Next-80B-A3B-Instruct",
+		name: "Qwen3-Next-80B-A3B-Instruct",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.25,
+			output: 1,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 66536,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3-Next-80B-A3B-Thinking": {
+		id: "Qwen/Qwen3-Next-80B-A3B-Thinking",
+		name: "Qwen3-Next-80B-A3B-Thinking",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 2,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3.5-397B-A17B": {
+		id: "Qwen/Qwen3.5-397B-A17B",
+		name: "Qwen3.5-397B-A17B",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.6,
+			output: 3.6,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 32768,
+	} satisfies Model<"openai-completions">,
+	"XiaomiMiMo/MiMo-V2-Flash": {
+		id: "XiaomiMiMo/MiMo-V2-Flash",
+		name: "MiMo-V2-Flash",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.1,
+			output: 0.3,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 4096,
+	} satisfies Model<"openai-completions">,
+	"deepseek-ai/DeepSeek-R1-0528": {
+		id: "deepseek-ai/DeepSeek-R1-0528",
+		name: "DeepSeek-R1-0528",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 3,
+			output: 5,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 163840,
+		maxTokens: 163840,
+	} satisfies Model<"openai-completions">,
+	"deepseek-ai/DeepSeek-V3.2": {
+		id: "deepseek-ai/DeepSeek-V3.2",
+		name: "DeepSeek-V3.2",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.28,
+			output: 0.4,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 163840,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"deepseek-ai/DeepSeek-V4-Pro": {
+		id: "deepseek-ai/DeepSeek-V4-Pro",
+		name: "DeepSeek V4 Pro",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.435,
+			output: 0.87,
+			cacheRead: 0.003625,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 393216,
+	} satisfies Model<"openai-completions">,
+	"moonshotai/Kimi-K2-Instruct": {
+		id: "moonshotai/Kimi-K2-Instruct",
+		name: "Kimi-K2-Instruct",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 1,
+			output: 3,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"moonshotai/Kimi-K2-Instruct-0905": {
+		id: "moonshotai/Kimi-K2-Instruct-0905",
+		name: "Kimi-K2-Instruct-0905",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 1,
+			output: 3,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"moonshotai/Kimi-K2-Thinking": {
+		id: "moonshotai/Kimi-K2-Thinking",
+		name: "Kimi-K2-Thinking",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.5,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"moonshotai/Kimi-K2.5": {
+		id: "moonshotai/Kimi-K2.5",
+		name: "Kimi-K2.5",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.6,
+			output: 3,
+			cacheRead: 0.1,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"moonshotai/Kimi-K2.6": {
+		id: "moonshotai/Kimi-K2.6",
+		name: "Kimi-K2.6",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.16,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"zai-org/GLM-4.7": {
+		id: "zai-org/GLM-4.7",
+		name: "GLM-4.7",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.2,
+			cacheRead: 0.11,
+			cacheWrite: 0,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"zai-org/GLM-4.7-Flash": {
+		id: "zai-org/GLM-4.7-Flash",
+		name: "GLM-4.7-Flash",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-completions">,
+	"zai-org/GLM-5": {
+		id: "zai-org/GLM-5",
+		name: "GLM-5",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1,
+			output: 3.2,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 202752,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"zai-org/GLM-5.1": {
+		id: "zai-org/GLM-5.1",
+		name: "GLM-5.1",
+		api: "openai-completions",
+		provider: "huggingface",
+		baseUrl: "https://router.huggingface.co/v1",
+		compat: {"supportsDeveloperRole":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1,
+			output: 3.2,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 202752,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+} as const;

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/images/register-builtins.ts

@@ -1,9 +1,9 @@
+import type { generateImages as generateImagesOpenRouterFunction } from "../../api/openrouter-images.ts";
 import { registerImagesApiProvider } from "../../images-api-registry.ts";
 import type { AssistantImages, ImagesContext, ImagesFunction, ImagesModel, ImagesOptions } from "../../types.ts";
-import type { generateImagesOpenRouter as generateImagesOpenRouterFunction } from "./openrouter.ts";
 
 interface OpenRouterImagesProviderModule {
-	generateImagesOpenRouter: typeof generateImagesOpenRouterFunction;
+	generateImages: typeof generateImagesOpenRouterFunction;
 }
 
 let openRouterImagesProviderModulePromise: Promise<OpenRouterImagesProviderModule> | undefined;
@@ -21,7 +21,7 @@ function createLazyLoadErrorImages(model: ImagesModel<"openrouter-images">, erro
 }
 
 function loadOpenRouterImagesProviderModule(): Promise<OpenRouterImagesProviderModule> {
-	openRouterImagesProviderModulePromise ||= import("./openrouter.ts").then(
+	openRouterImagesProviderModulePromise ||= import("../../api/openrouter-images.ts").then(
 		(module) => module as OpenRouterImagesProviderModule,
 	);
 	return openRouterImagesProviderModulePromise;
@@ -34,7 +34,7 @@ export const generateImagesOpenRouter: ImagesFunction<"openrouter-images", Image
 ) => {
 	try {
 		const module = await loadOpenRouterImagesProviderModule();
-		return await module.generateImagesOpenRouter(model, context, options);
+		return await module.generateImages(model, context, options);
 	} catch (error) {
 		return createLazyLoadErrorImages(model, error);
 	}

packages/ai/src/providers/kimi-coding.models.ts

@@ -0,0 +1,61 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const KIMI_CODING_MODELS = {
+	"k2p7": {
+		id: "k2p7",
+		name: "Kimi K2.7 Code",
+		api: "anthropic-messages",
+		provider: "kimi-coding",
+		baseUrl: "https://api.kimi.com/coding",
+		headers: {"User-Agent":"KimiCLI/1.5"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 32768,
+	} satisfies Model<"anthropic-messages">,
+	"kimi-for-coding": {
+		id: "kimi-for-coding",
+		name: "Kimi For Coding",
+		api: "anthropic-messages",
+		provider: "kimi-coding",
+		baseUrl: "https://api.kimi.com/coding",
+		headers: {"User-Agent":"KimiCLI/1.5"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 32768,
+	} satisfies Model<"anthropic-messages">,
+	"kimi-k2-thinking": {
+		id: "kimi-k2-thinking",
+		name: "Kimi K2 Thinking",
+		api: "anthropic-messages",
+		provider: "kimi-coding",
+		baseUrl: "https://api.kimi.com/coding",
+		headers: {"User-Agent":"KimiCLI/1.5"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 32768,
+	} satisfies Model<"anthropic-messages">,
+} as const;

packages/ai/src/providers/kimi-coding.ts

@@ -0,0 +1,15 @@
+import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { KIMI_CODING_MODELS } from "./kimi-coding.models.ts";
+
+export function kimiCodingProvider(): Provider<"anthropic-messages"> {
+	return createProvider({
+		id: "kimi-coding",
+		name: "Kimi For Coding",
+		baseUrl: "https://api.kimi.com/coding",
+		auth: { apiKey: envApiKeyAuth("Kimi API key", ["KIMI_API_KEY"]) },
+		models: Object.values(KIMI_CODING_MODELS),
+		api: anthropicMessagesApi(),
+	});
+}

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

@@ -0,0 +1,58 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const MINIMAX_CN_MODELS = {
+	"MiniMax-M2.7": {
+		id: "MiniMax-M2.7",
+		name: "MiniMax-M2.7",
+		api: "anthropic-messages",
+		provider: "minimax-cn",
+		baseUrl: "https://api.minimaxi.com/anthropic",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0.375,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"anthropic-messages">,
+	"MiniMax-M2.7-highspeed": {
+		id: "MiniMax-M2.7-highspeed",
+		name: "MiniMax-M2.7-highspeed",
+		api: "anthropic-messages",
+		provider: "minimax-cn",
+		baseUrl: "https://api.minimaxi.com/anthropic",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.4,
+			cacheRead: 0.06,
+			cacheWrite: 0.375,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"anthropic-messages">,
+	"MiniMax-M3": {
+		id: "MiniMax-M3",
+		name: "MiniMax-M3",
+		api: "anthropic-messages",
+		provider: "minimax-cn",
+		baseUrl: "https://api.minimaxi.com/anthropic",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.6,
+			output: 2.4,
+			cacheRead: 0.12,
+			cacheWrite: 0,
+		},
+		contextWindow: 512000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+} as const;

packages/ai/src/providers/minimax-cn.ts

@@ -0,0 +1,15 @@
+import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { MINIMAX_CN_MODELS } from "./minimax-cn.models.ts";
+
+export function minimaxCnProvider(): Provider<"anthropic-messages"> {
+	return createProvider({
+		id: "minimax-cn",
+		name: "MiniMax CN",
+		baseUrl: "https://api.minimaxi.com/anthropic",
+		auth: { apiKey: envApiKeyAuth("MiniMax CN API key", ["MINIMAX_CN_API_KEY"]) },
+		models: Object.values(MINIMAX_CN_MODELS),
+		api: anthropicMessagesApi(),
+	});
+}

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

@@ -0,0 +1,58 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const MINIMAX_MODELS = {
+	"MiniMax-M2.7": {
+		id: "MiniMax-M2.7",
+		name: "MiniMax-M2.7",
+		api: "anthropic-messages",
+		provider: "minimax",
+		baseUrl: "https://api.minimax.io/anthropic",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0.375,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"anthropic-messages">,
+	"MiniMax-M2.7-highspeed": {
+		id: "MiniMax-M2.7-highspeed",
+		name: "MiniMax-M2.7-highspeed",
+		api: "anthropic-messages",
+		provider: "minimax",
+		baseUrl: "https://api.minimax.io/anthropic",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.4,
+			cacheRead: 0.06,
+			cacheWrite: 0.375,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"anthropic-messages">,
+	"MiniMax-M3": {
+		id: "MiniMax-M3",
+		name: "MiniMax-M3",
+		api: "anthropic-messages",
+		provider: "minimax",
+		baseUrl: "https://api.minimax.io/anthropic",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.6,
+			output: 2.4,
+			cacheRead: 0.12,
+			cacheWrite: 0,
+		},
+		contextWindow: 512000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+} as const;

packages/ai/src/providers/minimax.ts

@@ -0,0 +1,15 @@
+import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { MINIMAX_MODELS } from "./minimax.models.ts";
+
+export function minimaxProvider(): Provider<"anthropic-messages"> {
+	return createProvider({
+		id: "minimax",
+		name: "MiniMax",
+		baseUrl: "https://api.minimax.io/anthropic",
+		auth: { apiKey: envApiKeyAuth("MiniMax API key", ["MINIMAX_API_KEY"]) },
+		models: Object.values(MINIMAX_MODELS),
+		api: anthropicMessagesApi(),
+	});
+}

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

@@ -0,0 +1,517 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const MISTRAL_MODELS = {
+	"codestral-latest": {
+		id: "codestral-latest",
+		name: "Codestral (latest)",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 0.9,
+			cacheRead: 0.03,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 4096,
+	} satisfies Model<"mistral-conversations">,
+	"devstral-2512": {
+		id: "devstral-2512",
+		name: "Devstral 2",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.4,
+			output: 2,
+			cacheRead: 0.04,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"mistral-conversations">,
+	"devstral-latest": {
+		id: "devstral-latest",
+		name: "Devstral 2",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.4,
+			output: 2,
+			cacheRead: 0.04,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"mistral-conversations">,
+	"devstral-medium-2507": {
+		id: "devstral-medium-2507",
+		name: "Devstral Medium",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.4,
+			output: 2,
+			cacheRead: 0.04,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+	"devstral-medium-latest": {
+		id: "devstral-medium-latest",
+		name: "Devstral 2 (latest)",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.4,
+			output: 2,
+			cacheRead: 0.04,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"mistral-conversations">,
+	"devstral-small-2505": {
+		id: "devstral-small-2505",
+		name: "Devstral Small 2505",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.1,
+			output: 0.3,
+			cacheRead: 0.01,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+	"devstral-small-2507": {
+		id: "devstral-small-2507",
+		name: "Devstral Small",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.1,
+			output: 0.3,
+			cacheRead: 0.01,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+	"labs-devstral-small-2512": {
+		id: "labs-devstral-small-2512",
+		name: "Devstral Small 2",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 256000,
+	} satisfies Model<"mistral-conversations">,
+	"magistral-medium-latest": {
+		id: "magistral-medium-latest",
+		name: "Magistral Medium (latest)",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 2,
+			output: 5,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"mistral-conversations">,
+	"magistral-small": {
+		id: "magistral-small",
+		name: "Magistral Small",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.5,
+			output: 1.5,
+			cacheRead: 0.05,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+	"ministral-3b-latest": {
+		id: "ministral-3b-latest",
+		name: "Ministral 3B (latest)",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.04,
+			output: 0.04,
+			cacheRead: 0.004,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+	"ministral-8b-latest": {
+		id: "ministral-8b-latest",
+		name: "Ministral 8B (latest)",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.1,
+			output: 0.1,
+			cacheRead: 0.01,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-large-2411": {
+		id: "mistral-large-2411",
+		name: "Mistral Large 2.1",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 2,
+			output: 6,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 16384,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-large-2512": {
+		id: "mistral-large-2512",
+		name: "Mistral Large 3",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.5,
+			output: 1.5,
+			cacheRead: 0.05,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-large-latest": {
+		id: "mistral-large-latest",
+		name: "Mistral Large (latest)",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.5,
+			output: 1.5,
+			cacheRead: 0.05,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-medium-2505": {
+		id: "mistral-medium-2505",
+		name: "Mistral Medium 3",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.4,
+			output: 2,
+			cacheRead: 0.04,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-medium-2508": {
+		id: "mistral-medium-2508",
+		name: "Mistral Medium 3.1",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.4,
+			output: 2,
+			cacheRead: 0.04,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-medium-2604": {
+		id: "mistral-medium-2604",
+		name: "Mistral Medium 3.5",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.5,
+			output: 7.5,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-medium-3.5": {
+		id: "mistral-medium-3.5",
+		name: "Mistral Medium 3.5",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.5,
+			output: 7.5,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-medium-latest": {
+		id: "mistral-medium-latest",
+		name: "Mistral Medium (latest)",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.4,
+			output: 2,
+			cacheRead: 0.04,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-nemo": {
+		id: "mistral-nemo",
+		name: "Mistral Nemo",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.15,
+			output: 0.15,
+			cacheRead: 0.015,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-small-2506": {
+		id: "mistral-small-2506",
+		name: "Mistral Small 3.2",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.1,
+			output: 0.3,
+			cacheRead: 0.01,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-small-2603": {
+		id: "mistral-small-2603",
+		name: "Mistral Small 4",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.15,
+			output: 0.6,
+			cacheRead: 0.015,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 256000,
+	} satisfies Model<"mistral-conversations">,
+	"mistral-small-latest": {
+		id: "mistral-small-latest",
+		name: "Mistral Small (latest)",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.15,
+			output: 0.6,
+			cacheRead: 0.015,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 256000,
+	} satisfies Model<"mistral-conversations">,
+	"open-mistral-7b": {
+		id: "open-mistral-7b",
+		name: "Mistral 7B",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.25,
+			output: 0.25,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 8000,
+		maxTokens: 8000,
+	} satisfies Model<"mistral-conversations">,
+	"open-mistral-nemo": {
+		id: "open-mistral-nemo",
+		name: "Open Mistral Nemo",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.15,
+			output: 0.15,
+			cacheRead: 0.015,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+	"open-mixtral-8x22b": {
+		id: "open-mixtral-8x22b",
+		name: "Mixtral 8x22B",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 2,
+			output: 6,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 64000,
+		maxTokens: 64000,
+	} satisfies Model<"mistral-conversations">,
+	"open-mixtral-8x7b": {
+		id: "open-mixtral-8x7b",
+		name: "Mixtral 8x7B",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.7,
+			output: 0.7,
+			cacheRead: 0.07,
+			cacheWrite: 0,
+		},
+		contextWindow: 32000,
+		maxTokens: 32000,
+	} satisfies Model<"mistral-conversations">,
+	"pixtral-12b": {
+		id: "pixtral-12b",
+		name: "Pixtral 12B",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.15,
+			output: 0.15,
+			cacheRead: 0.015,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+	"pixtral-large-latest": {
+		id: "pixtral-large-latest",
+		name: "Pixtral Large (latest)",
+		api: "mistral-conversations",
+		provider: "mistral",
+		baseUrl: "https://api.mistral.ai",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 6,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"mistral-conversations">,
+} as const;

packages/ai/src/providers/mistral.ts

@@ -1,664 +1,15 @@
-import { Mistral } from "@mistralai/mistralai";
-import type {
-	ChatCompletionStreamRequest,
-	ChatCompletionStreamRequestMessage,
-	CompletionEvent,
-	ContentChunk,
-	FunctionTool,
-} from "@mistralai/mistralai/models/components";
-import { calculateCost, clampThinkingLevel } from "../models.ts";
-import type {
-	AssistantMessage,
-	Context,
-	Message,
-	Model,
-	SimpleStreamOptions,
-	StopReason,
-	StreamFunction,
-	StreamOptions,
-	TextContent,
-	ThinkingContent,
-	Tool,
-	ToolCall,
-} from "../types.ts";
-import { AssistantMessageEventStream } from "../utils/event-stream.ts";
-import { shortHash } from "../utils/hash.ts";
-import { parseStreamingJson } from "../utils/json-parse.ts";
-import { sanitizeSurrogates } from "../utils/sanitize-unicode.ts";
-import { buildBaseOptions } from "./simple-options.ts";
-import { transformMessages } from "./transform-messages.ts";
+import { mistralConversationsApi } from "../api/mistral-conversations.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { MISTRAL_MODELS } from "./mistral.models.ts";
 
-const MISTRAL_TOOL_CALL_ID_LENGTH = 9;
-const MAX_MISTRAL_ERROR_BODY_CHARS = 4000;
-
-/**
- * Provider-specific options for the Mistral API.
- */
-type MistralReasoningEffort = "none" | "high";
-
-export interface MistralOptions extends StreamOptions {
-	toolChoice?: "auto" | "none" | "any" | "required" | { type: "function"; function: { name: string } };
-	promptMode?: "reasoning";
-	reasoningEffort?: MistralReasoningEffort;
-}
-
-/**
- * Stream responses from Mistral using `chat.stream`.
- */
-export const streamMistral: StreamFunction<"mistral-conversations", MistralOptions> = (
-	model: Model<"mistral-conversations">,
-	context: Context,
-	options?: MistralOptions,
-): AssistantMessageEventStream => {
-	const stream = new AssistantMessageEventStream();
-
-	(async () => {
-		const output = createOutput(model);
-
-		try {
-			const apiKey = options?.apiKey;
-			if (!apiKey) {
-				throw new Error(`No API key for provider: ${model.provider}`);
-			}
-
-			// Intentionally per-request: avoids shared SDK mutable state across concurrent consumers.
-			const mistral = new Mistral({
-				apiKey,
-				serverURL: model.baseUrl,
-			});
-
-			const normalizeMistralToolCallId = createMistralToolCallIdNormalizer();
-			const transformedMessages = transformMessages(context.messages, model, (id) => normalizeMistralToolCallId(id));
-
-			let payload = buildChatPayload(model, context, transformedMessages, options);
-			const nextPayload = await options?.onPayload?.(payload, model);
-			if (nextPayload !== undefined) {
-				payload = nextPayload as ChatCompletionStreamRequest;
-			}
-			const mistralStream = await mistral.chat.stream(payload, buildRequestOptions(model, options));
-			stream.push({ type: "start", partial: output });
-			await consumeChatStream(model, output, stream, mistralStream);
-
-			if (options?.signal?.aborted) {
-				throw new Error("Request was aborted");
-			}
-
-			if (output.stopReason === "aborted" || output.stopReason === "error") {
-				throw new Error("An unknown error occurred");
-			}
-
-			stream.push({ type: "done", reason: output.stopReason, message: output });
-			stream.end();
-		} catch (error) {
-			for (const block of output.content) {
-				// partialArgs is only a streaming scratch buffer; never persist it.
-				delete (block as { partialArgs?: string }).partialArgs;
-			}
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = formatMistralError(error);
-			stream.push({ type: "error", reason: output.stopReason, error: output });
-			stream.end();
-		}
-	})();
-
-	return stream;
-};
-
-/**
- * Maps provider-agnostic `SimpleStreamOptions` to Mistral options.
- */
-export const streamSimpleMistral: StreamFunction<"mistral-conversations", SimpleStreamOptions> = (
-	model: Model<"mistral-conversations">,
-	context: Context,
-	options?: SimpleStreamOptions,
-): AssistantMessageEventStream => {
-	const apiKey = options?.apiKey;
-	if (!apiKey) {
-		throw new Error(`No API key for provider: ${model.provider}`);
-	}
-
-	const base = buildBaseOptions(model, options, apiKey);
-	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : undefined;
-	const reasoning = clampedReasoning === "off" ? undefined : clampedReasoning;
-	const shouldUseReasoning = model.reasoning && reasoning !== undefined;
-
-	return streamMistral(model, context, {
-		...base,
-		promptMode: shouldUseReasoning && usesPromptModeReasoning(model) ? "reasoning" : undefined,
-		reasoningEffort:
-			shouldUseReasoning && usesReasoningEffort(model) ? mapReasoningEffort(model, reasoning) : undefined,
-	} satisfies MistralOptions);
-};
-
-function createOutput(model: Model<"mistral-conversations">): AssistantMessage {
-	return {
-		role: "assistant",
-		content: [],
-		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(),
-	};
-}
-
-function createMistralToolCallIdNormalizer(): (id: string) => string {
-	const idMap = new Map<string, string>();
-	const reverseMap = new Map<string, string>();
-
-	return (id: string): string => {
-		const existing = idMap.get(id);
-		if (existing) return existing;
-
-		let attempt = 0;
-		while (true) {
-			const candidate = deriveMistralToolCallId(id, attempt);
-			const owner = reverseMap.get(candidate);
-			if (!owner || owner === id) {
-				idMap.set(id, candidate);
-				reverseMap.set(candidate, id);
-				return candidate;
-			}
-			attempt++;
-		}
-	};
-}
-
-function deriveMistralToolCallId(id: string, attempt: number): string {
-	const normalized = id.replace(/[^a-zA-Z0-9]/g, "");
-	if (attempt === 0 && normalized.length === MISTRAL_TOOL_CALL_ID_LENGTH) return normalized;
-	const seedBase = normalized || id;
-	const seed = attempt === 0 ? seedBase : `${seedBase}:${attempt}`;
-	return shortHash(seed)
-		.replace(/[^a-zA-Z0-9]/g, "")
-		.slice(0, MISTRAL_TOOL_CALL_ID_LENGTH);
-}
-
-function formatMistralError(error: unknown): string {
-	if (error instanceof Error) {
-		const sdkError = error as Error & { statusCode?: unknown; body?: unknown };
-		const statusCode = typeof sdkError.statusCode === "number" ? sdkError.statusCode : undefined;
-		const bodyText = typeof sdkError.body === "string" ? sdkError.body.trim() : undefined;
-		if (statusCode !== undefined && bodyText) {
-			return `Mistral API error (${statusCode}): ${truncateErrorText(bodyText, MAX_MISTRAL_ERROR_BODY_CHARS)}`;
-		}
-		if (statusCode !== undefined) return `Mistral API error (${statusCode}): ${error.message}`;
-		return error.message;
-	}
-	return safeJsonStringify(error);
-}
-
-function truncateErrorText(text: string, maxChars: number): string {
-	if (text.length <= maxChars) return text;
-	return `${text.slice(0, maxChars)}... [truncated ${text.length - maxChars} chars]`;
-}
-
-function safeJsonStringify(value: unknown): string {
-	try {
-		const serialized = JSON.stringify(value);
-		return serialized === undefined ? String(value) : serialized;
-	} catch {
-		return String(value);
-	}
-}
-
-function buildRequestOptions(model: Model<"mistral-conversations">, options?: MistralOptions) {
-	const requestOptions: {
-		signal?: AbortSignal;
-		retries: { strategy: "none" };
-		headers?: Record<string, string>;
-	} = {
-		retries: { strategy: "none" },
-	};
-	if (options?.signal) requestOptions.signal = options.signal;
-
-	const headers: Record<string, string> = {};
-	if (model.headers) Object.assign(headers, model.headers);
-	if (options?.headers) Object.assign(headers, options.headers);
-
-	// Mistral infrastructure uses `x-affinity` for KV-cache reuse (prefix caching).
-	// Respect explicit caller-provided header values.
-	if (shouldUsePromptCaching(options) && !headers["x-affinity"]) {
-		headers["x-affinity"] = options.sessionId;
-	}
-
-	if (Object.keys(headers).length > 0) {
-		requestOptions.headers = headers;
-	}
-
-	return requestOptions;
-}
-
-function buildChatPayload(
-	model: Model<"mistral-conversations">,
-	context: Context,
-	messages: Message[],
-	options?: MistralOptions,
-): ChatCompletionStreamRequest {
-	const payload: ChatCompletionStreamRequest = {
-		model: model.id,
-		stream: true,
-		messages: toChatMessages(messages, model.input.includes("image")),
-	};
-
-	if (context.tools?.length) payload.tools = toFunctionTools(context.tools);
-	if (options?.temperature !== undefined) payload.temperature = options.temperature;
-	if (options?.maxTokens !== undefined) payload.maxTokens = options.maxTokens;
-	if (options?.toolChoice) payload.toolChoice = mapToolChoice(options.toolChoice);
-	if (options?.promptMode) payload.promptMode = options.promptMode;
-	if (options?.reasoningEffort) payload.reasoningEffort = options.reasoningEffort;
-	if (shouldUsePromptCaching(options)) payload.promptCacheKey = options.sessionId;
-
-	if (context.systemPrompt) {
-		payload.messages.unshift({
-			role: "system",
-			content: sanitizeSurrogates(context.systemPrompt),
-		});
-	}
-
-	return payload;
-}
-
-function shouldUsePromptCaching(options?: MistralOptions): options is MistralOptions & { sessionId: string } {
-	return options?.cacheRetention !== "none" && !!options?.sessionId;
-}
-
-function getMistralCachedPromptTokens(usage: unknown, promptTokens: number): number {
-	const rawUsage = usage as {
-		promptTokensDetails?: { cachedTokens?: unknown } | null;
-		prompt_tokens_details?: { cached_tokens?: unknown } | null;
-		promptTokenDetails?: { cachedTokens?: unknown } | null;
-		prompt_token_details?: { cached_tokens?: unknown } | null;
-		numCachedTokens?: unknown;
-		num_cached_tokens?: unknown;
-	};
-	const rawCachedTokens =
-		rawUsage.promptTokensDetails?.cachedTokens ??
-		rawUsage.prompt_tokens_details?.cached_tokens ??
-		rawUsage.promptTokenDetails?.cachedTokens ??
-		rawUsage.prompt_token_details?.cached_tokens ??
-		rawUsage.numCachedTokens ??
-		rawUsage.num_cached_tokens ??
-		0;
-	const cachedTokens = typeof rawCachedTokens === "number" && Number.isFinite(rawCachedTokens) ? rawCachedTokens : 0;
-	return Math.min(promptTokens, Math.max(0, cachedTokens));
-}
-
-async function consumeChatStream(
-	model: Model<"mistral-conversations">,
-	output: AssistantMessage,
-	stream: AssistantMessageEventStream,
-	mistralStream: AsyncIterable<CompletionEvent>,
-): Promise<void> {
-	let currentBlock: TextContent | ThinkingContent | null = null;
-	const blocks = output.content;
-	const blockIndex = () => blocks.length - 1;
-	const toolBlocksByKey = new Map<string, number>();
-
-	const finishCurrentBlock = (block?: typeof currentBlock) => {
-		if (!block) return;
-		if (block.type === "text") {
-			stream.push({
-				type: "text_end",
-				contentIndex: blockIndex(),
-				content: block.text,
-				partial: output,
-			});
-			return;
-		}
-		if (block.type === "thinking") {
-			stream.push({
-				type: "thinking_end",
-				contentIndex: blockIndex(),
-				content: block.thinking,
-				partial: output,
-			});
-		}
-	};
-
-	for await (const event of mistralStream) {
-		const chunk = event.data;
-		// Mistral's streamed CompletionChunk carries an id field. Keep the first non-empty one,
-		// mirroring how OpenAI-style streaming exposes a stable response identifier per stream.
-		output.responseId ||= chunk.id;
-
-		if (chunk.usage) {
-			const promptTokens = chunk.usage.promptTokens || 0;
-			const cachedPromptTokens = getMistralCachedPromptTokens(chunk.usage, promptTokens);
-
-			output.usage.input = Math.max(0, promptTokens - cachedPromptTokens);
-			output.usage.output = chunk.usage.completionTokens || 0;
-			output.usage.cacheRead = cachedPromptTokens;
-			output.usage.cacheWrite = 0;
-			output.usage.totalTokens =
-				chunk.usage.totalTokens ||
-				output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-			calculateCost(model, output.usage);
-		}
-
-		const choice = chunk.choices[0];
-		if (!choice) continue;
-
-		if (choice.finishReason) {
-			output.stopReason = mapChatStopReason(choice.finishReason);
-		}
-
-		const delta = choice.delta;
-		if (delta.content !== null && delta.content !== undefined) {
-			const contentItems = typeof delta.content === "string" ? [delta.content] : delta.content;
-			for (const item of contentItems) {
-				if (typeof item === "string") {
-					const textDelta = sanitizeSurrogates(item);
-					if (!currentBlock || currentBlock.type !== "text") {
-						finishCurrentBlock(currentBlock);
-						currentBlock = { type: "text", text: "" };
-						output.content.push(currentBlock);
-						stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-					}
-					currentBlock.text += textDelta;
-					stream.push({
-						type: "text_delta",
-						contentIndex: blockIndex(),
-						delta: textDelta,
-						partial: output,
-					});
-					continue;
-				}
-
-				if (item.type === "thinking") {
-					const deltaText = item.thinking
-						.map((part) => ("text" in part ? part.text : ""))
-						.filter((text) => text.length > 0)
-						.join("");
-					const thinkingDelta = sanitizeSurrogates(deltaText);
-					if (!thinkingDelta) continue;
-					if (!currentBlock || currentBlock.type !== "thinking") {
-						finishCurrentBlock(currentBlock);
-						currentBlock = { type: "thinking", thinking: "" };
-						output.content.push(currentBlock);
-						stream.push({ type: "thinking_start", contentIndex: blockIndex(), partial: output });
-					}
-					currentBlock.thinking += thinkingDelta;
-					stream.push({
-						type: "thinking_delta",
-						contentIndex: blockIndex(),
-						delta: thinkingDelta,
-						partial: output,
-					});
-					continue;
-				}
-
-				if (item.type === "text") {
-					const textDelta = sanitizeSurrogates(item.text);
-					if (!currentBlock || currentBlock.type !== "text") {
-						finishCurrentBlock(currentBlock);
-						currentBlock = { type: "text", text: "" };
-						output.content.push(currentBlock);
-						stream.push({ type: "text_start", contentIndex: blockIndex(), partial: output });
-					}
-					currentBlock.text += textDelta;
-					stream.push({
-						type: "text_delta",
-						contentIndex: blockIndex(),
-						delta: textDelta,
-						partial: output,
-					});
-				}
-			}
-		}
-
-		const toolCalls = delta.toolCalls || [];
-		for (const toolCall of toolCalls) {
-			if (currentBlock) {
-				finishCurrentBlock(currentBlock);
-				currentBlock = null;
-			}
-			const callId =
-				toolCall.id && toolCall.id !== "null"
-					? toolCall.id
-					: deriveMistralToolCallId(`toolcall:${toolCall.index ?? 0}`, 0);
-			const key = `${callId}:${toolCall.index || 0}`;
-			const existingIndex = toolBlocksByKey.get(key);
-			let block: (ToolCall & { partialArgs?: string }) | undefined;
-
-			if (existingIndex !== undefined) {
-				const existing = output.content[existingIndex];
-				if (existing?.type === "toolCall") {
-					block = existing as ToolCall & { partialArgs?: string };
-				}
-			}
-
-			if (!block) {
-				block = {
-					type: "toolCall",
-					id: callId,
-					name: toolCall.function.name,
-					arguments: {},
-					partialArgs: "",
-				};
-				output.content.push(block);
-				toolBlocksByKey.set(key, output.content.length - 1);
-				stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
-			}
-
-			const argsDelta =
-				typeof toolCall.function.arguments === "string"
-					? toolCall.function.arguments
-					: JSON.stringify(toolCall.function.arguments || {});
-			block.partialArgs = (block.partialArgs || "") + argsDelta;
-			block.arguments = parseStreamingJson<Record<string, unknown>>(block.partialArgs);
-			stream.push({
-				type: "toolcall_delta",
-				contentIndex: toolBlocksByKey.get(key)!,
-				delta: argsDelta,
-				partial: output,
-			});
-		}
-	}
-
-	finishCurrentBlock(currentBlock);
-	for (const index of toolBlocksByKey.values()) {
-		const block = output.content[index];
-		if (block.type !== "toolCall") continue;
-		const toolBlock = block as ToolCall & { partialArgs?: string };
-		toolBlock.arguments = parseStreamingJson<Record<string, unknown>>(toolBlock.partialArgs);
-		// Finalize in-place and strip the scratch buffer so replay only
-		// carries parsed arguments.
-		delete toolBlock.partialArgs;
-		stream.push({
-			type: "toolcall_end",
-			contentIndex: index,
-			toolCall: toolBlock,
-			partial: output,
-		});
-	}
-}
-
-function toFunctionTools(tools: Tool[]): Array<FunctionTool & { type: "function" }> {
-	return tools.map((tool) => ({
-		type: "function",
-		function: {
-			name: tool.name,
-			description: tool.description,
-			parameters: stripSymbolKeys(tool.parameters) as Record<string, unknown>,
-			strict: false,
-		},
-	}));
-}
-
-function stripSymbolKeys(value: unknown): unknown {
-	if (Array.isArray(value)) {
-		return value.map((item) => stripSymbolKeys(item));
-	}
-
-	if (value && typeof value === "object") {
-		const result: Record<string, unknown> = {};
-		for (const [key, entry] of Object.entries(value)) {
-			result[key] = stripSymbolKeys(entry);
-		}
-		return result;
-	}
-
-	return value;
-}
-
-function toChatMessages(messages: Message[], supportsImages: boolean): ChatCompletionStreamRequestMessage[] {
-	const result: ChatCompletionStreamRequestMessage[] = [];
-
-	for (const msg of messages) {
-		if (msg.role === "user") {
-			if (typeof msg.content === "string") {
-				result.push({ role: "user", content: sanitizeSurrogates(msg.content) });
-				continue;
-			}
-			const hadImages = msg.content.some((item) => item.type === "image");
-			const content: ContentChunk[] = msg.content
-				.filter((item) => item.type === "text" || supportsImages)
-				.map((item) => {
-					if (item.type === "text") return { type: "text", text: sanitizeSurrogates(item.text) };
-					return { type: "image_url", imageUrl: `data:${item.mimeType};base64,${item.data}` };
-				});
-			if (content.length > 0) {
-				result.push({ role: "user", content });
-				continue;
-			}
-			if (hadImages && !supportsImages) {
-				result.push({ role: "user", content: "(image omitted: model does not support images)" });
-			}
-			continue;
-		}
-
-		if (msg.role === "assistant") {
-			const contentParts: ContentChunk[] = [];
-			const toolCalls: Array<{ id: string; type: "function"; function: { name: string; arguments: string } }> = [];
-
-			for (const block of msg.content) {
-				if (block.type === "text") {
-					if (block.text.trim().length > 0) {
-						contentParts.push({ type: "text", text: sanitizeSurrogates(block.text) });
-					}
-					continue;
-				}
-				if (block.type === "thinking") {
-					if (block.thinking.trim().length > 0) {
-						contentParts.push({
-							type: "thinking",
-							thinking: [{ type: "text", text: sanitizeSurrogates(block.thinking) }],
-						});
-					}
-					continue;
-				}
-				toolCalls.push({
-					id: block.id,
-					type: "function",
-					function: { name: block.name, arguments: JSON.stringify(block.arguments || {}) },
-				});
-			}
-
-			const assistantMessage: ChatCompletionStreamRequestMessage = { role: "assistant" };
-			if (contentParts.length > 0) assistantMessage.content = contentParts;
-			if (toolCalls.length > 0) assistantMessage.toolCalls = toolCalls;
-			if (contentParts.length > 0 || toolCalls.length > 0) result.push(assistantMessage);
-			continue;
-		}
-
-		const toolContent: ContentChunk[] = [];
-		const textResult = msg.content
-			.filter((part) => part.type === "text")
-			.map((part) => (part.type === "text" ? sanitizeSurrogates(part.text) : ""))
-			.join("\n");
-		const hasImages = msg.content.some((part) => part.type === "image");
-		const toolText = buildToolResultText(textResult, hasImages, supportsImages, msg.isError);
-		toolContent.push({ type: "text", text: toolText });
-		for (const part of msg.content) {
-			if (!supportsImages) continue;
-			if (part.type !== "image") continue;
-			toolContent.push({
-				type: "image_url",
-				imageUrl: `data:${part.mimeType};base64,${part.data}`,
-			});
-		}
-		result.push({
-			role: "tool",
-			toolCallId: msg.toolCallId,
-			name: msg.toolName,
-			content: toolContent,
-		});
-	}
-
-	return result;
-}
-
-function buildToolResultText(text: string, hasImages: boolean, supportsImages: boolean, isError: boolean): string {
-	const trimmed = text.trim();
-	const errorPrefix = isError ? "[tool error] " : "";
-
-	if (trimmed.length > 0) {
-		const imageSuffix = hasImages && !supportsImages ? "\n[tool image omitted: model does not support images]" : "";
-		return `${errorPrefix}${trimmed}${imageSuffix}`;
-	}
-
-	if (hasImages) {
-		if (supportsImages) {
-			return isError ? "[tool error] (see attached image)" : "(see attached image)";
-		}
-		return isError
-			? "[tool error] (image omitted: model does not support images)"
-			: "(image omitted: model does not support images)";
-	}
-
-	return isError ? "[tool error] (no tool output)" : "(no tool output)";
-}
-
-function usesReasoningEffort(model: Model<"mistral-conversations">): boolean {
-	return model.id === "mistral-small-2603" || model.id === "mistral-small-latest" || model.id === "mistral-medium-3.5";
-}
-
-function usesPromptModeReasoning(model: Model<"mistral-conversations">): boolean {
-	return model.reasoning && !usesReasoningEffort(model);
-}
-
-function mapReasoningEffort(
-	model: Model<"mistral-conversations">,
-	level: Exclude<SimpleStreamOptions["reasoning"], undefined>,
-): MistralReasoningEffort {
-	return (model.thinkingLevelMap?.[level] ?? "high") as MistralReasoningEffort;
-}
-
-function mapToolChoice(
-	choice: MistralOptions["toolChoice"],
-): "auto" | "none" | "any" | "required" | { type: "function"; function: { name: string } } | undefined {
-	if (!choice) return undefined;
-	if (choice === "auto" || choice === "none" || choice === "any" || choice === "required") {
-		return choice as any;
-	}
-	return {
-		type: "function",
-		function: { name: choice.function.name },
-	};
-}
-
-function mapChatStopReason(reason: string | null): StopReason {
-	if (reason === null) return "stop";
-	switch (reason) {
-		case "stop":
-			return "stop";
-		case "length":
-		case "model_length":
-			return "length";
-		case "tool_calls":
-			return "toolUse";
-		case "error":
-			return "error";
-		default:
-			return "stop";
-	}
+export function mistralProvider(): Provider<"mistral-conversations"> {
+	return createProvider({
+		id: "mistral",
+		name: "Mistral",
+		baseUrl: "https://api.mistral.ai",
+		auth: { apiKey: envApiKeyAuth("Mistral API key", ["MISTRAL_API_KEY"]) },
+		models: Object.values(MISTRAL_MODELS),
+		api: mistralConversationsApi(),
+	});
 }

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

@@ -0,0 +1,171 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const MOONSHOTAI_CN_MODELS = {
+	"kimi-k2-0711-preview": {
+		id: "kimi-k2-0711-preview",
+		name: "Kimi K2 0711",
+		api: "openai-completions",
+		provider: "moonshotai-cn",
+		baseUrl: "https://api.moonshot.cn/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.5,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2-0905-preview": {
+		id: "kimi-k2-0905-preview",
+		name: "Kimi K2 0905",
+		api: "openai-completions",
+		provider: "moonshotai-cn",
+		baseUrl: "https://api.moonshot.cn/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.5,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2-thinking": {
+		id: "kimi-k2-thinking",
+		name: "Kimi K2 Thinking",
+		api: "openai-completions",
+		provider: "moonshotai-cn",
+		baseUrl: "https://api.moonshot.cn/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.5,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2-thinking-turbo": {
+		id: "kimi-k2-thinking-turbo",
+		name: "Kimi K2 Thinking Turbo",
+		api: "openai-completions",
+		provider: "moonshotai-cn",
+		baseUrl: "https://api.moonshot.cn/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.15,
+			output: 8,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2-turbo-preview": {
+		id: "kimi-k2-turbo-preview",
+		name: "Kimi K2 Turbo",
+		api: "openai-completions",
+		provider: "moonshotai-cn",
+		baseUrl: "https://api.moonshot.cn/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 2.4,
+			output: 10,
+			cacheRead: 0.6,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.5": {
+		id: "kimi-k2.5",
+		name: "Kimi K2.5",
+		api: "openai-completions",
+		provider: "moonshotai-cn",
+		baseUrl: "https://api.moonshot.cn/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.6,
+			output: 3,
+			cacheRead: 0.1,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.6": {
+		id: "kimi-k2.6",
+		name: "Kimi K2.6",
+		api: "openai-completions",
+		provider: "moonshotai-cn",
+		baseUrl: "https://api.moonshot.cn/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.16,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.7-code": {
+		id: "kimi-k2.7-code",
+		name: "Kimi K2.7 Code",
+		api: "openai-completions",
+		provider: "moonshotai-cn",
+		baseUrl: "https://api.moonshot.cn/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.19,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.7-code-highspeed": {
+		id: "kimi-k2.7-code-highspeed",
+		name: "Kimi K2.7 Code HighSpeed",
+		api: "openai-completions",
+		provider: "moonshotai-cn",
+		baseUrl: "https://api.moonshot.cn/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.9,
+			output: 8,
+			cacheRead: 0.38,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+} as const;

packages/ai/src/providers/moonshotai-cn.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 { MOONSHOTAI_CN_MODELS } from "./moonshotai-cn.models.ts";
+
+export function moonshotaiCnProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "moonshotai-cn",
+		name: "Moonshot AI CN",
+		baseUrl: "https://api.moonshot.cn/v1",
+		auth: { apiKey: envApiKeyAuth("Moonshot AI API key", ["MOONSHOT_API_KEY"]) },
+		models: Object.values(MOONSHOTAI_CN_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

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

@@ -0,0 +1,171 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const MOONSHOTAI_MODELS = {
+	"kimi-k2-0711-preview": {
+		id: "kimi-k2-0711-preview",
+		name: "Kimi K2 0711",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "https://api.moonshot.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.5,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2-0905-preview": {
+		id: "kimi-k2-0905-preview",
+		name: "Kimi K2 0905",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "https://api.moonshot.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.5,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2-thinking": {
+		id: "kimi-k2-thinking",
+		name: "Kimi K2 Thinking",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "https://api.moonshot.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 2.5,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2-thinking-turbo": {
+		id: "kimi-k2-thinking-turbo",
+		name: "Kimi K2 Thinking Turbo",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "https://api.moonshot.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.15,
+			output: 8,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2-turbo-preview": {
+		id: "kimi-k2-turbo-preview",
+		name: "Kimi K2 Turbo",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "https://api.moonshot.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 2.4,
+			output: 10,
+			cacheRead: 0.6,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.5": {
+		id: "kimi-k2.5",
+		name: "Kimi K2.5",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "https://api.moonshot.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.6,
+			output: 3,
+			cacheRead: 0.1,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.6": {
+		id: "kimi-k2.6",
+		name: "Kimi K2.6",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "https://api.moonshot.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.16,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.7-code": {
+		id: "kimi-k2.7-code",
+		name: "Kimi K2.7 Code",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "https://api.moonshot.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.19,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.7-code-highspeed": {
+		id: "kimi-k2.7-code-highspeed",
+		name: "Kimi K2.7 Code HighSpeed",
+		api: "openai-completions",
+		provider: "moonshotai",
+		baseUrl: "https://api.moonshot.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.9,
+			output: 8,
+			cacheRead: 0.38,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+} as const;

packages/ai/src/providers/moonshotai.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 { MOONSHOTAI_MODELS } from "./moonshotai.models.ts";
+
+export function moonshotaiProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "moonshotai",
+		name: "Moonshot AI",
+		baseUrl: "https://api.moonshot.ai/v1",
+		auth: { apiKey: envApiKeyAuth("Moonshot AI API key", ["MOONSHOT_API_KEY"]) },
+		models: Object.values(MOONSHOTAI_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

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

@@ -0,0 +1,368 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const NVIDIA_MODELS = {
+	"meta/llama-3.1-70b-instruct": {
+		id: "meta/llama-3.1-70b-instruct",
+		name: "Llama 3.1 70b Instruct",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 4096,
+	} satisfies Model<"openai-completions">,
+	"meta/llama-3.1-8b-instruct": {
+		id: "meta/llama-3.1-8b-instruct",
+		name: "Llama 3.1 8B Instruct",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 16000,
+		maxTokens: 4096,
+	} satisfies Model<"openai-completions">,
+	"meta/llama-3.2-11b-vision-instruct": {
+		id: "meta/llama-3.2-11b-vision-instruct",
+		name: "Llama 3.2 11b Vision Instruct",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 4096,
+	} satisfies Model<"openai-completions">,
+	"meta/llama-3.2-90b-vision-instruct": {
+		id: "meta/llama-3.2-90b-vision-instruct",
+		name: "Llama-3.2-90B-Vision-Instruct",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 8192,
+	} satisfies Model<"openai-completions">,
+	"meta/llama-3.3-70b-instruct": {
+		id: "meta/llama-3.3-70b-instruct",
+		name: "Llama 3.3 70b Instruct",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 4096,
+	} satisfies Model<"openai-completions">,
+	"mistralai/mistral-large-3-675b-instruct-2512": {
+		id: "mistralai/mistral-large-3-675b-instruct-2512",
+		name: "Mistral Large 3 675B Instruct 2512",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"mistralai/mistral-small-4-119b-2603": {
+		id: "mistralai/mistral-small-4-119b-2603",
+		name: "mistral-small-4-119b-2603",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 8192,
+	} satisfies Model<"openai-completions">,
+	"moonshotai/kimi-k2.6": {
+		id: "moonshotai/kimi-k2.6",
+		name: "Kimi K2.6",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"nvidia/nemotron-3-nano-30b-a3b": {
+		id: "nvidia/nemotron-3-nano-30b-a3b",
+		name: "nemotron-3-nano-30b-a3b",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"nvidia/nemotron-3-nano-omni-30b-a3b-reasoning": {
+		id: "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning",
+		name: "Nemotron 3 Nano Omni",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"nvidia/nemotron-3-super-120b-a12b": {
+		id: "nvidia/nemotron-3-super-120b-a12b",
+		name: "Nemotron 3 Super",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.2,
+			output: 0.8,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"nvidia/nemotron-3-ultra-550b-a55b": {
+		id: "nvidia/nemotron-3-ultra-550b-a55b",
+		name: "Nemotron 3 Ultra 550B A55B",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.5,
+			output: 2.5,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"nvidia/nvidia-nemotron-nano-9b-v2": {
+		id: "nvidia/nvidia-nemotron-nano-9b-v2",
+		name: "nvidia-nemotron-nano-9b-v2",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"openai/gpt-oss-120b": {
+		id: "openai/gpt-oss-120b",
+		name: "GPT-OSS-120B",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 8192,
+	} satisfies Model<"openai-completions">,
+	"openai/gpt-oss-20b": {
+		id: "openai/gpt-oss-20b",
+		name: "GPT OSS 20B",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 32768,
+	} satisfies Model<"openai-completions">,
+	"qwen/qwen3.5-122b-a10b": {
+		id: "qwen/qwen3.5-122b-a10b",
+		name: "Qwen3.5 122B-A10B",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"stepfun-ai/step-3.5-flash": {
+		id: "stepfun-ai/step-3.5-flash",
+		name: "Step 3.5 Flash",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"stepfun-ai/step-3.7-flash": {
+		id: "stepfun-ai/step-3.7-flash",
+		name: "Step 3.7 Flash",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-completions">,
+	"z-ai/glm-5.1": {
+		id: "z-ai/glm-5.1",
+		name: "GLM-5.1",
+		api: "openai-completions",
+		provider: "nvidia",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		headers: {"NVCF-POLL-SECONDS":"3600"},
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+} as const;

packages/ai/src/providers/nvidia.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 { NVIDIA_MODELS } from "./nvidia.models.ts";
+
+export function nvidiaProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "nvidia",
+		name: "NVIDIA",
+		baseUrl: "https://integrate.api.nvidia.com/v1",
+		auth: { apiKey: envApiKeyAuth("NVIDIA API key", ["NVIDIA_API_KEY"]) },
+		models: Object.values(NVIDIA_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

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

@@ -0,0 +1,79 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const OPENAI_CODEX_MODELS = {
+	"gpt-5.3-codex-spark": {
+		id: "gpt-5.3-codex-spark",
+		name: "GPT-5.3 Codex Spark",
+		api: "openai-codex-responses",
+		provider: "openai-codex",
+		baseUrl: "https://chatgpt.com/backend-api",
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh","minimal":"low"},
+		input: ["text"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-codex-responses">,
+	"gpt-5.4": {
+		id: "gpt-5.4",
+		name: "GPT-5.4",
+		api: "openai-codex-responses",
+		provider: "openai-codex",
+		baseUrl: "https://chatgpt.com/backend-api",
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh","minimal":"low"},
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 15,
+			cacheRead: 0.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 272000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-codex-responses">,
+	"gpt-5.4-mini": {
+		id: "gpt-5.4-mini",
+		name: "GPT-5.4 mini",
+		api: "openai-codex-responses",
+		provider: "openai-codex",
+		baseUrl: "https://chatgpt.com/backend-api",
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh","minimal":"low"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.75,
+			output: 4.5,
+			cacheRead: 0.075,
+			cacheWrite: 0,
+		},
+		contextWindow: 272000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-codex-responses">,
+	"gpt-5.5": {
+		id: "gpt-5.5",
+		name: "GPT-5.5",
+		api: "openai-codex-responses",
+		provider: "openai-codex",
+		baseUrl: "https://chatgpt.com/backend-api",
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh","minimal":"low"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 30,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 272000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-codex-responses">,
+} as const;

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

@@ -0,0 +1,18 @@
+import { openAICodexResponsesApi } from "../api/openai-codex-responses.lazy.ts";
+import { lazyOAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { loadOpenAICodexOAuth } from "../utils/oauth/load.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)", load: loadOpenAICodexOAuth }),
+		},
+		models: Object.values(OPENAI_CODEX_MODELS),
+		api: openAICodexResponsesApi(),
+	});
+}

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

@@ -0,0 +1,745 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const OPENAI_MODELS = {
+	"gpt-4": {
+		id: "gpt-4",
+		name: "GPT-4",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 30,
+			output: 60,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 8192,
+		maxTokens: 8192,
+	} satisfies Model<"openai-responses">,
+	"gpt-4-turbo": {
+		id: "gpt-4-turbo",
+		name: "GPT-4 Turbo",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 10,
+			output: 30,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 4096,
+	} satisfies Model<"openai-responses">,
+	"gpt-4.1": {
+		id: "gpt-4.1",
+		name: "GPT-4.1",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 1047576,
+		maxTokens: 32768,
+	} satisfies Model<"openai-responses">,
+	"gpt-4.1-mini": {
+		id: "gpt-4.1-mini",
+		name: "GPT-4.1 mini",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.4,
+			output: 1.6,
+			cacheRead: 0.1,
+			cacheWrite: 0,
+		},
+		contextWindow: 1047576,
+		maxTokens: 32768,
+	} satisfies Model<"openai-responses">,
+	"gpt-4.1-nano": {
+		id: "gpt-4.1-nano",
+		name: "GPT-4.1 nano",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.1,
+			output: 0.4,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 1047576,
+		maxTokens: 32768,
+	} satisfies Model<"openai-responses">,
+	"gpt-4o": {
+		id: "gpt-4o",
+		name: "GPT-4o",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 10,
+			cacheRead: 1.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-4o-2024-05-13": {
+		id: "gpt-4o-2024-05-13",
+		name: "GPT-4o (2024-05-13)",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 15,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 4096,
+	} satisfies Model<"openai-responses">,
+	"gpt-4o-2024-08-06": {
+		id: "gpt-4o-2024-08-06",
+		name: "GPT-4o (2024-08-06)",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 10,
+			cacheRead: 1.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-4o-2024-11-20": {
+		id: "gpt-4o-2024-11-20",
+		name: "GPT-4o (2024-11-20)",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 10,
+			cacheRead: 1.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-4o-mini": {
+		id: "gpt-4o-mini",
+		name: "GPT-4o mini",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		input: ["text", "image"],
+		cost: {
+			input: 0.15,
+			output: 0.6,
+			cacheRead: 0.075,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-5": {
+		id: "gpt-5",
+		name: "GPT-5",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5-chat-latest": {
+		id: "gpt-5-chat-latest",
+		name: "GPT-5 Chat Latest",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-5-codex": {
+		id: "gpt-5-codex",
+		name: "GPT-5-Codex",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5-mini": {
+		id: "gpt-5-mini",
+		name: "GPT-5 Mini",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 2,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5-nano": {
+		id: "gpt-5-nano",
+		name: "GPT-5 Nano",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.05,
+			output: 0.4,
+			cacheRead: 0.005,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5-pro": {
+		id: "gpt-5-pro",
+		name: "GPT-5 Pro",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 120,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1": {
+		id: "gpt-5.1",
+		name: "GPT-5.1",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":"none"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1-chat-latest": {
+		id: "gpt-5.1-chat-latest",
+		name: "GPT-5.1 Chat",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1-codex": {
+		id: "gpt-5.1-codex",
+		name: "GPT-5.1 Codex",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1-codex-max": {
+		id: "gpt-5.1-codex-max",
+		name: "GPT-5.1 Codex Max",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1-codex-mini": {
+		id: "gpt-5.1-codex-mini",
+		name: "GPT-5.1 Codex mini",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 2,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2": {
+		id: "gpt-5.2",
+		name: "GPT-5.2",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":"none","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2-chat-latest": {
+		id: "gpt-5.2-chat-latest",
+		name: "GPT-5.2 Chat",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2-codex": {
+		id: "gpt-5.2-codex",
+		name: "GPT-5.2 Codex",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2-pro": {
+		id: "gpt-5.2-pro",
+		name: "GPT-5.2 Pro",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 21,
+			output: 168,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.3-chat-latest": {
+		id: "gpt-5.3-chat-latest",
+		name: "GPT-5.3 Chat (latest)",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: false,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 16384,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.3-codex": {
+		id: "gpt-5.3-codex",
+		name: "GPT-5.3 Codex",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":"none","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.3-codex-spark": {
+		id: "gpt-5.3-codex-spark",
+		name: "GPT-5.3 Codex Spark",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 128000,
+		maxTokens: 32000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4": {
+		id: "gpt-5.4",
+		name: "GPT-5.4",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":"none","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 15,
+			cacheRead: 0.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 272000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4-mini": {
+		id: "gpt-5.4-mini",
+		name: "GPT-5.4 mini",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":"none","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.75,
+			output: 4.5,
+			cacheRead: 0.075,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4-nano": {
+		id: "gpt-5.4-nano",
+		name: "GPT-5.4 nano",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":"none","xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.2,
+			output: 1.25,
+			cacheRead: 0.02,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4-pro": {
+		id: "gpt-5.4-pro",
+		name: "GPT-5.4 Pro",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 30,
+			output: 180,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.5": {
+		id: "gpt-5.5",
+		name: "GPT-5.5",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":"none","xhigh":"xhigh","minimal":null},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 30,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 272000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.5-pro": {
+		id: "gpt-5.5-pro",
+		name: "GPT-5.5 Pro",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh","minimal":null,"low":null},
+		input: ["text", "image"],
+		cost: {
+			input: 30,
+			output: 180,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"o1": {
+		id: "o1",
+		name: "o1",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 60,
+			cacheRead: 7.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o1-pro": {
+		id: "o1-pro",
+		name: "o1-pro",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 150,
+			output: 600,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o3": {
+		id: "o3",
+		name: "o3",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o3-deep-research": {
+		id: "o3-deep-research",
+		name: "o3-deep-research",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 10,
+			output: 40,
+			cacheRead: 2.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o3-mini": {
+		id: "o3-mini",
+		name: "o3-mini",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.1,
+			output: 4.4,
+			cacheRead: 0.55,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o3-pro": {
+		id: "o3-pro",
+		name: "o3-pro",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 20,
+			output: 80,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o4-mini": {
+		id: "o4-mini",
+		name: "o4-mini",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1.1,
+			output: 4.4,
+			cacheRead: 0.275,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+	"o4-mini-deep-research": {
+		id: "o4-mini-deep-research",
+		name: "o4-mini-deep-research",
+		api: "openai-responses",
+		provider: "openai",
+		baseUrl: "https://api.openai.com/v1",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 8,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 100000,
+	} satisfies Model<"openai-responses">,
+} as const;

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,242 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const OPENCODE_GO_MODELS = {
+	"deepseek-v4-flash": {
+		id: "deepseek-v4-flash",
+		name: "DeepSeek V4 Flash",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"maxTokensField":"max_tokens","requiresReasoningContentOnAssistantMessages":true,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null,"high":"high","xhigh":"max"},
+		input: ["text"],
+		cost: {
+			input: 0.14,
+			output: 0.28,
+			cacheRead: 0.0028,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 384000,
+	} satisfies Model<"openai-completions">,
+	"deepseek-v4-pro": {
+		id: "deepseek-v4-pro",
+		name: "DeepSeek V4 Pro",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"maxTokensField":"max_tokens","requiresReasoningContentOnAssistantMessages":true,"thinkingFormat":"deepseek"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null,"high":"high","xhigh":"max"},
+		input: ["text"],
+		cost: {
+			input: 1.74,
+			output: 3.48,
+			cacheRead: 0.0145,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 384000,
+	} satisfies Model<"openai-completions">,
+	"glm-5.1": {
+		id: "glm-5.1",
+		name: "GLM-5.1",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.4,
+			output: 4.4,
+			cacheRead: 0.26,
+			cacheWrite: 0,
+		},
+		contextWindow: 202752,
+		maxTokens: 32768,
+	} satisfies Model<"openai-completions">,
+	"glm-5.2": {
+		id: "glm-5.2",
+		name: "GLM-5.2",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":null,"medium":null,"high":"high","xhigh":"max"},
+		input: ["text"],
+		cost: {
+			input: 1.4,
+			output: 4.4,
+			cacheRead: 0.26,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.6": {
+		id: "kimi-k2.6",
+		name: "Kimi K2.6",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"thinkingFormat":"deepseek","supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsLongCacheRetention":false},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.16,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.7-code": {
+		id: "kimi-k2.7-code",
+		name: "Kimi K2.7 Code",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.19,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"mimo-v2.5": {
+		id: "mimo-v2.5",
+		name: "MiMo V2.5",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.14,
+			output: 0.28,
+			cacheRead: 0.0028,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-completions">,
+	"mimo-v2.5-pro": {
+		id: "mimo-v2.5-pro",
+		name: "MiMo V2.5 Pro",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.74,
+			output: 3.48,
+			cacheRead: 0.0145,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 128000,
+	} satisfies Model<"openai-completions">,
+	"minimax-m2.7": {
+		id: "minimax-m2.7",
+		name: "MiniMax M2.7",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"minimax-m3": {
+		id: "minimax-m3",
+		name: "MiniMax M3 (3x usage)",
+		api: "anthropic-messages",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.1,
+			output: 0.4,
+			cacheRead: 0.02,
+			cacheWrite: 0,
+		},
+		contextWindow: 512000,
+		maxTokens: 131072,
+	} satisfies Model<"anthropic-messages">,
+	"qwen3.6-plus": {
+		id: "qwen3.6-plus",
+		name: "Qwen3.6 Plus",
+		api: "openai-completions",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go/v1",
+		compat: {"thinkingFormat":"qwen","maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.5,
+			output: 3,
+			cacheRead: 0.05,
+			cacheWrite: 0.625,
+		},
+		contextWindow: 1000000,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"qwen3.7-max": {
+		id: "qwen3.7-max",
+		name: "Qwen3.7 Max",
+		api: "anthropic-messages",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 2.5,
+			output: 7.5,
+			cacheRead: 0.5,
+			cacheWrite: 3.125,
+		},
+		contextWindow: 1000000,
+		maxTokens: 65536,
+	} satisfies Model<"anthropic-messages">,
+	"qwen3.7-plus": {
+		id: "qwen3.7-plus",
+		name: "Qwen3.7 Plus",
+		api: "anthropic-messages",
+		provider: "opencode-go",
+		baseUrl: "https://opencode.ai/zen/go",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.4,
+			output: 1.6,
+			cacheRead: 0.04,
+			cacheWrite: 0.5,
+		},
+		contextWindow: 1000000,
+		maxTokens: 65536,
+	} satisfies Model<"anthropic-messages">,
+} as const;

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

@@ -0,0 +1,18 @@
+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 { OPENCODE_GO_MODELS } from "./opencode-go.models.ts";
+
+export function opencodeGoProvider(): Provider<"anthropic-messages" | "openai-completions"> {
+	return createProvider({
+		id: "opencode-go",
+		name: "OpenCode Zen Go",
+		auth: { apiKey: envApiKeyAuth("OpenCode API key", ["OPENCODE_API_KEY"]) },
+		models: Object.values(OPENCODE_GO_MODELS),
+		api: {
+			"anthropic-messages": anthropicMessagesApi(),
+			"openai-completions": openAICompletionsApi(),
+		},
+	});
+}

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

@@ -0,0 +1,799 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const OPENCODE_MODELS = {
+	"big-pickle": {
+		id: "big-pickle",
+		name: "Big Pickle",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"openai-completions">,
+	"claude-haiku-4-5": {
+		id: "claude-haiku-4-5",
+		name: "Claude Haiku 4.5",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 1,
+			output: 5,
+			cacheRead: 0.1,
+			cacheWrite: 1.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-1": {
+		id: "claude-opus-4-1",
+		name: "Claude Opus 4.1",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 15,
+			output: 75,
+			cacheRead: 1.5,
+			cacheWrite: 18.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-5": {
+		id: "claude-opus-4-5",
+		name: "Claude Opus 4.5",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-6": {
+		id: "claude-opus-4-6",
+		name: "Claude Opus 4.6",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"max"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-7": {
+		id: "claude-opus-4-7",
+		name: "Claude Opus 4.7",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		compat: {"forceAdaptiveThinking":true,"supportsTemperature":false},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-opus-4-8": {
+		id: "claude-opus-4-8",
+		name: "Claude Opus 4.8",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		compat: {"forceAdaptiveThinking":true,"supportsTemperature":false},
+		reasoning: true,
+		thinkingLevelMap: {"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 25,
+			cacheRead: 0.5,
+			cacheWrite: 6.25,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4": {
+		id: "claude-sonnet-4",
+		name: "Claude Sonnet 4",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4-5": {
+		id: "claude-sonnet-4-5",
+		name: "Claude Sonnet 4.5",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 200000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"claude-sonnet-4-6": {
+		id: "claude-sonnet-4-6",
+		name: "Claude Sonnet 4.6",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		compat: {"forceAdaptiveThinking":true},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 3,
+			output: 15,
+			cacheRead: 0.3,
+			cacheWrite: 3.75,
+		},
+		contextWindow: 1000000,
+		maxTokens: 64000,
+	} satisfies Model<"anthropic-messages">,
+	"deepseek-v4-flash": {
+		id: "deepseek-v4-flash",
+		name: "DeepSeek V4 Flash",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens","supportsLongCacheRetention":false,"requiresReasoningContentOnAssistantMessages":true},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null,"high":"high","xhigh":"max"},
+		input: ["text"],
+		cost: {
+			input: 0.14,
+			output: 0.28,
+			cacheRead: 0.028,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 384000,
+	} satisfies Model<"openai-completions">,
+	"deepseek-v4-flash-free": {
+		id: "deepseek-v4-flash-free",
+		name: "DeepSeek V4 Flash Free",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens","requiresReasoningContentOnAssistantMessages":true},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null,"high":"high","xhigh":"max"},
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-completions">,
+	"deepseek-v4-pro": {
+		id: "deepseek-v4-pro",
+		name: "DeepSeek V4 Pro",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens","supportsLongCacheRetention":false,"requiresReasoningContentOnAssistantMessages":true},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null,"high":"high","xhigh":"max"},
+		input: ["text"],
+		cost: {
+			input: 1.74,
+			output: 3.84,
+			cacheRead: 0.145,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 384000,
+	} satisfies Model<"openai-completions">,
+	"gemini-3-flash": {
+		id: "gemini-3-flash",
+		name: "Gemini 3 Flash",
+		api: "google-generative-ai",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.5,
+			output: 3,
+			cacheRead: 0.05,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-3.1-pro": {
+		id: "gemini-3.1-pro",
+		name: "Gemini 3.1 Pro Preview",
+		api: "google-generative-ai",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":"LOW","medium":null,"high":"HIGH"},
+		input: ["text", "image"],
+		cost: {
+			input: 2,
+			output: 12,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"gemini-3.5-flash": {
+		id: "gemini-3.5-flash",
+		name: "Gemini 3.5 Flash",
+		api: "google-generative-ai",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.5,
+			output: 9,
+			cacheRead: 0.15,
+			cacheWrite: 0,
+		},
+		contextWindow: 1048576,
+		maxTokens: 65536,
+	} satisfies Model<"google-generative-ai">,
+	"glm-5": {
+		id: "glm-5",
+		name: "GLM-5",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1,
+			output: 3.2,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"glm-5.1": {
+		id: "glm-5.1",
+		name: "GLM-5.1",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 1.4,
+			output: 4.4,
+			cacheRead: 0.26,
+			cacheWrite: 0,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"gpt-5": {
+		id: "gpt-5",
+		name: "GPT-5",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.07,
+			output: 8.5,
+			cacheRead: 0.107,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5-codex": {
+		id: "gpt-5-codex",
+		name: "GPT-5 Codex",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.07,
+			output: 8.5,
+			cacheRead: 0.107,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5-nano": {
+		id: "gpt-5-nano",
+		name: "GPT-5 Nano",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.05,
+			output: 0.4,
+			cacheRead: 0.005,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1": {
+		id: "gpt-5.1",
+		name: "GPT-5.1",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.07,
+			output: 8.5,
+			cacheRead: 0.107,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1-codex": {
+		id: "gpt-5.1-codex",
+		name: "GPT-5.1 Codex",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.07,
+			output: 8.5,
+			cacheRead: 0.107,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1-codex-max": {
+		id: "gpt-5.1-codex-max",
+		name: "GPT-5.1 Codex Max",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.25,
+			output: 10,
+			cacheRead: 0.125,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.1-codex-mini": {
+		id: "gpt-5.1-codex-mini",
+		name: "GPT-5.1 Codex Mini",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.25,
+			output: 2,
+			cacheRead: 0.025,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2": {
+		id: "gpt-5.2",
+		name: "GPT-5.2",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.2-codex": {
+		id: "gpt-5.2-codex",
+		name: "GPT-5.2 Codex",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.3-codex": {
+		id: "gpt-5.3-codex",
+		name: "GPT-5.3 Codex",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 1.75,
+			output: 14,
+			cacheRead: 0.175,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4": {
+		id: "gpt-5.4",
+		name: "GPT-5.4",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 2.5,
+			output: 15,
+			cacheRead: 0.25,
+			cacheWrite: 0,
+		},
+		contextWindow: 272000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4-mini": {
+		id: "gpt-5.4-mini",
+		name: "GPT-5.4 Mini",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.75,
+			output: 4.5,
+			cacheRead: 0.075,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4-nano": {
+		id: "gpt-5.4-nano",
+		name: "GPT-5.4 Nano",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 0.2,
+			output: 1.25,
+			cacheRead: 0.02,
+			cacheWrite: 0,
+		},
+		contextWindow: 400000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.4-pro": {
+		id: "gpt-5.4-pro",
+		name: "GPT-5.4 Pro",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 30,
+			output: 180,
+			cacheRead: 30,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.5": {
+		id: "gpt-5.5",
+		name: "GPT-5.5",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh"},
+		input: ["text", "image"],
+		cost: {
+			input: 5,
+			output: 30,
+			cacheRead: 0.5,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"gpt-5.5-pro": {
+		id: "gpt-5.5-pro",
+		name: "GPT-5.5 Pro",
+		api: "openai-responses",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"xhigh":"xhigh","minimal":null,"low":null},
+		input: ["text", "image"],
+		cost: {
+			input: 30,
+			output: 180,
+			cacheRead: 30,
+			cacheWrite: 0,
+		},
+		contextWindow: 1050000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-responses">,
+	"grok-build-0.1": {
+		id: "grok-build-0.1",
+		name: "Grok Build 0.1",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"supportsReasoningEffort":false,"maxTokensField":"max_tokens"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":null,"medium":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1,
+			output: 2,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 256000,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.5": {
+		id: "kimi-k2.5",
+		name: "Kimi K2.5",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens","supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.6,
+			output: 3,
+			cacheRead: 0.08,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"kimi-k2.6": {
+		id: "kimi-k2.6",
+		name: "Kimi K2.6",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"thinkingFormat":"deepseek","supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.16,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"mimo-v2.5-free": {
+		id: "mimo-v2.5-free",
+		name: "MiMo V2.5 Free",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 200000,
+		maxTokens: 32000,
+	} satisfies Model<"openai-completions">,
+	"minimax-m2.5": {
+		id: "minimax-m2.5",
+		name: "MiniMax M2.5",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"minimax-m2.7": {
+		id: "minimax-m2.7",
+		name: "MiniMax M2.7",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens","supportsLongCacheRetention":false},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0,
+		},
+		contextWindow: 204800,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"nemotron-3-ultra-free": {
+		id: "nemotron-3-ultra-free",
+		name: "Nemotron 3 Ultra Free",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 128000,
+	} satisfies Model<"openai-completions">,
+	"north-mini-code-free": {
+		id: "north-mini-code-free",
+		name: "North Mini Code Free",
+		api: "openai-completions",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen/v1",
+		compat: {"maxTokensField":"max_tokens"},
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 256000,
+		maxTokens: 64000,
+	} satisfies Model<"openai-completions">,
+	"qwen3.5-plus": {
+		id: "qwen3.5-plus",
+		name: "Qwen3.5 Plus",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.2,
+			output: 1.2,
+			cacheRead: 0.02,
+			cacheWrite: 0.25,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"anthropic-messages">,
+	"qwen3.6-plus": {
+		id: "qwen3.6-plus",
+		name: "Qwen3.6 Plus",
+		api: "anthropic-messages",
+		provider: "opencode",
+		baseUrl: "https://opencode.ai/zen",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 0.5,
+			output: 3,
+			cacheRead: 0.05,
+			cacheWrite: 0.625,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"anthropic-messages">,
+} as const;

packages/ai/src/providers/opencode.ts

@@ -0,0 +1,24 @@
+import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.ts";
+import { googleGenerativeAIApi } from "../api/google-generative-ai.lazy.ts";
+import { openAICompletionsApi } from "../api/openai-completions.lazy.ts";
+import { openAIResponsesApi } from "../api/openai-responses.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { OPENCODE_MODELS } from "./opencode.models.ts";
+
+export function opencodeProvider(): Provider<
+	"anthropic-messages" | "google-generative-ai" | "openai-completions" | "openai-responses"
+> {
+	return createProvider({
+		id: "opencode",
+		name: "OpenCode Zen",
+		auth: { apiKey: envApiKeyAuth("OpenCode API key", ["OPENCODE_API_KEY"]) },
+		models: Object.values(OPENCODE_MODELS),
+		api: {
+			"anthropic-messages": anthropicMessagesApi(),
+			"google-generative-ai": googleGenerativeAIApi(),
+			"openai-completions": openAICompletionsApi(),
+			"openai-responses": openAIResponsesApi(),
+		},
+	});
+}

packages/ai/src/providers/openrouter-images.ts

@@ -0,0 +1,14 @@
+import { openrouterImagesApi } from "../api/openrouter-images.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { IMAGE_MODELS } from "../image-models.generated.ts";
+import { createImagesProvider, type ImagesProvider } from "../images-models.ts";
+
+export function openrouterImagesProvider(): ImagesProvider {
+	return createImagesProvider({
+		id: "openrouter",
+		name: "OpenRouter",
+		auth: { apiKey: envApiKeyAuth("OpenRouter API key", ["OPENROUTER_API_KEY"]) },
+		models: Object.values(IMAGE_MODELS.openrouter),
+		api: openrouterImagesApi(),
+	});
+}

packages/ai/src/providers/openrouter.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 { OPENROUTER_MODELS } from "./openrouter.models.ts";
+
+export function openrouterProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "openrouter",
+		name: "OpenRouter",
+		baseUrl: "https://openrouter.ai/api/v1",
+		auth: { apiKey: envApiKeyAuth("OpenRouter API key", ["OPENROUTER_API_KEY"]) },
+		models: Object.values(OPENROUTER_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

packages/ai/src/providers/register-builtins.ts

@@ -1,406 +0,0 @@
-import { clearApiProviders, registerApiProvider } from "../api-registry.ts";
-import type {
-	Api,
-	AssistantMessage,
-	AssistantMessageEvent,
-	Context,
-	Model,
-	SimpleStreamOptions,
-	StreamFunction,
-	StreamOptions,
-} from "../types.ts";
-import { AssistantMessageEventStream } from "../utils/event-stream.ts";
-import type { BedrockOptions } from "./amazon-bedrock.ts";
-import type { AnthropicOptions } from "./anthropic.ts";
-import type { AzureOpenAIResponsesOptions } from "./azure-openai-responses.ts";
-import type { GoogleOptions } from "./google.ts";
-import type { GoogleVertexOptions } from "./google-vertex.ts";
-import type { MistralOptions } from "./mistral.ts";
-import type { OpenAICodexResponsesOptions } from "./openai-codex-responses.ts";
-import type { OpenAICompletionsOptions } from "./openai-completions.ts";
-import type { OpenAIResponsesOptions } from "./openai-responses.ts";
-
-interface LazyProviderModule<
-	TApi extends Api,
-	TOptions extends StreamOptions,
-	TSimpleOptions extends SimpleStreamOptions,
-> {
-	stream: (model: Model<TApi>, context: Context, options?: TOptions) => AsyncIterable<AssistantMessageEvent>;
-	streamSimple: (
-		model: Model<TApi>,
-		context: Context,
-		options?: TSimpleOptions,
-	) => AsyncIterable<AssistantMessageEvent>;
-}
-
-interface AnthropicProviderModule {
-	streamAnthropic: StreamFunction<"anthropic-messages", AnthropicOptions>;
-	streamSimpleAnthropic: StreamFunction<"anthropic-messages", SimpleStreamOptions>;
-}
-
-interface AzureOpenAIResponsesProviderModule {
-	streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses", AzureOpenAIResponsesOptions>;
-	streamSimpleAzureOpenAIResponses: StreamFunction<"azure-openai-responses", SimpleStreamOptions>;
-}
-
-interface GoogleProviderModule {
-	streamGoogle: StreamFunction<"google-generative-ai", GoogleOptions>;
-	streamSimpleGoogle: StreamFunction<"google-generative-ai", SimpleStreamOptions>;
-}
-
-interface GoogleVertexProviderModule {
-	streamGoogleVertex: StreamFunction<"google-vertex", GoogleVertexOptions>;
-	streamSimpleGoogleVertex: StreamFunction<"google-vertex", SimpleStreamOptions>;
-}
-
-interface MistralProviderModule {
-	streamMistral: StreamFunction<"mistral-conversations", MistralOptions>;
-	streamSimpleMistral: StreamFunction<"mistral-conversations", SimpleStreamOptions>;
-}
-
-interface OpenAICodexResponsesProviderModule {
-	streamOpenAICodexResponses: StreamFunction<"openai-codex-responses", OpenAICodexResponsesOptions>;
-	streamSimpleOpenAICodexResponses: StreamFunction<"openai-codex-responses", SimpleStreamOptions>;
-}
-
-interface OpenAICompletionsProviderModule {
-	streamOpenAICompletions: StreamFunction<"openai-completions", OpenAICompletionsOptions>;
-	streamSimpleOpenAICompletions: StreamFunction<"openai-completions", SimpleStreamOptions>;
-}
-
-interface OpenAIResponsesProviderModule {
-	streamOpenAIResponses: StreamFunction<"openai-responses", OpenAIResponsesOptions>;
-	streamSimpleOpenAIResponses: StreamFunction<"openai-responses", SimpleStreamOptions>;
-}
-
-interface BedrockProviderModule {
-	streamBedrock: (
-		model: Model<"bedrock-converse-stream">,
-		context: Context,
-		options?: BedrockOptions,
-	) => AsyncIterable<AssistantMessageEvent>;
-	streamSimpleBedrock: (
-		model: Model<"bedrock-converse-stream">,
-		context: Context,
-		options?: SimpleStreamOptions,
-	) => AsyncIterable<AssistantMessageEvent>;
-}
-
-const importNodeOnlyProvider = (specifier: string): Promise<unknown> => {
-	const runtimeSpecifier = import.meta.url.endsWith(".js") ? specifier.replace(/\.ts$/, ".js") : specifier;
-	return import(runtimeSpecifier);
-};
-
-let anthropicProviderModulePromise:
-	| Promise<LazyProviderModule<"anthropic-messages", AnthropicOptions, SimpleStreamOptions>>
-	| undefined;
-let azureOpenAIResponsesProviderModulePromise:
-	| Promise<LazyProviderModule<"azure-openai-responses", AzureOpenAIResponsesOptions, SimpleStreamOptions>>
-	| undefined;
-let googleProviderModulePromise:
-	| Promise<LazyProviderModule<"google-generative-ai", GoogleOptions, SimpleStreamOptions>>
-	| undefined;
-let googleVertexProviderModulePromise:
-	| Promise<LazyProviderModule<"google-vertex", GoogleVertexOptions, SimpleStreamOptions>>
-	| undefined;
-let mistralProviderModulePromise:
-	| Promise<LazyProviderModule<"mistral-conversations", MistralOptions, SimpleStreamOptions>>
-	| undefined;
-let openAICodexResponsesProviderModulePromise:
-	| Promise<LazyProviderModule<"openai-codex-responses", OpenAICodexResponsesOptions, SimpleStreamOptions>>
-	| undefined;
-let openAICompletionsProviderModulePromise:
-	| Promise<LazyProviderModule<"openai-completions", OpenAICompletionsOptions, SimpleStreamOptions>>
-	| undefined;
-let openAIResponsesProviderModulePromise:
-	| Promise<LazyProviderModule<"openai-responses", OpenAIResponsesOptions, SimpleStreamOptions>>
-	| undefined;
-let bedrockProviderModuleOverride:
-	| LazyProviderModule<"bedrock-converse-stream", BedrockOptions, SimpleStreamOptions>
-	| undefined;
-let bedrockProviderModulePromise:
-	| Promise<LazyProviderModule<"bedrock-converse-stream", BedrockOptions, SimpleStreamOptions>>
-	| undefined;
-
-export function setBedrockProviderModule(module: BedrockProviderModule): void {
-	bedrockProviderModuleOverride = {
-		stream: module.streamBedrock,
-		streamSimple: module.streamSimpleBedrock,
-	};
-}
-
-function forwardStream(target: AssistantMessageEventStream, source: AsyncIterable<AssistantMessageEvent>): void {
-	(async () => {
-		for await (const event of source) {
-			target.push(event);
-		}
-		target.end();
-	})();
-}
-
-function createLazyLoadErrorMessage<TApi extends Api>(model: Model<TApi>, error: unknown): AssistantMessage {
-	return {
-		role: "assistant",
-		content: [],
-		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: "error",
-		errorMessage: error instanceof Error ? error.message : String(error),
-		timestamp: Date.now(),
-	};
-}
-
-function createLazyStream<TApi extends Api, TOptions extends StreamOptions, TSimpleOptions extends SimpleStreamOptions>(
-	loadModule: () => Promise<LazyProviderModule<TApi, TOptions, TSimpleOptions>>,
-): StreamFunction<TApi, TOptions> {
-	return (model, context, options) => {
-		const outer = new AssistantMessageEventStream();
-
-		loadModule()
-			.then((module) => {
-				const inner = module.stream(model, context, options);
-				forwardStream(outer, inner);
-			})
-			.catch((error) => {
-				const message = createLazyLoadErrorMessage(model, error);
-				outer.push({ type: "error", reason: "error", error: message });
-				outer.end(message);
-			});
-
-		return outer;
-	};
-}
-
-function createLazySimpleStream<
-	TApi extends Api,
-	TOptions extends StreamOptions,
-	TSimpleOptions extends SimpleStreamOptions,
->(loadModule: () => Promise<LazyProviderModule<TApi, TOptions, TSimpleOptions>>): StreamFunction<TApi, TSimpleOptions> {
-	return (model, context, options) => {
-		const outer = new AssistantMessageEventStream();
-
-		loadModule()
-			.then((module) => {
-				const inner = module.streamSimple(model, context, options);
-				forwardStream(outer, inner);
-			})
-			.catch((error) => {
-				const message = createLazyLoadErrorMessage(model, error);
-				outer.push({ type: "error", reason: "error", error: message });
-				outer.end(message);
-			});
-
-		return outer;
-	};
-}
-
-function loadAnthropicProviderModule(): Promise<
-	LazyProviderModule<"anthropic-messages", AnthropicOptions, SimpleStreamOptions>
-> {
-	anthropicProviderModulePromise ||= import("./anthropic.ts").then((module) => {
-		const provider = module as AnthropicProviderModule;
-		return {
-			stream: provider.streamAnthropic,
-			streamSimple: provider.streamSimpleAnthropic,
-		};
-	});
-	return anthropicProviderModulePromise;
-}
-
-function loadAzureOpenAIResponsesProviderModule(): Promise<
-	LazyProviderModule<"azure-openai-responses", AzureOpenAIResponsesOptions, SimpleStreamOptions>
-> {
-	azureOpenAIResponsesProviderModulePromise ||= import("./azure-openai-responses.ts").then((module) => {
-		const provider = module as AzureOpenAIResponsesProviderModule;
-		return {
-			stream: provider.streamAzureOpenAIResponses,
-			streamSimple: provider.streamSimpleAzureOpenAIResponses,
-		};
-	});
-	return azureOpenAIResponsesProviderModulePromise;
-}
-
-function loadGoogleProviderModule(): Promise<
-	LazyProviderModule<"google-generative-ai", GoogleOptions, SimpleStreamOptions>
-> {
-	googleProviderModulePromise ||= import("./google.ts").then((module) => {
-		const provider = module as GoogleProviderModule;
-		return {
-			stream: provider.streamGoogle,
-			streamSimple: provider.streamSimpleGoogle,
-		};
-	});
-	return googleProviderModulePromise;
-}
-
-function loadGoogleVertexProviderModule(): Promise<
-	LazyProviderModule<"google-vertex", GoogleVertexOptions, SimpleStreamOptions>
-> {
-	googleVertexProviderModulePromise ||= import("./google-vertex.ts").then((module) => {
-		const provider = module as GoogleVertexProviderModule;
-		return {
-			stream: provider.streamGoogleVertex,
-			streamSimple: provider.streamSimpleGoogleVertex,
-		};
-	});
-	return googleVertexProviderModulePromise;
-}
-
-function loadMistralProviderModule(): Promise<
-	LazyProviderModule<"mistral-conversations", MistralOptions, SimpleStreamOptions>
-> {
-	mistralProviderModulePromise ||= import("./mistral.ts").then((module) => {
-		const provider = module as MistralProviderModule;
-		return {
-			stream: provider.streamMistral,
-			streamSimple: provider.streamSimpleMistral,
-		};
-	});
-	return mistralProviderModulePromise;
-}
-
-function loadOpenAICodexResponsesProviderModule(): Promise<
-	LazyProviderModule<"openai-codex-responses", OpenAICodexResponsesOptions, SimpleStreamOptions>
-> {
-	openAICodexResponsesProviderModulePromise ||= import("./openai-codex-responses.ts").then((module) => {
-		const provider = module as OpenAICodexResponsesProviderModule;
-		return {
-			stream: provider.streamOpenAICodexResponses,
-			streamSimple: provider.streamSimpleOpenAICodexResponses,
-		};
-	});
-	return openAICodexResponsesProviderModulePromise;
-}
-
-function loadOpenAICompletionsProviderModule(): Promise<
-	LazyProviderModule<"openai-completions", OpenAICompletionsOptions, SimpleStreamOptions>
-> {
-	openAICompletionsProviderModulePromise ||= import("./openai-completions.ts").then((module) => {
-		const provider = module as OpenAICompletionsProviderModule;
-		return {
-			stream: provider.streamOpenAICompletions,
-			streamSimple: provider.streamSimpleOpenAICompletions,
-		};
-	});
-	return openAICompletionsProviderModulePromise;
-}
-
-function loadOpenAIResponsesProviderModule(): Promise<
-	LazyProviderModule<"openai-responses", OpenAIResponsesOptions, SimpleStreamOptions>
-> {
-	openAIResponsesProviderModulePromise ||= import("./openai-responses.ts").then((module) => {
-		const provider = module as OpenAIResponsesProviderModule;
-		return {
-			stream: provider.streamOpenAIResponses,
-			streamSimple: provider.streamSimpleOpenAIResponses,
-		};
-	});
-	return openAIResponsesProviderModulePromise;
-}
-
-function loadBedrockProviderModule(): Promise<
-	LazyProviderModule<"bedrock-converse-stream", BedrockOptions, SimpleStreamOptions>
-> {
-	if (bedrockProviderModuleOverride) {
-		return Promise.resolve(bedrockProviderModuleOverride);
-	}
-	bedrockProviderModulePromise ||= importNodeOnlyProvider("./amazon-bedrock.ts").then((module) => {
-		const provider = module as BedrockProviderModule;
-		return {
-			stream: provider.streamBedrock,
-			streamSimple: provider.streamSimpleBedrock,
-		};
-	});
-	return bedrockProviderModulePromise;
-}
-
-export const streamAnthropic = createLazyStream(loadAnthropicProviderModule);
-export const streamSimpleAnthropic = createLazySimpleStream(loadAnthropicProviderModule);
-export const streamAzureOpenAIResponses = createLazyStream(loadAzureOpenAIResponsesProviderModule);
-export const streamSimpleAzureOpenAIResponses = createLazySimpleStream(loadAzureOpenAIResponsesProviderModule);
-export const streamGoogle = createLazyStream(loadGoogleProviderModule);
-export const streamSimpleGoogle = createLazySimpleStream(loadGoogleProviderModule);
-export const streamGoogleVertex = createLazyStream(loadGoogleVertexProviderModule);
-export const streamSimpleGoogleVertex = createLazySimpleStream(loadGoogleVertexProviderModule);
-export const streamMistral = createLazyStream(loadMistralProviderModule);
-export const streamSimpleMistral = createLazySimpleStream(loadMistralProviderModule);
-export const streamOpenAICodexResponses = createLazyStream(loadOpenAICodexResponsesProviderModule);
-export const streamSimpleOpenAICodexResponses = createLazySimpleStream(loadOpenAICodexResponsesProviderModule);
-export const streamOpenAICompletions = createLazyStream(loadOpenAICompletionsProviderModule);
-export const streamSimpleOpenAICompletions = createLazySimpleStream(loadOpenAICompletionsProviderModule);
-export const streamOpenAIResponses = createLazyStream(loadOpenAIResponsesProviderModule);
-export const streamSimpleOpenAIResponses = createLazySimpleStream(loadOpenAIResponsesProviderModule);
-const streamBedrockLazy = createLazyStream(loadBedrockProviderModule);
-const streamSimpleBedrockLazy = createLazySimpleStream(loadBedrockProviderModule);
-
-export function registerBuiltInApiProviders(): void {
-	registerApiProvider({
-		api: "anthropic-messages",
-		stream: streamAnthropic,
-		streamSimple: streamSimpleAnthropic,
-	});
-
-	registerApiProvider({
-		api: "openai-completions",
-		stream: streamOpenAICompletions,
-		streamSimple: streamSimpleOpenAICompletions,
-	});
-
-	registerApiProvider({
-		api: "mistral-conversations",
-		stream: streamMistral,
-		streamSimple: streamSimpleMistral,
-	});
-
-	registerApiProvider({
-		api: "openai-responses",
-		stream: streamOpenAIResponses,
-		streamSimple: streamSimpleOpenAIResponses,
-	});
-
-	registerApiProvider({
-		api: "azure-openai-responses",
-		stream: streamAzureOpenAIResponses,
-		streamSimple: streamSimpleAzureOpenAIResponses,
-	});
-
-	registerApiProvider({
-		api: "openai-codex-responses",
-		stream: streamOpenAICodexResponses,
-		streamSimple: streamSimpleOpenAICodexResponses,
-	});
-
-	registerApiProvider({
-		api: "google-generative-ai",
-		stream: streamGoogle,
-		streamSimple: streamSimpleGoogle,
-	});
-
-	registerApiProvider({
-		api: "google-vertex",
-		stream: streamGoogleVertex,
-		streamSimple: streamSimpleGoogleVertex,
-	});
-
-	registerApiProvider({
-		api: "bedrock-converse-stream",
-		stream: streamBedrockLazy,
-		streamSimple: streamSimpleBedrockLazy,
-	});
-}
-
-export function resetApiProviders(): void {
-	clearApiProviders();
-	registerBuiltInApiProviders();
-}
-
-registerBuiltInApiProviders();

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

@@ -0,0 +1,363 @@
+// This file is auto-generated by scripts/generate-models.ts
+// Do not edit manually - run 'npm run generate-models' to update
+
+import type { Model } from "../types.ts";
+
+export const TOGETHER_MODELS = {
+	"MiniMaxAI/MiniMax-M2.7": {
+		id: "MiniMaxAI/MiniMax-M2.7",
+		name: "MiniMax-M2.7",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null,"low":null,"medium":null},
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0,
+		},
+		contextWindow: 202752,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"MiniMaxAI/MiniMax-M3": {
+		id: "MiniMaxAI/MiniMax-M3",
+		name: "MiniMax-M3",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.3,
+			output: 1.2,
+			cacheRead: 0.06,
+			cacheWrite: 0,
+		},
+		contextWindow: 524288,
+		maxTokens: 250000,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen2.5-7B-Instruct-Turbo": {
+		id: "Qwen/Qwen2.5-7B-Instruct-Turbo",
+		name: "Qwen 2.5 7B Instruct Turbo",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.3,
+			output: 0.3,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 32768,
+		maxTokens: 32768,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3-235B-A22B-Instruct-2507-tput": {
+		id: "Qwen/Qwen3-235B-A22B-Instruct-2507-tput",
+		name: "Qwen3 235B A22B Instruct 2507 FP8",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.2,
+			output: 0.6,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 262144,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3.5-397B-A17B": {
+		id: "Qwen/Qwen3.5-397B-A17B",
+		name: "Qwen3.5 397B A17B",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.6,
+			output: 3.6,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 130000,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3.5-9B": {
+		id: "Qwen/Qwen3.5-9B",
+		name: "Qwen3.5 9B",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.17,
+			output: 0.25,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 65536,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3.6-Plus": {
+		id: "Qwen/Qwen3.6-Plus",
+		name: "Qwen3.6 Plus",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text"],
+		cost: {
+			input: 0.5,
+			output: 3,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 500000,
+	} satisfies Model<"openai-completions">,
+	"Qwen/Qwen3.7-Max": {
+		id: "Qwen/Qwen3.7-Max",
+		name: "Qwen3.7 Max",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 1.25,
+			output: 3.75,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 1000000,
+		maxTokens: 500000,
+	} satisfies Model<"openai-completions">,
+	"deepseek-ai/DeepSeek-V4-Pro": {
+		id: "deepseek-ai/DeepSeek-V4-Pro",
+		name: "DeepSeek V4 Pro",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":true,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null,"high":"high","xhigh":null},
+		input: ["text"],
+		cost: {
+			input: 1.74,
+			output: 3.48,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 512000,
+		maxTokens: 384000,
+	} satisfies Model<"openai-completions">,
+	"essentialai/Rnj-1-Instruct": {
+		id: "essentialai/Rnj-1-Instruct",
+		name: "Rnj-1 Instruct",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.15,
+			output: 0.15,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 32768,
+		maxTokens: 32768,
+	} satisfies Model<"openai-completions">,
+	"google/gemma-4-31B-it": {
+		id: "google/gemma-4-31B-it",
+		name: "Gemma 4 31B Instruct",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text", "image"],
+		cost: {
+			input: 0.39,
+			output: 0.97,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"meta-llama/Llama-3.3-70B-Instruct-Turbo": {
+		id: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
+		name: "Llama 3.3 70B",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false},
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0.88,
+			output: 0.88,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"moonshotai/Kimi-K2.6": {
+		id: "moonshotai/Kimi-K2.6",
+		name: "Kimi K2.6",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text", "image"],
+		cost: {
+			input: 1.2,
+			output: 4.5,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 131000,
+	} satisfies Model<"openai-completions">,
+	"moonshotai/Kimi-K2.7-Code": {
+		id: "moonshotai/Kimi-K2.7-Code",
+		name: "Kimi K2.7 Code",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text"],
+		cost: {
+			input: 0.95,
+			output: 4,
+			cacheRead: 0.19,
+			cacheWrite: 0,
+		},
+		contextWindow: 262144,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"nvidia/nemotron-3-ultra-550b-a55b": {
+		id: "nvidia/nemotron-3-ultra-550b-a55b",
+		name: "Nemotron 3 Ultra 550B A55B",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text"],
+		cost: {
+			input: 0.6,
+			output: 3.6,
+			cacheRead: 0.2,
+			cacheWrite: 0,
+		},
+		contextWindow: 512300,
+		maxTokens: 512300,
+	} satisfies Model<"openai-completions">,
+	"openai/gpt-oss-120b": {
+		id: "openai/gpt-oss-120b",
+		name: "GPT OSS 120B",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":true,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"openai"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null},
+		input: ["text"],
+		cost: {
+			input: 0.15,
+			output: 0.6,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"openai/gpt-oss-20b": {
+		id: "openai/gpt-oss-20b",
+		name: "GPT OSS 20B",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":true,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"openai"},
+		reasoning: true,
+		thinkingLevelMap: {"off":null,"minimal":null},
+		input: ["text"],
+		cost: {
+			input: 0.05,
+			output: 0.2,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 131072,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"zai-org/GLM-5": {
+		id: "zai-org/GLM-5",
+		name: "GLM-5",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text"],
+		cost: {
+			input: 1,
+			output: 3.2,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 202752,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+	"zai-org/GLM-5.1": {
+		id: "zai-org/GLM-5.1",
+		name: "GLM-5.1",
+		api: "openai-completions",
+		provider: "together",
+		baseUrl: "https://api.together.ai/v1",
+		compat: {"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","supportsStrictMode":false,"supportsLongCacheRetention":false,"thinkingFormat":"together"},
+		reasoning: true,
+		thinkingLevelMap: {"minimal":null,"low":null,"medium":null},
+		input: ["text"],
+		cost: {
+			input: 1.4,
+			output: 4.4,
+			cacheRead: 0,
+			cacheWrite: 0,
+		},
+		contextWindow: 202752,
+		maxTokens: 131072,
+	} satisfies Model<"openai-completions">,
+} as const;

packages/ai/src/providers/together.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 { TOGETHER_MODELS } from "./together.models.ts";
+
+export function togetherProvider(): Provider<"openai-completions"> {
+	return createProvider({
+		id: "together",
+		name: "Together",
+		baseUrl: "https://api.together.ai/v1",
+		auth: { apiKey: envApiKeyAuth("Together API key", ["TOGETHER_API_KEY"]) },
+		models: Object.values(TOGETHER_MODELS),
+		api: openAICompletionsApi(),
+	});
+}

packages/ai/src/providers/vercel-ai-gateway.ts

@@ -0,0 +1,15 @@
+import { anthropicMessagesApi } from "../api/anthropic-messages.lazy.ts";
+import { envApiKeyAuth } from "../auth/helpers.ts";
+import { createProvider, type Provider } from "../models.ts";
+import { VERCEL_AI_GATEWAY_MODELS } from "./vercel-ai-gateway.models.ts";
+
+export function vercelAIGatewayProvider(): Provider<"anthropic-messages"> {
+	return createProvider({
+		id: "vercel-ai-gateway",
+		name: "Vercel AI Gateway",
+		baseUrl: "https://ai-gateway.vercel.sh",
+		auth: { apiKey: envApiKeyAuth("Vercel AI Gateway API key", ["AI_GATEWAY_API_KEY"]) },
+		models: Object.values(VERCEL_AI_GATEWAY_MODELS),
+		api: anthropicMessagesApi(),
+	});
+}