@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

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

@@ -1,3232 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-import { r as __exportAll } from "./fs-promises-shim-B2YFWkcd.mjs";
-import { B as USER_AGENT, F as $flag, N as $env, S as time, _ as parseStreamingJson, b as debug, o as readSseJson, q as getInstallId, t as structuredCloneJSON, x as error } from "./src-AELUUb5U.mjs";
-import { G as fetchWithRetry, V as ProviderHttpError, _ as AbortError, b as PYTHON_HTTP2_STREAM_RESET_PATTERN, c as finalize, h as MissingApiKeyError, i as isProviderRetryableError, x as PYTHON_HTTP_INCOMPLETE_CHUNK_PATTERN } from "./error-O63pC8zg.mjs";
-import { A as toolWireSchema, M as adaptSchemaForStrict, f as stripOpenAIResponsesComputerLinkedReasoningIdsForReplay, g as clearStreamingPartialJson, h as transformMessages, i as getOpenAIResponsesHistoryPayload, j as NO_STRICT, l as sanitizeOpenAIResponsesAssistantFallbackItemsForReplay, m as redactSensitiveInObject, o as normalizeSystemPrompts, r as getOpenAIResponsesHistoryItems, t as createOpenAIResponsesHistoryPayload, u as sanitizeOpenAIResponsesAssistantHistoryItemsForReplay, w as kStreamingPartialJson, z as sanitizeSchemaForOpenAIResponses } from "./utils-cZX3f_Ls.mjs";
-import { t as asRecord } from "./type-guards-CttAANEx.mjs";
-import { B as convertResponsesInputContent, D as applyOpenAIServiceTier, Dt as escapeHarmonyControlTokens, G as encodeResponsesToolCallId, J as finalizeCustomToolCallInputDone, K as encodeTextSignatureV1, Ot as isHarmonyDialectModel, P as buildResponsesDeltaInput, Q as finalizeToolCallArgumentsDone, R as computerCallMetadata, U as createSequentialCutoffSummaryState, X as finalizePendingResponsesToolCalls, Y as finalizeMessageText, Z as finalizeReasoningThinking, _ as appendReasoningSummaryPart, a as CODEX_BASE_URL, b as appendResponsesImageResult, c as OPENAI_HEADER_VALUES, ct as mapOpenAIReasoningEffort, d as getCodexAccountId, et as getOpenAIPromptCacheKey, ft as populateResponsesUsageFromResponse, g as appendMessageTextDelta, h as appendMessageContentPart, it as hasExecutableIncompleteResponsesToolCalls, k as applyReasoningSummaryDone, kt as hasVisibleAssistantContent, l as applyCodexResidencyHeader, lt as mapOpenAIResponsesStopReason, m as accumulateToolCallArgumentsDelta, mt as promoteResponsesToolUseStopReason, n as getEnvApiKey, o as CODEX_CLIENT_VERSION, ot as isOpenAIResponsesProgressEvent, p as accumulateCustomToolCallInputDelta, q as escapeReplayedControlTokens, r as isOfficialCodexApiUrl, s as OPENAI_HEADERS, u as codexRoutingHint, ut as normalizeOpenAIPromptCacheKey, v as appendReasoningSummaryPartDone, x as appendResponsesToolResultMessages, y as appendReasoningSummaryTextDelta, z as convertResponsesAssistantMessage } from "./stream-AVOoe5Hj.mjs";
-import { a as toNumber } from "./utils-I4I8azHN.mjs";
-import { o as requireSupportedEffort } from "./anthropic-wire-lbGAFzYb.mjs";
-import { n as getProxyForUrl } from "./proxy-DxvCQOCA.mjs";
-import "./effort-BdtQMN-_.mjs";
-import { t as calculateCost } from "./models-DnXMYGcJ.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-BKEtb45Y.mjs";
-import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs, t as armPreResponseTimeout } from "./idle-iterator-D0ZXEcUq.mjs";
-import { n as isRequestDebugEnabled, t as createRequestDebugSession } from "./request-debug-BwPOqN_j.mjs";
-import { t as notifyRawSseEvent } from "./sse-debug-B-tkLCPW.mjs";
-import { n as planStableOpenAIEffort, r as compactGrammarDefinition, t as getOpenAIEffortControlState } from "./openai-configuration-update-xMYUjaK_.mjs";
-import { scheduler } from "node:timers/promises";
-import { type } from "@oh-my-pi/omptype";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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 explicitly opts into Responses Lite.
-*
-* Provider-native compaction passes the model's `useResponsesLite` flag as an
-* explicit option; normal inference defaults to the full Responses contract.
-*/
-function resolveCodexResponsesLite(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 false;
-}
-/**
-* 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 && model.compat.supportsReasoningSummary) 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(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" && !model.compat.supportsAllTurnsReasoningContext) delete body.reasoning.context;
-			else body.reasoning.context = options.reasoningContext;
-		}
-	} else delete body.reasoning;
-	if (!model.compat.supportsReasoningSummary && body.reasoning) delete body.reasoning.summary;
-	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@18.1.17/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@18.1.17/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,
-	tool_namespaces_info: 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(),
-		turnStates: /* @__PURE__ */ new Map()
-	};
-}
-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 getOrCreateCodexTurnState(session, compatibilityKey) {
-	if (!compatibilityKey) return {};
-	const existing = session.turnStates.get(compatibilityKey);
-	if (existing) return existing;
-	const created = {};
-	session.turnStates.set(compatibilityKey, created);
-	return created;
-}
-/**
-* Drop every compatibility-scoped sticky-routing token when a fresh logical
-* turn begins, mirroring codex-rs's per-turn `OnceLock`. Standalone compaction
-* owns a throwaway cell, so it never disturbs the live turn's tokens. Runs on
-* every entry path that opens a turn — the normal stream (`createCodexRequestContext`)
-* and the raw compaction routes (`createOpenAICodexCompatibilityMetadata`).
-*/
-function clearCodexTurnStatesForNewTurn(session, startNewTurn, compaction) {
-	if (startNewTurn && compaction?.phase !== "standalone_turn") session.turnStates.clear();
-}
-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 turnMetadataHeaderJson = toAsciiJsonString(turnMetadata);
-	let turnMetadataJson = turnMetadataHeaderJson;
-	if (options.toolNamespacesInfo !== void 0) {
-		turnMetadata.tool_namespaces_info = options.toolNamespacesInfo;
-		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,
-		turnMetadataHeaderJson,
-		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.turnMetadataHeaderJson) headers.set(OPENAI_HEADERS.TURN_METADATA, metadata.turnMetadataHeaderJson);
-	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);
-	}
-};
-function createCodexProviderSessionState() {
-	const state = {
-		webSocketSessions: /* @__PURE__ */ new Map(),
-		webSocketPublicToPrivate: /* @__PURE__ */ new Map(),
-		metadataSessions: /* @__PURE__ */ new Map(),
-		effortControls: /* @__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();
-			state.effortControls.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 && "effortControls" in state && state.effortControls 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(turnState, state, headers) {
-	if (!turnState && !state || !headers) return;
-	const resolvedHeaders = headers instanceof Headers ? headers : new Headers(headers);
-	const responseTurnState = resolvedHeaders.get(X_CODEX_TURN_STATE_HEADER);
-	if (turnState && turnState.value === void 0 && responseTurnState && responseTurnState.length > 0) turnState.value = responseTurnState;
-	const modelsEtag = resolvedHeaders.get(X_MODELS_ETAG_HEADER);
-	if (state && 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) {
-	if (serviceTier !== "flex" && serviceTier !== "priority") return 1;
-	return model.serviceTierCost?.[serviceTier] ?? 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(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.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);
-	const standaloneCompaction = compaction?.phase === "standalone_turn";
-	clearCodexTurnStatesForNewTurn(metadataSession, startNewTurn, compaction);
-	const turnState = standaloneCompaction ? {} : getOrCreateCodexTurnState(metadataSession, sessionKey);
-	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,
-		toolNamespacesInfo: options?.toolNamespacesInfo
-	});
-	transformedBody.client_metadata = requestMetadata.clientMetadata;
-	return {
-		apiKey,
-		accountId,
-		baseUrl,
-		url,
-		requestHeaders,
-		transportSessionId,
-		providerSessionState,
-		isolatedTransportState,
-		websocketState,
-		turnState,
-		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)
-	});
-}
-/** Serialize normal Codex turns and V2 compaction with the same cacheable prefix. */
-async function buildTransformedCodexRequestBody(model, context, options, promptCacheKey = getOpenAIPromptCacheKey(options), inputPrefix) {
-	const input = convertMessages(model, context);
-	const params = {
-		model: model.requestModelId ?? model.id,
-		input: inputPrefix?.length ? [...inputPrefix, ...input] : input,
-		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 };
-	const body = await 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 });
-	applyCodexStableEffort(model, body, options);
-	return body;
-}
-/**
-* Keep the request-level effort byte-stable across a conversation and carry
-* later changes as `configuration_update` items (GPT-6 Astra). Requires a
-* session id and provider session state to remember the baseline; without
-* them every request stands alone and sends its own effort.
-*/
-function applyCodexStableEffort(model, body, options) {
-	if (!model.compat.supportsConfigurationUpdate || options?.codexCompaction) return;
-	const effort = body.reasoning?.effort;
-	if (effort === void 0 || effort === "none" || !body.input) return;
-	const providerState = getCodexProviderSessionState(options?.providerSessionState);
-	const sessionId = normalizeOpenAIPromptCacheKey(options?.sessionId);
-	if (!providerState || !sessionId) return;
-	const state = getOpenAIEffortControlState(providerState.effortControls, `${model.id}\u0000${sessionId}`);
-	body.reasoning = {
-		...body.reasoning,
-		effort: planStableOpenAIEffort(state, body.input, effort)
-	};
-}
-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 (requestContext.turnState.value) websocketClientMetadata[X_CODEX_TURN_STATE_HEADER] = requestContext.turnState.value;
-	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.turnState, requestContext.responsesLite, requestContext.requestMetadata, await getCodexAttestationHeader(requestContext.accountId), requestContext.transformedBody);
-	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, requestContext.turnState, 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.turnState, 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
-};
-const CODEX_APPEND_PRESERVING_REJECTION_CODES = {
-	rate_limit_exceeded: true,
-	slow_down: 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);
-}
-function shouldPreserveCodexWebSocketAppendState(context, error) {
-	if (!(error instanceof CodexProviderStreamError) || !error.code) return false;
-	const state = context.requestContext.websocketState;
-	return Object.hasOwn(CODEX_APPEND_PRESERVING_REJECTION_CODES, error.code.toLowerCase()) && context.runtime?.transport === "websocket" && state?.canAppend === true && state.lastRequest !== void 0 && state.lastResponseId !== void 0 && state.lastResponseItems !== void 0;
-}
-async function handleCodexStreamFailure(context, error) {
-	const { output } = context;
-	if (context.requestContext.websocketState && !shouldPreserveCodexWebSocketAppendState(context, error)) {
-		resetCodexWebSocketAppendState(context.requestContext.websocketState);
-		context.requestContext.websocketState.modelsEtag = void 0;
-	}
-	const result = await finalize(error, {
-		api: context.model.api,
-		provider: context.model.provider,
-		model: context.model.id,
-		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;
-			}
-			if (!this.runtime.sawTerminalEvent) {
-				CODEX_DEBUG && debug("[codex] codex stream ended unexpectedly", {
-					transport: this.runtime.transport,
-					terminalEventSeen: false,
-					unexpectedStreamEnd: true,
-					sentTurnStateHeader: Boolean(this.requestContext.turnState.value),
-					sentModelsEtagHeader: Boolean(this.requestContext.websocketState?.modelsEtag)
-				});
-				throw new CodexProviderStreamError("Codex stream ended before terminal completion event", true);
-			}
-			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.completed" || eventType === "response.done" || eventType === "response.incomplete") {
-			this.#handleResponseCompleted(rawEvent);
-			return firstTokenTime;
-		}
-		if (eventType === "response.metadata") {
-			updateCodexSessionMetadataFromHeaders(this.requestContext.turnState, 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, output.timestamp);
-		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.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.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;
-	}
-	/**
-	* Emit balancing `*_end` events for every block that opened (pushed a
-	* `*_start`) but never committed visible content, so a retry that resets
-	* `output` and replays cannot leave the consumer with an orphaned
-	* `text_start`/`thinking_start` from the abandoned attempt. Only reachable
-	* blocks are empty text/reasoning ones — a committed tool/text block blocks
-	* the retry upstream.
-	*/
-	#closeOpenBlocksForReplay() {
-		const { runtime, output, stream } = this;
-		const open = new Set(runtime.openItems.values());
-		for (const entry of runtime.openItemsByOutputIndex.values()) open.add(entry);
-		if (runtime.currentEntry) open.add(runtime.currentEntry);
-		for (const entry of open) {
-			const block = entry.block;
-			if (block?.type === "thinking") stream.push({
-				type: "thinking_end",
-				contentIndex: entry.contentIndex,
-				content: block.thinking,
-				partial: output
-			});
-			else if (block?.type === "text") stream.push({
-				type: "text_end",
-				contentIndex: entry.contentIndex,
-				content: block.text,
-				partial: output
-			});
-		}
-	}
-	async #tryRetryProviderError(error) {
-		const retryable = error instanceof CodexProviderStreamError ? error.retryable : isProviderRetryableError(error);
-		const streamedContent = this.output.content.some((block) => block.type === "text" && block.text.length > 0 || block.type === "thinking" && block.thinking.length > 0);
-		if (!retryable || hasVisibleAssistantContent(this.output) || streamedContent || !this.runtime.canSafelyReplayWebsocketOverSse || this.runtime.providerRetryAttempt >= CODEX_MAX_RETRIES || this.options?.signal?.aborted) return false;
-		this.#closeOpenBlocksForReplay();
-		this.runtime.providerRetryAttempt += 1;
-		const websocketState = this.requestContext.websocketState;
-		if (websocketState) {
-			resetCodexWebSocketAppendState(websocketState);
-			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 (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.153.0",
-					turnState: {},
-					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 });
-}
-const CODEX_CHAIN_TOP_LEVEL_EXCLUDE_MAP = { service_tier: true };
-/**
-* Shape the next websocket turn's request body: when the session's strict
-* history prefix is intact and request options other than the per-turn
-* service_tier match, chain via previous_response_id + delta-only input;
-* 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, CODEX_CHAIN_TOP_LEVEL_EXCLUDE_MAP) : 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", { hadModelsEtagHeader: Boolean(state.modelsEtag) });
-		resetCodexWebSocketAppendState(state);
-		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") {
-		const socket = this.#socket;
-		this.#socket = null;
-		this.#stopHeartbeat();
-		if (!socket || socket.readyState !== WebSocket.OPEN && socket.readyState !== WebSocket.CONNECTING) return;
-		try {
-			socket.close(1e3, reason);
-		} catch (error) {
-			CODEX_DEBUG && debug("[codex] codex websocket close failed", {
-				error: error instanceof Error ? error.message : String(error),
-				reason
-			});
-		}
-	}
-	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 = () => {
-			if (!settled) {
-				settled = true;
-				clearPending();
-				reject(new CodexWebSocketTransportError(`request was aborted`, { cause: signal?.reason }));
-			}
-			this.close("aborted");
-		};
-		if (signal) {
-			if (signal.aborted) onAbort();
-			else signal.addEventListener("abort", onAbort, { once: true });
-		}
-		if (!settled) timeout = setTimeout(() => {
-			this.close("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`, { cause: signal.reason });
-		this.#activeRequest = true;
-		this.#streamObserver = onSseEvent;
-		this.#dropStaleFrames();
-		const onAbort = () => {
-			this.#push(new CodexWebSocketTransportError(`request was aborted`, { cause: signal?.reason }));
-			this.close("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) {
-				if (signal?.aborted) throw new CodexWebSocketTransportError(`websocket connection is unavailable`, { cause: signal.reason });
-				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, turnState, 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(turnState, 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, turnState, responsesLite, codexClientVersion, requestMetadata, signal, firstEventTimeoutMs, codexSseMaxAttempts, onSseEvent, fetchOverride) {
-	const headers = createCodexHeaders(requestHeaders, accountId, apiKey, codexClientVersion, sessionId, "sse", state, turnState, responsesLite, requestMetadata, await getCodexAttestationHeader(accountId), body);
-	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(turnState, 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, turnState, responsesLite = false, requestMetadata, attestation, routedRequest) {
-	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 (routedRequest) headers.set(OPENAI_HEADERS.ROUTING_HINT, codexRoutingHint(routedRequest.model, routedRequest.service_tier));
-	else headers.delete(OPENAI_HEADERS.ROUTING_HINT);
-	applyCodexResidencyHeader(headers, accessToken);
-	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 (turnState?.value) headers.set(X_CODEX_TURN_STATE_HEADER, turnState.value);
-	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, options) {
-		super(`${CODEX_WEBSOCKET_TRANSPORT_ERROR_PREFIX}: ${detail}`, options);
-		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) || PYTHON_HTTP2_STREAM_RESET_PATTERN.test(message) || PYTHON_HTTP_INCOMPLETE_CHUNK_PATTERN.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 };