@openclaw/ai 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/{openai-chatgpt-responses-DP63Qt01.mjs → openai-chatgpt-responses-CedIj0hk.mjs}

@@ -1,15 +1,18 @@
-import { n as getEnvApiKey } from "./env-api-keys-DnhYpc27.mjs";
+import { n as getEnvApiKey } from "./env-api-keys-DrgeBuva.mjs";
 import { i as formatThrownValue, n as createAssistantMessageDiagnostic, t as appendAssistantMessageDiagnostic } from "./diagnostics-COpOtRwq.mjs";
 import { t as AssistantMessageEventStream } from "./event-stream-D8n2uFee.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-4t713IeR.mjs";
-import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
-import { l as buildBaseOptions, w as stripSystemPromptCacheBoundary } from "./transform-messages-eb6lxDLB.mjs";
-import { M as supportsOpenAITemperature, a as resolveResponsesReasoningEffort, i as processResponsesStream, n as convertResponsesMessages, s as convertResponsesToolPayload } from "./openai-responses-shared-CwnGU0KW.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-WHf2nuOI.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-XYGZcgO8.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
+import { A as buildBaseOptions, o as stripSystemPromptCacheBoundary, t as inspectTlsCertificateError } from "./shared-CdjNZd35.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-BbMELSI4.mjs";
+import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
 import { i as registerSessionResourceCleanup, n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-DhAAzLkj.mjs";
+import { i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-C3OgBjIk.mjs";
 import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
+import { _t as supportsOpenAITemperature, a as convertResponsesMessages, l as convertResponsesToolPayload, s as resolveResponsesReasoningEffort, y as processResponsesStream } from "./openai-D3PD6PE-.mjs";
 //#region packages/ai/src/internal/retry-sleep.ts
 function sleepWithAbort(ms, signal) {
 	return new Promise((resolve, reject) => {
@@ -58,6 +61,22 @@ 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 resolveRequestTimeoutMs(options) {
 	const timeoutMs = options?.timeoutMs;
 	return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? resolveTimerTimeoutMs(timeoutMs, 1) : void 0;
@@ -151,7 +170,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 new Error("Request was aborted");
+						if (activeSignal?.aborted) throw transportAbortError(activeSignal);
 						stream.push({
 							type: "done",
 							reason: output.stopReason,
@@ -187,60 +206,43 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			let lastError;
 			const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
 			for (let attempt = 0; attempt <= maxRetries; attempt++) {
-				if (activeSignal?.aborted) throw new Error("Request was aborted");
+				if (activeSignal?.aborted) throw transportAbortError(activeSignal);
+				let attemptResponse;
+				let errorText;
 				try {
-					response = await fetch(resolveCodexUrl(model.baseUrl), {
+					attemptResponse = await fetch(resolveCodexUrl(model.baseUrl), {
 						method: "POST",
 						headers: sseHeaders,
 						body: sseBody,
 						signal: activeSignal
 					});
+					response = attemptResponse;
 					await options?.onResponse?.({
-						status: response.status,
-						headers: headersToRecord(response.headers)
+						status: attemptResponse.status,
+						headers: headersToRecord(attemptResponse.headers)
 					}, model);
-					if (response.ok) break;
-					const errorText = await readChatGptResponsesErrorTextLimited(response);
-					if (attempt < maxRetries && 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 {
-									const retryAt = parseRetryAfterHttpDateMs(trimmedRetryAfter);
-									if (retryAt !== void 0) delayMs = clampTimerTimeoutMs(retryAt - Date.now(), 0) ?? delayMs;
-								}
-							}
-						}
-						await sleepWithAbort(delayMs, activeSignal);
-						continue;
-					}
-					const info = await parseErrorResponse(new Response(errorText, {
-						status: response.status,
-						statusText: response.statusText
-					}));
-					throw new Error(info.friendlyMessage || info.message);
+					if (attemptResponse.ok) break;
+					errorText = await readChatGptResponsesErrorTextLimited(attemptResponse);
 				} catch (error) {
 					if (error instanceof Error) {
 						if (isRequestTimeoutError(error, options?.signal, requestTimeoutSignal, requestTimeoutMs) && requestTimeoutMs !== void 0) throw formatRequestTimeoutError(requestTimeoutMs, error);
 						if (error.name === "AbortError" || error.message === "Request was aborted") throw new Error("Request was aborted", { cause: error });
 						if (error.name === "TimeoutError" && requestTimeoutMs !== void 0) throw new Error(`Request timed out after ${requestTimeoutMs}ms`, { cause: error });
 					}
-					lastError = error instanceof Error ? error : new Error(String(error));
-					if (attempt < maxRetries && !lastError.message.includes("usage limit")) {
+					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);
 						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");
@@ -249,7 +251,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 				partial: output
 			});
 			await processStream(response, output, stream, model, options, firstEventAbort.abort);
-			if (activeSignal?.aborted) throw new Error("Request was aborted");
+			if (activeSignal?.aborted) throw transportAbortError(activeSignal);
 			stream.push({
 				type: "done",
 				reason: output.stopReason,
@@ -359,6 +361,7 @@ 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)
 	});
@@ -796,7 +799,7 @@ async function* parseWebSocket(socket, signal) {
 	signal?.addEventListener("abort", onAbort);
 	try {
 		while (true) {
-			if (signal?.aborted) throw new Error("Request was aborted");
+			if (signal?.aborted) throw transportAbortError(signal);
 			const next = queue.shift();
 			if (next !== void 0) {
 				yield next;
@@ -807,7 +810,7 @@ async function* parseWebSocket(socket, signal) {
 				pending = resolve;
 			});
 		}
-		if (failed) throw toLintErrorObject(failed, "Non-Error thrown");
+		if (failed) throw toErrorObject(failed, "Non-Error thrown");
 		if (!sawCompletion) throw new Error("WebSocket stream closed before response.completed");
 	} finally {
 		socket.removeEventListener("message", onMessage);
@@ -869,7 +872,7 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 	const fullBody = body;
 	const requestBody = useCachedContext && entry ? buildCachedWebSocketRequestBody(entry, fullBody) : fullBody;
 	try {
-		if (options?.signal?.aborted) throw new Error("Request was aborted");
+		if (options?.signal?.aborted) throw transportAbortError(options.signal);
 		socket.send(JSON.stringify({
 			type: "response.create",
 			...requestBody
@@ -879,6 +882,7 @@ 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,15 +940,14 @@ async function readChatGptResponsesErrorTextLimited(response) {
 	}
 	return text;
 }
-async function parseErrorResponse(response) {
-	const raw = await readChatGptResponsesErrorTextLimited(response);
-	let message = raw || response.statusText || "Request failed";
+function parseErrorResponseText(raw, status, statusText) {
+	let message = raw || 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) || response.status === 429) {
+			if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || status === 429) {
 				const plan = err.plan_type ? ` (${err.plan_type.toLowerCase()} plan)` : "";
 				const mins = err.resets_at ? Math.max(0, Math.round((err.resets_at * 1e3 - Date.now()) / 6e4)) : void 0;
 				friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${mins !== void 0 ? ` Try again in ~${mins} min.` : ""}`.trim();
@@ -1003,12 +1006,5 @@ 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 };