@openclaw/ai 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{openai-chatgpt-responses-B84Ibtrd.mjs → openai-chatgpt-responses-CrPmqERt.mjs}

@@ -1,19 +1,23 @@
 import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
 import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-COpOtRwq.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-Dog2WQiR.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-DTqNc7ad.mjs";
+import { n as projectProviderError } from "./provider-error-BUwEnjXq.mjs";
+import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-DgNTYnRY.mjs";
+import { c as resolveTimerTimeoutMs, i as clampTimerTimeoutMs } from "./number-coercion-H9qHik3g.mjs";
+import { S as supportsOpenAITemperature, m as responsesPromptObserver } from "./openai-responses-contracts-CyfIkQi5.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { d as stripSystemPromptCacheBoundary } from "./tool-result-text-CTpIRbYd.mjs";
-import { t as toErrorObject } from "./error-coercion-DgxlWC0n.mjs";
-import { n as clampTimerTimeoutMs, o as resolveTimerTimeoutMs } from "./number-coercion-DvG7SNMg.mjs";
+import { l as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-D58D5Kvw.mjs";
+import { t as headersToRecord } from "./headers-DdOQtGuU.mjs";
+import { F as commitResponsesEncryptedContentAttempt, G as suppressOpenAIResponsesCompaction, L as isInvalidEncryptedContentError, U as buildOpenAIResponsesReasoningReplayMetadata, a as resolveResponsesReasoningEffort, c as processResponsesStream, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, p as ResponsesStreamFailure, r as convertResponsesMessages, s as convertResponsesToolPayload, z as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-DXIt3iY5.mjs";
+import { f as transportAbortError, p as withProviderResponseHook } from "./provider-transcript-transform-ePx-Bbfr.mjs";
 import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";
-import { d as transportAbortError } from "./transport-stream-shared-D81p90xq.mjs";
-import { _t as supportsOpenAITemperature, n as processResponsesStream } from "./openai-responses-stream-internal-Cw5txaGW.mjs";
-import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BBys9hSb.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { n as buildBaseOptions } from "./simple-options-9lhRrN73.mjs";
-import { i as resolveResponsesReasoningEffort, n as convertResponsesMessages, o as convertResponsesToolPayload } from "./openai-responses-shared-pXl6Wd8S.mjs";
-import { i as registerSessionResourceCleanup, n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-DhAAzLkj.mjs";
+import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-DJqkxbhC.mjs";
+import { o as createOpenAIResponseHook } from "./openai-tool-projection-CY04OcvQ.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-MK28puvq.mjs";
+import { n as registerSessionResourceCleanup } from "./session-resources-CkR4WWy1.mjs";
+import "./diagnostics.mjs";
+import { n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-KWcgd0d_.mjs";
 import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
 import { t as inspectTlsCertificateError } from "./tls-certificate-errors-DXSpluKI.mjs";
 //#region packages/ai/src/internal/retry-sleep.ts
@@ -36,6 +40,63 @@ function sleepWithAbort(ms, signal) {
 	});
 }
 //#endregion
+//#region packages/ai/src/providers/openai-chatgpt-responses-protocol.ts
+const OPENAI_CHATGPT_RESPONSES_SUCCESS_BODY_MAX_BYTES = 16 * 1024 * 1024;
+var CodexProtocolError = class extends Error {
+	constructor(message, options) {
+		super(message);
+		this.name = "CodexProtocolError";
+		this.payload = options?.payload;
+		this.cause = options?.cause;
+	}
+};
+async function* parseOpenAIChatGptResponsesSse(response) {
+	if (!response.body) return;
+	const reader = response.body.getReader();
+	const guard = createSseByteGuard(reader, {
+		maxBytes: OPENAI_CHATGPT_RESPONSES_SUCCESS_BODY_MAX_BYTES,
+		onOverflow: ({ size, maxBytes }) => /* @__PURE__ */ new Error(`OpenAI ChatGPT Responses success body exceeded ${maxBytes} bytes (received ${size})`)
+	});
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await guard.read();
+			if (value) buffer += decoder.decode(value, { stream: true });
+			if (done) buffer += decoder.decode();
+			while (true) {
+				const searchable = !done && buffer.endsWith("\r") && !buffer.endsWith("\r\r") && !buffer.endsWith("\n\r") ? buffer.slice(0, -1) : buffer;
+				const boundary = /(?:\r\n|\r(?!\n)|\n)(?:\r\n|\r(?!\n)|\n)/.exec(searchable);
+				if (!boundary) break;
+				const chunk = buffer.slice(0, boundary.index);
+				buffer = buffer.slice(boundary.index + boundary[0].length);
+				const dataLines = chunk.split(/\r\n|\r|\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim());
+				if (dataLines.length > 0) {
+					const data = dataLines.join("\n").trim();
+					if (data && data !== "[DONE]") {
+						let event;
+						try {
+							event = JSON.parse(data);
+						} catch (cause) {
+							if (!(cause instanceof SyntaxError)) throw cause;
+							throw new CodexProtocolError(MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, { cause });
+						}
+						yield event;
+					}
+				}
+			}
+			if (done) break;
+		}
+	} finally {
+		try {
+			await guard.cancel();
+		} catch {}
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}
+//#endregion
 //#region packages/ai/src/providers/openai-chatgpt-responses.ts
 const dynamicImport = (specifier) => import(specifier);
 function loadNodeOs() {
@@ -51,7 +112,6 @@ const CODEX_TOOL_CALL_PROVIDERS = /* @__PURE__ */ new Set(["openai", "opencode"]
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
 const OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES = 16 * 1024;
-const OPENAI_CHATGPT_RESPONSES_SUCCESS_BODY_MAX_BYTES = 16 * 1024 * 1024;
 const CODEX_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
 	"completed",
 	"incomplete",
@@ -116,29 +176,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 		let requestTimeoutSignal;
 		let activeSignal;
 		let firstEventAbort;
-		const output = {
-			role: "assistant",
-			content: [],
-			api: "openai-chatgpt-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 output = createResponsesAssistantOutput(model);
 		try {
 			const unresolvedApiKey = options?.apiKey || getEnvApiKey(model.provider) || "";
 			if (!unresolvedApiKey) throw new Error(`No API key for provider: ${model.provider}`);
@@ -146,9 +184,18 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			const modelHeaders = resolveAiTransportHeaderSentinels(model.headers);
 			const optionHeaders = resolveAiTransportHeaderSentinels(options?.headers);
 			const accountId = extractOpenAICodexAccountId(apiKey);
-			let body = buildRequestBody(model, context, options);
-			const nextBody = await options?.onPayload?.(body, model);
-			if (nextBody !== void 0) body = nextBody;
+			const buildBody = async (replayMode) => {
+				let body = buildRequestBody(model, context, options, replayMode);
+				const nextBody = await options?.onPayload?.(body, model);
+				if (nextBody !== void 0) body = nextBody;
+				return body;
+			};
+			let semanticAttempt = {
+				kind: "initial",
+				request: await buildBody("checkpoint")
+			};
+			const commitSemanticAttempt = (attempt) => commitResponsesEncryptedContentAttempt(attempt, (checkpoint) => suppressOpenAIResponsesCompaction(output, model, options, checkpoint));
+			const observePromptEgress = createResponsesPromptEgressObserver(options, context.systemPrompt);
 			const sessionId = clampOpenAIPromptCacheKey(options?.sessionId);
 			requestTimeoutMs = resolveRequestTimeoutMs(options);
 			requestTimeoutSignal = buildRequestSignal(options?.signal, requestTimeoutMs);
@@ -163,14 +210,21 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			if (transport !== "sse" && !websocketDisabledForSession) {
 				const websocketHeaders = buildWebSocketHeaders(modelHeaders, optionHeaders, accountId, apiKey, sessionId || createCodexRequestId());
 				let websocketStarted = false;
+				let websocketRequestSent = false;
 				let retriedWebSocketConnectionLimit = false;
 				while (true) {
+					const activeAttempt = semanticAttempt;
 					websocketStarted = false;
+					websocketRequestSent = false;
 					try {
-						await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
+						await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), activeAttempt.request, websocketHeaders, output, stream, model, () => {
+							commitSemanticAttempt(activeAttempt);
 							websocketStarted = true;
-						}, requestOptions, firstEventAbort.abort);
+						}, requestOptions, firstEventAbort.abort, observePromptEgress, activeAttempt.kind, () => {
+							websocketRequestSent = true;
+						});
 						if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+						if (output.stopReason === "aborted" || output.stopReason === "error") throw new CodexApiError(output.errorMessage ?? "An unknown error occurred");
 						stream.push({
 							type: "done",
 							reason: output.stopReason,
@@ -180,6 +234,12 @@ const streamOpenAICodexResponses = (model, context, options) => {
 						return;
 					} catch (error) {
 						const aborted = activeSignal?.aborted;
+						const nextSemanticAttempt = !aborted && websocketRequestSent && !websocketStarted && error instanceof CodexApiError && isInvalidEncryptedContentError(error) ? await resolveNextResponsesEncryptedContentAttempt(activeAttempt, error, { buildFullHistoryRequest: () => buildBody("full-history") }) : void 0;
+						if (nextSemanticAttempt) {
+							semanticAttempt = nextSemanticAttempt;
+							retriedWebSocketConnectionLimit = false;
+							continue;
+						}
 						const connectionLimitBeforeStart = !websocketStarted && isWebSocketConnectionLimitReachedError(error);
 						if (!aborted && connectionLimitBeforeStart && !retriedWebSocketConnectionLimit) {
 							retriedWebSocketConnectionLimit = true;
@@ -191,7 +251,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 							fallbackTransport: transport === "auto" && !websocketStarted ? "sse" : void 0,
 							eventsEmitted: websocketStarted,
 							phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
-							requestBytes: new TextEncoder().encode(JSON.stringify(body)).byteLength
+							requestBytes: new TextEncoder().encode(JSON.stringify(activeAttempt.request)).byteLength
 						}));
 						if (transport === "auto" && options?.sessionId) websocketSseFallbackSessions.add(options.sessionId);
 						if (websocketStarted || transport !== "auto") throw error;
@@ -199,61 +259,104 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					}
 				}
 			}
-			const sseHeaders = buildSSEHeaders(modelHeaders, optionHeaders, accountId, apiKey, sessionId);
-			const bodyJson = JSON.stringify(body);
-			const compressedBody = model.provider === "openai" && !sseHeaders.has("content-encoding") ? compressRequestBodyZstd(bodyJson) : null;
-			if (compressedBody) sseHeaders.set("content-encoding", "zstd");
-			const sseBody = compressedBody ?? bodyJson;
 			let response;
-			let lastError;
 			const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
-			for (let attempt = 0; attempt <= maxRetries; attempt++) {
-				if (activeSignal?.aborted) throw transportAbortError(activeSignal);
-				let attemptResponse;
-				let errorText;
-				try {
-					attemptResponse = await fetch(resolveCodexUrl(model.baseUrl), {
-						method: "POST",
-						headers: sseHeaders,
-						body: sseBody,
-						signal: activeSignal
+			while (true) {
+				const activeAttempt = semanticAttempt;
+				response = void 0;
+				const sseHeaders = buildSSEHeaders(modelHeaders, optionHeaders, accountId, apiKey, sessionId);
+				const bodyJson = JSON.stringify(activeAttempt.request);
+				const compressedBody = model.provider === "openai" && !sseHeaders.has("content-encoding") ? compressRequestBodyZstd(bodyJson) : null;
+				if (compressedBody) sseHeaders.set("content-encoding", "zstd");
+				const sseBody = compressedBody ?? bodyJson;
+				let terminalResponseError;
+				for (let attempt = 0; attempt <= maxRetries; attempt++) {
+					if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+					observePromptEgress?.(activeAttempt.request, {
+						egress: "native-codex-sse",
+						payloadVariant: activeAttempt.kind
 					});
+					let attemptResponse;
+					try {
+						attemptResponse = await fetch(resolveCodexUrl(model.baseUrl), {
+							method: "POST",
+							headers: sseHeaders,
+							body: sseBody,
+							signal: activeSignal
+						});
+					} catch (error) {
+						if (error instanceof Error) {
+							if (isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0) throw formatRequestTimeoutError(requestTimeoutMs, error);
+							if (error.name === "AbortError" || error.message === "Request was aborted") throw new Error("Request was aborted", { cause: error });
+							if (error.name === "TimeoutError" && requestTimeoutMs !== void 0) throw new Error(`Request timed out after ${requestTimeoutMs}ms`, { cause: error });
+						}
+						const tlsCertificateError = inspectTlsCertificateError(error);
+						const lastError = toErrorObject(error, String(error));
+						if (attempt < maxRetries && !lastError.message.includes("usage limit") && !tlsCertificateError) {
+							await sleepWithAbort(BASE_DELAY_MS * 2 ** attempt, activeSignal);
+							continue;
+						}
+						throw lastError;
+					}
 					response = attemptResponse;
-					await options?.onResponse?.({
-						status: attemptResponse.status,
-						headers: headersToRecord(attemptResponse.headers)
-					}, model);
 					if (attemptResponse.ok) break;
-					errorText = await readChatGptResponsesErrorTextLimited(attemptResponse);
-				} catch (error) {
-					if (error instanceof Error) {
-						if (isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0) throw formatRequestTimeoutError(requestTimeoutMs, error);
-						if (error.name === "AbortError" || error.message === "Request was aborted") throw new Error("Request was aborted", { cause: error });
-						if (error.name === "TimeoutError" && requestTimeoutMs !== void 0) throw new Error(`Request timed out after ${requestTimeoutMs}ms`, { cause: error });
-					}
-					const tlsCertificateError = inspectTlsCertificateError(error);
-					lastError = toErrorObject(error, String(error));
-					if (attempt < maxRetries && !lastError.message.includes("usage limit") && !tlsCertificateError) {
-						await sleepWithAbort(BASE_DELAY_MS * 2 ** attempt, activeSignal);
+					const hookStream = withFirstStreamEventTimeout(withProviderResponseHook({
+						signal: firstEventAbort.signal,
+						abort: firstEventAbort.abort,
+						hook: createOpenAIResponseHook(options?.onResponse, attemptResponse, model)
+					}), {
+						provider: model.provider,
+						api: model.api,
+						model: model.id,
+						timeoutMs: getFirstStreamEventTimeoutMs(options) ?? 0,
+						stage: "responses",
+						abort: firstEventAbort.abort,
+						onTimeout: getFirstStreamEventTimeoutHandler(options)
+					});
+					const [errorText] = await Promise.all([readChatGptResponsesErrorTextLimited(attemptResponse, activeSignal), hookStream[Symbol.asyncIterator]().next()]);
+					if (attempt < maxRetries && isRetryableError(attemptResponse.status, errorText)) {
+						await sleepWithAbort(resolveHttpRetryDelayMs(attemptResponse, attempt), activeSignal);
 						continue;
 					}
-					throw lastError;
+					const info = parseErrorResponseText(errorText, attemptResponse.status, attemptResponse.statusText);
+					terminalResponseError = new CodexApiError(info.friendlyMessage || info.message, { code: info.code });
+					break;
 				}
-				if (attempt < maxRetries && isRetryableError(attemptResponse.status, errorText)) {
-					await sleepWithAbort(resolveHttpRetryDelayMs(attemptResponse, attempt), activeSignal);
-					continue;
+				if (response?.ok) {
+					if (!response.body) throw new Error("No response body");
+					if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+					commitSemanticAttempt(activeAttempt);
+					break;
 				}
-				const info = parseErrorResponseText(errorText, attemptResponse.status, attemptResponse.statusText);
-				throw new Error(info.friendlyMessage || info.message);
+				if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+				const nextSemanticAttempt = terminalResponseError ? await resolveNextResponsesEncryptedContentAttempt(activeAttempt, terminalResponseError, { buildFullHistoryRequest: () => buildBody("full-history") }) : void 0;
+				if (!nextSemanticAttempt) throw terminalResponseError ?? /* @__PURE__ */ new Error("Failed after retries");
+				semanticAttempt = nextSemanticAttempt;
 			}
-			if (!response?.ok) throw lastError ?? /* @__PURE__ */ new Error("Failed after retries");
-			if (!response.body) throw new Error("No response body");
-			stream.push({
-				type: "start",
-				partial: output
+			await processResponsesStream(withProviderResponseHook({
+				stream: mapCodexEvents(parseOpenAIChatGptResponsesSse(response)),
+				signal: firstEventAbort.signal,
+				abort: firstEventAbort.abort,
+				hook: createOpenAIResponseHook(options?.onResponse, response, model),
+				onReady: () => stream.push({
+					type: "start",
+					partial: output
+				})
+			}), output, stream, model, {
+				serviceTier: options?.serviceTier,
+				firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
+				abortFirstEventStream: firstEventAbort.abort,
+				onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
+				signal: options?.signal,
+				reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
+					sessionId: options?.sessionId,
+					authProfileId: options?.authProfileId
+				}),
+				resolveServiceTier: resolveCodexServiceTier,
+				applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
 			});
-			await processStream(response, output, stream, model, options, firstEventAbort.abort);
 			if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -263,11 +366,11 @@ const streamOpenAICodexResponses = (model, context, options) => {
 		} catch (error) {
 			const normalizedError = isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0 ? formatRequestTimeoutError(requestTimeoutMs, error) : error;
 			for (const block of output.content) delete block.partialJson;
-			output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-			output.errorMessage = normalizedError instanceof Error ? normalizedError.message : String(normalizedError);
+			const terminal = projectProviderError(normalizedError, options?.signal);
+			Object.assign(output, terminal);
 			stream.push({
 				type: "error",
-				reason: output.stopReason,
+				reason: terminal.stopReason,
 				error: output
 			});
 			stream.end();
@@ -280,16 +383,21 @@ const streamOpenAICodexResponses = (model, context, options) => {
 const streamSimpleOpenAICodexResponses = (model, context, options) => {
 	const apiKey = options?.apiKey || getEnvApiKey(model.provider);
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
-	const base = buildBaseOptions(model, options, apiKey);
-	return streamOpenAICodexResponses(model, context, {
-		...base,
+	const resolvedOptions = {
+		...buildBaseOptions(model, options, apiKey),
+		authProfileId: options?.authProfileId,
 		reasoningEffort: resolveResponsesReasoningEffort(model, options?.reasoning)
-	});
+	};
+	responsesPromptObserver.copy(options, resolvedOptions);
+	return streamOpenAICodexResponses(model, context, resolvedOptions);
 };
-function buildRequestBody(model, context, options) {
+function buildRequestBody(model, context, options, replayMode = "checkpoint") {
 	const messages = convertResponsesMessages(model, context, CODEX_TOOL_CALL_PROVIDERS, {
 		includeSystemPrompt: false,
-		replayResponsesItemIds: false
+		replayResponsesItemIds: false,
+		sessionId: options?.sessionId,
+		authProfileId: options?.authProfileId,
+		replayMode
 	});
 	const body = {
 		model: model.id,
@@ -299,21 +407,16 @@ function buildRequestBody(model, context, options) {
 		input: messages,
 		text: { verbosity: options?.textVerbosity || "low" },
 		include: ["reasoning.encrypted_content"],
-		prompt_cache_key: options?.cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId),
-		tool_choice: "auto",
-		parallel_tool_calls: true
+		prompt_cache_key: options?.cacheRetention === "none" ? void 0 : clampOpenAIPromptCacheKey(options?.promptCacheKey ?? options?.sessionId)
 	};
 	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) body.temperature = options.temperature;
 	if (options?.serviceTier !== void 0) body.service_tier = options.serviceTier;
 	if (context.tools) {
 		const converted = convertResponsesToolPayload(context.tools, { strict: null });
-		if (converted.projection.inputToolCount > 0 || converted.projection.diagnostics.length > 0) {
+		if (converted.tools.length > 0) {
 			body.tools = converted.tools;
-			if (body.tools.length === 0) {
-				delete body.tools;
-				delete body.tool_choice;
-				delete body.parallel_tool_calls;
-			}
+			body.tool_choice = "auto";
+			body.parallel_tool_calls = true;
 		}
 	}
 	if (options?.reasoningEffort !== void 0) {
@@ -325,22 +428,6 @@ function buildRequestBody(model, context, options) {
 	}
 	return body;
 }
-function getServiceTierCostMultiplier(model, serviceTier) {
-	switch (serviceTier) {
-		case "flex": return .5;
-		case "priority": return model.id === "gpt-5.5" ? 2.5 : 2;
-		default: return 1;
-	}
-}
-function applyServiceTierPricing(usage, serviceTier, model) {
-	const multiplier = getServiceTierCostMultiplier(model, serviceTier);
-	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 resolveCodexServiceTier(responseServiceTier, requestServiceTier) {
 	if (responseServiceTier === "default" && (requestServiceTier === "flex" || requestServiceTier === "priority")) return requestServiceTier;
 	return responseServiceTier ?? requestServiceTier;
@@ -357,17 +444,6 @@ function resolveCodexWebSocketUrl(baseUrl) {
 	if (url.protocol === "http:") url.protocol = "ws:";
 	return url.toString();
 }
-async function processStream(response, output, stream, model, options, abortFirstEventStream) {
-	await processResponsesStream(mapCodexEvents(parseSSE(response)), output, stream, model, {
-		serviceTier: options?.serviceTier,
-		firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
-		abortFirstEventStream,
-		onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
-		signal: options?.signal,
-		resolveServiceTier: resolveCodexServiceTier,
-		applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
-	});
-}
 var CodexApiError = class extends Error {
 	constructor(message, options) {
 		super(message);
@@ -377,16 +453,8 @@ var CodexApiError = class extends Error {
 		this.cause = options?.cause;
 	}
 };
-var CodexProtocolError = class extends Error {
-	constructor(message, options) {
-		super(message);
-		this.name = "CodexProtocolError";
-		this.payload = options?.payload;
-		this.cause = options?.cause;
-	}
-};
 function isCodexNonTransportError(error) {
-	return error instanceof CodexApiError || error instanceof CodexProtocolError;
+	return error instanceof CodexApiError || error instanceof CodexProtocolError || error instanceof ResponsesStreamFailure;
 }
 function isWebSocketConnectionLimitReachedError(error) {
 	return error instanceof CodexApiError && error.code === WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE;
@@ -409,15 +477,6 @@ async function* mapCodexEvents(events) {
 				payload: event
 			});
 		}
-		if (type === "response.failed") {
-			const response = event.response;
-			const code = response?.error?.code;
-			const message = response?.error?.message;
-			throw new CodexApiError(message || "Codex response failed", {
-				code,
-				payload: event
-			});
-		}
 		if (type === "response.done" || type === "response.completed" || type === "response.incomplete") {
 			const response = event.response;
 			const normalizedResponse = response ? {
@@ -426,7 +485,7 @@ async function* mapCodexEvents(events) {
 			} : response;
 			yield {
 				...event,
-				type: "response.completed",
+				type: type === "response.done" ? "response.completed" : type,
 				response: normalizedResponse
 			};
 			return;
@@ -438,49 +497,6 @@ function normalizeCodexStatus(status) {
 	if (typeof status !== "string") return;
 	return CODEX_RESPONSE_STATUSES.has(status) ? status : void 0;
 }
-async function* parseSSE(response) {
-	if (!response.body) return;
-	const reader = response.body.getReader();
-	const guard = createSseByteGuard(reader, {
-		maxBytes: OPENAI_CHATGPT_RESPONSES_SUCCESS_BODY_MAX_BYTES,
-		onOverflow: ({ size, maxBytes }) => /* @__PURE__ */ new Error(`OpenAI ChatGPT Responses success body exceeded ${maxBytes} bytes (received ${size})`)
-	});
-	const decoder = new TextDecoder();
-	let buffer = "";
-	try {
-		while (true) {
-			const { done, value } = await guard.read();
-			if (done) break;
-			buffer += decoder.decode(value, { stream: true });
-			let idx = buffer.indexOf("\n\n");
-			while (idx !== -1) {
-				const chunk = buffer.slice(0, idx);
-				buffer = buffer.slice(idx + 2);
-				const dataLines = chunk.split("\n").filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim());
-				if (dataLines.length > 0) {
-					const data = dataLines.join("\n").trim();
-					if (data && data !== "[DONE]") try {
-						yield JSON.parse(data);
-					} catch (cause) {
-						throw new CodexProtocolError(`Invalid Codex SSE JSON: ${formatThrownValue(cause)}`, {
-							cause,
-							payload: data
-						});
-					}
-				}
-				idx = buffer.indexOf("\n\n");
-			}
-		}
-	} finally {
-		try {
-			await guard.cancel();
-		} catch {}
-		try {
-			reader.releaseLock();
-		} catch {}
-	}
-}
-const parseSSEForTest = parseSSE;
 const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
 const SESSION_WEBSOCKET_CACHE_TTL_MS = 300 * 1e3;
 const SESSION_WEBSOCKET_MAX_AGE_MS = 3300 * 1e3;
@@ -497,6 +513,7 @@ function closeOpenAICodexWebSocketSessions(sessionId) {
 		closeWebSocketSilently(entry.socket, 1e3, "debug_close");
 	};
 	if (sessionId) {
+		websocketSseFallbackSessions.delete(sessionId);
 		const entry = websocketSessionCache.get(sessionId);
 		if (entry) closeEntry(entry);
 		websocketSessionCache.delete(sessionId);
@@ -504,6 +521,7 @@ function closeOpenAICodexWebSocketSessions(sessionId) {
 	}
 	for (const entry of websocketSessionCache.values()) closeEntry(entry);
 	websocketSessionCache.clear();
+	websocketSseFallbackSessions.clear();
 }
 registerSessionResourceCleanup(closeOpenAICodexWebSocketSessions);
 function isWebSocketSseFallbackActive(sessionId) {
@@ -559,6 +577,13 @@ function closeWebSocketSilently(socket, code = 1e3, reason = "done") {
 function deleteOwnedWebSocketSession(sessionId, entry) {
 	if (websocketSessionCache.get(sessionId) === entry) websocketSessionCache.delete(sessionId);
 }
+function setOwnedWebSocketSession(sessionId, entry, expected) {
+	if (websocketSessionCache.get(sessionId) === expected) {
+		websocketSessionCache.set(sessionId, entry);
+		return true;
+	}
+	return false;
+}
 function scheduleSessionWebSocketExpiry(sessionId, entry) {
 	if (entry.idleTimer) clearTimeout(entry.idleTimer);
 	entry.idleTimer = setTimeout(() => {
@@ -639,6 +664,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		};
 	}
 	const cached = websocketSessionCache.get(sessionId);
+	let expectedCacheValue = cached;
 	if (cached) {
 		if (cached.idleTimer) {
 			clearTimeout(cached.idleTimer);
@@ -646,7 +672,8 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		}
 		if (!cached.busy && isWebSocketSessionExpired(cached)) {
 			closeWebSocketSilently(cached.socket, 1e3, "connection_age_limit");
-			websocketSessionCache.delete(sessionId);
+			deleteOwnedWebSocketSession(sessionId, cached);
+			expectedCacheValue = void 0;
 		} else if (!cached.busy && isWebSocketReusable(cached.socket)) {
 			cached.busy = true;
 			return {
@@ -674,7 +701,8 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		}
 		if (!isWebSocketReusable(cached.socket)) {
 			closeWebSocketSilently(cached.socket);
-			websocketSessionCache.delete(sessionId);
+			deleteOwnedWebSocketSession(sessionId, cached);
+			expectedCacheValue = void 0;
 		}
 	}
 	const socket = await connectWebSocket(url, headers, signal);
@@ -683,12 +711,12 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		busy: true,
 		createdAt: Date.now()
 	};
-	websocketSessionCache.set(sessionId, entry);
+	const ownsCache = setOwnedWebSocketSession(sessionId, entry, expectedCacheValue);
 	return {
 		socket,
-		entry,
+		entry: ownsCache ? entry : void 0,
 		release: ({ keep } = {}) => {
-			if (!keep || !isWebSocketReusable(entry.socket)) {
+			if (!ownsCache || !keep || !isWebSocketReusable(entry.socket)) {
 				closeWebSocketSilently(entry.socket);
 				if (entry.idleTimer) clearTimeout(entry.idleTimer);
 				deleteOwnedWebSocketSession(sessionId, entry);
@@ -728,19 +756,6 @@ function extractWebSocketCloseError(event) {
 	}
 	return /* @__PURE__ */ new Error("WebSocket closed");
 }
-async function decodeWebSocketData(data) {
-	if (typeof data === "string") return data;
-	if (data instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(data));
-	if (ArrayBuffer.isView(data)) {
-		const view = data;
-		return new TextDecoder().decode(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
-	}
-	if (data && typeof data === "object" && "arrayBuffer" in data) {
-		const arrayBuffer = await data.arrayBuffer();
-		return new TextDecoder().decode(new Uint8Array(arrayBuffer));
-	}
-	return null;
-}
 async function* parseWebSocket(socket, signal) {
 	const queue = [];
 	let pending = null;
@@ -754,29 +769,30 @@ async function* parseWebSocket(socket, signal) {
 		resolve();
 	};
 	const onMessage = (event) => {
-		(async () => {
-			let text = null;
-			try {
-				if (!event || typeof event !== "object" || !("data" in event)) return;
-				text = await decodeWebSocketData(event.data);
-				if (!text) return;
-				const parsed = JSON.parse(text);
-				const type = typeof parsed.type === "string" ? parsed.type : "";
-				if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
-					sawCompletion = true;
-					done = true;
-				}
-				queue.push(parsed);
-				wake();
-			} catch (cause) {
-				failed = new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, {
-					cause,
-					payload: text
-				});
+		const data = event && typeof event === "object" && "data" in event ? event.data : void 0;
+		if (typeof data !== "string") {
+			failed = new CodexProtocolError(MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, { payload: data });
+			done = true;
+			wake();
+			return;
+		}
+		try {
+			const parsed = JSON.parse(data);
+			const type = typeof parsed.type === "string" ? parsed.type : "";
+			if (type === "response.completed" || type === "response.done" || type === "response.incomplete") {
+				sawCompletion = true;
 				done = true;
-				wake();
 			}
-		})();
+			queue.push(parsed);
+			wake();
+		} catch (cause) {
+			failed = new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, {
+				cause,
+				payload: data
+			});
+			done = true;
+			wake();
+		}
 	};
 	const onError = (event) => {
 		failed = extractWebSocketError(event);
@@ -870,7 +886,7 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
 		yield event;
 	}
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, options, abortFirstEventStream) {
+async function processWebSocketStream(url, body, headers, output, stream, model, onStart, options, abortFirstEventStream, observePromptEgress, payloadVariant = "initial", onRequestSent) {
 	const { socket, entry, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
 	let keepConnection = true;
 	const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
@@ -878,24 +894,35 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 	const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
 	try {
 		if (options?.signal?.aborted) throw transportAbortError(options.signal);
+		observePromptEgress?.(requestBody, {
+			egress: "native-codex-websocket",
+			payloadVariant
+		});
 		socket.send(JSON.stringify({
 			type: "response.create",
 			...requestBody
 		}));
+		onRequestSent?.();
 		await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal)), output, stream, onStart), output, stream, model, {
 			serviceTier: options?.serviceTier,
 			firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
 			abortFirstEventStream,
 			onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
 			signal: options?.signal,
+			reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
+				sessionId: options?.sessionId,
+				authProfileId: options?.authProfileId
+			}),
 			resolveServiceTier: resolveCodexServiceTier,
-			applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
+			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
 		});
 		if (options?.signal?.aborted) keepConnection = false;
 		else if (useCachedContext && entry && output.responseId) {
 			const responseItems = convertResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
 				includeSystemPrompt: false,
-				replayResponsesItemIds: false
+				replayResponsesItemIds: false,
+				sessionId: options?.sessionId,
+				authProfileId: options?.authProfileId
 			}).filter((item) => item.type !== "function_call_output");
 			entry.continuation = {
 				lastRequestBody: fullBody,
@@ -911,17 +938,31 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 		release({ keep: keepConnection });
 	}
 }
-async function readChatGptResponsesErrorTextLimited(response) {
+async function readChatGptResponsesErrorTextLimited(response, signal) {
 	const reader = response.body?.getReader();
 	if (!reader) return "";
 	const decoder = new TextDecoder();
 	let total = 0;
 	let text = "";
 	let reachedLimit = false;
+	let completed = false;
+	let cancelPromise;
+	const cancel = () => {
+		cancelPromise ??= reader.cancel(signal?.reason).catch(() => {});
+		return cancelPromise;
+	};
+	const onAbort = () => {
+		cancel();
+	};
+	if (signal?.aborted) onAbort();
+	else signal?.addEventListener("abort", onAbort, { once: true });
 	try {
 		while (true) {
 			const { value, done } = await reader.read();
-			if (done) break;
+			if (done) {
+				completed = true;
+				break;
+			}
 			if (!value || value.byteLength === 0) continue;
 			const remaining = OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES - total;
 			if (remaining <= 0) {
@@ -938,7 +979,8 @@ async function readChatGptResponsesErrorTextLimited(response) {
 		}
 		if (!reachedLimit) text += decoder.decode();
 	} finally {
-		if (reachedLimit) await reader.cancel().catch(() => {});
+		signal?.removeEventListener("abort", onAbort);
+		if (!completed) await cancel();
 		try {
 			reader.releaseLock();
 		} catch {}
@@ -948,11 +990,12 @@ async function readChatGptResponsesErrorTextLimited(response) {
 function parseErrorResponseText(raw, status, statusText) {
 	let message = raw || statusText || "Request failed";
 	let friendlyMessage;
+	let code;
 	try {
 		const err = JSON.parse(raw)?.error;
 		if (err) {
-			const code = err.code || err.type || "";
-			if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || status === 429) {
+			code = err.code || err.type || void 0;
+			if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code ?? "") || status === 429) {
 				const plan = err.plan_type ? ` (${err.plan_type.toLowerCase()} plan)` : "";
 				const mins = err.resets_at ? Math.max(0, Math.round((err.resets_at * 1e3 - Date.now()) / 6e4)) : void 0;
 				friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${mins !== void 0 ? ` Try again in ~${mins} min.` : ""}`.trim();
@@ -961,6 +1004,7 @@ function parseErrorResponseText(raw, status, statusText) {
 		}
 	} catch {}
 	return {
+		...code ? { code } : {},
 		message,
 		friendlyMessage
 	};
@@ -1012,4 +1056,4 @@ function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token,
 	return headers;
 }
 //#endregion
-export { closeOpenAICodexWebSocketSessions, extractOpenAICodexAccountId, parseSSEForTest, resetOpenAICodexWebSocketStateForTest, streamOpenAICodexResponses, streamSimpleOpenAICodexResponses };
+export { closeOpenAICodexWebSocketSessions, extractOpenAICodexAccountId, resetOpenAICodexWebSocketStateForTest, streamOpenAICodexResponses, streamSimpleOpenAICodexResponses };