@xiaoso/dsh-tool-plus 0.1.6 → 0.1.7-beta.0

package/lib/{openai-codex-responses-BcnOotRB.mjs → openai-codex-responses-BL29nh9K.mjs}

@@ -1,24 +1,24 @@
 import { installBunShim as __installBunShim } from "./bun-shim.mjs";
 __installBunShim();
 import { r as __exportAll } from "./fs-promises-shim-Bx0fpxuk.mjs";
-import { B as USER_AGENT, C as error, I as $flag, P as $env, S as debug, g as parseStreamingJson, o as readSseJson, q as getInstallId, t as structuredCloneJSON, w as time } from "./src-BcD0_rQR.mjs";
-import { G as fetchWithRetry, V as ProviderHttpError, g as MissingApiKeyError, l as finalize, v as AbortError } from "./error-C-f_Wnw4.mjs";
-import { A as NO_STRICT, C as kStreamingPartialJson, L as sanitizeSchemaForOpenAIResponses, a as normalizeSystemPrompts, c as sanitizeOpenAIResponsesAssistantFallbackItemsForReplay, d as stripOpenAIResponsesComputerLinkedReasoningIdsForReplay, h as clearStreamingPartialJson, j as adaptSchemaForStrict, k as toolWireSchema, l as sanitizeOpenAIResponsesAssistantHistoryItemsForReplay, m as transformMessages, n as getOpenAIResponsesHistoryItems, p as redactSensitiveInObject, r as getOpenAIResponsesHistoryPayload, t as createOpenAIResponsesHistoryPayload } from "./utils-Cp2Mxf_U.mjs";
-import { t as asRecord } from "./type-guards-B9VVjRDK.mjs";
-import { A as computerCallMetadata, B as finalizeCustomToolCallInputDone, E as buildResponsesDeltaInput, F as createSequentialCutoffSummaryState, H as finalizePendingResponsesToolCalls, K as getOpenAIPromptCacheKey, L as encodeResponsesToolCallId, M as convertResponsesInputContent, Q as isOpenAIResponsesProgressEvent, R as encodeTextSignatureV1, U as finalizeReasoningThinking, V as finalizeMessageText, W as finalizeToolCallArgumentsDone, X as hasExecutableIncompleteResponsesToolCalls, a as accumulateCustomToolCallInputDelta, at as populateResponsesUsageFromResponse, bt as escapeHarmonyControlTokens, c as appendMessageTextDelta, d as appendReasoningSummaryTextDelta, f as appendResponsesImageResult, j as convertResponsesAssistantMessage, l as appendReasoningSummaryPart, n as getEnvApiKey, nt as mapOpenAIResponsesStopReason, o as accumulateToolCallArgumentsDelta, p as appendResponsesToolResultMessages, r as isOfficialCodexApiUrl, rt as normalizeOpenAIPromptCacheKey, s as appendMessageContentPart, st as promoteResponsesToolUseStopReason, tt as mapOpenAIReasoningEffort, u as appendReasoningSummaryPartDone, x as applyReasoningSummaryDone, xt as isHarmonyDialectModel, y as applyOpenAIServiceTier, z as escapeReplayedControlTokens } from "./stream-Bjq8wjfr.mjs";
-import { r as getProxyForUrl } from "./proxy-D9lm7ONA.mjs";
-import { E as supportsCodexReasoningSummary, T as supportsAllTurnsReasoningContext, s as requireSupportedEffort, t as calculateCost } from "./models-DRA2c_8U.mjs";
-import { a as toNumber } from "./utils-CQHPEQ3W.mjs";
-import "./identity-HNO1Oe9B.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-Dh2guZxS.mjs";
-import { a as getCodexAccountId, i as OPENAI_HEADER_VALUES, n as CODEX_CLIENT_VERSION, r as OPENAI_HEADERS, t as CODEX_BASE_URL } from "./codex-P1dGpX7G.mjs";
-import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs, t as armPreResponseTimeout } from "./idle-iterator-CYAxUkSD.mjs";
-import { n as isRequestDebugEnabled, t as createRequestDebugSession } from "./request-debug-HJMoJncL.mjs";
-import { t as notifyRawSseEvent } from "./sse-debug-CYdjOC96.mjs";
-import { t as compactGrammarDefinition } from "./grammar-D-NqNUxQ.mjs";
+import { 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-BwW51vA5.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-CORgGg5a.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-CUPhpw9A.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-B_7qN-bA.mjs";
+import { a as toNumber } from "./utils-DeWqNWV8.mjs";
+import { o as requireSupportedEffort } from "./anthropic-wire-CKuhDwZ1.mjs";
+import { n as getProxyForUrl } from "./proxy-5nWqRL1f.mjs";
+import "./effort-BdtQMN-_.mjs";
+import { t as calculateCost } from "./models-DnXMYGcJ.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-ulcDenZD.mjs";
+import { n as getOpenAIStreamFirstEventTimeoutMs, o as iterateWithIdleTimeout, r as getOpenAIStreamIdleTimeoutMs, t as armPreResponseTimeout } from "./idle-iterator-DlUkEfzW.mjs";
+import { n as isRequestDebugEnabled, t as createRequestDebugSession } from "./request-debug-NQN0BjHH.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@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/openai-codex/request-transformer.ts
+//#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",
@@ -29,18 +29,17 @@ const EFFORT_BY_NAME = {
 	max: "max"
 };
 /**
-* Resolve whether a Codex request uses the Responses Lite transport: an
-* explicit option wins, then the `PI_CODEX_RESPONSES_LITE` env override
-* (`1`/`true` forces Lite, `0`/`false` forces the full Responses body),
-* otherwise the model's catalog flag (codex-rs `model_info.use_responses_lite`)
-* decides.
+* 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(model, requested) {
+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 model.useResponsesLite === true;
+	return false;
 }
 /**
 * Whether to request `stream_options.reasoning_summary_delivery =
@@ -79,7 +78,7 @@ function mapCodexWireEffort(model, effort) {
 }
 function getReasoningConfig(model, effort, options) {
 	const config = { effort: effort === "none" ? "none" : mapCodexWireEffort(model, effort) };
-	if (options.reasoningSummary !== null && supportsCodexReasoningSummary(model.id)) config.summary = options.reasoningSummary ?? "auto";
+	if (options.reasoningSummary !== null && model.compat.supportsReasoningSummary) config.summary = options.reasoningSummary ?? "auto";
 	return config;
 }
 function filterInput(input) {
@@ -297,7 +296,7 @@ async function transformRequestBody(body, model, options = {}, prompt) {
 			}]
 		}];
 	}
-	const responsesLite = resolveCodexResponsesLite(model, options.responsesLite);
+	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) : {};
@@ -307,10 +306,11 @@ async function transformRequestBody(body, model, options = {}, prompt) {
 		};
 		if (responsesLite) body.reasoning.context = "all_turns";
 		else if (options.reasoningContext !== void 0) {
-			if (options.reasoningContext === "all_turns" && !supportsAllTurnsReasoningContext(model.id)) delete body.reasoning.context;
+			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
@@ -329,7 +329,7 @@ async function transformRequestBody(body, model, options = {}, prompt) {
 	return body;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/openai-codex/response-handler.ts
+//#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;
@@ -393,7 +393,7 @@ function toInt(v) {
 	return Number.isFinite(n) ? n : void 0;
 }
 //#endregion
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/providers/openai-codex-responses.ts
+//#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,
@@ -517,6 +517,7 @@ const CODEX_RESERVED_METADATA_KEYS = {
 	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,
@@ -530,7 +531,8 @@ function createCodexMetadataSessionState(sessionId) {
 	return {
 		sessionId,
 		threadId: crypto.randomUUID(),
-		windowId: crypto.randomUUID()
+		windowId: crypto.randomUUID(),
+		turnStates: /* @__PURE__ */ new Map()
 	};
 }
 function getOrCreateCodexMetadataSessionState(sessionId, providerState) {
@@ -541,6 +543,24 @@ function getOrCreateCodexMetadataSessionState(sessionId, providerState) {
 	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(),
@@ -598,7 +618,12 @@ function createCodexRequestMetadata(session, requestKind, options) {
 	};
 	if (session.turnStartedAtUnixMs !== void 0) turnMetadata.turn_started_at_unix_ms = session.turnStartedAtUnixMs;
 	for (const key in extra) turnMetadata[key] = extra[key];
-	const turnMetadataJson = toAsciiJsonString(turnMetadata);
+	const 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,
@@ -612,6 +637,7 @@ function createCodexRequestMetadata(session, requestKind, options) {
 		...identity,
 		turnId: session.turnId,
 		turnMetadataJson,
+		turnMetadataHeaderJson,
 		clientMetadata
 	};
 }
@@ -619,7 +645,7 @@ function applyCodexCompatibilityHeaders(headers, metadata) {
 	headers.set(OPENAI_HEADERS.SCOPED_SESSION_ID, metadata.sessionId);
 	headers.set(OPENAI_HEADERS.THREAD_ID, metadata.threadId);
 	headers.set(OPENAI_HEADERS.WINDOW_ID, metadata.windowId);
-	if (metadata.turnMetadataJson) headers.set(OPENAI_HEADERS.TURN_METADATA, metadata.turnMetadataJson);
+	if (metadata.turnMetadataHeaderJson) headers.set(OPENAI_HEADERS.TURN_METADATA, metadata.turnMetadataHeaderJson);
 	else headers.delete(OPENAI_HEADERS.TURN_METADATA);
 }
 var CodexStreamRuntime = class {
@@ -775,28 +801,25 @@ var CodexStreamRuntime = class {
 		const input = rawEvent.input;
 		if (typeof input === "string") finalizeCustomToolCallInputDone(entry.block, input);
 	}
-	handleResponseCreated(rawEvent) {
-		const response = rawEvent.response;
-		const state = this.websocketState;
-		if (state && this.transport === "websocket" && typeof response?.id === "string" && response.id.length > 0) state.lastResponseId = response.id;
-	}
 };
 function createCodexProviderSessionState() {
 	const state = {
 		webSocketSessions: /* @__PURE__ */ new Map(),
 		webSocketPublicToPrivate: /* @__PURE__ */ new Map(),
 		metadataSessions: /* @__PURE__ */ new Map(),
+		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;
+	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;
@@ -831,13 +854,13 @@ function toCodexHeaders(value) {
 	if (!record) return void 0;
 	return new Headers(record);
 }
-function updateCodexSessionMetadataFromHeaders(state, headers) {
-	if (!state || !headers) return;
+function updateCodexSessionMetadataFromHeaders(turnState, state, headers) {
+	if (!turnState && !state || !headers) return;
 	const resolvedHeaders = headers instanceof Headers ? headers : new Headers(headers);
-	const turnState = resolvedHeaders.get(X_CODEX_TURN_STATE_HEADER);
-	if (turnState && turnState.length > 0) state.turnState = turnState;
+	const 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 (modelsEtag && modelsEtag.length > 0) state.modelsEtag = modelsEtag;
+	if (state && modelsEtag && modelsEtag.length > 0) state.modelsEtag = modelsEtag;
 }
 function extractCodexWebSocketHandshakeHeaders(socket, openEvent) {
 	const eventRecord = openEvent;
@@ -979,11 +1002,8 @@ function unrollCodexComputerToolResult(message) {
 	return result;
 }
 function getCodexServiceTierCostMultiplier(model, serviceTier) {
-	switch (serviceTier) {
-		case "flex": return .5;
-		case "priority": return model.id === "gpt-5.5" ? 2.5 : 2;
-		default: return 1;
-	}
+	if (serviceTier !== "flex" && serviceTier !== "priority") return 1;
+	return model.serviceTierCost?.[serviceTier] ?? 1;
 }
 function resolveCodexCostServiceTier(res, req) {
 	switch (res) {
@@ -1057,8 +1077,8 @@ function createCodexRequestContext(model, transformedBody, options, contextOptio
 	const transportSessionId = normalizeOpenAIPromptCacheKey(options?.sessionId);
 	const codexClientVersion = CODEX_CLIENT_VERSION;
 	const requestHeaders = {
-		...model.headers ?? {},
-		...options?.headers ?? {}
+		...model.headers,
+		...options?.headers
 	};
 	const rawRequestDump = {
 		provider: model.provider,
@@ -1071,7 +1091,7 @@ function createCodexRequestContext(model, transformedBody, options, contextOptio
 	const providerSessionState = getCodexProviderSessionState(options?.providerSessionState);
 	const isolatedTransportState = contextOptions.isolateCompactionTransport && options?.codexCompaction ? createCodexProviderSessionState() : void 0;
 	const transportProviderSessionState = isolatedTransportState ?? providerSessionState;
-	const responsesLite = resolveCodexResponsesLite(model, options?.responsesLite);
+	const 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);
@@ -1079,20 +1099,22 @@ function createCodexRequestContext(model, transformedBody, options, contextOptio
 	const websocketState = sessionKey && isolatedTransportState ? getCodexWebSocketSessionState(sessionKey, isolatedTransportState) : sharedWebsocketState;
 	if (isolatedTransportState && websocketState && sharedWebsocketState) {
 		websocketState.disableWebsocket = sharedWebsocketState.disableWebsocket;
-		websocketState.turnState = sharedWebsocketState.turnState;
 		websocketState.modelsEtag = sharedWebsocketState.modelsEtag;
 	}
 	const metadataSession = getOrCreateCodexMetadataSessionState(transportSessionId ?? crypto.randomUUID(), providerSessionState);
 	const compaction = options?.codexCompaction;
 	const requestKind = compaction ? "compaction" : "turn";
 	const startNewTurn = resolveCodexStartNewTurn(metadataSession, requestKind, compaction, contextOptions.startNewTurn);
-	if (websocketState && startNewTurn) websocketState.turnState = void 0;
+	const 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
+		compaction,
+		toolNamespacesInfo: options?.toolNamespacesInfo
 	});
 	transformedBody.client_metadata = requestMetadata.clientMetadata;
 	return {
@@ -1105,6 +1127,7 @@ function createCodexRequestContext(model, transformedBody, options, contextOptio
 		providerSessionState,
 		isolatedTransportState,
 		websocketState,
+		turnState,
 		responsesLite,
 		requestMetadata,
 		codexClientVersion,
@@ -1119,11 +1142,12 @@ async function buildCodexRequestContext(model, context, options) {
 		turnStartedAtUnixMs: options?.codexCompaction ? void 0 : getCodexTurnStartedAtUnixMs(context)
 	});
 }
-/** @internal Exported for tests. */
-async function buildTransformedCodexRequestBody(model, context, options, promptCacheKey = getOpenAIPromptCacheKey(options)) {
+/** 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: convertMessages(model, context),
+		input: inputPrefix?.length ? [...inputPrefix, ...input] : input,
 		stream: true,
 		prompt_cache_key: promptCacheKey
 	};
@@ -1139,7 +1163,7 @@ async function buildTransformedCodexRequestBody(model, context, options, promptC
 	if (systemPrompts.length > 0) params.instructions = systemPrompts[0];
 	const developerMessages = systemPrompts.slice(1);
 	if (options?.clientMetadata && Object.keys(options.clientMetadata).length > 0) params.client_metadata = { ...options.clientMetadata };
-	return transformRequestBody(params, model, {
+	const body = await transformRequestBody(params, model, {
 		reasoningEffort: options?.reasoning,
 		reasoningOff: options?.forceReasoningOff,
 		reasoningSummary: options?.reasoningSummary,
@@ -1148,6 +1172,27 @@ async function buildTransformedCodexRequestBody(model, context, options, promptC
 		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;
@@ -1182,9 +1227,9 @@ async function openInitialCodexEventStream(model, options, requestSetup, request
 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 ?? {} };
+	const websocketClientMetadata = { ...chainedBody.client_metadata };
 	if (requestContext.responsesLite) websocketClientMetadata[CODEX_WS_RESPONSES_LITE_CLIENT_METADATA_KEY] = "true";
-	if (websocketState.turnState) websocketClientMetadata[X_CODEX_TURN_STATE_HEADER] = websocketState.turnState;
+	if (requestContext.turnState.value) websocketClientMetadata[X_CODEX_TURN_STATE_HEADER] = requestContext.turnState.value;
 	let websocketRequest = {
 		type: "response.create",
 		...chainedBody,
@@ -1193,7 +1238,7 @@ async function openCodexWebSocketTransport(model, options, requestContext, reque
 	const replacementWebsocketRequest = await options?.onPayload?.(websocketRequest, model);
 	if (replacementWebsocketRequest !== void 0) websocketRequest = replacementWebsocketRequest;
 	recordCodexTurnRequestDiagnostics(websocketState, websocketRequest, "websocket", canAppendBeforeRequest);
-	const websocketHeaders = createCodexHeaders(requestContext.requestHeaders, requestContext.accountId, requestContext.apiKey, requestContext.codexClientVersion, requestContext.transportSessionId, "websocket", websocketState, requestContext.responsesLite, requestContext.requestMetadata, await getCodexAttestationHeader(requestContext.accountId));
+	const 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;
@@ -1210,7 +1255,7 @@ async function openCodexWebSocketTransport(model, options, requestContext, reque
 		retryBudget: CODEX_WEBSOCKET_RETRY_BUDGET
 	});
 	return {
-		eventStream: (await getOrCreateCodexWebSocketConnection(websocketState, toWebSocketUrl(requestContext.url), websocketHeaders, model.provider, requestSetup.requestSignal)).streamRequest(websocketRequest, {
+		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),
@@ -1242,7 +1287,7 @@ function isCodexWithinTurnContinuation(context) {
 async function openCodexSseTransport(model, requestContext, requestSetup, options, state, body = requestContext.transformedBody) {
 	const open = async (wireBody) => {
 		requestContext.rawRequestDump.body = wireBody;
-		return requestSetup.wrapCodexSseStream(await openCodexSseEventStream(requestContext.url, requestContext.requestHeaders, requestContext.accountId, requestContext.apiKey, requestContext.transportSessionId, wireBody, state, requestContext.responsesLite, requestContext.codexClientVersion, requestContext.requestMetadata, requestSetup.requestSignal, requestSetup.firstEventTimeoutMs, options?.codexSseMaxAttempts, (event) => options?.onSseEvent?.(event, model), options?.fetch));
+		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;
@@ -1309,20 +1354,30 @@ 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) {
+	if (context.requestContext.websocketState && !shouldPreserveCodexWebSocketAppendState(context, error)) {
 		resetCodexWebSocketAppendState(context.requestContext.websocketState);
-		context.requestContext.websocketState.turnState = void 0;
 		context.requestContext.websocketState.modelsEtag = void 0;
 	}
 	const result = await finalize(error, {
 		api: context.model.api,
+		provider: context.model.provider,
+		model: context.model.id,
 		signal: context.options?.signal,
 		rawRequestDump: context.requestContext.rawRequestDump
 	});
@@ -1383,6 +1438,16 @@ var CodexStreamProcessor = class {
 				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;
@@ -1518,16 +1583,12 @@ var CodexStreamProcessor = class {
 			this.#handleOutputItemDone(rawEvent);
 			return firstTokenTime;
 		}
-		if (eventType === "response.created") {
-			this.runtime.handleResponseCreated(rawEvent);
-			return firstTokenTime;
-		}
 		if (eventType === "response.completed" || eventType === "response.done" || eventType === "response.incomplete") {
 			this.#handleResponseCompleted(rawEvent);
 			return firstTokenTime;
 		}
 		if (eventType === "response.metadata") {
-			updateCodexSessionMetadataFromHeaders(this.requestContext.websocketState, toCodexHeaders(rawEvent.headers));
+			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);
@@ -1693,7 +1754,7 @@ var CodexStreamProcessor = class {
 		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);
+		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);
@@ -1726,7 +1787,6 @@ var CodexStreamProcessor = class {
 		const websocketState = this.requestContext.websocketState;
 		if (websocketState) {
 			resetCodexWebSocketAppendState(websocketState);
-			websocketState.turnState = void 0;
 			websocketState.modelsEtag = void 0;
 		}
 		CODEX_DEBUG && debug("[codex] retrying codex turn after whitespace-only tool-call argument loop", {
@@ -1804,7 +1864,6 @@ var CodexStreamProcessor = class {
 		if (this.runtime.transport !== "websocket") return false;
 		this.runtime.providerRetryAttempt += 1;
 		resetCodexWebSocketAppendState(websocketState);
-		websocketState.turnState = void 0;
 		websocketState.modelsEtag = void 0;
 		this.runtime.resetAccumulators();
 		this.runtime.sawTerminalEvent = false;
@@ -1846,13 +1905,44 @@ var CodexStreamProcessor = class {
 		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) {
-		if (!(error instanceof CodexProviderStreamError && error.retryable) || this.output.content.length > 0 || this.runtime.providerRetryAttempt >= CODEX_MAX_RETRIES || this.options?.signal?.aborted) return false;
+		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.turnState = void 0;
 			websocketState.modelsEtag = void 0;
 		}
 		CODEX_DEBUG && debug("[codex] retrying codex provider stream error", {
@@ -1900,21 +1990,6 @@ var CodexStreamProcessor = class {
 	finalize(completion) {
 		const { output } = this;
 		if (this.options?.signal?.aborted) throw new AbortError();
-		if (!this.runtime.sawTerminalEvent) {
-			if (this.requestContext.websocketState) {
-				resetCodexWebSocketAppendState(this.requestContext.websocketState);
-				this.requestContext.websocketState.turnState = void 0;
-				this.requestContext.websocketState.modelsEtag = void 0;
-			}
-			CODEX_DEBUG && debug("[codex] codex stream ended unexpectedly", {
-				transport: this.runtime.transport,
-				terminalEventSeen: this.runtime.sawTerminalEvent,
-				unexpectedStreamEnd: true,
-				sentTurnStateHeader: Boolean(this.requestContext.websocketState?.turnState),
-				sentModelsEtagHeader: Boolean(this.requestContext.websocketState?.modelsEtag)
-			});
-			throw new CodexProviderStreamError("Codex stream ended before terminal completion event", false);
-		}
 		if (output.stopReason === "aborted" || output.stopReason === "error") throw new CodexProviderStreamError("Codex response failed", false);
 		output.providerPayload = createOpenAIResponsesHistoryPayload(this.model.provider, this.runtime.nativeOutputItems);
 		output.duration = performance.now() - this.startTime;
@@ -1990,7 +2065,8 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					baseUrl: model.baseUrl || "https://chatgpt.com/backend-api",
 					url: "",
 					requestHeaders: {},
-					codexClientVersion: "0.144.1",
+					codexClientVersion: "0.153.0",
+					turnState: {},
 					responsesLite: options?.responsesLite === true,
 					transformedBody: { model: model.id },
 					rawRequestDump: {
@@ -2255,10 +2331,11 @@ function recordCodexTurnUsageDiagnostics(state, rawUsage, displayedUsage) {
 	};
 	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 append
-* baseline is intact (same options, strict history prefix), chain via
-* `previous_response_id` + delta-only `input`; otherwise break the chain and
+* 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
@@ -2266,19 +2343,15 @@ function recordCodexTurnUsageDiagnostics(state, rawUsage, displayedUsage) {
 */
 function buildCodexChainedRequestBody(requestBody, state) {
 	const chainable = state?.canAppend === true;
-	const appendInput = chainable ? buildResponsesDeltaInput(state.lastRequest, state.lastResponseItems, requestBody) : null;
+	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", {
-			hadTurnStateHeader: Boolean(state.turnState),
-			hadModelsEtagHeader: Boolean(state.modelsEtag)
-		});
+		CODEX_DEBUG && debug("[codex] codex append reset", { hadModelsEtagHeader: Boolean(state.modelsEtag) });
 		resetCodexWebSocketAppendState(state);
-		state.turnState = void 0;
 		state.modelsEtag = void 0;
 	}
 	return requestBody;
@@ -2360,9 +2433,18 @@ var CodexWebSocketConnection = class {
 		return this.#headers.authorization === headers.authorization;
 	}
 	close(reason = "done") {
-		if (this.#socket && (this.#socket.readyState === WebSocket.OPEN || this.#socket.readyState === WebSocket.CONNECTING)) this.#socket.close(1e3, reason);
+		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;
@@ -2389,19 +2471,19 @@ var CodexWebSocketConnection = class {
 			if (signal) signal.removeEventListener("abort", onAbort);
 		};
 		const onAbort = () => {
-			socket.close(1e3, "aborted");
 			if (!settled) {
 				settled = true;
 				clearPending();
-				reject(new CodexWebSocketTransportError(`request was aborted`));
+				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(() => {
-			socket.close(1e3, "connect-timeout");
+			this.close("connect-timeout");
 			if (!settled) {
 				settled = true;
 				clearPending();
@@ -2470,13 +2552,13 @@ var CodexWebSocketConnection = class {
 	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`);
+		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");
-			this.#push(new CodexWebSocketTransportError(`request was aborted`));
 		};
 		if (signal) signal.addEventListener("abort", onAbort, { once: true });
 		try {
@@ -2491,7 +2573,10 @@ var CodexWebSocketConnection = class {
 			const requestPayload = JSON.stringify(request);
 			notifyCodexWebSocketOutbound(onSseEvent, request, requestPayload);
 			const socket = this.#socket;
-			if (!socket || socket.readyState !== WebSocket.OPEN) throw new CodexWebSocketTransportError(`websocket connection is unavailable`);
+			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) {
@@ -2717,7 +2802,7 @@ var CodexWebSocketConnection = class {
 		return this.#queue.shift() ?? null;
 	}
 };
-async function getOrCreateCodexWebSocketConnection(state, url, headers, provider, signal) {
+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) {
@@ -2745,7 +2830,7 @@ async function getOrCreateCodexWebSocketConnection(state, url, headers, provider
 	time("codexWs:newSocket");
 	state.connection = new CodexWebSocketConnection(url, headerRecord, {
 		onHandshakeHeaders: (handshakeHeaders) => {
-			updateCodexSessionMetadataFromHeaders(state, handshakeHeaders);
+			updateCodexSessionMetadataFromHeaders(turnState, state, handshakeHeaders);
 		},
 		proxy
 	});
@@ -2766,8 +2851,8 @@ function compressCodexRequestBody(bodyJson, baseUrl) {
 		return;
 	}
 }
-async function openCodexSseEventStream(url, requestHeaders, accountId, apiKey, sessionId, body, state, responsesLite, codexClientVersion, requestMetadata, signal, firstEventTimeoutMs, codexSseMaxAttempts, onSseEvent, fetchOverride) {
-	const headers = createCodexHeaders(requestHeaders, accountId, apiKey, codexClientVersion, sessionId, "sse", state, responsesLite, requestMetadata, await getCodexAttestationHeader(accountId));
+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 {
@@ -2827,7 +2912,7 @@ async function openCodexSseEventStream(url, requestHeaders, accountId, apiKey, s
 		cfRay: response.headers.get("cf-ray") || null
 	});
 	if (!response.ok) throw await CodexApiError.fromResponse(response);
-	updateCodexSessionMetadataFromHeaders(state, response.headers);
+	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,
@@ -2835,11 +2920,14 @@ async function openCodexSseEventStream(url, requestHeaders, accountId, apiKey, s
 		raw: [...event.raw]
 	}, void 0));
 }
-function createCodexHeaders(initHeaders, accountId, accessToken, codexClientVersion, sessionId, transport = "sse", state, responsesLite = false, requestMetadata, attestation) {
+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;
@@ -2866,7 +2954,7 @@ function createCodexHeaders(initHeaders, accountId, accessToken, codexClientVers
 		headers.delete(OPENAI_HEADERS.WINDOW_ID);
 		headers.delete(OPENAI_HEADERS.TURN_METADATA);
 	}
-	if (state?.turnState) headers.set(X_CODEX_TURN_STATE_HEADER, state.turnState);
+	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);
@@ -3030,8 +3118,8 @@ function convertOpenAICodexResponsesTools(tools, model) {
 	return payloads;
 }
 var CodexWebSocketTransportError = class extends Error {
-	constructor(detail) {
-		super(`${CODEX_WEBSOCKET_TRANSPORT_ERROR_PREFIX}: ${detail}`);
+	constructor(detail, options) {
+		super(`${CODEX_WEBSOCKET_TRANSPORT_ERROR_PREFIX}: ${detail}`, options);
 		this.name = "CodexWebSocketTransportError";
 	}
 };
@@ -3097,7 +3185,7 @@ function isRetryableCodexFailureEvent(rawEvent) {
 	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);
+	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);