@openclaw/ai 2026.9.7 → 2026.10.1-beta.1

package/dist/providers.mjs

@@ -1,6 +1,7 @@
-import { t as AssistantMessageEventStream } from "./event-stream-vd9UnCAU.mjs";
-import { n as projectProviderError } from "./provider-error-CwT_j2v0.mjs";
-import { n as clampOpenAIPromptCacheKey, t as OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH } from "./openai-prompt-cache-D2V7MqR7.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-C5AbCAaZ.mjs";
+import { n as projectProviderError } from "./provider-error-DQBE1bUQ.mjs";
+import { n as clampOpenAIPromptCacheKey, t as OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH } from "./openai-prompt-cache-I8YQTzf8.mjs";
+import { t as createZeroUsage } from "./usage-CJH5D6Ea.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";
@@ -15,20 +16,7 @@ function createLazyLoadErrorMessage(model, error, signal) {
 		api: model.api,
 		provider: model.provider,
 		model: model.id,
-		usage: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 0,
-			cost: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				total: 0
-			}
-		},
+		usage: createZeroUsage(),
 		...projectProviderError(error, signal),
 		timestamp: Date.now()
 	};
@@ -62,39 +50,39 @@ function createLazyRegistration(api, importModule, select) {
 	};
 }
 const registerBuiltIns = [
-	createLazyRegistration("anthropic-messages", () => import("./anthropic-Cw2pgccz.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("anthropic-messages", () => import("./anthropic-CZv6XFER.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamAnthropic,
 		streamSimple: module.streamSimpleAnthropic
 	})),
-	createLazyRegistration("openai-completions", () => import("./openai-completions-D14ihPYk.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("openai-completions", () => import("./openai-completions-DNyHnXKg.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamOpenAICompletions,
 		streamSimple: module.streamSimpleOpenAICompletions
 	})),
-	createLazyRegistration("mistral-conversations", () => import("./mistral-RS6mboC-.mjs"), (module) => ({
+	createLazyRegistration("mistral-conversations", () => import("./mistral-DSt4vQAO.mjs"), (module) => ({
 		stream: module.streamMistral,
 		streamSimple: module.streamSimpleMistral
 	})),
-	createLazyRegistration("openai-responses", () => import("./openai-responses-CKCBEc2W.mjs").then((n) => n.t), (module) => ({
+	createLazyRegistration("openai-responses", () => import("./openai-responses-uZ5oWSp7.mjs").then((n) => n.t), (module) => ({
 		stream: module.streamOpenAIResponses,
 		streamSimple: module.streamSimpleOpenAIResponses
 	})),
-	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-BwT3-X8P.mjs"), (module) => ({
+	createLazyRegistration("azure-openai-responses", () => import("./azure-openai-responses-DH7bd3QT.mjs"), (module) => ({
 		stream: module.streamAzureOpenAIResponses,
 		streamSimple: module.streamSimpleAzureOpenAIResponses
 	})),
-	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-CYbidtrn.mjs"), (module) => ({
+	createLazyRegistration("openai-chatgpt-responses", () => import("./openai-chatgpt-responses-BC2x0Oqx.mjs"), (module) => ({
 		stream: module.streamOpenAICodexResponses,
 		streamSimple: module.streamSimpleOpenAICodexResponses
 	})),
-	createLazyRegistration("google-generative-ai", () => import("./google-BfapkS_K.mjs"), (module) => ({
+	createLazyRegistration("google-generative-ai", () => import("./google-1WLOtb8w.mjs"), (module) => ({
 		stream: module.streamGoogle,
 		streamSimple: module.streamSimpleGoogle
 	})),
-	createLazyRegistration("google-interactions", () => import("./google-interactions-DW3iXzjc.mjs"), (module) => ({
+	createLazyRegistration("google-interactions", () => import("./google-interactions-wrnE6MLw.mjs"), (module) => ({
 		stream: module.streamGoogleInteractions,
 		streamSimple: module.streamSimpleGoogleInteractions
 	})),
-	createLazyRegistration("google-vertex", () => import("./google-vertex-Dov4kBWu.mjs"), (module) => ({
+	createLazyRegistration("google-vertex", () => import("./google-vertex-0LrlRoO3.mjs"), (module) => ({
 		stream: module.streamGoogleVertex,
 		streamSimple: module.streamSimpleGoogleVertex
 	}))

package/dist/{reasoning-tag-text-partitioner-B6FIIBt6.mjs → reasoning-tag-text-partitioner-Ju9VpUGl.mjs}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
-import "./provider-error-CwT_j2v0.mjs";
+import "./provider-error-DQBE1bUQ.mjs";
 import { t as expectDefined } from "./expect-lbe3Hgrh.mjs";
 //#region node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.js
 /**
@@ -11931,14 +11931,11 @@ function reduceReasoningText(text, codeSpans, state, options) {
 	const scan = scanReasoningTags(text.slice(start), options.final);
 	const tags = [];
 	for (const scannedTag of scan.tags) {
-		const tag = {
-			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 index = scannedTag.index + start;
+		if (!isInsideCode(index, codeSpans)) tags.push({
+			...scannedTag,
+			index
+		});
 	}
 	const mustParseRemainder = [];
 	if (options.scope === "leading") {
@@ -11950,9 +11947,7 @@ function reduceReasoningText(text, codeSpans, state, options) {
 		}
 	}
 	let cursor = start;
-	for (let tagIndex = 0; tagIndex < tags.length; tagIndex += 1) {
-		const tag = tags[tagIndex];
-		if (!tag) continue;
+	for (const [tagIndex, tag] of tags.entries()) {
 		const beforeTag = text.slice(cursor, tag.index);
 		append(beforeTag);
 		const tagEnd = tag.index + tag.text.length;
@@ -12094,6 +12089,19 @@ function createReasoningTagTextPartitioner() {
 			else target.push({ ...addition });
 		}
 	};
+	const reduceSafePrefix = (start, end, probeEnd, output) => {
+		const scan = scanReasoningTags(source.slice(start, end), false);
+		const reduceEnd = scan.pendingStart === void 0 ? end : start + scan.pendingStart;
+		merge(output, reduceReasoningText(source.slice(start, reduceEnd), [], reduction, {
+			final: false,
+			mode: "visible",
+			scope: "all"
+		}));
+		emitted = reduceEnd;
+		fastPathCheckedThrough = reduceEnd;
+		if (scan.pendingStart !== void 0) startPendingTagProbe(reduceEnd, probeEnd);
+		holdStart = reduction.depth > 0 || scan.pendingStart !== void 0 ? emitted : void 0;
+	};
 	const emitSafePrefix = (limit, output, appended) => {
 		if (strictMode) {
 			holdStart ??= emitted;
@@ -12103,17 +12111,7 @@ function createReasoningTagTextPartitioner() {
 			holdStart ??= emitted;
 			const segment = source.slice(emitted, limit);
 			if (!fastPathCodeSafe || /[\r\n`]/u.test(segment)) return;
-			const scan = scanReasoningTags(segment, false);
-			const reduceEnd = scan.pendingStart === void 0 ? limit : emitted + scan.pendingStart;
-			merge(output, reduceReasoningText(source.slice(emitted, reduceEnd), [], reduction, {
-				final: false,
-				mode: "visible",
-				scope: "all"
-			}));
-			emitted = reduceEnd;
-			fastPathCheckedThrough = reduceEnd;
-			if (scan.pendingStart !== void 0) startPendingTagProbe(reduceEnd, limit);
-			holdStart = reduction.depth > 0 || scan.pendingStart !== void 0 ? emitted : void 0;
+			reduceSafePrefix(emitted, limit, limit, output);
 			return;
 		}
 		if (holdStart !== void 0 || emitted >= limit) return;
@@ -12180,19 +12178,7 @@ function createReasoningTagTextPartitioner() {
 				source.indexOf("\n", special)
 			].filter((index) => index !== -1 && index < limit);
 			const safeLimit = boundaries.length > 0 ? Math.min(...boundaries) : limit;
-			const pendingAt = scanReasoningTags(source.slice(special, safeLimit), false).pendingStart;
-			const reduceEnd = pendingAt === void 0 ? safeLimit : special + pendingAt;
-			merge(output, reduceReasoningText(source.slice(special, reduceEnd), [], reduction, {
-				final: false,
-				mode: "visible",
-				scope: "all"
-			}));
-			emitted = reduceEnd;
-			fastPathCheckedThrough = reduceEnd;
-			if (pendingAt !== void 0) {
-				holdStart = reduceEnd;
-				startPendingTagProbe(reduceEnd, limit);
-			} else holdStart = reduction.depth > 0 ? emitted : void 0;
+			reduceSafePrefix(special, safeLimit, limit, output);
 		}
 	};
 	const processBlock = (end, final, output, parsedCodeSpans, parsedRetainStart) => {
@@ -12350,7 +12336,7 @@ function createReasoningTagTextPartitioner() {
 				const codeSpans = ownership.codeSpans;
 				nonFinalRetainStart = ownership.retainStart;
 				nonFinalOpenEndedCode = codeSpans.some(([, spanEnd]) => spanEnd === source.length);
-				if (!codeSpans.some(([, spanEnd]) => spanEnd === source.length)) compactCommittedSource(ownership.retainStart);
+				if (!nonFinalOpenEndedCode) compactCommittedSource(ownership.retainStart);
 			}
 		}
 		if (final) compactCommittedSource(source.length);

package/dist/required-api-key-D4kn3252.mjs

@@ -0,0 +1,9 @@
+import { n as getEnvApiKey } from "./env-api-keys-CyX4VKGO.mjs";
+//#region packages/ai/src/utils/required-api-key.ts
+function requireApiKey(provider, apiKey) {
+	const resolved = apiKey || getEnvApiKey(provider);
+	if (!resolved) throw new Error(`No API key for provider: ${provider}`);
+	return resolved;
+}
+//#endregion
+export { requireApiKey as t };

package/dist/sanitize-unicode-CjDG6jJx.d.mts

@@ -0,0 +1,5 @@
+//#region packages/ai/src/utils/sanitize-unicode.d.ts
+/** Remove unpaired surrogates rejected by providers; preserve valid Unicode pairs. */
+declare function sanitizeSurrogates(text: string): string;
+//#endregion
+export { sanitizeSurrogates as t };

package/dist/{session-affinity-Bcunsn4I.mjs → session-affinity-DA4WHv1h.mjs}

@@ -1,11 +1,7 @@
 //#region packages/ai/src/transports/session-affinity.ts
 function isOpencodeEndpoint(baseUrl) {
-	try {
-		const url = new URL(baseUrl);
-		return url.protocol === "https:" && url.hostname.replace(/\.$/, "") === "opencode.ai";
-	} catch {
-		return false;
-	}
+	const url = URL.parse(baseUrl);
+	return url?.protocol === "https:" && url.hostname.replace(/\.$/, "") === "opencode.ai";
 }
 /** Required conversation identity is independent of optional prompt caching. */
 function resolveOpencodeSessionHeaders(model, options) {

package/dist/session-resources-D1wgDQ8C.mjs

@@ -0,0 +1,40 @@
+//#region packages/ai/src/session-resources.ts
+const sessionResourceCleanups = /* @__PURE__ */ new Set();
+const sessionResourceCleanupObservers = /* @__PURE__ */ new Set();
+const sessionResourceOwnerIds = /* @__PURE__ */ new WeakMap();
+let nextSessionResourceOwnerId = 1;
+/** Returns a process-local key that keeps retained resources separated by runtime owner. */
+function getSessionResourceOwnerId(owner) {
+	const existing = sessionResourceOwnerIds.get(owner);
+	if (existing !== void 0) return existing;
+	const id = nextSessionResourceOwnerId++;
+	sessionResourceOwnerIds.set(owner, id);
+	return id;
+}
+/** Registers a session-resource cleanup hook and returns an unregister function. */
+function registerSessionResourceCleanup(cleanup) {
+	sessionResourceCleanups.add(cleanup);
+	return () => {
+		sessionResourceCleanups.delete(cleanup);
+	};
+}
+/** Registers metadata cleanup that runs only after every resource cleanup succeeds. */
+function registerSessionResourceCleanupObserver(observer) {
+	sessionResourceCleanupObservers.add(observer);
+	return () => {
+		sessionResourceCleanupObservers.delete(observer);
+	};
+}
+/** Runs all registered cleanup hooks, aggregating failures after every hook has run. */
+function cleanupSessionResources(sessionId, owner) {
+	const errors = [];
+	for (const cleanup of sessionResourceCleanups) try {
+		cleanup(sessionId, owner);
+	} catch (error) {
+		errors.push(error);
+	}
+	if (errors.length > 0) throw new AggregateError(errors, "Failed to cleanup session resources");
+	for (const observer of sessionResourceCleanupObservers) observer(sessionId, owner);
+}
+//#endregion
+export { registerSessionResourceCleanupObserver as i, getSessionResourceOwnerId as n, registerSessionResourceCleanup as r, cleanupSessionResources as t };

package/dist/{simple-options-CGAkCwtM.mjs → simple-options-BkKTXxhp.mjs}

@@ -1,8 +1,9 @@
 import { o as isRecord } from "./record-coerce-CNDovvft.mjs";
-import { O as hasMediaPayload, n as getAiTransportHost } from "./host-CHi3X87F.mjs";
-import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
-import { o as truncateUtf16Safe } from "./provider-error-CwT_j2v0.mjs";
-import { i as copyProviderAcceptanceObserver, j as sanitizeSurrogates } from "./transport-stream-shared-Dh5qKJ8e.mjs";
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-CtgOVOSv.mjs";
+import { M as hasMediaPayload, r as getAiTransportHost } from "./host-DCW52iHe.mjs";
+import { g as responsesServiceTierObserver } from "./openai-responses-contracts-BKu8O7l4.mjs";
+import { o as truncateUtf16Safe } from "./provider-error-DQBE1bUQ.mjs";
+import { P as sanitizeSurrogates, i as copyProviderAcceptanceObserver } from "./transport-stream-shared-CxXXz_Dd.mjs";
 //#region packages/ai/src/utils/prompt-cache-stability.ts
 /**
 * Prompt-cache normalization helpers. They keep generated prompt sections
@@ -33,11 +34,6 @@ function normalizePromptCapabilityIds(capabilities) {
 }
 //#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";
 /** Producer-delimited Runtime facts; instructions must remain outside this region. */
 const SYSTEM_PROMPT_RELOCATABLE_BOUNDARY = "\n<!-- OPENCLAW-RELOCATABLE-BOUNDARY -->\n";
@@ -80,8 +76,7 @@ function prependSystemPromptAdditionAfterCacheBoundary(params) {
 	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}`;
+	return `${split.stablePrefix}${SYSTEM_PROMPT_CACHE_BOUNDARY}${systemPromptAddition}${dynamicSuffix ? `\n\n${dynamicSuffix}` : ""}`;
 }
 //#endregion
 //#region packages/ai/src/providers/tool-result-text.ts
@@ -318,6 +313,7 @@ function buildBaseOptions(model, options, apiKey) {
 		metadata: options?.metadata
 	};
 	reasoningTagTextPolicy.copy(options, baseOptions);
+	responsesServiceTierObserver.copy(options, baseOptions);
 	modelRequestBodyState(baseOptions, options);
 	return copyProviderAcceptanceObserver(options, baseOptions);
 }

package/dist/{src-H4aXcFuX.mjs → src-B0NIt2UK.mjs}

@@ -1,5 +1,5 @@
 import "./diagnostics-DzrF1h4J.mjs";
-import "./validation-BFZc40Ig.mjs";
+import "./validation-DbqlIfDn.mjs";
 //#region packages/llm-core/src/model-contracts/anthropic.ts
 function normalizeClaudeModelId(modelId) {
 	const normalized = modelId?.trim().toLowerCase() ?? "";
@@ -66,6 +66,10 @@ function resolveClaudeMythos5ModelIdentity(ref) {
 function bindsClaudeThinkingPrefix(ref) {
 	return resolveClaudeOpus55ModelIdentity(ref) !== void 0 || resolveClaudeSonnet55ModelIdentity(ref) !== void 0 || /^claude-fable-5-1(?=$|[^a-z0-9])/.test(resolveClaudeModelIdentity(ref));
 }
+/** Return whether Claude accepts operator instructions within conversation history. */
+function supportsClaudeInHistorySystemMessages(ref) {
+	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || resolveClaudeSonnet5ModelIdentity(ref) !== void 0 || resolveClaudeFable5ModelIdentity(ref) !== void 0 || resolveClaudeMythos5ModelIdentity(ref) !== void 0 || /^claude-opus-4-8(?=$|[^a-z0-9])/.test(resolveClaudeModelIdentity(ref));
+}
 /** Return whether a Claude model requires adaptive thinking instead of manual budgets. */
 function requiresClaudeMandatoryAdaptiveThinking(ref) {
 	const modelId = resolveClaudeModelIdentity(ref);
@@ -110,8 +114,7 @@ function supportsClaudeAdaptiveThinking(ref) {
 }
 /** Return whether a Claude model has a native 1M-token context window. */
 function supportsClaude1MContext(ref) {
-	const modelId = resolveClaudeModelIdentity(ref);
-	return resolveClaudeOpus5ModelIdentity(ref) !== void 0 || resolveClaudeSonnet5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-(?:fable-5|mythos-(?:5|preview)|opus-4-(?:6|7|8)|sonnet-4-6)(?=$|[^a-z0-9])/.test(modelId);
+	return supportsClaudeAdaptiveThinking(ref);
 }
 /** Return whether a Claude model supports Anthropic's native fast mode. */
 function supportsClaudeFastMode(ref) {
@@ -219,4 +222,4 @@ function calculateUsageCost(usage, pricing) {
 	return cost;
 }
 //#endregion
-export { supportsClaudeFastMode as C, supportsClaudeAdaptiveThinking as S, supportsClaudeNativeXhighEffort as T, resolveClaudeOpus55ModelIdentity as _, CLAUDE_OPUS_55_THINKING_PROFILE as a, resolveClaudeSonnet5ModelIdentity as b, CLAUDE_SONNET_5_THINKING_PROFILE as c, requiresClaudeDefaultSampling as d, requiresClaudeMandatoryAdaptiveThinking as f, resolveClaudeNativeThinkingLevelMap as g, resolveClaudeMythos5ModelIdentity as h, CLAUDE_FABLE_5_THINKING_PROFILE as i, bindsClaudeThinkingPrefix as l, resolveClaudeModelIdentity as m, normalizeModelCostConfig as n, CLAUDE_OPUS_5_THINKING_PROFILE as o, resolveClaudeFable5ModelIdentity as p, normalizeResolvedPricing as r, CLAUDE_SONNET_55_THINKING_PROFILE as s, calculateUsageCost as t, requiresClaudeBetweenToolsThinking as u, resolveClaudeOpus5ModelIdentity as v, supportsClaudeNativeMaxEffort as w, supportsClaude1MContext as x, resolveClaudeSonnet55ModelIdentity as y };
+export { supportsClaudeFastMode as C, supportsClaudeNativeXhighEffort as E, supportsClaudeAdaptiveThinking as S, supportsClaudeNativeMaxEffort as T, resolveClaudeOpus55ModelIdentity as _, CLAUDE_OPUS_55_THINKING_PROFILE as a, resolveClaudeSonnet5ModelIdentity as b, CLAUDE_SONNET_5_THINKING_PROFILE as c, requiresClaudeDefaultSampling as d, requiresClaudeMandatoryAdaptiveThinking as f, resolveClaudeNativeThinkingLevelMap as g, resolveClaudeMythos5ModelIdentity as h, CLAUDE_FABLE_5_THINKING_PROFILE as i, bindsClaudeThinkingPrefix as l, resolveClaudeModelIdentity as m, normalizeModelCostConfig as n, CLAUDE_OPUS_5_THINKING_PROFILE as o, resolveClaudeFable5ModelIdentity as p, normalizeResolvedPricing as r, CLAUDE_SONNET_55_THINKING_PROFILE as s, calculateUsageCost as t, requiresClaudeBetweenToolsThinking as u, resolveClaudeOpus5ModelIdentity as v, supportsClaudeInHistorySystemMessages as w, supportsClaude1MContext as x, resolveClaudeSonnet55ModelIdentity as y };

package/dist/stream-DSdzKsDK.mjs

@@ -0,0 +1,275 @@
+import { i as bindAssistantMessageEventStream, o as getEventStreamCompletion } from "./event-stream-C5AbCAaZ.mjs";
+import { i as getDefaultAiTransportHost, n as createAiTransportHost, o as runWithAiTransportHost, s as supportsScopedAiTransportHosts } from "./host-DCW52iHe.mjs";
+import { i as registerSessionResourceCleanupObserver, t as cleanupSessionResources } from "./session-resources-D1wgDQ8C.mjs";
+//#region packages/ai/src/api-registry.ts
+function wrapStream(api, stream) {
+	return (model, context, options) => {
+		if (model.api !== api) throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+		return stream(model, context, options);
+	};
+}
+/** Creates an isolated provider registry for one runtime or tenant. */
+function createApiRegistry() {
+	const providers = /* @__PURE__ */ new Map();
+	function registerApiProvider(provider, sourceId) {
+		providers.set(provider.api, {
+			provider: {
+				api: provider.api,
+				stream: wrapStream(provider.api, provider.stream),
+				streamSimple: wrapStream(provider.api, provider.streamSimple)
+			},
+			sourceId
+		});
+	}
+	function getApiProvider(api) {
+		return providers.get(api)?.provider;
+	}
+	function getApiProviders() {
+		return Array.from(providers.values(), (entry) => entry.provider);
+	}
+	function unregisterApiProviders(sourceId) {
+		for (const [api, entry] of providers.entries()) if (entry.sourceId === sourceId) providers.delete(api);
+	}
+	return {
+		registerApiProvider,
+		getApiProvider,
+		getApiProviders,
+		unregisterApiProviders,
+		clearApiProviders: () => providers.clear()
+	};
+}
+//#endregion
+//#region packages/ai/src/stream.ts
+const defaultHostSessionReferences = /* @__PURE__ */ new Set();
+const defaultHostSessionFinalizer = new FinalizationRegistry((reference) => defaultHostSessionReferences.delete(reference));
+function trackDefaultHostSessions(sessions) {
+	const reference = new WeakRef(sessions);
+	defaultHostSessionReferences.add(reference);
+	defaultHostSessionFinalizer.register(sessions, reference, reference);
+}
+registerSessionResourceCleanupObserver((sessionId, owner) => {
+	for (const reference of defaultHostSessionReferences) {
+		const sessions = reference.deref();
+		if (!sessions) {
+			defaultHostSessionReferences.delete(reference);
+			continue;
+		}
+		const pruneOwners = (owners) => {
+			if (owner) owners.delete(owner);
+			else owners.clear();
+			return owners.size === 0;
+		};
+		if (sessionId) {
+			const owners = sessions.get(sessionId);
+			if (owners && pruneOwners(owners)) sessions.delete(sessionId);
+			continue;
+		}
+		for (const [ownedSessionId, owners] of sessions) if (pruneOwners(owners)) sessions.delete(ownedSessionId);
+	}
+});
+function retainUnscopedStreamLifetime(stream, runWithHost) {
+	let releaseLifetime;
+	const lifetime = new Promise((resolve) => {
+		releaseLifetime = resolve;
+	});
+	runWithHost(() => lifetime);
+	let released = false;
+	let resultSettled = false;
+	let bufferSettled = false;
+	const releaseIfSettled = () => {
+		if (!released && resultSettled && bufferSettled) {
+			released = true;
+			releaseLifetime();
+		}
+	};
+	const push = stream.push.bind(stream);
+	const end = stream.end.bind(stream);
+	const result = stream.result.bind(stream);
+	const iterate = stream[Symbol.asyncIterator].bind(stream);
+	const bufferedEvents = [];
+	const bufferWaiters = /* @__PURE__ */ new Set();
+	let bufferError;
+	let resultPromise;
+	const wrapIterationError = (error) => new Error("Stream iteration failed", { cause: error });
+	const notifyBufferWaiters = () => {
+		for (const resolve of bufferWaiters) resolve();
+		bufferWaiters.clear();
+	};
+	const observeResult = () => {
+		if (!resultPromise) {
+			let providerResult;
+			try {
+				providerResult = runWithHost(result);
+			} catch (error) {
+				providerResult = Promise.reject(new Error("Stream result failed", { cause: error }));
+			}
+			providerResult.then(() => {
+				resultSettled = true;
+				releaseIfSettled();
+			}, () => {
+				resultSettled = true;
+				releaseIfSettled();
+			});
+			resultPromise = providerResult;
+		}
+		return resultPromise;
+	};
+	(async () => {
+		try {
+			const iterator = runWithHost(iterate);
+			while (true) {
+				const next = await runWithHost(() => iterator.next());
+				if (next.done) return;
+				bufferedEvents.push(next.value);
+				notifyBufferWaiters();
+			}
+		} catch (error) {
+			bufferError = wrapIterationError(error);
+		} finally {
+			bufferSettled = true;
+			notifyBufferWaiters();
+			observeResult().catch(() => {});
+			releaseIfSettled();
+		}
+	})();
+	return {
+		push: (event) => runWithHost(() => push(event)),
+		end: (message) => runWithHost(() => end(message)),
+		result: observeResult,
+		[Symbol.asyncIterator]() {
+			let index = 0;
+			let done = false;
+			const next = async () => {
+				if (done) return {
+					done: true,
+					value: void 0
+				};
+				if (index < bufferedEvents.length) {
+					const value = bufferedEvents[index];
+					if (value === void 0) throw new Error("Buffered stream event is missing");
+					index += 1;
+					return {
+						done: false,
+						value
+					};
+				}
+				if (bufferSettled) {
+					if (bufferError) throw bufferError;
+					done = true;
+					return {
+						done: true,
+						value: void 0
+					};
+				}
+				await new Promise((resolve) => {
+					bufferWaiters.add(resolve);
+				});
+				return next();
+			};
+			return {
+				[Symbol.asyncIterator]() {
+					return this;
+				},
+				next,
+				async return(value) {
+					done = true;
+					notifyBufferWaiters();
+					return {
+						done: true,
+						value
+					};
+				}
+			};
+		}
+	};
+}
+function createRuntime(registry, transportHost) {
+	const explicitHost = transportHost === void 0 ? void 0 : createAiTransportHost(transportHost);
+	const defaultHostsBySession = /* @__PURE__ */ new Map();
+	if (!explicitHost) trackDefaultHostSessions(defaultHostsBySession);
+	const resolveRuntimeHost = () => explicitHost ?? getDefaultAiTransportHost();
+	const startStream = (start, sessionId) => {
+		const host = resolveRuntimeHost();
+		if (!explicitHost) {
+			const hosts = defaultHostsBySession.get(sessionId) ?? /* @__PURE__ */ new Set();
+			hosts.add(host);
+			defaultHostsBySession.set(sessionId, hosts);
+		}
+		const runWithStreamHost = (operation) => runWithAiTransportHost(host, operation);
+		const started = runWithStreamHost(start);
+		const completion = getEventStreamCompletion(started);
+		const bound = bindAssistantMessageEventStream(started, runWithStreamHost);
+		if (completion) {
+			if (!supportsScopedAiTransportHosts()) {
+				let producerSettled = false;
+				const observedCompletion = completion.then(() => {
+					producerSettled = true;
+				}, (error) => {
+					producerSettled = true;
+					throw error;
+				});
+				runWithStreamHost(() => observedCompletion);
+				const result = runWithStreamHost(() => started.result());
+				return bindAssistantMessageEventStream(started, (operation) => producerSettled ? operation() : runWithStreamHost(operation), { result: () => result });
+			}
+			runWithStreamHost(() => completion);
+		}
+		return !completion && !supportsScopedAiTransportHosts() ? retainUnscopedStreamLifetime(started, runWithStreamHost) : bound;
+	};
+	function resolveApiProvider(api) {
+		const provider = registry.getApiProvider(api);
+		if (!provider) throw new Error(`No API provider registered for api: ${api}`);
+		return provider;
+	}
+	function stream(model, context, options) {
+		return startStream(() => resolveApiProvider(model.api).stream(model, context, options), options?.sessionId);
+	}
+	async function complete(model, context, options) {
+		return stream(model, context, options).result();
+	}
+	function streamSimple(model, context, options) {
+		return startStream(() => resolveApiProvider(model.api).streamSimple(model, context, options), options?.sessionId);
+	}
+	async function completeSimple(model, context, options) {
+		return streamSimple(model, context, options).result();
+	}
+	function cleanupSessionResources$1(sessionId) {
+		if (!supportsScopedAiTransportHosts()) {
+			cleanupSessionResources(sessionId);
+			return;
+		}
+		const usedHosts = /* @__PURE__ */ new Set();
+		if (!explicitHost) {
+			if (sessionId) for (const host of defaultHostsBySession.get(sessionId) ?? []) usedHosts.add(host);
+			else for (const owners of defaultHostsBySession.values()) for (const host of owners) usedHosts.add(host);
+			usedHosts.add(getDefaultAiTransportHost());
+		}
+		const hosts = explicitHost ? [explicitHost] : [...usedHosts];
+		const errors = [];
+		for (const host of hosts) try {
+			runWithAiTransportHost(host, () => cleanupSessionResources(sessionId, host));
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw new AggregateError(errors, "Failed to cleanup runtime session resources");
+	}
+	return {
+		registry,
+		stream,
+		complete,
+		streamSimple,
+		completeSimple,
+		cleanupSessionResources: cleanupSessionResources$1
+	};
+}
+/** Creates an isolated LLM runtime backed by the supplied provider registry. */
+function createLlmRuntime(registry = createApiRegistry()) {
+	return createRuntime(registry);
+}
+/** Creates a Node runtime whose provider work retains an explicit transport host. */
+function createNodeLlmRuntime(registry = createApiRegistry(), transportHost = {}) {
+	if (!supportsScopedAiTransportHosts()) throw new Error("Explicit AI transport hosts require Node.js async context support");
+	return createRuntime(registry, transportHost);
+}
+//#endregion
+export { createNodeLlmRuntime as n, createApiRegistry as r, createLlmRuntime as t };

package/dist/{stream-first-event-timeout-B9o0S4SZ.mjs → stream-first-event-timeout-D9ZmL_s9.mjs}

@@ -1,4 +1,4 @@
-import { a as clampTimerTimeoutMs } from "./base64-C1PsYcRQ.mjs";
+import { i as clampTimerTimeoutMs } from "./number-coercion-V8-BhME4.mjs";
 //#region packages/ai/src/utils/stream-first-event-timeout.ts
 function getFirstStreamEventTimeoutMs(options) {
 	return options?.firstEventTimeoutMs;
@@ -21,14 +21,14 @@ function createFirstStreamEventTimeoutError(context) {
 function createFirstStreamEventAbortController(parentSignal) {
 	const controller = new AbortController();
 	const abortFromParent = () => {
-		if (!controller.signal.aborted) controller.abort(parentSignal?.reason);
+		controller.abort(parentSignal?.reason);
 	};
 	if (parentSignal?.aborted) abortFromParent();
 	else parentSignal?.addEventListener("abort", abortFromParent, { once: true });
 	return {
 		signal: controller.signal,
 		abort(reason) {
-			if (!controller.signal.aborted) controller.abort(reason);
+			controller.abort(reason);
 		},
 		dispose() {
 			parentSignal?.removeEventListener("abort", abortFromParent);

package/dist/{string-coerce-fsri9iCu.mjs → string-coerce-CtgOVOSv.mjs}

@@ -13,6 +13,10 @@ function normalizeNullableString(value) {
 function normalizeOptionalString(value) {
 	return normalizeNullableString(value) ?? void 0;
 }
+/** Rejects only empty or non-string values while preserving whitespace. */
+function readNonEmptyStringPreservingWhitespace(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 /** Stringifies primitive ids/flags before applying optional string normalization. */
 function normalizeStringifiedOptionalString(value) {
 	if (typeof value === "string") return normalizeOptionalString(value);
@@ -31,4 +35,4 @@ 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 };
+export { normalizeOptionalString as a, readStringValue as c, normalizeOptionalLowercaseString as i, normalizeLowercaseStringOrEmpty as n, normalizeStringifiedOptionalString as o, normalizeNullableString as r, readNonEmptyStringPreservingWhitespace as s, hasNonEmptyString as t };

package/dist/{string-normalization-J9ZiLfGO.mjs → string-normalization-PN10hf6d.mjs}

@@ -1,4 +1,4 @@
-import { a as normalizeOptionalString } from "./string-coerce-fsri9iCu.mjs";
+import { a as normalizeOptionalString } from "./string-coerce-CtgOVOSv.mjs";
 //#region packages/normalization-core/src/string-normalization.ts
 /** Coerces entries to strings, trims them, and drops empty results. */
 function normalizeStringEntries(list) {