@openclaw/ai 2026.10.1-beta.2 → 2026.10.5-beta.1

package/dist/{openai-chatgpt-responses-BC2x0Oqx.mjs → openai-chatgpt-responses-OCwckGhY.mjs}

@@ -1,26 +1,24 @@
 import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-DzrF1h4J.mjs";
-import { t as AssistantMessageEventStream } from "./event-stream-C5AbCAaZ.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-X2gmsUWv.mjs";
 import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
-import { r as clampPositiveTimerTimeoutMs } from "./number-coercion-V8-BhME4.mjs";
-import { E as headersToRecord, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-DCW52iHe.mjs";
-import { D as supportsOpenAITemperature, h as responsesPromptObserver } from "./openai-responses-contracts-BKu8O7l4.mjs";
+import { i as clampPositiveTimerTimeoutMs } from "./number-coercion-C3hztWoY.mjs";
+import { E as headersToRecord, a as resolveAiTransportHeaderSentinels, r as getAiTransportHost } from "./host-JWXZWa-c.mjs";
+import { h as responsesPromptObserver, k as supportsOpenAITemperature } from "./openai-responses-contracts-DlKMMTxK.mjs";
 import { r as registerSessionResourceCleanup } from "./session-resources-D1wgDQ8C.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-I8YQTzf8.mjs";
-import { _ as extractErrorCodeOrErrno, o as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, v as toErrorObject } from "./diagnostics-Caj-4RBA.mjs";
-import { n as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE } from "./text-signature-MLwfi6fq.mjs";
+import "./provider-error-CF9GWCs2.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-Cr2xKVrS.mjs";
+import { s as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, v as extractErrorCodeOrErrno, y as toErrorObject } from "./diagnostics-tQasYct1.mjs";
+import { a as MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, d as streamFragmentError, p as consumeResponseBytes } from "./text-signature-B_MB6U_9.mjs";
 import { parseRetryAfterHeadersSeconds } from "./internal/retry-after.mjs";
-import { c as resolveOpenAIResponsesTextFormat } from "./openai-completions-compat-BdmlhD4u.mjs";
-import { n as buildManagedModelFetch } from "./host-policy-B3jc4Rpn.mjs";
-import { S as withProviderResponseHook, b as transportAbortError, h as notifyProviderStreamOpened, n as assignTransportErrorDetails } from "./transport-stream-shared-CxXXz_Dd.mjs";
-import { C as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-BkKTXxhp.mjs";
-import { b as createOpenAIResponseHook, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, x as createResponseModelTracker, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-JFsnIyto.mjs";
-import { t as createAssistantOutput } from "./assistant-output-OLm-Oln0.mjs";
-import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-D9ZmL_s9.mjs";
-import { A as recordResponsesContextUsage, J as buildOpenAIResponsesReasoningReplayMetadata, P as convertProviderResponsesMessages, S as isInvalidEncryptedContentError, T as ResponsesStreamFailure, Z as suppressOpenAIResponsesCompaction, b as commitResponsesEncryptedContentAttempt, i as convertResponsesToolPayload, n as applyResponsesServiceTierPricing, o as readOpenAIMisalignmentReview, s as processResponsesStream, w as resolveNextResponsesEncryptedContentAttempt } from "./openai-responses-shared-C7oVyjED.mjs";
-import { t as createSseByteGuard } from "./streaming-byte-guard-CC-HMn_u.mjs";
-import { t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-CCg7B6l4.mjs";
-import { n as withResponsesRequestAcceptance, t as responsesRequestLifecycle } from "./openai-responses-request-lifecycle-Fsag-IGZ.mjs";
-import { t as requireApiKey } from "./required-api-key-D4kn3252.mjs";
+import { c as resolveOpenAIResponsesTextFormat } from "./openai-completions-compat-pg1q4uNG.mjs";
+import { n as buildManagedModelFetch } from "./host-policy-q4Azym9F.mjs";
+import { S as withProviderResponseHook, b as transportAbortError, h as notifyProviderStreamOpened, n as assignTransportErrorDetails } from "./transport-stream-shared-DH08b7Il.mjs";
+import { C as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-BARFAzk9.mjs";
+import { Dt as createResponseModelTracker, E as ResponsesStreamFailure, Et as createOpenAIResponseHook, F as convertProviderResponsesMessages, S as isInvalidEncryptedContentError, T as resolveNextResponsesEncryptedContentAttempt, Tt as createOpenAIProviderAcceptanceHook, _t as resolveOpenAISimpleReasoningEffort, at as suppressOpenAIResponsesCompaction, b as commitResponsesEncryptedContentAttempt, gt as resolveOpenAIRequestReasoning, i as convertResponsesToolPayload, j as recordResponsesContextUsage, n as applyResponsesServiceTierPricing, nt as buildOpenAIResponsesReasoningReplayMetadata, o as readOpenAIMisalignmentReview, s as processResponsesStream } from "./openai-responses-shared-DVGhq5xF.mjs";
+import { t as createAssistantOutput } from "./assistant-output-CUEeSotf.mjs";
+import { a as withFirstStreamEventTimeout, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-Dc42hKv6.mjs";
+import { n as withResponsesRequestAcceptance, r as createResponsesPromptEgressObserver, t as responsesRequestLifecycle } from "./openai-responses-request-lifecycle-D2IFiI0-.mjs";
+import { t as requireApiKey } from "./required-api-key-CFJvcFy_.mjs";
 import { n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-KWcgd0d_.mjs";
 //#region packages/ai/src/providers/openai-chatgpt-responses-events.ts
 var CodexApiError = class extends Error {
@@ -35,9 +33,10 @@ var CodexApiError = class extends Error {
 };
 function extractCodexEventError(event) {
 	const nested = isRecord(event.error) ? event.error : void 0;
+	const read = (field) => typeof event[field] === "string" ? event[field] : typeof nested?.[field] === "string" ? nested[field] : void 0;
 	return {
-		code: typeof event.code === "string" ? event.code : typeof nested?.code === "string" ? nested.code : void 0,
-		message: typeof event.message === "string" ? event.message : typeof nested?.message === "string" ? nested.message : void 0
+		code: read("code"),
+		message: read("message")
 	};
 }
 async function* mapCodexEvents(events, initialResponseHeaders, options) {
@@ -84,7 +83,7 @@ function normalizeCodexStatus(status) {
 }
 //#endregion
 //#region packages/ai/src/providers/openai-chatgpt-responses-protocol.ts
-const OPENAI_CHATGPT_RESPONSES_SUCCESS_BODY_MAX_BYTES = 16777216;
+const OPENAI_CHATGPT_RESPONSES_SSE_FRAME_MAX_BYTES = 16777216;
 var CodexProtocolError = class extends Error {
 	constructor(message, options) {
 		super(message);
@@ -96,44 +95,52 @@ var CodexProtocolError = class extends Error {
 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 = "";
+	let buffer = /* @__PURE__ */ new Uint8Array(1024);
+	let size = 0;
+	let lineEmpty = true;
+	let skipLf = false;
+	let cancelReason;
 	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 && (!done || buffer.length === 0)) break;
-				const chunk = boundary ? buffer.slice(0, boundary.index) : buffer;
-				buffer = boundary ? 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;
+			const { done, value } = await reader.read();
+			for (let index = 0; index < (value?.length ?? 0) + (done ? 1 : 0); index++) {
+				const byte = value?.[index];
+				if (byte !== void 0) {
+					const crlf = skipLf && byte === 10;
+					skipLf = byte === 13;
+					const lineEnding = byte === 10 || byte === 13;
+					const boundary = !crlf && lineEnding && lineEmpty;
+					lineEmpty = lineEnding;
+					if (crlf && size === 0) continue;
+					if (size >= OPENAI_CHATGPT_RESPONSES_SSE_FRAME_MAX_BYTES) throw new Error(`OpenAI ChatGPT Responses SSE frame exceeded ${OPENAI_CHATGPT_RESPONSES_SSE_FRAME_MAX_BYTES} bytes`);
+					if (size === buffer.length) {
+						const grown = new Uint8Array(Math.min(buffer.length * 2, OPENAI_CHATGPT_RESPONSES_SSE_FRAME_MAX_BYTES));
+						grown.set(buffer);
+						buffer = grown;
 					}
+					buffer[size++] = byte;
+					if (!boundary) continue;
 				}
+				const chunk = decoder.decode(buffer.subarray(0, size), { stream: !done });
+				size = 0;
+				const data = chunk.split(/\r\n|\r|\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n").trim();
+				if (!data || data === "[DONE]") continue;
+				let event;
+				try {
+					event = JSON.parse(data);
+				} catch (cause) {
+					throw streamFragmentError(cause, CodexProtocolError);
+				}
+				yield event;
 			}
 			if (done) break;
 		}
+	} catch (error) {
+		cancelReason = error;
+		throw error;
 	} finally {
-		try {
-			await guard.cancel();
-		} catch {}
+		reader.cancel(cancelReason).catch(() => void 0);
 		try {
 			reader.releaseLock();
 		} catch {}
@@ -155,17 +162,16 @@ function resolveCodexWebSocketUrl(baseUrl) {
 //#endregion
 //#region packages/ai/src/providers/openai-chatgpt-responses-websocket-authority.ts
 const OPENAI_BETA_RESPONSES_WEBSOCKETS = "responses_websockets=2026-02-06";
-function createCodexWebSocketAuthority(transportHost, baseUrl, headers) {
+function resolveCodexWebSocketAuthority(params) {
+	if (params.transport === "sse") return;
+	const headers = params.headers();
 	return {
-		transportHost,
-		url: resolveCodexWebSocketUrl(baseUrl),
+		transportHost: params.transportHost,
+		url: resolveCodexWebSocketUrl(params.baseUrl),
 		headers,
 		normalizedHeaders: Array.from(headers.entries()).filter(([name]) => name !== "traceparent")
 	};
 }
-function resolveCodexWebSocketAuthority(params) {
-	return params.transport === "sse" ? void 0 : createCodexWebSocketAuthority(params.transportHost, params.baseUrl, params.headers());
-}
 function buildCodexWebSocketHeaders(baseHeaders, requestId) {
 	baseHeaders.delete("accept");
 	baseHeaders.delete("content-type");
@@ -298,13 +304,8 @@ const RETRYABLE_WEBSOCKET_CLOSE_CODES = /* @__PURE__ */ new Set([
 ]);
 const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
+const WEBSOCKET_REPLAY_REJECTION = "Codex error: Persisted response contains hosted-tool, compaction, or unverifiable hidden reasoning state that Rustponses cannot replay. Start a new response or use the Python Responses service for this continuation.";
 const OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES = 16384;
-function buildRequestSignal(baseSignal, timeoutMs) {
-	if (timeoutMs === void 0) return baseSignal;
-	const timeoutSignal = AbortSignal.timeout(timeoutMs);
-	if (!baseSignal) return timeoutSignal;
-	return AbortSignal.any([baseSignal, timeoutSignal]);
-}
 function isRequestTimeoutError(error, callerSignal, requestSignal, timeoutMs) {
 	if (timeoutMs === void 0 || callerSignal?.aborted || !requestSignal?.aborted) return false;
 	if (!(error instanceof Error)) return false;
@@ -361,13 +362,41 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			const observePromptEgress = createResponsesPromptEgressObserver(options, context.systemPrompt);
 			const sessionId = clampOpenAIPromptCacheKey(options?.sessionId);
 			requestTimeoutMs = clampPositiveTimerTimeoutMs(options?.timeoutMs);
-			requestTimeoutSignal = buildRequestSignal(options?.signal, requestTimeoutMs);
+			requestTimeoutSignal = options?.signal;
+			if (requestTimeoutMs !== void 0) {
+				const timeoutSignal = AbortSignal.timeout(requestTimeoutMs);
+				requestTimeoutSignal = options?.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+			}
 			firstEventAbort = createFirstStreamEventAbortController(requestTimeoutSignal);
 			activeSignal = firstEventAbort.signal;
 			const requestOptions = activeSignal === options?.signal ? options : {
 				...options,
 				signal: activeSignal
 			};
+			const processStream = (events, streamOptions, activitySignal) => processResponsesStream(events, output, stream, model, {
+				serviceTier: streamOptions?.serviceTier,
+				firstEventTimeoutMs: getFirstStreamEventTimeoutMs(streamOptions),
+				abortFirstEventStream: firstEventAbort?.abort,
+				onFirstEventTimeout: getFirstStreamEventTimeoutHandler(streamOptions),
+				signal: activitySignal ?? streamOptions?.signal,
+				reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
+					sessionId: streamOptions?.sessionId,
+					authProfileId: streamOptions?.authProfileId
+				}),
+				resolveServiceTier: resolveCodexServiceTier,
+				applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
+			});
+			const completeStream = (terminal, attempt, ErrorType) => {
+				if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+				if (output.stopReason === "aborted" || output.stopReason === "error") throw new ErrorType(output.errorMessage ?? "An unknown error occurred");
+				if (terminal && attempt.kind === "initial") recordResponsesContextUsage(output, model, options, attempt.request, terminal.output, "provider");
+				stream.push({
+					type: "done",
+					reason: output.stopReason,
+					message: output
+				});
+				stream.end();
+			};
 			const transport = options?.transport || "auto";
 			let websocketAuthority;
 			if (!transportHost.requiresManagedTransport(model)) try {
@@ -389,45 +418,36 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			const websocketDisabledForSession = transport === "auto" && websocketAuthority !== void 0 && hasCodexWebSocketSseFallback(websocketState.sseFallbacks, options?.sessionId, websocketAuthority);
 			if (websocketAuthority && !websocketDisabledForSession) {
 				let websocketStarted = false;
-				let websocketRequestSent = false;
-				let retriedWebSocketConnectionLimit = false;
+				let retriedWebSocketRejection = false;
 				while (true) {
 					const activeAttempt = semanticAttempt;
+					const dispatch = {};
 					websocketStarted = false;
-					websocketRequestSent = false;
 					try {
-						const terminal = await processWebSocketStream(websocketState, websocketAuthority, activeAttempt.request, output, stream, model, () => {
+						completeStream(await processWebSocketStream(websocketState, websocketAuthority, activeAttempt.request, output, stream, model, () => {
 							websocketStarted = true;
 						}, () => {
 							commitSemanticAttempt(activeAttempt);
-						}, requestOptions, firstEventAbort.abort, observePromptEgress, activeAttempt.kind, () => {
-							websocketRequestSent = true;
-						}, options?.signal);
-						if (activeSignal?.aborted) throw transportAbortError(activeSignal);
-						if (output.stopReason === "aborted" || output.stopReason === "error") throw new CodexApiError(output.errorMessage ?? "An unknown error occurred");
-						if (terminal && activeAttempt.kind === "initial") recordResponsesContextUsage(output, model, options, activeAttempt.request, terminal.output, "provider");
-						stream.push({
-							type: "done",
-							reason: output.stopReason,
-							message: output
-						});
-						stream.end();
+						}, requestOptions, processStream, observePromptEgress, activeAttempt.kind, (request) => {
+							dispatch.request = request;
+						}, options?.signal), activeAttempt, CodexApiError);
 						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;
+						const nextSemanticAttempt = !aborted && dispatch.request && !websocketStarted && error instanceof CodexApiError && isInvalidEncryptedContentError(error) ? await resolveNextResponsesEncryptedContentAttempt(activeAttempt, error, { buildFullHistoryRequest: () => buildBody("full-history") }) : void 0;
 						if (nextSemanticAttempt) {
 							semanticAttempt = nextSemanticAttempt;
-							retriedWebSocketConnectionLimit = false;
+							retriedWebSocketRejection = false;
 							continue;
 						}
-						const connectionLimitBeforeStart = !websocketStarted && isWebSocketConnectionLimitReachedError(error);
-						if (!aborted && connectionLimitBeforeStart && !retriedWebSocketConnectionLimit) {
-							retriedWebSocketConnectionLimit = true;
+						const reconnectBeforeStart = !websocketStarted && (isWebSocketConnectionLimitReachedError(error) || dispatch.request?.previous_response_id && error instanceof CodexApiError && error.message === WEBSOCKET_REPLAY_REJECTION);
+						if (!aborted && reconnectBeforeStart && !retriedWebSocketRejection) {
+							retriedWebSocketRejection = true;
 							continue;
 						}
-						if (aborted || isCodexNonTransportError(error) && !connectionLimitBeforeStart) throw error;
-						appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", error, {
+						const transportError = isWebSocketConnectionLimitReachedError(error) ? Object.assign(new Error(error.message, { cause: error }), { code: WEBSOCKET_TRANSPORT_ERROR_CODE }) : error;
+						if (aborted || isCodexNonTransportError(transportError)) throw transportError;
+						appendAssistantMessageDiagnostic(output, createAssistantMessageDiagnostic("provider_transport_failure", transportError, {
 							configuredTransport: transport,
 							fallbackTransport: transport === "auto" && !websocketStarted ? "sse" : void 0,
 							eventsEmitted: websocketStarted,
@@ -435,7 +455,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 							requestBytes: new TextEncoder().encode(JSON.stringify(activeAttempt.request)).byteLength
 						}));
 						if (transport === "auto" && options?.sessionId) addCodexWebSocketSseFallback(websocketState.sseFallbacks, options.sessionId, websocketAuthority);
-						if (websocketStarted || transport !== "auto") throw error;
+						if (websocketStarted || transport !== "auto") throw transportError;
 						break;
 					}
 				}
@@ -503,7 +523,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				if (!nextSemanticAttempt) throw terminalResponseError;
 				semanticAttempt = nextSemanticAttempt;
 			}
-			const hookedResponseStream = withProviderResponseHook({
+			completeStream(await processStream(withProviderResponseHook({
 				stream: mapCodexEvents(parseOpenAIChatGptResponsesSse(response), response.headers, requestOptions),
 				signal: firstEventAbort.signal,
 				abort: firstEventAbort.abort,
@@ -512,29 +532,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					type: "start",
 					partial: output
 				})
-			});
-			const terminal = await processResponsesStream(hookedResponseStream, 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)
-			});
-			if (activeSignal?.aborted) throw transportAbortError(activeSignal);
-			if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
-			if (terminal && semanticAttempt.kind === "initial") recordResponsesContextUsage(output, model, options, semanticAttempt.request, terminal.output, "provider");
-			stream.push({
-				type: "done",
-				reason: output.stopReason,
-				message: output
-			});
-			stream.end();
+			}), options), semanticAttempt, Error);
 		} catch (error) {
 			await responsesRequestLifecycle.get(options)?.settle().catch(() => void 0);
 			const requestTimedOut = isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0;
@@ -708,33 +706,18 @@ async function connectWebSocket(url, headers, signal) {
 			reject(error instanceof Error ? error : new Error(String(error)));
 			return;
 		}
-		const onOpen = () => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			resolve(socket);
-		};
-		const onError = (event) => {
-			const error = extractWebSocketError(event);
+		const settle = (error, aborted = false) => {
 			if (settled) return;
 			settled = true;
 			cleanup();
-			reject(error);
-		};
-		const onClose = (event) => {
-			const error = extractWebSocketCloseError(event);
-			if (settled) return;
-			settled = true;
-			cleanup();
-			reject(error);
-		};
-		const onAbort = () => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			socket.close(1e3, "aborted");
-			reject(/* @__PURE__ */ new Error("Request was aborted"));
+			if (aborted) socket.close(1e3, "aborted");
+			if (error) reject(error);
+			else resolve(socket);
 		};
+		const onOpen = () => settle();
+		const onError = (event) => settle(extractWebSocketError(event));
+		const onClose = (event) => settle(extractWebSocketCloseError(event));
+		const onAbort = () => settle(/* @__PURE__ */ new Error("Request was aborted"), true);
 		const cleanup = () => {
 			socket.removeEventListener("open", onOpen);
 			socket.removeEventListener("error", onError);
@@ -847,12 +830,15 @@ async function* parseWebSocket(socket, signal) {
 		pending = null;
 		resolve();
 	};
+	const finish = (error) => {
+		if (error) failed = error;
+		done = true;
+		wake();
+	};
 	const onMessage = (event) => {
 		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();
+			finish(new CodexProtocolError(MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, { payload: data }));
 			return;
 		}
 		try {
@@ -865,34 +851,15 @@ async function* parseWebSocket(socket, signal) {
 			queue.push(parsed);
 			wake();
 		} catch (cause) {
-			failed = new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, {
+			finish(new CodexProtocolError(`Invalid Codex WebSocket JSON: ${formatThrownValue(cause)}`, {
 				cause,
 				payload: data
-			});
-			done = true;
-			wake();
-		}
-	};
-	const onError = (event) => {
-		failed = extractWebSocketError(event);
-		done = true;
-		wake();
-	};
-	const onClose = (event) => {
-		if (sawCompletion) {
-			done = true;
-			wake();
-			return;
+			}));
 		}
-		if (!failed) failed = extractWebSocketCloseError(event);
-		done = true;
-		wake();
-	};
-	const onAbort = () => {
-		failed = /* @__PURE__ */ new Error("Request was aborted");
-		done = true;
-		wake();
 	};
+	const onError = (event) => finish(extractWebSocketError(event));
+	const onClose = (event) => finish(!sawCompletion && !failed ? extractWebSocketCloseError(event) : void 0);
+	const onAbort = () => finish(/* @__PURE__ */ new Error("Request was aborted"));
 	socket.addEventListener("message", onMessage);
 	socket.addEventListener("error", onError);
 	socket.addEventListener("close", onClose);
@@ -919,58 +886,52 @@ async function* parseWebSocket(socket, signal) {
 		signal?.removeEventListener("abort", onAbort);
 	}
 }
-function requestBodyWithoutInput(body) {
+function serializeRequestContext(body) {
 	const { input: _input, previous_response_id: _previousResponseId, ...rest } = body;
-	return rest;
-}
-function requestBodiesMatchExceptInput(a, b) {
-	return JSON.stringify(requestBodyWithoutInput(a)) === JSON.stringify(requestBodyWithoutInput(b));
-}
-function getCachedWebSocketInputDelta(body, continuation) {
-	if (!requestBodiesMatchExceptInput(body, continuation.lastRequestBody)) return;
-	const currentInput = body.input ?? [];
-	const baseline = [...continuation.lastRequestBody.input ?? [], ...continuation.lastResponseItems];
-	if (currentInput.length < baseline.length) return;
-	const prefix = currentInput.slice(0, baseline.length);
-	if (JSON.stringify(prefix) !== JSON.stringify(baseline)) return;
-	return currentInput.slice(baseline.length);
+	return JSON.stringify(rest);
 }
 function buildCachedWebSocketRequestBody(entry, body) {
 	const continuation = entry.continuation;
 	if (!continuation) return body;
-	const delta = getCachedWebSocketInputDelta(body, continuation);
-	if (!delta || !continuation.lastResponseId) {
+	const currentInput = body.input ?? [];
+	const baseline = [...continuation.lastRequestBody.input ?? [], ...continuation.lastResponseItems];
+	if (!continuation.lastResponseId || serializeRequestContext(body) !== serializeRequestContext(continuation.lastRequestBody) || currentInput.length < baseline.length || JSON.stringify(currentInput.slice(0, baseline.length)) !== JSON.stringify(baseline)) {
 		entry.continuation = void 0;
 		return body;
 	}
 	return {
 		...body,
 		previous_response_id: continuation.lastResponseId,
-		input: delta
+		input: currentInput.slice(baseline.length)
 	};
 }
-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
-			});
-		}
-		yield event;
-	}
-}
-async function processWebSocketStream(state, authority, body, output, stream, model, onFirstProviderEvent, onStart, options, abortFirstEventStream, observePromptEgress, payloadVariant = "initial", onRequestSent, activitySignal) {
+async function processWebSocketStream(state, authority, body, output, stream, model, onFirstProviderEvent, onStart, options, processStream, observePromptEgress, payloadVariant = "initial", onRequestSent, activitySignal) {
 	const { socket, entry, release } = await acquireWebSocket(state, authority, 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 requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, body) : body;
+	async function* acceptedEvents() {
+		let started = false;
+		for await (const event of mapCodexEvents(parseWebSocket(socket, options?.signal), void 0, options)) {
+			if (!started) {
+				started = true;
+				onFirstProviderEvent();
+				onStart();
+				await notifyProviderStreamOpened({
+					options,
+					cancelStream: () => {
+						keepConnection = false;
+						closeWebSocketSilently(socket);
+					}
+				});
+				stream.push({
+					type: "start",
+					partial: output
+				});
+			}
+			yield event;
+		}
+	}
 	try {
 		if (options?.signal?.aborted) throw transportAbortError(options.signal);
 		observePromptEgress?.(requestBody, {
@@ -987,26 +948,8 @@ async function processWebSocketStream(state, authority, body, output, stream, mo
 			type: "response.create",
 			...requestBody
 		}));
-		onRequestSent?.();
-		const terminal = await processResponsesStream(startWebSocketOutputOnFirstEvent(mapCodexEvents(parseWebSocket(socket, options?.signal), void 0, options), 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: activitySignal ?? options?.signal,
-			reasoningReplayMetadata: buildOpenAIResponsesReasoningReplayMetadata(model, {
-				sessionId: options?.sessionId,
-				authProfileId: options?.authProfileId
-			}),
-			resolveServiceTier: resolveCodexServiceTier,
-			applyServiceTierPricing: (usage, serviceTier) => applyResponsesServiceTierPricing(usage, serviceTier, model)
-		});
+		onRequestSent?.(requestBody);
+		const terminal = await processStream(acceptedEvents(), options, activitySignal);
 		if (options?.signal?.aborted) keepConnection = false;
 		else if (useCachedContext && entry && output.responseId) {
 			const responseItems = convertProviderResponsesMessages(model, { messages: [output] }, CODEX_TOOL_CALL_PROVIDERS, {
@@ -1016,7 +959,7 @@ async function processWebSocketStream(state, authority, body, output, stream, mo
 				authProfileId: options?.authProfileId
 			}).filter((item) => item.type !== "function_call_output");
 			entry.continuation = {
-				lastRequestBody: fullBody,
+				lastRequestBody: body,
 				lastResponseId: output.responseId,
 				lastResponseItems: responseItems
 			};
@@ -1034,9 +977,7 @@ 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 = () => {
@@ -1049,27 +990,17 @@ async function readChatGptResponsesErrorTextLimited(response, signal) {
 	if (signal?.aborted) onAbort();
 	else signal?.addEventListener("abort", onAbort, { once: true });
 	try {
-		while (true) {
-			const { value, done } = await reader.read();
-			if (done) {
-				completed = true;
-				break;
-			}
-			if (!value || value.byteLength === 0) continue;
-			const remaining = OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES - total;
-			if (remaining <= 0) {
-				reachedLimit = true;
-				break;
-			}
-			const chunk = value.byteLength > remaining ? value.subarray(0, remaining) : value;
-			total += chunk.byteLength;
-			text += decoder.decode(chunk, { stream: true });
-			if (total >= OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES) {
-				reachedLimit = true;
-				break;
-			}
-		}
-		if (!reachedLimit) text += decoder.decode();
+		const { truncated } = await consumeResponseBytes({
+			maxBytes: OPENAI_CHATGPT_RESPONSES_ERROR_BODY_MAX_BYTES,
+			stopAtLimit: true,
+			read: () => reader.read(),
+			onChunk: (chunk) => {
+				text += decoder.decode(chunk, { stream: true });
+			},
+			onLimit: () => {}
+		});
+		completed = !truncated;
+		if (completed) text += decoder.decode();
 	} finally {
 		signal?.removeEventListener("abort", onAbort);
 		if (!completed) await cancel();

package/dist/{openai-completions-DNyHnXKg.mjs → openai-completions-DOltBUe9.mjs}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { k as clampThinkingLevel } from "./host-DCW52iHe.mjs";
-import { n as buildBaseOptions } from "./simple-options-BkKTXxhp.mjs";
-import { i as convertMessages, n as streamOpenAICompletionsRequest } from "./openai-completions-transport-DWM2mQDB.mjs";
-import { t as requireApiKey } from "./required-api-key-D4kn3252.mjs";
+import { k as clampThinkingLevel } from "./host-JWXZWa-c.mjs";
+import { n as buildBaseOptions } from "./simple-options-BARFAzk9.mjs";
+import { c as convertMessages, n as streamOpenAICompletionsRequest } from "./openai-completions-transport-OMrn7gnZ.mjs";
+import { t as requireApiKey } from "./required-api-key-CFJvcFy_.mjs";
 //#region packages/ai/src/providers/openai-completions.ts
 var openai_completions_exports = /* @__PURE__ */ __exportAll({
 	convertMessages: () => convertMessages,
@@ -14,11 +14,12 @@ const streamSimpleOpenAICompletions = (model, context, options) => {
 	const apiKey = requireApiKey(model.provider, options?.apiKey);
 	const base = buildBaseOptions(model, options, apiKey);
 	const clampedReasoning = options?.reasoning ? clampThinkingLevel(model, options.reasoning) : void 0;
-	const toolChoice = options?.toolChoice;
+	const completionsOptions = options;
 	return streamOpenAICompletions(model, context, {
 		...base,
 		reasoningEffort: clampedReasoning,
-		toolChoice
+		toolChoice: completionsOptions?.toolChoice,
+		streaming: completionsOptions?.streaming
 	});
 };
 //#endregion