@openclaw/ai 2026.10.2 → 2026.10.5-beta.2

package/dist/{openai-chatgpt-responses-CHdn8YJ_.mjs → openai-chatgpt-responses-V4iP0dv5.mjs}

@@ -1,25 +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-u3o8XiAp.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-Bf3NjYNj.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-BK6E2g4Q.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-D_vRrx-z.mjs";
+import "./provider-error-CF9GWCs2.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-r93BJhjm.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-Drb4Erb8.mjs";
 import { parseRetryAfterHeadersSeconds } from "./internal/retry-after.mjs";
-import { c as resolveOpenAIResponsesTextFormat } from "./openai-completions-compat-GMN8A0fm.mjs";
-import { n as buildManagedModelFetch } from "./host-policy-BwhNNGQR.mjs";
-import { S as withProviderResponseHook, b as transportAbortError, h as notifyProviderStreamOpened, n as assignTransportErrorDetails } from "./transport-stream-shared-CCR7hSW0.mjs";
-import { C as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-7QuSKriJ.mjs";
-import { b as createOpenAIResponseHook, g as resolveOpenAISimpleReasoningEffort, h as resolveOpenAIRequestReasoning, x as createResponseModelTracker, y as createOpenAIProviderAcceptanceHook } from "./openai-transport-params-D7JMUPjf.mjs";
-import { t as createAssistantOutput } from "./assistant-output-D5762GPH.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-CKNmC3vC.mjs";
-import { t as createResponsesPromptEgressObserver } from "./openai-responses-prompt-observer-internal-CefUzh8M.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-CYX18uDk.mjs";
+import { n as buildManagedModelFetch } from "./host-policy-BzZluO6_.mjs";
+import { S as withProviderResponseHook, b as transportAbortError, h as notifyProviderStreamOpened, n as assignTransportErrorDetails } from "./transport-stream-shared-CWGOuLcA.mjs";
+import { C as stripSystemPromptCacheBoundary, n as buildBaseOptions } from "./simple-options-BAu4B54D.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-D-aDYAkJ.mjs";
+import { t as createAssistantOutput } from "./assistant-output-BuhRpLeD.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-NSIJo9jY.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 {
@@ -34,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) {
@@ -130,8 +130,7 @@ async function* parseOpenAIChatGptResponsesSse(response) {
 				try {
 					event = JSON.parse(data);
 				} catch (cause) {
-					if (!(cause instanceof SyntaxError)) throw cause;
-					throw new CodexProtocolError(MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, { cause });
+					throw streamFragmentError(cause, CodexProtocolError);
 				}
 				yield event;
 			}
@@ -163,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");
@@ -375,6 +373,30 @@ const streamOpenAICodexResponses = (model, context, 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 {
@@ -402,22 +424,13 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					const dispatch = {};
 					websocketStarted = 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, (request) => {
+						}, requestOptions, processStream, observePromptEgress, activeAttempt.kind, (request) => {
 							dispatch.request = request;
-						}, 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();
+						}, options?.signal), activeAttempt, CodexApiError);
 						return;
 					} catch (error) {
 						const aborted = activeSignal?.aborted;
@@ -427,7 +440,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 							retriedWebSocketRejection = false;
 							continue;
 						}
-						const reconnectBeforeStart = !websocketStarted && isWebSocketConnectionLimitReachedError(error) || !websocketStarted && dispatch.request?.previous_response_id && error instanceof CodexApiError && error.message === WEBSOCKET_REPLAY_REJECTION;
+						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;
@@ -510,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,
@@ -519,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;
@@ -715,33 +706,18 @@ async function connectWebSocket(url, headers, signal) {
 			reject(error instanceof Error ? error : new Error(String(error)));
 			return;
 		}
-		const onOpen = () => {
+		const settle = (error, aborted = false) => {
 			if (settled) return;
 			settled = true;
 			cleanup();
-			resolve(socket);
-		};
-		const onError = (event) => {
-			const error = extractWebSocketError(event);
-			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);
@@ -854,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 {
@@ -872,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);
@@ -926,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, {
@@ -995,25 +949,7 @@ async function processWebSocketStream(state, authority, body, output, stream, mo
 			...requestBody
 		}));
 		onRequestSent?.(requestBody);
-		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)
-		});
+		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, {
@@ -1023,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
 			};
@@ -1041,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 = () => {
@@ -1056,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-BZfHIaZ7.mjs → openai-completions-BY-kr5IS.mjs}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
-import { k as clampThinkingLevel } from "./host-u3o8XiAp.mjs";
-import { n as buildBaseOptions } from "./simple-options-7QuSKriJ.mjs";
-import { i as convertMessages, n as streamOpenAICompletionsRequest } from "./openai-completions-transport-CuoQfnKV.mjs";
-import { t as requireApiKey } from "./required-api-key-D4kn3252.mjs";
+import { k as clampThinkingLevel } from "./host-Bf3NjYNj.mjs";
+import { n as buildBaseOptions } from "./simple-options-BAu4B54D.mjs";
+import { c as convertMessages, n as streamOpenAICompletionsRequest } from "./openai-completions-transport-v38m71Oq.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

package/dist/{openai-completions-compat-GMN8A0fm.mjs → openai-completions-compat-CYX18uDk.mjs}

@@ -1,5 +1,5 @@
 import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
-import { a as resolveProviderRequestCapabilities } from "./host-policy-BwhNNGQR.mjs";
+import { a as resolveProviderRequestCapabilities } from "./host-policy-BzZluO6_.mjs";
 //#region packages/ai/src/providers/openai-response-format.ts
 const JSON_SCHEMA_RESPONSE_FORMAT_NAME = "openclaw_response";
 const OLLAMA_CLOUD_ORIGIN = "https://ollama.com";
@@ -101,11 +101,12 @@ function resolveOpenAICompletionsCompatDefaults(input) {
 	const isNonStandard = endpointClass === "cerebras-native" || endpointClass === "chutes-native" || endpointClass === "deepseek-native" || endpointClass === "mistral-public" || endpointClass === "opencode-native" || endpointClass === "opencode-go-native" || endpointClass === "xai-native" || isXiaomi || isZai || isDefaultRoute && isDefaultRouteProvider(input.provider, "cerebras", "chutes", "deepseek", "opencode", "xai");
 	const isOpenRouterLike = input.provider === "openrouter" || endpointClass === "openrouter";
 	const isLocalEndpoint = endpointClass === "local";
-	const usesMaxTokens = endpointClass === "chutes-native" || endpointClass === "mistral-public" || knownProviderFamily === "mistral" || isMoonshot || isCloudflareAiGateway || isZai || isTogether || isDefaultRoute && isDefaultRouteProvider(provider, "chutes");
+	const isMistral = knownProviderFamily === "mistral" || endpointClass === "mistral-public";
+	const usesMaxTokens = endpointClass === "chutes-native" || isMistral || isMoonshot || isCloudflareAiGateway || isZai || isTogether || isDefaultRoute && isDefaultRouteProvider(provider, "chutes");
 	return {
-		supportsStore: !isNonStandard && knownProviderFamily !== "mistral" && !usesExplicitProxyLikeEndpoint,
+		supportsStore: !isNonStandard && !isMistral && !usesExplicitProxyLikeEndpoint,
 		supportsDeveloperRole: !isNonStandard && !isMoonshotLike && !usesConfiguredNonOpenAIEndpoint,
-		supportsReasoningEffort: !isZai && !isTogether && knownProviderFamily !== "mistral" && endpointClass !== "xai-native" && !usesExplicitProxyLikeEndpoint,
+		supportsReasoningEffort: !isZai && !isTogether && !isMistral && endpointClass !== "xai-native" && (!usesExplicitProxyLikeEndpoint || input.reasoning === true),
 		supportsUsageInStreaming: supportsOpenAICompletionsStreamingUsageCompat || !isNonStandard && (isLocalEndpoint || !usesConfiguredNonOpenAIEndpoint || supportsNativeStreamingUsageCompat),
 		maxTokensField: usesMaxTokens ? "max_tokens" : "max_completion_tokens",
 		thinkingFormat: isDeepSeek || isXiaomi ? "deepseek" : isZai ? "zai" : isTogether ? "together" : isOpenRouterLike ? "openrouter" : "openai",
@@ -135,6 +136,7 @@ function detectOpenAICompletionsCompat(model, resolveCapabilities) {
 		defaults: resolveOpenAICompletionsCompatDefaults({
 			provider: model.provider,
 			modelId: model.id,
+			reasoning: model.reasoning,
 			baseUrl: model.baseUrl,
 			...capabilities
 		})
@@ -147,21 +149,23 @@ function resolveSessionAffinity(model, detectedFormat) {
 }
 /** Applies explicit model overrides once on top of the canonical transport defaults. */
 function resolveOpenAICompletionsCompat(model, resolveCapabilities) {
-	const { defaults } = detectOpenAICompletionsCompat(model, resolveCapabilities);
+	const { defaults, capabilities } = detectOpenAICompletionsCompat(model, resolveCapabilities);
 	const configured = model.compat;
+	const thinkingFormat = configured?.thinkingFormat ?? defaults.thinkingFormat;
 	return {
 		supportsStore: configured?.supportsStore ?? defaults.supportsStore,
 		supportsDeveloperRole: configured?.supportsDeveloperRole ?? defaults.supportsDeveloperRole,
 		supportsReasoningEffort: configured?.supportsReasoningEffort ?? defaults.supportsReasoningEffort,
 		supportedReasoningEfforts: configured?.supportedReasoningEfforts,
 		reasoningEffortMap: configured?.reasoningEffortMap,
+		reasoningEffortForOff: capabilities.usesExplicitProxyLikeEndpoint && thinkingFormat === "openai" && !configured?.supportedReasoningEfforts?.includes("none") ? null : "none",
 		supportsUsageInStreaming: configured?.supportsUsageInStreaming ?? defaults.supportsUsageInStreaming,
 		maxTokensField: configured?.maxTokensField ?? defaults.maxTokensField,
 		requiresToolResultName: configured?.requiresToolResultName ?? false,
 		requiresAssistantAfterToolResult: configured?.requiresAssistantAfterToolResult ?? false,
 		requiresThinkingAsText: configured?.requiresThinkingAsText ?? false,
 		requiresReasoningContentOnAssistantMessages: configured?.requiresReasoningContentOnAssistantMessages ?? defaults.requiresReasoningContentOnAssistantMessages,
-		thinkingFormat: configured?.thinkingFormat ?? defaults.thinkingFormat,
+		thinkingFormat,
 		openRouterRouting: configured?.openRouterRouting,
 		vercelGatewayRouting: configured?.vercelGatewayRouting ?? {},
 		zaiToolStream: configured?.zaiToolStream ?? false,

package/dist/{openai-completions-compat-BgPg1BRs.d.mts → openai-completions-compat-i-nLZxFy.d.mts}

@@ -1,8 +1,7 @@
-import "./index-D27wAoOr.mjs";
-import { N as OpenAICompletionsCompat, k as Model } from "./types-DvzmWW8J.mjs";
-import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-DiPhRjrc.mjs";
+import "./index-BYDvopUB.mjs";
+import { N as OpenAICompletionsCompat, k as Model } from "./types-Bd2T86VJ.mjs";
+import { a as AiProviderRequestPolicyInput, i as AiProviderRequestCapabilities } from "./host-CTDz7LXD.mjs";
 //#region packages/ai/src/transports/openai-completions-compat.d.ts
-type ProviderRequestCapabilities = AiProviderRequestCapabilities;
 type OpenAICompletionsSessionAffinity = "none" | "openai" | "openrouter";
 type OpenAICompletionsCompatDefaults = {
   supportsStore: boolean;
@@ -20,10 +19,6 @@ type OpenAICompletionsCompatDefaults = {
   sessionAffinityFormat: Exclude<OpenAICompletionsSessionAffinity, "none">;
   supportsLongCacheRetention: boolean;
 };
-type DetectedOpenAICompletionsCompat = {
-  capabilities: ProviderRequestCapabilities;
-  defaults: OpenAICompletionsCompatDefaults;
-};
 type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "cacheControlFormat" | "openRouterRouting" | "sendSessionAffinityHeaders" | "reasoningEffortMap" | "supportedReasoningEfforts"> & Pick<OpenAICompletionsCompat, "reasoningEffortMap" | "supportedReasoningEfforts"> & {
   cacheControlFormat?: OpenAICompletionsCompat["cacheControlFormat"];
   openRouterRouting?: OpenAICompletionsCompat["openRouterRouting"];
@@ -31,6 +26,7 @@ type ResolvedOpenAICompletionsCompat = Omit<Required<OpenAICompletionsCompat>, "
   visibleReasoningDetailTypes: string[];
   requiresNonEmptyUserOrAssistantMessage: boolean;
   configuredSupportsLongCacheRetention?: boolean;
+  reasoningEffortForOff: "none" | null;
 };
 /** Native OpenAI defaults never apply to a configured proxy endpoint. */
 declare function isNativeOpenAIEndpoint(model: {
@@ -54,12 +50,15 @@ declare function resolveOpenAIPromptCacheKeySupport(model: {
   compat?: Pick<OpenAICompletionsCompat, "supportsPromptCacheKey" | "supportsLongCacheRetention"> | null;
 }): boolean;
 /** Detects endpoint capabilities and defaults for an OpenAI-completions model. */
-declare function detectOpenAICompletionsCompat(model: Pick<Model<"openai-completions">, "provider" | "baseUrl" | "id"> & {
+declare function detectOpenAICompletionsCompat(model: Pick<Model<"openai-completions">, "provider" | "baseUrl" | "id" | "reasoning"> & {
   compat?: {
     supportsStore?: boolean;
   } | null;
-}, resolveCapabilities?: (input: AiProviderRequestPolicyInput) => ProviderRequestCapabilities): DetectedOpenAICompletionsCompat;
+}, resolveCapabilities?: (input: AiProviderRequestPolicyInput) => AiProviderRequestCapabilities): {
+  capabilities: AiProviderRequestCapabilities;
+  defaults: OpenAICompletionsCompatDefaults;
+};
 /** Applies explicit model overrides once on top of the canonical transport defaults. */
-declare function resolveOpenAICompletionsCompat(model: Pick<Model<"openai-completions">, "id" | "provider" | "baseUrl" | "compat">, resolveCapabilities?: (input: AiProviderRequestPolicyInput) => ProviderRequestCapabilities): ResolvedOpenAICompletionsCompat;
+declare function resolveOpenAICompletionsCompat(model: Pick<Model<"openai-completions">, "id" | "provider" | "baseUrl" | "compat" | "reasoning">, resolveCapabilities?: (input: AiProviderRequestPolicyInput) => AiProviderRequestCapabilities): ResolvedOpenAICompletionsCompat;
 //#endregion
 export { resolveOpenAICompletionsCompat as a, isOpenAICodexResponsesModel as i, detectOpenAICompletionsCompat as n, resolveOpenAIPromptCacheKeySupport as o, isNativeOpenAIEndpoint as r, usesNativeOpenAICodexResponsesBackend as s, ResolvedOpenAICompletionsCompat as t };