@xiaoso/dsh-tool-plus 0.1.0-beta.2 → 0.1.0-beta.4

package/lib/openai-codex-responses-pejZgdZo.mjs

@@ -0,0 +1,3144 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { r as __exportAll } from "./fs-promises-shim-Bx0fpxuk.mjs";
+import { B as USER_AGENT, C as error, I as $flag, P as $env, S as debug, g as parseStreamingJson, o as readSseJson, q as getInstallId, t as structuredCloneJSON, w as time } from "./src-BgpusnsB.mjs";
+import { G as fetchWithRetry, V as ProviderHttpError, g as MissingApiKeyError, l as finalize, v as AbortError } from "./error-Dd8DIqs-.mjs";
+import { A as NO_STRICT, C as kStreamingPartialJson, L as sanitizeSchemaForOpenAIResponses, a as normalizeSystemPrompts, c as sanitizeOpenAIResponsesAssistantFallbackItemsForReplay, d as stripOpenAIResponsesComputerLinkedReasoningIdsForReplay, h as clearStreamingPartialJson, j as adaptSchemaForStrict, k as toolWireSchema, l as sanitizeOpenAIResponsesAssistantHistoryItemsForReplay, m as transformMessages, n as getOpenAIResponsesHistoryItems, p as redactSensitiveInObject, r as getOpenAIResponsesHistoryPayload, t as createOpenAIResponsesHistoryPayload } from "./utils-Cp76gCyk.mjs";
+import { t as asRecord } from "./type-guards-B9VVjRDK.mjs";
+import { A as computerCallMetadata, B as finalizeCustomToolCallInputDone, E as buildResponsesDeltaInput, F as createSequentialCutoffSummaryState, H as finalizePendingResponsesToolCalls, K as getOpenAIPromptCacheKey, L as encodeResponsesToolCallId, M as convertResponsesInputContent, Q as isOpenAIResponsesProgressEvent, R as encodeTextSignatureV1, U as finalizeReasoningThinking, V as finalizeMessageText, W as finalizeToolCallArgumentsDone, X as hasExecutableIncompleteResponsesToolCalls, a as accumulateCustomToolCallInputDelta, at as populateResponsesUsageFromResponse, bt as escapeHarmonyControlTokens, c as appendMessageTextDelta, d as appendReasoningSummaryTextDelta, f as appendResponsesImageResult, j as convertResponsesAssistantMessage, l as appendReasoningSummaryPart, n as getEnvApiKey, nt as mapOpenAIResponsesStopReason, o as accumulateToolCallArgumentsDelta, p as appendResponsesToolResultMessages, r as isOfficialCodexApiUrl, rt as normalizeOpenAIPromptCacheKey, s as appendMessageContentPart, st as promoteResponsesToolUseStopReason, tt as mapOpenAIReasoningEffort, u as appendReasoningSummaryPartDone, x as applyReasoningSummaryDone, xt as isHarmonyDialectModel, y as applyOpenAIServiceTier, z as escapeReplayedControlTokens } from "./stream-CRtexYLe.mjs";
+import { r as getProxyForUrl } from "./proxy-pM_NIv-H.mjs";
+import { E as supportsCodexReasoningSummary, T as supportsAllTurnsReasoningContext, s as requireSupportedEffort, t as calculateCost } from "./models-SGASygJ3.mjs";
+import { a as toNumber } from "./utils-D2YknRk4.mjs";
+import "./identity-Da1GPU9a.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-BbFZJy-z.mjs";
+import { a as getCodexAccountId, i as OPENAI_HEADER_VALUES, n as CODEX_CLIENT_VERSION, r as OPENAI_HEADERS, t as CODEX_BASE_URL } from "./codex-P1dGpX7G.mjs";
+import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs, t as armPreResponseTimeout } from "./idle-iterator-DUjKQEGT.mjs";
+import { n as isRequestDebugEnabled, t as createRequestDebugSession } from "./request-debug-HJMoJncL.mjs";
+import { t as notifyRawSseEvent } from "./sse-debug-CYdjOC96.mjs";
+import { t as compactGrammarDefinition } from "./grammar-D-NqNUxQ.mjs";
+import { scheduler } from "node:timers/promises";
+import { type } from "@oh-my-pi/omptype";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/openai-codex/request-transformer.ts
+/** Caller literal → catalog `Effort` bridge (the enum is nominal). */
+const EFFORT_BY_NAME = {
+	minimal: "minimal",
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max"
+};
+/**
+* Resolve whether a Codex request uses the Responses Lite transport: an
+* explicit option wins, then the `PI_CODEX_RESPONSES_LITE` env override
+* (`1`/`true` forces Lite, `0`/`false` forces the full Responses body),
+* otherwise the model's catalog flag (codex-rs `model_info.use_responses_lite`)
+* decides.
+*/
+function resolveCodexResponsesLite(model, requested) {
+	if (requested !== void 0) return requested;
+	const env = $env.PI_CODEX_RESPONSES_LITE?.trim().toLowerCase();
+	if (env === "1" || env === "true") return true;
+	if (env === "0" || env === "false") return false;
+	return model.useResponsesLite === true;
+}
+/**
+* Whether to request `stream_options.reasoning_summary_delivery =
+* "sequential_cutoff"` (codex-rs `concurrent_reasoning_summaries`), enabled by
+* `PI_CODEX_CONCURRENT_SUMMARIES=1`.
+*
+* Off by default because the mode cancels summary sections still in flight when
+* the reasoning item closes: measured over 12 interleaved turns it halved
+* visible thinking (0.83 vs 1.67 summary parts, 37 vs 69 chars per turn) and
+* produced no summary at all on 3 of 12 turns. codex-rs ships it disabled too
+* (`Stage::UnderDevelopment`, `default_enabled: false`).
+*/
+function concurrentSummariesEnabled() {
+	const env = $env.PI_CODEX_CONCURRENT_SUMMARIES?.trim().toLowerCase();
+	return env === "1" || env === "true";
+}
+/**
+* Clamp a user-facing effort to the model's ladder, then remap to the wire
+* tier. User efforts map 1:1 onto wire tiers; the effort map only covers
+* host quirks where a wire tier genuinely does not exist (e.g. `minimal→none`).
+* A mapped value outside the Codex wire vocabulary is a broken compat/model
+* effort map — fail loudly rather than silently sending a different tier.
+*/
+function mapCodexWireEffort(model, effort) {
+	const mapped = mapOpenAIReasoningEffort(model, model.compat, requireSupportedEffort(model, EFFORT_BY_NAME[effort]));
+	switch (mapped) {
+		case "none":
+		case "minimal":
+		case "low":
+		case "medium":
+		case "high":
+		case "xhigh":
+		case "max": return mapped;
+		default: throw new Error(`Effort map for ${model.provider}/${model.id} produced invalid Codex reasoning effort "${mapped}"`);
+	}
+}
+function getReasoningConfig(model, effort, options) {
+	const config = { effort: effort === "none" ? "none" : mapCodexWireEffort(model, effort) };
+	if (options.reasoningSummary !== null && supportsCodexReasoningSummary(model.id)) config.summary = options.reasoningSummary ?? "auto";
+	return config;
+}
+function filterInput(input) {
+	if (!Array.isArray(input)) return input;
+	return input.filter((item) => item.type !== "item_reference").map((item) => {
+		if (item.type === "computer_call") return item;
+		if (item.id != null) {
+			const { id: _id, ...rest } = item;
+			return rest;
+		}
+		return item;
+	});
+}
+const CODEX_ORPHAN_OUTPUT_LIMIT = 16e3;
+/** Placeholder output for a tool call whose result never landed in the input. */
+const CODEX_INTERRUPTED_TOOL_OUTPUT = "[No tool output recorded: the tool call was interrupted before it produced a result.]";
+function orphanFunctionOutputToMessage(item, callId) {
+	const itemRecord = item;
+	const toolName = typeof itemRecord.name === "string" ? itemRecord.name : "tool";
+	let text = "";
+	try {
+		const output = itemRecord.output;
+		text = typeof output === "string" ? output : JSON.stringify(output);
+	} catch {
+		text = String(itemRecord.output ?? "");
+	}
+	if (text.length > CODEX_ORPHAN_OUTPUT_LIMIT) text = `${text.slice(0, CODEX_ORPHAN_OUTPUT_LIMIT)}\n...[truncated]`;
+	return {
+		type: "message",
+		role: "assistant",
+		content: `[Previous ${toolName} result; call_id=${callId}]: ${text}`
+	};
+}
+function toolCallKind(type) {
+	if (type === "function_call") return "function";
+	if (type === "custom_tool_call") return "custom";
+	if (type === "computer_call") return "computer";
+}
+function toolOutputKind(type) {
+	if (type === "function_call_output") return "function";
+	if (type === "custom_tool_call_output") return "custom";
+	if (type === "computer_call_output") return "computer";
+}
+/**
+* Repair both halves of unpaired tool exchanges so the Responses input grammar
+* stays valid — the API rejects either orphan with a 400:
+*
+* - `function_call_output` / `custom_tool_call_output` with no matching call →
+*   folded into an assistant message (`400 No tool call found for … output`).
+*   Regression of #472 / #1351.
+* - `function_call` / `custom_tool_call` with no matching `*_output` → a
+*   placeholder output is synthesized immediately after the call
+*   (`400 No tool output found for function call …`). Hit when the user
+*   branches/navigates the session tree to a node that ends on a tool call (the
+*   tool-result child is dropped from the reconstructed history) or when a turn
+*   is aborted/crashes after the call streamed but before its result persisted.
+*/
+function repairToolCallPairs(input) {
+	const callKinds = /* @__PURE__ */ new Map();
+	const outputKinds = /* @__PURE__ */ new Map();
+	for (const item of input) {
+		const callId = typeof item.call_id === "string" ? item.call_id : void 0;
+		if (callId === void 0) continue;
+		const callKind = toolCallKind(item.type);
+		const outputKind = toolOutputKind(item.type);
+		if (callKind) callKinds.set(callId, callKind);
+		if (outputKind) outputKinds.set(callId, outputKind);
+	}
+	const repaired = [];
+	for (const item of input) {
+		const callId = typeof item.call_id === "string" ? item.call_id : void 0;
+		const callKind = toolCallKind(item.type);
+		const outputKind = toolOutputKind(item.type);
+		if (outputKind && callId !== void 0 && callKinds.get(callId) !== outputKind) {
+			repaired.push(orphanFunctionOutputToMessage(item, callId));
+			continue;
+		}
+		if (callKind && callId !== void 0 && outputKinds.get(callId) !== callKind) {
+			if (callKind === "computer") {
+				repaired.push({
+					type: "message",
+					role: "assistant",
+					content: `[Computer call interrupted before a screenshot was recorded; call_id=${callId}]`
+				});
+				continue;
+			}
+			repaired.push(item, {
+				type: callKind === "custom" ? "custom_tool_call_output" : "function_call_output",
+				call_id: callId,
+				output: CODEX_INTERRUPTED_TOOL_OUTPUT
+			});
+			continue;
+		}
+		repaired.push(item);
+	}
+	return repaired;
+}
+/**
+* Responses Lite requests must not pin image detail levels: codex-rs strips
+* `detail` from every input image (message content and tool outputs) before
+* sending, letting the server choose.
+*/
+function stripImageDetails(input) {
+	for (const item of input) {
+		if (!item || typeof item !== "object") continue;
+		const content = "content" in item ? item.content : void 0;
+		const output = "output" in item ? item.output : void 0;
+		for (const collection of [content, output]) {
+			if (!Array.isArray(collection)) continue;
+			for (const part of collection) {
+				if (!part || typeof part !== "object") continue;
+				if (!("type" in part) || part.type !== "input_image") continue;
+				if ("detail" in part) part.detail = void 0;
+			}
+		}
+	}
+}
+/**
+* Applies the Responses Lite body contract in place (codex-rs
+* `build_responses_request` with `use_responses_lite`): strips pinned image
+* detail, forces parallel tool calling off, moves tools into a leading
+* `additional_tools` developer item and the base instructions into a
+* developer message, then omits top-level `instructions`/`tools`. Because the
+* rewrite removes top-level `tools`, a forced hosted-tool choice (e.g.
+* `{ type: "web_search" }`) would leave the backend unable to validate the
+* choice against a tools collection and it rejects the request with HTTP 400
+* (#5771). Native computer and named-function choices preserve exact forcing
+* by isolating the selected declaration and using `"required"`; other hosted
+* choices fall back to `"auto"`. Explicit string constraints such as `"none"`
+* and `"required"` remain valid. Shared by normal turns and both remote-compaction
+* paths — codex-rs routes `/responses/compact` through the same builder.
+*/
+function applyCodexResponsesLiteShape(body) {
+	const input = Array.isArray(body.input) ? body.input : [];
+	stripImageDetails(input);
+	body.parallel_tool_calls = false;
+	const declaredTools = Array.isArray(body.tools) ? body.tools : [];
+	let additionalTools = declaredTools;
+	if (body.tool_choice && typeof body.tool_choice === "object" && "type" in body.tool_choice) {
+		const choice = body.tool_choice;
+		const selected = declaredTools.find((tool) => {
+			if (tool === null || typeof tool !== "object" || !("type" in tool)) return false;
+			if (choice.type === "computer") return tool.type === "computer";
+			return choice.type === "function" && tool.type === "function" && "name" in choice && typeof choice.name === "string" && "name" in tool && tool.name === choice.name;
+		});
+		if (selected) {
+			additionalTools = [selected];
+			body.tool_choice = "required";
+		}
+	}
+	const prefix = [{
+		type: "additional_tools",
+		role: "developer",
+		tools: additionalTools
+	}];
+	if (typeof body.instructions === "string" && body.instructions.length > 0) prefix.push({
+		type: "message",
+		role: "developer",
+		content: [{
+			type: "input_text",
+			text: body.instructions
+		}]
+	});
+	body.input = [...prefix, ...input];
+	if (body.tool_choice !== "none" && body.tool_choice !== "required") body.tool_choice = "auto";
+	delete body.instructions;
+	delete body.tools;
+}
+async function transformRequestBody(body, model, options = {}, prompt) {
+	body.store = false;
+	body.stream = true;
+	if (body.input && Array.isArray(body.input)) {
+		body.input = filterInput(body.input);
+		if (body.input) body.input = repairToolCallPairs(body.input);
+	}
+	if (prompt?.developerMessages && prompt.developerMessages.length > 0) {
+		const developerMessages = prompt.developerMessages.map((text) => ({
+			type: "message",
+			role: "developer",
+			content: [{
+				type: "input_text",
+				text
+			}]
+		}));
+		const input = Array.isArray(body.input) ? body.input : [];
+		body.input = [...developerMessages, ...input];
+	}
+	let finalInstruction = prompt?.developerMessages.findLast((text) => text.trim().length > 0);
+	if (finalInstruction === void 0 && Array.isArray(body.input)) for (let itemIndex = body.input.length - 1; itemIndex >= 0; itemIndex -= 1) {
+		const item = body.input[itemIndex];
+		if (item.role !== "developer" || !Array.isArray(item.content)) continue;
+		for (let partIndex = item.content.length - 1; partIndex >= 0; partIndex -= 1) {
+			const part = item.content[partIndex];
+			if (part && typeof part === "object" && "type" in part && part.type === "input_text" && "text" in part && typeof part.text === "string" && part.text.trim().length > 0) {
+				finalInstruction = part.text;
+				break;
+			}
+		}
+		if (finalInstruction !== void 0) break;
+	}
+	if (finalInstruction === void 0 && typeof body.instructions === "string" && body.instructions.trim().length > 0) finalInstruction = body.instructions;
+	if (finalInstruction !== void 0) {
+		const input = Array.isArray(body.input) ? body.input : [];
+		let hasVisibleInput = false;
+		for (const item of input) if (item.role !== "developer") {
+			hasVisibleInput = true;
+			break;
+		}
+		if (!hasVisibleInput) body.input = [...input, {
+			type: "message",
+			role: "user",
+			content: [{
+				type: "input_text",
+				text: finalInstruction
+			}]
+		}];
+	}
+	const responsesLite = resolveCodexResponsesLite(model, options.responsesLite);
+	if (responsesLite) applyCodexResponsesLiteShape(body);
+	if (options.reasoningOff || options.reasoningEffort !== void 0 || responsesLite) {
+		const reasoningConfig = options.reasoningOff ? { effort: "none" } : options.reasoningEffort !== void 0 ? getReasoningConfig(model, options.reasoningEffort, options) : {};
+		body.reasoning = {
+			...body.reasoning,
+			...reasoningConfig
+		};
+		if (responsesLite) body.reasoning.context = "all_turns";
+		else if (options.reasoningContext !== void 0) {
+			if (options.reasoningContext === "all_turns" && !supportsAllTurnsReasoningContext(model.id)) delete body.reasoning.context;
+			else body.reasoning.context = options.reasoningContext;
+		}
+	} else delete body.reasoning;
+	if (model.reasoningMode && !options.reasoningOff) body.reasoning = {
+		...body.reasoning,
+		mode: model.reasoningMode
+	};
+	if (body.reasoning?.summary !== void 0 && concurrentSummariesEnabled()) body.stream_options = { reasoning_summary_delivery: "sequential_cutoff" };
+	else delete body.stream_options;
+	if (options.textVerbosity !== void 0) body.text = {
+		...body.text,
+		verbosity: options.textVerbosity
+	};
+	const include = Array.isArray(options.include) ? [...options.include] : [];
+	include.push("reasoning.encrypted_content");
+	body.include = Array.from(new Set(include));
+	delete body.max_output_tokens;
+	delete body.max_completion_tokens;
+	return body;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/openai-codex/response-handler.ts
+/** Non-2xx response from the Codex backend, with the parsed body retained. */
+var CodexApiError = class CodexApiError extends ProviderHttpError {
+	info;
+	constructor(info, headers) {
+		super(info.friendlyMessage || info.message, info.status, {
+			headers,
+			code: info.code
+		});
+		this.name = "CodexApiError";
+		this.info = info;
+	}
+	static async fromResponse(response) {
+		return new CodexApiError(await parseCodexError(response), response.headers);
+	}
+};
+async function parseCodexError(response) {
+	const raw = await response.text();
+	let message = raw || response.statusText || "Request failed";
+	let friendlyMessage;
+	let rateLimits;
+	let errorCode;
+	try {
+		const err = JSON.parse(raw)?.error ?? {};
+		const headers = response.headers;
+		const primary = {
+			used_percent: toNumber(headers.get("x-codex-primary-used-percent")),
+			window_minutes: toInt(headers.get("x-codex-primary-window-minutes")),
+			resets_at: toInt(headers.get("x-codex-primary-reset-at"))
+		};
+		const secondary = {
+			used_percent: toNumber(headers.get("x-codex-secondary-used-percent")),
+			window_minutes: toInt(headers.get("x-codex-secondary-window-minutes")),
+			resets_at: toInt(headers.get("x-codex-secondary-reset-at"))
+		};
+		rateLimits = primary.used_percent !== void 0 || secondary.used_percent !== void 0 ? {
+			primary,
+			secondary
+		} : void 0;
+		const code = String(err.code ?? err.type ?? "");
+		errorCode = code || void 0;
+		const resetsAt = err.resets_at ?? primary.resets_at ?? secondary.resets_at;
+		const mins = resetsAt ? Math.max(0, Math.round((resetsAt * 1e3 - Date.now()) / 6e4)) : void 0;
+		if (/usage_limit_reached|usage_not_included/i.test(code)) {
+			const planType = err.plan_type;
+			friendlyMessage = `You have hit your ChatGPT usage limit${planType ? ` (${String(planType).toLowerCase()} plan)` : ""}.${mins !== void 0 ? ` Try again in ~${mins} min.` : ""}`.trim();
+		} else if (/rate_limit_exceeded/i.test(code) || response.status === 429) friendlyMessage = `ChatGPT rate limit exceeded.${mins !== void 0 ? ` Try again in ~${mins} min.` : ""}`.trim();
+		message = err.message || friendlyMessage || message;
+	} catch {}
+	return {
+		message,
+		status: response.status,
+		code: errorCode,
+		friendlyMessage,
+		rateLimits,
+		raw
+	};
+}
+function toInt(v) {
+	if (v == null) return void 0;
+	const n = parseInt(v, 10);
+	return Number.isFinite(n) ? n : void 0;
+}
+//#endregion
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/openai-codex-responses.ts
+var openai_codex_responses_exports = /* @__PURE__ */ __exportAll({
+	CodexWebSocketTransportError: () => CodexWebSocketTransportError,
+	buildTransformedCodexRequestBody: () => buildTransformedCodexRequestBody,
+	convertCodexResponsesMessages: () => convertMessages,
+	convertOpenAICodexResponsesTools: () => convertOpenAICodexResponsesTools,
+	createCodexProviderStreamError: () => createCodexProviderStreamError,
+	getCodexAttestationHeader: () => getCodexAttestationHeader,
+	isRetryableCodexFailureEvent: () => isRetryableCodexFailureEvent,
+	normalizeCodexToolChoice: () => normalizeCodexToolChoice,
+	resolveCodexResponsesUrl: () => resolveCodexResponsesUrl,
+	streamOpenAICodexResponses: () => streamOpenAICodexResponses
+});
+const CODEX_DEBUG = $flag("PI_CODEX_DEBUG");
+const CODEX_MAX_RETRIES = 5;
+const CODEX_RETRY_DELAY_MS = 500;
+function resolveCodexSseMaxAttempts(value) {
+	if (value === void 0) return 6;
+	if (!Number.isFinite(value)) return 1;
+	return Math.max(1, Math.trunc(value));
+}
+const CODEX_WEBSOCKET_CONNECT_TIMEOUT_MS = 1e4;
+const CODEX_WEBSOCKET_PING_INTERVAL_MS = Number($env.PI_CODEX_WEBSOCKET_PING_INTERVAL_MS || 1e4);
+const CODEX_WEBSOCKET_PONG_TIMEOUT_MS = Number($env.PI_CODEX_WEBSOCKET_PONG_TIMEOUT_MS || 6e4);
+const CODEX_WEBSOCKET_MESSAGE_QUEUE_CAPACITY = Number($env.PI_CODEX_WEBSOCKET_MESSAGE_QUEUE_CAPACITY || 4096);
+/**
+* Maximum quiet period (no inbound frames AND no observed pong) we'll trust a
+* reused WebSocket for before forcing a fresh handshake. Codex backends and
+* intermediaries occasionally evict idle sockets server-side without sending a
+* FIN, leaving the local `readyState` as OPEN while the next `send()` becomes a
+* write into a half-open buffer. Reusing such a socket parks the next request
+* at `#nextMessage` until the first-event/idle timeout fires (issue #1450). The
+* heartbeat below also catches dead sockets, but only after `pongTimeoutMs`
+* (default 60s) and only while a request is active — this gate closes the door
+* earlier and even when the gap between requests is purely client-side (tool
+* execution, user typing, etc.). Set `PI_CODEX_WEBSOCKET_MAX_IDLE_REUSE_MS=0`
+* to disable.
+*/
+const CODEX_WEBSOCKET_MAX_IDLE_REUSE_MS = Number($env.PI_CODEX_WEBSOCKET_MAX_IDLE_REUSE_MS || 3e4);
+/**
+* Steady-state liveness ceiling for the Codex WebSocket transport. Distinct from
+* the OMP-wide stream watchdog removed in #1392: a WebSocket can stay TCP-open
+* indefinitely without exchanging frames (server crash after upgrade, half-open
+* network path), so we still need a transport-internal cap to detect those
+* states and trigger the WS→SSE fallback. Only applies AFTER the first event
+* has arrived — slow first-token paths wait as long as the caller permits.
+*/
+const CODEX_WEBSOCKET_IDLE_TIMEOUT_MS = Number($env.PI_CODEX_WEBSOCKET_IDLE_TIMEOUT_MS || 3e5);
+/**
+* Maximum wait for the first WebSocket event before falling back to SSE.
+* Unlike a stream watchdog, this triggers a transport switch (not a request
+* failure) — the outer retry loop catches the timeout error and re-runs on
+* SSE. Generous default so legitimately slow first-token providers still get
+* a chance on the WS transport before falling through.
+*/
+const CODEX_WEBSOCKET_FIRST_EVENT_TIMEOUT_MS = Number($env.PI_CODEX_WEBSOCKET_FIRST_EVENT_TIMEOUT_MS || 3e5);
+const CODEX_WEBSOCKET_RETRY_BUDGET = Number($env.PI_CODEX_WEBSOCKET_RETRY_BUDGET || CODEX_MAX_RETRIES);
+const CODEX_WEBSOCKET_RETRY_DELAY_MS = Number($env.PI_CODEX_WEBSOCKET_RETRY_DELAY_MS || CODEX_RETRY_DELAY_MS);
+const CODEX_WEBSOCKET_TRANSPORT_ERROR_PREFIX = "Codex websocket transport error";
+const CODEX_RETRYABLE_EVENT_CODES = /* @__PURE__ */ new Set([
+	"model_error",
+	"server_error",
+	"internal_error"
+]);
+const CODEX_RETRYABLE_EVENT_MESSAGE = /processing your request|retry your request|temporar(?:y|ily)|overloaded|service.?unavailable|internal error|server error/i;
+const CODEX_PROVIDER_SESSION_STATE_KEY = "openai-codex-responses";
+/**
+* Resolve the `x-oai-attestation` header value for one upstream request.
+* Gated on ChatGPT-OAuth credentials (a Codex JWT carries `chatgpt_account_id`;
+* codex-rs gates on `auth.is_chatgpt_auth()`). A throwing hook degrades to no
+* header rather than failing the request.
+*/
+async function getCodexAttestationHeader(accountId) {}
+const X_CODEX_TURN_STATE_HEADER = "x-codex-turn-state";
+const X_MODELS_ETAG_HEADER = "x-models-etag";
+/** WebSocket frames cannot carry per-request HTTP headers; codex-rs mirrors the lite marker into `client_metadata` under this key. */
+const CODEX_WS_RESPONSES_LITE_CLIENT_METADATA_KEY = "ws_request_header_x_openai_internal_codex_responses_lite";
+/** `response.metadata` payload key carrying ChatGPT moderation metadata. */
+const CODEX_MODERATION_METADATA_KEY = "openai_chatgpt_moderation_metadata";
+/** Connection-level websocket failures that should immediately fall back to SSE without retrying. */
+const CODEX_WEBSOCKET_FATAL_PATTERNS = [
+	"websocket error:",
+	"websocket closed before open",
+	"connection timeout"
+];
+/** Max total time to spend retrying 429s with server-provided delays (5 minutes). */
+const CODEX_RATE_LIMIT_BUDGET_MS = 3e5;
+const CODEX_ADDITIONAL_PROGRESS_EVENT_TYPES = /* @__PURE__ */ new Set(["response.done", "response.incomplete"]);
+const CODEX_WHITESPACE_TOOL_CALL_ARGUMENT_DELTA_EVENT_LIMIT = 256;
+const CODEX_WHITESPACE_TOOL_CALL_ARGUMENT_DELTA_CHAR_LIMIT = 16384;
+const CODEX_WHITESPACE_LOOP_RETRY_LIMIT = 2;
+const CODEX_WHITESPACE_LOOP_RETRY_DELAY_MS = 250;
+function isCodexStreamProgressEvent(event) {
+	if (isOpenAIResponsesProgressEvent(event)) return true;
+	if (!event || typeof event !== "object") return false;
+	const type = event.type;
+	return typeof type === "string" && CODEX_ADDITIONAL_PROGRESS_EVENT_TYPES.has(type);
+}
+function extractCodexFrameResponseId(frame) {
+	const id = frame.response?.id;
+	return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function extractCodexFrameSequenceNumber(frame) {
+	const raw = frame.sequence_number;
+	return typeof raw === "number" && Number.isFinite(raw) ? Math.trunc(raw) : void 0;
+}
+function createCodexWebSocketTimeoutMessage(reason, details) {
+	const now = Date.now();
+	return `${reason} (last event: ${details.lastEventType ? `${details.lastEventType} ${Math.max(0, now - details.lastEventAt)}ms ago` : "none"}; last progress: ${details.lastProgressEventType ? `${details.lastProgressEventType} ${Math.max(0, now - details.lastProgressAt)}ms ago` : "none"})`;
+}
+const CODEX_RESERVED_METADATA_KEYS = {
+	installation_id: true,
+	[OPENAI_HEADERS.INSTALLATION_ID]: true,
+	session_id: true,
+	thread_id: true,
+	turn_id: true,
+	window_id: true,
+	[OPENAI_HEADERS.WINDOW_ID]: true,
+	[OPENAI_HEADERS.TURN_METADATA]: true,
+	[OPENAI_HEADERS.PARENT_THREAD_ID]: true,
+	[OPENAI_HEADERS.SUBAGENT]: true,
+	request_kind: true,
+	compaction: true,
+	code_mode_tool_names: true,
+	turn_started_at_unix_ms: true,
+	forked_from_thread_id: true,
+	parent_thread_id: true,
+	parent_turn_id: true,
+	subagent_kind: true,
+	thread_source: true,
+	sandbox: true,
+	workspaces: true
+};
+function createCodexMetadataSessionState(sessionId) {
+	return {
+		sessionId,
+		threadId: crypto.randomUUID(),
+		windowId: crypto.randomUUID()
+	};
+}
+function getOrCreateCodexMetadataSessionState(sessionId, providerState) {
+	if (!providerState) return createCodexMetadataSessionState(sessionId);
+	const existing = providerState.metadataSessions.get(sessionId);
+	if (existing) return existing;
+	const created = createCodexMetadataSessionState(sessionId);
+	providerState.metadataSessions.set(sessionId, created);
+	return created;
+}
+function createCodexCompatibilityIdentity(session) {
+	return {
+		installationId: getInstallId(),
+		sessionId: session.sessionId,
+		threadId: session.threadId,
+		windowId: session.windowId
+	};
+}
+function resolveCodexStartNewTurn(session, requestKind, compaction, override) {
+	if (requestKind !== "compaction") {
+		if (requestKind === "turn") {
+			const reuseCompactionTurn = session.reuseTurnForNextRequest === true;
+			session.reuseTurnForNextRequest = false;
+			session.compactionOperationId = void 0;
+			if (reuseCompactionTurn) return false;
+		}
+		return override ?? requestKind === "turn";
+	}
+	if (!compaction) return override ?? false;
+	const startsNewOperation = session.compactionOperationId !== compaction.operationId;
+	if (startsNewOperation) session.reuseTurnForNextRequest = false;
+	session.compactionOperationId = compaction.operationId;
+	return override ?? (compaction.phase !== "mid_turn" && startsNewOperation);
+}
+function toAsciiJsonString(value) {
+	return JSON.stringify(value).replace(/[\x7f-\uffff]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+function createCodexRequestMetadata(session, requestKind, options) {
+	if (options.startNewTurn || !session.turnId) {
+		session.turnId = crypto.randomUUID();
+		session.turnStartedAtUnixMs = options.turnStartedAtUnixMs;
+	}
+	const identity = createCodexCompatibilityIdentity(session);
+	const parentTurnId = options.parentTurnId?.trim() ? options.parentTurnId : void 0;
+	const extra = {};
+	const callerMetadata = options.clientMetadata;
+	if (callerMetadata) {
+		for (const key in callerMetadata) if (!CODEX_RESERVED_METADATA_KEYS[key]) extra[key] = callerMetadata[key];
+	}
+	const turnMetadata = {
+		installation_id: identity.installationId,
+		session_id: identity.sessionId,
+		thread_id: identity.threadId,
+		turn_id: session.turnId,
+		window_id: identity.windowId,
+		request_kind: requestKind
+	};
+	if (parentTurnId) turnMetadata.parent_turn_id = parentTurnId;
+	if (options.compaction) turnMetadata.compaction = {
+		trigger: options.compaction.trigger,
+		reason: options.compaction.reason,
+		implementation: options.compaction.implementation,
+		phase: options.compaction.phase,
+		strategy: options.compaction.strategy
+	};
+	if (session.turnStartedAtUnixMs !== void 0) turnMetadata.turn_started_at_unix_ms = session.turnStartedAtUnixMs;
+	for (const key in extra) turnMetadata[key] = extra[key];
+	const turnMetadataJson = toAsciiJsonString(turnMetadata);
+	const clientMetadata = {
+		[OPENAI_HEADERS.INSTALLATION_ID]: identity.installationId,
+		session_id: identity.sessionId,
+		thread_id: identity.threadId,
+		[OPENAI_HEADERS.WINDOW_ID]: identity.windowId,
+		turn_id: session.turnId
+	};
+	if (parentTurnId) clientMetadata.parent_turn_id = parentTurnId;
+	clientMetadata[OPENAI_HEADERS.TURN_METADATA] = turnMetadataJson;
+	return {
+		...identity,
+		turnId: session.turnId,
+		turnMetadataJson,
+		clientMetadata
+	};
+}
+function applyCodexCompatibilityHeaders(headers, metadata) {
+	headers.set(OPENAI_HEADERS.SCOPED_SESSION_ID, metadata.sessionId);
+	headers.set(OPENAI_HEADERS.THREAD_ID, metadata.threadId);
+	headers.set(OPENAI_HEADERS.WINDOW_ID, metadata.windowId);
+	if (metadata.turnMetadataJson) headers.set(OPENAI_HEADERS.TURN_METADATA, metadata.turnMetadataJson);
+	else headers.delete(OPENAI_HEADERS.TURN_METADATA);
+}
+var CodexStreamRuntime = class {
+	eventStream;
+	requestBodyForState;
+	transport;
+	websocketState;
+	/**
+	* Items open on the wire keyed by `item.id`. `response.output_item.added`
+	* registers here; `output_item.done` removes. A keyed event whose `item_id`
+	* is not present is dropped rather than appended to a sibling.
+	*/
+	openItems = /* @__PURE__ */ new Map();
+	/**
+	* Items open on the wire keyed by `output_index` for streams whose function
+	* call items omit `id`; these still carry `output_index` on deltas/done.
+	*/
+	openItemsByOutputIndex = /* @__PURE__ */ new Map();
+	/**
+	* Most recently added open item for events that omit both `item_id` and
+	* `output_index`. Always tracks the latest `output_item.added`, including
+	* fully keyless items that never make it into the keyed maps; cleared when
+	* its item closes.
+	*/
+	currentEntry = null;
+	/** Convenience mirrors of {@link currentEntry} for legacy singleton handlers. */
+	currentItem = null;
+	currentBlock = null;
+	nativeOutputItems = [];
+	/** Sequential-cutoff summary sections/emitted text, global to the response (indices span reasoning items). */
+	cutoffSummaries = createSequentialCutoffSummaryState();
+	/** Summary deltas buffered while waiting to see whether atomic `.done` events arrive. */
+	pendingSummaryDeltas = /* @__PURE__ */ new Map();
+	websocketStreamRetries = 0;
+	providerRetryAttempt = 0;
+	sawTerminalEvent = false;
+	canSafelyReplayWebsocketOverSse = true;
+	whitespaceToolCallArgumentsDelta;
+	whitespaceLoopRetries = 0;
+	constructor(initial) {
+		this.eventStream = initial.eventStream;
+		this.requestBodyForState = initial.requestBodyForState;
+		this.transport = initial.transport;
+		this.websocketState = initial.websocketState;
+	}
+	/**
+	* Wipe per-attempt accumulator state before a recovery path replays the turn.
+	* Keeps {@link openItems} and the legacy singleton-current pointers in lockstep
+	* with {@link nativeOutputItems} so a stale delta from the failed attempt can't
+	* bind to a sibling on the retry.
+	*/
+	resetAccumulators() {
+		this.openItems.clear();
+		this.openItemsByOutputIndex.clear();
+		this.currentEntry = null;
+		this.currentItem = null;
+		this.currentBlock = null;
+		this.nativeOutputItems.length = 0;
+		this.pendingSummaryDeltas.clear();
+		this.cutoffSummaries = createSequentialCutoffSummaryState();
+	}
+	/**
+	* Look up the open item a Codex stream event targets. `item_id` wins because it
+	* uniquely identifies a response item; `output_index` covers idless function
+	* call items. A keyed event whose target is already closed is dropped instead
+	* of being routed to a sibling. Only streams that omit both keys fall back to
+	* {@link currentEntry} — the most recently added item, including fully keyless
+	* ones that never reached the keyed maps.
+	*/
+	openItemForEvent(rawEvent) {
+		const itemId = typeof rawEvent.item_id === "string" ? rawEvent.item_id : "";
+		if (itemId) return this.openItems.get(itemId) ?? null;
+		const outputIndex = typeof rawEvent.output_index === "number" && Number.isFinite(rawEvent.output_index) ? Math.trunc(rawEvent.output_index) : void 0;
+		if (outputIndex !== void 0) return this.openItemsByOutputIndex.get(outputIndex) ?? null;
+		return this.currentEntry;
+	}
+	queueSummaryDelta(entry, delta) {
+		if (entry?.block?.type !== "thinking" || delta.length === 0) return;
+		const pending = this.pendingSummaryDeltas.get(entry) ?? [];
+		pending.push(delta);
+		this.pendingSummaryDeltas.set(entry, pending);
+	}
+	takeSummaryDeltas(entry) {
+		if (!entry) return [];
+		const pending = this.pendingSummaryDeltas.get(entry) ?? [];
+		this.pendingSummaryDeltas.delete(entry);
+		return pending;
+	}
+	closeOpenItem(entry) {
+		if (!entry) return;
+		if (entry.itemId) this.openItems.delete(entry.itemId);
+		if (entry.outputIndex !== void 0) this.openItemsByOutputIndex.delete(entry.outputIndex);
+		if (this.currentEntry === entry) {
+			this.currentEntry = null;
+			this.currentItem = null;
+			this.currentBlock = null;
+		}
+	}
+	observeWhitespaceToolCallArgumentsDelta(rawEvent, delta) {
+		if (!isJsonWhitespaceOnly(delta)) {
+			this.whitespaceToolCallArgumentsDelta = void 0;
+			return;
+		}
+		const itemId = typeof rawEvent.item_id === "string" && rawEvent.item_id.length > 0 ? rawEvent.item_id : this.currentItem?.id ?? "";
+		const outputIndex = typeof rawEvent.output_index === "number" && Number.isFinite(rawEvent.output_index) ? Math.trunc(rawEvent.output_index) : void 0;
+		const sequenceNumber = typeof rawEvent.sequence_number === "number" && Number.isFinite(rawEvent.sequence_number) ? Math.trunc(rawEvent.sequence_number) : void 0;
+		let state = this.whitespaceToolCallArgumentsDelta;
+		if (!state || state.itemId !== itemId || state.outputIndex !== outputIndex) {
+			state = {
+				itemId,
+				outputIndex,
+				consecutiveEvents: 0,
+				consecutiveChars: 0,
+				firstSequenceNumber: sequenceNumber
+			};
+			this.whitespaceToolCallArgumentsDelta = state;
+		}
+		state.consecutiveEvents += 1;
+		state.consecutiveChars += delta.length;
+		state.lastSequenceNumber = sequenceNumber;
+		if (state.consecutiveEvents < CODEX_WHITESPACE_TOOL_CALL_ARGUMENT_DELTA_EVENT_LIMIT && state.consecutiveChars < CODEX_WHITESPACE_TOOL_CALL_ARGUMENT_DELTA_CHAR_LIMIT) return;
+		const itemLabel = itemId ? ` for item ${itemId}` : "";
+		const sequenceLabel = state.firstSequenceNumber === void 0 || state.lastSequenceNumber === void 0 ? "" : `, sequence ${state.firstSequenceNumber}..${state.lastSequenceNumber}`;
+		return { message: `Interrupted OpenAI Codex response after ${state.consecutiveEvents} consecutive whitespace-only tool-call argument delta events (${state.consecutiveChars} chars${sequenceLabel})${itemLabel}.` };
+	}
+	handleToolCallArgumentsDelta(rawEvent, stream, output) {
+		const delta = rawEvent.delta || "";
+		const interruption = this.observeWhitespaceToolCallArgumentsDelta(rawEvent, delta);
+		if (interruption) return interruption;
+		const entry = this.openItemForEvent(rawEvent);
+		if (!entry) return void 0;
+		if (entry.item.type !== "function_call" || entry.block?.type !== "toolCall") return void 0;
+		accumulateToolCallArgumentsDelta(entry.block, delta, stream, output, entry.contentIndex);
+	}
+	handleToolCallArgumentsDone(rawEvent) {
+		const entry = this.openItemForEvent(rawEvent);
+		if (entry?.item.type !== "function_call" || entry.block?.type !== "toolCall") return;
+		const args = rawEvent.arguments;
+		if (typeof args === "string") finalizeToolCallArgumentsDone(entry.block, args);
+	}
+	handleCustomToolCallInputDelta(rawEvent, stream, output) {
+		const delta = rawEvent.delta || "";
+		const interruption = this.observeWhitespaceToolCallArgumentsDelta(rawEvent, delta);
+		if (interruption) return interruption;
+		const entry = this.openItemForEvent(rawEvent);
+		if (!entry) return void 0;
+		if (entry.item.type !== "custom_tool_call" || entry.block?.type !== "toolCall") return void 0;
+		accumulateCustomToolCallInputDelta(entry.block, delta, stream, output, entry.contentIndex);
+	}
+	handleCustomToolCallInputDone(rawEvent) {
+		const entry = this.openItemForEvent(rawEvent);
+		if (entry?.item.type !== "custom_tool_call" || entry.block?.type !== "toolCall") return;
+		const input = rawEvent.input;
+		if (typeof input === "string") finalizeCustomToolCallInputDone(entry.block, input);
+	}
+	handleResponseCreated(rawEvent) {
+		const response = rawEvent.response;
+		const state = this.websocketState;
+		if (state && this.transport === "websocket" && typeof response?.id === "string" && response.id.length > 0) state.lastResponseId = response.id;
+	}
+};
+function createCodexProviderSessionState() {
+	const state = {
+		webSocketSessions: /* @__PURE__ */ new Map(),
+		webSocketPublicToPrivate: /* @__PURE__ */ new Map(),
+		metadataSessions: /* @__PURE__ */ new Map(),
+		close: () => {
+			for (const session of state.webSocketSessions.values()) session.connection?.close("session_disposed");
+			state.webSocketSessions.clear();
+			state.webSocketPublicToPrivate.clear();
+			state.metadataSessions.clear();
+		}
+	};
+	return state;
+}
+function isCodexProviderSessionState(state) {
+	return state !== void 0 && "webSocketSessions" in state && state.webSocketSessions instanceof Map && "webSocketPublicToPrivate" in state && state.webSocketPublicToPrivate instanceof Map && "metadataSessions" in state && state.metadataSessions instanceof Map;
+}
+function getCodexProviderSessionState(providerSessionState) {
+	if (!providerSessionState) return void 0;
+	const existing = providerSessionState.get(CODEX_PROVIDER_SESSION_STATE_KEY);
+	if (isCodexProviderSessionState(existing)) return existing;
+	const created = createCodexProviderSessionState();
+	providerSessionState.set(CODEX_PROVIDER_SESSION_STATE_KEY, created);
+	return created;
+}
+function isCodexWebSocketRetryableStreamError(error) {
+	if (!(error instanceof CodexWebSocketTransportError)) return false;
+	const message = error.message.toLowerCase();
+	return message.includes("websocket closed (") || message.includes("websocket closed before response completion") || message.includes("websocket connection is unavailable") || message.includes("websocket send failed") || message.includes("websocket ping failed") || message.includes("websocket pong timeout") || message.includes("websocket message queue exceeded") || message.includes("websocket request already in progress") || message.includes("idle timeout waiting for websocket") || message.includes("timeout waiting for first websocket event") || message.includes("syntaxerror") || message.includes("json");
+}
+function toCodexHeaderRecord(value) {
+	if (!value || typeof value !== "object") return null;
+	const headers = {};
+	for (const [key, entry] of Object.entries(value)) if (typeof entry === "string") headers[key] = entry;
+	else if (Array.isArray(entry) && entry.every((item) => typeof item === "string")) headers[key] = entry.join(",");
+	else if (typeof entry === "number" || typeof entry === "boolean") headers[key] = String(entry);
+	return Object.keys(headers).length > 0 ? headers : null;
+}
+function toCodexHeaders(value) {
+	if (!value) return void 0;
+	if (value instanceof Headers) return value;
+	if (Array.isArray(value)) try {
+		return new Headers(value);
+	} catch {
+		return;
+	}
+	const record = toCodexHeaderRecord(value);
+	if (!record) return void 0;
+	return new Headers(record);
+}
+function updateCodexSessionMetadataFromHeaders(state, headers) {
+	if (!state || !headers) return;
+	const resolvedHeaders = headers instanceof Headers ? headers : new Headers(headers);
+	const turnState = resolvedHeaders.get(X_CODEX_TURN_STATE_HEADER);
+	if (turnState && turnState.length > 0) state.turnState = turnState;
+	const modelsEtag = resolvedHeaders.get(X_MODELS_ETAG_HEADER);
+	if (modelsEtag && modelsEtag.length > 0) state.modelsEtag = modelsEtag;
+}
+function extractCodexWebSocketHandshakeHeaders(socket, openEvent) {
+	const eventRecord = openEvent;
+	const eventResponse = eventRecord?.response;
+	const socketRecord = socket;
+	const socketResponse = socketRecord.response;
+	const socketHandshake = socketRecord.handshake;
+	return toCodexHeaders(eventRecord?.responseHeaders) ?? toCodexHeaders(eventRecord?.headers) ?? toCodexHeaders(eventResponse?.headers) ?? toCodexHeaders(socketRecord.responseHeaders) ?? toCodexHeaders(socketRecord.handshakeHeaders) ?? toCodexHeaders(socketResponse?.headers) ?? toCodexHeaders(socketHandshake?.headers);
+}
+function notifyCodexWebSocketInbound(observer, parsed, text) {
+	const type = typeof parsed.type === "string" ? parsed.type : null;
+	const raw = [`: ws ← ${type ?? "(untyped)"}`];
+	if (type) raw.push(`event: ${type}`);
+	raw.push(`data: ${text}`);
+	notifyRawSseEvent(observer, {
+		event: type,
+		data: text,
+		raw
+	});
+}
+function notifyCodexWebSocketOutbound(observer, request, payload) {
+	const type = typeof request.type === "string" ? request.type : null;
+	const raw = [`: ws → ${type ?? "(untyped)"}`];
+	if (type) raw.push(`event: ${type}`);
+	raw.push(`data: ${payload}`);
+	notifyRawSseEvent(observer, {
+		event: type,
+		data: payload,
+		raw
+	});
+}
+function notifyCodexWebSocketMalformed(observer, data, error) {
+	const text = typeof data === "string" ? data : "";
+	const raw = [`: ws ← (parse-error: ${error instanceof Error ? error.message : String(error)})`];
+	if (text) raw.push(`data: ${text}`);
+	notifyRawSseEvent(observer, {
+		event: "parse_error",
+		data: text,
+		raw
+	});
+}
+/** @internal Exported for tests. */
+function normalizeCodexToolChoice(choice, tools = [], model) {
+	if (!choice) return void 0;
+	if (typeof choice === "string") return choice;
+	const allowFreeform = model ? model.applyPatchToolType === "freeform" : false;
+	const mapName = (name) => {
+		const directTool = tools.find((tool) => tool.name === name);
+		const customTool = allowFreeform ? tools.find((tool) => tool.customFormat && (tool.name === name || tool.customWireName === name)) : void 0;
+		const offeredTool = customTool ?? directTool;
+		if (!offeredTool) return void 0;
+		if (offeredTool.native?.type === "computer" && model?.supportsComputerUse === true) return { type: "computer" };
+		return customTool ? {
+			type: "custom",
+			name: customTool.customWireName ?? customTool.name
+		} : {
+			type: "function",
+			name: offeredTool.name
+		};
+	};
+	if (choice.type === "computer") {
+		const computer = tools.find((tool) => tool.native?.type === "computer");
+		if (!computer) return void 0;
+		return model?.supportsComputerUse === true ? { type: "computer" } : {
+			type: "function",
+			name: computer.name
+		};
+	}
+	if (choice.type === "function") {
+		if ("function" in choice && choice.function?.name) return mapName(choice.function.name);
+		if ("name" in choice && choice.name) return mapName(choice.name);
+	}
+	if (choice.type === "tool" && choice.name) return mapName(choice.name);
+}
+function unrollCodexComputerItems(items, supportsImageDetailOriginal) {
+	const replayItems = stripOpenAIResponsesComputerLinkedReasoningIdsForReplay(items);
+	const unrolled = [];
+	for (const item of replayItems) {
+		if (item.type === "computer_call") {
+			const actions = item.actions ?? (item.action ? [item.action] : []);
+			unrolled.push({
+				type: "function_call",
+				call_id: item.call_id,
+				name: "computer",
+				arguments: JSON.stringify({ actions }),
+				status: item.status
+			});
+			continue;
+		}
+		if (item.type === "computer_call_output") {
+			const image = typeof item.output.image_url === "string" && item.output.image_url.length > 0 ? {
+				type: "input_image",
+				detail: supportsImageDetailOriginal ? "original" : "auto",
+				image_url: item.output.image_url
+			} : typeof item.output.file_id === "string" && item.output.file_id.length > 0 ? {
+				type: "input_image",
+				detail: supportsImageDetailOriginal ? "original" : "auto",
+				file_id: item.output.file_id
+			} : void 0;
+			unrolled.push({
+				type: "function_call_output",
+				call_id: item.call_id,
+				output: image ? "(see attached image)" : ""
+			});
+			if (image) unrolled.push({
+				role: "user",
+				content: [{
+					type: "input_text",
+					text: "Attached image from computer tool result:"
+				}, image]
+			});
+			continue;
+		}
+		unrolled.push(item);
+	}
+	return unrolled;
+}
+function unrollCodexComputerAssistantMessage(message) {
+	let changed = false;
+	const content = message.content.map((block) => {
+		if (block.type !== "toolCall" || block.providerMetadata?.type !== "computer") return block;
+		changed = true;
+		const call = {
+			...block,
+			arguments: { actions: structuredCloneJSON(block.providerMetadata.actions) }
+		};
+		delete call.providerMetadata;
+		return call;
+	});
+	return changed ? {
+		...message,
+		content
+	} : message;
+}
+function unrollCodexComputerToolResult(message) {
+	if (message.providerMetadata?.type !== "computer") return message;
+	const result = { ...message };
+	delete result.providerMetadata;
+	return result;
+}
+function getCodexServiceTierCostMultiplier(model, serviceTier) {
+	switch (serviceTier) {
+		case "flex": return .5;
+		case "priority": return model.id === "gpt-5.5" ? 2.5 : 2;
+		default: return 1;
+	}
+}
+function resolveCodexCostServiceTier(res, req) {
+	switch (res) {
+		case "flex": return "flex";
+		case "priority": return "priority";
+		default:
+			if (req === "flex" || req === "priority") return req;
+			return "default";
+	}
+}
+function applyCodexServiceTierPricing(model, usage, resTier, reqTier) {
+	const multiplier = getCodexServiceTierCostMultiplier(model, resolveCodexCostServiceTier(resTier, reqTier));
+	if (multiplier === 1) return;
+	usage.cost.input *= multiplier;
+	usage.cost.output *= multiplier;
+	usage.cost.cacheRead *= multiplier;
+	usage.cost.cacheWrite *= multiplier;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}
+function resetOutputState(output) {
+	output.content.length = 0;
+	output.usage = {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+	output.stopReason = "stop";
+	output.stopDetails = void 0;
+}
+function createRequestSetup(options) {
+	const requestAbortController = new AbortController();
+	const requestSignal = options?.signal ? AbortSignal.any([options.signal, requestAbortController.signal]) : requestAbortController.signal;
+	const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
+	const websocketIdleTimeoutMs = options?.streamIdleTimeoutMs ?? CODEX_WEBSOCKET_IDLE_TIMEOUT_MS;
+	const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getOpenAIStreamFirstEventTimeoutMs(idleTimeoutMs);
+	const websocketFirstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? CODEX_WEBSOCKET_FIRST_EVENT_TIMEOUT_MS;
+	const wrapCodexSseStream = (source) => iterateWithIdleTimeout(source, {
+		idleTimeoutMs,
+		firstItemTimeoutMs: firstEventTimeoutMs,
+		firstItemErrorMessage: "OpenAI Codex SSE stream timed out while waiting for the first event",
+		errorMessage: "OpenAI Codex SSE stream stalled while waiting for the next event",
+		onIdle: () => requestAbortController.abort(),
+		onFirstItemTimeout: () => requestAbortController.abort(),
+		abortSignal: options?.signal,
+		isProgressItem: isCodexStreamProgressEvent
+	});
+	return {
+		requestAbortController,
+		requestSignal,
+		wrapCodexSseStream,
+		firstEventTimeoutMs,
+		websocketIdleTimeoutMs,
+		websocketFirstEventTimeoutMs
+	};
+}
+function createCodexRequestContext(model, transformedBody, options, contextOptions) {
+	const apiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
+	if (!apiKey) throw new MissingApiKeyError(model.provider);
+	const accountId = getCodexAccountId(apiKey);
+	const baseUrl = model.baseUrl || "https://chatgpt.com/backend-api";
+	const url = resolveCodexResponsesUrl(baseUrl);
+	const transportSessionId = normalizeOpenAIPromptCacheKey(options?.sessionId);
+	const codexClientVersion = CODEX_CLIENT_VERSION;
+	const requestHeaders = {
+		...model.headers ?? {},
+		...options?.headers ?? {}
+	};
+	const rawRequestDump = {
+		provider: model.provider,
+		api: model.api,
+		model: model.id,
+		method: "POST",
+		url,
+		body: transformedBody
+	};
+	const providerSessionState = getCodexProviderSessionState(options?.providerSessionState);
+	const isolatedTransportState = contextOptions.isolateCompactionTransport && options?.codexCompaction ? createCodexProviderSessionState() : void 0;
+	const transportProviderSessionState = isolatedTransportState ?? providerSessionState;
+	const responsesLite = resolveCodexResponsesLite(model, options?.responsesLite);
+	const sessionKey = getCodexWebSocketSessionKey(transportSessionId, model, accountId, apiKey, baseUrl, responsesLite);
+	const publicSessionKey = transportSessionId ? `${baseUrl}:${model.id}:${transportSessionId}` : void 0;
+	if (sessionKey && publicSessionKey) transportProviderSessionState?.webSocketPublicToPrivate.set(publicSessionKey, sessionKey);
+	const sharedWebsocketState = sessionKey && providerSessionState ? isolatedTransportState ? providerSessionState.webSocketSessions.get(sessionKey) : getCodexWebSocketSessionState(sessionKey, providerSessionState) : void 0;
+	const websocketState = sessionKey && isolatedTransportState ? getCodexWebSocketSessionState(sessionKey, isolatedTransportState) : sharedWebsocketState;
+	if (isolatedTransportState && websocketState && sharedWebsocketState) {
+		websocketState.disableWebsocket = sharedWebsocketState.disableWebsocket;
+		websocketState.turnState = sharedWebsocketState.turnState;
+		websocketState.modelsEtag = sharedWebsocketState.modelsEtag;
+	}
+	const metadataSession = getOrCreateCodexMetadataSessionState(transportSessionId ?? crypto.randomUUID(), providerSessionState);
+	const compaction = options?.codexCompaction;
+	const requestKind = compaction ? "compaction" : "turn";
+	const startNewTurn = resolveCodexStartNewTurn(metadataSession, requestKind, compaction, contextOptions.startNewTurn);
+	if (websocketState && startNewTurn) websocketState.turnState = void 0;
+	const requestMetadata = createCodexRequestMetadata(metadataSession, requestKind, {
+		startNewTurn,
+		turnStartedAtUnixMs: compaction ? startNewTurn || !metadataSession.turnId ? Date.now() : void 0 : contextOptions.turnStartedAtUnixMs,
+		clientMetadata: transformedBody.client_metadata,
+		parentTurnId: options?.parentTurnId,
+		compaction
+	});
+	transformedBody.client_metadata = requestMetadata.clientMetadata;
+	return {
+		apiKey,
+		accountId,
+		baseUrl,
+		url,
+		requestHeaders,
+		transportSessionId,
+		providerSessionState,
+		isolatedTransportState,
+		websocketState,
+		responsesLite,
+		requestMetadata,
+		codexClientVersion,
+		transformedBody,
+		rawRequestDump
+	};
+}
+async function buildCodexRequestContext(model, context, options) {
+	return createCodexRequestContext(model, await buildTransformedCodexRequestBody(model, context, options, getOpenAIPromptCacheKey(options)), options, {
+		isolateCompactionTransport: true,
+		startNewTurn: options?.codexCompaction ? void 0 : !isCodexWithinTurnContinuation(context),
+		turnStartedAtUnixMs: options?.codexCompaction ? void 0 : getCodexTurnStartedAtUnixMs(context)
+	});
+}
+/** @internal Exported for tests. */
+async function buildTransformedCodexRequestBody(model, context, options, promptCacheKey = getOpenAIPromptCacheKey(options)) {
+	const params = {
+		model: model.requestModelId ?? model.id,
+		input: convertMessages(model, context),
+		stream: true,
+		prompt_cache_key: promptCacheKey
+	};
+	applyOpenAIServiceTier(params, options?.serviceTier, model);
+	if (context.tools && context.tools.length > 0) {
+		params.tools = convertOpenAICodexResponsesTools(context.tools, model);
+		if (options?.toolChoice) {
+			const toolChoice = normalizeCodexToolChoice(options.toolChoice, context.tools, model);
+			if (toolChoice) params.tool_choice = toolChoice;
+		}
+	}
+	const systemPrompts = normalizeSystemPrompts(context.systemPrompt);
+	if (systemPrompts.length > 0) params.instructions = systemPrompts[0];
+	const developerMessages = systemPrompts.slice(1);
+	if (options?.clientMetadata && Object.keys(options.clientMetadata).length > 0) params.client_metadata = { ...options.clientMetadata };
+	return transformRequestBody(params, model, {
+		reasoningEffort: options?.reasoning,
+		reasoningOff: options?.forceReasoningOff,
+		reasoningSummary: options?.reasoningSummary,
+		reasoningContext: options?.reasoningContext,
+		textVerbosity: options?.textVerbosity,
+		include: options?.include,
+		responsesLite: options?.responsesLite
+	}, { developerMessages });
+}
+async function openInitialCodexEventStream(model, options, requestSetup, requestContext) {
+	const { transformedBody, websocketState } = requestContext;
+	if (websocketState && shouldUseCodexWebSocket(model, websocketState, options?.preferWebsockets)) {
+		const websocketRetryBudget = CODEX_WEBSOCKET_RETRY_BUDGET;
+		let websocketRetries = 0;
+		while (true) try {
+			return await openCodexWebSocketTransport(model, options, requestContext, requestSetup, websocketState, websocketRetries, options ? (event) => options.onSseEvent?.(event, model) : void 0);
+		} catch (error) {
+			if (!(error instanceof CodexWebSocketTransportError)) throw error;
+			const fatalWebSocketMessage = error.message.toLowerCase();
+			const isFatal = CODEX_WEBSOCKET_FATAL_PATTERNS.some((pattern) => fatalWebSocketMessage.includes(pattern.toLowerCase()));
+			const activateFallback = isFatal || websocketRetries >= websocketRetryBudget;
+			recordCodexWebSocketFailure(websocketState, activateFallback);
+			CODEX_DEBUG && debug("[codex] codex websocket fallback", {
+				error: error.message,
+				retry: websocketRetries,
+				retryBudget: websocketRetryBudget,
+				activated: activateFallback,
+				fatal: isFatal
+			});
+			if (!activateFallback) {
+				websocketRetries += 1;
+				await scheduler.wait(CODEX_WEBSOCKET_RETRY_DELAY_MS * Math.max(1, websocketRetries), { signal: requestSetup.requestSignal });
+				continue;
+			}
+			break;
+		}
+	}
+	return openCodexSseTransport(model, requestContext, requestSetup, options, websocketState, transformedBody);
+}
+async function openCodexWebSocketTransport(model, options, requestContext, requestSetup, websocketState, retry, onSseEvent) {
+	const canAppendBeforeRequest = websocketState.canAppend === true;
+	const chainedBody = buildCodexChainedRequestBody(requestContext.transformedBody, websocketState);
+	const websocketClientMetadata = { ...chainedBody.client_metadata ?? {} };
+	if (requestContext.responsesLite) websocketClientMetadata[CODEX_WS_RESPONSES_LITE_CLIENT_METADATA_KEY] = "true";
+	if (websocketState.turnState) websocketClientMetadata[X_CODEX_TURN_STATE_HEADER] = websocketState.turnState;
+	let websocketRequest = {
+		type: "response.create",
+		...chainedBody,
+		client_metadata: websocketClientMetadata
+	};
+	const replacementWebsocketRequest = await options?.onPayload?.(websocketRequest, model);
+	if (replacementWebsocketRequest !== void 0) websocketRequest = replacementWebsocketRequest;
+	recordCodexTurnRequestDiagnostics(websocketState, websocketRequest, "websocket", canAppendBeforeRequest);
+	const websocketHeaders = createCodexHeaders(requestContext.requestHeaders, requestContext.accountId, requestContext.apiKey, requestContext.codexClientVersion, requestContext.transportSessionId, "websocket", websocketState, requestContext.responsesLite, requestContext.requestMetadata, await getCodexAttestationHeader(requestContext.accountId));
+	const requestBodyForState = structuredCloneJSON(requestContext.transformedBody);
+	if (websocketRequest.stream_options === void 0) delete requestBodyForState.stream_options;
+	else requestBodyForState.stream_options = websocketRequest.stream_options;
+	requestContext.rawRequestDump.body = websocketRequest;
+	CODEX_DEBUG && debug("[codex] codex websocket request", {
+		url: toWebSocketUrl(requestContext.url),
+		model: requestContext.transformedBody.model,
+		reasoningEffort: requestContext.transformedBody.reasoning?.effort ?? null,
+		headers: redactHeaders(websocketHeaders),
+		sentTurnStateHeader: websocketHeaders.has(X_CODEX_TURN_STATE_HEADER),
+		sentModelsEtagHeader: websocketHeaders.has(X_MODELS_ETAG_HEADER),
+		requestType: websocketRequest.type,
+		retry,
+		retryBudget: CODEX_WEBSOCKET_RETRY_BUDGET
+	});
+	return {
+		eventStream: (await getOrCreateCodexWebSocketConnection(websocketState, toWebSocketUrl(requestContext.url), websocketHeaders, model.provider, requestSetup.requestSignal)).streamRequest(websocketRequest, {
+			idleTimeoutMs: requestSetup.websocketIdleTimeoutMs,
+			firstEventTimeoutMs: requestSetup.websocketFirstEventTimeoutMs
+		}, requestSetup.requestSignal, onSseEvent),
+		requestBodyForState,
+		transport: "websocket"
+	};
+}
+function getCodexTurnStartedAtUnixMs(context) {
+	for (let i = context.messages.length - 1; i >= 0; i--) {
+		const message = context.messages[i];
+		if (message?.role === "user" && Number.isFinite(message.timestamp)) return Math.trunc(message.timestamp);
+	}
+	return Date.now();
+}
+/**
+* True when the request continues the current turn (everything after the
+* last assistant message is tool results), false when a new user turn starts.
+* Mirrors codex-rs, which scopes `x-codex-turn-state` to a single turn and
+* clears it when the next one begins.
+*/
+function isCodexWithinTurnContinuation(context) {
+	for (let i = context.messages.length - 1; i >= 0; i--) {
+		const role = context.messages[i]?.role;
+		if (role === "toolResult") continue;
+		return role === "assistant";
+	}
+	return false;
+}
+async function openCodexSseTransport(model, requestContext, requestSetup, options, state, body = requestContext.transformedBody) {
+	const open = async (wireBody) => {
+		requestContext.rawRequestDump.body = wireBody;
+		return requestSetup.wrapCodexSseStream(await openCodexSseEventStream(requestContext.url, requestContext.requestHeaders, requestContext.accountId, requestContext.apiKey, requestContext.transportSessionId, wireBody, state, requestContext.responsesLite, requestContext.codexClientVersion, requestContext.requestMetadata, requestSetup.requestSignal, requestSetup.firstEventTimeoutMs, options?.codexSseMaxAttempts, (event) => options?.onSseEvent?.(event, model), options?.fetch));
+	};
+	const canAppendBeforeRequest = state?.canAppend === true;
+	let wireBody = body;
+	const replacementWireBody = await options?.onPayload?.(wireBody, model);
+	if (replacementWireBody !== void 0) wireBody = replacementWireBody;
+	recordCodexTurnRequestDiagnostics(state, wireBody, "sse", canAppendBeforeRequest);
+	return {
+		eventStream: await open(wireBody),
+		requestBodyForState: structuredCloneJSON(wireBody),
+		transport: "sse"
+	};
+}
+function isJsonWhitespaceOnly(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code !== 9 && code !== 10 && code !== 13 && code !== 32) return false;
+	}
+	return true;
+}
+function createOutputBlockForItem(item) {
+	if (item.type === "reasoning") return {
+		type: "thinking",
+		thinking: ""
+	};
+	if (item.type === "message") {
+		const phase = item.phase === "commentary" || item.phase === "final_answer" ? item.phase : void 0;
+		return {
+			type: "text",
+			text: "",
+			textSignature: encodeTextSignatureV1(item.id, phase)
+		};
+	}
+	if (item.type === "function_call") return {
+		type: "toolCall",
+		id: encodeResponsesToolCallId(item.call_id, item.id),
+		name: item.name,
+		arguments: {},
+		[kStreamingPartialJson]: item.arguments || ""
+	};
+	if (item.type === "computer_call") return {
+		type: "toolCall",
+		id: encodeResponsesToolCallId(item.call_id, item.id),
+		name: "computer",
+		arguments: {},
+		providerMetadata: computerCallMetadata(item),
+		[kStreamingPartialJson]: ""
+	};
+	if (item.type === "custom_tool_call") return {
+		type: "toolCall",
+		id: encodeResponsesToolCallId(item.call_id, item.id),
+		name: item.name,
+		arguments: { input: item.input ?? "" },
+		customWireName: item.name,
+		[kStreamingPartialJson]: item.input ?? ""
+	};
+	return null;
+}
+function getOutputBlockStartEventType(block) {
+	if (block.type === "thinking") return "thinking_start";
+	if (block.type === "text") return "text_start";
+	return "toolcall_start";
+}
+const CODEX_STALE_PREVIOUS_RESPONSE_CODES = {
+	previous_response_not_found: true,
+	codex_previous_response_stale: true
+};
+function isCodexStalePreviousResponseError(error) {
+	if (!(error instanceof Error)) return false;
+	if ("code" in error && typeof error.code === "string" && Object.hasOwn(CODEX_STALE_PREVIOUS_RESPONSE_CODES, error.code)) return true;
+	return /previous[ _]?response/i.test(error.message) && /not[ _]?found|invalid|expired|stale|unsupported/i.test(error.message);
+}
+async function handleCodexStreamFailure(context, error) {
+	const { output } = context;
+	if (context.requestContext.websocketState) {
+		resetCodexWebSocketAppendState(context.requestContext.websocketState);
+		context.requestContext.websocketState.turnState = void 0;
+		context.requestContext.websocketState.modelsEtag = void 0;
+	}
+	const result = await finalize(error, {
+		api: context.model.api,
+		signal: context.options?.signal,
+		rawRequestDump: context.requestContext.rawRequestDump
+	});
+	output.stopReason = result.stopReason;
+	output.errorStatus = result.status;
+	output.errorId = result.id;
+	output.errorMessage = result.message;
+	output.duration = performance.now() - context.startTime;
+	if (context.firstTokenTime) output.ttft = context.firstTokenTime - context.startTime;
+	return output;
+}
+/**
+* Owns one `streamOpenAICodexResponses` call: the request scaffolding
+* (model/output/stream/options/request context) plus the per-attempt
+* {@link CodexStreamRuntime}. Drives the event loop in {@link process}, applies
+* the transport-fallback / retry recovery ladder, and emits the final message
+* in {@link finalize}. The runtime object is mutated in place across retries
+* (event stream and accumulators are swapped/reset), never reassigned.
+*/
+var CodexStreamProcessor = class {
+	runtime;
+	model;
+	output;
+	stream;
+	options;
+	requestSetup;
+	requestContext;
+	startTime;
+	firstTokenTime;
+	constructor(init) {
+		this.runtime = init.runtime;
+		this.model = init.model;
+		this.output = init.output;
+		this.stream = init.stream;
+		this.options = init.options;
+		this.requestSetup = init.requestSetup;
+		this.requestContext = init.requestContext;
+		this.startTime = init.startTime;
+	}
+	/**
+	* Whether the request actually sent (post-`onPayload`) opted into
+	* sequential-cutoff summary delivery. Atomic `.done` events are preferred;
+	* incremental deltas remain buffered as a compatibility fallback when a
+	* transport emits them instead.
+	*/
+	get #sequentialCutoffSummaries() {
+		return this.runtime.requestBodyForState.stream_options?.reasoning_summary_delivery === "sequential_cutoff";
+	}
+	async process() {
+		const { output, stream } = this;
+		stream.push({
+			type: "start",
+			partial: output
+		});
+		while (true) try {
+			let firstTokenTime = this.firstTokenTime;
+			for await (const rawEvent of this.runtime.eventStream) {
+				firstTokenTime = this.#handleStreamEvent(rawEvent, firstTokenTime);
+				if (this.runtime.sawTerminalEvent) break;
+			}
+			return { firstTokenTime };
+		} catch (error) {
+			if (!await this.#recoverStreamError(error)) throw error;
+			stream.push({
+				type: "start",
+				partial: output
+			});
+		}
+	}
+	#handleStreamEvent(rawEvent, firstTokenTime) {
+		const { output, stream } = this;
+		const eventType = typeof rawEvent.type === "string" ? rawEvent.type : "";
+		if (!eventType) return firstTokenTime;
+		if (eventType === "response.output_item.added") {
+			this.runtime.whitespaceToolCallArgumentsDelta = void 0;
+			if (!firstTokenTime) firstTokenTime = performance.now();
+			const item = rawEvent.item;
+			this.runtime.currentItem = item;
+			this.runtime.currentBlock = createOutputBlockForItem(item);
+			let contentIndex = -1;
+			if (this.runtime.currentBlock) {
+				output.content.push(this.runtime.currentBlock);
+				contentIndex = output.content.length - 1;
+			}
+			const itemId = typeof item.id === "string" ? item.id : void 0;
+			const outputIndex = typeof rawEvent.output_index === "number" && Number.isFinite(rawEvent.output_index) ? Math.trunc(rawEvent.output_index) : void 0;
+			const entry = {
+				item,
+				block: this.runtime.currentBlock,
+				contentIndex,
+				itemId,
+				outputIndex
+			};
+			this.runtime.currentEntry = entry;
+			if (itemId) this.runtime.openItems.set(itemId, entry);
+			if (outputIndex !== void 0) this.runtime.openItemsByOutputIndex.set(outputIndex, entry);
+			if (!this.runtime.currentBlock) return firstTokenTime;
+			stream.push({
+				type: getOutputBlockStartEventType(this.runtime.currentBlock),
+				contentIndex,
+				partial: output
+			});
+			return firstTokenTime;
+		}
+		if (eventType === "response.reasoning_summary_part.added") {
+			if (this.#sequentialCutoffSummaries) return firstTokenTime;
+			const entry = this.runtime.openItemForEvent(rawEvent);
+			if (entry?.item.type === "reasoning") appendReasoningSummaryPart(entry.item, rawEvent.part);
+			return firstTokenTime;
+		}
+		if (eventType === "response.reasoning_summary_text.delta") {
+			const entry = this.runtime.openItemForEvent(rawEvent);
+			const delta = typeof rawEvent.delta === "string" ? rawEvent.delta : "";
+			if (this.#sequentialCutoffSummaries) {
+				this.runtime.queueSummaryDelta(entry, delta);
+				return firstTokenTime;
+			}
+			if (entry?.item.type === "reasoning" && entry.block?.type === "thinking") appendReasoningSummaryTextDelta(entry.item, entry.block, delta, stream, output, entry.contentIndex);
+			return firstTokenTime;
+		}
+		if (eventType === "response.reasoning_summary_text.done") {
+			if (!this.#sequentialCutoffSummaries) return firstTokenTime;
+			const entry = this.runtime.openItemForEvent(rawEvent);
+			if (entry?.item.type === "reasoning" && entry.block?.type === "thinking") {
+				this.runtime.takeSummaryDeltas(entry);
+				if (!firstTokenTime) firstTokenTime = performance.now();
+				const summaryIndex = typeof rawEvent.summary_index === "number" && Number.isFinite(rawEvent.summary_index) ? Math.trunc(rawEvent.summary_index) : 0;
+				applyReasoningSummaryDone(this.runtime.cutoffSummaries, entry.block, typeof rawEvent.text === "string" ? rawEvent.text : "", summaryIndex, stream, output, entry.contentIndex);
+			}
+			return firstTokenTime;
+		}
+		if (eventType === "response.reasoning_text.delta") {
+			const entry = this.runtime.openItemForEvent(rawEvent);
+			const delta = typeof rawEvent.delta === "string" ? rawEvent.delta : "";
+			if (entry?.item.type === "reasoning" && entry.block?.type === "thinking") {
+				entry.block.thinking += delta;
+				stream.push({
+					type: "thinking_delta",
+					contentIndex: entry.contentIndex,
+					delta,
+					partial: output
+				});
+			}
+			return firstTokenTime;
+		}
+		if (eventType === "response.reasoning_summary_part.done") {
+			const entry = this.runtime.openItemForEvent(rawEvent);
+			if (this.#sequentialCutoffSummaries) {
+				if (entry && this.runtime.pendingSummaryDeltas.has(entry)) this.runtime.queueSummaryDelta(entry, "\n\n");
+				return firstTokenTime;
+			}
+			if (entry?.item.type === "reasoning" && entry.block?.type === "thinking") appendReasoningSummaryPartDone(entry.item, entry.block, stream, output, entry.contentIndex);
+			return firstTokenTime;
+		}
+		if (eventType === "response.content_part.added") {
+			const entry = this.runtime.openItemForEvent(rawEvent);
+			if (entry?.item.type === "message") appendMessageContentPart(entry.item, rawEvent.part);
+			return firstTokenTime;
+		}
+		if (eventType === "response.output_text.delta" || eventType === "response.refusal.delta") {
+			const entry = this.runtime.openItemForEvent(rawEvent);
+			if (entry?.item.type === "message" && entry.block?.type === "text") appendMessageTextDelta(entry.item, entry.block, rawEvent.delta || "", stream, output, entry.contentIndex, eventType === "response.refusal.delta" ? "refusal" : "output_text");
+			return firstTokenTime;
+		}
+		if (eventType === "response.function_call_arguments.delta") {
+			const interruption = this.runtime.handleToolCallArgumentsDelta(rawEvent, stream, output);
+			if (interruption) {
+				this.runtime.websocketState?.connection?.close("degenerate-tool-call");
+				throw new CodexWhitespaceToolCallLoopError(interruption.message);
+			}
+			return firstTokenTime;
+		}
+		if (eventType === "response.function_call_arguments.done") {
+			this.runtime.whitespaceToolCallArgumentsDelta = void 0;
+			this.runtime.handleToolCallArgumentsDone(rawEvent);
+			return firstTokenTime;
+		}
+		if (eventType === "response.custom_tool_call_input.delta") {
+			const interruption = this.runtime.handleCustomToolCallInputDelta(rawEvent, stream, output);
+			if (interruption) {
+				this.runtime.websocketState?.connection?.close("degenerate-tool-call");
+				throw new CodexWhitespaceToolCallLoopError(interruption.message);
+			}
+			return firstTokenTime;
+		}
+		if (eventType === "response.custom_tool_call_input.done") {
+			this.runtime.whitespaceToolCallArgumentsDelta = void 0;
+			this.runtime.handleCustomToolCallInputDone(rawEvent);
+			return firstTokenTime;
+		}
+		if (eventType === "response.output_item.done") {
+			this.runtime.whitespaceToolCallArgumentsDelta = void 0;
+			this.#handleOutputItemDone(rawEvent);
+			return firstTokenTime;
+		}
+		if (eventType === "response.created") {
+			this.runtime.handleResponseCreated(rawEvent);
+			return firstTokenTime;
+		}
+		if (eventType === "response.completed" || eventType === "response.done" || eventType === "response.incomplete") {
+			this.#handleResponseCompleted(rawEvent);
+			return firstTokenTime;
+		}
+		if (eventType === "response.metadata") {
+			updateCodexSessionMetadataFromHeaders(this.requestContext.websocketState, toCodexHeaders(rawEvent.headers));
+			const moderation = asRecord(rawEvent.metadata)?.[CODEX_MODERATION_METADATA_KEY];
+			if (moderation !== void 0) try {
+				this.options?.onModerationMetadata?.(moderation);
+			} catch {}
+			return firstTokenTime;
+		}
+		if (eventType === "error" || eventType === "response.failed") throw createCodexProviderStreamError(rawEvent);
+		return firstTokenTime;
+	}
+	#flushSummaryDeltas(entry) {
+		if (entry?.block?.type !== "thinking") return;
+		for (const delta of this.runtime.takeSummaryDeltas(entry)) {
+			entry.block.thinking += delta;
+			this.stream.push({
+				type: "thinking_delta",
+				contentIndex: entry.contentIndex,
+				delta,
+				partial: this.output
+			});
+		}
+	}
+	#handleOutputItemDone(rawEvent) {
+		const { runtime, output, stream } = this;
+		const rawItem = rawEvent.item;
+		if (!rawItem || typeof rawItem !== "object") return;
+		const item = structuredCloneJSON(rawItem);
+		if (item.type === "image_generation_call" && item.result) item.status = "completed";
+		runtime.nativeOutputItems.push(item);
+		const itemId = "id" in item && typeof item.id === "string" ? item.id : "";
+		const entry = (itemId ? runtime.openItems.get(itemId) : null) ?? runtime.openItemForEvent(rawEvent);
+		const block = entry?.block ?? null;
+		const contentIndex = entry?.contentIndex ?? output.content.length - 1;
+		if (item.type === "image_generation_call" && item.result) {
+			appendResponsesImageResult(output, stream, item.result);
+			runtime.closeOpenItem(entry);
+			return;
+		}
+		if (item.type === "reasoning" && block?.type === "thinking") {
+			this.#flushSummaryDeltas(entry);
+			block.thinking = finalizeReasoningThinking(item, block.thinking, this.#sequentialCutoffSummaries ? this.runtime.cutoffSummaries : void 0);
+			block.thinkingSignature = JSON.stringify(item);
+			stream.push({
+				type: "thinking_end",
+				contentIndex,
+				content: block.thinking,
+				partial: output
+			});
+			runtime.closeOpenItem(entry);
+			return;
+		}
+		if (item.type === "message" && block?.type === "text") {
+			block.text = finalizeMessageText(item, block.text);
+			const phase = item.phase === "commentary" || item.phase === "final_answer" ? item.phase : void 0;
+			block.textSignature = encodeTextSignatureV1(item.id, phase);
+			stream.push({
+				type: "text_end",
+				contentIndex,
+				content: block.text,
+				partial: output
+			});
+			runtime.closeOpenItem(entry);
+			return;
+		}
+		if (item.type === "function_call") {
+			const toolCall = {
+				type: "toolCall",
+				id: encodeResponsesToolCallId(item.call_id, item.id),
+				name: item.name,
+				arguments: parseStreamingJson(item.arguments || "{}")
+			};
+			if (block?.type === "toolCall") {
+				block.arguments = toolCall.arguments;
+				clearStreamingPartialJson(block);
+			}
+			runtime.closeOpenItem(entry);
+			runtime.canSafelyReplayWebsocketOverSse = false;
+			stream.push({
+				type: "toolcall_end",
+				contentIndex,
+				toolCall,
+				partial: output
+			});
+			return;
+		}
+		if (item.type === "computer_call") {
+			const toolCall = {
+				type: "toolCall",
+				id: encodeResponsesToolCallId(item.call_id, item.id),
+				name: "computer",
+				arguments: {},
+				providerMetadata: computerCallMetadata(item)
+			};
+			let resolvedContentIndex = contentIndex;
+			if (block?.type === "toolCall") {
+				block.id = toolCall.id;
+				block.providerMetadata = toolCall.providerMetadata;
+				clearStreamingPartialJson(block);
+			} else {
+				output.content.push(toolCall);
+				resolvedContentIndex = output.content.length - 1;
+			}
+			runtime.closeOpenItem(entry);
+			runtime.canSafelyReplayWebsocketOverSse = false;
+			stream.push({
+				type: "toolcall_end",
+				contentIndex: resolvedContentIndex,
+				toolCall,
+				partial: output
+			});
+			return;
+		}
+		if (item.type === "custom_tool_call") {
+			const partial = block?.type === "toolCall" ? block[kStreamingPartialJson] : void 0;
+			const rawInput = partial && partial.length > 0 ? partial : item.input ?? "";
+			const toolCall = {
+				type: "toolCall",
+				id: encodeResponsesToolCallId(item.call_id, item.id),
+				name: item.name,
+				arguments: { input: rawInput },
+				customWireName: item.name
+			};
+			if (block?.type === "toolCall") {
+				block.arguments = { input: rawInput };
+				clearStreamingPartialJson(block);
+			}
+			runtime.closeOpenItem(entry);
+			runtime.canSafelyReplayWebsocketOverSse = false;
+			stream.push({
+				type: "toolcall_end",
+				contentIndex,
+				toolCall,
+				partial: output
+			});
+			return;
+		}
+	}
+	#handleResponseCompleted(rawEvent) {
+		const { runtime, model, output } = this;
+		runtime.sawTerminalEvent = true;
+		const rawResponse = rawEvent.response;
+		const response = rawResponse && typeof rawResponse === "object" ? rawResponse : void 0;
+		const responseId = response && "id" in response && typeof response.id === "string" ? response.id : void 0;
+		const usage = response && "usage" in response ? parseCodexResponseUsage(response.usage) : void 0;
+		const serviceTier = response && "service_tier" in response ? parseCodexServiceTier(response.service_tier) : void 0;
+		const status = response && "status" in response ? parseCodexResponseStatus(response.status) : void 0;
+		const endTurn = response && "end_turn" in response ? response.end_turn : void 0;
+		populateResponsesUsageFromResponse(output, usage);
+		recordCodexTurnUsageDiagnostics(runtime.websocketState, usage, output.usage);
+		if (responseId) output.responseId = responseId;
+		const state = runtime.websocketState;
+		if (state) {
+			if (runtime.transport !== "websocket") resetCodexWebSocketAppendState(state);
+			else {
+				state.lastRequest = structuredCloneJSON(runtime.requestBodyForState);
+				const replayableResponseItems = sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(structuredCloneJSON(runtime.nativeOutputItems));
+				if (responseId && replayableResponseItems) {
+					state.lastResponseId = responseId;
+					state.lastResponseItems = replayableResponseItems;
+					state.canAppend = rawEvent.type === "response.done" || rawEvent.type === "response.completed";
+				} else state.canAppend = false;
+			}
+		}
+		const incompleteDetails = response && "incomplete_details" in response && response.incomplete_details && typeof response.incomplete_details === "object" ? response.incomplete_details : void 0;
+		const shouldPromoteIncompleteToolUse = status === "incomplete" && incompleteDetails !== void 0 && "reason" in incompleteDetails && incompleteDetails.reason === "max_output_tokens" && hasExecutableIncompleteResponsesToolCalls(output);
+		finalizePendingResponsesToolCalls(output);
+		calculateCost(model, output.usage);
+		applyCodexServiceTierPricing(model, output.usage, serviceTier, runtime.requestBodyForState.service_tier);
+		output.stopReason = mapOpenAIResponsesStopReason(status);
+		promoteResponsesToolUseStopReason(output, endTurn === true ? true : endTurn === false ? false : void 0, shouldPromoteIncompleteToolUse);
+	}
+	async #recoverStreamError(error) {
+		if (await this.#tryRecoverWhitespaceToolCallLoop(error)) return true;
+		if (await this.#tryReconnectWebSocketOnConnectionLimit(error)) return true;
+		if (await this.#tryRecoverPreviousResponseNotFound(error)) return true;
+		if (await this.#tryReplayWebsocketFailureOverSse(error)) return true;
+		if (await this.#tryRetryProviderError(error)) return true;
+		return false;
+	}
+	/**
+	* Recover from the degenerate whitespace-only tool-call argument loop
+	* ({@link CodexWhitespaceToolCallLoopError}). The interrupted function call has
+	* no usable arguments, so drop the partial turn and replay the request from
+	* scratch — bounded by {@link CODEX_WHITESPACE_LOOP_RETRY_LIMIT}. Sampling
+	* nondeterminism usually breaks the loop on a fresh attempt; once the budget is
+	* exhausted the original error is surfaced (now without the junk tool call
+	* polluting the message). Replay is refused once any visible content was already
+	* delivered to the consumer — a finished tool call (`canSafelyReplayWebsocketOverSse`),
+	* or any streamed text/commentary block still in `output.content` after the degenerate
+	* tool call is dropped — because replaying re-emits already-streamed deltas.
+	*/
+	async #tryRecoverWhitespaceToolCallLoop(error) {
+		if (!(error instanceof CodexWhitespaceToolCallLoopError)) return false;
+		this.#dropTrailingDegenerateToolCall();
+		if (this.runtime.whitespaceLoopRetries >= CODEX_WHITESPACE_LOOP_RETRY_LIMIT || !this.runtime.canSafelyReplayWebsocketOverSse || this.output.content.some((block) => block.type !== "thinking") || this.options?.signal?.aborted) return false;
+		this.runtime.whitespaceLoopRetries += 1;
+		const websocketState = this.requestContext.websocketState;
+		if (websocketState) {
+			resetCodexWebSocketAppendState(websocketState);
+			websocketState.turnState = void 0;
+			websocketState.modelsEtag = void 0;
+		}
+		CODEX_DEBUG && debug("[codex] retrying codex turn after whitespace-only tool-call argument loop", {
+			retry: this.runtime.whitespaceLoopRetries,
+			retryBudget: CODEX_WHITESPACE_LOOP_RETRY_LIMIT,
+			transport: this.runtime.transport
+		});
+		this.runtime.resetAccumulators();
+		this.runtime.sawTerminalEvent = false;
+		this.runtime.whitespaceToolCallArgumentsDelta = void 0;
+		resetOutputState(this.output);
+		this.firstTokenTime = void 0;
+		await scheduler.wait(CODEX_WHITESPACE_LOOP_RETRY_DELAY_MS * this.runtime.whitespaceLoopRetries, { signal: this.requestSetup.requestSignal });
+		if (this.runtime.transport === "websocket" && websocketState) {
+			await this.#reopenWebSocketStream(websocketState);
+			return true;
+		}
+		await this.#reopenSseStream(websocketState);
+		return true;
+	}
+	/**
+	* Pop the half-built degenerate tool-call block (the one whose arguments were
+	* nothing but whitespace) off the output accumulator so it never surfaces in the
+	* caller's message. Any legitimate content produced before it is preserved.
+	*/
+	#dropTrailingDegenerateToolCall() {
+		const { runtime, output } = this;
+		const block = runtime.currentBlock;
+		if (block && block.type === "toolCall" && output.content[output.content.length - 1] === block) output.content.pop();
+		runtime.closeOpenItem(runtime.currentEntry);
+	}
+	/**
+	* Handles `websocket_connection_limit_reached` errors by closing the stale connection
+	* and opening a fresh websocket. If content has already been emitted to the caller,
+	* falls back to SSE replay (same as other WS failures) since we cannot safely
+	* continue a partial response on a new connection. If a tool call was already
+	* delivered (`canSafelyReplayWebsocketOverSse` is false), the error surfaces
+	* instead — replaying would re-emit the same tool calls.
+	*/
+	async #tryReconnectWebSocketOnConnectionLimit(error) {
+		if (!(error instanceof CodexProviderStreamError) || error.code !== "websocket_connection_limit_reached") return false;
+		const websocketState = this.requestContext.websocketState;
+		if (!websocketState || this.runtime.transport !== "websocket" || this.options?.signal?.aborted) return false;
+		websocketState.connection?.close("connection_limit");
+		websocketState.connection = void 0;
+		resetCodexWebSocketAppendState(websocketState);
+		if (this.output.content.length > 0 && !this.runtime.canSafelyReplayWebsocketOverSse) return false;
+		CODEX_DEBUG && debug("[codex] codex websocket connection limit reached, reconnecting", {
+			hadContent: this.output.content.length > 0,
+			retry: this.runtime.websocketStreamRetries
+		});
+		if (this.output.content.length > 0) {
+			this.runtime.resetAccumulators();
+			resetOutputState(this.output);
+			this.firstTokenTime = void 0;
+			recordCodexWebSocketFailure(websocketState, true);
+			await this.#reopenSseStream(websocketState);
+			return true;
+		}
+		this.runtime.resetAccumulators();
+		this.firstTokenTime = void 0;
+		if (this.runtime.websocketStreamRetries >= CODEX_WEBSOCKET_RETRY_BUDGET) {
+			recordCodexWebSocketFailure(websocketState, true);
+			await this.#reopenSseStream(websocketState);
+			return true;
+		}
+		this.runtime.websocketStreamRetries += 1;
+		await scheduler.wait(CODEX_WEBSOCKET_RETRY_DELAY_MS * Math.max(1, this.runtime.websocketStreamRetries), { signal: this.requestSetup.requestSignal });
+		await this.#reopenWebSocketStream(websocketState);
+		return true;
+	}
+	async #tryRecoverPreviousResponseNotFound(error) {
+		const websocketState = this.requestContext.websocketState;
+		if (!isCodexStalePreviousResponseError(error) || !websocketState || this.output.content.length > 0 || this.options?.signal?.aborted || this.runtime.providerRetryAttempt >= CODEX_MAX_RETRIES) return false;
+		if (this.runtime.transport !== "websocket") return false;
+		this.runtime.providerRetryAttempt += 1;
+		resetCodexWebSocketAppendState(websocketState);
+		websocketState.turnState = void 0;
+		websocketState.modelsEtag = void 0;
+		this.runtime.resetAccumulators();
+		this.runtime.sawTerminalEvent = false;
+		resetOutputState(this.output);
+		this.firstTokenTime = void 0;
+		CODEX_DEBUG && debug("[codex] codex previous_response_id expired; retrying with full context", { retry: this.runtime.providerRetryAttempt });
+		await this.#reopenWebSocketStream(websocketState);
+		return true;
+	}
+	async #tryReplayWebsocketFailureOverSse(error) {
+		const websocketState = this.requestContext.websocketState;
+		if (!(this.runtime.transport === "websocket" && websocketState && isCodexWebSocketRetryableStreamError(error) && this.runtime.canSafelyReplayWebsocketOverSse && !this.runtime.sawTerminalEvent && !this.options?.signal?.aborted)) return false;
+		const state = websocketState;
+		const streamError = error instanceof Error ? error : new Error(String(error));
+		const replayingBufferedOutputOverSse = this.output.content.length > 0;
+		const fatalWebSocketMessage = streamError.message.toLowerCase();
+		const isFatal = CODEX_WEBSOCKET_FATAL_PATTERNS.some((pattern) => fatalWebSocketMessage.includes(pattern.toLowerCase()));
+		const activateFallback = replayingBufferedOutputOverSse || isFatal || this.runtime.websocketStreamRetries >= CODEX_WEBSOCKET_RETRY_BUDGET;
+		recordCodexWebSocketFailure(state, activateFallback);
+		CODEX_DEBUG && debug("[codex] codex websocket stream fallback", {
+			error: streamError.message,
+			retry: this.runtime.websocketStreamRetries,
+			retryBudget: CODEX_WEBSOCKET_RETRY_BUDGET,
+			activated: activateFallback,
+			fatal: isFatal,
+			replayedBufferedOutput: replayingBufferedOutputOverSse
+		});
+		if (!activateFallback) {
+			this.runtime.websocketStreamRetries += 1;
+			this.runtime.resetAccumulators();
+			this.firstTokenTime = void 0;
+			await scheduler.wait(CODEX_WEBSOCKET_RETRY_DELAY_MS * Math.max(1, this.runtime.websocketStreamRetries), { signal: this.requestSetup.requestSignal });
+			await this.#reopenWebSocketStream(state);
+			return true;
+		}
+		this.runtime.resetAccumulators();
+		resetOutputState(this.output);
+		this.firstTokenTime = void 0;
+		await this.#reopenSseStream(state);
+		return true;
+	}
+	async #tryRetryProviderError(error) {
+		if (!(error instanceof CodexProviderStreamError && error.retryable) || this.output.content.length > 0 || this.runtime.providerRetryAttempt >= CODEX_MAX_RETRIES || this.options?.signal?.aborted) return false;
+		this.runtime.providerRetryAttempt += 1;
+		const websocketState = this.requestContext.websocketState;
+		if (websocketState) {
+			resetCodexWebSocketAppendState(websocketState);
+			websocketState.turnState = void 0;
+			websocketState.modelsEtag = void 0;
+		}
+		CODEX_DEBUG && debug("[codex] retrying codex provider stream error", {
+			error: error instanceof Error ? error.message : String(error),
+			retry: this.runtime.providerRetryAttempt,
+			retryBudget: CODEX_MAX_RETRIES,
+			transport: this.runtime.transport
+		});
+		this.runtime.resetAccumulators();
+		this.runtime.sawTerminalEvent = false;
+		resetOutputState(this.output);
+		this.firstTokenTime = void 0;
+		await scheduler.wait(CODEX_RETRY_DELAY_MS * this.runtime.providerRetryAttempt, { signal: this.requestSetup.requestSignal });
+		if (this.runtime.transport === "websocket" && websocketState) {
+			await this.#reopenWebSocketStream(websocketState);
+			return true;
+		}
+		await this.#reopenSseStream(websocketState);
+		return true;
+	}
+	async #reopenWebSocketStream(state) {
+		try {
+			const next = await openCodexWebSocketTransport(this.model, this.options, this.requestContext, this.requestSetup, state, this.runtime.websocketStreamRetries, this.options ? (event) => this.options?.onSseEvent?.(event, this.model) : void 0);
+			this.runtime.eventStream = next.eventStream;
+			this.runtime.requestBodyForState = next.requestBodyForState;
+			this.runtime.transport = next.transport;
+			state.lastTransport = next.transport;
+		} catch (error) {
+			if (!(error instanceof CodexWebSocketTransportError)) throw error;
+			recordCodexWebSocketFailure(state, true);
+			CODEX_DEBUG && debug("[codex] codex websocket reopen failed, falling back to SSE", {
+				error: error.message,
+				retry: this.runtime.websocketStreamRetries
+			});
+			await this.#reopenSseStream(state);
+		}
+	}
+	async #reopenSseStream(state) {
+		const next = await openCodexSseTransport(this.model, this.requestContext, this.requestSetup, this.options, state);
+		this.runtime.eventStream = next.eventStream;
+		this.runtime.requestBodyForState = next.requestBodyForState;
+		this.runtime.transport = next.transport;
+		if (state) state.lastTransport = next.transport;
+	}
+	finalize(completion) {
+		const { output } = this;
+		if (this.options?.signal?.aborted) throw new AbortError();
+		if (!this.runtime.sawTerminalEvent) {
+			if (this.requestContext.websocketState) {
+				resetCodexWebSocketAppendState(this.requestContext.websocketState);
+				this.requestContext.websocketState.turnState = void 0;
+				this.requestContext.websocketState.modelsEtag = void 0;
+			}
+			CODEX_DEBUG && debug("[codex] codex stream ended unexpectedly", {
+				transport: this.runtime.transport,
+				terminalEventSeen: this.runtime.sawTerminalEvent,
+				unexpectedStreamEnd: true,
+				sentTurnStateHeader: Boolean(this.requestContext.websocketState?.turnState),
+				sentModelsEtagHeader: Boolean(this.requestContext.websocketState?.modelsEtag)
+			});
+			throw new CodexProviderStreamError("Codex stream ended before terminal completion event", false);
+		}
+		if (output.stopReason === "aborted" || output.stopReason === "error") throw new CodexProviderStreamError("Codex response failed", false);
+		output.providerPayload = createOpenAIResponsesHistoryPayload(this.model.provider, this.runtime.nativeOutputItems);
+		output.duration = performance.now() - this.startTime;
+		if (completion.firstTokenTime) output.ttft = completion.firstTokenTime - this.startTime;
+		return output;
+	}
+};
+const streamOpenAICodexResponses = (model, context, options) => {
+	const stream = new AssistantMessageEventStream();
+	(async () => {
+		const startTime = performance.now();
+		const output = {
+			role: "assistant",
+			content: [],
+			api: "openai-codex-responses",
+			provider: model.provider,
+			model: model.id,
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				totalTokens: 0,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			},
+			stopReason: "stop",
+			timestamp: Date.now()
+		};
+		const requestSetup = createRequestSetup(options);
+		let processingContext;
+		let requestContext;
+		try {
+			requestContext = await buildCodexRequestContext(model, context, options);
+			const initialTransport = await openInitialCodexEventStream(model, options, requestSetup, requestContext);
+			const runtime = new CodexStreamRuntime({
+				...initialTransport,
+				websocketState: requestContext.websocketState
+			});
+			if (requestContext.websocketState) requestContext.websocketState.lastTransport = initialTransport.transport;
+			processingContext = new CodexStreamProcessor({
+				runtime,
+				model,
+				output,
+				stream,
+				options,
+				requestSetup,
+				requestContext,
+				startTime
+			});
+			const completion = await processingContext.process();
+			processingContext.firstTokenTime = completion.firstTokenTime;
+			const message = processingContext.finalize(completion);
+			stream.push({
+				type: "done",
+				reason: message.stopReason,
+				message
+			});
+			stream.end();
+		} catch (error$1) {
+			const failureContext = processingContext ?? {
+				model,
+				output,
+				options,
+				requestContext: requestContext ?? {
+					apiKey: "",
+					accountId: "",
+					baseUrl: model.baseUrl || "https://chatgpt.com/backend-api",
+					url: "",
+					requestHeaders: {},
+					codexClientVersion: "0.144.1",
+					responsesLite: options?.responsesLite === true,
+					transformedBody: { model: model.id },
+					rawRequestDump: {
+						provider: model.provider,
+						api: output.api,
+						model: model.id,
+						method: "POST",
+						url: "",
+						body: { model: model.id }
+					}
+				},
+				startTime
+			};
+			try {
+				const failure = await handleCodexStreamFailure(failureContext, error$1);
+				stream.push({
+					type: "error",
+					reason: failure.stopReason,
+					error: failure
+				});
+			} catch (failureError) {
+				error("Codex stream failure handler threw", { error: failureError instanceof Error ? failureError.message : String(failureError) });
+				output.stopReason = "error";
+				output.errorMessage ??= error$1 instanceof Error ? error$1.message : String(error$1);
+				stream.push({
+					type: "error",
+					reason: "error",
+					error: output
+				});
+			}
+			stream.end();
+		} finally {
+			requestContext?.isolatedTransportState?.close();
+		}
+	})();
+	return stream;
+};
+function getCodexWebSocketSessionKey(normalizedSessionId, model, accountId, apiKey, baseUrl, responsesLite) {
+	if (!normalizedSessionId) return void 0;
+	const credentialKey = accountId ? `account:${accountId}` : `token:${Bun.hash(apiKey).toString(36)}`;
+	const liteSuffix = responsesLite ? ":lite" : "";
+	return `${credentialKey}:${baseUrl}:${model.id}:${normalizedSessionId}${liteSuffix}`;
+}
+function getCodexWebSocketSessionState(sessionKey, providerSessionState) {
+	const existing = providerSessionState.webSocketSessions.get(sessionKey);
+	if (existing) return existing;
+	const created = {
+		disableWebsocket: false,
+		canAppend: false,
+		fallbackCount: 0,
+		prewarmed: false,
+		stats: {
+			fullContextRequests: 0,
+			deltaRequests: 0,
+			lastInputItems: 0
+		}
+	};
+	providerSessionState.webSocketSessions.set(sessionKey, created);
+	return created;
+}
+function resetCodexWebSocketAppendState(state) {
+	state.canAppend = false;
+	state.lastRequest = void 0;
+	state.lastResponseId = void 0;
+	state.lastResponseItems = void 0;
+}
+function recordCodexWebSocketFailure(state, activateFallback) {
+	resetCodexWebSocketAppendState(state);
+	if (state.connection && !state.connection.isConnecting()) {
+		state.connection.close("fallback");
+		state.connection = void 0;
+	}
+	state.lastFallbackAt = Date.now();
+	if (activateFallback && !state.disableWebsocket) {
+		state.disableWebsocket = true;
+		state.fallbackCount += 1;
+	}
+}
+function getCodexWebSocketEnvValue() {
+	if ($env.PI_CODEX_WEBSOCKET !== void 0) return $flag("PI_CODEX_WEBSOCKET");
+}
+function shouldUseCodexWebSocket(model, state, preferWebsockets) {
+	if (model.preferWebsockets === false) return false;
+	if (!state || state.disableWebsocket) return false;
+	const envVal = getCodexWebSocketEnvValue();
+	if (envVal !== void 0) return envVal;
+	if (preferWebsockets === false) return false;
+	return true;
+}
+const codexDiagnosticsTextEncoder = new TextEncoder();
+function jsonByteLength(value) {
+	const json = JSON.stringify(value);
+	return codexDiagnosticsTextEncoder.encode(json === void 0 ? "undefined" : json).byteLength;
+}
+function hashJson(value) {
+	const json = JSON.stringify(value);
+	return String(Bun.hash(json === void 0 ? "undefined" : json));
+}
+function parseCodexServiceTier(value) {
+	switch (value) {
+		case "auto":
+		case "default":
+		case "flex":
+		case "scale":
+		case "priority": return value;
+		default: return;
+	}
+}
+function parseCodexResponseStatus(value) {
+	switch (value) {
+		case "completed":
+		case "failed":
+		case "in_progress":
+		case "cancelled":
+		case "queued":
+		case "incomplete": return value;
+		default: return;
+	}
+}
+function parseCodexResponseUsage(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const usage = {};
+	let hasUsage = false;
+	if ("input_tokens" in value && typeof value.input_tokens === "number") {
+		usage.input_tokens = value.input_tokens;
+		hasUsage = true;
+	}
+	if ("output_tokens" in value && typeof value.output_tokens === "number") {
+		usage.output_tokens = value.output_tokens;
+		hasUsage = true;
+	}
+	if ("total_tokens" in value && typeof value.total_tokens === "number") {
+		usage.total_tokens = value.total_tokens;
+		hasUsage = true;
+	}
+	if ("prompt_cache_hit_tokens" in value && typeof value.prompt_cache_hit_tokens === "number") {
+		usage.prompt_cache_hit_tokens = value.prompt_cache_hit_tokens;
+		hasUsage = true;
+	}
+	if ("input_tokens_details" in value && value.input_tokens_details && typeof value.input_tokens_details === "object") {
+		const details = value.input_tokens_details;
+		const parsedDetails = {};
+		let hasDetails = false;
+		if ("cached_tokens" in details && typeof details.cached_tokens === "number") {
+			parsedDetails.cached_tokens = details.cached_tokens;
+			hasDetails = true;
+		}
+		if ("cache_write_tokens" in details && typeof details.cache_write_tokens === "number") {
+			parsedDetails.cache_write_tokens = details.cache_write_tokens;
+			hasDetails = true;
+		}
+		if ("orchestration_input_tokens" in details && typeof details.orchestration_input_tokens === "number") {
+			parsedDetails.orchestration_input_tokens = details.orchestration_input_tokens;
+			hasDetails = true;
+		}
+		if ("orchestration_input_cached_tokens" in details && typeof details.orchestration_input_cached_tokens === "number") {
+			parsedDetails.orchestration_input_cached_tokens = details.orchestration_input_cached_tokens;
+			hasDetails = true;
+		}
+		if (hasDetails) {
+			usage.input_tokens_details = parsedDetails;
+			hasUsage = true;
+		}
+	}
+	if ("output_tokens_details" in value && value.output_tokens_details && typeof value.output_tokens_details === "object") {
+		const details = value.output_tokens_details;
+		const parsedDetails = {};
+		let hasDetails = false;
+		if ("reasoning_tokens" in details && typeof details.reasoning_tokens === "number") {
+			parsedDetails.reasoning_tokens = details.reasoning_tokens;
+			hasDetails = true;
+		}
+		if ("orchestration_output_tokens" in details && typeof details.orchestration_output_tokens === "number") {
+			parsedDetails.orchestration_output_tokens = details.orchestration_output_tokens;
+			hasDetails = true;
+		}
+		if (hasDetails) {
+			usage.output_tokens_details = parsedDetails;
+			hasUsage = true;
+		}
+	}
+	return hasUsage ? usage : void 0;
+}
+function describeCodexInputItemType(item) {
+	if (item && typeof item === "object") {
+		if ("type" in item && typeof item.type === "string") return item.type;
+		if ("role" in item && typeof item.role === "string") return item.role;
+	}
+	return typeof item;
+}
+function createCodexOptionsHash(request) {
+	const options = {};
+	for (const key in request) {
+		if (key === "input" || key === "previous_response_id" || key === "type" || key === "client_metadata") continue;
+		options[key] = request[key];
+	}
+	return hashJson(options);
+}
+function buildCodexTurnRequestDiagnostics(request, transport, canAppendBeforeRequest) {
+	const input = request.input;
+	const inputItems = Array.isArray(input) ? input : [];
+	const inputItemTypes = inputItems.map(describeCodexInputItemType);
+	const promptCacheKey = typeof request.prompt_cache_key === "string" ? request.prompt_cache_key : void 0;
+	const toolsHash = request.tools === void 0 ? void 0 : hashJson(request.tools);
+	return {
+		transport,
+		previousResponseIdPresent: typeof request.previous_response_id === "string" && request.previous_response_id.length > 0,
+		inputItemCount: inputItems.length,
+		inputItemTypes,
+		...inputItemTypes[0] ? { firstInputItemType: inputItemTypes[0] } : {},
+		inputJsonBytes: jsonByteLength(inputItems),
+		...promptCacheKey !== void 0 ? { promptCacheKey } : {},
+		...toolsHash !== void 0 ? { toolsHash } : {},
+		optionsHash: createCodexOptionsHash(request),
+		canAppendBeforeRequest
+	};
+}
+function recordCodexTurnRequestDiagnostics(state, request, transport, canAppendBeforeRequest) {
+	if (!state) return;
+	const input = request.input;
+	state.stats.lastInputItems = Array.isArray(input) ? input.length : 0;
+	const previousResponseId = typeof request.previous_response_id === "string" ? request.previous_response_id : void 0;
+	if (previousResponseId && previousResponseId.length > 0) {
+		state.stats.deltaRequests += 1;
+		state.stats.lastDeltaInputItems = state.stats.lastInputItems;
+		state.stats.lastPreviousResponseId = previousResponseId;
+	} else {
+		state.stats.fullContextRequests += 1;
+		state.stats.lastDeltaInputItems = void 0;
+		state.stats.lastPreviousResponseId = void 0;
+	}
+	state.stats.lastTurn = { request: buildCodexTurnRequestDiagnostics(request, transport, canAppendBeforeRequest) };
+	CODEX_DEBUG && debug("[codex] codex turn request diagnostics", { diagnostics: state.stats.lastTurn.request });
+}
+function recordCodexTurnUsageDiagnostics(state, rawUsage, displayedUsage) {
+	if (!state?.stats.lastTurn || !rawUsage) return;
+	const details = rawUsage.input_tokens_details;
+	const outputDetails = rawUsage.output_tokens_details;
+	const rawInputTokens = rawUsage.input_tokens ?? 0;
+	const rawCachedTokens = details?.cached_tokens ?? rawUsage.prompt_cache_hit_tokens ?? 0;
+	const usageDiagnostics = {
+		rawInputTokens,
+		rawCachedTokens,
+		rawUncachedTokens: Math.max(0, rawInputTokens - rawCachedTokens),
+		rawOutputTokens: rawUsage.output_tokens ?? 0,
+		...typeof rawUsage.total_tokens === "number" ? { rawTotalTokens: rawUsage.total_tokens } : {},
+		...typeof details?.orchestration_input_tokens === "number" ? { rawOrchestrationInputTokens: details.orchestration_input_tokens } : {},
+		...typeof details?.orchestration_input_cached_tokens === "number" ? { rawOrchestrationCachedTokens: details.orchestration_input_cached_tokens } : {},
+		...typeof outputDetails?.orchestration_output_tokens === "number" ? { rawOrchestrationOutputTokens: outputDetails.orchestration_output_tokens } : {},
+		displayedInputTokens: displayedUsage.input,
+		displayedOutputTokens: displayedUsage.output,
+		displayedCacheReadTokens: displayedUsage.cacheRead,
+		displayedCacheWriteTokens: displayedUsage.cacheWrite,
+		displayedTotalTokens: displayedUsage.totalTokens,
+		displayedOrchestrationInputTokens: displayedUsage.orchestration?.input ?? 0,
+		displayedOrchestrationCacheReadTokens: displayedUsage.orchestration?.cacheRead ?? 0,
+		displayedOrchestrationOutputTokens: displayedUsage.orchestration?.output ?? 0
+	};
+	state.stats.lastTurn = {
+		...state.stats.lastTurn,
+		usage: usageDiagnostics
+	};
+	CODEX_DEBUG && debug("[codex] codex turn diagnostics", { diagnostics: state.stats.lastTurn });
+}
+/**
+* Shape the next websocket turn's request body: when the session's append
+* baseline is intact (same options, strict history prefix), chain via
+* `previous_response_id` + delta-only `input`; otherwise break the chain and
+* replay the full transcript. SSE requests never chain — the HTTP endpoint's
+* request schema has no `previous_response_id` (codex-rs carries it only on
+* websocket `response.create` frames) and strict gateway validators 400 it
+* with `{"detail":"Unsupported parameter: previous_response_id"}`.
+*/
+function buildCodexChainedRequestBody(requestBody, state) {
+	const chainable = state?.canAppend === true;
+	const appendInput = chainable ? buildResponsesDeltaInput(state.lastRequest, state.lastResponseItems, requestBody) : null;
+	if (appendInput && appendInput.length > 0 && state?.lastResponseId) return {
+		...requestBody,
+		previous_response_id: state.lastResponseId,
+		input: appendInput
+	};
+	if (chainable && state) {
+		CODEX_DEBUG && debug("[codex] codex append reset", {
+			hadTurnStateHeader: Boolean(state.turnState),
+			hadModelsEtagHeader: Boolean(state.modelsEtag)
+		});
+		resetCodexWebSocketAppendState(state);
+		state.turnState = void 0;
+		state.modelsEtag = void 0;
+	}
+	return requestBody;
+}
+function toWebSocketUrl(url) {
+	const parsed = new URL(url);
+	if (parsed.protocol === "https:") parsed.protocol = "wss:";
+	else if (parsed.protocol === "http:") parsed.protocol = "ws:";
+	return parsed.toString();
+}
+function headersToRecord(headers) {
+	const result = {};
+	for (const [key, value] of headers.entries()) result[key] = value;
+	return result;
+}
+var CodexWebSocketConnection = class {
+	#url;
+	#headers;
+	#proxy;
+	#onHandshakeHeaders;
+	#socket = null;
+	#queue = [];
+	#waiters = [];
+	#connectPromise;
+	#activeRequest = false;
+	#streamObserver;
+	#heartbeatInterval;
+	#removePongListener;
+	#handshakeHeaders;
+	#debugResponseLog;
+	/**
+	* Wall-clock of the most recent inbound activity on this socket — any
+	* decoded message, any pong, or the moment the handshake completed. Used
+	* by {@link isHealthyForReuse} so we don't write a continuation frame into
+	* a TCP-open-but-server-evicted socket whose `readyState` still says OPEN.
+	*/
+	#lastInboundAt = 0;
+	/** Wall-clock of the last heartbeat ping we issued; 0 if none yet. */
+	#lastPingAt = 0;
+	/**
+	* Most recent `response.id` accepted on this socket, retained across
+	* requests. Lets the next request drop a trailing/duplicate frame from the
+	* previous (cleanly-completed) response that outlived the queue drain.
+	*/
+	#lastSeenResponseId;
+	constructor(url, headers, options) {
+		this.#url = url;
+		this.#headers = headers;
+		this.#proxy = options.proxy;
+		this.#onHandshakeHeaders = options.onHandshakeHeaders;
+	}
+	isOpen() {
+		return this.#socket?.readyState === WebSocket.OPEN;
+	}
+	/** True while a handshake (possibly started by another caller) is still in flight. */
+	isConnecting() {
+		return this.#connectPromise !== void 0;
+	}
+	/**
+	* Stricter variant of {@link isOpen} for the connection-pool reuse gate.
+	* Refuses sockets that have been silent past {@link CODEX_WEBSOCKET_MAX_IDLE_REUSE_MS}.
+	*
+	* Bun's `WebSocket` does not always surface server-side eviction (no
+	* `onclose`, no `onerror`), so a socket can sit in readyState OPEN long
+	* after the upstream has dropped it. Reusing such a socket sends the next
+	* `response.create` into a half-open write buffer and parks the reader
+	* until the first-event / idle timeout fires (issue #1450). Forcing a
+	* reconnect on any suspect socket trades a sub-second handshake for a
+	* 60–300 s stall.
+	*/
+	isHealthyForReuse() {
+		if (!this.isOpen()) return false;
+		const maxIdleMs = CODEX_WEBSOCKET_MAX_IDLE_REUSE_MS;
+		if (maxIdleMs <= 0) return true;
+		if (this.#lastInboundAt === 0) return false;
+		return Date.now() - this.#lastInboundAt <= maxIdleMs;
+	}
+	matchesAuth(headers) {
+		return this.#headers.authorization === headers.authorization;
+	}
+	close(reason = "done") {
+		if (this.#socket && (this.#socket.readyState === WebSocket.OPEN || this.#socket.readyState === WebSocket.CONNECTING)) this.#socket.close(1e3, reason);
+		this.#socket = null;
+		this.#stopHeartbeat();
+	}
+	async connect(signal) {
+		if (this.isOpen()) return;
+		if (this.#connectPromise) {
+			time("codexWs:awaitSharedHandshake");
+			await this.#connectPromise;
+			return;
+		}
+		const { promise, resolve, reject } = Promise.withResolvers();
+		this.#connectPromise = promise;
+		const socket = new WebSocket(this.#url, {
+			headers: this.#headers,
+			proxy: this.#proxy
+		});
+		socket.binaryType = "nodebuffer";
+		this.#socket = socket;
+		let settled = false;
+		let timeout;
+		const clearPending = () => {
+			if (timeout !== void 0) {
+				clearTimeout(timeout);
+				timeout = void 0;
+			}
+			if (signal) signal.removeEventListener("abort", onAbort);
+		};
+		const onAbort = () => {
+			socket.close(1e3, "aborted");
+			if (!settled) {
+				settled = true;
+				clearPending();
+				reject(new CodexWebSocketTransportError(`request was aborted`));
+			}
+		};
+		if (signal) {
+			if (signal.aborted) onAbort();
+			else signal.addEventListener("abort", onAbort, { once: true });
+		}
+		if (!settled) timeout = setTimeout(() => {
+			socket.close(1e3, "connect-timeout");
+			if (!settled) {
+				settled = true;
+				clearPending();
+				reject(new CodexWebSocketTransportError(`connection timeout`));
+			}
+		}, CODEX_WEBSOCKET_CONNECT_TIMEOUT_MS);
+		socket.onopen = (event) => {
+			if (!settled) {
+				settled = true;
+				clearPending();
+				this.#lastInboundAt = Date.now();
+				this.#captureHandshakeHeaders(socket, event);
+				this.#startHeartbeat(socket);
+				resolve();
+			}
+		};
+		socket.onerror = (event) => {
+			const eventRecord = event;
+			const error = new CodexWebSocketTransportError(`websocket error: ${typeof eventRecord.message === "string" && eventRecord.message || eventRecord.error instanceof Error && eventRecord.error.message || String(event.type)}`);
+			if (!settled) {
+				settled = true;
+				clearPending();
+				reject(error);
+				return;
+			}
+			this.#push(error);
+		};
+		socket.onclose = (event) => {
+			this.#socket = null;
+			this.#stopHeartbeat();
+			if (!settled) {
+				settled = true;
+				clearPending();
+				reject(new CodexWebSocketTransportError(`websocket closed before open (${event.code})`));
+				return;
+			}
+			this.#push(new CodexWebSocketTransportError(`websocket closed (${event.code})`));
+			this.#push(null);
+		};
+		socket.onmessage = (event) => {
+			this.#lastInboundAt = Date.now();
+			this.#writeDebugWebSocketFrame(event.data);
+			try {
+				const text = typeof event.data === "string" ? event.data : Buffer.from(event.data).toString("utf-8");
+				if (!text) return;
+				const parsed = JSON.parse(text);
+				if (parsed.type === "error" && typeof parsed.error === "object" && parsed.error) {
+					const inner = parsed.error;
+					if (typeof parsed.code !== "string" && typeof inner.code === "string") parsed.code = inner.code;
+					if (typeof parsed.message !== "string" && typeof inner.message === "string") parsed.message = inner.message;
+				}
+				notifyCodexWebSocketInbound(this.#streamObserver, parsed, text);
+				this.#push(parsed);
+			} catch (error) {
+				notifyCodexWebSocketMalformed(this.#streamObserver, event.data, error);
+				this.#push(new CodexWebSocketTransportError(`${String(error)}`));
+			}
+		};
+		time("codexWs:awaitTcpHandshake");
+		try {
+			await promise;
+		} finally {
+			this.#connectPromise = void 0;
+		}
+	}
+	async *streamRequest(request, timeouts, signal, onSseEvent) {
+		if (!this.#socket || this.#socket.readyState !== WebSocket.OPEN) throw new CodexWebSocketTransportError(`websocket connection is unavailable`);
+		if (this.#activeRequest) throw new CodexWebSocketTransportError(`websocket request already in progress`);
+		if (signal?.aborted) throw new CodexWebSocketTransportError(`request was aborted`);
+		this.#activeRequest = true;
+		this.#streamObserver = onSseEvent;
+		this.#dropStaleFrames();
+		const onAbort = () => {
+			this.close("aborted");
+			this.#push(new CodexWebSocketTransportError(`request was aborted`));
+		};
+		if (signal) signal.addEventListener("abort", onAbort, { once: true });
+		try {
+			const debugSession = isRequestDebugEnabled() ? await createRequestDebugSession({
+				protocol: "websocket",
+				method: "POST",
+				url: this.#url,
+				headers: this.#headers,
+				body: request
+			}) : void 0;
+			this.#debugResponseLog = debugSession ? await debugSession.openResponseLog("WebSocket 101 Switching Protocols", this.#handshakeHeaders) : void 0;
+			const requestPayload = JSON.stringify(request);
+			notifyCodexWebSocketOutbound(onSseEvent, request, requestPayload);
+			const socket = this.#socket;
+			if (!socket || socket.readyState !== WebSocket.OPEN) throw new CodexWebSocketTransportError(`websocket connection is unavailable`);
+			try {
+				socket.send(requestPayload);
+			} catch (error) {
+				throw new CodexWebSocketTransportError(`websocket send failed: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			let sawFirstEvent = false;
+			const { idleTimeoutMs, firstEventTimeoutMs } = timeouts;
+			let lastProgressAt = Date.now();
+			let lastProgressEventType;
+			let lastEventAt = lastProgressAt;
+			let lastEventType;
+			let activeResponseId;
+			let lastSequence;
+			const priorResponseId = this.#lastSeenResponseId;
+			while (true) {
+				let timeoutMs;
+				let timeoutReason;
+				if (sawFirstEvent) {
+					timeoutReason = createCodexWebSocketTimeoutMessage("idle timeout waiting for websocket", {
+						lastEventAt,
+						lastEventType,
+						lastProgressAt,
+						lastProgressEventType
+					});
+					if (idleTimeoutMs !== void 0 && idleTimeoutMs > 0) {
+						timeoutMs = idleTimeoutMs - (Date.now() - lastProgressAt);
+						if (timeoutMs <= 0) {
+							CODEX_DEBUG && debug("[codex] codex websocket idle timeout", {
+								lastEventType,
+								lastProgressEventType,
+								msSinceLastEvent: Date.now() - lastEventAt,
+								msSinceLastProgress: Date.now() - lastProgressAt
+							});
+							throw new CodexWebSocketTransportError(`${timeoutReason}`);
+						}
+					}
+				} else {
+					timeoutReason = createCodexWebSocketTimeoutMessage("timeout waiting for first websocket event", {
+						lastEventAt,
+						lastEventType,
+						lastProgressAt,
+						lastProgressEventType
+					});
+					if (firstEventTimeoutMs !== void 0 && firstEventTimeoutMs > 0) timeoutMs = firstEventTimeoutMs;
+				}
+				const next = await this.#nextMessage(timeoutMs, timeoutReason);
+				if (next instanceof Error) throw next;
+				if (next === null) throw new CodexWebSocketTransportError(`websocket closed before response completion`);
+				const eventType = typeof next.type === "string" ? next.type : "";
+				const frameResponseId = extractCodexFrameResponseId(next);
+				const frameSequence = extractCodexFrameSequenceNumber(next);
+				if (frameResponseId !== void 0) {
+					if (activeResponseId === void 0) {
+						if (priorResponseId !== void 0 && frameResponseId === priorResponseId) continue;
+						activeResponseId = frameResponseId;
+					} else if (frameResponseId !== activeResponseId) {
+						this.close("stale-frame");
+						throw new CodexWebSocketTransportError(`websocket frame for response ${frameResponseId} interleaved into active response ${activeResponseId}`);
+					}
+					this.#lastSeenResponseId = frameResponseId;
+				}
+				if (frameSequence !== void 0) {
+					if (activeResponseId !== void 0 && lastSequence !== void 0 && frameSequence < lastSequence) {
+						this.close("stale-frame");
+						throw new CodexWebSocketTransportError(`websocket sequence_number ${frameSequence} regressed below ${lastSequence} within response ${activeResponseId}`);
+					}
+					lastSequence = frameSequence;
+				}
+				sawFirstEvent = true;
+				lastEventAt = Date.now();
+				lastEventType = eventType || void 0;
+				if (isCodexStreamProgressEvent(next)) {
+					lastProgressAt = lastEventAt;
+					lastProgressEventType = lastEventType;
+				}
+				yield next;
+				if (eventType === "response.completed" || eventType === "response.done" || eventType === "response.incomplete" || eventType === "response.failed" || eventType === "error") break;
+			}
+		} finally {
+			this.#activeRequest = false;
+			this.#streamObserver = void 0;
+			if (signal) signal.removeEventListener("abort", onAbort);
+			const debugResponseLog = this.#debugResponseLog;
+			this.#debugResponseLog = void 0;
+			await debugResponseLog?.close();
+		}
+	}
+	#captureHandshakeHeaders(socket, openEvent) {
+		const headers = extractCodexWebSocketHandshakeHeaders(socket, openEvent);
+		if (!headers) return;
+		this.#handshakeHeaders = headers;
+		this.#onHandshakeHeaders?.(headers);
+	}
+	#writeDebugWebSocketFrame(data) {
+		const log = this.#debugResponseLog;
+		if (!log) return;
+		if (typeof data === "string") {
+			log.write(data);
+			return;
+		}
+		if (data instanceof Uint8Array) {
+			log.write(data);
+			return;
+		}
+		if (data instanceof ArrayBuffer) {
+			log.write(new Uint8Array(data));
+			return;
+		}
+		log.write(String(data));
+	}
+	#startHeartbeat(socket) {
+		this.#stopHeartbeat();
+		const intervalMs = CODEX_WEBSOCKET_PING_INTERVAL_MS;
+		if (intervalMs <= 0) return;
+		this.#lastPingAt = 0;
+		const socketEventTarget = socket;
+		const onPong = () => {
+			this.#lastInboundAt = Date.now();
+		};
+		if (typeof socketEventTarget.addEventListener === "function" && typeof socketEventTarget.removeEventListener === "function") {
+			socketEventTarget.addEventListener("pong", onPong);
+			this.#removePongListener = () => socketEventTarget.removeEventListener("pong", onPong);
+		}
+		this.#heartbeatInterval = setInterval(() => {
+			if (this.#socket !== socket || socket.readyState !== WebSocket.OPEN) {
+				this.#stopHeartbeat();
+				return;
+			}
+			const pongTimeoutMs = CODEX_WEBSOCKET_PONG_TIMEOUT_MS;
+			if (pongTimeoutMs > 0 && this.#lastPingAt > 0 && this.#lastPingAt > this.#lastInboundAt && Date.now() - this.#lastPingAt > pongTimeoutMs) {
+				this.#failQueue(new CodexWebSocketTransportError(`websocket pong timeout`), "pong-timeout");
+				return;
+			}
+			if (typeof socket.ping !== "function") {
+				this.#stopHeartbeat();
+				return;
+			}
+			try {
+				socket.ping();
+				this.#lastPingAt = Date.now();
+			} catch (error) {
+				this.#failQueue(new CodexWebSocketTransportError(`websocket ping failed: ${error instanceof Error ? error.message : String(error)}`), "ping-failed");
+			}
+		}, intervalMs);
+		this.#heartbeatInterval.unref();
+	}
+	#stopHeartbeat() {
+		if (this.#heartbeatInterval) {
+			clearInterval(this.#heartbeatInterval);
+			this.#heartbeatInterval = void 0;
+		}
+		if (this.#removePongListener) {
+			this.#removePongListener();
+			this.#removePongListener = void 0;
+		}
+		this.#lastPingAt = 0;
+	}
+	#failQueue(error, closeReason) {
+		CODEX_DEBUG && debug("[codex] codex websocket transport failure", {
+			error: error.message,
+			closeReason
+		});
+		this.#queue.length = 0;
+		this.#queue.push(error);
+		this.close(closeReason);
+		this.#wakeWaiters();
+	}
+	/**
+	* Discard data frames from a previous request that remained in `#queue`
+	* after the consumer broke out on the terminal event. Preserves any queued
+	* transport error (from `onerror` / `onclose` / `#failQueue`) so the next
+	* `#nextMessage` surfaces the death signal instead of waiting it out.
+	*
+	* Returns the number of frames dropped (test/debug visibility only).
+	*/
+	#dropStaleFrames() {
+		if (this.#queue.length === 0) return 0;
+		const surviving = this.#queue.filter((item) => item instanceof Error);
+		const dropped = this.#queue.length - surviving.length;
+		if (dropped === 0) return 0;
+		this.#queue.length = 0;
+		for (const item of surviving) this.#queue.push(item);
+		CODEX_DEBUG && debug("[codex] codex websocket dropped stale frames before request", { dropped });
+		return dropped;
+	}
+	#wakeWaiters() {
+		for (;;) {
+			const waiter = this.#waiters.shift();
+			if (!waiter) break;
+			waiter();
+		}
+	}
+	#push(item) {
+		if (item instanceof Error) {
+			this.#queue.push(item);
+			this.#wakeWaiters();
+			return;
+		}
+		if (item !== null && this.#queue.length >= CODEX_WEBSOCKET_MESSAGE_QUEUE_CAPACITY) {
+			this.#failQueue(new CodexWebSocketTransportError(`websocket message queue exceeded ${CODEX_WEBSOCKET_MESSAGE_QUEUE_CAPACITY} items`), "queue-overflow");
+			return;
+		}
+		this.#queue.push(item);
+		const waiter = this.#waiters.shift();
+		if (waiter) waiter();
+	}
+	async #nextMessage(timeoutMs, timeoutReason) {
+		while (this.#queue.length === 0) {
+			const { promise, resolve } = Promise.withResolvers();
+			this.#waiters.push(resolve);
+			let timedOut = false;
+			let timeout;
+			if (timeoutMs !== void 0 && timeoutMs > 0) timeout = setTimeout(() => {
+				timedOut = true;
+				const waiterIndex = this.#waiters.indexOf(resolve);
+				if (waiterIndex >= 0) this.#waiters.splice(waiterIndex, 1);
+				resolve();
+			}, timeoutMs);
+			await promise;
+			if (timeout) clearTimeout(timeout);
+			if (timedOut && this.#queue.length === 0) return new CodexWebSocketTransportError(`${timeoutReason}`);
+		}
+		return this.#queue.shift() ?? null;
+	}
+};
+async function getOrCreateCodexWebSocketConnection(state, url, headers, provider, signal) {
+	const proxy = getProxyForUrl(provider, new URL(url));
+	const headerRecord = headersToRecord(headers);
+	for (let joinAttempt = 0; joinAttempt < 3; joinAttempt += 1) {
+		const pending = state.connection;
+		if (!pending || pending.isOpen() || !pending.isConnecting()) break;
+		try {
+			await pending.connect(signal);
+		} catch {}
+	}
+	if (state.connection?.isOpen()) {
+		if (!state.connection.matchesAuth(headerRecord)) {
+			state.connection.close("token-refresh");
+			resetCodexWebSocketAppendState(state);
+		} else if (state.connection.isHealthyForReuse()) {
+			time("codexWs:reuseOpenSocket");
+			return state.connection;
+		} else {
+			CODEX_DEBUG && debug("[codex] codex websocket reuse rejected by health check", {});
+			state.connection.close("stale-reuse");
+			resetCodexWebSocketAppendState(state);
+		}
+	}
+	state.connection?.close("reconnect");
+	resetCodexWebSocketAppendState(state);
+	time("codexWs:newSocket");
+	state.connection = new CodexWebSocketConnection(url, headerRecord, {
+		onHandshakeHeaders: (handshakeHeaders) => {
+			updateCodexSessionMetadataFromHeaders(state, handshakeHeaders);
+		},
+		proxy
+	});
+	await state.connection.connect(signal);
+	return state.connection;
+}
+/**
+* Compress an SSE request body with zstd. Returns `undefined` when
+* compression is disabled or fails, in which case the caller sends the
+* plain JSON string without a `content-encoding` header.
+*/
+function compressCodexRequestBody(bodyJson, baseUrl) {
+	if (!isOfficialCodexApiUrl(baseUrl) || !$flag("PI_CODEX_ZSTD", true)) return void 0;
+	try {
+		return Bun.zstdCompressSync(bodyJson, { level: 3 });
+	} catch (error) {
+		CODEX_DEBUG && debug("[codex] codex request body compression failed", { error: error instanceof Error ? error.message : String(error) });
+		return;
+	}
+}
+async function openCodexSseEventStream(url, requestHeaders, accountId, apiKey, sessionId, body, state, responsesLite, codexClientVersion, requestMetadata, signal, firstEventTimeoutMs, codexSseMaxAttempts, onSseEvent, fetchOverride) {
+	const headers = createCodexHeaders(requestHeaders, accountId, apiKey, codexClientVersion, sessionId, "sse", state, responsesLite, requestMetadata, await getCodexAttestationHeader(accountId));
+	let clearPreResponseTimeout;
+	const fetchAttempt = async (input, init) => {
+		try {
+			return await (fetchOverride ?? fetch)(input, init);
+		} finally {
+			clearPreResponseTimeout?.();
+			clearPreResponseTimeout = void 0;
+		}
+	};
+	const bodyJson = JSON.stringify(body);
+	const compressedBody = compressCodexRequestBody(bodyJson, url);
+	if (compressedBody !== void 0) headers.set("content-encoding", "zstd");
+	CODEX_DEBUG && debug("[codex] codex request", {
+		url,
+		model: body.model,
+		headers: redactHeaders(headers),
+		sentTurnStateHeader: headers.has(X_CODEX_TURN_STATE_HEADER),
+		sentModelsEtagHeader: headers.has(X_MODELS_ETAG_HEADER)
+	});
+	const send = (requestBody) => fetchWithRetry(url, {
+		method: "POST",
+		headers,
+		body: requestBody,
+		signal,
+		prepareInit: () => {
+			const watchdog = armPreResponseTimeout(signal, firstEventTimeoutMs);
+			clearPreResponseTimeout = watchdog.clear;
+			return { signal: watchdog.signal };
+		},
+		maxAttempts: resolveCodexSseMaxAttempts(codexSseMaxAttempts),
+		defaultDelayMs: (attempt) => CODEX_RETRY_DELAY_MS * (attempt + 1),
+		maxDelayMs: CODEX_RATE_LIMIT_BUDGET_MS,
+		fetch: fetchAttempt,
+		timeout: false
+	});
+	let response;
+	try {
+		response = await send(compressedBody ?? bodyJson);
+		if (compressedBody !== void 0 && (response.status === 400 || response.status === 415)) {
+			const rejectedStatus = response.status;
+			await response.body?.cancel();
+			headers.delete("content-encoding");
+			CODEX_DEBUG && debug("[codex] retrying request without zstd after encoding rejection", {
+				url,
+				status: rejectedStatus
+			});
+			response = await send(bodyJson);
+		}
+	} finally {
+		clearPreResponseTimeout?.();
+	}
+	CODEX_DEBUG && debug("[codex] codex response", {
+		url: response.url,
+		status: response.status,
+		statusText: response.statusText,
+		contentType: response.headers.get("content-type") || null,
+		cfRay: response.headers.get("cf-ray") || null
+	});
+	if (!response.ok) throw await CodexApiError.fromResponse(response);
+	updateCodexSessionMetadataFromHeaders(state, response.headers);
+	if (!response.body) throw new CodexProviderStreamError("No response body", false);
+	return readSseJson(response.body, signal, (event) => onSseEvent?.({
+		event: event.event,
+		data: event.data,
+		raw: [...event.raw]
+	}, void 0));
+}
+function createCodexHeaders(initHeaders, accountId, accessToken, codexClientVersion, sessionId, transport = "sse", state, responsesLite = false, requestMetadata, attestation) {
+	const headers = new Headers(initHeaders ?? {});
+	headers.delete("x-api-key");
+	headers.set("Authorization", `Bearer ${accessToken}`);
+	if (accountId) headers.set(OPENAI_HEADERS.ACCOUNT_ID, accountId);
+	if (attestation) headers.set(OPENAI_HEADERS.ATTESTATION, attestation);
+	else headers.delete(OPENAI_HEADERS.ATTESTATION);
+	const betaHeader = transport === "websocket" ? OPENAI_HEADER_VALUES.BETA_RESPONSES_WEBSOCKETS_V2 : OPENAI_HEADER_VALUES.BETA_RESPONSES;
+	headers.delete(OPENAI_HEADERS.BETA);
+	headers.delete("openai-beta");
+	headers.set(OPENAI_HEADERS.BETA, betaHeader);
+	headers.set(OPENAI_HEADERS.ORIGINATOR, OPENAI_HEADER_VALUES.ORIGINATOR_CODEX);
+	headers.set(OPENAI_HEADERS.VERSION, codexClientVersion);
+	headers.set("User-Agent", USER_AGENT);
+	if (sessionId) {
+		headers.set(OPENAI_HEADERS.CONVERSATION_ID, sessionId);
+		headers.set(OPENAI_HEADERS.SESSION_ID, sessionId);
+		headers.set("x-client-request-id", sessionId);
+	} else {
+		headers.delete(OPENAI_HEADERS.CONVERSATION_ID);
+		headers.delete(OPENAI_HEADERS.SESSION_ID);
+		headers.delete("x-client-request-id");
+	}
+	headers.delete(OPENAI_HEADERS.INSTALLATION_ID);
+	if (requestMetadata) applyCodexCompatibilityHeaders(headers, requestMetadata);
+	else {
+		headers.delete(OPENAI_HEADERS.SCOPED_SESSION_ID);
+		headers.delete(OPENAI_HEADERS.THREAD_ID);
+		headers.delete(OPENAI_HEADERS.WINDOW_ID);
+		headers.delete(OPENAI_HEADERS.TURN_METADATA);
+	}
+	if (state?.turnState) headers.set(X_CODEX_TURN_STATE_HEADER, state.turnState);
+	else headers.delete(X_CODEX_TURN_STATE_HEADER);
+	if (state?.modelsEtag) headers.set(X_MODELS_ETAG_HEADER, state.modelsEtag);
+	else headers.delete(X_MODELS_ETAG_HEADER);
+	if (responsesLite) headers.set(OPENAI_HEADERS.RESPONSES_LITE, "true");
+	else headers.delete(OPENAI_HEADERS.RESPONSES_LITE);
+	if (transport === "sse") {
+		headers.set("accept", "text/event-stream");
+		headers.set("content-type", "application/json");
+	} else {
+		headers.delete("accept");
+		headers.delete("content-type");
+	}
+	return headers;
+}
+function redactHeaders(headers) {
+	const redacted = {};
+	for (const [key, value] of headers.entries()) {
+		const lower = key.toLowerCase();
+		if (lower === "authorization") {
+			redacted[key] = "Bearer [redacted]";
+			continue;
+		}
+		if (lower.includes("account") || lower.includes("session") || lower.includes("conversation") || lower.includes("thread") || lower.includes("window") || lower.includes("installation") || lower.startsWith("x-codex-turn") || lower === "x-client-request-id" || lower === "cookie") {
+			redacted[key] = "[redacted]";
+			continue;
+		}
+		redacted[key] = value;
+	}
+	return redacted;
+}
+/** Resolve a Codex Responses endpoint exactly as the chat and compaction transports do. */
+function resolveCodexResponsesUrl(baseUrl) {
+	const normalized = (baseUrl && baseUrl.trim().length > 0 ? baseUrl : CODEX_BASE_URL).replace(/\/+$/, "");
+	if (normalized.endsWith("/codex/responses")) return normalized;
+	if (normalized.endsWith("/codex")) return `${normalized}/responses`;
+	return `${normalized}/codex/responses`;
+}
+function convertMessages(model, context) {
+	const messages = [];
+	const normalizeToolCallId = (id) => {
+		if (!id.includes("|")) return id;
+		const [callId, itemId] = id.split("|");
+		const sanitizedCallId = callId.replace(/[^a-zA-Z0-9_-]/g, "_");
+		let sanitizedItemId = itemId.replace(/[^a-zA-Z0-9_-]/g, "_");
+		if (!sanitizedItemId.startsWith("fc")) sanitizedItemId = `fc_${sanitizedItemId}`;
+		let normalizedCallId = sanitizedCallId.length > 64 ? sanitizedCallId.slice(0, 64) : sanitizedCallId;
+		let normalizedItemId = sanitizedItemId.length > 64 ? sanitizedItemId.slice(0, 64) : sanitizedItemId;
+		normalizedCallId = normalizedCallId.replace(/_+$/, "");
+		normalizedItemId = normalizedItemId.replace(/_+$/, "");
+		return `${normalizedCallId}|${normalizedItemId}`;
+	};
+	const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
+	const escapeControlTokens = isHarmonyDialectModel(model);
+	let msgIndex = 0;
+	const customCallIds = /* @__PURE__ */ new Set();
+	const knownCallIds = /* @__PURE__ */ new Set();
+	const computerCallIds = /* @__PURE__ */ new Set();
+	for (const msg of transformedMessages) {
+		if (msg.role === "user" || msg.role === "developer") {
+			const providerPayload = msg.providerPayload;
+			const historyItems = getOpenAIResponsesHistoryItems(providerPayload, model.provider);
+			if (historyItems) {
+				const redactedHistoryItems = redactSensitiveInObject(historyItems).result;
+				const replayItems = model.supportsComputerUse === true ? redactedHistoryItems : unrollCodexComputerItems(redactedHistoryItems, model.compat.supportsImageDetailOriginal);
+				for (const item of replayItems) {
+					if (item.type === "custom_tool_call") customCallIds.add(item.call_id);
+					if (item.type === "computer_call") computerCallIds.add(item.call_id);
+					if ((item.type === "function_call" || item.type === "custom_tool_call") && item.call_id) knownCallIds.add(item.call_id);
+				}
+				messages.push(...escapeControlTokens ? escapeReplayedControlTokens(replayItems) : replayItems);
+				msgIndex += 1;
+				continue;
+			}
+			const normalizedContent = normalizeInputMessageContent(model, msg.content);
+			if (normalizedContent.length === 0) continue;
+			messages.push({
+				role: msg.role,
+				content: normalizedContent
+			});
+			msgIndex += 1;
+			continue;
+		}
+		if (msg.role === "assistant") {
+			const assistantMsg = msg;
+			const providerPayload = assistantMsg.api === model.api && assistantMsg.model === model.id ? getOpenAIResponsesHistoryPayload(assistantMsg.providerPayload, model.provider, assistantMsg.provider) : void 0;
+			const historyItems = providerPayload?.items;
+			let suppressHiddenEmptyFallback = false;
+			if (historyItems) {
+				const sanitizedHistoryItems = sanitizeOpenAIResponsesAssistantHistoryItemsForReplay(historyItems);
+				if (sanitizedHistoryItems) {
+					const rawReplayItems = model.supportsComputerUse === true ? sanitizedHistoryItems : unrollCodexComputerItems(sanitizedHistoryItems, model.compat.supportsImageDetailOriginal);
+					const replayItems = escapeControlTokens ? escapeReplayedControlTokens(rawReplayItems) : rawReplayItems;
+					for (const item of replayItems) {
+						if (item.type === "custom_tool_call") customCallIds.add(item.call_id);
+						if (item.type === "computer_call") computerCallIds.add(item.call_id);
+						if ((item.type === "function_call" || item.type === "custom_tool_call") && item.call_id) knownCallIds.add(item.call_id);
+					}
+					if (providerPayload?.dt) messages.push(...replayItems);
+					else messages.splice(0, messages.length, ...replayItems);
+					msgIndex += 1;
+					continue;
+				}
+				suppressHiddenEmptyFallback = true;
+			}
+			const convertedOutputItems = convertResponsesAssistantMessage(model.supportsComputerUse === true ? assistantMsg : unrollCodexComputerAssistantMessage(assistantMsg), model, msgIndex, knownCallIds, !suppressHiddenEmptyFallback, customCallIds, false, true, void 0, computerCallIds);
+			const outputItems = suppressHiddenEmptyFallback ? sanitizeOpenAIResponsesAssistantFallbackItemsForReplay(convertedOutputItems) : convertedOutputItems;
+			if (outputItems.length > 0) messages.push(...escapeControlTokens ? escapeReplayedControlTokens(outputItems) : outputItems);
+			msgIndex += 1;
+			continue;
+		}
+		if (msg.role === "toolResult") appendResponsesToolResultMessages(messages, model.supportsComputerUse === true ? msg : unrollCodexComputerToolResult(msg), model, false, model.compat.supportsImageDetailOriginal, knownCallIds, customCallIds, true, computerCallIds);
+		msgIndex += 1;
+	}
+	return messages;
+}
+function normalizeInputMessageContent(model, content) {
+	const escapeControlTokens = isHarmonyDialectModel(model);
+	if (typeof content === "string") {
+		if (!content || content.trim() === "") return [];
+		const text = content.toWellFormed();
+		return [{
+			type: "input_text",
+			text: escapeControlTokens ? escapeHarmonyControlTokens(text) : text
+		}];
+	}
+	return convertResponsesInputContent(content, model.input.includes("image"), model.compat.supportsImageDetailOriginal, escapeControlTokens) ?? [];
+}
+/** @internal Exported for tests. */
+function convertOpenAICodexResponsesTools(tools, model) {
+	const allowFreeform = model.applyPatchToolType === "freeform";
+	const payloads = [];
+	for (const tool of tools) {
+		if (tool.native?.type === "computer" && model.supportsComputerUse === true) {
+			payloads.push({ type: "computer" });
+			continue;
+		}
+		if (allowFreeform && tool.customFormat) {
+			payloads.push({
+				type: "custom",
+				name: tool.customWireName ?? tool.name,
+				description: tool.description || "",
+				format: {
+					type: "grammar",
+					syntax: tool.customFormat.syntax,
+					definition: compactGrammarDefinition(tool.customFormat.syntax, tool.customFormat.definition)
+				}
+			});
+			continue;
+		}
+		const strict = !!(!NO_STRICT && tool.strict);
+		const baseParameters = sanitizeSchemaForOpenAIResponses(toolWireSchema(tool));
+		const { schema: parameters, strict: effectiveStrict } = adaptSchemaForStrict(baseParameters, strict);
+		payloads.push({
+			type: "function",
+			name: tool.name,
+			description: tool.description || "",
+			parameters,
+			...effectiveStrict ? { strict: true } : !NO_STRICT && tool.strict === false ? { strict: false } : {}
+		});
+	}
+	return payloads;
+}
+var CodexWebSocketTransportError = class extends Error {
+	constructor(detail) {
+		super(`${CODEX_WEBSOCKET_TRANSPORT_ERROR_PREFIX}: ${detail}`);
+		this.name = "CodexWebSocketTransportError";
+	}
+};
+var CodexWhitespaceToolCallLoopError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "CodexWhitespaceToolCallLoopError";
+	}
+};
+var CodexProviderStreamError = class extends Error {
+	retryable;
+	code;
+	constructor(message, retryable, code) {
+		super(message);
+		this.name = "CodexProviderStreamError";
+		this.retryable = retryable;
+		this.code = code;
+	}
+};
+const optionalCodexString = type("unknown").pipe((raw) => {
+	const out = type("string")(raw);
+	return out instanceof type.errors ? void 0 : out;
+});
+const innerErrorDetailSchema = type({
+	"code?": optionalCodexString,
+	"type?": optionalCodexString,
+	"message?": optionalCodexString
+});
+const codexErrorDetailSchema = type("unknown").pipe((raw) => {
+	const out = innerErrorDetailSchema(raw);
+	return out instanceof type.errors ? void 0 : out;
+});
+const innerFailureEventSchema = type({
+	"type?": optionalCodexString,
+	"code?": optionalCodexString,
+	"message?": optionalCodexString,
+	"status?": optionalCodexString,
+	"error?": codexErrorDetailSchema,
+	"response?": type("unknown").pipe((raw) => {
+		const out = type({
+			"error?": codexErrorDetailSchema,
+			"message?": optionalCodexString,
+			"status?": optionalCodexString
+		})(raw);
+		return out instanceof type.errors ? void 0 : out;
+	})
+});
+const codexFailureEventSchema = type("unknown").pipe((raw) => {
+	const out = innerFailureEventSchema(raw);
+	return out instanceof type.errors ? {
+		type: void 0,
+		code: void 0,
+		message: void 0,
+		status: void 0,
+		error: void 0,
+		response: void 0
+	} : out;
+});
+function isRetryableCodexFailureEvent(rawEvent) {
+	const event = codexFailureEventSchema(rawEvent);
+	if (event instanceof type.errors) return false;
+	const error = event.error ?? event.response?.error;
+	const code = error?.code ?? error?.type ?? event.code;
+	if (code && CODEX_RETRYABLE_EVENT_CODES.has(code.toLowerCase())) return true;
+	const message = error?.message ?? event.message ?? event.response?.message;
+	return !!message && CODEX_RETRYABLE_EVENT_MESSAGE.test(message);
+}
+function createCodexProviderStreamError(rawEvent) {
+	const event = codexFailureEventSchema(rawEvent);
+	if (event instanceof type.errors) return new CodexProviderStreamError("Codex response failed", false);
+	const nestedError = event.error ?? event.response?.error;
+	const code = nestedError?.code ?? nestedError?.type ?? event.code ?? "";
+	const message = event.message ?? "";
+	return new CodexProviderStreamError(event.type === "error" ? formatCodexErrorEvent(rawEvent, code, message) : formatCodexFailure(rawEvent) ?? "Codex response failed", isRetryableCodexFailureEvent(rawEvent), code || void 0);
+}
+function formatCodexFailure(rawEvent) {
+	const event = codexFailureEventSchema(rawEvent);
+	if (event instanceof type.errors) return null;
+	const error = event.error ?? event.response?.error;
+	const message = error?.message ?? event.message ?? event.response?.message;
+	const code = error?.code ?? error?.type ?? event.code;
+	const status = event.response?.status ?? event.status;
+	const meta = [];
+	if (code) meta.push(`code=${code}`);
+	if (status) meta.push(`status=${status}`);
+	if (message) return `Codex response failed: ${message}${meta.length ? ` (${meta.join(", ")})` : ""}`;
+	if (meta.length) return `Codex response failed (${meta.join(", ")})`;
+	try {
+		const rawEventJson = JSON.stringify(rawEvent);
+		return `Codex response failed: ${rawEventJson.length <= 800 ? rawEventJson : `${rawEventJson.slice(0, 800)}…[truncated ${rawEventJson.length - 800}]`}`;
+	} catch {
+		return "Codex response failed";
+	}
+}
+function formatCodexErrorEvent(rawEvent, code, message) {
+	const detail = formatCodexFailure(rawEvent);
+	if (detail) return detail.replace("response failed", "error event");
+	const meta = [];
+	if (code) meta.push(`code=${code}`);
+	if (message) meta.push(`message=${message}`);
+	if (meta.length > 0) return `Codex error event (${meta.join(", ")})`;
+	try {
+		const rawEventJson = JSON.stringify(rawEvent);
+		return `Codex error event: ${rawEventJson.length <= 800 ? rawEventJson : `${rawEventJson.slice(0, 800)}…[truncated ${rawEventJson.length - 800}]`}`;
+	} catch {
+		return "Codex error event";
+	}
+}
+//#endregion
+export { openai_codex_responses_exports as t };