@codeworksh/aikit 0.6.0 → 0.7.0

package/openai-codex-_3XkJ4bs.mjs

@@ -0,0 +1,1158 @@
+import { o as getOpenAICodexAccountId } from "./codex-DyQHzQmn.mjs";
+import { APICallError, LoadAPIKeyError, NoSuchModelError } from "@ai-sdk/provider";
+//#region src/providers/openai-codex/codex-tools.ts
+function appendOpenAICodexGrammarInputJsonDelta(buffer, inputProperty, nextInput, close) {
+	if (buffer.closed) {
+		if (close && nextInput === buffer.input) return void 0;
+		throw new Error(`grammar tool input for property "${inputProperty}" changed after it was closed`);
+	}
+	if (!nextInput.startsWith(buffer.input)) throw new Error(`grammar tool input for property "${inputProperty}" changed non-monotonically`);
+	const inputDelta = nextInput.slice(buffer.input.length);
+	if (!close && inputDelta.length === 0) return void 0;
+	let delta = "";
+	if (!buffer.started) {
+		delta += `{${JSON.stringify(inputProperty)}:"`;
+		buffer.started = true;
+	}
+	delta += JSON.stringify(inputDelta).slice(1, -1);
+	buffer.input = nextInput;
+	if (close) {
+		delta += "\"}";
+		buffer.closed = true;
+	}
+	return delta;
+}
+function inferGrammarInputProperty(parameters) {
+	const schema = parameters;
+	if (schema.type !== "object") throw new Error("grammar constrained sampling requires an object parameter schema");
+	if (!Array.isArray(schema.required) || schema.required.length !== 1 || typeof schema.required[0] !== "string") throw new Error("grammar constrained sampling requires exactly one required string property");
+	const inputProperty = schema.required[0];
+	if (!schema.properties?.[inputProperty]) throw new Error(`grammar constrained sampling requires a properties entry for ${inputProperty}`);
+	if (schema.properties[inputProperty]?.type !== "string") throw new Error(`grammar constrained sampling property ${inputProperty} must have type string`);
+	return inputProperty;
+}
+function resolveOpenAICodexToolConstraint(tool, compat) {
+	const config = tool.constrainedSampling;
+	if (!config) return void 0;
+	if (config.type === "json_schema") {
+		if (compat?.supportsStrictMode ?? true) return {
+			type: "json_schema",
+			strict: true
+		};
+		if (config.strict === "require") throw new Error(`Tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`);
+		return;
+	}
+	if (!(compat?.supportsOpenAIGrammarTools ?? false)) return void 0;
+	const lark = config.variants.openai_lark;
+	const regex = config.variants.openai_regex;
+	const hasLark = typeof lark === "string" && lark.trim().length > 0;
+	const hasRegex = typeof regex === "string" && regex.trim().length > 0;
+	if (!hasLark && !hasRegex) throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: no supported grammar variant was provided.`);
+	try {
+		return {
+			type: "grammar",
+			format: hasLark ? "lark" : "regex",
+			definition: hasLark ? lark : regex,
+			inputProperty: inferGrammarInputProperty(tool.parameters)
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
+	}
+}
+const openAICodexTools = { custom(args) {
+	return {
+		name: args.name,
+		description: args.description,
+		parameters: args.parameters,
+		constrainedSampling: {
+			type: "grammar",
+			variants: args.format.syntax === "lark" ? { openai_lark: args.format.definition } : { openai_regex: args.format.definition }
+		}
+	};
+} };
+const TOOL_SEARCH_MODEL_IDS = /* @__PURE__ */ new Set([
+	"gpt-5.4",
+	"gpt-5.4-mini",
+	"gpt-5.5",
+	"gpt-5.6-luna",
+	"gpt-5.6-sol",
+	"gpt-5.6-terra"
+]);
+const ADDITIONAL_TOOLS_MODEL_IDS = /* @__PURE__ */ new Set([
+	"gpt-5.6-luna",
+	"gpt-5.6-sol",
+	"gpt-5.6-terra"
+]);
+function resolveOpenAICodexDeferredToolsMode(modelId, compat) {
+	if (compat?.supportsAdditionalTools ?? ADDITIONAL_TOOLS_MODEL_IDS.has(modelId)) return "additional-tools";
+	return compat?.supportsToolSearch ?? TOOL_SEARCH_MODEL_IDS.has(modelId) ? "tool-search" : void 0;
+}
+function prepareOpenAICodexTools({ tools, toolChoice, deferredToolNames }) {
+	const warnings = [];
+	const deferredCodexTools = /* @__PURE__ */ new Map();
+	const grammarToolInputProperties = /* @__PURE__ */ new Map();
+	if (!tools || tools.length === 0) return {
+		codexTools: void 0,
+		deferredCodexTools,
+		grammarToolInputProperties,
+		codexToolChoice: void 0,
+		warnings
+	};
+	const codexTools = [];
+	for (const tool of tools) {
+		if (tool.type !== "function") {
+			warnings.push({
+				type: "unsupported",
+				feature: `tool type ${tool.type}`,
+				details: `OpenAI Codex only supports function tools; ignoring ${tool.name}.`
+			});
+			continue;
+		}
+		const grammar = (tool.providerOptions?.["openai-codex"])?.grammar;
+		const codexTool = grammar?.type === "grammar" ? {
+			type: "custom",
+			name: tool.name,
+			...tool.description !== void 0 && { description: tool.description },
+			format: {
+				type: "grammar",
+				syntax: grammar.format,
+				definition: grammar.definition
+			}
+		} : {
+			type: "function",
+			name: tool.name,
+			...tool.description !== void 0 && { description: tool.description },
+			parameters: tool.inputSchema,
+			strict: tool.strict ?? null
+		};
+		if (grammar?.type === "grammar") grammarToolInputProperties.set(tool.name, grammar.inputProperty);
+		if (deferredToolNames?.has(tool.name)) deferredCodexTools.set(tool.name, codexTool);
+		else codexTools.push(codexTool);
+	}
+	let codexToolChoice;
+	switch (toolChoice?.type) {
+		case void 0: break;
+		case "auto":
+		case "none":
+		case "required":
+			codexToolChoice = toolChoice.type;
+			break;
+		case "tool":
+			warnings.push({
+				type: "unsupported",
+				feature: "toolChoice tool name",
+				details: "OpenAI Codex does not support forcing a specific tool; using 'required' instead."
+			});
+			codexToolChoice = "required";
+	}
+	return {
+		codexTools: codexTools.length > 0 ? codexTools : void 0,
+		deferredCodexTools,
+		grammarToolInputProperties,
+		codexToolChoice,
+		warnings
+	};
+}
+//#endregion
+//#region src/utils/hash.ts
+/** Fast deterministic hash for shortening provider wire identifiers. */
+function shortHash(value) {
+	let high = 3735928559;
+	let low = 1103547991;
+	for (let index = 0; index < value.length; index++) {
+		const character = value.charCodeAt(index);
+		high = Math.imul(high ^ character, 2654435761);
+		low = Math.imul(low ^ character, 1597334677);
+	}
+	high = Math.imul(high ^ high >>> 16, 2246822507) ^ Math.imul(low ^ low >>> 13, 3266489909);
+	low = Math.imul(low ^ low >>> 16, 2246822507) ^ Math.imul(high ^ high >>> 13, 3266489909);
+	return (low >>> 0).toString(36) + (high >>> 0).toString(36);
+}
+//#endregion
+//#region src/providers/openai-codex/codex-error.ts
+function isTerminalRateLimitError(body) {
+	return /GoUsageLimitError|FreeUsageLimitError|Monthly usage limit reached|available balance|insufficient_quota|out of budget|quota exceeded|billing/i.test(body);
+}
+/**
+* Turn a Codex error payload into a human-friendly message. ChatGPT plan usage
+* limits deserve a clearer message than the raw backend error.
+*/
+function openAICodexErrorMessage(status, body, statusText) {
+	let message = body || statusText || "OpenAI Codex request failed";
+	try {
+		const error = JSON.parse(body)?.error;
+		if (error) {
+			const code = error.code ?? error.type ?? "";
+			if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || status === 429) {
+				const plan = error.plan_type ? ` (${error.plan_type.toLowerCase()} plan)` : "";
+				const minutes = error.resets_at ? Math.max(0, Math.round((error.resets_at * 1e3 - Date.now()) / 6e4)) : void 0;
+				return `You have hit your ChatGPT usage limit${plan}.${minutes === void 0 ? "" : ` Try again in ~${minutes} min.`}`.trim();
+			}
+			message = error.message || message;
+		}
+	} catch {}
+	return message;
+}
+async function createOpenAICodexAPICallError(args) {
+	const { response, url, requestBodyValues } = args;
+	const responseBody = await response.text().catch(() => "");
+	const responseHeaders = {};
+	response.headers.forEach((value, key) => {
+		responseHeaders[key] = value;
+	});
+	return new APICallError({
+		message: openAICodexErrorMessage(response.status, responseBody, response.statusText),
+		url,
+		requestBodyValues,
+		statusCode: response.status,
+		responseHeaders,
+		responseBody,
+		isRetryable: response.status === 408 || response.status === 409 || response.status === 429 && !isTerminalRateLimitError(responseBody) || response.status >= 500
+	});
+}
+//#endregion
+//#region src/providers/openai-codex/codex-prompt.ts
+const DEFAULT_INSTRUCTIONS = "You are a helpful assistant.";
+function splitToolCallId(toolCallId) {
+	const separator = toolCallId.indexOf("|");
+	if (separator === -1) return {
+		callId: toolCallId,
+		itemId: toolCallId
+	};
+	return {
+		callId: toolCallId.slice(0, separator),
+		itemId: toolCallId.slice(separator + 1)
+	};
+}
+function joinToolCallId(callId, itemId) {
+	return `${callId}|${itemId}`;
+}
+function uint8ArrayToBase64(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function imageUrlFromFilePart(part) {
+	const data = part.data;
+	if (data instanceof URL) return data.toString();
+	if (typeof data === "string") {
+		if (data.startsWith("data:") || data.startsWith("http://") || data.startsWith("https://")) return data;
+		return `data:${part.mediaType};base64,${data}`;
+	}
+	if (data instanceof Uint8Array) return `data:${part.mediaType};base64,${uint8ArrayToBase64(data)}`;
+	if ("type" in data) {
+		if (data.type === "url") return data.url.toString();
+		if (data.type === "data") return typeof data.data === "string" ? `data:${part.mediaType};base64,${data.data}` : `data:${part.mediaType};base64,${uint8ArrayToBase64(data.data)}`;
+	}
+}
+function toolResultOutput(output, supportsImages) {
+	switch (output.type) {
+		case "text":
+		case "error-text": return output.value || "(no tool output)";
+		case "json":
+		case "error-json": return JSON.stringify(output.value);
+		case "execution-denied": return output.reason ?? "Tool execution denied";
+		case "content": {
+			const text = output.value.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+			const images = [];
+			if (supportsImages) {
+				for (const part of output.value) if (part.type === "file-data" && part.mediaType.startsWith("image/")) images.push({
+					type: "input_image",
+					image_url: `data:${part.mediaType};base64,${part.data}`,
+					detail: "auto"
+				});
+				else if (part.type === "file-url") images.push({
+					type: "input_image",
+					image_url: part.url,
+					detail: "auto"
+				});
+				else if (part.type === "file" && part.mediaType.startsWith("image/")) {
+					const data = part.data;
+					if (data.type === "url") images.push({
+						type: "input_image",
+						image_url: data.url.toString(),
+						detail: "auto"
+					});
+					else if (data.type === "data") {
+						const encoded = typeof data.data === "string" ? data.data : uint8ArrayToBase64(data.data);
+						images.push({
+							type: "input_image",
+							image_url: `data:${part.mediaType};base64,${encoded}`,
+							detail: "auto"
+						});
+					}
+				}
+			}
+			if (images.length === 0) return text || (output.value.length > 0 ? "(see attached image)" : "(no tool output)");
+			return [...text ? [{
+				type: "input_text",
+				text
+			}] : [], ...images];
+		}
+		default: return JSON.stringify(output);
+	}
+}
+function customToolInput(input, toolName, inputProperty) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) throw new Error(`Custom tool "${toolName}" requires object input with string property "${inputProperty}".`);
+	const value = input[inputProperty];
+	if (typeof value !== "string") throw new Error(`Custom tool "${toolName}" requires string input property "${inputProperty}".`);
+	return value;
+}
+function customToolOutput(output, supportsImages) {
+	const value = toolResultOutput(output, supportsImages);
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+function codexProviderMetadata(providerOptions) {
+	const codex = providerOptions?.["openai-codex"];
+	return typeof codex === "object" && codex !== null && !Array.isArray(codex) ? codex : void 0;
+}
+function addedToolNames(providerOptions) {
+	const names = codexProviderMetadata(providerOptions)?.addedToolNames;
+	return Array.isArray(names) ? names.filter((name) => typeof name === "string") : [];
+}
+function reasoningItem(providerOptions) {
+	const value = codexProviderMetadata(providerOptions)?.reasoningItem;
+	if (typeof value !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return void 0;
+		const item = parsed;
+		return item.type === "reasoning" && typeof item.id === "string" ? item : void 0;
+	} catch {
+		return;
+	}
+}
+/** Collect definitions that were introduced at a transcript load point rather than at request start. */
+function collectOpenAICodexDeferredToolNames(prompt) {
+	const deferredNames = /* @__PURE__ */ new Set();
+	const usedNames = /* @__PURE__ */ new Set();
+	for (const message of prompt) {
+		if (message.role === "assistant") {
+			for (const part of message.content) {
+				if (part.type === "tool-call") usedNames.add(part.toolName);
+				if (part.type === "tool-result") {
+					for (const name of addedToolNames(part.providerOptions)) if (!usedNames.has(name)) deferredNames.add(name);
+				}
+			}
+			continue;
+		}
+		if (message.role !== "tool") continue;
+		for (const part of message.content) {
+			if (part.type !== "tool-result") continue;
+			for (const name of addedToolNames(part.providerOptions)) if (!usedNames.has(name)) deferredNames.add(name);
+		}
+	}
+	return deferredNames;
+}
+function deferredToolCallId(toolCallId, names) {
+	return `aikit_tool_load_${shortHash(`${toolCallId}:${names.join(",")}`)}`;
+}
+/**
+* Convert an AI SDK V3 prompt into the Codex Responses request shape.
+* System messages become `instructions`; everything else maps to `input` items.
+*/
+function convertToOpenAICodexPrompt(prompt, options) {
+	let instructions;
+	const input = [];
+	let syntheticMessageCounter = 0;
+	const loadedToolNames = /* @__PURE__ */ new Set();
+	const appendDeferredTools = (toolCallId, names) => {
+		const tools = [];
+		for (const name of names) {
+			const tool = options?.deferredTools?.get(name);
+			if (!tool || loadedToolNames.has(name)) continue;
+			loadedToolNames.add(name);
+			tools.push(tool);
+		}
+		if (tools.length === 0) return;
+		if (options?.deferredToolsMode === "additional-tools") {
+			input.push({
+				type: "additional_tools",
+				role: "developer",
+				tools
+			});
+			return;
+		}
+		if (options?.deferredToolsMode === "tool-search") {
+			const callId = deferredToolCallId(toolCallId, tools.map((tool) => tool.name));
+			input.push({
+				type: "tool_search_call",
+				call_id: callId,
+				execution: "client",
+				status: "completed",
+				arguments: {
+					query: tools.map((tool) => tool.name).join(" "),
+					limit: tools.length
+				}
+			});
+			input.push({
+				type: "tool_search_output",
+				call_id: callId,
+				execution: "client",
+				status: "completed",
+				tools: tools.map((tool) => ({
+					...tool,
+					defer_loading: true
+				}))
+			});
+		}
+	};
+	for (const message of prompt) switch (message.role) {
+		case "system":
+			instructions = instructions == null ? message.content : `${instructions}\n\n${message.content}`;
+			break;
+		case "user": {
+			const content = [];
+			for (const part of message.content) if (part.type === "text") content.push({
+				type: "input_text",
+				text: part.text
+			});
+			else if (part.type === "file" && part.mediaType.startsWith("image/")) {
+				const imageUrl = imageUrlFromFilePart(part);
+				if (imageUrl) content.push({
+					type: "input_image",
+					image_url: imageUrl,
+					detail: "auto"
+				});
+			}
+			if (content.length > 0) input.push({
+				role: "user",
+				content
+			});
+			break;
+		}
+		case "assistant":
+			for (const part of message.content) if (part.type === "reasoning") {
+				const item = reasoningItem(part.providerOptions);
+				if (item) input.push(item);
+			} else if (part.type === "text") {
+				syntheticMessageCounter++;
+				const messageId = codexProviderMetadata(part.providerOptions)?.messageId;
+				input.push({
+					type: "message",
+					role: "assistant",
+					id: typeof messageId === "string" && messageId.length <= 64 ? messageId : `msg_aikit_${syntheticMessageCounter}`,
+					content: [{
+						type: "output_text",
+						text: part.text,
+						annotations: []
+					}],
+					status: "completed"
+				});
+			} else if (part.type === "tool-call") {
+				const { callId, itemId } = splitToolCallId(part.toolCallId);
+				const metadata = codexProviderMetadata(part.providerOptions);
+				const namespace = metadata?.namespace;
+				const inputProperty = options?.grammarToolInputProperties?.get(part.toolName);
+				if (inputProperty) input.push({
+					type: "custom_tool_call",
+					...metadata?.omitItemId === true || !itemId.startsWith("ctc_") ? {} : { id: itemId },
+					call_id: callId,
+					name: part.toolName,
+					input: customToolInput(part.input, part.toolName, inputProperty),
+					...typeof namespace === "string" ? { namespace } : {}
+				});
+				else input.push({
+					type: "function_call",
+					...metadata?.omitItemId === true || !itemId.startsWith("fc_") ? {} : { id: itemId },
+					call_id: callId,
+					name: part.toolName,
+					arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input ?? {}),
+					...typeof namespace === "string" ? { namespace } : {}
+				});
+			}
+			break;
+		case "tool": for (const part of message.content) {
+			if (part.type !== "tool-result") continue;
+			const { callId } = splitToolCallId(part.toolCallId);
+			if (options?.grammarToolInputProperties?.has(part.toolName)) input.push({
+				type: "custom_tool_call_output",
+				call_id: callId,
+				output: customToolOutput(part.output, options?.supportsImages ?? true)
+			});
+			else input.push({
+				type: "function_call_output",
+				call_id: callId,
+				output: toolResultOutput(part.output, options?.supportsImages ?? true)
+			});
+			appendDeferredTools(part.toolCallId, addedToolNames(part.providerOptions));
+		}
+	}
+	return {
+		instructions: instructions || DEFAULT_INSTRUCTIONS,
+		input
+	};
+}
+//#endregion
+//#region src/providers/openai-codex/codex-sse.ts
+/**
+* Minimal SSE parsing for the Codex Responses endpoint. Each event is a JSON
+* payload on `data:` lines; `[DONE]` terminates the stream.
+*/
+function parseOpenAICodexSSEStream(body) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	const parseChunk = (chunk, controller) => {
+		const dataLines = chunk.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+		if (dataLines.length === 0) return;
+		const data = dataLines.join("\n").trim();
+		if (!data || data === "[DONE]") return;
+		try {
+			controller.enqueue(JSON.parse(data));
+		} catch (cause) {
+			controller.error(new Error(`Invalid OpenAI Codex SSE JSON: ${data.slice(0, 200)}`, { cause }));
+		}
+	};
+	return body.pipeThrough(new TransformStream({
+		transform(value, controller) {
+			buffer += decoder.decode(value, { stream: true });
+			let index = buffer.indexOf("\n\n");
+			while (index !== -1) {
+				const chunk = buffer.slice(0, index);
+				buffer = buffer.slice(index + 2);
+				parseChunk(chunk, controller);
+				index = buffer.indexOf("\n\n");
+			}
+		},
+		flush(controller) {
+			buffer += decoder.decode();
+			if (buffer.trim()) parseChunk(buffer, controller);
+		}
+	}));
+}
+//#endregion
+//#region src/providers/openai-codex/codex-usage.ts
+function convertOpenAICodexUsage(usage) {
+	const inputTotal = usage?.input_tokens;
+	const cachedTokens = usage?.input_tokens_details?.cached_tokens ?? 0;
+	const cacheWriteTokens = usage?.input_tokens_details?.cache_write_tokens ?? 0;
+	const outputTotal = usage?.output_tokens;
+	const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens ?? 0;
+	return {
+		inputTokens: {
+			total: inputTotal,
+			noCache: inputTotal === void 0 ? void 0 : Math.max(inputTotal - cachedTokens - cacheWriteTokens, 0),
+			cacheRead: inputTotal === void 0 ? void 0 : cachedTokens,
+			cacheWrite: inputTotal === void 0 ? void 0 : cacheWriteTokens
+		},
+		outputTokens: {
+			total: outputTotal,
+			text: outputTotal === void 0 ? void 0 : outputTotal - reasoningTokens,
+			reasoning: outputTotal === void 0 ? void 0 : reasoningTokens
+		},
+		...usage ? { raw: usage } : {}
+	};
+}
+function mapOpenAICodexFinishReason(status, hasToolCalls, incompleteReason) {
+	switch (status) {
+		case "completed": return {
+			unified: hasToolCalls ? "tool-calls" : "stop",
+			raw: status
+		};
+		case "incomplete": return incompleteReason === "max_output_tokens" ? {
+			unified: "length",
+			raw: `${status}.${incompleteReason}`
+		} : {
+			unified: "error",
+			raw: incompleteReason ? `${status}.${incompleteReason}` : status
+		};
+		case "failed":
+		case "cancelled": return {
+			unified: "error",
+			raw: status
+		};
+		case void 0: return {
+			unified: "other",
+			raw: void 0
+		};
+		default: return {
+			unified: "stop",
+			raw: status
+		};
+	}
+}
+//#endregion
+//#region src/providers/openai-codex/codex-language-model.ts
+const OPENAI_CODEX_DEFAULT_BASE_URL = "https://chatgpt.com/backend-api";
+const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
+function compressOpenAICodexRequest(body) {
+	if (typeof process === "undefined" || !(process.versions?.node || process.versions?.bun)) return void 0;
+	const zlib = process.getBuiltinModule?.("node:zlib");
+	if (!zlib || typeof zlib.zstdCompressSync !== "function") return void 0;
+	try {
+		const compressed = zlib.zstdCompressSync(body, { params: { [zlib.constants.ZSTD_c_compressionLevel]: REQUEST_COMPRESSION_ZSTD_LEVEL } });
+		return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+	} catch {
+		return;
+	}
+}
+function clampOpenAICodexPromptCacheKey(key) {
+	if (key === void 0) return void 0;
+	const characters = Array.from(key);
+	return characters.length <= 64 ? key : characters.slice(0, 64).join("");
+}
+/**
+* Resolve the Codex responses endpoint from a base URL that may already
+* include the `/codex` or `/codex/responses` suffix.
+*/
+function resolveOpenAICodexUrl(baseUrl) {
+	const normalized = (baseUrl?.trim() ? baseUrl : OPENAI_CODEX_DEFAULT_BASE_URL).replace(/\/+$/, "");
+	if (normalized.endsWith("/codex/responses")) return normalized;
+	if (normalized.endsWith("/codex")) return `${normalized}/responses`;
+	return `${normalized}/codex/responses`;
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function cleanHeaders(headers) {
+	const result = {};
+	for (const [key, value] of Object.entries(headers)) if (value !== void 0) result[key] = value;
+	return result;
+}
+var OpenAICodexLanguageModel = class {
+	specificationVersion = "v3";
+	modelId;
+	config;
+	constructor(modelId, config) {
+		this.modelId = modelId;
+		this.config = config;
+	}
+	get provider() {
+		return this.config.provider;
+	}
+	get supportedUrls() {
+		return {};
+	}
+	getArgs(options) {
+		const warnings = [];
+		if (options.topP != null) warnings.push({
+			type: "unsupported",
+			feature: "topP"
+		});
+		if (options.topK != null) warnings.push({
+			type: "unsupported",
+			feature: "topK"
+		});
+		if (options.presencePenalty != null) warnings.push({
+			type: "unsupported",
+			feature: "presencePenalty"
+		});
+		if (options.frequencyPenalty != null) warnings.push({
+			type: "unsupported",
+			feature: "frequencyPenalty"
+		});
+		if (options.seed != null) warnings.push({
+			type: "unsupported",
+			feature: "seed"
+		});
+		if (options.stopSequences != null) warnings.push({
+			type: "unsupported",
+			feature: "stopSequences"
+		});
+		if (options.maxOutputTokens != null) warnings.push({
+			type: "unsupported",
+			feature: "maxOutputTokens"
+		});
+		if (options.responseFormat && options.responseFormat.type !== "text") warnings.push({
+			type: "unsupported",
+			feature: "responseFormat"
+		});
+		const codexOptions = options.providerOptions?.["openai-codex"] ?? {};
+		const deferredToolsMode = resolveOpenAICodexDeferredToolsMode(this.modelId, this.config.compat);
+		const deferredToolNames = deferredToolsMode ? collectOpenAICodexDeferredToolNames(options.prompt) : void 0;
+		const tools = prepareOpenAICodexTools({
+			tools: options.tools,
+			toolChoice: options.toolChoice,
+			...deferredToolNames !== void 0 && { deferredToolNames }
+		});
+		const { instructions, input } = convertToOpenAICodexPrompt(options.prompt, {
+			deferredTools: tools.deferredCodexTools,
+			...deferredToolsMode !== void 0 && { deferredToolsMode },
+			grammarToolInputProperties: tools.grammarToolInputProperties,
+			supportsImages: this.config.compat?.supportsImages ?? this.modelId !== "gpt-5.3-codex-spark"
+		});
+		warnings.push(...tools.warnings);
+		const args = {
+			model: this.modelId,
+			store: false,
+			instructions,
+			input,
+			tool_choice: tools.codexToolChoice ?? "auto",
+			parallel_tool_calls: true,
+			include: codexOptions.include ?? ["reasoning.encrypted_content"],
+			text: { verbosity: codexOptions.textVerbosity ?? "low" }
+		};
+		if (tools.codexTools) args.tools = tools.codexTools;
+		if (options.temperature != null) args.temperature = options.temperature;
+		const promptCacheKey = clampOpenAICodexPromptCacheKey(codexOptions.promptCacheKey ?? this.config.sessionId);
+		if (promptCacheKey) args.prompt_cache_key = promptCacheKey;
+		const serviceTier = codexOptions.serviceTier ?? this.config.serviceTier;
+		if (serviceTier) args.service_tier = serviceTier;
+		if (codexOptions.reasoningEffort) args.reasoning = {
+			effort: codexOptions.reasoningEffort,
+			summary: codexOptions.reasoningSummary ?? "auto"
+		};
+		return {
+			args,
+			warnings,
+			grammarToolInputProperties: tools.grammarToolInputProperties
+		};
+	}
+	async doGenerate(options) {
+		const { stream, request, response } = await this.doStream(options);
+		const content = [];
+		const textBlocks = /* @__PURE__ */ new Map();
+		const reasoningBlocks = /* @__PURE__ */ new Map();
+		const warnings = [];
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		let usage = convertOpenAICodexUsage(void 0);
+		let responseId;
+		let responseModelId;
+		const reader = stream.getReader();
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			switch (value.type) {
+				case "stream-start":
+					warnings.push(...value.warnings);
+					break;
+				case "response-metadata":
+					responseId = value.id;
+					responseModelId = value.modelId;
+					break;
+				case "text-start": {
+					const block = {
+						type: "text",
+						text: ""
+					};
+					textBlocks.set(value.id, block);
+					content.push(block);
+					break;
+				}
+				case "text-delta": {
+					const block = textBlocks.get(value.id);
+					if (block) block.text += value.delta;
+					break;
+				}
+				case "text-end": {
+					const block = textBlocks.get(value.id);
+					if (block && value.providerMetadata !== void 0) block.providerMetadata = value.providerMetadata;
+					break;
+				}
+				case "reasoning-start": {
+					const block = {
+						type: "reasoning",
+						text: ""
+					};
+					reasoningBlocks.set(value.id, block);
+					content.push(block);
+					break;
+				}
+				case "reasoning-delta": {
+					const block = reasoningBlocks.get(value.id);
+					if (block) block.text += value.delta;
+					break;
+				}
+				case "reasoning-end": {
+					const block = reasoningBlocks.get(value.id);
+					if (block && value.providerMetadata !== void 0) block.providerMetadata = value.providerMetadata;
+					break;
+				}
+				case "tool-call":
+					content.push(value);
+					break;
+				case "finish":
+					finishReason = value.finishReason;
+					usage = value.usage;
+					break;
+				case "error": throw value.error instanceof Error ? value.error : new Error(String(value.error));
+			}
+		}
+		return {
+			content: content.filter((part) => part.type === "text" || part.type === "reasoning" ? part.text !== "" || part.providerMetadata !== void 0 : true),
+			finishReason,
+			usage,
+			...request !== void 0 && { request },
+			response: {
+				...response,
+				...responseId !== void 0 && { id: responseId },
+				...responseModelId !== void 0 && { modelId: responseModelId }
+			},
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings, grammarToolInputProperties } = this.getArgs(options);
+		const body = {
+			...args,
+			stream: true
+		};
+		const url = resolveOpenAICodexUrl(this.config.baseURL);
+		const headers = cleanHeaders({
+			...await this.config.headers(),
+			...options.headers
+		});
+		const bodyJson = JSON.stringify(body);
+		const compressedBody = compressOpenAICodexRequest(bodyJson);
+		if (compressedBody) headers["content-encoding"] = "zstd";
+		const response = await (this.config.fetch ?? globalThis.fetch)(url, {
+			method: "POST",
+			headers,
+			body: compressedBody ?? bodyJson,
+			...options.abortSignal !== void 0 && { signal: options.abortSignal }
+		});
+		if (!response.ok) throw await createOpenAICodexAPICallError({
+			response,
+			url,
+			requestBodyValues: body
+		});
+		if (!response.body) throw new Error("OpenAI Codex response has no body");
+		const responseHeaders = {};
+		response.headers.forEach((value, key) => {
+			responseHeaders[key] = value;
+		});
+		return {
+			stream: parseOpenAICodexSSEStream(response.body).pipeThrough(this.createTransformStream(warnings, options.includeRawChunks ?? false, grammarToolInputProperties)),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
+	createTransformStream(warnings, includeRawChunks, grammarToolInputProperties) {
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		let usage;
+		let hasToolCalls = false;
+		let finished = false;
+		const toolCallIdsByItemId = /* @__PURE__ */ new Map();
+		const customToolInputsByItemId = /* @__PURE__ */ new Map();
+		const finish = (controller) => {
+			if (finished) return;
+			finished = true;
+			controller.enqueue({
+				type: "finish",
+				finishReason,
+				usage: convertOpenAICodexUsage(usage)
+			});
+		};
+		const handleOutputItemAdded = (item, controller) => {
+			const itemType = asString(item.type);
+			const itemId = asString(item.id);
+			if (!itemType || !itemId) return;
+			if (itemType === "message") controller.enqueue({
+				type: "text-start",
+				id: itemId
+			});
+			else if (itemType === "reasoning") controller.enqueue({
+				type: "reasoning-start",
+				id: itemId
+			});
+			else if (itemType === "function_call") {
+				const toolCallId = joinToolCallId(asString(item.call_id) ?? itemId, itemId);
+				toolCallIdsByItemId.set(itemId, toolCallId);
+				hasToolCalls = true;
+				controller.enqueue({
+					type: "tool-input-start",
+					id: toolCallId,
+					toolName: asString(item.name) ?? ""
+				});
+			} else if (itemType === "custom_tool_call") {
+				const toolName = asString(item.name) ?? "";
+				const inputProperty = grammarToolInputProperties.get(toolName) ?? "input";
+				const toolCallId = joinToolCallId(asString(item.call_id) ?? itemId, itemId);
+				customToolInputsByItemId.set(itemId, {
+					toolCallId,
+					toolName,
+					inputProperty,
+					buffer: {
+						input: "",
+						started: false,
+						closed: false
+					}
+				});
+				hasToolCalls = true;
+				controller.enqueue({
+					type: "tool-input-start",
+					id: toolCallId,
+					toolName
+				});
+			}
+		};
+		const handleOutputItemDone = (item, controller) => {
+			const itemType = asString(item.type);
+			const itemId = asString(item.id);
+			if (!itemType || !itemId) return;
+			if (itemType === "message") controller.enqueue({
+				type: "text-end",
+				id: itemId,
+				providerMetadata: { "openai-codex": { messageId: itemId } }
+			});
+			else if (itemType === "reasoning") controller.enqueue({
+				type: "reasoning-end",
+				id: itemId,
+				providerMetadata: { "openai-codex": { reasoningItem: JSON.stringify(item) } }
+			});
+			else if (itemType === "function_call") {
+				const toolCallId = toolCallIdsByItemId.get(itemId) ?? joinToolCallId(asString(item.call_id) ?? itemId, itemId);
+				hasToolCalls = true;
+				controller.enqueue({
+					type: "tool-input-end",
+					id: toolCallId
+				});
+				controller.enqueue({
+					type: "tool-call",
+					toolCallId,
+					toolName: asString(item.name) ?? "",
+					input: asString(item.arguments) ?? "",
+					...asString(item.namespace) ? { providerMetadata: { "openai-codex": { namespace: asString(item.namespace) } } } : {}
+				});
+			} else if (itemType === "custom_tool_call") {
+				const state = customToolInputsByItemId.get(itemId);
+				if (!state) return;
+				const input = asString(item.input) ?? state.buffer.input;
+				const delta = appendOpenAICodexGrammarInputJsonDelta(state.buffer, state.inputProperty, input, true);
+				if (delta) controller.enqueue({
+					type: "tool-input-delta",
+					id: state.toolCallId,
+					delta
+				});
+				hasToolCalls = true;
+				controller.enqueue({
+					type: "tool-input-end",
+					id: state.toolCallId
+				});
+				controller.enqueue({
+					type: "tool-call",
+					toolCallId: state.toolCallId,
+					toolName: state.toolName,
+					input: JSON.stringify({ [state.inputProperty]: input }),
+					...asString(item.namespace) ? { providerMetadata: { "openai-codex": { namespace: asString(item.namespace) } } } : {}
+				});
+				customToolInputsByItemId.delete(itemId);
+			}
+		};
+		return new TransformStream({
+			start(controller) {
+				controller.enqueue({
+					type: "stream-start",
+					warnings
+				});
+			},
+			transform(event, controller) {
+				if (includeRawChunks) controller.enqueue({
+					type: "raw",
+					rawValue: event
+				});
+				const type = asString(event.type);
+				if (!type) return;
+				switch (type) {
+					case "response.created": {
+						const response = asRecord(event.response);
+						const id = asString(response?.id);
+						const modelId = asString(response?.model);
+						controller.enqueue({
+							type: "response-metadata",
+							...id !== void 0 && { id },
+							...modelId !== void 0 && { modelId }
+						});
+						break;
+					}
+					case "response.output_item.added": {
+						const item = asRecord(event.item);
+						if (item) handleOutputItemAdded(item, controller);
+						break;
+					}
+					case "response.output_text.delta": {
+						const itemId = asString(event.item_id);
+						const delta = asString(event.delta);
+						if (itemId && delta) controller.enqueue({
+							type: "text-delta",
+							id: itemId,
+							delta
+						});
+						break;
+					}
+					case "response.reasoning_text.delta":
+					case "response.reasoning_summary_text.delta": {
+						const itemId = asString(event.item_id);
+						const delta = asString(event.delta);
+						if (itemId && delta) controller.enqueue({
+							type: "reasoning-delta",
+							id: itemId,
+							delta
+						});
+						break;
+					}
+					case "response.function_call_arguments.delta": {
+						const itemId = asString(event.item_id);
+						const delta = asString(event.delta);
+						const toolCallId = itemId ? toolCallIdsByItemId.get(itemId) : void 0;
+						if (toolCallId && delta) controller.enqueue({
+							type: "tool-input-delta",
+							id: toolCallId,
+							delta
+						});
+						break;
+					}
+					case "response.custom_tool_call_input.delta": {
+						const itemId = asString(event.item_id);
+						const delta = asString(event.delta);
+						const state = itemId ? customToolInputsByItemId.get(itemId) : void 0;
+						if (!state || delta === void 0) break;
+						const jsonDelta = appendOpenAICodexGrammarInputJsonDelta(state.buffer, state.inputProperty, state.buffer.input + delta, false);
+						if (jsonDelta) controller.enqueue({
+							type: "tool-input-delta",
+							id: state.toolCallId,
+							delta: jsonDelta
+						});
+						break;
+					}
+					case "response.custom_tool_call_input.done": {
+						const itemId = asString(event.item_id);
+						const input = asString(event.input);
+						const state = itemId ? customToolInputsByItemId.get(itemId) : void 0;
+						if (!state || input === void 0) break;
+						const jsonDelta = appendOpenAICodexGrammarInputJsonDelta(state.buffer, state.inputProperty, input, true);
+						if (jsonDelta) controller.enqueue({
+							type: "tool-input-delta",
+							id: state.toolCallId,
+							delta: jsonDelta
+						});
+						break;
+					}
+					case "response.output_item.done": {
+						const item = asRecord(event.item);
+						if (item) handleOutputItemDone(item, controller);
+						break;
+					}
+					case "response.completed":
+					case "response.done":
+					case "response.incomplete": {
+						const response = asRecord(event.response);
+						usage = response?.usage ?? usage;
+						const status = asString(response?.status) ?? (type === "response.incomplete" ? "incomplete" : "completed");
+						const incompleteReason = asString(asRecord(response?.incomplete_details)?.reason);
+						finishReason = mapOpenAICodexFinishReason(status, hasToolCalls, incompleteReason);
+						finish(controller);
+						controller.terminate();
+						break;
+					}
+					case "response.failed": {
+						const error = asRecord(asRecord(event.response)?.error);
+						finishReason = {
+							unified: "error",
+							raw: "failed"
+						};
+						controller.enqueue({
+							type: "error",
+							error: new Error(asString(error?.message) ?? "OpenAI Codex response failed")
+						});
+						break;
+					}
+					case "error": {
+						const code = asString(event.code);
+						const message = asString(event.message);
+						finishReason = {
+							unified: "error",
+							raw: code ?? "error"
+						};
+						controller.enqueue({
+							type: "error",
+							error: /* @__PURE__ */ new Error(`OpenAI Codex error${code ? ` ${code}` : ""}: ${message ?? JSON.stringify(event)}`)
+						});
+						break;
+					}
+				}
+			},
+			flush(controller) {
+				finish(controller);
+			}
+		});
+	}
+};
+//#endregion
+//#region src/providers/openai-codex/codex-provider.ts
+const OPENAI_CODEX_API_KEY_ENV = "OPENAI_CODEX_API_KEY";
+const DEFAULT_ORIGINATOR = "codework";
+async function resolveApiKey(settings) {
+	const apiKey = typeof settings.apiKey === "function" ? await settings.apiKey() : settings.apiKey ?? (typeof process === "undefined" ? void 0 : process.env["OPENAI_CODEX_API_KEY"]);
+	if (!apiKey) throw new LoadAPIKeyError({ message: `OpenAI Codex API key is missing. Pass it using the 'apiKey' option or the ${OPENAI_CODEX_API_KEY_ENV} environment variable.` });
+	return apiKey;
+}
+function resolveAccountId(settings, apiKey) {
+	const accountId = settings.accountId ?? getOpenAICodexAccountId(apiKey);
+	if (!accountId) throw new LoadAPIKeyError({ message: "Failed to extract the ChatGPT account id from the OpenAI Codex access token. Provide it using the 'accountId' option or pass a valid ChatGPT OAuth JWT as the API key." });
+	return accountId;
+}
+function createOpenAICodex(options = {}) {
+	const baseURL = options.baseURL?.replace(/\/+$/, "") || "https://chatgpt.com/backend-api";
+	const sessionId = clampOpenAICodexPromptCacheKey(options.sessionId);
+	const getHeaders = async () => {
+		const apiKey = await resolveApiKey(options);
+		const accountId = resolveAccountId(options, apiKey);
+		return {
+			Authorization: `Bearer ${apiKey}`,
+			"chatgpt-account-id": accountId,
+			"OpenAI-Beta": "responses=experimental",
+			originator: options.originator ?? DEFAULT_ORIGINATOR,
+			accept: "text/event-stream",
+			"content-type": "application/json",
+			...sessionId ? {
+				"session-id": sessionId,
+				"x-client-request-id": sessionId
+			} : {},
+			...options.headers
+		};
+	};
+	const createLanguageModel = (modelId) => new OpenAICodexLanguageModel(modelId, {
+		provider: "openai-codex",
+		baseURL,
+		headers: getHeaders,
+		...options.fetch !== void 0 && { fetch: options.fetch },
+		...sessionId !== void 0 && { sessionId },
+		...options.serviceTier !== void 0 && { serviceTier: options.serviceTier },
+		...options.compat !== void 0 && { compat: options.compat }
+	});
+	const provider = function(modelId) {
+		if (new.target) throw new Error("The OpenAI Codex model function cannot be called with the new keyword.");
+		return createLanguageModel(modelId);
+	};
+	provider.specificationVersion = "v3";
+	provider.languageModel = createLanguageModel;
+	provider.responses = createLanguageModel;
+	provider.embeddingModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "embeddingModel"
+		});
+	};
+	provider.textEmbeddingModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "embeddingModel"
+		});
+	};
+	provider.imageModel = (modelId) => {
+		throw new NoSuchModelError({
+			modelId,
+			modelType: "imageModel"
+		});
+	};
+	return provider;
+}
+/**
+* Default provider instance using `OPENAI_CODEX_API_KEY`.
+*/
+const openaiCodex = createOpenAICodex();
+//#endregion
+export { appendOpenAICodexGrammarInputJsonDelta as _, OpenAICodexLanguageModel as a, resolveOpenAICodexDeferredToolsMode as b, convertOpenAICodexUsage as c, convertToOpenAICodexPrompt as d, joinToolCallId as f, shortHash as g, openAICodexErrorMessage as h, OPENAI_CODEX_DEFAULT_BASE_URL as i, mapOpenAICodexFinishReason as l, createOpenAICodexAPICallError as m, createOpenAICodex as n, clampOpenAICodexPromptCacheKey as o, splitToolCallId as p, openaiCodex as r, resolveOpenAICodexUrl as s, OPENAI_CODEX_API_KEY_ENV as t, collectOpenAICodexDeferredToolNames as u, openAICodexTools as v, resolveOpenAICodexToolConstraint as x, prepareOpenAICodexTools as y };
+
+//# sourceMappingURL=openai-codex-_3XkJ4bs.mjs.map