@openclaw/ai 2026.8.1-beta.2 → 2026.8.1-beta.3

package/dist/simple-options-oqsXB6U3.mjs

@@ -0,0 +1,450 @@
+import { r as createAssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-BP7HLLZn.mjs";
+import { i as asOptionalRecord, n as asNullableRecord, t as asNonArrayRecord } from "./record-coerce-DdXsgUd_.mjs";
+import { n as projectProviderError } from "./provider-error-C8mBRJDl.mjs";
+import { t as headersToRecord } from "./headers-B_e4-1J0.mjs";
+//#region packages/ai/src/utils/prompt-cache-stability.ts
+/**
+* Prompt-cache normalization helpers. They keep generated prompt sections
+* deterministic across platform newlines, trailing whitespace, and input
+* ordering.
+*/
+/** Canonicalizes provider tool order without relying on host locale settings. */
+function sortPromptCacheToolsByName(tools) {
+	const compareText = (left, right) => {
+		const leftText = left ?? "";
+		const rightText = right ?? "";
+		return leftText < rightText ? -1 : leftText > rightText ? 1 : 0;
+	};
+	return tools.toSorted((left, right) => compareText(left.wireName ?? left.name, right.wireName ?? right.name) || compareText(left.description, right.description));
+}
+/** Normalize structured prompt text before hashing or snapshot comparison. */
+function normalizeStructuredPromptSection(text) {
+	return sanitizeSurrogates(text).replace(/\r\n?/g, "\n").replace(/[ \t]+$/gm, "").trim();
+}
+/** Normalize, de-dupe, and sort capability ids for stable prompt payloads. */
+function normalizePromptCapabilityIds(capabilities) {
+	const seen = /* @__PURE__ */ new Set();
+	const normalized = [];
+	for (const capability of capabilities) {
+		const value = normalizeLowercaseStringOrEmpty(normalizeStructuredPromptSection(capability));
+		if (!value || seen.has(value)) continue;
+		seen.add(value);
+		normalized.push(value);
+	}
+	return normalized.toSorted((left, right) => left.localeCompare(right));
+}
+//#endregion
+//#region packages/ai/src/utils/system-prompt-cache-boundary.ts
+/**
+* System prompt cache-boundary helpers.
+*
+* Keeps stable prompt prefixes separate from dynamic runtime additions for provider prompt caching.
+*/
+const SYSTEM_PROMPT_CACHE_BOUNDARY = "\n<!-- OPENCLAW_CACHE_BOUNDARY -->\n";
+function stripSystemPromptCacheBoundary(text) {
+	return text.replaceAll(SYSTEM_PROMPT_CACHE_BOUNDARY, "\n");
+}
+function ensureSystemPromptCacheBoundary(systemPrompt) {
+	if (systemPrompt.trim().length === 0) return systemPrompt;
+	return systemPrompt.includes("\n<!-- OPENCLAW_CACHE_BOUNDARY -->\n") ? systemPrompt : `${systemPrompt}${SYSTEM_PROMPT_CACHE_BOUNDARY}`;
+}
+function splitSystemPromptCacheBoundary(text) {
+	const boundaryIndex = text.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+	if (boundaryIndex === -1) return;
+	return {
+		stablePrefix: text.slice(0, boundaryIndex).trimEnd(),
+		dynamicSuffix: text.slice(boundaryIndex + 34).trimStart()
+	};
+}
+function prependSystemPromptAdditionAfterCacheBoundary(params) {
+	const systemPromptAddition = typeof params.systemPromptAddition === "string" ? normalizeStructuredPromptSection(params.systemPromptAddition) : "";
+	if (!systemPromptAddition) return params.systemPrompt;
+	if (params.systemPrompt.trim().length === 0) return systemPromptAddition;
+	const split = splitSystemPromptCacheBoundary(params.systemPrompt);
+	if (!split) return `${systemPromptAddition}\n\n${params.systemPrompt}`;
+	const dynamicSuffix = split.dynamicSuffix ? normalizeStructuredPromptSection(split.dynamicSuffix) : "";
+	if (!dynamicSuffix) return `${split.stablePrefix}${SYSTEM_PROMPT_CACHE_BOUNDARY}${systemPromptAddition}`;
+	return `${split.stablePrefix}${SYSTEM_PROMPT_CACHE_BOUNDARY}${systemPromptAddition}\n\n${dynamicSuffix}`;
+}
+//#endregion
+//#region packages/ai/src/transports/json-unsafe-integers.ts
+/**
+* JSON parsing helpers that preserve integer literals larger than
+* Number.MAX_SAFE_INTEGER as strings before JSON.parse can round them.
+*/
+const MAX_SAFE_INTEGER_ABS_STR = String(Number.MAX_SAFE_INTEGER);
+function isAsciiDigit(ch) {
+	return ch !== void 0 && ch >= "0" && ch <= "9";
+}
+function parseJsonNumberToken(input, start) {
+	let idx = start;
+	if (input[idx] === "-") idx += 1;
+	if (idx >= input.length) return null;
+	if (input[idx] === "0") idx += 1;
+	else if (isAsciiDigit(input[idx]) && input[idx] !== "0") while (isAsciiDigit(input[idx])) idx += 1;
+	else return null;
+	let isInteger = true;
+	if (input[idx] === ".") {
+		isInteger = false;
+		idx += 1;
+		if (!isAsciiDigit(input[idx])) return null;
+		while (isAsciiDigit(input[idx])) idx += 1;
+	}
+	if (input[idx] === "e" || input[idx] === "E") {
+		isInteger = false;
+		idx += 1;
+		if (input[idx] === "+" || input[idx] === "-") idx += 1;
+		if (!isAsciiDigit(input[idx])) return null;
+		while (isAsciiDigit(input[idx])) idx += 1;
+	}
+	return {
+		token: input.slice(start, idx),
+		end: idx,
+		isInteger
+	};
+}
+function isUnsafeIntegerLiteral(token) {
+	const digits = token[0] === "-" ? token.slice(1) : token;
+	if (digits.length < MAX_SAFE_INTEGER_ABS_STR.length) return false;
+	if (digits.length > MAX_SAFE_INTEGER_ABS_STR.length) return true;
+	return digits > MAX_SAFE_INTEGER_ABS_STR;
+}
+/** Quotes integer literals above Number.MAX_SAFE_INTEGER before JSON.parse. */
+function quoteUnsafeIntegerLiterals(input) {
+	let out = "";
+	let inString = false;
+	let escaped = false;
+	let idx = 0;
+	while (idx < input.length) {
+		const ch = input[idx] ?? "";
+		if (inString) {
+			out += ch;
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inString = false;
+			idx += 1;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			out += ch;
+			idx += 1;
+			continue;
+		}
+		if (ch === "-" || isAsciiDigit(ch)) {
+			const parsed = parseJsonNumberToken(input, idx);
+			if (parsed) {
+				if (parsed.isInteger && isUnsafeIntegerLiteral(parsed.token)) out += `"${parsed.token}"`;
+				else out += parsed.token;
+				idx = parsed.end;
+				continue;
+			}
+		}
+		out += ch;
+		idx += 1;
+	}
+	return out;
+}
+/** Parses JSON while preserving unsafe integer literals as strings. */
+function parseJsonPreservingUnsafeIntegers(input) {
+	return JSON.parse(quoteUnsafeIntegerLiterals(input));
+}
+/** Parses or accepts an object while preserving unsafe integer literals in string input. */
+function parseJsonObjectPreservingUnsafeIntegers(value) {
+	if (typeof value === "string") try {
+		return asNullableRecord(parseJsonPreservingUnsafeIntegers(value));
+	} catch {
+		return null;
+	}
+	return asNullableRecord(value);
+}
+//#endregion
+//#region packages/ai/src/transports/transport-stream-shared.ts
+const EMPTY_TOOL_RESULT_TEXT = "(no output)";
+const MALFORMED_TOOL_CALL_TERMINAL_ERROR_MESSAGE = "Provider completed tool call with malformed JSON arguments";
+function sanitizeTransportPayloadText(text) {
+	if (typeof text !== "string") return "";
+	return sanitizeSurrogates(text);
+}
+function sanitizeNonEmptyTransportPayloadText(text, fallback = EMPTY_TOOL_RESULT_TEXT) {
+	const sanitized = sanitizeTransportPayloadText(text);
+	return sanitized.trim().length > 0 ? sanitized : fallback;
+}
+function coerceTransportToolCallArguments(argumentsValue) {
+	const argumentsRecord = asOptionalRecord(argumentsValue);
+	if (argumentsRecord) return argumentsRecord;
+	if (typeof argumentsValue === "string") try {
+		return asNonArrayRecord(JSON.parse(argumentsValue));
+	} catch {}
+	return {};
+}
+/** Admit only complete object-shaped terminal tool arguments; partial parsing is preview-only. */
+function parseTerminalToolCallArguments(value, errorMessage = MALFORMED_TOOL_CALL_TERMINAL_ERROR_MESSAGE) {
+	const parsed = parseJsonObjectPreservingUnsafeIntegers(value);
+	if (!parsed) throw new Error(errorMessage);
+	return parsed;
+}
+/** Validate a complete sibling set before mutating any call into executable state. */
+function finalizeTerminalToolCallArguments(calls, readArguments, errorMessage) {
+	const validated = calls.map((call) => [call, parseTerminalToolCallArguments(readArguments(call), errorMessage)]);
+	for (const [call, argumentsValue] of validated) call.arguments = argumentsValue;
+}
+function mergeTransportHeaders(...headerSources) {
+	const merged = {};
+	for (const headers of headerSources) if (headers) Object.assign(merged, headers);
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeTransportMetadata(payload, metadata) {
+	if (!metadata || Object.keys(metadata).length === 0) return payload;
+	const existingMetadata = asOptionalRecord(payload.metadata);
+	return {
+		...payload,
+		metadata: {
+			...existingMetadata,
+			...metadata
+		}
+	};
+}
+function createEmptyTransportUsage() {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+function createWritableTransportEventStream() {
+	const eventStream = createAssistantMessageEventStream();
+	return {
+		eventStream,
+		stream: eventStream
+	};
+}
+/**
+* Abort error to surface for an aborted `signal`.
+*
+* Rethrows the caller's abort reason only when it carries a `code`, so that code
+* survives into `errorCode` on the persisted assistant message and consumers can
+* recognize an abort's origin without matching error text. A default
+* `abort()` reason is an uncoded DOMException that carries nothing the synthetic
+* error does not, so it keeps the "Request was aborted" text every transport
+* already emits rather than churning it.
+*/
+function transportAbortError(signal) {
+	const reason = signal?.reason;
+	return reason instanceof Error && typeof reason.code === "string" ? reason : /* @__PURE__ */ new Error("Request was aborted");
+}
+const providerAcceptanceObserver = Symbol("openclaw.providerAcceptanceObserver");
+function readProviderAcceptanceObserver(options) {
+	if (options === null || typeof options !== "object") return;
+	const descriptor = Object.getOwnPropertyDescriptor(options, providerAcceptanceObserver);
+	const value = descriptor && "value" in descriptor ? descriptor.value : void 0;
+	return isProviderAcceptanceObserver(value) ? value : void 0;
+}
+function isProviderAcceptanceObserver(value) {
+	return typeof value === "function";
+}
+function writeProviderAcceptanceObserver(options, observer) {
+	Object.defineProperty(options, providerAcceptanceObserver, {
+		configurable: true,
+		enumerable: true,
+		value: observer
+	});
+	return options;
+}
+/** Attach an OpenClaw-internal provider acceptance observer to one model call. */
+function withProviderAcceptanceObserver(options, observer) {
+	const existing = readProviderAcceptanceObserver(options);
+	return writeProviderAcceptanceObserver(options, existing ? (acceptance) => {
+		observer(acceptance);
+		existing(acceptance);
+	} : observer);
+}
+/** Preserve the private provider acceptance observer when a built-in wrapper rebuilds options. */
+function copyProviderAcceptanceObserver(source, target) {
+	const observer = readProviderAcceptanceObserver(source);
+	return observer ? writeProviderAcceptanceObserver(target, observer) : target;
+}
+async function awaitProviderLifecycleCallback(callback, signal) {
+	if (signal?.aborted) throw transportAbortError(signal);
+	if (!callback) return;
+	const callbackPromise = Promise.resolve().then(callback);
+	if (!signal) {
+		await callbackPromise;
+		return;
+	}
+	let onAbort;
+	try {
+		await Promise.race([callbackPromise, new Promise((_resolve, reject) => {
+			onAbort = () => reject(transportAbortError(signal));
+			signal.addEventListener("abort", onAbort, { once: true });
+		})]);
+	} finally {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+	if (signal.aborted) throw transportAbortError(signal);
+}
+function startProviderStreamCancellation(cancelStream, error) {
+	const reason = error instanceof Error ? error : new Error(String(error));
+	try {
+		Promise.resolve(cancelStream(reason)).catch(() => void 0);
+	} catch {}
+}
+async function awaitProviderLifecycleWithCleanup(params) {
+	try {
+		await params.run();
+	} catch (error) {
+		startProviderStreamCancellation(params.cancelStream, error);
+		throw error;
+	}
+}
+/** Report observed HTTP metadata; rejected responses use only onResponse. */
+async function notifyProviderHttpMetadata(params) {
+	const observer = readProviderAcceptanceObserver(params.options);
+	if (!observer && !params.options?.onResponse) return;
+	const { status, headers } = params.response;
+	const signal = params.signal ?? params.options?.signal;
+	const accepted = status >= 200 && status < 300;
+	await awaitProviderLifecycleWithCleanup({
+		cancelStream: params.cancelStream,
+		run: async () => {
+			await awaitProviderLifecycleCallback(accepted && observer ? () => observer({
+				kind: "http_response",
+				status,
+				headers
+			}) : void 0, signal);
+			await awaitProviderLifecycleCallback(params.options?.onResponse ? () => params.options?.onResponse?.({
+				status,
+				headers
+			}, params.model) : void 0, signal);
+		}
+	});
+}
+/** Report a real HTTP response before body consumption. */
+async function notifyProviderHttpResponse(params) {
+	await notifyProviderHttpMetadata({
+		options: params.options,
+		response: {
+			status: params.response.status,
+			headers: headersToRecord(params.response.headers)
+		},
+		model: params.model,
+		signal: params.signal,
+		cancelStream: (reason) => {
+			if (params.cancelStream) startProviderStreamCancellation(params.cancelStream, reason);
+			return params.response.body?.cancel(reason);
+		}
+	});
+}
+/** Report an accepted SDK stream when the SDK does not expose HTTP metadata. */
+async function notifyProviderStreamOpened(params) {
+	const observer = readProviderAcceptanceObserver(params.options);
+	if (!observer) return;
+	await awaitProviderLifecycleWithCleanup({
+		cancelStream: params.cancelStream,
+		run: () => awaitProviderLifecycleCallback(() => observer({ kind: "provider_stream_opened" }), params.signal ?? params.options?.signal)
+	});
+}
+/** Run a provider-response hook before start/body consumption inside the first-event deadline. */
+function withProviderResponseHook(params) {
+	return { async *[Symbol.asyncIterator]() {
+		try {
+			await awaitProviderLifecycleCallback(params.hook, params.signal);
+		} catch (error) {
+			params.abort(error instanceof Error ? error : new Error(String(error)));
+			throw error;
+		}
+		if (params.signal.aborted) throw transportAbortError(params.signal);
+		params.onReady?.();
+		if (params.stream) yield* params.stream;
+	} };
+}
+function finalizeTransportStream(params) {
+	const { stream, output, signal } = params;
+	if (signal?.aborted) throw transportAbortError(signal);
+	if (output.stopReason === "aborted" || output.stopReason === "error") throw new Error(output.errorMessage ?? "An unknown error occurred");
+	stream.push({
+		type: "done",
+		reason: output.stopReason,
+		message: output
+	});
+	stream.end();
+}
+/** @deprecated Use projectProviderError. v2026.7.2-beta.5 compatibility; remove after 2026.10. */
+function assignTransportErrorDetails(output, error, signal) {
+	const projection = projectProviderError(error, signal);
+	Object.assign(output, projection);
+	return projection;
+}
+function failTransportStream(params) {
+	const { stream, output, signal, error, cleanup } = params;
+	cleanup?.();
+	const projection = assignTransportErrorDetails(output, error, signal);
+	stream.push({
+		type: "error",
+		reason: projection.stopReason,
+		error: output
+	});
+	stream.end();
+}
+//#endregion
+//#region packages/ai/src/providers/simple-options.ts
+function buildBaseOptions(model, options, apiKey) {
+	const firstEventOptions = options;
+	return copyProviderAcceptanceObserver(options, {
+		temperature: options?.temperature,
+		maxTokens: options?.maxTokens,
+		stop: options?.stop,
+		signal: options?.signal,
+		apiKey: apiKey || options?.apiKey,
+		transport: options?.transport,
+		cacheRetention: options?.cacheRetention,
+		sessionId: options?.sessionId,
+		promptCacheKey: options?.promptCacheKey,
+		headers: options?.headers,
+		onPayload: options?.onPayload,
+		onResponse: options?.onResponse,
+		timeoutMs: options?.timeoutMs,
+		firstEventTimeoutMs: firstEventOptions?.firstEventTimeoutMs,
+		onFirstEventTimeout: firstEventOptions?.onFirstEventTimeout,
+		maxRetries: options?.maxRetries,
+		maxRetryDelayMs: options?.maxRetryDelayMs,
+		metadata: options?.metadata
+	});
+}
+function clampMaxTokensToModel(model, requestedMaxTokens) {
+	return requestedMaxTokens === void 0 ? void 0 : Math.max(1, Math.min(requestedMaxTokens, model.maxTokens));
+}
+function clampReasoning(effort) {
+	return effort === "xhigh" ? "high" : effort;
+}
+function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+	const budgets = {
+		minimal: 1024,
+		low: 2048,
+		medium: 8192,
+		high: 16384,
+		max: 32768,
+		...customBudgets
+	};
+	const minOutputTokens = 1024;
+	let thinkingBudget = budgets[clampReasoning(reasoningLevel)];
+	const maxTokens = baseMaxTokens === void 0 ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+	if (maxTokens <= thinkingBudget) thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
+	return {
+		maxTokens,
+		thinkingBudget
+	};
+}
+//#endregion
+export { splitSystemPromptCacheBoundary as A, withProviderResponseHook as C, SYSTEM_PROMPT_CACHE_BOUNDARY as D, quoteUnsafeIntegerLiterals as E, normalizePromptCapabilityIds as M, normalizeStructuredPromptSection as N, ensureSystemPromptCacheBoundary as O, sortPromptCacheToolsByName as P, withProviderAcceptanceObserver as S, parseJsonPreservingUnsafeIntegers as T, notifyProviderStreamOpened as _, assignTransportErrorDetails as a, sanitizeTransportPayloadText as b, createEmptyTransportUsage as c, finalizeTerminalToolCallArguments as d, finalizeTransportStream as f, notifyProviderHttpResponse as g, notifyProviderHttpMetadata as h, clampReasoning as i, stripSystemPromptCacheBoundary as j, prependSystemPromptAdditionAfterCacheBoundary as k, createWritableTransportEventStream as l, mergeTransportMetadata as m, buildBaseOptions as n, coerceTransportToolCallArguments as o, mergeTransportHeaders as p, clampMaxTokensToModel as r, copyProviderAcceptanceObserver as s, adjustMaxTokensForThinking as t, failTransportStream as u, parseTerminalToolCallArguments as v, parseJsonObjectPreservingUnsafeIntegers as w, transportAbortError as x, sanitizeNonEmptyTransportPayloadText as y };

package/dist/{tool-schema-json-projection-q5d7QX5c.mjs → tool-schema-json-projection-FEr-jOoZ.mjs}

@@ -1,4 +1,4 @@
-import { n as getAiTransportHost } from "./host-DTqNc7ad.mjs";
+import { n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
 import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
 import { types } from "node:util";
 //#region packages/ai/src/transports/host-policy.ts
@@ -8,14 +8,23 @@ function buildGuardedModelFetch(model, timeoutMs, options) {
 	if (timeoutMs !== void 0) return host.buildModelFetch(model, timeoutMs) ?? globalThis.fetch;
 	return host.buildModelFetch(model) ?? globalThis.fetch;
 }
-function resolveProviderEndpoint(baseUrl) {
-	return { endpointClass: getAiTransportHost().resolveProviderEndpointClass(baseUrl) };
+function resolveProviderEndpoint(model) {
+	return { endpointClass: getAiTransportHost().resolveProviderRequestCapabilities({
+		baseUrl: model.baseUrl,
+		model
+	}).endpointClass };
 }
-function resolveProviderRequestCapabilities(input) {
-	return getAiTransportHost().resolveProviderRequestCapabilities(input);
+function resolveProviderRequestCapabilities(input, model) {
+	return getAiTransportHost().resolveProviderRequestCapabilities({
+		...input,
+		model
+	});
 }
-function resolveProviderRequestPolicyConfig(input) {
-	return { headers: getAiTransportHost().resolveProviderRequestHeaders(input) };
+function resolveProviderRequestPolicyConfig(model, input) {
+	return { headers: getAiTransportHost().resolveProviderRequestHeaders({
+		...input,
+		model
+	}) };
 }
 function resolveModelRequestTimeoutMs(model, timeoutMs) {
 	return timeoutMs ?? getAiTransportHost().resolveModelRequestTimeoutMs(model);

package/dist/{transport-utils-DJqkxbhC.mjs → transport-utils-Bv0FHkd0.mjs}

@@ -1,5 +1,5 @@
 import { a as normalizeOptionalString } from "./string-coerce-fsri9iCu.mjs";
-import { n as getAiTransportHost } from "./host-DTqNc7ad.mjs";
+import { n as getAiTransportHost } from "./host-DF_yxOsA.mjs";
 import { t as truncateUtf16Safe } from "./utf16-slice-CvGodqok.mjs";
 import { a as parseStrictFiniteNumber, n as asFiniteNumberInRange, o as parseStrictNonNegativeInteger } from "./number-coercion-H9qHik3g.mjs";
 import { parseRetryAfterHttpDateMs } from "./internal/retry-after.mjs";