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

package/dist/provider-types.mjs

@@ -0,0 +1,8 @@
+//#region packages/ai/src/provider-types.ts
+const PROVIDER_CONTEXT_HANDOFF = Symbol("providerContextHandoff");
+/** Resolves provider-only context without widening the canonical call contract. */
+async function resolveProviderContext(context, options) {
+	return options?.[PROVIDER_CONTEXT_HANDOFF]?.() ?? context;
+}
+//#endregion
+export { PROVIDER_CONTEXT_HANDOFF, resolveProviderContext };

package/dist/providers.d.mts

@@ -1,4 +1,4 @@
-import { n as ApiRegistry } from "./api-registry-EpJoVwM1.mjs";
+import { n as ApiRegistry } from "./api-registry-k3zTz0cV.mjs";
 import { n as clampOpenAIPromptCacheKey, t as OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH } from "./openai-prompt-cache-2uo_1OR1.mjs";
 
 //#region packages/ai/src/providers/register-builtins.d.ts

package/dist/providers.mjs

@@ -1,15 +1,14 @@
-import { t as AssistantMessageEventStream } from "./event-stream-CEV9t6da.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { n as projectProviderError } from "./provider-error-BUwEnjXq.mjs";
 import { n as clampOpenAIPromptCacheKey, t as OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH } from "./openai-prompt-cache-mZTCdRPo.mjs";
 //#region packages/ai/src/providers/register-builtins.ts
 /** Source id used for built-in API provider registrations. */
 const BUILT_IN_API_PROVIDER_SOURCE_ID = "core:built-in";
-function forwardStream(target, source) {
-	(async () => {
-		for await (const event of source) target.push(event);
-		target.end();
-	})();
+async function forwardStream(target, source) {
+	for await (const event of source) target.push(event);
+	target.end();
 }
-function createLazyLoadErrorMessage(model, error) {
+function createLazyLoadErrorMessage(model, error, signal) {
 	return {
 		role: "assistant",
 		content: [],
@@ -30,8 +29,7 @@ function createLazyLoadErrorMessage(model, error) {
 				total: 0
 			}
 		},
-		stopReason: "error",
-		errorMessage: error instanceof Error ? error.message : String(error),
+		...projectProviderError(error, signal),
 		timestamp: Date.now()
 	};
 }
@@ -39,10 +37,10 @@ function createLazyStream(load, select) {
 	return (model, context, options) => {
 		const outer = new AssistantMessageEventStream();
 		load().then((streams) => forwardStream(outer, select(streams)(model, context, options))).catch((error) => {
-			const message = createLazyLoadErrorMessage(model, error);
+			const message = createLazyLoadErrorMessage(model, error, options?.signal);
 			outer.push({
 				type: "error",
-				reason: "error",
+				reason: message.stopReason,
 				error: message
 			});
 			outer.end(message);
@@ -64,35 +62,35 @@ function createLazyRegistration(api, importModule, select) {
 	};
 }
 const registerBuiltIns = [
-	createLazyRegistration("anthropic-messages", () => import("./anthropic-CE-7SkF6.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("anthropic-messages", () => import("./anthropic-B6dLpq5L.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamAnthropic,
 		streamSimple: module.streamSimpleAnthropic
 	})),
-	createLazyRegistration("openai-completions", () => import("./openai-completions-BaIpl93j.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("openai-completions", () => import("./openai-completions-BPnt4Sml.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamOpenAICompletions,
 		streamSimple: module.streamSimpleOpenAICompletions
 	})),
-	createLazyRegistration("mistral-conversations", () => import("./mistral-Dx6VzNjf.mjs"), (module) => ({
+	createLazyRegistration("mistral-conversations", () => import("./mistral-CEWoQI_g.mjs"), (module) => ({
 		stream: module.streamMistral,
 		streamSimple: module.streamSimpleMistral
 	})),
-	createLazyRegistration("openai-responses", () => import("./openai-responses-Bdx3V_Yu.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("openai-responses", () => import("./openai-responses-DhIKtOup.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamOpenAIResponses,
 		streamSimple: module.streamSimpleOpenAIResponses
 	})),
-	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-Cc_kasye.mjs"), (module) => ({
+	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-mxIOtUnn.mjs"), (module) => ({
 		stream: module.streamAzureOpenAIResponses,
 		streamSimple: module.streamSimpleAzureOpenAIResponses
 	})),
-	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-SC9m0FSf.mjs"), (module) => ({
+	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-CrPmqERt.mjs"), (module) => ({
 		stream: module.streamOpenAICodexResponses,
 		streamSimple: module.streamSimpleOpenAICodexResponses
 	})),
-	createLazyRegistration("google-generative-ai", () => import("./google-CGQu21aw.mjs"), (module) => ({
+	createLazyRegistration("google-generative-ai", () => import("./google-C7h2QzDX.mjs"), (module) => ({
 		stream: module.streamGoogle,
 		streamSimple: module.streamSimpleGoogle
 	})),
-	createLazyRegistration("google-vertex", () => import("./google-vertex-CusxWzvE.mjs"), (module) => ({
+	createLazyRegistration("google-vertex", () => import("./google-vertex-Bhc3TjDl.mjs"), (module) => ({
 		stream: module.streamGoogleVertex,
 		streamSimple: module.streamSimpleGoogleVertex
 	}))

package/dist/{reasoning-tag-text-partitioner-CGDyLWUR.mjs → reasoning-tag-text-partitioner-rnPwX2pg.mjs}

@@ -11573,6 +11573,7 @@ const REASONING_TAG_NAMES = [
 	"thinking",
 	"thought",
 	"reasoning",
+	"internal",
 	"antthinking",
 	"antml:think",
 	"antml:thinking",
@@ -11645,7 +11646,8 @@ function parseReasoningTagAt(text, start, final) {
 					index: start,
 					text: text.slice(start, end),
 					isClose,
-					isSelfClosing: !isClose && lastSignificant === "/"
+					isSelfClosing: !isClose && lastSignificant === "/",
+					isPrivate: partialName === "internal"
 				}
 			};
 		}
@@ -11748,16 +11750,18 @@ function reduceReasoningText(text, codeSpans, state, options) {
 			index: scannedTag.index + start,
 			isClose: scannedTag.isClose,
 			isSelfClosing: scannedTag.isSelfClosing,
+			isPrivate: scannedTag.isPrivate,
 			text: scannedTag.text
 		};
 		if (!isInsideCode(tag.index, codeSpans)) tags.push(tag);
 	}
-	const hasCloseAfter = [];
+	const mustParseRemainder = [];
 	if (options.scope === "leading") {
-		let seenClose = false;
+		let mustParse = false;
 		for (let index = tags.length - 1; index >= 0; index -= 1) {
-			hasCloseAfter[index] = seenClose;
-			seenClose ||= tags[index]?.isClose === true;
+			mustParse ||= tags[index]?.isPrivate === true;
+			mustParseRemainder[index] = mustParse;
+			mustParse ||= tags[index]?.isClose === true;
 		}
 	}
 	let cursor = start;
@@ -11777,17 +11781,19 @@ function reduceReasoningText(text, codeSpans, state, options) {
 			continue;
 		}
 		if (!tag.isClose) {
-			if (state.depth === 0 && options.scope === "leading" && state.visibleEver && !hasCloseAfter[tagIndex]) {
+			if (state.depth === 0 && options.scope === "leading" && state.visibleEver && !mustParseRemainder[tagIndex]) {
 				emit("text", text.slice(tag.index));
 				cursor = text.length;
 				break;
 			}
 			if (state.depth === 0) state.pending = {
 				content: "",
+				containsPrivate: tag.isPrivate,
 				openTag: tag.text,
 				protectedClose: false,
 				visibleBefore: state.visibleEver
 			};
+			else if (state.pending) state.pending.containsPrivate ||= tag.isPrivate;
 			state.depth += 1;
 			cursor = tagEnd;
 			continue;
@@ -11795,7 +11801,7 @@ function reduceReasoningText(text, codeSpans, state, options) {
 		if (state.depth > 0) {
 			state.depth -= 1;
 			if (state.depth === 0 && state.pending) {
-				emit("thinking", state.pending.content);
+				if (!state.pending.containsPrivate) emit("thinking", state.pending.content);
 				state.pending = void 0;
 			} else if (state.pending) state.pending.protectedClose = true;
 			cursor = tagEnd;
@@ -11815,7 +11821,7 @@ function reduceReasoningText(text, codeSpans, state, options) {
 	append(text.slice(cursor));
 	if (options.final && state.depth > 0 && state.pending) {
 		const pending = state.pending;
-		if (options.mode === "static-preserve" || options.mode === "static-strict" && !pending.visibleBefore && !pending.protectedClose || options.mode === "visible" && !pending.protectedClose) emit("text", options.mode === "visible" && pending.visibleBefore ? pending.openTag + pending.content : pending.content);
+		if (!pending.containsPrivate) if (options.mode === "static-preserve" || options.mode === "static-strict" && !pending.visibleBefore && !pending.protectedClose || options.mode === "visible" && !pending.protectedClose) emit("text", options.mode === "visible" && pending.visibleBefore ? pending.openTag + pending.content : pending.content);
 		else emit("thinking", pending.content);
 		state.depth = 0;
 		state.pending = void 0;

package/dist/record-coerce-DdXsgUd_.mjs

@@ -0,0 +1,23 @@
+//#region packages/normalization-core/src/record-coerce.ts
+/** Type guard for non-array object records at browser-safe boundaries. */
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Returns a non-array record or undefined. */
+function asOptionalRecord(value) {
+	return isRecord(value) ? value : void 0;
+}
+/** Returns a non-array record or a fresh ordinary empty record. */
+function asNonArrayRecord(value) {
+	return asOptionalRecord(value) ?? {};
+}
+/** Returns a non-array record or null. */
+function asNullableRecord(value) {
+	return isRecord(value) ? value : null;
+}
+/** Returns any object-backed record, including arrays, or undefined. */
+function asOptionalObjectRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+//#endregion
+export { isRecord as a, asOptionalRecord as i, asNullableRecord as n, asOptionalObjectRecord as r, asNonArrayRecord as t };

package/dist/{model-utils-Dau5dlgm.mjs → sanitize-unicode-BYqrYtC_.mjs}

@@ -1,4 +1,5 @@
-import { a as requiresClaudeMandatoryAdaptiveThinking, l as resolveClaudeNativeThinkingLevelMap } from "./src-QkygScBs.mjs";
+import { a as requiresClaudeMandatoryAdaptiveThinking, l as resolveClaudeNativeThinkingLevelMap } from "./anthropic-JsNA5KCu.mjs";
+import "./src-D2H6yKkH.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) {
@@ -61,4 +62,29 @@ function modelsAreEqual(a, b) {
 	return a.id === b.id && a.provider === b.provider;
 }
 //#endregion
-export { modelsAreEqual as a, getSupportedThinkingLevels as i, calculateCost as n, clampThinkingLevel as r, applyProviderReportedUsageCost as t };
+//#region packages/ai/src/utils/sanitize-unicode.ts
+/**
+* Removes unpaired Unicode surrogate characters from a string.
+*
+* Unpaired surrogates (high surrogates 0xD800-0xDBFF without matching low surrogates 0xDC00-0xDFFF,
+* or vice versa) cause JSON serialization errors in many API providers.
+*
+* Valid emoji and other characters outside the Basic Multilingual Plane use properly paired
+* surrogates and will NOT be affected by this function.
+*
+* @param text - The text to sanitize
+* @returns The sanitized text with unpaired surrogates removed
+*
+* @example
+* // Valid emoji (properly paired surrogates) are preserved
+* sanitizeSurrogates("Hello 🙈 World") // => "Hello 🙈 World"
+*
+* // Unpaired high surrogate is removed
+* const unpaired = String.fromCharCode(0xD83D); // high surrogate without low
+* sanitizeSurrogates(`Text ${unpaired} here`) // => "Text  here"
+*/
+function sanitizeSurrogates(text) {
+	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+//#endregion
+export { getSupportedThinkingLevels as a, clampThinkingLevel as i, applyProviderReportedUsageCost as n, modelsAreEqual as o, calculateCost as r, sanitizeSurrogates as t };

package/dist/session-resources-CkR4WWy1.mjs

@@ -0,0 +1,21 @@
+//#region packages/ai/src/session-resources.ts
+const sessionResourceCleanups = /* @__PURE__ */ new Set();
+/** Registers a session-resource cleanup hook and returns an unregister function. */
+function registerSessionResourceCleanup(cleanup) {
+	sessionResourceCleanups.add(cleanup);
+	return () => {
+		sessionResourceCleanups.delete(cleanup);
+	};
+}
+/** Runs all registered cleanup hooks, aggregating failures after every hook has run. */
+function cleanupSessionResources(sessionId) {
+	const errors = [];
+	for (const cleanup of sessionResourceCleanups) try {
+		cleanup(sessionId);
+	} catch (error) {
+		errors.push(error);
+	}
+	if (errors.length > 0) throw new AggregateError(errors, "Failed to cleanup session resources");
+}
+//#endregion
+export { registerSessionResourceCleanup as n, cleanupSessionResources as t };

package/dist/simple-options-D58D5Kvw.mjs

@@ -0,0 +1,117 @@
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import { t as sanitizeSurrogates } from "./sanitize-unicode-BYqrYtC_.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/providers/simple-options.ts
+function buildBaseOptions(model, options, apiKey) {
+	const firstEventOptions = options;
+	return {
+		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 { SYSTEM_PROMPT_CACHE_BOUNDARY as a, splitSystemPromptCacheBoundary as c, normalizeStructuredPromptSection as d, sortPromptCacheToolsByName as f, clampReasoning as i, stripSystemPromptCacheBoundary as l, buildBaseOptions as n, ensureSystemPromptCacheBoundary as o, clampMaxTokensToModel as r, prependSystemPromptAdditionAfterCacheBoundary as s, adjustMaxTokensForThinking as t, normalizePromptCapabilityIds as u };

package/dist/src-D2H6yKkH.mjs

@@ -0,0 +1,2 @@
+import "./validation-B61OhAio.mjs";
+export {};

package/dist/{stream-first-event-timeout-BIBomOGq.mjs → stream-first-event-timeout-MK28puvq.mjs}

@@ -1,4 +1,4 @@
-import { n as clampTimerTimeoutMs } from "./number-coercion-1Miyb5MO.mjs";
+import { i as clampTimerTimeoutMs } from "./number-coercion-H9qHik3g.mjs";
 //#region packages/ai/src/utils/stream-first-event-timeout.ts
 function getFirstStreamEventTimeoutMs(options) {
 	return options?.firstEventTimeoutMs;
@@ -57,8 +57,8 @@ function withFirstStreamEventTimeout(stream, context) {
 				timer = setTimeout(() => {
 					const timeoutError = createFirstStreamEventTimeoutError(timeoutContext);
 					timeoutContext.onTimeout?.(timeoutError);
-					timeoutContext.abort?.(timeoutError);
 					reject(timeoutError);
+					timeoutContext.abort?.(timeoutError);
 				}, timeoutMs);
 				timer.unref?.();
 				iterator.next().then(resolve, reject);

package/dist/string-coerce-fsri9iCu.mjs

@@ -0,0 +1,34 @@
+//#region packages/normalization-core/src/string-coerce.ts
+/** Reads a value only when it is already a string, preserving whitespace. */
+function readStringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/** Trims string input and returns null for non-strings or empty strings. */
+function normalizeNullableString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : null;
+}
+/** Trims string input and returns undefined for non-strings or empty strings. */
+function normalizeOptionalString(value) {
+	return normalizeNullableString(value) ?? void 0;
+}
+/** Stringifies primitive ids/flags before applying optional string normalization. */
+function normalizeStringifiedOptionalString(value) {
+	if (typeof value === "string") return normalizeOptionalString(value);
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return normalizeOptionalString(String(value));
+}
+/** Lowercases a normalized optional string. */
+function normalizeOptionalLowercaseString(value) {
+	return normalizeOptionalString(value)?.toLowerCase();
+}
+/** Lowercases a normalized string or returns an empty string when absent. */
+function normalizeLowercaseStringOrEmpty(value) {
+	return normalizeOptionalLowercaseString(value) ?? "";
+}
+/** Type guard for strings that remain non-empty after trimming. */
+function hasNonEmptyString(value) {
+	return normalizeOptionalString(value) !== void 0;
+}
+//#endregion
+export { normalizeOptionalString as a, normalizeOptionalLowercaseString as i, normalizeLowercaseStringOrEmpty as n, normalizeStringifiedOptionalString as o, normalizeNullableString as r, readStringValue as s, hasNonEmptyString as t };

package/dist/{tool-schema-json-projection-B1b-XCn5.mjs → tool-schema-json-projection-q5d7QX5c.mjs}

@@ -1,4 +1,5 @@
-import { n as getAiTransportHost } from "./host-Bl7Kgddo.mjs";
+import { n as getAiTransportHost } from "./host-DTqNc7ad.mjs";
+import { a as isRecord } from "./record-coerce-DdXsgUd_.mjs";
 import { types } from "node:util";
 //#region packages/ai/src/transports/host-policy.ts
 function buildGuardedModelFetch(model, timeoutMs, options) {
@@ -39,9 +40,6 @@ function isJsonValue(value) {
 		default: return false;
 	}
 }
-function isJsonObject(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 function isNonFiniteNumberValue(value) {
 	if (typeof value === "number") return !Number.isFinite(value);
 	if (value === null || typeof value !== "object" || !types.isNumberObject(value)) return false;
@@ -95,12 +93,12 @@ const schemaMapKeywords = /* @__PURE__ */ new Set([
 ]);
 function findDynamicSchemaKeywordViolations(schema, path) {
 	if (Array.isArray(schema)) return schema.flatMap((entry, index) => findDynamicSchemaKeywordViolations(entry, `${path}[${index}]`));
-	if (!isJsonObject(schema)) return [];
+	if (!isRecord(schema)) return [];
 	const violations = [];
 	for (const key of ["$dynamicRef", "$dynamicAnchor"]) if (key in schema) violations.push(`${path}.${key}`);
 	for (const [key, value] of Object.entries(schema)) {
 		if (!value || typeof value !== "object") continue;
-		if (schemaMapKeywords.has(key) && isJsonObject(value)) for (const [schemaName, childSchema] of Object.entries(value)) violations.push(...findDynamicSchemaKeywordViolations(childSchema, `${path}.${key}.${schemaName}`));
+		if (schemaMapKeywords.has(key) && isRecord(value)) for (const [schemaName, childSchema] of Object.entries(value)) violations.push(...findDynamicSchemaKeywordViolations(childSchema, `${path}.${key}.${schemaName}`));
 		else violations.push(...findDynamicSchemaKeywordViolations(value, `${path}.${key}`));
 	}
 	return violations;
@@ -109,7 +107,7 @@ function findDynamicSchemaKeywordViolations(schema, path) {
 function projectRuntimeToolInputSchema(schema, path = "parameters") {
 	const projection = serializeToolInputSchema(schema, path);
 	const violations = [...projection.violations];
-	if (!isJsonObject(projection.schema)) violations.push(`${path} must be a JSON object schema`);
+	if (!isRecord(projection.schema)) violations.push(`${path} must be a JSON object schema`);
 	else if (projection.schema.type !== void 0 && projection.schema.type !== "object") violations.push(`${path}.type must be "object"`);
 	violations.push(...findDynamicSchemaKeywordViolations(projection.schema, path));
 	return {

package/dist/transport-utils-DJqkxbhC.mjs

@@ -0,0 +1,138 @@
+import { a as normalizeOptionalString } from "./string-coerce-fsri9iCu.mjs";
+import { n as getAiTransportHost } from "./host-DTqNc7ad.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";
+import { createHash } from "node:crypto";
+//#region packages/ai/src/transports/transport-utils.ts
+const MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE = "OpenClaw transport error: malformed_streaming_fragment";
+const NON_LATIN_RE = /[\u2E80-\u9FFF\uA000-\uA4FF\uAC00-\uD7AF\uF900-\uFAFF\uFF01-\uFF60\uFFE0-\uFFE6\u{20000}-\u{2FA1F}]/gu;
+const CJK_SURROGATE_HIGH_RE = /[\uD840-\uD87E][\uDC00-\uDFFF]/g;
+function sha256Hex(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function sha256HexPrefix(value, length) {
+	return sha256Hex(value).slice(0, length);
+}
+function redactIdentifier(value, opts) {
+	const trimmed = normalizeOptionalString(value);
+	if (!trimmed) return "-";
+	return `sha256:${sha256HexPrefix(trimmed, Number.isFinite(opts?.len) ? Math.max(1, Math.floor(opts?.len ?? 12)) : 12)}`;
+}
+function redactSensitiveText(text, _options) {
+	return getAiTransportHost().redactToolPayloadText(text);
+}
+function resolveSecretSentinel(value) {
+	return getAiTransportHost().resolveSecretSentinel(value);
+}
+function resolveModelHeaderSentinels(model) {
+	if (!model.headers) return model;
+	let headers;
+	for (const [name, value] of Object.entries(model.headers)) {
+		const resolved = resolveSecretSentinel(value);
+		if (resolved !== value) {
+			headers ??= { ...model.headers };
+			headers[name] = resolved;
+		}
+	}
+	return headers ? {
+		...model,
+		headers
+	} : model;
+}
+function createAbortError(message, options) {
+	const error = new Error(message, options);
+	error.name = "AbortError";
+	return error;
+}
+function estimateStringChars(text) {
+	if (!text) return 0;
+	const nonLatinCount = (text.match(NON_LATIN_RE) ?? []).length;
+	return (nonLatinCount === 0 ? text.length : text.length - (text.match(CJK_SURROGATE_HIGH_RE) ?? []).length) + nonLatinCount * 3;
+}
+function supportsModelTools(model) {
+	return (model.compat && typeof model.compat === "object" ? model.compat : void 0)?.supportsTools !== false;
+}
+function isCodeModeModelVisibleToolName(name, visibleToolNames) {
+	return visibleToolNames.has(name);
+}
+function isGoogleGemini3Model(modelId, family) {
+	const normalized = modelId.trim().toLowerCase();
+	const suffix = family === "pro" ? "pro" : "flash";
+	return new RegExp(`(?:^|/)gemini-(?:3(?:\\.\\d+)?-${suffix}|${suffix}${family === "flash" ? "(?:-lite)?" : ""}-latest)(?:-|$)`).test(normalized);
+}
+function isGoogleGemini3ProModel(modelId) {
+	return isGoogleGemini3Model(modelId, "pro");
+}
+function isGoogleGemini3FlashModel(modelId) {
+	return isGoogleGemini3Model(modelId, "flash");
+}
+function parseRetryAfterSeconds(headers) {
+	const retryAfterMs = headers.get("retry-after-ms");
+	if (retryAfterMs) {
+		const trimmed = retryAfterMs.trim();
+		if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+			const milliseconds = asFiniteNumberInRange(parseStrictFiniteNumber(trimmed), {
+				min: 0,
+				max: Number.MAX_SAFE_INTEGER
+			});
+			return milliseconds === void 0 ? Number.POSITIVE_INFINITY : milliseconds / 1e3;
+		}
+	}
+	const retryAfter = headers.get("retry-after")?.trim();
+	if (!retryAfter) return;
+	if (/^\d+$/.test(retryAfter)) return parseStrictNonNegativeInteger(retryAfter) ?? Number.POSITIVE_INFINITY;
+	const retryAt = parseRetryAfterHttpDateMs(retryAfter);
+	return retryAt === void 0 ? void 0 : Math.max(0, (retryAt - Date.now()) / 1e3);
+}
+async function readChunkWithIdleTimeout(reader, timeoutMs, onIdleTimeout) {
+	let timer;
+	try {
+		return await Promise.race([reader.read(), new Promise((_resolve, reject) => {
+			timer = setTimeout(() => reject(onIdleTimeout?.({ chunkTimeoutMs: timeoutMs }) ?? /* @__PURE__ */ new Error("Read timed out")), timeoutMs);
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+async function readResponseTextSnippet(response, options) {
+	const maxBytes = options?.maxBytes ?? 8 * 1024;
+	const maxChars = options?.maxChars ?? 200;
+	const reader = response.body?.getReader();
+	if (!reader) return;
+	const chunks = [];
+	let bytes = 0;
+	let truncated = false;
+	try {
+		while (bytes < maxBytes) {
+			const result = options?.chunkTimeoutMs ? await readChunkWithIdleTimeout(reader, options.chunkTimeoutMs, options.onIdleTimeout) : await reader.read();
+			if (result.done) break;
+			if (!result.value?.length) continue;
+			const remaining = maxBytes - bytes;
+			chunks.push(result.value.subarray(0, remaining));
+			bytes += Math.min(result.value.length, remaining);
+			if (result.value.length >= remaining) {
+				truncated = true;
+				await reader.cancel().catch(() => void 0);
+				break;
+			}
+		}
+	} catch (error) {
+		await reader.cancel(error).catch(() => void 0);
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+	const merged = new Uint8Array(bytes);
+	let offset = 0;
+	for (const chunk of chunks) {
+		merged.set(chunk, offset);
+		offset += chunk.length;
+	}
+	const collapsed = new TextDecoder().decode(merged).replace(/\s+/g, " ").trim();
+	if (!collapsed) return;
+	if (collapsed.length > maxChars) return `${truncateUtf16Safe(collapsed, maxChars)}…`;
+	return truncated ? `${collapsed}…` : collapsed;
+}
+//#endregion
+export { isGoogleGemini3FlashModel as a, readResponseTextSnippet as c, resolveModelHeaderSentinels as d, resolveSecretSentinel as f, isCodeModeModelVisibleToolName as i, redactIdentifier as l, supportsModelTools as m, createAbortError as n, isGoogleGemini3ProModel as o, sha256Hex as p, estimateStringChars as r, parseRetryAfterSeconds as s, MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE as t, redactSensitiveText as u };