@codeworksh/aikit 0.3.0 → 0.3.1

package/index.mjs

@@ -6,15 +6,33 @@ import addFormats from "ajv-formats";
 import { uuidv7 } from "uuidv7";
 import Anthropic from "@anthropic-ai/sdk";
 import { parse } from "partial-json";
+import OpenAI from "openai";
 import { transform } from "esbuild";
 //#region src/provider/provider.ts
 let Provider;
 (function(_Provider) {
 	const KnownProviderEnum = _Provider.KnownProviderEnum = {
 		anthropic: "anthropic",
-		openai: "openai"
+		openai: "openai",
+		githubCopilot: "github-copilot",
+		openrouter: "openrouter",
+		groq: "groq",
+		xai: "xai",
+		cerebras: "cerebras",
+		zai: "zai",
+		opencode: "opencode"
 	};
-	const KnownProviderSchema = _Provider.KnownProviderSchema = Type.Union([Type.Literal(KnownProviderEnum.anthropic), Type.Literal(KnownProviderEnum.openai)]);
+	const KnownProviderSchema = _Provider.KnownProviderSchema = Type.Union([
+		Type.Literal(KnownProviderEnum.anthropic),
+		Type.Literal(KnownProviderEnum.openai),
+		Type.Literal(KnownProviderEnum.githubCopilot),
+		Type.Literal(KnownProviderEnum.openrouter),
+		Type.Literal(KnownProviderEnum.groq),
+		Type.Literal(KnownProviderEnum.xai),
+		Type.Literal(KnownProviderEnum.cerebras),
+		Type.Literal(KnownProviderEnum.zai),
+		Type.Literal(KnownProviderEnum.opencode)
+	]);
 	_Provider.Info = Type.Object({
 		id: KnownProviderSchema,
 		name: Type.String(),
@@ -76,6 +94,46 @@ let ModelCatalog;
 	}, 60 * 1e3 * 60).unref();
 })(ModelCatalog || (ModelCatalog = {}));
 //#endregion
+//#region src/model/transform.ts
+function defaultBaseUrl(providerId) {
+	switch (providerId) {
+		case Provider.KnownProviderEnum.openai: return "https://api.openai.com/v1";
+		default: return;
+	}
+}
+function resolveDefaultProtocol(providerId) {
+	switch (providerId) {
+		case Provider.KnownProviderEnum.anthropic: return Model.KnownProtocolEnum.anthropicMessages;
+		case Provider.KnownProviderEnum.openai: return Model.KnownProtocolEnum.openaiResponses;
+		default: return Model.KnownProtocolEnum.openaiCompletions;
+	}
+}
+function applyModification(providerId, provider, model) {
+	const baseUrl = model.baseUrl ?? provider.baseUrl ?? provider.api ?? defaultBaseUrl(providerId);
+	const normalized = {
+		id: model.id,
+		name: model.name,
+		provider: Model.toProviderInfo(providerId, provider),
+		baseUrl,
+		reasoning: Boolean(model.reasoning),
+		input: Model.normalizeInput(model.modalities.input),
+		cost: {
+			input: model.cost?.input ?? 0,
+			output: model.cost?.output ?? 0,
+			cacheRead: model.cost?.cache_read ?? 0,
+			cacheWrite: model.cost?.cache_write ?? 0
+		},
+		contextWindow: model.limit?.context ?? 0,
+		maxTokens: model.limit?.output ?? 0,
+		headers: model.headers ?? provider.headers,
+		protocol: resolveDefaultProtocol(providerId)
+	};
+	if (providerId === Provider.KnownProviderEnum.openai) {
+		normalized.supportedProtocols = { openaiCompletions: Model.KnownProtocolEnum.openaiCompletions };
+		return normalized;
+	} else return normalized;
+}
+//#endregion
 //#region src/model/model.ts
 let Model;
 (function(_Model) {
@@ -97,6 +155,11 @@ let Model;
 		cacheWrite: Type.Number()
 	});
 	const HeadersSchema = Type.Optional(Type.Record(Type.String(), Type.String()));
+	const SupportedProtocolsSchema = _Model.SupportedProtocolsSchema = Type.Object({
+		anthropicMessages: Type.Optional(Type.Literal(KnownProtocolEnum.anthropicMessages)),
+		openaiCompletions: Type.Optional(Type.Literal(KnownProtocolEnum.openaiCompletions)),
+		openaiResponses: Type.Optional(Type.Literal(KnownProtocolEnum.openaiResponses))
+	});
 	const BaseSchema = _Model.BaseSchema = Type.Object({
 		id: Type.String(),
 		name: Type.String(),
@@ -107,7 +170,8 @@ let Model;
 		cost: CostSchema,
 		contextWindow: Type.Number(),
 		maxTokens: Type.Number(),
-		headers: HeadersSchema
+		headers: HeadersSchema,
+		supportedProtocols: Type.Optional(Type.Partial(SupportedProtocolsSchema))
 	});
 	const OpenAICompletionsCompatSchema = _Model.OpenAICompletionsCompatSchema = Type.Object({
 		supportsStore: Type.Optional(Type.Boolean()),
@@ -128,6 +192,7 @@ let Model;
 		])),
 		openRouterRouting: Type.Optional(Provider.OpenRouterRoutingSchema),
 		vercelGatewayRouting: Type.Optional(Provider.VercelGatewayRoutingSchema),
+		zaiToolStream: Type.Optional(Type.Boolean()),
 		supportsStrictMode: Type.Optional(Type.Boolean())
 	});
 	const OpenAIResponsesCompatSchema = _Model.OpenAIResponsesCompatSchema = Type.Object({});
@@ -141,7 +206,7 @@ let Model;
 		protocol: Type.Literal(KnownProtocolEnum.openaiResponses),
 		compat: Type.Optional(OpenAIResponsesCompatSchema)
 	})]);
-	_Model.Schema = Type.Union([
+	_Model.Info = Type.Union([
 		AnthropicSchema,
 		OpenAICompletionsSchema,
 		OpenAIResponsesSchema
@@ -155,18 +220,13 @@ let Model;
 		usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
 	}
 	_Model.calculateCost = calculateCost;
-	function resolveProtocol(providerId) {
-		switch (providerId) {
-			case Provider.KnownProviderEnum.anthropic: return KnownProtocolEnum.anthropicMessages;
-			case Provider.KnownProviderEnum.openai: return KnownProtocolEnum.openaiResponses;
-		}
-	}
 	function normalizeInput(input) {
 		const normalized = /* @__PURE__ */ new Set();
 		for (const modality of input ?? ["text"]) if (modality === "text" || modality === "image") normalized.add(modality);
 		if (normalized.size === 0) normalized.add("text");
 		return [...normalized];
 	}
+	_Model.normalizeInput = normalizeInput;
 	function toProviderInfo(providerId, provider) {
 		return {
 			id: providerId,
@@ -176,26 +236,9 @@ let Model;
 			options: provider.headers
 		};
 	}
+	_Model.toProviderInfo = toProviderInfo;
 	function toModelValue(providerId, provider, model) {
-		const baseUrl = model.baseUrl ?? provider.baseUrl ?? provider.api;
-		return {
-			id: model.id,
-			name: model.name,
-			provider: toProviderInfo(providerId, provider),
-			baseUrl,
-			reasoning: Boolean(model.reasoning),
-			input: normalizeInput(model.modalities.input),
-			cost: {
-				input: model.cost?.input ?? 0,
-				output: model.cost?.output ?? 0,
-				cacheRead: model.cost?.cache_read ?? 0,
-				cacheWrite: model.cost?.cache_write ?? 0
-			},
-			contextWindow: model.limit?.context ?? 0,
-			maxTokens: model.limit?.output ?? 0,
-			headers: model.headers ?? provider.headers,
-			protocol: resolveProtocol(providerId)
-		};
+		return applyModification(providerId, provider, model);
 	}
 	async function getBuiltInModels() {
 		return pipe(await ModelCatalog.get(), pick(BUILTINS), mapValues((provider, providerId) => mapValues(provider.models, (model) => toModelValue(providerId, provider, model))));
@@ -211,8 +254,13 @@ let Model;
 		}
 		return registry;
 	});
-	async function getModel(provider, model) {
-		return (await registry()).get(provider)?.get(model);
+	async function getModel(provider, model, overrides) {
+		const result = (await registry()).get(provider)?.get(model);
+		if (result && overrides) return {
+			...result,
+			...overrides
+		};
+		return result;
 	}
 	_Model.getModel = getModel;
 	async function getProviders() {
@@ -1296,8 +1344,10 @@ function sanitizeSurrogates(text) {
 	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
 }
 //#endregion
-//#region src/provider/providers/anthropic/index.ts
+//#region src/provider/providers/utils.ts
 function getEnvApiKey(_provider) {}
+//#endregion
+//#region src/provider/providers/anthropic/index.ts
 function resolveCacheRetention(cacheRetention) {
 	if (cacheRetention) return cacheRetention;
 	if (typeof process !== "undefined" && process.env.CODEWORK_CACHE_RETENTION === "long") return "long";
@@ -1374,7 +1424,7 @@ function mergeHeaders(...headerSources) {
 function isOAuthToken(apiKey) {
 	return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, optionsHeaders) {
+function createClient$1(model, apiKey, interleavedThinking, optionsHeaders) {
 	const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
 	if (interleavedThinking) betaFeatures.push("interleaved-thinking-2025-05-14");
 	if (isOAuthToken(apiKey)) {
@@ -1432,7 +1482,7 @@ function assertReplayableAssistant(message) {
 	if (!sawToolCall && message.stopReason === "toolUse") throw new Error("Assistant message with stopReason 'toolUse' must contain at least one toolCall");
 	if (sawTerminalToolCall && sawNonTerminalToolCall) throw new Error("Assistant message cannot mix terminal and non-terminal toolCall states");
 }
-function buildSyntheticToolResult(block) {
+function buildSyntheticToolResult$1(block) {
 	return {
 		type: "tool_result",
 		tool_use_id: block.callID,
@@ -1447,7 +1497,7 @@ function buildSyntheticToolResult(block) {
 		is_error: true
 	};
 }
-function convertMessages(messages, model, isOAuthToken, cacheControl) {
+function convertMessages$1(messages, model, isOAuthToken, cacheControl) {
 	const params = [];
 	const transformedMessages = Message.transformMessages(messages, model, normalizeToolCallId);
 	for (const msg of transformedMessages) {
@@ -1503,7 +1553,7 @@ function convertMessages(messages, model, isOAuthToken, cacheControl) {
 				name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
 				input: block.arguments ?? {}
 			});
-			if (block.status === "pending" || block.status === "running") toolResults.push(buildSyntheticToolResult(block));
+			if (block.status === "pending" || block.status === "running") toolResults.push(buildSyntheticToolResult$1(block));
 			else toolResults.push({
 				type: "tool_result",
 				tool_use_id: block.callID,
@@ -1535,7 +1585,7 @@ function convertMessages(messages, model, isOAuthToken, cacheControl) {
 	}
 	return params;
 }
-function convertTools(tools, isOAuthToken) {
+function convertTools$1(tools, isOAuthToken) {
 	if (!tools) return [];
 	return tools.map((tool) => {
 		const jsonSchema = tool.parameters;
@@ -1550,7 +1600,7 @@ function convertTools(tools, isOAuthToken) {
 		};
 	});
 }
-function mapStopReason(reason) {
+function mapStopReason$1(reason) {
 	switch (reason) {
 		case "end_turn": return "stop";
 		case "max_tokens": return "length";
@@ -1562,11 +1612,11 @@ function mapStopReason(reason) {
 		default: throw new Error("Unhandled Anthropic stop reason");
 	}
 }
-function buildParams(model, context, isOAuthToken, options) {
+function buildParams$1(model, context, isOAuthToken, options) {
 	const { cacheControl } = getCacheControl(model.baseUrl, options?.cacheRetention);
 	const params = {
 		model: model.id,
-		messages: convertMessages(context.messages, model, isOAuthToken, cacheControl),
+		messages: convertMessages$1(context.messages, model, isOAuthToken, cacheControl),
 		max_tokens: options?.maxTokens || model.maxTokens / 3 | 0,
 		stream: true
 	};
@@ -1587,7 +1637,7 @@ function buildParams(model, context, isOAuthToken, options) {
 		...cacheControl ? { cache_control: cacheControl } : {}
 	}];
 	if (options?.temperature !== void 0 && !options?.thinkingEnabled) params.temperature = options.temperature;
-	if (context.tools) params.tools = convertTools(context.tools, isOAuthToken);
+	if (context.tools) params.tools = convertTools$1(context.tools, isOAuthToken);
 	if (options?.thinkingEnabled && model.reasoning) params.thinking = {
 		type: "enabled",
 		budget_tokens: options.thinkingBudgetTokens || 1024
@@ -1635,13 +1685,13 @@ const streamAnthropic = (model, context, options) => {
 				client = options.client;
 				isOAuthToken = false;
 			} else {
-				const apiKey = options?.apiKey ?? getEnvApiKey(model.provider);
+				const apiKey = options?.apiKey ?? /* @__PURE__ */ getEnvApiKey(model.provider);
 				if (!apiKey) throw new Error(`No API key for provider: ${model.provider.id}`);
-				const created = createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers);
+				const created = createClient$1(model, apiKey, options?.interleavedThinking ?? true, options?.headers);
 				client = created.client;
 				isOAuthToken = created.isOAuthToken;
 			}
-			let params = buildParams(model, context, isOAuthToken, options);
+			let params = buildParams$1(model, context, isOAuthToken, options);
 			const nextParams = await options?.onPayload?.(params, model);
 			if (nextParams !== void 0) params = nextParams;
 			const anthropicStream = client.messages.stream({
@@ -1784,7 +1834,7 @@ const streamAnthropic = (model, context, options) => {
 					}
 				}
 			} else if (event.type === "message_delta") {
-				if (event.delta.stop_reason) output.stopReason = mapStopReason(event.delta.stop_reason);
+				if (event.delta.stop_reason) output.stopReason = mapStopReason$1(event.delta.stop_reason);
 				if (event.usage.input_tokens != null) output.usage.input = event.usage.input_tokens;
 				if (event.usage.output_tokens != null) output.usage.output = event.usage.output_tokens;
 				if (event.usage.cache_read_input_tokens != null) output.usage.cacheRead = event.usage.cache_read_input_tokens;
@@ -1817,7 +1867,7 @@ const streamAnthropic = (model, context, options) => {
 	return stream;
 };
 const streamSimpleAnthropic = (model, context, options) => {
-	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+	const apiKey = options?.apiKey || /* @__PURE__ */ getEnvApiKey(model.provider);
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider.id}`);
 	const base = Stream.buildBaseOptions(model, options, apiKey);
 	if (!options?.reasoning) return streamAnthropic(model, context, {
@@ -1832,14 +1882,651 @@ const streamSimpleAnthropic = (model, context, options) => {
 		thinkingBudgetTokens: adjusted.thinkingBudget
 	});
 };
-//#endregion
-//#region src/provider/register.ts
-const providerModules = [["providers/anthropic/index.ts", {
+const anthropicProtocolProvider = {
 	protocol: Model.KnownProtocolEnum.anthropicMessages,
 	stream: streamAnthropic,
 	streamSimple: streamSimpleAnthropic
-}]];
-for (const [path, provider] of providerModules) Stream.registerProtocolProvider(provider, path);
+};
+//#endregion
+//#region src/provider/providers/github/github.ts
+function inferCopilotInitiator(messages) {
+	const last = messages[messages.length - 1];
+	return last && last.role !== "user" ? "agent" : "user";
+}
+function hasCopilotVisionInput(messages) {
+	return messages.some((msg) => {
+		if (msg.role === "user") return msg.parts.some((c) => c.type === "image");
+		return false;
+	});
+}
+function buildCopilotDynamicHeaders(params) {
+	const headers = {
+		"X-Initiator": inferCopilotInitiator(params.messages),
+		"Openai-Intent": "conversation-edits"
+	};
+	if (params.hasImages) headers["Copilot-Vision-Request"] = "true";
+	return headers;
+}
+//#endregion
+//#region src/provider/providers/openai/completions.ts
+function hasToolHistory(messages) {
+	for (const msg of messages) {
+		if (msg.role !== "assistant") continue;
+		if (msg.parts.some((block) => block.type === "toolCall")) return true;
+	}
+	return false;
+}
+function buildSyntheticToolResult(block, compat) {
+	const message = {
+		role: "tool",
+		content: [
+			"<result>",
+			"No Result Provided",
+			"</result>"
+		].join("\n"),
+		tool_call_id: block.callID
+	};
+	if (compat.requiresToolResultName) message.name = block.name;
+	return message;
+}
+function resolveBaseUrl(model) {
+	return model.baseUrl || (model.provider.id === Provider.KnownProviderEnum.openai ? "https://api.openai.com/v1" : "");
+}
+const streamOpenAICompletions = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const output = Message.createAssistantMessage({
+			role: "assistant",
+			parts: [],
+			protocol: model.protocol,
+			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",
+			time: {
+				created: Date.now(),
+				completed: Date.now()
+			}
+		});
+		try {
+			const client = createClient(model, context, options?.apiKey || /* @__PURE__ */ getEnvApiKey(model.provider) || "", options?.headers);
+			let params = buildParams(model, context, options);
+			const nextParams = await options?.onPayload?.(params, model);
+			if (nextParams !== void 0) params = nextParams;
+			const openaiStream = await client.chat.completions.create(params, { signal: options?.signal });
+			stream.push({
+				type: "start",
+				partial: output
+			});
+			let currentBlock = null;
+			const blocks = output.parts;
+			const activeToolCalls = /* @__PURE__ */ new Map();
+			const finishCurrentBlock = (block) => {
+				if (block) {
+					const partIndex = block.index ?? blocks.indexOf(block);
+					delete block.index;
+					if (block.type === "text") stream.push({
+						type: "text.end",
+						partIndex,
+						content: block.text,
+						partial: output
+					});
+					else if (block.type === "thinking") stream.push({
+						type: "thinking.end",
+						partIndex,
+						content: block.thinking,
+						partial: output
+					});
+					else if (block.type === "toolCall") {
+						if (block.streamIndex !== void 0) activeToolCalls.delete(block.streamIndex);
+						block.arguments = parseStreamingJson(block.partialArgs);
+						delete block.partialArgs;
+						delete block.streamIndex;
+						stream.push({
+							type: "toolcall.end",
+							partIndex,
+							toolCall: block,
+							partial: output
+						});
+					}
+				}
+			};
+			const flushActiveToolCalls = () => {
+				for (const toolBlock of [...activeToolCalls.values()].sort((a, b) => (a.index ?? 0) - (b.index ?? 0))) finishCurrentBlock(toolBlock);
+			};
+			for await (const chunk of openaiStream) {
+				if (!chunk || typeof chunk !== "object") continue;
+				output.responseId ||= chunk.id;
+				if (chunk.usage) output.usage = parseChunkUsage(chunk.usage, model);
+				const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : void 0;
+				if (!choice) continue;
+				const choiceWithUsage = choice;
+				if (!chunk.usage && choiceWithUsage.usage) output.usage = parseChunkUsage(choiceWithUsage.usage, model);
+				if (choice.finish_reason) {
+					const finishReasonResult = mapStopReason(choice.finish_reason);
+					output.stopReason = finishReasonResult.stopReason;
+					if (finishReasonResult.errorMessage) output.errorMessage = finishReasonResult.errorMessage;
+				}
+				if (!choice.delta) continue;
+				if (choice.delta.content !== null && choice.delta.content !== void 0 && choice.delta.content.length > 0) {
+					if (activeToolCalls.size > 0) flushActiveToolCalls();
+					if (!currentBlock || currentBlock.type !== "text") {
+						finishCurrentBlock(currentBlock);
+						currentBlock = {
+							type: "text",
+							text: "",
+							index: output.parts.length
+						};
+						output.parts.push(currentBlock);
+						stream.push({
+							type: "text.start",
+							partIndex: currentBlock.index,
+							partial: output
+						});
+					}
+					if (currentBlock.type === "text") {
+						currentBlock.text += choice.delta.content;
+						stream.push({
+							type: "text.delta",
+							partIndex: currentBlock.index,
+							delta: choice.delta.content,
+							partial: output
+						});
+					}
+				}
+				const reasoningFields = [
+					"reasoning_content",
+					"reasoning",
+					"reasoning_text"
+				];
+				let foundReasoningField = null;
+				for (const field of reasoningFields) {
+					const value = choice.delta[field];
+					if (typeof value === "string" && value.length > 0) {
+						foundReasoningField = field;
+						break;
+					}
+				}
+				if (foundReasoningField) {
+					if (activeToolCalls.size > 0) flushActiveToolCalls();
+					if (!currentBlock || currentBlock.type !== "thinking") {
+						finishCurrentBlock(currentBlock);
+						currentBlock = {
+							type: "thinking",
+							thinking: "",
+							thinkingSignature: foundReasoningField,
+							index: output.parts.length
+						};
+						output.parts.push(currentBlock);
+						stream.push({
+							type: "thinking.start",
+							partIndex: currentBlock.index,
+							partial: output
+						});
+					}
+					if (currentBlock.type === "thinking") {
+						const delta = choice.delta[foundReasoningField];
+						if (typeof delta === "string") {
+							currentBlock.thinking += delta;
+							stream.push({
+								type: "thinking.delta",
+								partIndex: currentBlock.index,
+								delta,
+								partial: output
+							});
+						}
+					}
+				}
+				if (choice.delta.tool_calls) {
+					if (currentBlock) {
+						finishCurrentBlock(currentBlock);
+						currentBlock = null;
+					}
+					for (const toolCall of choice.delta.tool_calls) {
+						const streamIndex = toolCall.index ?? activeToolCalls.size;
+						let toolBlock = activeToolCalls.get(streamIndex);
+						if (!toolBlock) {
+							toolBlock = {
+								type: "toolCall",
+								callID: toolCall.id || "",
+								name: toolCall.function?.name || "",
+								arguments: {},
+								partialArgs: "",
+								index: output.parts.length,
+								streamIndex,
+								status: "pending",
+								time: {
+									start: Date.now(),
+									end: Date.now()
+								}
+							};
+							activeToolCalls.set(streamIndex, toolBlock);
+							output.parts.push(toolBlock);
+							stream.push({
+								type: "toolcall.start",
+								partIndex: toolBlock.index,
+								partial: output
+							});
+						}
+						if (toolCall.id) toolBlock.callID = toolCall.id;
+						if (toolCall.function?.name) toolBlock.name = toolCall.function.name;
+						let delta = "";
+						if (toolCall.function?.arguments) {
+							delta = toolCall.function.arguments;
+							toolBlock.partialArgs = (toolBlock.partialArgs || "") + delta;
+							toolBlock.arguments = parseStreamingJson(toolBlock.partialArgs);
+						}
+						toolBlock.time.end = Date.now();
+						stream.push({
+							type: "toolcall.delta",
+							partIndex: toolBlock.index,
+							delta,
+							partial: output
+						});
+					}
+				}
+				const reasoningDetails = choice.delta.reasoning_details;
+				if (reasoningDetails && Array.isArray(reasoningDetails)) {
+					for (const detail of reasoningDetails) if (detail.type === "reasoning.encrypted" && typeof detail.id === "string" && detail.data !== void 0) {
+						const matchingToolCall = output.parts.find((block) => block.type === "toolCall" && block.callID === detail.id);
+						if (matchingToolCall) matchingToolCall.thoughtSignature = JSON.stringify(detail);
+					}
+				}
+			}
+			finishCurrentBlock(currentBlock);
+			flushActiveToolCalls();
+			if (options?.signal?.aborted) throw new Error("Request was aborted");
+			if (output.stopReason === "aborted") throw new Error("Request was aborted");
+			if (output.stopReason === "error") throw new Error(output.errorMessage || "Provider returned an error stop reason");
+			output.time.completed = Date.now();
+			stream.push({
+				type: "done",
+				reason: output.stopReason,
+				message: output
+			});
+			stream.end();
+		} catch (error) {
+			for (const block of output.parts) {
+				delete block.index;
+				delete block.partialArgs;
+				delete block.streamIndex;
+			}
+			output.time.completed = Date.now();
+			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+			output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+			const rawMetadata = error?.error?.metadata?.raw;
+			if (rawMetadata) output.errorMessage += `\n${rawMetadata}`;
+			stream.push({
+				type: "error",
+				reason: output.stopReason,
+				error: output
+			});
+			stream.end();
+		}
+	})();
+	return stream;
+};
+const streamSimpleOpenAICompletions = (model, context, options) => {
+	const apiKey = options?.apiKey || /* @__PURE__ */ getEnvApiKey(model.provider);
+	if (!apiKey) throw new Error(`No API key for provider: ${model.provider.id}`);
+	const base = Stream.buildBaseOptions(model, options, apiKey);
+	const simpleReasoning = Model.supportsXhigh(model) ? options?.reasoning : Stream.clampReasoning(options?.reasoning);
+	const reasoningEffort = simpleReasoning && simpleReasoning !== Stream.ThinkingLevelEnum.off ? simpleReasoning : void 0;
+	const toolChoice = options?.toolChoice;
+	return streamOpenAICompletions(model, context, {
+		...base,
+		reasoningEffort,
+		toolChoice
+	});
+};
+function buildParams(model, context, options) {
+	const compat = getCompat(model);
+	const messages = convertMessages(model, context, compat);
+	maybeAddOpenRouterAnthropicCacheControl(model, messages);
+	const baseUrl = resolveBaseUrl(model);
+	const params = {
+		model: model.id,
+		messages,
+		stream: true
+	};
+	if (compat.supportsUsageInStreaming !== false) params.stream_options = { include_usage: true };
+	if (compat.supportsStore) params.store = false;
+	if (options?.maxTokens) if (compat.maxTokensField === "max_tokens") params.max_tokens = options.maxTokens;
+	else params.max_completion_tokens = options.maxTokens;
+	if (options?.temperature !== void 0) params.temperature = options.temperature;
+	if (context.tools) {
+		params.tools = convertTools(context.tools, compat);
+		if (compat.zaiToolStream) params.tool_stream = true;
+	} else if (hasToolHistory(context.messages)) params.tools = [];
+	if (options?.toolChoice) params.tool_choice = options.toolChoice;
+	if ((compat.thinkingFormat === "zai" || compat.thinkingFormat === "qwen") && model.reasoning) params.enable_thinking = !!options?.reasoningEffort;
+	else if (compat.thinkingFormat === "qwen-chat-template" && model.reasoning) params.chat_template_kwargs = { enable_thinking: !!options?.reasoningEffort };
+	else if (compat.thinkingFormat === "openrouter" && model.reasoning) {
+		const openRouterParams = params;
+		if (options?.reasoningEffort) openRouterParams.reasoning = { effort: mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap) };
+		else openRouterParams.reasoning = { effort: "none" };
+	} else if (options?.reasoningEffort && model.reasoning && compat.supportsReasoningEffort) params.reasoning_effort = mapReasoningEffort(options.reasoningEffort, compat.reasoningEffortMap);
+	if (baseUrl.includes("openrouter.ai") && model.compat?.openRouterRouting) params.provider = model.compat.openRouterRouting;
+	if (baseUrl.includes("ai-gateway.vercel.sh") && model.compat?.vercelGatewayRouting) {
+		const routing = model.compat.vercelGatewayRouting;
+		if (routing.only || routing.order) {
+			const gatewayOptions = {};
+			if (routing.only) gatewayOptions.only = routing.only;
+			if (routing.order) gatewayOptions.order = routing.order;
+			params.providerOptions = { gateway: gatewayOptions };
+		}
+	}
+	return params;
+}
+function createClient(model, context, apiKey, optsHeaders) {
+	const baseUrl = resolveBaseUrl(model);
+	if (!apiKey) {
+		if (!process.env.OPENAI_API_KEY) throw new Error("OpenAI API key is required. set OPENAI_API_KEY environment variable or pass it as an argument");
+		apiKey = process.env.OPENAI_API_KEY;
+	}
+	const headers = { ...model.headers };
+	if (model.provider.id === Provider.KnownProviderEnum.githubCopilot) {
+		const hasImages = hasCopilotVisionInput(context.messages);
+		const copilotHeaders = buildCopilotDynamicHeaders({
+			messages: context.messages,
+			hasImages
+		});
+		Object.assign(headers, copilotHeaders);
+	}
+	if (optsHeaders) Object.assign(headers, optsHeaders);
+	return new OpenAI({
+		apiKey,
+		baseURL: baseUrl,
+		dangerouslyAllowBrowser: true,
+		defaultHeaders: headers
+	});
+}
+function mapReasoningEffort(effort, reasoningEffortMap) {
+	return reasoningEffortMap[effort] ?? effort;
+}
+function maybeAddOpenRouterAnthropicCacheControl(model, messages) {
+	if (model.provider.id !== Provider.KnownProviderEnum.openrouter || !model.id.startsWith("anthropic/")) return;
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (!msg) continue;
+		if (msg.role !== "user" && msg.role !== "assistant") continue;
+		const content = msg.content;
+		if (typeof content === "string") {
+			msg.content = [Object.assign({
+				type: "text",
+				text: content
+			}, { cache_control: { type: "ephemeral" } })];
+			return;
+		}
+		if (!Array.isArray(content)) continue;
+		for (let j = content.length - 1; j >= 0; j--) {
+			const part = content[j];
+			if (part?.type === "text") {
+				Object.assign(part, { cache_control: { type: "ephemeral" } });
+				return;
+			}
+		}
+	}
+}
+function convertMessages(model, context, compat) {
+	const params = [];
+	const normalizeToolCallId = (id) => {
+		if (id.includes("|")) return (id.split("|")[0] ?? id).replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
+		if (model.provider.id === Provider.KnownProviderEnum.openai) return id.length > 40 ? id.slice(0, 40) : id;
+		return id;
+	};
+	const transformedMessages = Message.transformMessages(context.messages, model, normalizeToolCallId);
+	if (context.systemPrompt) {
+		const role = model.reasoning && compat.supportsDeveloperRole ? "developer" : "system";
+		params.push({
+			role,
+			content: sanitizeSurrogates(context.systemPrompt)
+		});
+	}
+	let lastRole = null;
+	for (const msg of transformedMessages) {
+		if (compat.requiresAssistantAfterToolResult && lastRole === "tool" && msg.role === "user") {
+			params.push({
+				role: "assistant",
+				content: "I have processed the tool results."
+			});
+			lastRole = "assistant";
+		}
+		if (msg.role === "user") {
+			const content = msg.parts.flatMap((item) => {
+				if (item.type === "text") {
+					const text = sanitizeSurrogates(item.text);
+					if (text.trim().length === 0) return [];
+					return [{
+						type: "text",
+						text
+					}];
+				}
+				if (!model.input.includes("image")) return [];
+				return [{
+					type: "image_url",
+					image_url: { url: `data:${item.mimeType};base64,${item.data}` }
+				}];
+			});
+			if (content.length === 0) continue;
+			params.push({
+				role: "user",
+				content
+			});
+			lastRole = "user";
+			continue;
+		}
+		const assistantMsg = {
+			role: "assistant",
+			content: compat.requiresAssistantAfterToolResult ? "" : null
+		};
+		const textSegments = msg.parts.filter((block) => block.type === "text").map((block) => sanitizeSurrogates(block.text)).filter((text) => text.trim().length > 0);
+		const nonEmptyThinkingBlocks = msg.parts.filter((block) => block.type === "thinking").filter((block) => block.thinking.trim().length > 0);
+		if (compat.requiresThinkingAsText && nonEmptyThinkingBlocks.length > 0) textSegments.unshift(...nonEmptyThinkingBlocks.map((block) => sanitizeSurrogates(block.thinking)));
+		else if (nonEmptyThinkingBlocks.length > 0) {
+			const signature = nonEmptyThinkingBlocks[0]?.thinkingSignature;
+			if (signature && signature.length > 0) assistantMsg[signature] = nonEmptyThinkingBlocks.map((block) => sanitizeSurrogates(block.thinking)).join("\n");
+		}
+		if (textSegments.length > 0) assistantMsg.content = textSegments.join("");
+		const toolCalls = msg.parts.filter((block) => block.type === "toolCall");
+		if (toolCalls.length > 0) {
+			assistantMsg.tool_calls = toolCalls.map((toolCall) => ({
+				id: toolCall.callID,
+				type: "function",
+				function: {
+					name: toolCall.name,
+					arguments: JSON.stringify(toolCall.arguments)
+				}
+			}));
+			const reasoningDetails = toolCalls.filter((toolCall) => toolCall.thoughtSignature).map((toolCall) => {
+				try {
+					return JSON.parse(toolCall.thoughtSignature);
+				} catch {
+					return null;
+				}
+			}).filter(Boolean);
+			if (reasoningDetails.length > 0) assistantMsg.reasoning_details = reasoningDetails;
+		}
+		const assistantContent = assistantMsg.content;
+		if (!(assistantContent !== null && assistantContent !== void 0 && (typeof assistantContent === "string" ? assistantContent.length > 0 : assistantContent.length > 0)) && !assistantMsg.tool_calls) continue;
+		params.push(assistantMsg);
+		lastRole = "assistant";
+		const imageBlocks = [];
+		for (const toolCall of toolCalls) {
+			if (toolCall.status === "pending" || toolCall.status === "running") {
+				params.push(buildSyntheticToolResult(toolCall, compat));
+				lastRole = "tool";
+				continue;
+			}
+			const textResult = toolCall.result.content.filter((content) => content.type === "text").map((content) => content.text).join("\n");
+			const hasImages = toolCall.result.content.some((content) => content.type === "image");
+			const toolResultMsg = {
+				role: "tool",
+				content: sanitizeSurrogates(textResult.length > 0 ? textResult : "(see attached image)"),
+				tool_call_id: toolCall.callID
+			};
+			if (compat.requiresToolResultName) toolResultMsg.name = toolCall.name;
+			params.push(toolResultMsg);
+			lastRole = "tool";
+			if (hasImages && model.input.includes("image")) {
+				for (const block of toolCall.result.content) if (block.type === "image") imageBlocks.push({
+					type: "image_url",
+					image_url: { url: `data:${block.mimeType};base64,${block.data}` }
+				});
+			}
+		}
+		if (imageBlocks.length > 0) {
+			if (compat.requiresAssistantAfterToolResult) params.push({
+				role: "assistant",
+				content: "I have processed the tool results."
+			});
+			params.push({
+				role: "user",
+				content: [{
+					type: "text",
+					text: "Attached image(s) from tool result:"
+				}, ...imageBlocks]
+			});
+			lastRole = "user";
+		}
+	}
+	return params;
+}
+function convertTools(tools, compat) {
+	return tools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters,
+			...compat.supportsStrictMode !== false && { strict: false }
+		}
+	}));
+}
+function parseChunkUsage(rawUsage, model) {
+	const promptTokens = rawUsage.prompt_tokens || 0;
+	const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
+	const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
+	const reasoningTokens = rawUsage.completion_tokens_details?.reasoning_tokens || 0;
+	const cacheReadTokens = cacheWriteTokens > 0 ? Math.max(0, reportedCachedTokens - cacheWriteTokens) : reportedCachedTokens;
+	const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
+	const outputTokens = (rawUsage.completion_tokens || 0) + reasoningTokens;
+	const usage = {
+		input,
+		output: outputTokens,
+		cacheRead: cacheReadTokens,
+		cacheWrite: cacheWriteTokens,
+		totalTokens: input + outputTokens + cacheReadTokens + cacheWriteTokens,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+	Model.calculateCost(model, usage);
+	return usage;
+}
+function mapStopReason(reason) {
+	if (reason === null) return { stopReason: "stop" };
+	switch (reason) {
+		case "stop":
+		case "end": return { stopReason: "stop" };
+		case "length": return { stopReason: "length" };
+		case "function_call":
+		case "tool_calls": return { stopReason: "toolUse" };
+		case "content_filter": return {
+			stopReason: "error",
+			errorMessage: "Provider finish_reason: content_filter"
+		};
+		case "network_error": return {
+			stopReason: "error",
+			errorMessage: "Provider finish_reason: network_error"
+		};
+		default: return {
+			stopReason: "error",
+			errorMessage: `Provider finish_reason: ${reason}`
+		};
+	}
+}
+function detectCompat(model) {
+	const provider = model.provider.id;
+	const baseUrl = resolveBaseUrl(model);
+	const isZai = provider === "zai" || baseUrl.includes("api.z.ai");
+	const isNonStandard = provider === "cerebras" || baseUrl.includes("cerebras.ai") || provider === "xai" || baseUrl.includes("api.x.ai") || baseUrl.includes("chutes.ai") || baseUrl.includes("deepseek.com") || isZai || provider === "opencode" || baseUrl.includes("opencode.ai");
+	const useMaxTokens = baseUrl.includes("chutes.ai");
+	const isGrok = provider === "xai" || baseUrl.includes("api.x.ai");
+	const reasoningEffortMap = (provider === "groq" || baseUrl.includes("groq.com")) && model.id === "qwen/qwen3-32b" ? {
+		minimal: "default",
+		low: "default",
+		medium: "default",
+		high: "default",
+		xhigh: "default"
+	} : {};
+	return {
+		supportsStore: !isNonStandard,
+		supportsDeveloperRole: !isNonStandard,
+		supportsReasoningEffort: !isGrok && !isZai,
+		reasoningEffortMap,
+		supportsUsageInStreaming: true,
+		maxTokensField: useMaxTokens ? "max_tokens" : "max_completion_tokens",
+		requiresToolResultName: false,
+		requiresAssistantAfterToolResult: false,
+		requiresThinkingAsText: false,
+		thinkingFormat: isZai ? "zai" : provider === "openrouter" || baseUrl.includes("openrouter.ai") ? "openrouter" : "openai",
+		openRouterRouting: {},
+		vercelGatewayRouting: {},
+		zaiToolStream: false,
+		supportsStrictMode: true
+	};
+}
+/**
+* Get resolved compatibility settings for a model.
+* Uses explicit model.compat if provided, otherwise auto-detects from provider/URL.
+*/
+function getCompat(model) {
+	const detected = detectCompat(model);
+	if (!model.compat) return detected;
+	return {
+		supportsStore: model.compat.supportsStore ?? detected.supportsStore,
+		supportsDeveloperRole: model.compat.supportsDeveloperRole ?? detected.supportsDeveloperRole,
+		supportsReasoningEffort: model.compat.supportsReasoningEffort ?? detected.supportsReasoningEffort,
+		reasoningEffortMap: model.compat.reasoningEffortMap ?? detected.reasoningEffortMap,
+		supportsUsageInStreaming: model.compat.supportsUsageInStreaming ?? detected.supportsUsageInStreaming,
+		maxTokensField: model.compat.maxTokensField ?? detected.maxTokensField,
+		requiresToolResultName: model.compat.requiresToolResultName ?? detected.requiresToolResultName,
+		requiresAssistantAfterToolResult: model.compat.requiresAssistantAfterToolResult ?? detected.requiresAssistantAfterToolResult,
+		requiresThinkingAsText: model.compat.requiresThinkingAsText ?? detected.requiresThinkingAsText,
+		thinkingFormat: model.compat.thinkingFormat ?? detected.thinkingFormat,
+		openRouterRouting: model.compat.openRouterRouting ?? {},
+		vercelGatewayRouting: model.compat.vercelGatewayRouting ?? detected.vercelGatewayRouting,
+		zaiToolStream: model.compat.zaiToolStream ?? detected.zaiToolStream,
+		supportsStrictMode: model.compat.supportsStrictMode ?? detected.supportsStrictMode
+	};
+}
+const openAICompletionsProtocolProvider = {
+	protocol: Model.KnownProtocolEnum.openaiCompletions,
+	stream: streamOpenAICompletions,
+	streamSimple: streamSimpleOpenAICompletions
+};
+//#endregion
+//#region src/provider/register.ts
+Stream.registerProtocolProvider(anthropicProtocolProvider, "providers/anthropic/index.ts");
+Stream.registerProtocolProvider(openAICompletionsProtocolProvider, "providers/openai/completions.ts");
 //#endregion
 //#region src/agent/agent.ts
 let Agent;
@@ -2656,7 +3343,7 @@ let CodeMode;
 })(CodeMode || (CodeMode = {}));
 //#endregion
 //#region src/llm.ts
-const llmImpl = async (provider, model) => Model.getModel(provider, model);
+const llmImpl = async (provider, model, overrides) => Model.getModel(provider, model, overrides);
 const llm = Object.assign(llmImpl, {
 	model: Model.getModel,
 	models: Model.getModels,