@openclaw/ai 2026.7.2-beta.4 → 2026.7.2-beta.6

package/dist/number-coercion-DvG7SNMg.mjs

@@ -0,0 +1,129 @@
+import { a as requiresClaudeMandatoryAdaptiveThinking, l as resolveClaudeNativeThinkingLevelMap } from "./src-QkygScBs.mjs";
+//#region packages/ai/src/model-utils.ts
+/** Calculates and stores model cost fields from token usage and per-million pricing. */
+function calculateCost(model, usage) {
+	const cacheWrite1h = Math.min(usage.cacheWrite, Math.max(0, usage.cacheWrite1h ?? 0));
+	const cacheWrite5m = usage.cacheWrite - cacheWrite1h;
+	usage.cost.input = model.cost.input / 1e6 * usage.input;
+	usage.cost.output = model.cost.output / 1e6 * usage.output;
+	usage.cost.cacheRead = model.cost.cacheRead / 1e6 * usage.cacheRead;
+	usage.cost.cacheWrite = (model.cost.cacheWrite * cacheWrite5m + model.cost.input * 2 * cacheWrite1h) / 1e6;
+	usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+	return usage.cost;
+}
+/** Replaces the catalog estimate when the provider reports an authoritative billed total. */
+function applyProviderReportedUsageCost(usage, reportedCost) {
+	if (typeof reportedCost !== "number" || !Number.isFinite(reportedCost) || reportedCost < 0) return;
+	usage.cost.total = reportedCost;
+	usage.cost.totalOrigin = "provider-billed";
+}
+const EXTENDED_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function resolveThinkingLevelMap(model) {
+	return model.api === "anthropic-messages" ? resolveClaudeNativeThinkingLevelMap(model) ?? model.thinkingLevelMap : model.thinkingLevelMap;
+}
+/** Returns thinking levels exposed by a reasoning-capable model. */
+function getSupportedThinkingLevels(model) {
+	const mandatoryAdaptiveContract = model.api === "anthropic-messages" && requiresClaudeMandatoryAdaptiveThinking(model);
+	if (!model.reasoning && !mandatoryAdaptiveContract) return ["off"];
+	const thinkingLevelMap = resolveThinkingLevelMap(model);
+	return EXTENDED_THINKING_LEVELS.filter((level) => {
+		const mapped = thinkingLevelMap?.[level];
+		if (mapped === null) return false;
+		if (level === "xhigh" || level === "max") return mapped !== void 0;
+		return true;
+	});
+}
+/** Clamps a requested thinking level to the closest supported level for a model. */
+function clampThinkingLevel(model, level) {
+	const availableLevels = getSupportedThinkingLevels(model);
+	if (availableLevels.includes(level)) return level;
+	const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);
+	if (requestedIndex === -1) return availableLevels[0] ?? "off";
+	const thinkingLevelMap = resolveThinkingLevelMap(model);
+	if ((level === "xhigh" || level === "max") && thinkingLevelMap?.[level] === null) {
+		for (const candidate of EXTENDED_THINKING_LEVELS.slice(0, requestedIndex).toReversed()) if (availableLevels.includes(candidate)) return candidate;
+	}
+	for (const candidate of EXTENDED_THINKING_LEVELS.slice(requestedIndex)) if (availableLevels.includes(candidate)) return candidate;
+	for (const candidate of EXTENDED_THINKING_LEVELS.slice(0, requestedIndex).toReversed()) if (availableLevels.includes(candidate)) return candidate;
+	return availableLevels[0] ?? "off";
+}
+/** Compares model identity by provider and id. */
+function modelsAreEqual(a, b) {
+	if (!a || !b) return false;
+	return a.id === b.id && a.provider === b.provider;
+}
+//#endregion
+//#region packages/normalization-core/src/number-coercion.ts
+/** Returns a number only when the input is already finite. */
+function asFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+/** Returns a finite number only when it satisfies the supplied inclusive/exclusive bounds. */
+function asFiniteNumberInRange(value, range) {
+	const number = asFiniteNumber(value);
+	if (number === void 0) return;
+	if (range.min !== void 0) {
+		if (range.minExclusive ? number <= range.min : number < range.min) return;
+	}
+	if (range.max !== void 0) {
+		if (range.maxExclusive ? number >= range.max : number > range.max) return;
+	}
+	return number;
+}
+function normalizeNumericString(value) {
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+/** Parses only safe integer numbers or base-10 integer strings. */
+function parseStrictInteger(value) {
+	if (typeof value === "number") return Number.isSafeInteger(value) ? value : void 0;
+	if (typeof value !== "string") return;
+	const normalized = normalizeNumericString(value);
+	if (!normalized || !/^[+-]?\d+$/.test(normalized)) return;
+	const parsed = Number(normalized);
+	return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+/** Parses only finite decimal/scientific string tokens, rejecting partial numbers. */
+function parseStrictFiniteNumber(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (typeof value !== "string") return;
+	const normalized = normalizeNumericString(value);
+	if (!normalized || !/^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))(?:e[+-]?\d+)?$/i.test(normalized)) return;
+	const parsed = Number(normalized);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+/** Conservative upper bound for Node timer delays. */
+const MAX_TIMER_TIMEOUT_MS = 2147e6;
+/** Clamps finite millisecond values into the Node-safe timer range. */
+function clampTimerTimeoutMs(valueMs, minMs = 1) {
+	const value = asFiniteNumber(valueMs);
+	if (value === void 0) return;
+	return Math.min(Math.max(Math.floor(value), Math.max(1, Math.floor(minMs))), MAX_TIMER_TIMEOUT_MS);
+}
+/** Resolves arbitrary timeout input with fallback and minimum timer bounds. */
+function resolveTimerTimeoutMs(valueMs, fallbackMs, minMs = 1) {
+	const value = asFiniteNumber(valueMs) ?? asFiniteNumber(fallbackMs);
+	const min = Math.max(0, Math.floor(minMs));
+	if (value === void 0) return min;
+	return Math.min(Math.max(Math.floor(value), min), MAX_TIMER_TIMEOUT_MS);
+}
+/** Parses strict positive integer values from numbers or strings. */
+function parseStrictPositiveInteger(value) {
+	const parsed = parseStrictInteger(value);
+	return parsed !== void 0 && parsed > 0 ? parsed : void 0;
+}
+/** Parses strict non-negative integer values from numbers or strings. */
+function parseStrictNonNegativeInteger(value) {
+	const parsed = parseStrictInteger(value);
+	return parsed !== void 0 && parsed >= 0 ? parsed : void 0;
+}
+//#endregion
+export { parseStrictPositiveInteger as a, calculateCost as c, modelsAreEqual as d, parseStrictNonNegativeInteger as i, clampThinkingLevel as l, clampTimerTimeoutMs as n, resolveTimerTimeoutMs as o, parseStrictFiniteNumber as r, applyProviderReportedUsageCost as s, asFiniteNumberInRange as t, getSupportedThinkingLevels as u };

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

@@ -1,15 +1,21 @@
 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-XYGZcgO8.mjs";
-import { D as buildBaseOptions, a as stripSystemPromptCacheBoundary } from "./system-prompt-cache-boundary-CbHeV4_l.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 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 { i as registerSessionResourceCleanup, n as resolveOpenAICodexAccountId } from "./openai-chatgpt-jwt-DhAAzLkj.mjs";
-import { d as resolveTimerTimeoutMs, i as getFirstStreamEventTimeoutMs, r as getFirstStreamEventTimeoutHandler, s as clampTimerTimeoutMs, t as createFirstStreamEventAbortController } from "./stream-first-event-timeout-DP4xEyBY.mjs";
 import { t as createSseByteGuard } from "./streaming-byte-guard-BrbkbwUu.mjs";
-import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";
-import { L as supportsOpenAITemperature, a as resolveResponsesReasoningEffort, i as processResponsesStream, n as convertResponsesMessages, s as convertResponsesToolPayload } from "./openai-responses-shared-CzCurmY1.mjs";
-import { a as clampOpenAIPromptCacheKey } from "./openai-tool-projection-ITOU9bG1.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) => {
@@ -144,10 +150,6 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			const nextBody = await options?.onPayload?.(body, model);
 			if (nextBody !== void 0) body = nextBody;
 			const sessionId = clampOpenAIPromptCacheKey(options?.sessionId);
-			const websocketRequestId = sessionId || createCodexRequestId();
-			const sseHeaders = buildSSEHeaders(modelHeaders, optionHeaders, accountId, apiKey, 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);
@@ -159,6 +161,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 			const transport = options?.transport || "auto";
 			const websocketDisabledForSession = transport === "auto" && isWebSocketSseFallbackActive(options?.sessionId);
 			if (transport !== "sse" && !websocketDisabledForSession) {
+				const websocketHeaders = buildWebSocketHeaders(modelHeaders, optionHeaders, accountId, apiKey, sessionId || createCodexRequestId());
 				let websocketStarted = false;
 				let retriedWebSocketConnectionLimit = false;
 				while (true) {
@@ -167,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,
@@ -188,7 +191,7 @@ const streamOpenAICodexResponses = (model, context, options) => {
 							fallbackTransport: transport === "auto" && !websocketStarted ? "sse" : void 0,
 							eventsEmitted: websocketStarted,
 							phase: websocketStarted ? "after_message_stream_start" : "before_message_stream_start",
-							requestBytes: new TextEncoder().encode(bodyJson).byteLength
+							requestBytes: new TextEncoder().encode(JSON.stringify(body)).byteLength
 						}));
 						if (transport === "auto" && options?.sessionId) websocketSseFallbackSessions.add(options.sessionId);
 						if (websocketStarted || transport !== "auto") throw error;
@@ -196,6 +199,8 @@ const streamOpenAICodexResponses = (model, context, options) => {
 					}
 				}
 			}
+			const sseHeaders = buildSSEHeaders(modelHeaders, optionHeaders, accountId, apiKey, sessionId);
+			const bodyJson = JSON.stringify(body);
 			const compressedBody = model.provider === "openai" && !sseHeaders.has("content-encoding") ? compressRequestBodyZstd(bodyJson) : null;
 			if (compressedBody) sseHeaders.set("content-encoding", "zstd");
 			const sseBody = compressedBody ?? bodyJson;
@@ -203,7 +208,7 @@ 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 {
@@ -226,8 +231,9 @@ const streamOpenAICodexResponses = (model, context, options) => {
 						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;
 					}
@@ -247,7 +253,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,
@@ -357,6 +363,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)
 	});
@@ -549,12 +556,15 @@ 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");
-		websocketSessionCache.delete(sessionId);
+		deleteOwnedWebSocketSession(sessionId, entry);
 	}, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
 async function connectWebSocket(url, headers, signal) {
@@ -645,7 +655,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 				release: ({ keep } = {}) => {
 					if (!keep || !isWebSocketReusable(cached.socket)) {
 						closeWebSocketSilently(cached.socket);
-						websocketSessionCache.delete(sessionId);
+						deleteOwnedWebSocketSession(sessionId, cached);
 						return;
 					}
 					cached.busy = false;
@@ -681,7 +691,7 @@ async function acquireWebSocket(url, headers, sessionId, signal) {
 			if (!keep || !isWebSocketReusable(entry.socket)) {
 				closeWebSocketSilently(entry.socket);
 				if (entry.idleTimer) clearTimeout(entry.idleTimer);
-				if (websocketSessionCache.get(sessionId) === entry) websocketSessionCache.delete(sessionId);
+				deleteOwnedWebSocketSession(sessionId, entry);
 				return;
 			}
 			entry.busy = false;
@@ -794,7 +804,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;
@@ -805,7 +815,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);
@@ -867,7 +877,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
@@ -877,6 +887,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)
 		});
@@ -1000,12 +1011,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 };