@varo-ui/ai 1.0.0

package/dist/index.mjs

@@ -0,0 +1,984 @@
+import { createSmoothMarkdownStream } from "markstream-core";
+import { getMarkdown, isUnsafeHtmlUrl, parseMarkdownToStructure } from "stream-markdown-parser";
+//#region src/text-stream.ts
+function splitGraphemes(value) {
+	const intlRuntime = Intl;
+	if (typeof intlRuntime !== "object" || intlRuntime === null || !("Segmenter" in intlRuntime) || typeof intlRuntime.Segmenter !== "function") return Array.from(value);
+	const Segmenter = intlRuntime.Segmenter;
+	return Array.from(new Segmenter(void 0, { granularity: "grapheme" }).segment(value), (item) => item.segment);
+}
+function clamp(value, min, max) {
+	return Math.min(max, Math.max(min, value));
+}
+function createTimerTextStream(options = {}) {
+	const minCharsPerSecond = Math.max(1, options.minCharsPerSecond ?? 40);
+	const maxCharsPerSecond = Math.max(minCharsPerSecond, options.maxCharsPerSecond ?? 800);
+	const targetLatencyMs = Math.max(50, options.targetLatencyMs ?? 700);
+	const maxCommitFps = Math.max(1, Math.min(30, options.maxCommitFps ?? 20));
+	const maxCharsPerCommit = Math.max(1, options.maxCharsPerCommit ?? 64);
+	const catchUpThreshold = Math.max(1, options.catchUpThreshold ?? 320);
+	const listeners = /* @__PURE__ */ new Set();
+	const pending = [];
+	let pendingOffset = 0;
+	let source = "";
+	let visible = "";
+	let done = false;
+	let paused = false;
+	let destroyed = false;
+	let timer;
+	let lastTick = Date.now();
+	let budget = 0;
+	function pendingCount() {
+		return pending.length - pendingOffset;
+	}
+	function snapshot() {
+		const pendingChars = pendingCount();
+		return {
+			caughtUp: pendingChars === 0,
+			done,
+			final: done && pendingChars === 0,
+			paused,
+			pendingChars,
+			source,
+			visible
+		};
+	}
+	function emit() {
+		listeners.forEach((listener) => listener());
+	}
+	function compactPending() {
+		if (pendingOffset < 1024 || pendingOffset * 2 < pending.length) return;
+		pending.splice(0, pendingOffset);
+		pendingOffset = 0;
+	}
+	function schedule() {
+		if (destroyed || paused || timer || pendingCount() === 0) return;
+		timer = setTimeout(tick, Math.ceil(1e3 / maxCommitFps));
+	}
+	function tick() {
+		timer = void 0;
+		if (destroyed || paused) return;
+		const now = Date.now();
+		const deltaMs = Math.max(1, now - lastTick);
+		lastTick = now;
+		const backlog = pendingCount();
+		if (backlog === 0) {
+			emit();
+			return;
+		}
+		const cps = clamp(backlog * 1e3 / targetLatencyMs * (backlog >= catchUpThreshold ? 1.8 : 1), minCharsPerSecond, maxCharsPerSecond);
+		budget += cps * deltaMs / 1e3;
+		const commitCount = Math.min(backlog, maxCharsPerCommit, Math.max(1, Math.floor(budget)));
+		budget = Math.max(0, budget - commitCount);
+		visible += pending.slice(pendingOffset, pendingOffset + commitCount).join("");
+		pendingOffset += commitCount;
+		compactPending();
+		emit();
+		schedule();
+	}
+	function cancelTimer() {
+		clearTimeout(timer);
+		timer = void 0;
+	}
+	return {
+		destroy() {
+			if (destroyed) return;
+			destroyed = true;
+			cancelTimer();
+			pending.length = 0;
+			listeners.clear();
+		},
+		enqueue(chunk) {
+			if (destroyed || !chunk) return;
+			if (done) done = false;
+			source += chunk;
+			pending.push(...splitGraphemes(chunk));
+			lastTick = Date.now();
+			emit();
+			schedule();
+		},
+		finish(finishOptions = {}) {
+			if (destroyed) return;
+			done = true;
+			if (finishOptions.flush) {
+				visible = source;
+				pending.length = 0;
+				pendingOffset = 0;
+				cancelTimer();
+			}
+			emit();
+			schedule();
+		},
+		flush() {
+			if (destroyed) return;
+			visible = source;
+			pending.length = 0;
+			pendingOffset = 0;
+			budget = 0;
+			cancelTimer();
+			emit();
+		},
+		getSnapshot: snapshot,
+		pause() {
+			if (destroyed || paused) return;
+			paused = true;
+			cancelTimer();
+			emit();
+		},
+		reset(content = "") {
+			cancelTimer();
+			source = content;
+			visible = content;
+			pending.length = 0;
+			pendingOffset = 0;
+			done = false;
+			paused = false;
+			budget = 0;
+			lastTick = Date.now();
+			emit();
+		},
+		resume() {
+			if (destroyed || !paused) return;
+			paused = false;
+			lastTick = Date.now();
+			emit();
+			schedule();
+		},
+		subscribe(listener) {
+			if (destroyed) return () => {};
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+function createTextStream(options = {}) {
+	if (typeof requestAnimationFrame !== "function" || typeof cancelAnimationFrame !== "function") return createTimerTextStream(options);
+	const controller = createSmoothMarkdownStream(options);
+	return {
+		destroy: controller.destroy,
+		enqueue: controller.enqueue,
+		finish: controller.finish,
+		flush: controller.flush,
+		getSnapshot: controller.getSnapshot,
+		pause: controller.pause,
+		reset: controller.reset,
+		resume: controller.resume,
+		subscribe: controller.subscribe
+	};
+}
+//#endregion
+//#region src/agent-stream.ts
+function initialSnapshot() {
+	return {
+		data: [],
+		eventCount: 0,
+		reasoning: [],
+		status: "idle",
+		tools: []
+	};
+}
+function createAgentStreamController(options = {}) {
+	const text = createTextStream(options.text);
+	const listeners = /* @__PURE__ */ new Set();
+	let snapshot = initialSnapshot();
+	let destroyed = false;
+	let cancelled = false;
+	let transportDone = false;
+	let connecting = false;
+	let cancelActiveConnect;
+	function emit() {
+		listeners.forEach((listener) => listener());
+	}
+	function setSnapshot(update) {
+		snapshot = {
+			...snapshot,
+			...update
+		};
+		emit();
+	}
+	function updateReasoning(id, update) {
+		setSnapshot({ reasoning: snapshot.reasoning.map((part) => part.id === id ? {
+			...part,
+			...update
+		} : part) });
+	}
+	function updateTool(id, update) {
+		setSnapshot({ tools: snapshot.tools.map((part) => part.id === id ? {
+			...part,
+			...update
+		} : part) });
+	}
+	function finalStatus() {
+		const textSnapshot = text.getSnapshot();
+		if (!transportDone || !textSnapshot.final) return;
+		setSnapshot({ status: snapshot.error ? "failed" : cancelled ? "cancelled" : "completed" });
+	}
+	const unsubscribeText = text.subscribe(() => {
+		if (destroyed || !snapshot.message) return;
+		const textSnapshot = text.getSnapshot();
+		snapshot = {
+			...snapshot,
+			message: {
+				...snapshot.message,
+				final: textSnapshot.final,
+				source: textSnapshot.source,
+				visible: textSnapshot.visible
+			}
+		};
+		emit();
+		finalStatus();
+	});
+	function push(event) {
+		if (destroyed || cancelled) return;
+		snapshot = {
+			...snapshot,
+			eventCount: snapshot.eventCount + 1
+		};
+		switch (event.type) {
+			case "message.start":
+				transportDone = false;
+				text.reset();
+				setSnapshot({
+					error: void 0,
+					message: {
+						final: false,
+						id: event.messageId,
+						role: event.role,
+						source: "",
+						visible: ""
+					},
+					status: "streaming"
+				});
+				break;
+			case "text.delta":
+				if (snapshot.message?.id === event.messageId) text.enqueue(event.delta);
+				break;
+			case "message.end":
+				if (snapshot.message?.id === event.messageId) text.finish();
+				break;
+			case "reasoning.start":
+				setSnapshot({ reasoning: [...snapshot.reasoning, {
+					content: "",
+					id: event.id,
+					status: "running",
+					title: event.title
+				}] });
+				break;
+			case "reasoning.delta": {
+				const part = snapshot.reasoning.find((item) => item.id === event.id);
+				if (part) updateReasoning(event.id, { content: `${part.content}${event.delta}` });
+				break;
+			}
+			case "reasoning.end":
+				updateReasoning(event.id, {
+					durationMs: event.durationMs,
+					status: "completed"
+				});
+				break;
+			case "tool.start":
+				setSnapshot({ tools: [...snapshot.tools, {
+					id: event.id,
+					input: event.input,
+					name: event.name,
+					status: "running",
+					summary: event.summary
+				}] });
+				break;
+			case "tool.update":
+				updateTool(event.id, { summary: event.summary });
+				break;
+			case "tool.result":
+				updateTool(event.id, {
+					output: event.output,
+					status: "completed",
+					summary: event.summary
+				});
+				break;
+			case "tool.error":
+				updateTool(event.id, {
+					error: event.error,
+					status: "failed"
+				});
+				break;
+			case "approval.required":
+				setSnapshot({
+					approval: {
+						choices: event.choices ?? [],
+						description: event.description,
+						id: event.id,
+						status: "waiting",
+						title: event.title
+					},
+					status: "waiting"
+				});
+				break;
+			case "approval.resolved":
+				if (snapshot.approval?.id === event.id) setSnapshot({
+					approval: {
+						...snapshot.approval,
+						resolvedValue: event.value,
+						status: "completed"
+					},
+					status: "streaming"
+				});
+				break;
+			case "data":
+				setSnapshot({ data: [...snapshot.data, {
+					name: event.name,
+					value: event.value
+				}] });
+				break;
+			case "error":
+				transportDone = true;
+				text.finish({ flush: true });
+				setSnapshot({
+					error: event,
+					status: "failed"
+				});
+				break;
+			case "done":
+				transportDone = true;
+				text.finish();
+				setSnapshot({ usage: event.usage });
+				if (!snapshot.message) setSnapshot({ status: "completed" });
+				finalStatus();
+				break;
+		}
+	}
+	async function waitForTerminal() {
+		if (snapshot.status === "completed" || snapshot.status === "failed" || snapshot.status === "cancelled") return snapshot;
+		return await new Promise((resolve) => {
+			const unsubscribe = subscribe(() => {
+				if (snapshot.status !== "completed" && snapshot.status !== "failed" && snapshot.status !== "cancelled") return;
+				unsubscribe();
+				resolve(snapshot);
+			});
+		});
+	}
+	function subscribe(listener) {
+		if (destroyed) return () => {};
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	}
+	function reset() {
+		text.reset();
+		snapshot = initialSnapshot();
+		cancelled = false;
+		transportDone = false;
+		emit();
+	}
+	function cancel(reason = "Cancelled") {
+		if (destroyed || cancelled) return;
+		cancelled = true;
+		transportDone = true;
+		text.finish({ flush: true });
+		setSnapshot({
+			error: {
+				code: "cancelled",
+				message: reason,
+				retryable: true,
+				type: "error"
+			},
+			status: "cancelled"
+		});
+		cancelActiveConnect?.();
+	}
+	return {
+		cancel,
+		async connect(events) {
+			if (connecting) throw new Error("Agent stream controller is already connected");
+			connecting = true;
+			reset();
+			const iterator = events[Symbol.asyncIterator]();
+			let resolveCancellation;
+			const cancellation = new Promise((resolve) => {
+				resolveCancellation = resolve;
+			});
+			cancelActiveConnect = resolveCancellation;
+			try {
+				try {
+					while (!cancelled && !destroyed) {
+						const outcome = await Promise.race([iterator.next().then((result) => ({
+							kind: "event",
+							result
+						})), cancellation.then(() => ({ kind: "cancelled" }))]);
+						if (outcome.kind === "cancelled" || outcome.result.done) break;
+						push(outcome.result.value);
+					}
+					if (!transportDone && !cancelled && !destroyed) push({ type: "done" });
+				} catch (error) {
+					push({
+						message: error instanceof Error ? error.message : String(error),
+						retryable: true,
+						type: "error"
+					});
+				} finally {
+					if (cancelled || destroyed) iterator.return?.();
+				}
+				return await waitForTerminal();
+			} finally {
+				connecting = false;
+				cancelActiveConnect = void 0;
+			}
+		},
+		destroy() {
+			if (destroyed) return;
+			cancel("Agent stream controller destroyed");
+			destroyed = true;
+			unsubscribeText();
+			text.destroy();
+			listeners.clear();
+		},
+		getSnapshot() {
+			return snapshot;
+		},
+		push,
+		reset,
+		subscribe
+	};
+}
+//#endregion
+//#region src/event-channel.ts
+function createAgentEventChannel() {
+	const queue = [];
+	let ended = false;
+	let failure;
+	let wake;
+	async function* iterate() {
+		while (!ended || queue.length > 0) {
+			if (failure) throw failure;
+			const event = queue.shift();
+			if (event) {
+				yield event;
+				continue;
+			}
+			await new Promise((resolve) => {
+				wake = resolve;
+			});
+			wake = void 0;
+		}
+		if (failure) throw failure;
+	}
+	function notify() {
+		wake?.();
+	}
+	return {
+		end() {
+			ended = true;
+			notify();
+		},
+		fail(error) {
+			failure = error instanceof Error ? error : new Error(String(error));
+			ended = true;
+			notify();
+		},
+		push(event) {
+			if (ended) return;
+			queue.push(event);
+			notify();
+		},
+		source: { [Symbol.asyncIterator]: iterate }
+	};
+}
+//#endregion
+//#region src/type-guards.ts
+function isUnknownRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/event-parser.ts
+function requiredString(value, key) {
+	const field = value[key];
+	if (typeof field !== "string" || field.length === 0) throw new TypeError(`Agent stream event field "${key}" must be a non-empty string`);
+	return field;
+}
+function optionalString(value, key) {
+	const field = value[key];
+	if (field === void 0) return void 0;
+	if (typeof field !== "string") throw new TypeError(`Agent stream event field "${key}" must be a string`);
+	return field;
+}
+function optionalBoolean(value, key) {
+	const field = value[key];
+	if (field === void 0) return void 0;
+	if (typeof field !== "boolean") throw new TypeError(`Agent stream event field "${key}" must be a boolean`);
+	return field;
+}
+function optionalNumber(value, key) {
+	const field = value[key];
+	if (field === void 0) return void 0;
+	if (typeof field !== "number" || !Number.isFinite(field)) throw new TypeError(`Agent stream event field "${key}" must be a finite number`);
+	return field;
+}
+function parseChoices(value) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw new TypeError("Agent approval choices must be an array");
+	return value.map((choice) => {
+		if (!isUnknownRecord(choice)) throw new TypeError("Agent approval choice must be an object");
+		return {
+			description: optionalString(choice, "description"),
+			disabled: optionalBoolean(choice, "disabled"),
+			label: requiredString(choice, "label"),
+			value: requiredString(choice, "value")
+		};
+	});
+}
+function parseAgentStreamEvent(value) {
+	if (!isUnknownRecord(value) || typeof value.type !== "string") throw new TypeError("Agent stream event must be an object with a string type");
+	switch (value.type) {
+		case "message.start": {
+			const role = requiredString(value, "role");
+			if (role !== "assistant" && role !== "system" && role !== "user") throw new TypeError(`Unsupported agent message role: ${role}`);
+			return {
+				messageId: requiredString(value, "messageId"),
+				role,
+				type: value.type
+			};
+		}
+		case "text.delta": return {
+			delta: requiredString(value, "delta"),
+			messageId: requiredString(value, "messageId"),
+			type: value.type
+		};
+		case "message.end": return {
+			messageId: requiredString(value, "messageId"),
+			type: value.type
+		};
+		case "reasoning.start": return {
+			id: requiredString(value, "id"),
+			title: requiredString(value, "title"),
+			type: value.type
+		};
+		case "reasoning.delta": return {
+			delta: requiredString(value, "delta"),
+			id: requiredString(value, "id"),
+			type: value.type
+		};
+		case "reasoning.end": return {
+			durationMs: optionalNumber(value, "durationMs"),
+			id: requiredString(value, "id"),
+			type: value.type
+		};
+		case "tool.start": return {
+			id: requiredString(value, "id"),
+			input: value.input,
+			name: requiredString(value, "name"),
+			summary: optionalString(value, "summary"),
+			type: value.type
+		};
+		case "tool.update": return {
+			id: requiredString(value, "id"),
+			summary: optionalString(value, "summary"),
+			type: value.type
+		};
+		case "tool.result": return {
+			id: requiredString(value, "id"),
+			output: value.output,
+			summary: optionalString(value, "summary"),
+			type: value.type
+		};
+		case "tool.error": return {
+			error: requiredString(value, "error"),
+			id: requiredString(value, "id"),
+			type: value.type
+		};
+		case "approval.required": return {
+			choices: parseChoices(value.choices),
+			description: optionalString(value, "description"),
+			id: requiredString(value, "id"),
+			title: requiredString(value, "title"),
+			type: value.type
+		};
+		case "approval.resolved": return {
+			id: requiredString(value, "id"),
+			type: value.type,
+			value: requiredString(value, "value")
+		};
+		case "data":
+			if (!("value" in value)) throw new TypeError("Agent data event must include a value field");
+			return {
+				name: requiredString(value, "name"),
+				type: value.type,
+				value: value.value
+			};
+		case "error": return {
+			code: optionalString(value, "code"),
+			message: requiredString(value, "message"),
+			retryable: optionalBoolean(value, "retryable"),
+			type: value.type
+		};
+		case "done": {
+			const usage = value.usage;
+			if (usage !== void 0 && !isUnknownRecord(usage)) throw new TypeError("Agent done usage must be an object");
+			return {
+				type: value.type,
+				usage: usage ? {
+					inputTokens: optionalNumber(usage, "inputTokens"),
+					outputTokens: optionalNumber(usage, "outputTokens")
+				} : void 0
+			};
+		}
+		default: throw new TypeError(`Unsupported agent stream event type: ${value.type}`);
+	}
+}
+//#endregion
+//#region src/markdown.ts
+let parserId = 0;
+function createStreamingMarkdownParser(options = {}) {
+	parserId += 1;
+	const validateLink = options.validateLink ?? ((url) => !isUnsafeHtmlUrl(url));
+	const markdown = getMarkdown(`varo-agent-${parserId}`, {
+		customHtmlTags: options.customHtmlTags,
+		enableMath: options.enableMath ?? true,
+		markdownItOptions: {
+			breaks: true,
+			html: false,
+			linkify: true,
+			...options.markdownItOptions,
+			validateLink
+		}
+	});
+	return {
+		parse(content, parseOptions = {}) {
+			return parseMarkdownToStructure(content, markdown, {
+				customHtmlTags: options.customHtmlTags,
+				final: parseOptions.final ?? false,
+				includeSourceMap: options.includeSourceMap ?? false,
+				reuseStableTopLevelNodes: true,
+				streamParse: "auto",
+				validateLink
+			});
+		},
+		reset() {
+			markdown.stream?.reset?.();
+		}
+	};
+}
+//#endregion
+//#region src/markdown-view.ts
+function stringValue(value, fallback = "") {
+	return typeof value === "string" ? value : fallback;
+}
+function booleanValue(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function numberValue(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function alignValue(value) {
+	return value === "center" || value === "left" || value === "right" ? value : void 0;
+}
+function nodeField(node, key) {
+	return key in node ? Reflect.get(node, key) : void 0;
+}
+function normalizeUnknownNode(value) {
+	if (!isUnknownRecord(value) || typeof value.type !== "string" || typeof value.raw !== "string") return void 0;
+	return normalizeMarkdownNode(value);
+}
+function normalizeChildren(value) {
+	if (!Array.isArray(value)) return [];
+	const result = [];
+	value.forEach((item) => {
+		const normalized = normalizeUnknownNode(item);
+		if (normalized) result.push(normalized);
+	});
+	return result;
+}
+function textNode(text) {
+	return {
+		kind: "text",
+		text
+	};
+}
+function normalizeMarkdownNode(node) {
+	const fallback = stringValue(node.raw);
+	switch (node.type) {
+		case "text": return textNode(stringValue(node.content, fallback));
+		case "heading": return {
+			children: normalizeChildren(node.children),
+			kind: "heading",
+			level: numberValue(nodeField(node, "level")) ?? 2,
+			text: stringValue(nodeField(node, "text"))
+		};
+		case "paragraph":
+		case "inline": return {
+			children: normalizeChildren(node.children),
+			kind: "paragraph"
+		};
+		case "list": return {
+			children: normalizeChildren(nodeField(node, "items")),
+			kind: "list",
+			ordered: booleanValue(nodeField(node, "ordered")) ?? false,
+			start: numberValue(nodeField(node, "start"))
+		};
+		case "list_item": return {
+			children: normalizeChildren(node.children),
+			kind: "list-item"
+		};
+		case "code_block": return {
+			kind: "code-block",
+			language: stringValue(nodeField(node, "language")),
+			loading: booleanValue(node.loading),
+			text: stringValue(node.code, fallback)
+		};
+		case "inline_code": return {
+			kind: "inline-code",
+			text: stringValue(node.code, fallback)
+		};
+		case "link": return {
+			children: normalizeChildren(node.children),
+			href: stringValue(nodeField(node, "href")),
+			kind: "link",
+			text: stringValue(nodeField(node, "text")),
+			title: stringValue(nodeField(node, "title"))
+		};
+		case "image": return {
+			alt: stringValue(nodeField(node, "alt")),
+			href: stringValue(nodeField(node, "src")),
+			kind: "image",
+			title: stringValue(nodeField(node, "title"))
+		};
+		case "thematic_break": return { kind: "thematic-break" };
+		case "blockquote": return {
+			children: normalizeChildren(node.children),
+			kind: "blockquote"
+		};
+		case "table": {
+			const header = nodeField(node, "header");
+			const rows = nodeField(node, "rows");
+			return {
+				children: normalizeChildren(Array.isArray(rows) ? [header, ...rows] : [header]),
+				kind: "table"
+			};
+		}
+		case "table_row": return {
+			children: normalizeChildren(nodeField(node, "cells")),
+			kind: "table-row"
+		};
+		case "table_cell": return {
+			align: alignValue(nodeField(node, "align")),
+			children: normalizeChildren(node.children),
+			header: booleanValue(nodeField(node, "header")),
+			kind: "table-cell"
+		};
+		case "strong": return {
+			children: normalizeChildren(node.children),
+			kind: "strong"
+		};
+		case "emphasis": return {
+			children: normalizeChildren(node.children),
+			kind: "emphasis"
+		};
+		case "strikethrough": return {
+			children: normalizeChildren(node.children),
+			kind: "strikethrough"
+		};
+		case "highlight": return {
+			children: normalizeChildren(node.children),
+			kind: "highlight"
+		};
+		case "insert": return {
+			children: normalizeChildren(node.children),
+			kind: "insert"
+		};
+		case "subscript": return {
+			children: normalizeChildren(node.children),
+			kind: "subscript"
+		};
+		case "superscript": return {
+			children: normalizeChildren(node.children),
+			kind: "superscript"
+		};
+		case "checkbox":
+		case "checkbox_input": return {
+			checked: booleanValue(nodeField(node, "checked")),
+			kind: "checkbox"
+		};
+		case "emoji": return textNode(stringValue(nodeField(node, "markup"), fallback));
+		case "definition_list": return {
+			children: normalizeChildren(nodeField(node, "items")),
+			kind: "definition-list"
+		};
+		case "definition_item": return {
+			children: [{
+				children: normalizeChildren(nodeField(node, "term")),
+				header: true,
+				kind: "definition"
+			}, {
+				children: normalizeChildren(nodeField(node, "definition")),
+				kind: "definition"
+			}],
+			kind: "definition"
+		};
+		case "footnote": return {
+			children: normalizeChildren(node.children),
+			kind: "footnote",
+			title: stringValue(nodeField(node, "id"))
+		};
+		case "footnote_reference":
+		case "reference": return {
+			kind: "footnote",
+			text: stringValue(nodeField(node, "id"))
+		};
+		case "admonition": return {
+			children: normalizeChildren(node.children),
+			kind: "admonition",
+			text: stringValue(nodeField(node, "kind")),
+			title: stringValue(nodeField(node, "title"))
+		};
+		case "vmr_container": return {
+			children: normalizeChildren(node.children),
+			kind: "admonition",
+			loading: booleanValue(node.loading),
+			title: stringValue(nodeField(node, "name"))
+		};
+		case "hardbreak": return { kind: "hardbreak" };
+		case "math_inline": return {
+			kind: "math-inline",
+			text: stringValue(node.content, fallback)
+		};
+		case "math_block": return {
+			kind: "math-block",
+			text: stringValue(node.content, fallback)
+		};
+		case "html_block":
+		case "html_inline": return textNode(stringValue(node.content, fallback));
+		default: return textNode(fallback);
+	}
+}
+function normalizeMarkdownNodes(nodes) {
+	return nodes.map(normalizeMarkdownNode);
+}
+//#endregion
+//#region src/sse.ts
+function createFallbackUtf8Decoder() {
+	let carry = /* @__PURE__ */ new Uint8Array(0);
+	return { decode(chunk, final = false) {
+		const bytes = new Uint8Array(carry.length + chunk.length);
+		bytes.set(carry);
+		bytes.set(chunk, carry.length);
+		let cursor = 0;
+		let result = "";
+		while (cursor < bytes.length) {
+			const first = bytes[cursor];
+			if (first < 128) {
+				result += String.fromCodePoint(first);
+				cursor += 1;
+				continue;
+			}
+			const size = first >= 240 ? 4 : first >= 224 ? 3 : first >= 192 ? 2 : 1;
+			if (size === 1) {
+				result += "�";
+				cursor += 1;
+				continue;
+			}
+			if (cursor + size > bytes.length) break;
+			let codePoint = first & (size === 2 ? 31 : size === 3 ? 15 : 7);
+			let valid = true;
+			for (let index = 1; index < size; index += 1) {
+				const continuation = bytes[cursor + index];
+				if ((continuation & 192) !== 128) {
+					valid = false;
+					break;
+				}
+				codePoint = codePoint << 6 | continuation & 63;
+			}
+			if (!valid || codePoint > 1114111) {
+				result += "�";
+				cursor += 1;
+				continue;
+			}
+			result += String.fromCodePoint(codePoint);
+			cursor += size;
+		}
+		carry = bytes.slice(cursor);
+		if (final && carry.length > 0) {
+			result += "�";
+			carry = /* @__PURE__ */ new Uint8Array(0);
+		}
+		return result;
+	} };
+}
+function createUtf8Decoder() {
+	if (typeof TextDecoder === "function") {
+		const decoder = new TextDecoder();
+		return { decode(chunk, final = false) {
+			return decoder.decode(chunk, { stream: !final });
+		} };
+	}
+	return createFallbackUtf8Decoder();
+}
+function toBytes(chunk) {
+	return chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+}
+function createAgentSseEventSource() {
+	const channel = createAgentEventChannel();
+	const decoder = createUtf8Decoder();
+	const dataLines = [];
+	let textBuffer = "";
+	let ended = false;
+	function dispatch() {
+		if (dataLines.length === 0 || ended) return;
+		const payload = dataLines.join("\n");
+		dataLines.length = 0;
+		if (payload === "[DONE]") {
+			channel.push({ type: "done" });
+			return;
+		}
+		try {
+			channel.push(parseAgentStreamEvent(JSON.parse(payload)));
+		} catch (error) {
+			ended = true;
+			channel.fail(error);
+		}
+	}
+	function processLine(line) {
+		const normalized = line.endsWith("\r") ? line.slice(0, -1) : line;
+		if (normalized.length === 0) {
+			dispatch();
+			return;
+		}
+		if (normalized.startsWith(":")) return;
+		if (normalized === "data") {
+			dataLines.push("");
+			return;
+		}
+		if (normalized.startsWith("data:")) {
+			const value = normalized.slice(5);
+			dataLines.push(value.startsWith(" ") ? value.slice(1) : value);
+		}
+	}
+	function appendText(value) {
+		textBuffer += value;
+		let lineEnd = textBuffer.indexOf("\n");
+		while (lineEnd >= 0) {
+			processLine(textBuffer.slice(0, lineEnd));
+			textBuffer = textBuffer.slice(lineEnd + 1);
+			lineEnd = textBuffer.indexOf("\n");
+		}
+	}
+	return {
+		end() {
+			if (ended) return;
+			appendText(decoder.decode(/* @__PURE__ */ new Uint8Array(0), true));
+			if (textBuffer.length > 0) processLine(textBuffer);
+			dispatch();
+			ended = true;
+			channel.end();
+		},
+		fail(error) {
+			if (ended) return;
+			ended = true;
+			channel.fail(error);
+		},
+		feed(chunk) {
+			if (ended) return;
+			appendText(typeof chunk === "string" ? chunk : decoder.decode(toBytes(chunk)));
+		},
+		source: channel.source
+	};
+}
+//#endregion
+export { createAgentEventChannel, createAgentSseEventSource, createAgentStreamController, createStreamingMarkdownParser, createTextStream, normalizeMarkdownNode, normalizeMarkdownNodes, parseAgentStreamEvent };
+
+//# sourceMappingURL=index.mjs.map