@openclaw/ai 0.0.0 → 2026.7.1-2

package/dist/reasoning-tag-text-partitioner-axhAdUwg.mjs

@@ -0,0 +1,394 @@
+//#region packages/markdown-core/src/fences.ts
+/** Scans fenced-code spans incrementally so chunking can carry an open fence forward. */
+function scanFenceSpans(buffer, state) {
+	const spans = [];
+	const startsAtLineStart = state?.atLineStart ?? true;
+	let open = state?.open ? {
+		...state.open,
+		start: 0
+	} : void 0;
+	let offset = 0;
+	while (offset <= buffer.length) {
+		const nextNewline = buffer.indexOf("\n", offset);
+		const lineEnd = nextNewline === -1 ? buffer.length : nextNewline;
+		const line = buffer.slice(offset, lineEnd).replace(/\r$/, "");
+		const match = line.match(/^( {0,3})(`{3,}|~{3,})(.*)$/);
+		if (match && (offset > 0 || startsAtLineStart)) {
+			const indent = match[1];
+			const marker = match[2];
+			const markerChar = marker[0];
+			const markerLen = marker.length;
+			if (!open) open = {
+				start: offset,
+				markerChar,
+				markerLen,
+				openLine: line,
+				marker,
+				indent
+			};
+			else if (open.markerChar === markerChar && markerLen >= open.markerLen && /^[ \t]*$/.test(match[3])) {
+				const end = lineEnd;
+				spans.push({
+					start: open.start,
+					end,
+					openLine: open.openLine,
+					marker: open.marker,
+					indent: open.indent
+				});
+				open = void 0;
+			}
+		}
+		if (nextNewline === -1) break;
+		offset = nextNewline + 1;
+	}
+	if (open) spans.push({
+		start: open.start,
+		end: buffer.length,
+		openLine: open.openLine,
+		marker: open.marker,
+		indent: open.indent
+	});
+	return {
+		spans,
+		state: {
+			atLineStart: buffer.length === 0 ? startsAtLineStart : buffer.endsWith("\n"),
+			...open ? { open: {
+				markerChar: open.markerChar,
+				markerLen: open.markerLen,
+				openLine: open.openLine,
+				marker: open.marker,
+				indent: open.indent
+			} } : {}
+		}
+	};
+}
+//#endregion
+//#region packages/markdown-core/src/code-spans.ts
+/** Creates the carry-forward state used when scanning inline code across chunks. */
+function createInlineCodeState() {
+	return {
+		open: false,
+		ticks: 0
+	};
+}
+/** Builds a lookup for fenced and inline code spans while preserving scanner state. */
+function buildCodeSpanIndex(text, inlineState, fenceState) {
+	const { spans: fenceSpans, state: nextFenceState } = scanFenceSpans(text, fenceState);
+	const { spans: inlineSpans, state: nextInlineState } = parseInlineCodeSpans(text, fenceSpans, inlineState ? {
+		open: inlineState.open,
+		ticks: inlineState.ticks
+	} : createInlineCodeState());
+	return {
+		inlineState: nextInlineState,
+		fenceState: nextFenceState,
+		isInside: (index) => isInsideFenceSpan(index, fenceSpans) || isInsideInlineSpan(index, inlineSpans)
+	};
+}
+function parseInlineCodeSpans(text, fenceSpans, initialState) {
+	const spans = [];
+	let open = initialState.open;
+	let ticks = initialState.ticks;
+	let openStart = open ? 0 : -1;
+	let i = 0;
+	while (i < text.length) {
+		const fence = findFenceSpanAtInclusive(fenceSpans, i);
+		if (fence) {
+			i = fence.end;
+			continue;
+		}
+		if (text[i] !== "`") {
+			i += 1;
+			continue;
+		}
+		const runStart = i;
+		let runLength = 0;
+		while (i < text.length && text[i] === "`") {
+			runLength += 1;
+			i += 1;
+		}
+		if (!open) {
+			open = true;
+			ticks = runLength;
+			openStart = runStart;
+			continue;
+		}
+		if (runLength === ticks) {
+			spans.push([openStart, i]);
+			open = false;
+			ticks = 0;
+			openStart = -1;
+		}
+	}
+	if (open) spans.push([openStart, text.length]);
+	return {
+		spans,
+		state: {
+			open,
+			ticks
+		}
+	};
+}
+function findFenceSpanAtInclusive(spans, index) {
+	return spans.find((span) => index >= span.start && index < span.end);
+}
+function isInsideFenceSpan(index, spans) {
+	return spans.some((span) => index >= span.start && index < span.end);
+}
+function isInsideInlineSpan(index, spans) {
+	return spans.some(([start, end]) => index >= start && index < end);
+}
+//#endregion
+//#region packages/ai/src/utils/reasoning-tag-text-partitioner.ts
+const REASONING_TAG_RE = /<\s*(\/?)\s*(?:(?:antml:|mm:)?(?:think(?:ing)?|thought|reasoning)|antthinking)\b[^<>]*>/gi;
+const REASONING_TAG_NAMES = [
+	"think",
+	"thinking",
+	"thought",
+	"reasoning",
+	"antthinking",
+	"antml:think",
+	"antml:thinking",
+	"antml:thought",
+	"antml:reasoning",
+	"mm:think",
+	"mm:thinking",
+	"mm:thought",
+	"mm:reasoning"
+];
+function createReasoningTagTextPartitioner() {
+	let buffer = "";
+	let reasoningDepth = 0;
+	let strictMode = false;
+	let emittedVisibleText = false;
+	let inlineCodeState = createInlineCodeState();
+	let fenceState;
+	let hiddenInlineCodeState = createInlineCodeState();
+	let hiddenFenceState;
+	let recoverableOpenTagText;
+	const consume = (final, recoverFullUnclosed) => {
+		const output = [];
+		const emit = (kind, text) => {
+			if (!text) return;
+			if (kind === "text" && text.trim().length > 0) emittedVisibleText = true;
+			if (kind === "text") {
+				const nextCode = buildCodeSpanIndex(text, inlineCodeState, fenceState);
+				inlineCodeState = nextCode.inlineState;
+				fenceState = nextCode.fenceState;
+			} else {
+				const nextCode = buildCodeSpanIndex(text, hiddenInlineCodeState, hiddenFenceState);
+				hiddenInlineCodeState = nextCode.inlineState;
+				hiddenFenceState = nextCode.fenceState;
+			}
+			const previous = output[output.length - 1];
+			if (previous?.kind === kind) {
+				previous.text += text;
+				return;
+			}
+			output.push({
+				kind,
+				text
+			});
+		};
+		while (buffer) {
+			const activeInlineCodeState = reasoningDepth === 0 ? inlineCodeState : hiddenInlineCodeState;
+			const activeFenceState = reasoningDepth === 0 ? fenceState : hiddenFenceState;
+			const codeSpans = buildCodeSpanIndex(buffer, activeInlineCodeState, activeFenceState);
+			const hasUnclosedCode = reasoningDepth === 0 && Boolean(codeSpans.inlineState.open || codeSpans.fenceState.open);
+			const hasRawReasoning = hasRawReasoningTag(buffer);
+			const tag = findNextReasoningTag(buffer, (index) => final && hasUnclosedCode && hasRawReasoning ? false : codeSpans.isInside(index));
+			if (!tag) {
+				if (final) {
+					const recoverAsText = reasoningDepth > 0 && recoverFullUnclosed && !hasRawReasoningCloseTag(buffer);
+					const recoveredText = recoverAsText && recoverableOpenTagText ? recoverableOpenTagText + buffer : buffer;
+					emit(reasoningDepth > 0 && !recoverAsText ? "thinking" : "text", recoveredText);
+					buffer = "";
+					reasoningDepth = 0;
+					recoverableOpenTagText = void 0;
+					return output;
+				}
+				if (reasoningDepth > 0 && recoverFullUnclosed && (!emittedVisibleText || recoverableOpenTagText)) return output;
+				if (hasUnclosedCode && hasRawReasoning) {
+					const openCodeIndex = inlineCodeState.open || fenceState?.open ? 0 : findOpenCodeContextStart(buffer);
+					if (openCodeIndex !== -1) {
+						emit("text", buffer.slice(0, openCodeIndex));
+						buffer = buffer.slice(openCodeIndex);
+						return output;
+					}
+				}
+				const trailingFenceStart = findTrailingFenceFragmentStart(buffer, activeInlineCodeState, activeFenceState);
+				if (trailingFenceStart !== -1) {
+					emit(reasoningDepth > 0 ? "thinking" : "text", buffer.slice(0, trailingFenceStart));
+					buffer = buffer.slice(trailingFenceStart);
+					return output;
+				}
+				const keepFrom = reasoningTagPrefixSuffixIndex(buffer, (index) => codeSpans.isInside(index));
+				if (keepFrom === -1) {
+					emit(reasoningDepth > 0 ? "thinking" : "text", buffer);
+					buffer = "";
+					return output;
+				}
+				if (reasoningDepth === 0 && keepFrom > 0 && buffer.slice(0, keepFrom).trim().length > 0 && isReasoningCloseTagPrefix(buffer.slice(keepFrom))) return output;
+				if (keepFrom > 0) {
+					emit(reasoningDepth > 0 ? "thinking" : "text", buffer.slice(0, keepFrom));
+					buffer = buffer.slice(keepFrom);
+				}
+				return output;
+			}
+			const beforeTag = buffer.slice(0, tag.index);
+			const afterTag = buffer.slice(tag.index + tag.text.length);
+			if (tag.isClose && reasoningDepth === 0) {
+				if (recoverFullUnclosed && beforeTag.trim().length > 0 && afterTag.trim().length > 0) {
+					emit("text", beforeTag + tag.text);
+					buffer = afterTag;
+					continue;
+				}
+				if (beforeTag.trim().length > 0 && afterTag.trim().length === 0 && !final) return output;
+				if (beforeTag.trim().length === 0 || afterTag.trim().length === 0) emit("text", beforeTag);
+				buffer = afterTag;
+				continue;
+			}
+			emit(reasoningDepth > 0 ? "thinking" : "text", buffer.slice(0, tag.index));
+			buffer = afterTag;
+			if (tag.isClose) {
+				reasoningDepth = Math.max(0, reasoningDepth - 1);
+				if (reasoningDepth === 0) {
+					recoverableOpenTagText = void 0;
+					hiddenInlineCodeState = createInlineCodeState();
+					hiddenFenceState = void 0;
+				}
+			} else {
+				if (reasoningDepth === 0) {
+					recoverableOpenTagText = recoverFullUnclosed && emittedVisibleText ? tag.text : void 0;
+					hiddenInlineCodeState = createInlineCodeState();
+					hiddenFenceState = void 0;
+				}
+				reasoningDepth += 1;
+			}
+		}
+		return output;
+	};
+	return {
+		markStrict() {
+			strictMode = true;
+		},
+		push(chunk) {
+			strictMode = true;
+			buffer += chunk;
+			return consume(false, false);
+		},
+		pushVisible(chunk) {
+			buffer += chunk;
+			return consume(false, true);
+		},
+		flush() {
+			return consume(true, !strictMode);
+		},
+		hasPending() {
+			return buffer.length > 0 || reasoningDepth > 0;
+		},
+		isInsideReasoning() {
+			return reasoningDepth > 0;
+		}
+	};
+}
+function hasRawReasoningTag(text) {
+	REASONING_TAG_RE.lastIndex = 0;
+	return REASONING_TAG_RE.test(text);
+}
+function hasRawReasoningCloseTag(text) {
+	REASONING_TAG_RE.lastIndex = 0;
+	for (;;) {
+		const match = REASONING_TAG_RE.exec(text);
+		if (!match) return false;
+		if (match[1] === "/") return true;
+	}
+}
+function findNextReasoningTag(text, isIndexInsideCode) {
+	REASONING_TAG_RE.lastIndex = 0;
+	for (;;) {
+		const match = REASONING_TAG_RE.exec(text);
+		if (!match) return null;
+		if (!isIndexInsideCode(match.index)) return {
+			index: match.index,
+			text: match[0],
+			isClose: match[1] === "/"
+		};
+	}
+}
+function reasoningTagPrefixSuffixIndex(text, isIndexInsideCode) {
+	for (let index = text.lastIndexOf("<"); index >= 0;) {
+		if (!isIndexInsideCode(index) && isReasoningTagPrefix(text.slice(index))) return index;
+		if (index === 0) break;
+		index = text.lastIndexOf("<", index - 1);
+	}
+	return -1;
+}
+function isReasoningTagPrefix(text) {
+	const name = normalizeReasoningTagPrefixName(text);
+	return REASONING_TAG_NAMES.some((tagName) => {
+		if (tagName.startsWith(name)) return true;
+		if (!name.startsWith(tagName)) return false;
+		const rest = name.slice(tagName.length);
+		return rest.length === 0 || /^[\s/>]/.test(rest);
+	});
+}
+function isReasoningCloseTagPrefix(text) {
+	return text.replace(/^<\s*/, "<").replace(/^<\s*\//, "</").replace(/^<\/\s*/, "</").toLowerCase().startsWith("</") && isReasoningTagPrefix(text);
+}
+function normalizeReasoningTagPrefixName(text) {
+	const normalized = text.replace(/^<\s*/, "<").replace(/^<\s*\//, "</").replace(/^<\/\s*/, "</").toLowerCase();
+	return (normalized.startsWith("</") ? normalized.slice(2) : normalized.slice(1)).trimStart();
+}
+function findOpenCodeContextStart(text) {
+	const fence = findOpenFenceStart(text);
+	const inline = findOpenInlineCodeStart(text);
+	if (fence === -1) return inline;
+	if (inline === -1) return fence;
+	return Math.min(fence, inline);
+}
+function findOpenInlineCodeStart(text) {
+	let openStart = -1;
+	let openTicks = 0;
+	let index = 0;
+	while (index < text.length) {
+		if (text[index] !== "`") {
+			index += 1;
+			continue;
+		}
+		const runStart = index;
+		let runLength = 0;
+		while (index < text.length && text[index] === "`") {
+			runLength += 1;
+			index += 1;
+		}
+		if (openStart === -1) {
+			openStart = runStart;
+			openTicks = runLength;
+		} else if (runLength === openTicks) {
+			openStart = -1;
+			openTicks = 0;
+		}
+	}
+	return openStart;
+}
+function findOpenFenceStart(text) {
+	const fenceRe = /(^|\n)(```|~~~)[^\n]*(?:\n|$)/g;
+	let open = null;
+	for (const match of text.matchAll(fenceRe)) {
+		const index = (match.index ?? 0) + match[1].length;
+		const marker = match[2] ?? "";
+		if (open !== null && open.marker === marker) open = null;
+		else if (!open) open = {
+			marker,
+			index
+		};
+	}
+	return open?.index ?? -1;
+}
+function findTrailingFenceFragmentStart(text, inlineState, fenceState) {
+	if (inlineState.open || fenceState?.open) return -1;
+	const lineStart = Math.max(text.lastIndexOf("\n") + 1, 0);
+	return text.slice(lineStart).match(/^( {0,3})(`{1,2}|~{1,2})$/) ? lineStart : -1;
+}
+//#endregion
+export { createReasoningTagTextPartitioner as t };

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

@@ -0,0 +1,24 @@
+//#region packages/ai/src/utils/sanitize-unicode.d.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"
+ */
+declare function sanitizeSurrogates(text: string): string;
+//#endregion
+export { sanitizeSurrogates as t };

package/dist/sanitize-unicode-DT5o51ur.mjs

@@ -0,0 +1,26 @@
+//#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 { sanitizeSurrogates as t };

package/dist/src-CZ503MYJ.mjs

@@ -0,0 +1,99 @@
+import "./validation-FrchoOlv.mjs";
+//#region packages/llm-core/src/model-contracts/anthropic.ts
+function normalizeClaudeModelId(modelId) {
+	const normalized = modelId?.trim().toLowerCase() ?? "";
+	return (normalized.startsWith("anthropic/") ? normalized.slice(10) : normalized).replace(/[._\s]+/g, "-");
+}
+const CLAUDE_FABLE_5_THINKING_PROFILE = {
+	levels: [
+		{ id: "off" },
+		{ id: "minimal" },
+		{ id: "low" },
+		{ id: "medium" },
+		{ id: "high" },
+		{ id: "xhigh" },
+		{ id: "adaptive" },
+		{ id: "max" }
+	],
+	defaultLevel: "high",
+	preserveWhenCatalogReasoningFalse: true
+};
+const CLAUDE_SONNET_5_THINKING_PROFILE = {
+	levels: [
+		{ id: "off" },
+		{ id: "minimal" },
+		{ id: "low" },
+		{ id: "medium" },
+		{ id: "high" },
+		{ id: "xhigh" },
+		{ id: "adaptive" },
+		{ id: "max" }
+	],
+	defaultLevel: "high"
+};
+/** Resolve the canonical normalized Claude model id for one runtime model ref. */
+function resolveClaudeModelIdentity(ref) {
+	const normalized = normalizeClaudeModelId((typeof ref.params?.canonicalModelId === "string" ? ref.params.canonicalModelId : void 0) ?? ref.id);
+	const match = /(?:^|[-/])claude-/.exec(normalized);
+	return match ? normalized.slice((match.index ?? 0) + (match[0].startsWith("claude-") ? 0 : 1)) : normalized;
+}
+/** Resolve Claude Fable 5 through direct ids, cloud ids, or deployment metadata. */
+function resolveClaudeFable5ModelIdentity(ref) {
+	const normalized = resolveClaudeModelIdentity(ref);
+	const match = /(?:^|-)claude-fable-5(?=$|[^a-z0-9])/.exec(normalized);
+	if (!match) return;
+	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
+}
+/** Resolve Claude Mythos 5 through direct ids, cloud ids, or deployment metadata. */
+function resolveClaudeMythos5ModelIdentity(ref) {
+	const normalized = resolveClaudeModelIdentity(ref);
+	const match = /(?:^|-)claude-mythos-5(?=$|[^a-z0-9])/.exec(normalized);
+	if (!match) return;
+	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
+}
+/** Return whether a Claude model requires adaptive thinking instead of manual budgets. */
+function requiresClaudeMandatoryAdaptiveThinking(ref) {
+	const modelId = resolveClaudeModelIdentity(ref);
+	return resolveClaudeFable5ModelIdentity(ref) !== void 0 || resolveClaudeMythos5ModelIdentity(ref) !== void 0 || /(?:^|-)claude-mythos-preview(?=$|[^a-z0-9])/.test(modelId);
+}
+/** Resolve Claude Sonnet 5 through direct ids, cloud ids, or deployment metadata. */
+function resolveClaudeSonnet5ModelIdentity(ref) {
+	const normalized = resolveClaudeModelIdentity(ref);
+	const match = /(?:^|-)claude-sonnet-5(?=$|[^a-z0-9])/.exec(normalized);
+	if (!match) return;
+	return normalized.slice((match.index ?? 0) + (match[0].startsWith("-") ? 1 : 0));
+}
+/** Return whether a Claude model supports adaptive thinking. */
+function supportsClaudeAdaptiveThinking(ref) {
+	const modelId = resolveClaudeModelIdentity(ref);
+	return /(?:^|-)claude-(?:fable-5|mythos-(?:5|preview)|opus-4-(?:6|7|8)|sonnet-(?:5|4-6))(?=$|[^a-z0-9])/.test(modelId);
+}
+/** Return whether a Claude model supports native max effort. */
+function supportsClaudeNativeMaxEffort(ref) {
+	const modelId = resolveClaudeModelIdentity(ref);
+	return /(?:^|-)claude-(?:fable-5|mythos-5|opus-4-(?:6|7|8)|sonnet-(?:5|4-6))(?=$|[^a-z0-9])/.test(modelId);
+}
+/** Return whether a Claude model supports native xhigh effort. */
+function supportsClaudeNativeXhighEffort(ref) {
+	const modelId = resolveClaudeModelIdentity(ref);
+	return /(?:^|-)claude-(?:fable-5|mythos-5|opus-4-(?:7|8)|sonnet-5)(?=$|[^a-z0-9])/.test(modelId);
+}
+/** Return whether a Claude model rejects caller-selected sampling parameters. */
+function requiresClaudeDefaultSampling(ref) {
+	const modelId = resolveClaudeModelIdentity(ref);
+	return supportsClaudeNativeXhighEffort(ref) || /(?:^|-)claude-mythos-preview(?=$|[^a-z0-9])/.test(modelId);
+}
+/**
+* Fill native Claude effort mappings only when the provider did not publish a
+* narrower route-specific contract.
+*/
+function resolveClaudeNativeThinkingLevelMap(ref) {
+	if (ref.thinkingLevelMap !== void 0) return ref.thinkingLevelMap;
+	if (!supportsClaudeNativeMaxEffort(ref)) return;
+	return {
+		xhigh: supportsClaudeNativeXhighEffort(ref) ? "xhigh" : null,
+		max: "max"
+	};
+}
+//#endregion
+export { resolveClaudeFable5ModelIdentity as a, resolveClaudeNativeThinkingLevelMap as c, supportsClaudeNativeMaxEffort as d, supportsClaudeNativeXhighEffort as f, requiresClaudeMandatoryAdaptiveThinking as i, resolveClaudeSonnet5ModelIdentity as l, CLAUDE_SONNET_5_THINKING_PROFILE as n, resolveClaudeModelIdentity as o, requiresClaudeDefaultSampling as r, resolveClaudeMythos5ModelIdentity as s, CLAUDE_FABLE_5_THINKING_PROFILE as t, supportsClaudeAdaptiveThinking as u };

package/dist/stream-CREqxHgU.mjs

@@ -0,0 +1,74 @@
+//#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);
+	};
+}
+function wrapStreamSimple(api, streamSimple) {
+	return (model, context, options) => {
+		if (model.api !== api) throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+		return streamSimple(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: wrapStreamSimple(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
+/** Creates an isolated LLM runtime backed by the supplied provider registry. */
+function createLlmRuntime(registry = createApiRegistry()) {
+	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 resolveApiProvider(model.api).stream(model, context, options);
+	}
+	async function complete(model, context, options) {
+		return stream(model, context, options).result();
+	}
+	function streamSimple(model, context, options) {
+		return resolveApiProvider(model.api).streamSimple(model, context, options);
+	}
+	async function completeSimple(model, context, options) {
+		return streamSimple(model, context, options).result();
+	}
+	return {
+		registry,
+		stream,
+		complete,
+		streamSimple,
+		completeSimple
+	};
+}
+//#endregion
+export { createApiRegistry as n, createLlmRuntime as t };