@openclaw/ai 2026.7.2-beta.7 → 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-DlMgPR39.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-D8n2uFee.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-CH4UUnZr.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-DsOxhOD1.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-CWmpvWYh.mjs"), (module) => ({
+	createLazyRegistration("mistral-conversations", () => import("./mistral-CEWoQI_g.mjs"), (module) => ({
 		stream: module.streamMistral,
 		streamSimple: module.streamSimpleMistral
 	})),
-	createLazyRegistration("openai-responses", () => import("./openai-responses-BT7A3sLu.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-CImcwB83.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-B84Ibtrd.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-CtSg0iTS.mjs"), (module) => ({
+	createLazyRegistration("google-generative-ai", () => import("./google-C7h2QzDX.mjs"), (module) => ({
 		stream: module.streamGoogle,
 		streamSimple: module.streamSimpleGoogle
 	})),
-	createLazyRegistration("google-vertex", () => import("./google-vertex-31f1uS9L.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/sanitize-unicode-BYqrYtC_.mjs

@@ -0,0 +1,90 @@
+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) {
+	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/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-BBys9hSb.mjs → stream-first-event-timeout-MK28puvq.mjs}

@@ -1,4 +1,4 @@
-import { n as clampTimerTimeoutMs } from "./number-coercion-DvG7SNMg.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-BwNu3nDi.mjs → tool-schema-json-projection-q5d7QX5c.mjs}

@@ -1,4 +1,32 @@
+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) {
+	const host = getAiTransportHost();
+	if (options !== void 0) return host.buildModelFetch(model, timeoutMs, options) ?? globalThis.fetch;
+	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 resolveProviderRequestCapabilities(input) {
+	return getAiTransportHost().resolveProviderRequestCapabilities(input);
+}
+function resolveProviderRequestPolicyConfig(input) {
+	return { headers: getAiTransportHost().resolveProviderRequestHeaders(input) };
+}
+function resolveModelRequestTimeoutMs(model, timeoutMs) {
+	return timeoutMs ?? getAiTransportHost().resolveModelRequestTimeoutMs(model);
+}
+function resolveOpenAIStrictToolSetting(model, options) {
+	return getAiTransportHost().resolveOpenAIStrictToolSetting(model, options);
+}
+function transformTransportMessages(messages, model, normalizeToolCallId, options) {
+	return getAiTransportHost().transformTransportMessages(messages, model, normalizeToolCallId, options);
+}
+//#endregion
 //#region packages/ai/src/providers/tool-schema-json-projection.ts
 function isJsonValue(value) {
 	if (value === null) return true;
@@ -12,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;
@@ -68,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;
@@ -82,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 {
@@ -91,4 +116,4 @@ function projectRuntimeToolInputSchema(schema, path = "parameters") {
 	};
 }
 //#endregion
-export { projectRuntimeToolInputSchema as t };
+export { resolveProviderEndpoint as a, transformTransportMessages as c, resolveOpenAIStrictToolSetting as i, buildGuardedModelFetch as n, resolveProviderRequestCapabilities as o, resolveModelRequestTimeoutMs as r, resolveProviderRequestPolicyConfig as s, projectRuntimeToolInputSchema as t };