agentic-ui-kit 0.2.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-ui-kit",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "React UI kit for LLM chat and agentic apps: streaming messages, tool calls, approvals, themable with CSS variables.",
   "license": "MIT",
   "type": "module",

package/dist/sse-BA_ebMcH.js

@@ -1,408 +0,0 @@
-// ../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);
-}
-// ../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", "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"));
-}
-export { activityTokens as a, estimateTokens as c, resolveEffort as d, settleToolCall as f, toBlocks as i, outputTokens as l, readEventStream as n, applyEvent as o, parsePartialJson as p, isActivityPart as r, awaitingToolCalls as s, formatEvent as t, reduceEvents as u };