agentic-ui-kit 0.2.1 → 0.4.0

package/dist/ui-markup-DtMYer7I.js

@@ -0,0 +1,1082 @@
+// ../core/src/partial-json.ts
+const tryParse = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+};
+/**
+* Best-effort value of JSON that is still streaming, so a tool call's fields can show while the model
+* writes them: `{"title":"Stand-up","day":"Tu` gives `{ title: "Stand-up", day: "Tu" }`. Open strings are
+* cut where the text ends, open objects and arrays are closed, and a key without its value yet is left
+* out. Returns undefined when nothing usable has arrived. One pass over the text.
+*/
+function parsePartialJson(text) {
+	const whole = tryParse(text);
+	if (whole !== void 0) return whole;
+	const stack = [];
+	const closers = () => stack.map((f) => f.close).reverse().join("");
+	let safe = 0;
+	let safeClose = "";
+	const valueDone = (end) => {
+		const top = stack.at(-1);
+		if (top) top.expect = "comma";
+		safe = end;
+		safeClose = closers();
+	};
+	let i = 0;
+	const n = text.length;
+	while (i < n) {
+		const ch = text[i];
+		if (ch === " " || ch === "\n" || ch === "\r" || ch === "	") {
+			i++;
+			continue;
+		}
+		const top = stack.at(-1);
+		if (ch === "\"") {
+			let j = i + 1;
+			let escaped = false;
+			for (; j < n; j++) {
+				const c = text[j];
+				if (escaped) escaped = false;
+				else if (c === "\\") escaped = true;
+				else if (c === "\"") break;
+			}
+			const isKey = top?.close === "}" && top.expect === "key";
+			if (j >= n) {
+				if (isKey) break;
+				const body = text.slice(i, n).replace(/\\(u[0-9a-fA-F]{0,3})?$/, "");
+				return tryParse(text.slice(0, i) + body + "\"" + closers()) ?? tryParse(text.slice(0, safe) + safeClose);
+			}
+			i = j + 1;
+			if (isKey) top.expect = "colon";
+			else valueDone(i);
+			continue;
+		}
+		if (ch === ":") {
+			if (top) top.expect = "value";
+			i++;
+			continue;
+		}
+		if (ch === ",") {
+			if (top) top.expect = top.close === "}" ? "key" : "value";
+			i++;
+			continue;
+		}
+		if (ch === "{" || ch === "[") {
+			stack.push({
+				close: ch === "{" ? "}" : "]",
+				expect: ch === "{" ? "key" : "value"
+			});
+			i++;
+			safe = i;
+			safeClose = closers();
+			continue;
+		}
+		if (ch === "}" || ch === "]") {
+			stack.pop();
+			i++;
+			valueDone(i);
+			continue;
+		}
+		let j = i;
+		while (j < n && !" \n\r	,]}:".includes(text[j])) j++;
+		if (j >= n) {
+			if (/^-?\d+(\.\d+)?$/.test(text.slice(i, j))) return tryParse(text.slice(0, j) + closers()) ?? tryParse(text.slice(0, safe) + safeClose);
+			break;
+		}
+		i = j;
+		valueDone(i);
+	}
+	return safe === 0 ? void 0 : tryParse(text.slice(0, safe) + safeClose);
+}
+/**
+* JSON as far as it is valid: a stray bracket midway keeps what came before it, instead of losing it all.
+* `error` says where it broke, for feedback to the model.
+*/
+function salvageJson(text) {
+	try {
+		return { value: JSON.parse(text) };
+	} catch (error) {
+		const m = /position (\d+)|line 1 column (\d+)/.exec(String(error));
+		const at = m ? Number(m[1] ?? Number(m[2]) - 1) : text.length;
+		const near = text.slice(Math.max(0, at - 30), at + 10);
+		return {
+			value: parsePartialJson(text.slice(0, at)),
+			error: `invalid JSON at character ${at}, near ${JSON.stringify(near)}`
+		};
+	}
+}
+// ../core/src/reduce.ts
+/**
+* Applies one stream event to the message it builds. Pure and immutable: returns the same object when the
+* event changes nothing, so React can skip renders.
+*
+* Events with a seq at or below `message.lastSeq` are dropped, so replaying from an earlier seq after a
+* reconnect is safe. Events other than run.start need the message to exist; without it they are dropped.
+*/
+function applyEvent(message, event) {
+	if (event.type === "run.start") {
+		if (message?.runId === event.runId && (message.lastSeq ?? -1) >= event.seq) return message;
+		if (message?.id === event.messageId) return {
+			...message,
+			status: "streaming",
+			runId: event.runId,
+			lastSeq: event.seq
+		};
+		return {
+			id: event.messageId,
+			parentId: event.parentId,
+			role: "assistant",
+			status: "streaming",
+			parts: [],
+			createdAt: event.createdAt,
+			runId: event.runId,
+			lastSeq: event.seq,
+			...event.model !== void 0 && { model: event.model },
+			...event.effort !== void 0 && { effort: event.effort }
+		};
+	}
+	if (!message || message.runId !== event.runId) return message;
+	if ((message.lastSeq ?? -1) >= event.seq) return message;
+	const seen = {
+		...message,
+		lastSeq: event.seq
+	};
+	switch (event.type) {
+		case "part.start":
+			if (message.parts.some((p) => p.id === event.part.id)) return seen;
+			return {
+				...seen,
+				parts: [...message.parts, event.part]
+			};
+		case "part.delta": return updatePart(seen, event.partId, (part) => appendDelta(part, event.text, event.inputJson));
+		case "part.update": return updatePart(seen, event.partId, (part) => applyFields(part, event));
+		case "part.end": return updatePart(seen, event.partId, (part) => closePart(applyFields(part, event)));
+		case "run.usage": return {
+			...seen,
+			usage: event.usage
+		};
+		case "run.end": return {
+			...seen,
+			status: event.status,
+			parts: message.parts.map((p) => closeOpenPart(p, event.status)),
+			...event.usage !== void 0 && { usage: event.usage },
+			...event.error !== void 0 && { error: event.error }
+		};
+		case "title": return seen;
+	}
+}
+/** Builds a message from a full event list, e.g. a stored run or a test fixture. */
+function reduceEvents(events, initial) {
+	let message = initial;
+	for (const event of events) message = applyEvent(message, event);
+	return message;
+}
+function updatePart(message, partId, update) {
+	const index = message.parts.findIndex((p) => p.id === partId);
+	if (index === -1) return message;
+	const parts = message.parts.slice();
+	parts[index] = update(parts[index]);
+	return {
+		...message,
+		parts
+	};
+}
+function appendDelta(part, text = "", inputJson = "") {
+	switch (part.type) {
+		case "text":
+		case "thinking": return text ? {
+			...part,
+			text: part.text + text
+		} : part;
+		case "custom": return text ? {
+			...part,
+			text: (part.text ?? "") + text
+		} : part;
+		case "widget": return text ? {
+			...part,
+			html: (part.html ?? "") + text
+		} : part;
+		case "tool_call":
+			if (!inputJson) return part;
+			return {
+				...part,
+				inputJson: part.inputJson + inputJson,
+				partialInput: parsePartialJson(part.inputJson + inputJson)
+			};
+		case "attachment": return part;
+	}
+}
+/** Copies the fields from `fields` that are valid for the part's type. */
+function applyFields(part, fields) {
+	const pick = (...keys) => {
+		const out = {};
+		for (const key of keys) if (fields[key] !== void 0) out[key] = fields[key];
+		return out;
+	};
+	const status = pick("status");
+	switch (part.type) {
+		case "text": return {
+			...part,
+			...status
+		};
+		case "thinking": return {
+			...part,
+			...status,
+			...pick("title", "durationMs")
+		};
+		case "tool_call": {
+			const next = {
+				...part,
+				...status,
+				...pick("title", "subtitle", "durationMs", "input", "result", "data", "error")
+			};
+			return next.status === "input" || next.status === "streaming" ? next : withParsedInput(next);
+		}
+		case "attachment": return {
+			...part,
+			...status,
+			...pick("url")
+		};
+		case "widget": return {
+			...part,
+			...status,
+			...pick("title", "resourceUri")
+		};
+		case "custom": return {
+			...part,
+			...status,
+			...pick("data")
+		};
+	}
+}
+function closePart(part) {
+	return withParsedInput(part.status === "error" ? part : {
+		...part,
+		status: "done"
+	});
+}
+/** Parses a tool call's streamed input if it is complete JSON and not parsed yet. */
+function withParsedInput(part) {
+	if (part.type !== "tool_call") return part;
+	const { partialInput: _, ...rest } = part;
+	if (part.input !== void 0 || !part.inputJson) return "partialInput" in part ? rest : part;
+	const input = parseJson(part.inputJson);
+	if (input !== void 0) return {
+		...rest,
+		input
+	};
+	return part.status === "error" ? rest : {
+		...rest,
+		status: "error",
+		error: part.error ?? "The tool input was cut off or is not valid JSON"
+	};
+}
+/** At the end of a run, parts still open are closed. A tool call cut off by a stop or an error is an error. */
+function closeOpenPart(part, runStatus) {
+	if (part.status === "done" || part.status === "error") return part;
+	if (part.type === "tool_call" && part.status === "awaiting" && runStatus === "done") return withParsedInput(part);
+	if (part.type === "tool_call" && runStatus !== "done") {
+		const error = part.error ?? (runStatus === "stopped" ? "Stopped" : "Failed");
+		return withParsedInput({
+			...part,
+			status: "error",
+			error
+		});
+	}
+	return closePart(part);
+}
+function parseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+/** Rough token count of text, about four characters per token. For live counters, not billing. */
+function estimateTokens(text) {
+	return Math.ceil(text.length / 4);
+}
+/**
+* Tokens the model spent inside an activity group: its reasoning and the tool inputs it wrote. Tool
+* results are not model output, so they do not count. An estimate; per-step counts are not reported.
+*/
+function activityTokens(parts) {
+	let chars = 0;
+	for (const part of parts) if (part.type === "thinking") chars += part.text.length;
+	else if (part.type === "tool_call") chars += part.inputJson.length;
+	return Math.ceil(chars / 4);
+}
+/**
+* Output tokens of a message so far: the backend's count when it has sent one, else an estimate from
+* everything the model has written (text, thinking, tool input, widget html).
+*/
+function outputTokens(message) {
+	if (message.usage?.outputTokens !== void 0) return message.usage.outputTokens;
+	let chars = 0;
+	for (const part of message.parts) if (part.type === "text" || part.type === "thinking") chars += part.text.length;
+	else if (part.type === "tool_call") chars += part.inputJson.length;
+	else if (part.type === "widget") chars += part.html?.length ?? 0;
+	else if (part.type === "custom") chars += part.text?.length ?? 0;
+	return Math.ceil(chars / 4);
+}
+/**
+* The effort to send with a model: the chosen one if the model offers it, else the model's default, else
+* none. Models without effort levels never get one.
+*/
+function resolveEffort(model, effort) {
+	const levels = model?.efforts;
+	if (!levels?.length) return void 0;
+	if (effort && levels.some((e) => e.id === effort)) return effort;
+	return model?.defaultEffort ?? levels[0].id;
+}
+/** Tool calls the client has to act on: run them (client tools) or ask the user (approvals). */
+function awaitingToolCalls(message) {
+	return message.parts.filter((p) => p.type === "tool_call" && p.status === "awaiting");
+}
+/** Sets fields on one tool call locally, e.g. a client tool's result or the user's approval. */
+function settleToolCall(message, partId, fields) {
+	return {
+		...message,
+		parts: message.parts.map((p) => p.id === partId && p.type === "tool_call" ? {
+			...p,
+			...fields
+		} : p)
+	};
+}
+// ../core/src/blocks.ts
+function isActivityPart(part) {
+	return part.type === "thinking" || part.type === "tool_call";
+}
+function toBlocks(parts, standalone) {
+	const blocks = [];
+	for (const part of parts) {
+		if (part.type === "tool_call" && standalone?.(part)) {
+			blocks.push({
+				kind: "tool",
+				id: part.id,
+				part
+			});
+			continue;
+		}
+		if (!isActivityPart(part)) {
+			blocks.push({
+				kind: "part",
+				id: part.id,
+				part
+			});
+			continue;
+		}
+		const last = blocks.at(-1);
+		if (last?.kind === "activity") last.parts.push(part);
+		else blocks.push({
+			kind: "activity",
+			id: part.id,
+			parts: [part]
+		});
+	}
+	return blocks;
+}
+// ../core/src/sse.ts
+/**
+* Reads a server-sent event stream of `StreamEvent`s. Each SSE message carries one JSON event in `data`;
+* comments and messages without data (keep-alives) are skipped.
+*/
+async function* readEventStream(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		for (;;) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			let end;
+			while ((end = messageEnd(buffer)) !== -1) {
+				const event = parseMessage(buffer.slice(0, end));
+				buffer = buffer.slice(end).replace(BLANK_LINE_START, "");
+				if (event) yield event;
+			}
+		}
+		const event = parseMessage(buffer + decoder.decode());
+		if (event) yield event;
+	} finally {
+		reader.releaseLock();
+	}
+}
+/** Formats one event as an SSE message, for servers written in TS. */
+function formatEvent(event) {
+	return `id: ${event.seq}\ndata: ${JSON.stringify(event)}\n\n`;
+}
+const BLANK_LINE = /\r\n\r\n|\n\n|\r\r/;
+const BLANK_LINE_START = /^(\r\n\r\n|\n\n|\r\r)/;
+function messageEnd(buffer) {
+	const match = BLANK_LINE.exec(buffer);
+	return match ? match.index : -1;
+}
+function parseMessage(text) {
+	const data = [];
+	for (const line of text.split(/\r\n|\r|\n/)) if (line.startsWith("data:")) data.push(line.slice(line.startsWith("data: ") ? 6 : 5));
+	if (data.length === 0) return void 0;
+	return JSON.parse(data.join("\n"));
+}
+// ../core/src/ui-tree.ts
+/**
+* Host-registered components: instead of HTML, the model writes a small tree of components the host
+* registered (trusted React, themed, able to read the app's own data). The kit validates each node against
+* its component's schema; bad nodes render nothing. Idea from OpenUI (github.com/thesysdev/openui).
+*/
+/** Schema for a prop that holds an action, e.g. `{ onPress: uiActionSchema }`. */
+const uiActionSchema = { anyOf: [
+	{
+		type: "object",
+		properties: {
+			action: { const: "set" },
+			key: { type: "string" },
+			value: {}
+		},
+		required: [
+			"action",
+			"key",
+			"value"
+		]
+	},
+	{
+		type: "object",
+		properties: {
+			action: { const: "send" },
+			text: {
+				type: "string",
+				minLength: 1
+			}
+		},
+		required: ["action", "text"]
+	},
+	{
+		type: "object",
+		properties: {
+			action: { const: "open" },
+			url: {
+				type: "string",
+				pattern: "^https?://"
+			}
+		},
+		required: ["action", "url"]
+	},
+	{
+		type: "object",
+		properties: {
+			action: { const: "copy" },
+			text: { type: "string" }
+		},
+		required: ["action", "text"]
+	}
+] };
+const renderUiToolName = "render_ui";
+const typeOk = (type, value) => {
+	switch (type) {
+		case "string": return typeof value === "string";
+		case "number": return typeof value === "number" && Number.isFinite(value);
+		case "integer": return Number.isInteger(value);
+		case "boolean": return typeof value === "boolean";
+		case "null": return value === null;
+		case "array": return Array.isArray(value);
+		case "object": return typeof value === "object" && value !== null && !Array.isArray(value);
+		default: return true;
+	}
+};
+const show = (v) => {
+	const text = JSON.stringify(v);
+	return text === void 0 ? String(v) : text.length > 40 ? text.slice(0, 37) + "..." : text;
+};
+const kind = (v) => v === null ? "null" : Array.isArray(v) ? "array" : typeof v;
+/**
+* Why `value` doesn't fit `schema`, one line per problem, each starting with its path ("props.items[2].label").
+* Empty when it fits. Covers the common JSON Schema keywords (type, enum, const, properties, required,
+* additionalProperties, items, anyOf/oneOf/allOf, lengths, ranges, pattern); others are ignored.
+*/
+function schemaErrors(schema, value, path = "value") {
+	if (schema === void 0 || schema === true) return [];
+	if (schema === false) return [`${path}: not allowed`];
+	const s = schema;
+	if (s.type !== void 0 && ![s.type].flat().some((t) => typeOk(t, value))) return [`${path}: expected ${[s.type].flat().join(" or ")}, got ${kind(value)} ${show(value)}`];
+	if (s.const !== void 0 && JSON.stringify(s.const) !== JSON.stringify(value)) return [`${path}: must be ${show(s.const)}`];
+	if (Array.isArray(s.enum) && !s.enum.some((e) => JSON.stringify(e) === JSON.stringify(value))) return [`${path}: must be one of ${s.enum.map(show).join(", ")}, got ${show(value)}`];
+	const anyOf = s.anyOf ?? s.oneOf;
+	if (Array.isArray(anyOf)) {
+		const each = anyOf.map((sub) => schemaErrors(sub, value, path));
+		if (!each.some((e) => e.length === 0)) return each.reduce((a, b) => b.length < a.length ? b : a);
+	}
+	const out = [];
+	if (Array.isArray(s.allOf)) for (const sub of s.allOf) out.push(...schemaErrors(sub, value, path));
+	if (typeof value === "string") {
+		if (typeof s.minLength === "number" && value.length < s.minLength) out.push(`${path}: at least ${s.minLength} characters`);
+		if (typeof s.maxLength === "number" && value.length > s.maxLength) out.push(`${path}: at most ${s.maxLength} characters`);
+		if (typeof s.pattern === "string" && !new RegExp(s.pattern).test(value)) out.push(`${path}: must match ${s.pattern}, got ${show(value)}`);
+	}
+	if (typeof value === "number") {
+		if (typeof s.minimum === "number" && value < s.minimum) out.push(`${path}: at least ${s.minimum}, got ${value}`);
+		if (typeof s.maximum === "number" && value > s.maximum) out.push(`${path}: at most ${s.maximum}, got ${value}`);
+	}
+	if (Array.isArray(value)) {
+		if (typeof s.minItems === "number" && value.length < s.minItems) out.push(`${path}: at least ${s.minItems} items, got ${value.length}`);
+		if (typeof s.maxItems === "number" && value.length > s.maxItems) out.push(`${path}: at most ${s.maxItems} items, got ${value.length}`);
+		if (s.items !== void 0) value.forEach((v, i) => out.push(...schemaErrors(s.items, v, `${path}[${i}]`)));
+	}
+	if (typeOk("object", value)) {
+		const obj = value;
+		const props = s.properties ?? {};
+		if (Array.isArray(s.required)) {
+			for (const k of s.required) if (obj[k] === void 0) out.push(`${path}.${k}: required`);
+		}
+		for (const [k, v] of Object.entries(obj)) if (k in props) out.push(...schemaErrors(props[k], v, `${path}.${k}`));
+		else if (s.additionalProperties === false) out.push(`${path}.${k}: unknown prop (allowed: ${Object.keys(props).join(", ") || "none"})`);
+		else if (s.additionalProperties !== void 0) out.push(...schemaErrors(s.additionalProperties, v, `${path}.${k}`));
+	}
+	return out;
+}
+/** Whether `value` fits `schema`; see `schemaErrors` for why not. */
+function matchesSchema(schema, value) {
+	return schemaErrors(schema, value).length === 0;
+}
+/** A prop that reads the widget's state: `{ "$state": "tab" }`. */
+function isStateRef(value) {
+	return typeof value === "object" && value !== null && typeof value.$state === "string";
+}
+/** The render tool for these components, with a description generated from them. */
+function renderUiTool(components) {
+	const list = components.map((c) => {
+		const props = c.props ? JSON.stringify(c.props) : "{}";
+		return `- ${c.name}${c.children ? " (takes children)" : ""}: ${c.description}\n  props: ${props}`;
+	}).join("\n");
+	return {
+		name: renderUiToolName,
+		description: `Show an interactive visual built from the app's components, inline in your reply.
+Write a tree: { "root": { "component": "<name>", "props": { ... }, "children": [ ...nodes ] }, "state": { ... } }.
+"root" is a JSON object, never a string. Only these components exist; a node with an unknown component or
+props that don't fit is not shown. One visual per answer: don't also draw the same thing another way.
+${list}
+
+Actions: a prop the schema marks as an action takes one of
+{ "action": "set", "key": "<state key>", "value": <any> } (change the widget's state; prefer this),
+{ "action": "send", "text": "..." } (send a message as the user, for what needs you),
+{ "action": "open", "url": "https://..." }, { "action": "copy", "text": "..." }.
+State: "state" holds starting values; any prop can read one with { "$state": "<key>" }.
+Set apart what you added or changed from what was already there.`,
+		inputSchema: {
+			type: "object",
+			properties: {
+				root: {
+					type: "object",
+					description: "The top node.",
+					properties: { component: { enum: components.map((c) => c.name) } },
+					required: ["component"]
+				},
+				state: {
+					type: "object",
+					description: "Starting values of the widget's state."
+				}
+			},
+			required: ["root"]
+		}
+	};
+}
+function checkUiTree(input, components, options = {}) {
+	const { toolName = renderUiToolName, where } = typeof options === "string" ? { toolName: options } : options;
+	const errors = [];
+	const byName = new Map(components.map((c) => [c.name, c]));
+	const lower = new Map(components.map((c) => [c.name.toLowerCase(), c.name]));
+	let total = 0;
+	let bad = 0;
+	const fail = (line) => errors.push(line);
+	const unwrap = (key, value) => {
+		if (typeof value !== "string") return value;
+		const { value: parsed, error } = salvageJson(value);
+		fail(`${key}: must be a JSON object like {"component":"Stack","children":[...]}, not a string: don't put it in quotes or escape it${error ? ` (the string also has ${error})` : ""}`);
+		return parsed;
+	};
+	const i = typeof input === "string" ? unwrap("input", input) : input;
+	if (typeof i !== "object" || i === null) return {
+		ok: false,
+		errors: ["input: expected an object"],
+		feedback: `Not shown: the input must be an object { "root": { "component": ..., "props": {...}, "children": [...] }, "state": {...} }. Call ${toolName} again.`
+	};
+	const { root, state: rawState } = i;
+	const state = unwrap("state", rawState);
+	if (state !== void 0 && (typeof state !== "object" || state === null || Array.isArray(state))) fail("state: expected an object of starting values");
+	const values = typeof state === "object" && state !== null ? state : {};
+	const walk = (node, path) => {
+		if (Array.isArray(node) && path === "root") return node.forEach((n, k) => walk(n, `root[${k}]`));
+		total++;
+		const at = where ? where(node, path) : path;
+		const before = errors.length;
+		if (typeof node !== "object" || node === null || Array.isArray(node)) {
+			fail(`${at}: expected a node { "component": ..., "props": {...} }, got ${kind(node)}`);
+			bad++;
+		} else {
+			const { component, props = {}, children, ...rest } = node;
+			const extra = Object.keys(rest);
+			if (typeof props === "object" && props !== null && "children" in props) fail(`${at}.props.children: children go in the node's "children" array, next to "props", not inside props`);
+			if (extra.length) fail(`${at}: unknown key ${extra.map((k) => `"${k}"`).join(", ")} (a node has only component, props, children)`);
+			const spec = typeof component === "string" ? byName.get(component) : void 0;
+			if (typeof component !== "string") fail(`${at}.component: required, one of ${components.map((c) => c.name).join(", ")}`);
+			else if (!spec) {
+				const near = lower.get(component.toLowerCase());
+				fail(`${at}.component: unknown "${component}"${near ? `; did you mean "${near}"?` : `; use one of ${components.map((c) => c.name).join(", ")}`}`);
+			}
+			if (typeof props !== "object" || props === null || Array.isArray(props)) fail(`${at}.props: expected an object`);
+			else if (spec) {
+				const unset = /* @__PURE__ */ new Set();
+				const resolve = (v, at) => {
+					if (isStateRef(v)) {
+						if (!(v.$state in values)) unset.add(at);
+						return values[v.$state];
+					}
+					if (Array.isArray(v)) return v.map((x, n) => resolve(x, `${at}[${n}]`));
+					if (typeof v === "object" && v !== null) return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, resolve(x, `${at}.${k}`)]).filter(([, x]) => x !== void 0));
+					return v;
+				};
+				const resolved = resolve(props, `${at}.props`);
+				for (const line of schemaErrors(spec.props ?? { type: "object" }, resolved, `${at}.props`)) {
+					if (line.startsWith(`${at}.props.children:`)) continue;
+					if (![...unset].some((u) => line.startsWith(u + ":") || line.startsWith(u + "."))) fail(line);
+				}
+			}
+			if (errors.length > before) bad++;
+			if (children !== void 0) {
+				if (spec && !spec.children) fail(`${at}.children: ${spec.name} takes no children (they are not shown)`);
+				else if (!Array.isArray(children)) fail(`${at}.children: expected an array of nodes`);
+				else children.forEach((child, n) => walk(child, `${path}.children[${n}]`));
+			}
+		}
+	};
+	if (root === void 0) fail("root: required");
+	else walk(unwrap("root", root), "root");
+	const ok = errors.length === 0;
+	return {
+		ok,
+		errors,
+		feedback: ok ? "Shown to the user." : `${bad === 0 ? "Not shown as written" : `Only part of it is shown: ${bad} of ${total} nodes were left out`}. Fix these and call ${toolName} again, without remarking on the fix to the user:\n` + errors.slice(0, 20).map((e) => `- ${e}`).join("\n") + (errors.length > 20 ? `\n- ...and ${errors.length - 20} more` : "")
+	};
+}
+// ../core/src/ui-markup.ts
+/**
+* UI as JSX in the reply: the model writes a ```ui fenced block in its normal text, e.g.
+*
+*   <State tab="stills" />
+*   <Card title="Pixel 9 Pro"><Metric label="Zoom" value="5x" /></Card>
+*
+* Every model has seen a lot of JSX; it streams element by element and needs no JSON escaping. The parser is
+* lenient where the intent is clear (JS-style objects, `{$state.k}`, `{"$state":"k"}`, text children) and
+* tolerates a block cut short while it streams.
+*/
+/** The fence language the kit draws as UI. */
+const uiMarkupLanguage = "ui";
+/** Reads a value written inside `{…}`: JSON, or a JS literal (unquoted keys, single quotes, trailing commas). */
+function readUiValue(source) {
+	const text = source.trim();
+	const ref = /^\$?state\.([\w-]+)$/.exec(text);
+	if (ref) return { value: { $state: ref[1] } };
+	try {
+		return { value: JSON.parse(text) };
+	} catch {}
+	if (/^"[^"]+"\s*:/.test(text)) try {
+		return { value: JSON.parse(`{${text}}`) };
+	} catch {}
+	let i = 0;
+	const fail = (what) => {
+		throw new Error(`${what} at "${text.slice(Math.max(0, i - 10), i + 10)}"`);
+	};
+	const space = () => {
+		while (i < text.length && /\s/.test(text[i])) i++;
+	};
+	const value = () => {
+		space();
+		const c = text[i];
+		if (c === "{") {
+			i++;
+			const out = {};
+			for (;;) {
+				space();
+				if (text[i] === "}") return i++, out;
+				const key = text[i] === "\"" || text[i] === "'" ? str() : word();
+				space();
+				if (text[i++] !== ":") fail("expected :");
+				out[key] = value();
+				space();
+				if (text[i] === ",") i++;
+				else if (text[i] !== "}") fail("expected , or }");
+			}
+		}
+		if (c === "[") {
+			i++;
+			const out = [];
+			for (;;) {
+				space();
+				if (text[i] === "]") return i++, out;
+				out.push(value());
+				space();
+				if (text[i] === ",") i++;
+				else if (text[i] !== "]") fail("expected , or ]");
+			}
+		}
+		if (c === "\"" || c === "'" || c === "`") return str();
+		const w = word();
+		if (w === "true") return true;
+		if (w === "false") return false;
+		if (w === "null" || w === "undefined") return null;
+		const ref = /^\$?state\.([\w-]+)$/.exec(w);
+		if (ref) return { $state: ref[1] };
+		if (/^-?\d/.test(w) && !Number.isNaN(Number(w))) return Number(w);
+		return fail(w ? `unknown name ${w} (JavaScript expressions are not run; write the value out)` : "expected a value");
+	};
+	const word = () => {
+		const m = /^[\w$.+-]+/.exec(text.slice(i));
+		if (!m) return "";
+		i += m[0].length;
+		return m[0];
+	};
+	const str = () => {
+		const q = text[i++];
+		let out = "";
+		while (i < text.length && text[i] !== q) {
+			if (text[i] === "\\") {
+				const e = text[++i];
+				out += e === "n" ? "\n" : e === "t" ? "	" : e;
+			} else out += text[i];
+			i++;
+		}
+		if (text[i++] !== q) fail("unclosed string");
+		return out;
+	};
+	try {
+		const v = value();
+		space();
+		if (i < text.length) fail("unexpected text");
+		return { value: v };
+	} catch (error) {
+		return { error: error.message };
+	}
+}
+/** Parses UI markup (the inside of a ```ui block). Safe on any prefix of it. */
+function parseUiMarkup(source) {
+	const lines = /* @__PURE__ */ new WeakMap();
+	const errors = [];
+	const state = {};
+	const top = [];
+	const stack = [];
+	let i = 0;
+	const lineAt = (at) => source.slice(0, at).split("\n").length;
+	const add = (node) => stack.length ? (stack.at(-1).node.children ??= []).push(node) : top.push(node);
+	const braceEnd = (from) => {
+		let depth = 0;
+		for (let j = from; j < source.length; j++) {
+			const c = source[j];
+			if (c === "\"" || c === "'" || c === "`") {
+				for (j++; j < source.length && source[j] !== c; j++) if (source[j] === "\\") j++;
+			} else if (c === "{") depth++;
+			else if (c === "}" && --depth === 0) return j;
+		}
+		return -1;
+	};
+	const flushText = (end) => {
+		const open = stack.at(-1);
+		const text = source.slice(i, end);
+		if (!text.trim()) return;
+		if (open) open.text.push(text);
+		else errors.push(`line ${lineAt(i)}: text outside any component (put it in a component, e.g. <Text text="…" />)`);
+	};
+	const close = (open) => {
+		const text = open.text.join("").replace(/\s+/g, " ").trim();
+		if (text && !open.node.children?.length) {
+			const props = open.node.props ??= {};
+			if (!("text" in props)) props.text = text;
+		}
+	};
+	while (i < source.length) {
+		const lt = source.indexOf("<", i);
+		const brace = source.indexOf("{", i);
+		if (brace >= 0 && (lt < 0 || brace < lt) && stack.length) {
+			const end = braceEnd(brace);
+			flushText(brace);
+			const inner = source.slice(brace + 1, end < 0 ? void 0 : end).trim();
+			if (end >= 0 && !/^\/\*[\s\S]*\*\/$/.test(inner)) {
+				const { value, error } = readUiValue(inner);
+				if (typeof value === "string") stack.at(-1).text.push(value);
+				else errors.push(`line ${lineAt(brace)}: {${inner.slice(0, 40)}} as a child is not supported${error ? ` (${error})` : ""}; write the elements out`);
+			}
+			if (end < 0) break;
+			i = end + 1;
+			continue;
+		}
+		if (lt < 0) {
+			flushText(source.length);
+			i = source.length;
+			break;
+		}
+		flushText(lt);
+		i = lt;
+		if (source.startsWith("<!--", i)) {
+			const end = source.indexOf("-->", i);
+			if (end < 0) break;
+			i = end + 3;
+			continue;
+		}
+		const closing = /^<\/\s*([A-Za-z][\w.]*)?\s*>/.exec(source.slice(i));
+		if (closing) {
+			const name = closing[1];
+			const at = name ? stack.map((o) => o.node.component).lastIndexOf(name) : stack.length - 1;
+			if (at < 0) errors.push(`line ${lineAt(i)}: </${name}> closes nothing`);
+			else for (const open of stack.splice(at).reverse()) {
+				if (open !== stack[at] && open.node.component !== name && name) errors.push(`line ${lineAt(i)}: <${open.node.component}> was not closed before </${name}>`);
+				close(open);
+			}
+			i += closing[0].length;
+			continue;
+		}
+		if (/^<\/[^>]*$/.test(source.slice(i))) break;
+		const name = /^<([A-Za-z][\w.]*)/.exec(source.slice(i));
+		if (!name) {
+			const open = stack.at(-1);
+			if (open) open.text.push("<");
+			i++;
+			continue;
+		}
+		const start = i;
+		let j = i + name[0].length;
+		const props = {};
+		let done;
+		let cut = false;
+		while (j < source.length) {
+			const ws = /^\s*/.exec(source.slice(j))[0].length;
+			j += ws;
+			if (source.startsWith("/>", j)) {
+				done = "self";
+				j += 2;
+				break;
+			}
+			if (source[j] === "/" && j === source.length - 1) break;
+			if (source[j] === ">") {
+				done = "open";
+				j++;
+				break;
+			}
+			const attr = /^([A-Za-z_$][\w$:-]*)/.exec(source.slice(j));
+			if (!attr) {
+				if (j < source.length) errors.push(`line ${lineAt(j)}: <${name[1]}>: unexpected "${source[j]}"`);
+				j++;
+				continue;
+			}
+			j += attr[0].length;
+			const key = attr[1];
+			const eq = /^\s*=\s*/.exec(source.slice(j));
+			if (!eq) {
+				props[key] = true;
+				continue;
+			}
+			j += eq[0].length;
+			const q = source[j];
+			if (q === "\"" || q === "'") {
+				const end = source.indexOf(q, j + 1);
+				if (end < 0) {
+					cut = true;
+					break;
+				}
+				props[key] = source.slice(j + 1, end);
+				j = end + 1;
+			} else if (q === "{") {
+				const end = braceEnd(j);
+				if (end < 0) {
+					cut = true;
+					break;
+				}
+				const { value, error } = readUiValue(source.slice(j + 1, end));
+				if (error) errors.push(`line ${lineAt(j)}: <${name[1]}> ${key}: can't read {${source.slice(j + 1, end).slice(0, 60)}}: ${error}`);
+				else props[key] = value;
+				j = end + 1;
+			} else if (q === void 0) {
+				cut = true;
+				break;
+			} else {
+				const bare = /^[^\s/>]+/.exec(source.slice(j))[0];
+				props[key] = bare;
+				j += bare.length;
+			}
+		}
+		if (cut || !done) break;
+		i = j;
+		if (name[1] === "State") {
+			if (stack.length) errors.push(`line ${lineAt(start)}: <State> goes at the top, outside other components`);
+			Object.assign(state, props);
+			if (done === "open") stack.push({
+				node: { component: "State" },
+				text: []
+			});
+			continue;
+		}
+		const node = {
+			component: name[1],
+			...Object.keys(props).length && { props }
+		};
+		lines.set(node, lineAt(start));
+		add(node);
+		if (done === "open") stack.push({
+			node,
+			text: []
+		});
+	}
+	const complete = stack.filter((o) => o.node.component !== "State").length === 0;
+	for (const open of stack.reverse()) close(open);
+	return {
+		nodes: top,
+		state,
+		errors,
+		complete,
+		lineOf: (node) => lines.get(node)
+	};
+}
+/** Finds the ```ui blocks in reply text (the last may still be open while it streams). */
+function findUiBlocks(text, language = "ui") {
+	const blocks = [];
+	const open = new RegExp("^([ \\t]*)(`{3,}|~{3,})[ \\t]*" + language.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "[ \\t]*$", "gm");
+	for (let m; m = open.exec(text);) {
+		const start = m.index + m[0].length + 1;
+		const fence = m[2];
+		const close = new RegExp("^[ \\t]*" + fence[0] + "{" + fence.length + ",}[ \\t]*$", "m").exec(text.slice(start));
+		const end = close ? start + close.index : text.length;
+		blocks.push({
+			source: text.slice(start, end),
+			offset: start,
+			closed: !!close
+		});
+		if (!close) break;
+		open.lastIndex = end + close[0].length;
+	}
+	return blocks;
+}
+/**
+* Checks the ```ui blocks in a finished reply against the host's components, so the harness can tell the
+* model what to fix (in its own words: line numbers, "did you mean", the props a component takes).
+*/
+function checkUiMarkup(text, components, language = "ui") {
+	const blocks = findUiBlocks(text, language);
+	const errors = [];
+	blocks.forEach((block, n) => {
+		const where = blocks.length > 1 ? `block ${n + 1}, ` : "";
+		if (!block.closed) errors.push(`${where}the block is not closed with \`\`\``);
+		errors.push(...markupErrors(block.source, components, where, block.closed));
+	});
+	const ok = errors.length === 0;
+	return {
+		ok,
+		errors,
+		feedback: ok ? "" : `The \`\`\`${language} block in your last reply did not fully show. Problems:\n` + list(errors) + `\nWhen you next write UI, avoid these. If the user still needs it, write the block again, fixed.`
+	};
+}
+function markupErrors(source, components, where = "", closed = true) {
+	const errors = [];
+	const parsed = parseUiMarkup(source);
+	for (const e of parsed.errors) errors.push(where + e);
+	if (closed && !parsed.complete) errors.push(`${where}some elements are not closed`);
+	if (!parsed.nodes.length) errors.push(`${where}no components`);
+	const check = checkUiTree({
+		root: parsed.nodes,
+		state: parsed.state
+	}, components, { where: (node, path) => {
+		const line = isNode(node) ? parsed.lineOf(node) : void 0;
+		const name = isNode(node) ? `<${node.component}>` : path;
+		return `${where}${line ? `line ${line} ` : ""}${name}`;
+	} });
+	errors.push(...check.errors);
+	return errors;
+}
+const list = (errors) => errors.slice(0, 20).map((e) => `- ${e}`).join("\n") + (errors.length > 20 ? `\n- ...and ${errors.length - 20} more` : "");
+const isNode = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && typeof v.component === "string";
+function hint(schema, inner = false) {
+	const s = schema ?? {};
+	if (Array.isArray(s.enum)) return s.enum.map((e) => JSON.stringify(e)).join("|");
+	if (Array.isArray(s.anyOf)) return inner ? "action" : "{action}";
+	const type = Array.isArray(s.type) ? s.type[0] : s.type;
+	const wrap = (v) => inner ? v : `{${v}}`;
+	if (type === "string") return inner ? "text" : "\"…\"";
+	if (type === "number" || type === "integer") return wrap("number");
+	if (type === "boolean") return wrap("true|false");
+	if (type === "array") return wrap(`[${hint(s.items, true)}, …]`);
+	if (type === "object" && s.properties) {
+		const req = new Set(s.required ?? []);
+		return wrap(`{${Object.keys(s.properties).map((k) => k + (req.has(k) ? "" : "?")).join(", ")}}`);
+	}
+	return wrap("value");
+}
+function markupRules(components) {
+	const line = (c) => {
+		const props = c.props?.properties ?? {};
+		const req = new Set(c.props?.required ?? []);
+		const attrs = Object.entries(props).map(([k, v]) => `${k}${req.has(k) ? "" : "?"}=${hint(v)}`);
+		return `- ${`<${c.name}${attrs.length ? " " + attrs.join(" ") : ""}${c.children ? `>…</${c.name}>` : " />"}`}\n  ${c.description}`;
+	};
+	return `Only these components exist:
+${components.map(line).join("\n")}
+
+How to write it
+- Plain JSX: strings as attr="text"; numbers, lists and objects in braces, e.g. items={[{"label": "Tent"}]}.
+- Components marked >…< take other components inside them; the rest close with />.
+- Actions (for onPress and similar): {"action":"send","text":"…"} sends that text to you as the user;
+  {"action":"set","key":"k","value":…} changes local state; {"action":"open","url":"https://…"};
+  {"action":"copy","text":"…"}.
+- Local state: start values on the first line, <State tab="overview" />; read one with attr={$state.tab}.
+- No JavaScript: no .map(), no variables, no functions. Write every element out.`;
+}
+/** The suggested UI tool's name. */
+const showUiToolName = "show_ui";
+/**
+* A suggested tool for drawing UI from your components: the model passes JSX as a string, which streams
+* into the chat element by element (draw it with `uiMarkupToolView`), and the harness answers the call with
+* `checkUiMarkupCode(...).feedback`. Built only from the components, so it is byte-stable across turns.
+*/
+function showUiTool(components, name = showUiToolName) {
+	return {
+		name,
+		description: "Show interactive UI inline in your reply, built from the app's components: options to compare, a plan, a checklist, numbers at a glance. Write JSX in `markup`. Keep explaining in text around it; one call per answer unless the user asks for more.\n\n" + markupRules(components),
+		inputSchema: {
+			type: "object",
+			properties: { markup: {
+				type: "string",
+				description: "JSX of the components above, e.g. <Card title=\"Plan\"><Metric label=\"Total\" value=\"€184\" /></Card>"
+			} },
+			required: ["markup"]
+		}
+	};
+}
+/**
+* Checks the markup of one UI tool call. Its `feedback` is the tool result to return: "Shown to the user." or
+* what to fix, by line and component.
+*/
+function checkUiMarkupCode(markup, components, toolName = showUiToolName) {
+	if (typeof markup !== "string" || !markup.trim()) return {
+		ok: false,
+		errors: ["markup: required, JSX of the components"],
+		feedback: `Not shown: markup is empty. Call ${toolName} again with JSX in markup.`
+	};
+	const errors = markupErrors(markup, components);
+	const ok = errors.length === 0;
+	return {
+		ok,
+		errors,
+		feedback: ok ? "Shown to the user." : `Not all of it is shown. Fix these and call ${toolName} again, without remarking on the fix to the user:\n` + list(errors)
+	};
+}
+/**
+* A suggested system-prompt section that teaches the model to write ```ui blocks in its reply text, if you'd
+* rather not use a tool. It only depends on the components, so it stays byte-stable across turns.
+*/
+function uiMarkupGuide(components, language = "ui") {
+	return `## Interactive UI in your reply
+When a visual helps more than text (options to compare, a plan, a checklist, numbers at a glance), write a
+\`\`\`${language} fenced block in your reply. It holds JSX of the app's components.
+${markupRules(components)}
+- Keep explaining in text around the block. One block per answer, unless the user asks for more.`;
+}
+export { salvageJson as A, awaitingToolCalls as C, resolveEffort as D, reduceEvents as E, settleToolCall as O, applyEvent as S, outputTokens as T, formatEvent as _, readUiValue as a, toBlocks as b, uiMarkupGuide as c, isStateRef as d, matchesSchema as f, uiActionSchema as g, schemaErrors as h, parseUiMarkup as i, parsePartialJson as k, uiMarkupLanguage as l, renderUiToolName as m, checkUiMarkupCode as n, showUiTool as o, renderUiTool as p, findUiBlocks as r, showUiToolName as s, checkUiMarkup as t, checkUiTree as u, readEventStream as v, estimateTokens as w, activityTokens as x, isActivityPart as y };