@openclaw/ai 2026.8.1-beta.1 → 2026.8.1-beta.3

package/dist/{openai-chatgpt-responses-SC9m0FSf.mjs → openai-chatgpt-responses-C339VIfT.mjs}

@@ -1,18 +1,22 @@
 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-CEV9t6da.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-Bl7Kgddo.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-DF_yxOsA.mjs";
+import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
+import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-BG-1AsBI.mjs";
+import { c as resolveTimerTimeoutMs, i as clampTimerTimeoutMs } from "./number-coercion-H9qHik3g.mjs";
+import { S as supportsOpenAITemperature, m as responsesPromptObserver } from "./openai-responses-contracts-DvILoqBk.mjs";
 import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { c as buildBaseOptions, h as stripSystemPromptCacheBoundary } from "./tool-result-text-Dvkp2Dus.mjs";
-import { n as toErrorObject, t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-DDZPxRfr.mjs";
-import { B as responsesPromptObserver, n as processResponsesStream, pt as supportsOpenAITemperature, t as ResponsesStreamFailure } from "./openai-responses-stream-internal-Bl8YyVtF.mjs";
-import { n as clampTimerTimeoutMs, o as resolveTimerTimeoutMs } from "./number-coercion-1Miyb5MO.mjs";
-import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";
-import { d as transportAbortError, f as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-stream-shared-CPNv7A3r.mjs";
-import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-BIBomOGq.mjs";
+import { C as withProviderResponseHook, _ as notifyProviderStreamOpened, j as stripSystemPromptCacheBoundary, n as buildBaseOptions, x as transportAbortError } from "./simple-options-oqsXB6U3.mjs";
 import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, n as applyResponsesServiceTierPricing, r as convertResponsesMessages, s as convertResponsesToolPayload } from "./openai-responses-shared-CCyMvg7M.mjs";
-import { i as registerSessionResourceCleanup, n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-DhAAzLkj.mjs";
+import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";
+import { t as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./transport-utils-Bv0FHkd0.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-Cvt5MgEm.mjs";
+import { o as createOpenAIProviderAcceptanceHook, s as createOpenAIResponseHook } from "./openai-tool-projection-CHGLt03m.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
@@ -35,6 +39,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() {
@@ -50,7 +111,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",
@@ -123,9 +183,17 @@ 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);
@@ -141,13 +209,20 @@ 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, () => {
 							websocketStarted = true;
-						}, requestOptions, firstEventAbort.abort, observePromptEgress);
+						}, () => {
+							commitSemanticAttempt(activeAttempt);
+						}, 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({
@@ -159,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;
@@ -170,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;
@@ -178,64 +259,102 @@ 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 {
-					observePromptEgress?.(body, {
+			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: "initial"
-					});
-					attemptResponse = await fetch(resolveCodexUrl(model.baseUrl), {
-						method: "POST",
-						headers: sseHeaders,
-						body: sseBody,
-						signal: activeSignal
+						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: createOpenAIProviderAcceptanceHook(options, 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({
@@ -247,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();
@@ -266,15 +385,19 @@ const streamSimpleOpenAICodexResponses = (model, context, options) => {
 	if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
 	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,
@@ -321,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) => applyResponsesServiceTierPricing(usage, serviceTier, model)
-	});
-}
 var CodexApiError = class extends Error {
 	constructor(message, options) {
 		super(message);
@@ -341,14 +453,6 @@ 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 || error instanceof ResponsesStreamFailure;
 }
@@ -393,53 +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 (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((l) => l.startsWith("data:")).map((l) => l.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 {}
-	}
-}
-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;
@@ -815,12 +872,14 @@ function buildCachedWebSocketRequestBody(entry, body) {
 		input: delta
 	};
 }
-async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart) {
+async function* startWebSocketOutputOnFirstEvent(events, output, stream, onFirstProviderEvent, reportStreamOpened, onStart) {
 	let started = false;
 	for await (const event of events) {
 		if (!started) {
 			started = true;
+			onFirstProviderEvent();
 			onStart();
+			await reportStreamOpened();
 			stream.push({
 				type: "start",
 				partial: output
@@ -829,7 +888,7 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
 		yield event;
 	}
 }
-async function processWebSocketStream(url, body, headers, output, stream, model, onStart, options, abortFirstEventStream, observePromptEgress) {
+async function processWebSocketStream(url, body, headers, output, stream, model, onFirstProviderEvent, 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";
@@ -839,18 +898,29 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 		if (options?.signal?.aborted) throw transportAbortError(options.signal);
 		observePromptEgress?.(requestBody, {
 			egress: "native-codex-websocket",
-			payloadVariant: "initial"
+			payloadVariant
 		});
 		socket.send(JSON.stringify({
 			type: "response.create",
 			...requestBody
 		}));
-		await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal)), output, stream, onStart), output, stream, model, {
+		onRequestSent?.();
+		await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal)), output, stream, onFirstProviderEvent, () => notifyProviderStreamOpened({
+			options,
+			cancelStream: () => {
+				keepConnection = false;
+				closeWebSocketSilently(socket);
+			}
+		}), 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) => applyResponsesServiceTierPricing(usage, serviceTier, model)
 		});
@@ -858,7 +928,9 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 		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,
@@ -874,17 +946,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) {
@@ -901,7 +987,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 {}
@@ -911,11 +998,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();
@@ -924,6 +1012,7 @@ function parseErrorResponseText(raw, status, statusText) {
 		}
 	} catch {}
 	return {
+		...code ? { code } : {},
 		message,
 		friendlyMessage
 	};
@@ -975,4 +1064,4 @@ function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token,
 	return headers;
 }
 //#endregion
-export { closeOpenAICodexWebSocketSessions, extractOpenAICodexAccountId, parseSSEForTest, resetOpenAICodexWebSocketStateForTest, streamOpenAICodexResponses, streamSimpleOpenAICodexResponses };
+export { closeOpenAICodexWebSocketSessions, extractOpenAICodexAccountId, resetOpenAICodexWebSocketStateForTest, streamOpenAICodexResponses, streamSimpleOpenAICodexResponses };