@codeworksh/aikit 0.7.2 → 0.8.0-dev.20260905193244

package/{openai-codex-_3XkJ4bs.mjs → openai-codex-t4B7g-gv.mjs}

@@ -1,5 +1,359 @@
-import { o as getOpenAICodexAccountId } from "./codex-DyQHzQmn.mjs";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as FailureSchema } from "./schema-rXSoWhic.mjs";
+import { a as KnownProviderEnumSchema, o as ProviderInfo } from "./model-CBnredXj.mjs";
+import { o as getOpenAICodexAccountId } from "./codex-MtP1574D.mjs";
+import Type$1 from "typebox";
+import { uuidv7 } from "uuidv7";
 import { APICallError, LoadAPIKeyError, NoSuchModelError } from "@ai-sdk/provider";
+import { EventSourceParserStream } from "eventsource-parser/stream";
+//#region src/message/message.ts
+var message_exports = /* @__PURE__ */ __exportAll({
+	AssistantMessageSchema: () => AssistantMessageSchema,
+	ConstrainedSamplingSchema: () => ConstrainedSamplingSchema,
+	ContextSchema: () => ContextSchema,
+	GrammarVariantsSchema: () => GrammarVariantsSchema,
+	ImageContentSchema: () => ImageContentSchema,
+	MessageSchema: () => MessageSchema,
+	StopReasonSchema: () => StopReasonSchema,
+	TextContentSchema: () => TextContentSchema,
+	ThinkingContentSchema: () => ThinkingContentSchema,
+	ToolAbortedSchema: () => ToolAbortedSchema,
+	ToolCallAbortedPartSchema: () => ToolCallAbortedPartSchema,
+	ToolCallBaseSchema: () => ToolCallBaseSchema,
+	ToolCallCompletedPartSchema: () => ToolCallCompletedPartSchema,
+	ToolCallErrorPartSchema: () => ToolCallErrorPartSchema,
+	ToolCallInFlightSchema: () => ToolCallInFlightSchema,
+	ToolCallPendingPartSchema: () => ToolCallPendingPartSchema,
+	ToolCallRunningPartSchema: () => ToolCallRunningPartSchema,
+	ToolCallSchema: () => ToolCallSchema,
+	ToolCallSkippedPartSchema: () => ToolCallSkippedPartSchema,
+	ToolCallTerminalPartSchema: () => ToolCallTerminalPartSchema,
+	ToolCompletedSchema: () => ToolCompletedSchema,
+	ToolErrorResult: () => ToolErrorResult,
+	ToolErrorSchema: () => ToolErrorSchema,
+	ToolRunningPartial: () => ToolRunningPartial,
+	ToolRunningSchema: () => ToolRunningSchema,
+	ToolSchema: () => ToolSchema,
+	ToolSkippedSchema: () => ToolSkippedSchema,
+	ToolStatusEnum: () => ToolStatusEnum,
+	ToolSuccessResult: () => ToolSuccessResult,
+	UsageSchema: () => UsageSchema,
+	UserMessageSchema: () => UserMessageSchema,
+	createAssistantMessage: () => createAssistantMessage,
+	createMessageId: () => createMessageId,
+	createUserMessage: () => createUserMessage,
+	defineTool: () => defineTool,
+	resolveJsonSchemaConstraint: () => resolveJsonSchemaConstraint,
+	transformMessages: () => transformMessages
+});
+const TextContentSchema = Type$1.Object({
+	type: Type$1.Literal("text"),
+	text: Type$1.String(),
+	textSignature: Type$1.Optional(Type$1.String())
+});
+const ImageContentSchema = Type$1.Object({
+	type: Type$1.Literal("image"),
+	data: Type$1.String(),
+	mimeType: Type$1.String()
+});
+const ThinkingContentSchema = Type$1.Object({
+	type: Type$1.Literal("thinking"),
+	thinking: Type$1.String(),
+	thinkingSignature: Type$1.Optional(Type$1.String()),
+	/** When true, the thinking content was redacted by safety filters. The opaque
+	*  encrypted payload is stored in `thinkingSignature` so it can be passed back
+	*  to the API for multi-turn continuity. */
+	redacted: Type$1.Optional(Type$1.Boolean())
+});
+const ToolCallBaseSchema = Type$1.Object({
+	type: Type$1.Literal("toolCall"),
+	callID: Type$1.String(),
+	name: Type$1.String(),
+	arguments: Type$1.Record(Type$1.String(), Type$1.Any()),
+	thoughtSignature: Type$1.Optional(Type$1.String()),
+	namespace: Type$1.Optional(Type$1.String()),
+	/** Names from Context.tools that became available after this tool result. */
+	addedToolNames: Type$1.Optional(Type$1.Array(Type$1.String())),
+	time: Type$1.Object({
+		start: Type$1.Number(),
+		end: Type$1.Number()
+	})
+});
+const ToolSuccessResult = Type$1.Object({
+	content: Type$1.Array(Type$1.Union([TextContentSchema, ImageContentSchema])),
+	details: Type$1.Optional(Type$1.Any()),
+	isError: Type$1.Literal(false)
+});
+const ToolErrorResult = Type$1.Object({
+	content: Type$1.Array(Type$1.Union([TextContentSchema, ImageContentSchema])),
+	details: Type$1.Optional(Type$1.Any()),
+	isError: Type$1.Literal(true)
+});
+const ToolRunningPartial = Type$1.Object({
+	content: Type$1.Optional(Type$1.Array(Type$1.Union([TextContentSchema, ImageContentSchema]))),
+	details: Type$1.Optional(Type$1.Any())
+});
+const ToolStatusEnum = {
+	pending: "pending",
+	running: "running",
+	completed: "completed",
+	error: "error",
+	skipped: "skipped",
+	aborted: "aborted"
+};
+const ToolRunningSchema = Type$1.Object({
+	status: Type$1.Literal(ToolStatusEnum.running),
+	partial: Type$1.Optional(ToolRunningPartial)
+});
+const ToolCompletedSchema = Type$1.Object({
+	status: Type$1.Literal(ToolStatusEnum.completed),
+	result: ToolSuccessResult
+});
+const ToolErrorSchema = Type$1.Object({
+	status: Type$1.Literal(ToolStatusEnum.error),
+	result: ToolErrorResult
+});
+const ToolSkippedSchema = Type$1.Object({
+	status: Type$1.Literal(ToolStatusEnum.skipped),
+	result: ToolErrorResult
+});
+const ToolAbortedSchema = Type$1.Object({
+	status: Type$1.Literal(ToolStatusEnum.aborted),
+	result: ToolErrorResult
+});
+const ToolCallPendingPartSchema = Type$1.Intersect([ToolCallBaseSchema, Type$1.Object({ status: Type$1.Literal(ToolStatusEnum.pending) })]);
+const ToolCallRunningPartSchema = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolRunningSchema]));
+const ToolCallCompletedPartSchema = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolCompletedSchema]));
+const ToolCallErrorPartSchema = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolErrorSchema]));
+const ToolCallSkippedPartSchema = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolSkippedSchema]));
+const ToolCallAbortedPartSchema = Type$1.Evaluate(Type$1.Intersect([ToolCallBaseSchema, ToolAbortedSchema]));
+const ToolCallTerminalPartSchema = Type$1.Union([
+	ToolCallCompletedPartSchema,
+	ToolCallErrorPartSchema,
+	ToolCallSkippedPartSchema,
+	ToolCallAbortedPartSchema
+]);
+const ToolCallInFlightSchema = Type$1.Object({
+	callID: Type$1.String(),
+	name: Type$1.String(),
+	rawArgs: Type$1.Record(Type$1.String(), Type$1.Unknown()),
+	args: Type$1.Optional(Type$1.Unknown())
+});
+const ToolCallSchema = Type$1.Union([
+	ToolCallPendingPartSchema,
+	ToolCallRunningPartSchema,
+	ToolCallTerminalPartSchema
+]);
+const UsageSchema = Type$1.Object({
+	input: Type$1.Number(),
+	output: Type$1.Number(),
+	cacheRead: Type$1.Number(),
+	cacheWrite: Type$1.Number(),
+	/** Subset of `cacheWrite` written with 1h retention. Only Anthropic reports this split. */
+	cacheWrite1h: Type$1.Optional(Type$1.Number()),
+	reasoning: Type$1.Optional(Type$1.Number()),
+	totalTokens: Type$1.Number(),
+	cost: Type$1.Object({
+		input: Type$1.Number(),
+		output: Type$1.Number(),
+		cacheRead: Type$1.Number(),
+		cacheWrite: Type$1.Number(),
+		total: Type$1.Number()
+	})
+});
+const StopReasonSchema = Type$1.Union([
+	Type$1.Literal("stop"),
+	Type$1.Literal("length"),
+	Type$1.Literal("toolUse"),
+	Type$1.Literal("error"),
+	Type$1.Literal("aborted")
+]);
+const UserMessageSchema = Type$1.Object({
+	messageId: Type$1.String(),
+	role: Type$1.Literal("user"),
+	time: Type$1.Object({ created: Type$1.Number() }),
+	parts: Type$1.Array(Type$1.Union([TextContentSchema, ImageContentSchema]))
+});
+const AssistantMessageSchema = Type$1.Object({
+	role: Type$1.Literal("assistant"),
+	protocol: KnownProviderEnumSchema,
+	provider: ProviderInfo,
+	model: Type$1.String(),
+	usage: UsageSchema,
+	stopReason: StopReasonSchema,
+	errorMessage: Type$1.Optional(Type$1.String()),
+	/**
+	* Structured, provider-independent failure details for a failed request.
+	* The schema is based on ai-sdk as the underlying provider wire protocol.
+	* Depends on ai-sdk
+	*/
+	failure: Type$1.Optional(FailureSchema),
+	time: Type$1.Object({
+		created: Type$1.Number(),
+		completed: Type$1.Number()
+	}),
+	parts: Type$1.Array(Type$1.Union([
+		TextContentSchema,
+		ImageContentSchema,
+		ThinkingContentSchema,
+		ToolCallSchema
+	])),
+	responseId: Type$1.Optional(Type$1.String()),
+	responseModel: Type$1.Optional(Type$1.String()),
+	messageId: Type$1.String()
+});
+const MessageSchema = Type$1.Union([UserMessageSchema, AssistantMessageSchema]);
+function createMessageId() {
+	return uuidv7();
+}
+function createUserMessage(message) {
+	const { messageId = createMessageId(), ...rest } = message;
+	return {
+		messageId,
+		...rest
+	};
+}
+function createAssistantMessage(message) {
+	const { messageId = createMessageId(), ...rest } = message;
+	return {
+		messageId,
+		...rest
+	};
+}
+const GrammarVariantsSchema = Type$1.Partial(Type$1.Object({
+	openai_lark: Type$1.String(),
+	openai_regex: Type$1.String()
+}));
+const ConstrainedSamplingSchema = Type$1.Union([Type$1.Object({
+	type: Type$1.Literal("json_schema"),
+	strict: Type$1.Union([Type$1.Literal("prefer"), Type$1.Literal("require")])
+}), Type$1.Object({
+	type: Type$1.Literal("grammar"),
+	variants: GrammarVariantsSchema
+})]);
+/**
+* Generic tool definition with typed parameter schema.
+* Usage:
+*
+* const search = Message.defineTool({
+*   name: "search",
+*   description: "Search documents",
+*   parameters: Type.Object({
+*     query: Type.String(),
+*     limit: Type.Optional(Type.Number()),
+*   }),
+* });
+*
+* type SearchParams = Static<typeof search.parameters>;
+*/
+const ToolSchema = Type$1.Object({
+	name: Type$1.String(),
+	description: Type$1.String(),
+	parameters: Type$1.Unsafe({}),
+	constrainedSampling: Type$1.Optional(Type$1.Union([Type$1.Literal(false), ConstrainedSamplingSchema]))
+});
+function defineTool(tool) {
+	return tool;
+}
+function resolveJsonSchemaConstraint(tool, compat) {
+	const config = tool.constrainedSampling;
+	if (!config || config.type !== "json_schema") return;
+	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.`);
+}
+const ContextSchema = Type$1.Object({
+	systemPrompt: Type$1.Optional(Type$1.String()),
+	messages: Type$1.Array(MessageSchema),
+	tools: Type$1.Optional(Type$1.Array(ToolSchema))
+});
+function isUnresolvedToolCall(toolCall) {
+	return toolCall.status === ToolStatusEnum.pending || toolCall.status === ToolStatusEnum.running;
+}
+function syntheticSkippedToolCall(toolCall) {
+	const { status: _status, partial: _partial, ...base } = toolCall;
+	return {
+		...base,
+		status: ToolStatusEnum.skipped,
+		result: {
+			content: [{
+				type: "text",
+				text: "no result provided"
+			}],
+			isError: true
+		},
+		time: {
+			...toolCall.time,
+			end: Math.max(toolCall.time.end, Date.now())
+		}
+	};
+}
+function transformMessages(messages, model, normalizeToolCallId) {
+	const toolCallIDMap = /* @__PURE__ */ new Map();
+	const transformed = [];
+	for (const msg of messages) {
+		if (msg.role === "user") {
+			transformed.push(msg);
+			continue;
+		}
+		const assistantMsg = msg;
+		const isSameModel = assistantMsg.provider.id === model.provider.id && assistantMsg.protocol === model.protocol && assistantMsg.model === model.id;
+		const parts = assistantMsg.parts.flatMap((block) => {
+			if (block.type === "thinking") {
+				if (isSameModel && block.thinkingSignature) return block;
+				if (!block.thinking || block.thinking.trim() === "") return [];
+				if (isSameModel) return block;
+				return {
+					type: "text",
+					text: block.thinking
+				};
+			}
+			if (block.type === "text") {
+				if (isSameModel) return block;
+				return {
+					type: "text",
+					text: block.text
+				};
+			}
+			if (block.type === "toolCall") {
+				const toolCall = block;
+				let normalizedToolCall = toolCall;
+				if (!isSameModel && toolCall.thoughtSignature) {
+					normalizedToolCall = { ...toolCall };
+					delete normalizedToolCall.thoughtSignature;
+				}
+				const normalizedID = toolCallIDMap.get(block.callID);
+				if (normalizedID && normalizedID !== block.callID) normalizedToolCall = {
+					...normalizedToolCall,
+					callID: normalizedID
+				};
+				else if (!isSameModel && normalizeToolCallId) {
+					const nextID = normalizeToolCallId(toolCall.callID, model, assistantMsg);
+					if (nextID !== toolCall.callID) {
+						toolCallIDMap.set(toolCall.callID, nextID);
+						normalizedToolCall = {
+							...normalizedToolCall,
+							callID: nextID
+						};
+					}
+				}
+				return normalizedToolCall;
+			}
+			return block;
+		}).map((block) => {
+			if (block.type === "toolCall" && isUnresolvedToolCall(block)) return syntheticSkippedToolCall(block);
+			return block;
+		});
+		transformed.push({
+			...assistantMsg,
+			parts
+		});
+	}
+	return transformed;
+}
+//#endregion
 //#region src/providers/openai-codex/codex-tools.ts
 function appendOpenAICodexGrammarInputJsonDelta(buffer, inputProperty, nextInput, close) {
 	if (buffer.closed) {
@@ -34,14 +388,7 @@ function inferGrammarInputProperty(parameters) {
 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 (config.type === "json_schema") return resolveJsonSchemaConstraint(tool, compat);
 	if (!(compat?.supportsOpenAIGrammarTools ?? false)) return void 0;
 	const lark = config.variants.openai_lark;
 	const regex = config.variants.openai_regex;
@@ -57,7 +404,7 @@ function resolveOpenAICodexToolConstraint(tool, compat) {
 		};
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
+		throw new Error(`tool "${tool.name}" cannot use grammar constrained sampling: ${message}.`);
 	}
 }
 const openAICodexTools = { custom(args) {
@@ -71,22 +418,9 @@ const openAICodexTools = { custom(args) {
 		}
 	};
 } };
-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 resolveOpenAICodexDeferredToolsMode(compat) {
+	if (compat?.supportsAdditionalTools ?? false) return "additional-tools";
+	return compat?.supportsToolSearch ?? false ? "tool-search" : void 0;
 }
 function prepareOpenAICodexTools({ tools, toolChoice, deferredToolNames }) {
 	const warnings = [];
@@ -171,27 +505,83 @@ function shortHash(value) {
 }
 //#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);
+const asRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const asString$1 = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+function normalizeErrorPayload(value) {
+	const record = asRecord$1(value);
+	const source = asRecord$1(record?.error) ?? record ?? {};
+	const code = asString$1(source.code);
+	const type = asString$1(source.type);
+	const message = asString$1(source.message);
+	const planType = asString$1(source.plan_type);
+	return { error: {
+		...code !== void 0 && { code },
+		...type !== void 0 && { type },
+		...message !== void 0 && { message },
+		...planType !== void 0 && { plan_type: planType },
+		...typeof source.resets_at === "number" && { resets_at: source.resets_at }
+	} };
+}
+function parseErrorPayload(body) {
+	try {
+		return normalizeErrorPayload(JSON.parse(body));
+	} catch {
+		return;
+	}
+}
+function errorIdentifiers(error) {
+	return `${error?.code ?? ""} ${error?.type ?? ""}`.toLowerCase();
+}
+function hasIdentifier(error, identifiers) {
+	const value = errorIdentifiers(error);
+	return identifiers.some((identifier) => value.includes(identifier));
+}
+function isUsageLimitError(error) {
+	return hasIdentifier(error, [
+		"usage_limit_reached",
+		"gousagelimiterror",
+		"freeusagelimiterror"
+	]);
+}
+function isTerminalRateLimitError(body, payload = parseErrorPayload(body)) {
+	return isUsageLimitError(payload?.error) || hasIdentifier(payload?.error, ["usage_not_included", "insufficient_quota"]) || /GoUsageLimitError|FreeUsageLimitError|Monthly usage limit reached|available balance|out of budget|quota exceeded|billing/i.test(body);
+}
+function streamErrorStatus(error) {
+	if (isUsageLimitError(error) || hasIdentifier(error, [
+		"usage_not_included",
+		"insufficient_quota",
+		"rate_limit"
+	])) return 429;
+	if (hasIdentifier(error, ["server_is_overloaded", "slow_down"])) return 503;
+	if (hasIdentifier(error, [
+		"context_length_exceeded",
+		"invalid_prompt",
+		"bio_policy",
+		"cyber_policy",
+		"misalignment_policy_violation"
+	])) return 400;
+	return 500;
+}
+function retryAfterHeader(message) {
+	const match = message?.match(/try again in\s*(\d+(?:\.\d+)?)\s*(s|ms|seconds?)/i);
+	if (!match) return {};
+	const value = Number(match[1]);
+	if (!Number.isFinite(value)) return {};
+	return { "retry-after": String(match[2]?.toLowerCase() === "ms" ? value / 1e3 : value) };
 }
 /**
-* Turn a Codex error payload into a human-friendly message. ChatGPT plan usage
-* limits deserve a clearer message than the raw backend error.
+* Turn a Codex error payload into a human-friendly message. Only terminal
+* ChatGPT plan exhaustion is rewritten; transient 429s retain backend detail.
 */
-function openAICodexErrorMessage(status, body, statusText) {
+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 {}
+	const error = parseErrorPayload(body)?.error;
+	if (isUsageLimitError(error)) {
+		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();
+	}
+	if (error?.message) message = error.message;
 	return message;
 }
 async function createOpenAICodexAPICallError(args) {
@@ -201,6 +591,7 @@ async function createOpenAICodexAPICallError(args) {
 	response.headers.forEach((value, key) => {
 		responseHeaders[key] = value;
 	});
+	const data = parseErrorPayload(responseBody);
 	return new APICallError({
 		message: openAICodexErrorMessage(response.status, responseBody, response.statusText),
 		url,
@@ -208,7 +599,40 @@ async function createOpenAICodexAPICallError(args) {
 		statusCode: response.status,
 		responseHeaders,
 		responseBody,
-		isRetryable: response.status === 408 || response.status === 409 || response.status === 429 && !isTerminalRateLimitError(responseBody) || response.status >= 500
+		...data !== void 0 && { data },
+		isRetryable: response.status === 408 || response.status === 409 || response.status === 429 && !isTerminalRateLimitError(responseBody, data) || response.status >= 500
+	});
+}
+/** Map an error embedded in a successful SSE response to the same API error shape as HTTP failures. */
+function createOpenAICodexStreamError(args) {
+	const { error: value, url, requestBodyValues } = args;
+	const data = normalizeErrorPayload(value);
+	const error = data.error;
+	const statusCode = streamErrorStatus(error);
+	const responseBody = JSON.stringify(data);
+	const responseHeaders = {
+		...args.responseHeaders,
+		...retryAfterHeader(error?.message)
+	};
+	return new APICallError({
+		message: openAICodexErrorMessage(statusCode, responseBody),
+		url,
+		requestBodyValues,
+		statusCode,
+		responseHeaders,
+		responseBody,
+		data,
+		isRetryable: statusCode >= 500 || hasIdentifier(error, ["rate_limit"]) && !isTerminalRateLimitError(responseBody, data)
+	});
+}
+/** A transport failure used when an SSE response ends without a terminal Responses event. */
+function createOpenAICodexPrematureCloseError(args) {
+	return new APICallError({
+		message: "OpenAI Codex stream closed before response.completed",
+		url: args.url,
+		requestBodyValues: args.requestBodyValues,
+		...args.responseHeaders !== void 0 && { responseHeaders: args.responseHeaders },
+		isRetryable: true
 	});
 }
 //#endregion
@@ -294,9 +718,9 @@ function toolResultOutput(output, supportsImages) {
 	}
 }
 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}".`);
+	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}".`);
+	if (typeof value !== "string") throw new Error(`custom tool "${toolName}" requires string input property "${inputProperty}".`);
 	return value;
 }
 function customToolOutput(output, supportsImages) {
@@ -346,7 +770,7 @@ function collectOpenAICodexDeferredToolNames(prompt) {
 	return deferredNames;
 }
 function deferredToolCallId(toolCallId, names) {
-	return `aikit_tool_load_${shortHash(`${toolCallId}:${names.join(",")}`)}`;
+	return `cdwrk_aikit_tool_${shortHash(`${toolCallId}:${names.join(",")}`)}`;
 }
 /**
 * Convert an AI SDK V3 prompt into the Codex Responses request shape.
@@ -432,7 +856,7 @@ function convertToOpenAICodexPrompt(prompt, options) {
 				input.push({
 					type: "message",
 					role: "assistant",
-					id: typeof messageId === "string" && messageId.length <= 64 ? messageId : `msg_aikit_${syntheticMessageCounter}`,
+					id: typeof messageId === "string" && messageId.length <= 64 ? messageId : `msg_cdwrk_aikit_${syntheticMessageCounter}`,
 					content: [{
 						type: "output_text",
 						text: part.text,
@@ -486,40 +910,29 @@ function convertToOpenAICodexPrompt(prompt, options) {
 }
 //#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.
-*/
+/** Parse standards-compliant event streams from the Codex Responses endpoint. */
 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");
-			}
+		transform(chunk, controller) {
+			const text = decoder.decode(chunk, { stream: true });
+			if (text) controller.enqueue(text);
 		},
 		flush(controller) {
-			buffer += decoder.decode();
-			if (buffer.trim()) parseChunk(buffer, controller);
+			const text = decoder.decode();
+			if (text) controller.enqueue(text);
+		}
+	})).pipeThrough(new EventSourceParserStream({ onError: "terminate" })).pipeThrough(new TransformStream({ transform(event, controller) {
+		const data = event.data.trim();
+		if (!data || data === "[DONE]") return;
+		try {
+			const parsed = JSON.parse(data);
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new TypeError("codex SSE data must be a JSON object");
+			controller.enqueue(parsed);
+		} catch (cause) {
+			controller.error(new Error(`invalid OpenAI Codex SSE JSON: ${data.slice(0, 200)}`, { cause }));
 		}
-	}));
+	} }));
 }
 //#endregion
 //#region src/providers/openai-codex/codex-usage.ts
@@ -657,12 +1070,12 @@ var OpenAICodexLanguageModel = class {
 			type: "unsupported",
 			feature: "maxOutputTokens"
 		});
-		if (options.responseFormat && options.responseFormat.type !== "text") warnings.push({
+		if (options.responseFormat?.type === "json" && options.responseFormat.schema === void 0) warnings.push({
 			type: "unsupported",
 			feature: "responseFormat"
 		});
 		const codexOptions = options.providerOptions?.["openai-codex"] ?? {};
-		const deferredToolsMode = resolveOpenAICodexDeferredToolsMode(this.modelId, this.config.compat);
+		const deferredToolsMode = resolveOpenAICodexDeferredToolsMode(this.config.compat);
 		const deferredToolNames = deferredToolsMode ? collectOpenAICodexDeferredToolNames(options.prompt) : void 0;
 		const tools = prepareOpenAICodexTools({
 			tools: options.tools,
@@ -673,9 +1086,16 @@ var OpenAICodexLanguageModel = class {
 			deferredTools: tools.deferredCodexTools,
 			...deferredToolsMode !== void 0 && { deferredToolsMode },
 			grammarToolInputProperties: tools.grammarToolInputProperties,
-			supportsImages: this.config.compat?.supportsImages ?? this.modelId !== "gpt-5.3-codex-spark"
+			supportsImages: this.config.compat?.supportsImages ?? false
 		});
 		warnings.push(...tools.warnings);
+		const text = { verbosity: codexOptions.textVerbosity ?? "low" };
+		if (options.responseFormat?.type === "json" && options.responseFormat.schema !== void 0) text.format = {
+			type: "json_schema",
+			strict: true,
+			schema: options.responseFormat.schema,
+			name: options.responseFormat.name ?? "codex_output_schema"
+		};
 		const args = {
 			model: this.modelId,
 			store: false,
@@ -683,12 +1103,12 @@ var OpenAICodexLanguageModel = class {
 			input,
 			tool_choice: tools.codexToolChoice ?? "auto",
 			parallel_tool_calls: true,
-			include: codexOptions.include ?? ["reasoning.encrypted_content"],
-			text: { verbosity: codexOptions.textVerbosity ?? "low" }
+			include: ["reasoning.encrypted_content"],
+			text
 		};
 		if (tools.codexTools) args.tools = tools.codexTools;
 		if (options.temperature != null) args.temperature = options.temperature;
-		const promptCacheKey = clampOpenAICodexPromptCacheKey(codexOptions.promptCacheKey ?? this.config.sessionId);
+		const promptCacheKey = clampOpenAICodexPromptCacheKey(this.config.sessionId);
 		if (promptCacheKey) args.prompt_cache_key = promptCacheKey;
 		const serviceTier = codexOptions.serviceTier ?? this.config.serviceTier;
 		if (serviceTier) args.service_tier = serviceTier;
@@ -813,18 +1233,22 @@ var OpenAICodexLanguageModel = class {
 			url,
 			requestBodyValues: body
 		});
-		if (!response.body) throw new Error("OpenAI Codex response has no 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)),
+			stream: parseOpenAICodexSSEStream(response.body).pipeThrough(this.createTransformStream(warnings, options.includeRawChunks ?? false, grammarToolInputProperties, {
+				url,
+				requestBodyValues: body,
+				responseHeaders
+			})),
 			request: { body },
 			response: { headers: responseHeaders }
 		};
 	}
-	createTransformStream(warnings, includeRawChunks, grammarToolInputProperties) {
+	createTransformStream(warnings, includeRawChunks, grammarToolInputProperties, request) {
 		let finishReason = {
 			unified: "other",
 			raw: void 0
@@ -832,6 +1256,7 @@ var OpenAICodexLanguageModel = class {
 		let usage;
 		let hasToolCalls = false;
 		let finished = false;
+		let servedServiceTier;
 		const toolCallIdsByItemId = /* @__PURE__ */ new Map();
 		const customToolInputsByItemId = /* @__PURE__ */ new Map();
 		const finish = (controller) => {
@@ -840,8 +1265,18 @@ var OpenAICodexLanguageModel = class {
 			controller.enqueue({
 				type: "finish",
 				finishReason,
-				usage: convertOpenAICodexUsage(usage)
+				usage: convertOpenAICodexUsage(usage),
+				...servedServiceTier === void 0 ? {} : { providerMetadata: { "openai-codex": { serviceTier: servedServiceTier } } }
+			});
+		};
+		const fail = (controller, error) => {
+			if (finished) return;
+			finished = true;
+			controller.enqueue({
+				type: "error",
+				error
 			});
+			controller.terminate();
 		};
 		const handleOutputItemAdded = (item, controller) => {
 			const itemType = asString(item.type);
@@ -1034,10 +1469,10 @@ var OpenAICodexLanguageModel = class {
 						break;
 					}
 					case "response.completed":
-					case "response.done":
 					case "response.incomplete": {
 						const response = asRecord(event.response);
 						usage = response?.usage ?? usage;
+						servedServiceTier = asString(response?.service_tier) ?? servedServiceTier;
 						const status = asString(response?.status) ?? (type === "response.incomplete" ? "incomplete" : "completed");
 						const incompleteReason = asString(asRecord(response?.incomplete_details)?.reason);
 						finishReason = mapOpenAICodexFinishReason(status, hasToolCalls, incompleteReason);
@@ -1051,29 +1486,31 @@ var OpenAICodexLanguageModel = class {
 							unified: "error",
 							raw: "failed"
 						};
-						controller.enqueue({
-							type: "error",
-							error: new Error(asString(error?.message) ?? "OpenAI Codex response failed")
-						});
+						fail(controller, createOpenAICodexStreamError({
+							error: error ?? { message: "OpenAI Codex response failed" },
+							...request
+						}));
 						break;
 					}
-					case "error": {
-						const code = asString(event.code);
-						const message = asString(event.message);
+					case "error":
 						finishReason = {
 							unified: "error",
-							raw: code ?? "error"
+							raw: asString(event.code) ?? "error"
 						};
-						controller.enqueue({
-							type: "error",
-							error: /* @__PURE__ */ new Error(`OpenAI Codex error${code ? ` ${code}` : ""}: ${message ?? JSON.stringify(event)}`)
-						});
-						break;
-					}
+						fail(controller, createOpenAICodexStreamError({
+							error: event,
+							...request
+						}));
 				}
 			},
 			flush(controller) {
-				finish(controller);
+				if (!finished) {
+					finished = true;
+					controller.enqueue({
+						type: "error",
+						error: createOpenAICodexPrematureCloseError(request)
+					});
+				}
 			}
 		});
 	}
@@ -1122,7 +1559,7 @@ function createOpenAICodex(options = {}) {
 		...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.");
+		if (new.target) throw new Error("openAI codex model function cannot be called with the new keyword.");
 		return createLanguageModel(modelId);
 	};
 	provider.specificationVersion = "v3";
@@ -1153,6 +1590,6 @@ function createOpenAICodex(options = {}) {
 */
 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 };
+export { ToolCallSchema as C, transformMessages as D, resolveJsonSchemaConstraint as E, AssistantMessageSchema as S, message_exports as T, 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, createAssistantMessage as w, resolveOpenAICodexToolConstraint as x, prepareOpenAICodexTools as y };
 
-//# sourceMappingURL=openai-codex-_3XkJ4bs.mjs.map
+//# sourceMappingURL=openai-codex-t4B7g-gv.mjs.map