@codeworksh/aikit 0.6.0-dev.20260613095948 → 0.7.0

package/openai-codex-CZrBnLAJ.mjs

@@ -1,753 +0,0 @@
-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