@openclaw/ai 2026.7.2-beta.6 → 2026.7.33

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

@@ -1,41 +1,14 @@
-import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-CtMlqaQ4.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 { 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 { 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 AssistantMessageEventStream } from "./event-stream-ReMmOTzX.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-4t713IeR.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 { b as stripSystemPromptCacheBoundary, o as buildBaseOptions } from "./transform-messages-BhGF_fF4.mjs";
+import { a as resolveResponsesReasoningEffort, i as processResponsesStream, n as convertResponsesMessages, s as convertResponsesToolPayload } from "./openai-responses-shared-L3PWZvkm.mjs";
+import { i as getFirstStreamEventTimeoutMs, o as clampTimerTimeoutMs, r as getFirstStreamEventTimeoutHandler, s as resolveTimerTimeoutMs, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-RjWszj8c.mjs";
+import { a as clampOpenAIPromptCacheKey } from "./openai-tool-projection-BPlyXt8H.mjs";
 import { i as registerSessionResourceCleanup, n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-DhAAzLkj.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
-function sleepWithAbort(ms, signal) {
-	return new Promise((resolve, reject) => {
-		if (signal?.aborted) {
-			reject(/* @__PURE__ */ new Error("Request was aborted"));
-			return;
-		}
-		const onAbort = () => {
-			clearTimeout(timeout);
-			signal?.removeEventListener("abort", onAbort);
-			reject(/* @__PURE__ */ new Error("Request was aborted"));
-		};
-		const timeout = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-//#endregion
 //#region packages/ai/src/providers/openai-chatgpt-responses.ts
 const dynamicImport = (specifier) => import(specifier);
 function loadNodeOs() {
@@ -44,9 +17,10 @@ function loadNodeOs() {
 }
 const os = loadNodeOs();
 const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
-const DEFAULT_MAX_RETRIES = 3;
+const MAX_RETRIES = 3;
 const BASE_DELAY_MS = 1e3;
 const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
+const RETRY_AFTER_HTTP_DATE_RE = /^(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT|(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), \d{2}-(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\d{2} \d{2}:\d{2}:\d{2} GMT|(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) [ \d]\d \d{2}:\d{2}:\d{2} \d{4})$/;
 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";
@@ -64,21 +38,18 @@ function isRetryableError(status, errorText) {
 	if (status === 429 || status === 500 || status === 502 || status === 503 || status === 504) return true;
 	return /rate.?limit|overloaded|service.?unavailable|upstream.?connect|connection.?refused/i.test(errorText);
 }
-function resolveHttpRetryDelayMs(response, attempt) {
-	const fallbackMs = BASE_DELAY_MS * 2 ** attempt;
-	const retryAfterMs = response.headers.get("retry-after-ms");
-	if (retryAfterMs) {
-		const trimmed = retryAfterMs.trim();
-		const millis = Number(trimmed);
-		if (/^\d+(?:\.\d+)?$/.test(trimmed) && Number.isFinite(millis)) return clampTimerTimeoutMs(millis, 0) ?? fallbackMs;
-	}
-	const retryAfter = response.headers.get("retry-after");
-	if (!retryAfter) return fallbackMs;
-	const trimmed = retryAfter.trim();
-	const seconds = Number(trimmed);
-	if (/^\d+$/.test(trimmed) && Number.isFinite(seconds)) return clampTimerTimeoutMs(seconds * 1e3, 0) ?? fallbackMs;
-	const retryAt = parseRetryAfterHttpDateMs(trimmed);
-	return retryAt === void 0 ? fallbackMs : clampTimerTimeoutMs(retryAt - Date.now(), 0) ?? fallbackMs;
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(/* @__PURE__ */ new Error("Request was aborted"));
+			return;
+		}
+		const timeout = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timeout);
+			reject(/* @__PURE__ */ new Error("Request was aborted"));
+		});
+	});
 }
 function resolveRequestTimeoutMs(options) {
 	const timeoutMs = options?.timeoutMs;
@@ -149,7 +120,10 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			let body = buildRequestBody(model, context, options);
 			const nextBody = await options?.onPayload?.(body, model);
 			if (nextBody !== void 0) body = nextBody;
-			const sessionId = clampOpenAIPromptCacheKey(options?.sessionId);
+			const websocketRequestId = options?.sessionId || createCodexRequestId();
+			const sseHeaders = buildSSEHeaders(modelHeaders, optionHeaders, accountId, apiKey, options?.sessionId);
+			const websocketHeaders = buildWebSocketHeaders(modelHeaders, optionHeaders, accountId, apiKey, websocketRequestId);
+			const bodyJson = JSON.stringify(body);
 			requestTimeoutMs = resolveRequestTimeoutMs(options);
 			requestTimeoutSignal = buildRequestSignal(options?.signal, requestTimeoutMs);
 			firstEventAbort = createFirstStreamEventAbortController(requestTimeoutSignal);
@@ -160,8 +134,8 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			};
 			const transport = options?.transport || "auto";
 			const websocketDisabledForSession = transport === "auto" && isWebSocketSseFallbackActive(options?.sessionId);
+			if (websocketDisabledForSession) recordWebSocketSseFallback(options?.sessionId);
 			if (transport !== "sse" && !websocketDisabledForSession) {
-				const websocketHeaders = buildWebSocketHeaders(modelHeaders, optionHeaders, accountId, apiKey, sessionId || createCodexRequestId());
 				let websocketStarted = false;
 				let retriedWebSocketConnectionLimit = false;
 				while (true) {
@@ -170,7 +144,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 						await processWebSocketStream(resolveCodexWebSocketUrl(model.baseUrl), body, websocketHeaders, output, stream, model, () => {
 							websocketStarted = true;
 						}, requestOptions, firstEventAbort.abort);
-						if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+						if (activeSignal?.aborted) throw new Error("Request was aborted");
 						stream.push({
 							type: "done",
 							reason: output.stopReason,
@@ -191,60 +165,75 @@ 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(bodyJson).byteLength
 						}));
-						if (transport === "auto" && options?.sessionId) websocketSseFallbackSessions.add(options.sessionId);
+						recordWebSocketFailure(options?.sessionId, error, { activateSseFallback: transport === "auto" });
 						if (websocketStarted || transport !== "auto") throw error;
+						recordWebSocketSseFallback(options?.sessionId);
 						break;
 					}
 				}
 			}
-			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;
+			for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+				if (activeSignal?.aborted) throw new Error("Request was aborted");
 				try {
-					attemptResponse = await fetch(resolveCodexUrl(model.baseUrl), {
+					response = await fetch(resolveCodexUrl(model.baseUrl), {
 						method: "POST",
 						headers: sseHeaders,
 						body: sseBody,
 						signal: activeSignal
 					});
-					response = attemptResponse;
 					await options?.onResponse?.({
-						status: attemptResponse.status,
-						headers: headersToRecord(attemptResponse.headers)
+						status: response.status,
+						headers: headersToRecord(response.headers)
 					}, model);
-					if (attemptResponse.ok) break;
-					errorText = await readChatGptResponsesErrorTextLimited(attemptResponse);
+					if (response.ok) break;
+					const errorText = await readChatGptResponsesErrorTextLimited(response);
+					if (attempt < MAX_RETRIES && isRetryableError(response.status, errorText)) {
+						let delayMs = BASE_DELAY_MS * 2 ** attempt;
+						const retryAfterMs = response.headers.get("retry-after-ms");
+						if (retryAfterMs !== null) {
+							const trimmedRetryAfterMs = retryAfterMs.trim();
+							const millis = Number(trimmedRetryAfterMs);
+							if (/^\d+(?:\.\d+)?$/.test(trimmedRetryAfterMs) && Number.isFinite(millis)) delayMs = clampTimerTimeoutMs(millis, 0) ?? delayMs;
+						} else {
+							const retryAfter = response.headers.get("retry-after");
+							if (retryAfter) {
+								const trimmedRetryAfter = retryAfter.trim();
+								const seconds = Number(trimmedRetryAfter);
+								if (/^\d+$/.test(trimmedRetryAfter) && Number.isFinite(seconds)) delayMs = clampTimerTimeoutMs(seconds * 1e3, 0) ?? delayMs;
+								else if (RETRY_AFTER_HTTP_DATE_RE.test(trimmedRetryAfter)) {
+									const date = Date.parse(trimmedRetryAfter);
+									if (!Number.isNaN(date)) delayMs = clampTimerTimeoutMs(date - Date.now(), 0) ?? delayMs;
+								}
+							}
+						}
+						await sleep(delayMs, activeSignal);
+						continue;
+					}
+					const info = await parseErrorResponse(new Response(errorText, {
+						status: response.status,
+						statusText: response.statusText
+					}));
+					throw new Error(info.friendlyMessage || info.message);
 				} 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);
+					lastError = error instanceof Error ? error : new Error(String(error));
+					if (attempt < MAX_RETRIES && !lastError.message.includes("usage limit")) {
+						await sleep(BASE_DELAY_MS * 2 ** attempt, activeSignal);
 						continue;
 					}
 					throw lastError;
 				}
-				if (attempt < maxRetries && isRetryableError(attemptResponse.status, errorText)) {
-					await sleepWithAbort(resolveHttpRetryDelayMs(attemptResponse, attempt), activeSignal);
-					continue;
-				}
-				const info = parseErrorResponseText(errorText, attemptResponse.status, attemptResponse.statusText);
-				throw new Error(info.friendlyMessage || info.message);
 			}
 			if (!response?.ok) throw lastError ?? /* @__PURE__ */ new Error("Failed after retries");
 			if (!response.body) throw new Error("No response body");
@@ -253,7 +242,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				partial: output
 			});
 			await processStream(response, output, stream, model, options, firstEventAbort.abort);
-			if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+			if (activeSignal?.aborted) throw new Error("Request was aborted");
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -303,7 +292,7 @@ function buildRequestBody(model, context, options) {
 		tool_choice: "auto",
 		parallel_tool_calls: true
 	};
-	if (options?.temperature !== void 0 && supportsOpenAITemperature(model)) body.temperature = options.temperature;
+	if (options?.temperature !== void 0) body.temperature = options.temperature;
 	if (options?.serviceTier !== void 0) body.service_tier = options.serviceTier;
 	if (context.tools) {
 		const converted = convertResponsesToolPayload(context.tools, { strict: null });
@@ -363,7 +352,6 @@ async function processStream(response, output, stream, model, options, abortFirs
 		firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
 		abortFirstEventStream,
 		onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
-		signal: options?.signal,
 		resolveServiceTier: resolveCodexServiceTier,
 		applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
 	});
@@ -485,10 +473,36 @@ 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;
 const websocketSessionCache = /* @__PURE__ */ new Map();
+const websocketDebugStats = /* @__PURE__ */ new Map();
 const websocketSseFallbackSessions = /* @__PURE__ */ new Set();
 let cachedWebsocket = null;
-function resetOpenAICodexWebSocketStateForTest() {
+function getOrCreateWebSocketDebugStats(sessionId) {
+	let stats = websocketDebugStats.get(sessionId);
+	if (!stats) {
+		stats = {
+			requests: 0,
+			connectionsCreated: 0,
+			connectionsReused: 0,
+			cachedContextRequests: 0,
+			storeTrueRequests: 0,
+			fullContextRequests: 0,
+			deltaRequests: 0,
+			lastInputItems: 0,
+			websocketFailures: 0,
+			sseFallbacks: 0
+		};
+		websocketDebugStats.set(sessionId, stats);
+	}
+	return stats;
+}
+function resetOpenAICodexWebSocketDebugStats(sessionId) {
 	cachedWebsocket = null;
+	if (sessionId) {
+		websocketDebugStats.delete(sessionId);
+		websocketSseFallbackSessions.delete(sessionId);
+		return;
+	}
+	websocketDebugStats.clear();
 	websocketSseFallbackSessions.clear();
 }
 function closeOpenAICodexWebSocketSessions(sessionId) {
@@ -509,6 +523,20 @@ registerSessionResourceCleanup(closeOpenAICodexWebSocketSessions);
 function isWebSocketSseFallbackActive(sessionId) {
 	return sessionId ? websocketSseFallbackSessions.has(sessionId) : false;
 }
+function recordWebSocketSseFallback(sessionId) {
+	if (!sessionId) return;
+	const stats = getOrCreateWebSocketDebugStats(sessionId);
+	stats.sseFallbacks++;
+	stats.websocketFallbackActive = isWebSocketSseFallbackActive(sessionId);
+}
+function recordWebSocketFailure(sessionId, error, options) {
+	if (!sessionId) return;
+	if (options.activateSseFallback) websocketSseFallbackSessions.add(sessionId);
+	const stats = getOrCreateWebSocketDebugStats(sessionId);
+	stats.websocketFailures++;
+	stats.lastWebSocketError = formatThrownValue(error);
+	stats.websocketFallbackActive = isWebSocketSseFallbackActive(sessionId);
+}
 async function getWebSocketConstructor() {
 	if (cachedWebsocket) return cachedWebsocket;
 	if (process?.versions?.bun && (process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)) {
@@ -556,15 +584,12 @@ function closeWebSocketSilently(socket, code = 1e3, reason = "done") {
 		socket.close(code, reason);
 	} catch {}
 }
-function deleteOwnedWebSocketSession(sessionId, entry) {
-	if (websocketSessionCache.get(sessionId) === entry) websocketSessionCache.delete(sessionId);
-}
 function scheduleSessionWebSocketExpiry(sessionId, entry) {
 	if (entry.idleTimer) clearTimeout(entry.idleTimer);
 	entry.idleTimer = setTimeout(() => {
 		if (entry.busy) return;
 		closeWebSocketSilently(entry.socket, 1e3, "idle_timeout");
-		deleteOwnedWebSocketSession(sessionId, entry);
+		websocketSessionCache.delete(sessionId);
 	}, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
 async function connectWebSocket(url, headers, signal) {
@@ -629,6 +654,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 		const socket = await connectWebSocket(url, headers, signal);
 		return {
 			socket,
+			reused: false,
 			release: ({ keep } = {}) => {
 				if (keep === false) {
 					closeWebSocketSilently(socket);
@@ -652,10 +678,11 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 			return {
 				socket: cached.socket,
 				entry: cached,
+				reused: true,
 				release: ({ keep } = {}) => {
 					if (!keep || !isWebSocketReusable(cached.socket)) {
 						closeWebSocketSilently(cached.socket);
-						deleteOwnedWebSocketSession(sessionId, cached);
+						websocketSessionCache.delete(sessionId);
 						return;
 					}
 					cached.busy = false;
@@ -667,6 +694,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 			const socket = await connectWebSocket(url, headers, signal);
 			return {
 				socket,
+				reused: false,
 				release: () => {
 					closeWebSocketSilently(socket);
 				}
@@ -687,11 +715,12 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 	return {
 		socket,
 		entry,
+		reused: false,
 		release: ({ keep } = {}) => {
 			if (!keep || !isWebSocketReusable(entry.socket)) {
 				closeWebSocketSilently(entry.socket);
 				if (entry.idleTimer) clearTimeout(entry.idleTimer);
-				deleteOwnedWebSocketSession(sessionId, entry);
+				if (websocketSessionCache.get(sessionId) === entry) websocketSessionCache.delete(sessionId);
 				return;
 			}
 			entry.busy = false;
@@ -804,10 +833,9 @@ async function* parseWebSocket(socket, signal) {
 	signal?.addEventListener("abort", onAbort);
 	try {
 		while (true) {
-			if (signal?.aborted) throw transportAbortError(signal);
-			const next = queue.shift();
-			if (next !== void 0) {
-				yield next;
+			if (signal?.aborted) throw new Error("Request was aborted");
+			if (queue.length > 0) {
+				yield queue.shift();
 				continue;
 			}
 			if (done) break;
@@ -815,7 +843,7 @@ async function* parseWebSocket(socket, signal) {
 				pending = resolve;
 			});
 		}
-		if (failed) throw toErrorObject(failed, "Non-Error thrown");
+		if (failed) throw toLintErrorObject(failed, "Non-Error thrown");
 		if (!sawCompletion) throw new Error("WebSocket stream closed before response.completed");
 	} finally {
 		socket.removeEventListener("message", onMessage);
@@ -871,13 +899,31 @@ async function* startWebSocketOutputOnFirstEvent(events, output, stream, onStart
 	}
 }
 async function processWebSocketStream(url, body, headers, output, stream, model, onStart, options, abortFirstEventStream) {
-	const { socket, entry, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
+	const { socket, entry, reused, release } = await acquireWebSocket(url, headers, options?.sessionId, options?.signal);
 	let keepConnection = true;
 	const useCachedContext = options?.transport === "websocket-cached" || options?.transport === "auto";
 	const fullBody = body;
 	const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
+	const stats = options?.sessionId ? getOrCreateWebSocketDebugStats(options.sessionId) : void 0;
+	if (stats) {
+		stats.requests++;
+		if (reused) stats.connectionsReused++;
+		else stats.connectionsCreated++;
+		if (useCachedContext) stats.cachedContextRequests++;
+		if (requestBody.store === true) stats.storeTrueRequests++;
+		stats.lastInputItems = requestBody.input?.length ?? 0;
+		if (requestBody.previous_response_id) {
+			stats.deltaRequests++;
+			stats.lastDeltaInputItems = requestBody.input?.length ?? 0;
+			stats.lastPreviousResponseId = requestBody.previous_response_id;
+		} else {
+			stats.fullContextRequests++;
+			stats.lastDeltaInputItems = void 0;
+			stats.lastPreviousResponseId = void 0;
+		}
+	}
 	try {
-		if (options?.signal?.aborted) throw transportAbortError(options.signal);
+		if (options?.signal?.aborted) throw new Error("Request was aborted");
 		socket.send(JSON.stringify({
 			type: "response.create",
 			...requestBody
@@ -887,7 +933,6 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 			firstEventTimeoutMs: getFirstStreamEventTimeoutMs(options),
 			abortFirstEventStream,
 			onFirstEventTimeout: getFirstStreamEventTimeoutHandler(options),
-			signal: options?.signal,
 			resolveServiceTier: resolveCodexServiceTier,
 			applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model)
 		});
@@ -936,7 +981,7 @@ async function readChatGptResponsesErrorTextLimited(response) {
 				break;
 			}
 		}
-		if (!reachedLimit) text += decoder.decode();
+		text += decoder.decode();
 	} finally {
 		if (reachedLimit) await reader.cancel().catch(() => {});
 		try {
@@ -945,14 +990,15 @@ async function readChatGptResponsesErrorTextLimited(response) {
 	}
 	return text;
 }
-function parseErrorResponseText(raw, status, statusText) {
-	let message = raw || statusText || "Request failed";
+async function parseErrorResponse(response) {
+	const raw = await readChatGptResponsesErrorTextLimited(response);
+	let message = raw || response.statusText || "Request failed";
 	let friendlyMessage;
 	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) {
+			if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.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();
@@ -1011,5 +1057,12 @@ function buildWebSocketHeaders(initHeaders, additionalHeaders, accountId, token,
 	headers.set("session_id", requestId);
 	return headers;
 }
+function toLintErrorObject(value, fallbackMessage) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	const error = new Error(fallbackMessage, { cause: value });
+	if (typeof value === "object" && value !== null || typeof value === "function") Object.assign(error, value);
+	return error;
+}
 //#endregion
-export { closeOpenAICodexWebSocketSessions, extractOpenAICodexAccountId, parseSSEForTest, resetOpenAICodexWebSocketStateForTest, streamOpenAICodexResponses, streamSimpleOpenAICodexResponses };
+export { closeOpenAICodexWebSocketSessions, extractOpenAICodexAccountId, parseSSEForTest, resetOpenAICodexWebSocketDebugStats, streamOpenAICodexResponses, streamSimpleOpenAICodexResponses };