@codeworksh/aikit 0.4.1-dev.20260531052349 → 0.5.1-dev.20260613074656

package/openai-codex-CZrBnLAJ.mjs

@@ -0,0 +1,753 @@
+import { o as getOpenAICodexAccountId } from "./codex-C36oU6yH.mjs";
+import { APICallError, LoadAPIKeyError, NoSuchModelError } from "@ai-sdk/provider";
+//#region src/providers/openai-codex/codex-error.ts
+/**
+* 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 >= 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)}`;
+}
+function toolResultOutputToText(output) {
+	switch (output.type) {
+		case "text":
+		case "error-text": return output.value;
+		case "json":
+		case "error-json": return JSON.stringify(output.value);
+		case "execution-denied": return output.reason ?? "Tool execution denied";
+		case "content": return output.value.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+		default: return JSON.stringify(output);
+	}
+}
+/**
+* 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) {
+	let instructions;
+	const input = [];
+	let syntheticMessageCounter = 0;
+	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": {
+			const textParts = [];
+			for (const part of message.content) if (part.type === "text") textParts.push(part.text);
+			else if (part.type === "tool-call") {
+				const { callId, itemId } = splitToolCallId(part.toolCallId);
+				input.push({
+					type: "function_call",
+					id: itemId,
+					call_id: callId,
+					name: part.toolName,
+					arguments: typeof part.input === "string" ? part.input : JSON.stringify(part.input ?? {})
+				});
+			}
+			if (textParts.length > 0) {
+				syntheticMessageCounter++;
+				input.push({
+					type: "message",
+					role: "assistant",
+					id: `msg_${Date.now()}_${syntheticMessageCounter}`,
+					content: [{
+						type: "output_text",
+						text: textParts.join("\n"),
+						annotations: []
+					}],
+					status: "completed"
+				});
+			}
+			break;
+		}
+		case "tool":
+			for (const part of message.content) {
+				if (part.type !== "tool-result") continue;
+				const { callId } = splitToolCallId(part.toolCallId);
+				input.push({
+					type: "function_call_output",
+					call_id: callId,
+					output: toolResultOutputToText(part.output)
+				});
+			}
+			break;
+	}
+	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-tools.ts
+function prepareOpenAICodexTools({ tools, toolChoice }) {
+	const warnings = [];
+	if (!tools || tools.length === 0) return {
+		codexTools: void 0,
+		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;
+		}
+		codexTools.push({
+			type: "function",
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.inputSchema,
+			strict: null
+		});
+	}
+	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";
+			break;
+	}
+	return {
+		codexTools: codexTools.length > 0 ? codexTools : void 0,
+		codexToolChoice,
+		warnings
+	};
+}
+//#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 outputTotal = usage?.output_tokens;
+	const reasoningTokens = usage?.output_tokens_details?.reasoning_tokens ?? 0;
+	return {
+		inputTokens: {
+			total: inputTotal,
+			noCache: inputTotal === void 0 ? void 0 : inputTotal - cachedTokens,
+			cacheRead: inputTotal === void 0 ? void 0 : cachedTokens,
+			cacheWrite: inputTotal === void 0 ? void 0 : 0
+		},
+		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) {
+	switch (status) {
+		case "completed": return {
+			unified: hasToolCalls ? "tool-calls" : "stop",
+			raw: status
+		};
+		case "incomplete": return {
+			unified: "length",
+			raw: 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";
+/**
+* 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 { instructions, input } = convertToOpenAICodexPrompt(options.prompt);
+		const tools = prepareOpenAICodexTools({
+			tools: options.tools,
+			toolChoice: options.toolChoice
+		});
+		warnings.push(...tools.warnings);
+		const args = {
+			model: this.modelId,
+			store: codexOptions.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 = 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
+		};
+	}
+	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 "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 "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 !== "" : true),
+			finishReason,
+			usage,
+			request,
+			response: {
+				...response,
+				id: responseId,
+				modelId: responseModelId
+			},
+			warnings
+		};
+	}
+	async doStream(options) {
+		const { args, warnings } = this.getArgs(options);
+		const body = {
+			...args,
+			stream: true
+		};
+		const url = resolveOpenAICodexUrl(this.config.baseURL);
+		const headers = cleanHeaders({
+			...await this.config.headers(),
+			...options.headers
+		});
+		const response = await (this.config.fetch ?? globalThis.fetch)(url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+			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)),
+			request: { body },
+			response: { headers: responseHeaders }
+		};
+	}
+	createTransformStream(warnings, includeRawChunks) {
+		let finishReason = {
+			unified: "other",
+			raw: void 0
+		};
+		let usage;
+		let hasToolCalls = false;
+		const toolCallIdsByItemId = /* @__PURE__ */ new Map();
+		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) ?? ""
+				});
+			}
+		};
+		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
+			});
+			else if (itemType === "reasoning") controller.enqueue({
+				type: "reasoning-end",
+				id: itemId
+			});
+			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) ?? ""
+				});
+			}
+		};
+		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);
+						controller.enqueue({
+							type: "response-metadata",
+							id: asString(response?.id),
+							modelId: asString(response?.model)
+						});
+						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.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;
+						finishReason = mapOpenAICodexFinishReason(asString(response?.status) ?? (type === "response.incomplete" ? "incomplete" : "completed"), hasToolCalls);
+						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;
+					}
+					default: break;
+				}
+			},
+			flush(controller) {
+				controller.enqueue({
+					type: "finish",
+					finishReason,
+					usage: convertOpenAICodexUsage(usage)
+				});
+			}
+		});
+	}
+};
+//#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 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",
+			...options.sessionId ? {
+				"session-id": options.sessionId,
+				"x-client-request-id": options.sessionId
+			} : {},
+			...options.headers
+		};
+	};
+	const createLanguageModel = (modelId) => new OpenAICodexLanguageModel(modelId, {
+		provider: "openai-codex",
+		baseURL,
+		headers: getHeaders,
+		fetch: options.fetch,
+		sessionId: options.sessionId,
+		serviceTier: options.serviceTier
+	});
+	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 { OpenAICodexLanguageModel as a, mapOpenAICodexFinishReason as c, joinToolCallId as d, splitToolCallId as f, OPENAI_CODEX_DEFAULT_BASE_URL as i, prepareOpenAICodexTools as l, openAICodexErrorMessage as m, createOpenAICodex as n, resolveOpenAICodexUrl as o, createOpenAICodexAPICallError as p, openaiCodex as r, convertOpenAICodexUsage as s, OPENAI_CODEX_API_KEY_ENV as t, convertToOpenAICodexPrompt as u };
+
+//# sourceMappingURL=openai-codex-CZrBnLAJ.mjs.map