@ulearning/ai-generative-frame 0.0.0-stage → 1.0.0-next.0

package/dist/assistant-ui/snapshotSaver.d.ts

@@ -0,0 +1,11 @@
+export type SnapshotSaver<T> = {
+    /** Saves `read()` once changes settle, if it differs from the newest entry recorded. */
+    schedule(read: () => T): void;
+    /** Saves a change that is still waiting now rather than after the delay. */
+    flush(): void;
+};
+/**
+ * Saves snapshots of a tool call's UI state through `record`, 500 ms after the last change and when flushed, whenever the snapshot differs from the newest entry recorded; `initial` is that entry when saving starts. One record is in flight at a time, so entries land in the order they are sent, and a change made meanwhile is saved once it settles. When the current snapshot cannot be recorded, `record(null)` marks it, so the call starts fresh on its next mount rather than from an older snapshot; a marker that fails is sent again only after a newer snapshot is tried.
+ */
+export declare function createSnapshotSaver<T>(initial: T, record: (snapshot: T | null) => unknown): SnapshotSaver<T>;
+//# sourceMappingURL=snapshotSaver.d.ts.map

package/dist/assistant-ui/snapshotSaver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotSaver.d.ts","mappings":"AAoCA,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;IAC7B;IACA,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI;IAC7B;IACA,KAAK,IAAI,IAAI;CACd;AAED;;;AAGA,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,KAAK,OAAO,GACtC,aAAa,CAAC,CAAC,CAAC","names":[],"ignoreList":[],"sources":["../../src/assistant-ui/snapshotSaver.ts"],"sourcesContent":[null]}

package/dist/assistant-ui/snapshotSaver.js

@@ -0,0 +1,83 @@
+// src/assistant-ui/snapshotSaver.ts
+const SAVE_DELAY_MS = 500;
+/** The snapshot as JSON only when it is plain JSON throughout, since `JSON.stringify` quietly turns `NaN`, `undefined`, and class instances into other values, which would compare equal to a different snapshot and restore something else. */
+const serialize = (snapshot) => {
+	try {
+		return JSON.stringify(snapshot, function(key, value) {
+			const raw = this[key];
+			if (raw === null || typeof raw === "string" || typeof raw === "boolean" || typeof raw === "number" && Number.isFinite(raw)) return value;
+			if (typeof raw === "object" && typeof raw.toJSON !== "function") {
+				const prototype = Object.getPrototypeOf(raw);
+				if (Array.isArray(raw) ? prototype === Array.prototype : prototype === Object.prototype || prototype === null) return value;
+			}
+			throw new TypeError("Not plain JSON");
+		});
+	} catch {
+		return;
+	}
+};
+/**
+* Saves snapshots of a tool call's UI state through `record`, 500 ms after the last change and when flushed, whenever the snapshot differs from the newest entry recorded; `initial` is that entry when saving starts. One record is in flight at a time, so entries land in the order they are sent, and a change made meanwhile is saved once it settles. When the current snapshot cannot be recorded, `record(null)` marks it, so the call starts fresh on its next mount rather than from an older snapshot; a marker that fails is sent again only after a newer snapshot is tried.
+*/
+function createSnapshotSaver(initial, record) {
+	let recorded = JSON.stringify(initial);
+	let failed;
+	let markerFailed = false;
+	let busy = false;
+	let timer;
+	let read;
+	const send = (snapshot, json, marker) => {
+		busy = true;
+		let result;
+		try {
+			result = Promise.resolve(record(snapshot));
+		} catch (error) {
+			result = Promise.reject(error);
+		}
+		result.then(() => {
+			recorded = json;
+			if (!marker) failed = void 0;
+		}, () => {
+			if (marker) markerFailed = true;
+			else failed = json;
+		}).finally(() => {
+			busy = false;
+			if (timer === void 0) save();
+		});
+	};
+	const save = () => {
+		if (busy || !read) return;
+		let snapshot;
+		let json;
+		try {
+			snapshot = read();
+			json = serialize(snapshot);
+		} catch {}
+		if (json === recorded) return;
+		if (json !== void 0 && json !== failed) {
+			markerFailed = false;
+			send(snapshot, json, false);
+			return;
+		}
+		if (recorded !== "null" && !markerFailed) send(null, "null", true);
+	};
+	return {
+		schedule(next) {
+			read = next;
+			clearTimeout(timer);
+			timer = setTimeout(() => {
+				timer = void 0;
+				save();
+			}, SAVE_DELAY_MS);
+		},
+		flush() {
+			if (timer === void 0) return;
+			clearTimeout(timer);
+			timer = void 0;
+			save();
+		}
+	};
+}
+export { createSnapshotSaver };
+
+//# sourceMappingURL=snapshotSaver.js.map

package/dist/assistant-ui/snapshotSaver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshotSaver.js","names":[],"sources":["../../src/assistant-ui/snapshotSaver.ts"],"sourcesContent":["const SAVE_DELAY_MS = 500;\n\n/** The snapshot as JSON only when it is plain JSON throughout, since `JSON.stringify` quietly turns `NaN`, `undefined`, and class instances into other values, which would compare equal to a different snapshot and restore something else. */\nconst serialize = (snapshot: unknown): string | undefined => {\n  try {\n    return JSON.stringify(\n      snapshot,\n      function (this: Record<string, unknown>, key: string, value: unknown) {\n        const raw = this[key];\n        if (\n          raw === null ||\n          typeof raw === \"string\" ||\n          typeof raw === \"boolean\" ||\n          (typeof raw === \"number\" && Number.isFinite(raw))\n        )\n          return value;\n        if (\n          typeof raw === \"object\" &&\n          typeof (raw as { toJSON?: unknown }).toJSON !== \"function\"\n        ) {\n          const prototype = Object.getPrototypeOf(raw);\n          if (\n            Array.isArray(raw)\n              ? prototype === Array.prototype\n              : prototype === Object.prototype || prototype === null\n          )\n            return value;\n        }\n        throw new TypeError(\"Not plain JSON\");\n      },\n    );\n  } catch {\n    return undefined;\n  }\n};\n\nexport type SnapshotSaver<T> = {\n  /** Saves `read()` once changes settle, if it differs from the newest entry recorded. */\n  schedule(read: () => T): void;\n  /** Saves a change that is still waiting now rather than after the delay. */\n  flush(): void;\n};\n\n/**\n * Saves snapshots of a tool call's UI state through `record`, 500 ms after the last change and when flushed, whenever the snapshot differs from the newest entry recorded; `initial` is that entry when saving starts. One record is in flight at a time, so entries land in the order they are sent, and a change made meanwhile is saved once it settles. When the current snapshot cannot be recorded, `record(null)` marks it, so the call starts fresh on its next mount rather than from an older snapshot; a marker that fails is sent again only after a newer snapshot is tried.\n */\nexport function createSnapshotSaver<T>(\n  initial: T,\n  record: (snapshot: T | null) => unknown,\n): SnapshotSaver<T> {\n  let recorded = JSON.stringify(initial);\n  let failed: string | undefined;\n  let markerFailed = false;\n  let busy = false;\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  let read: (() => T) | undefined;\n\n  const send = (snapshot: T | null, json: string, marker: boolean) => {\n    busy = true;\n    let result: Promise<unknown>;\n    try {\n      result = Promise.resolve(record(snapshot));\n    } catch (error) {\n      result = Promise.reject(error);\n    }\n    void result\n      .then(\n        () => {\n          recorded = json;\n          if (!marker) failed = undefined;\n        },\n        () => {\n          if (marker) markerFailed = true;\n          else failed = json;\n        },\n      )\n      .finally(() => {\n        busy = false;\n        if (timer === undefined) save();\n      });\n  };\n\n  const save = () => {\n    if (busy || !read) return;\n    let snapshot: T | undefined;\n    let json: string | undefined;\n    try {\n      snapshot = read();\n      json = serialize(snapshot);\n    } catch {}\n    if (json === recorded) return;\n    if (json !== undefined && json !== failed) {\n      markerFailed = false;\n      send(snapshot as T, json, false);\n      return;\n    }\n    if (recorded !== \"null\" && !markerFailed) send(null, \"null\", true);\n  };\n\n  return {\n    schedule(next) {\n      read = next;\n      clearTimeout(timer);\n      timer = setTimeout(() => {\n        timer = undefined;\n        save();\n      }, SAVE_DELAY_MS);\n    },\n    flush() {\n      if (timer === undefined) return;\n      clearTimeout(timer);\n      timer = undefined;\n      save();\n    },\n  };\n}\n"],"mappings":";AAAA,MAAM,gBAAgB;;AAGtB,MAAM,aAAa,aAA0C;CAC3D,IAAI;EACF,OAAO,KAAK,UACV,UACA,SAAyC,KAAa,OAAgB;GACpE,MAAM,MAAM,KAAK;GACjB,IACE,QAAQ,QACR,OAAO,QAAQ,YACf,OAAO,QAAQ,aACd,OAAO,QAAQ,YAAY,OAAO,SAAS,GAAG,GAE/C,OAAO;GACT,IACE,OAAO,QAAQ,YACf,OAAQ,IAA6B,WAAW,YAChD;IACA,MAAM,YAAY,OAAO,eAAe,GAAG;IAC3C,IACE,MAAM,QAAQ,GAAG,IACb,cAAc,MAAM,YACpB,cAAc,OAAO,aAAa,cAAc,MAEpD,OAAO;GACX;GACA,MAAM,IAAI,UAAU,gBAAgB;EACtC,CACF;CACF,QAAQ;EACN;CACF;AACF;;;;AAYA,SAAgB,oBACd,SACA,QACkB;CAClB,IAAI,WAAW,KAAK,UAAU,OAAO;CACrC,IAAI;CACJ,IAAI,eAAe;CACnB,IAAI,OAAO;CACX,IAAI;CACJ,IAAI;CAEJ,MAAM,QAAQ,UAAoB,MAAc,WAAoB;EAClE,OAAO;EACP,IAAI;EACJ,IAAI;GACF,SAAS,QAAQ,QAAQ,OAAO,QAAQ,CAAC;EAC3C,SAAS,OAAO;GACd,SAAS,QAAQ,OAAO,KAAK;EAC/B;EACA,OACG,WACO;GACJ,WAAW;GACX,IAAI,CAAC,QAAQ,SAAS,KAAA;EACxB,SACM;GACJ,IAAI,QAAQ,eAAe;QACtB,SAAS;EAChB,CACF,CAAC,CACA,cAAc;GACb,OAAO;GACP,IAAI,UAAU,KAAA,GAAW,KAAK;EAChC,CAAC;CACL;CAEA,MAAM,aAAa;EACjB,IAAI,QAAQ,CAAC,MAAM;EACnB,IAAI;EACJ,IAAI;EACJ,IAAI;GACF,WAAW,KAAK;GAChB,OAAO,UAAU,QAAQ;EAC3B,QAAQ,CAAC;EACT,IAAI,SAAS,UAAU;EACvB,IAAI,SAAS,KAAA,KAAa,SAAS,QAAQ;GACzC,eAAe;GACf,KAAK,UAAe,MAAM,KAAK;GAC/B;EACF;EACA,IAAI,aAAa,UAAU,CAAC,cAAc,KAAK,MAAM,QAAQ,IAAI;CACnE;CAEA,OAAO;EACL,SAAS,MAAM;GACb,OAAO;GACP,aAAa,KAAK;GAClB,QAAQ,iBAAiB;IACvB,QAAQ,KAAA;IACR,KAAK;GACP,GAAG,aAAa;EAClB;EACA,QAAQ;GACN,IAAI,UAAU,KAAA,GAAW;GACzB,aAAa,KAAK;GAClB,QAAQ,KAAA;GACR,KAAK;EACP;CACF;AACF"}

package/dist/assistant-ui/tool-calls.d.ts

@@ -0,0 +1,21 @@
+/** The part of a thread message the history readers need. */
+export type MessageLike = {
+    readonly content: string | readonly unknown[];
+    readonly status?: {
+        readonly type: string;
+    };
+};
+/** A tool call as the history readers see it. */
+export type ToolCall = {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    argsText: string | undefined;
+    result: unknown;
+    /** Whether the arguments can no longer change, read as core reads a tool call's status: it has a final result, or its message is no longer running. */
+    settled: boolean;
+};
+export declare function toolCalls(messages: readonly MessageLike[]): Generator<ToolCall>;
+/** Whether a later call in the same message, with this call's whole title, takes over what this call shows, as `takesOver` decides. A call in a later message never does, since earlier messages are the conversation's history. */
+export declare function hasLaterToolCallInMessage(messages: readonly MessageLike[], toolCallId: string, title: string, takesOver: (call: ToolCall) => boolean): boolean;
+//# sourceMappingURL=tool-calls.d.ts.map

package/dist/assistant-ui/tool-calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-calls.d.ts","mappings":"AAUA;AACA,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE;IAC7C,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM;KAAE;CAC5C;AAED;AACA,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,MAAM;IACV,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS;IAC5B,MAAM,EAAE,OAAO;IACf;IACA,OAAO,EAAE,OAAO;CACjB;AAED,wBAAiB,SAAS,CACxB,QAAQ,EAAE,SAAS,WAAW,EAAE,GAC/B,SAAS,CAAC,QAAQ,CAAC;AA8DtB;AACA,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,GACrC,OAAO","names":[],"ignoreList":[],"sources":["../../src/assistant-ui/tool-calls.ts"],"sourcesContent":[null]}

package/dist/assistant-ui/tool-calls.js

@@ -0,0 +1,65 @@
+// src/assistant-ui/tool-calls.ts
+function* toolCalls(messages) {
+	for (const message of messages) {
+		if (typeof message.content === "string") continue;
+		const running = message.status?.type === "running";
+		for (const part of message.content) {
+			const call = part;
+			if (call?.type === "tool-call" && call.toolCallId && call.toolName) yield {
+				id: call.toolCallId,
+				name: call.toolName,
+				args: call.args ?? {},
+				argsText: typeof call.argsText === "string" ? call.argsText : void 0,
+				result: call.result,
+				settled: call.result !== void 0 && call.isPreliminary !== true || !running
+			};
+		}
+	}
+}
+const STRING_TOKEN = /"(?:[^"\\]|\\.)*"/y;
+const decode = (token) => {
+	try {
+		return JSON.parse(token);
+	} catch {
+		return;
+	}
+};
+/** The top-level `title` of streamed arguments once its string has closed, whatever escaping it was written with. */
+const streamedTitle = (argsText) => {
+	let depth = 0;
+	let key;
+	let inValue = false;
+	for (let i = 0; i < argsText.length; i++) {
+		const char = argsText[i];
+		if (char === "\"") {
+			STRING_TOKEN.lastIndex = i;
+			const token = STRING_TOKEN.exec(argsText)?.[0];
+			if (token === void 0) return void 0;
+			if (depth === 1) {
+				if (!inValue) key = decode(token);
+				else if (key === "title") return decode(token);
+				else inValue = false;
+			}
+			i += token.length - 1;
+		} else if (char === "{" || char === "[") depth++;
+		else if (char === "}" || char === "]") depth--;
+		else if (depth === 1 && char === ":") inValue = true;
+		else if (depth === 1 && char === ",") inValue = false;
+	}
+};
+/** Whether streamed arguments hold this whole title, not a prefix of a longer one that is still arriving. */
+const holdsTitle = (argsText, title) => argsText === void 0 || streamedTitle(argsText) === title;
+/** Whether a later call in the same message, with this call's whole title, takes over what this call shows, as `takesOver` decides. A call in a later message never does, since earlier messages are the conversation's history. */
+function hasLaterToolCallInMessage(messages, toolCallId, title, takesOver) {
+	if (!title) return false;
+	for (const message of messages) {
+		let seen = false;
+		for (const call of toolCalls([message])) if (call.id === toolCallId) seen = true;
+		else if (seen && call.args["title"] === title && holdsTitle(call.argsText, title) && takesOver(call)) return true;
+		if (seen) return false;
+	}
+	return false;
+}
+export { hasLaterToolCallInMessage, toolCalls };
+
+//# sourceMappingURL=tool-calls.js.map

package/dist/assistant-ui/tool-calls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-calls.js","names":[],"sources":["../../src/assistant-ui/tool-calls.ts"],"sourcesContent":["type ToolCallLike = {\n  type: string;\n  toolName?: string;\n  toolCallId?: string;\n  args?: unknown;\n  argsText?: unknown;\n  result?: unknown;\n  isPreliminary?: unknown;\n};\n\n/** The part of a thread message the history readers need. */\nexport type MessageLike = {\n  readonly content: string | readonly unknown[];\n  readonly status?: { readonly type: string };\n};\n\n/** A tool call as the history readers see it. */\nexport type ToolCall = {\n  id: string;\n  name: string;\n  args: Record<string, unknown>;\n  argsText: string | undefined;\n  result: unknown;\n  /** Whether the arguments can no longer change, read as core reads a tool call's status: it has a final result, or its message is no longer running. */\n  settled: boolean;\n};\n\nexport function* toolCalls(\n  messages: readonly MessageLike[],\n): Generator<ToolCall> {\n  for (const message of messages) {\n    if (typeof message.content === \"string\") continue;\n    const running = message.status?.type === \"running\";\n    for (const part of message.content) {\n      const call = part as ToolCallLike;\n      if (call?.type === \"tool-call\" && call.toolCallId && call.toolName) {\n        yield {\n          id: call.toolCallId,\n          name: call.toolName,\n          args: (call.args ?? {}) as Record<string, unknown>,\n          argsText:\n            typeof call.argsText === \"string\" ? call.argsText : undefined,\n          result: call.result,\n          settled:\n            (call.result !== undefined && call.isPreliminary !== true) ||\n            !running,\n        };\n      }\n    }\n  }\n}\n\nconst STRING_TOKEN = /\"(?:[^\"\\\\]|\\\\.)*\"/y;\n\nconst decode = (token: string): unknown => {\n  try {\n    return JSON.parse(token);\n  } catch {\n    return undefined;\n  }\n};\n\n/** The top-level `title` of streamed arguments once its string has closed, whatever escaping it was written with. */\nconst streamedTitle = (argsText: string): unknown => {\n  let depth = 0;\n  let key: unknown;\n  let inValue = false;\n  for (let i = 0; i < argsText.length; i++) {\n    const char = argsText[i];\n    if (char === '\"') {\n      STRING_TOKEN.lastIndex = i;\n      const token = STRING_TOKEN.exec(argsText)?.[0];\n      if (token === undefined) return undefined;\n      if (depth === 1) {\n        if (!inValue) key = decode(token);\n        else if (key === \"title\") return decode(token);\n        else inValue = false;\n      }\n      i += token.length - 1;\n    } else if (char === \"{\" || char === \"[\") depth++;\n    else if (char === \"}\" || char === \"]\") depth--;\n    else if (depth === 1 && char === \":\") inValue = true;\n    else if (depth === 1 && char === \",\") inValue = false;\n  }\n  return undefined;\n};\n\n/** Whether streamed arguments hold this whole title, not a prefix of a longer one that is still arriving. */\nconst holdsTitle = (argsText: string | undefined, title: string) =>\n  argsText === undefined || streamedTitle(argsText) === title;\n\n/** Whether a later call in the same message, with this call's whole title, takes over what this call shows, as `takesOver` decides. A call in a later message never does, since earlier messages are the conversation's history. */\nexport function hasLaterToolCallInMessage(\n  messages: readonly MessageLike[],\n  toolCallId: string,\n  title: string,\n  takesOver: (call: ToolCall) => boolean,\n): boolean {\n  if (!title) return false;\n  for (const message of messages) {\n    let seen = false;\n    for (const call of toolCalls([message])) {\n      if (call.id === toolCallId) seen = true;\n      else if (\n        seen &&\n        call.args[\"title\"] === title &&\n        holdsTitle(call.argsText, title) &&\n        takesOver(call)\n      )\n        return true;\n    }\n    if (seen) return false;\n  }\n  return false;\n}\n"],"mappings":";AA2BA,UAAiB,UACf,UACqB;CACrB,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,OAAO,QAAQ,YAAY,UAAU;EACzC,MAAM,UAAU,QAAQ,QAAQ,SAAS;EACzC,KAAK,MAAM,QAAQ,QAAQ,SAAS;GAClC,MAAM,OAAO;GACb,IAAI,MAAM,SAAS,eAAe,KAAK,cAAc,KAAK,UACxD,MAAM;IACJ,IAAI,KAAK;IACT,MAAM,KAAK;IACX,MAAO,KAAK,QAAQ,CAAC;IACrB,UACE,OAAO,KAAK,aAAa,WAAW,KAAK,WAAW,KAAA;IACtD,QAAQ,KAAK;IACb,SACG,KAAK,WAAW,KAAA,KAAa,KAAK,kBAAkB,QACrD,CAAC;GACL;EAEJ;CACF;AACF;AAEA,MAAM,eAAe;AAErB,MAAM,UAAU,UAA2B;CACzC,IAAI;EACF,OAAO,KAAK,MAAM,KAAK;CACzB,QAAQ;EACN;CACF;AACF;;AAGA,MAAM,iBAAiB,aAA8B;CACnD,IAAI,QAAQ;CACZ,IAAI;CACJ,IAAI,UAAU;CACd,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;EACxC,MAAM,OAAO,SAAS;EACtB,IAAI,SAAS,MAAK;GAChB,aAAa,YAAY;GACzB,MAAM,QAAQ,aAAa,KAAK,QAAQ,CAAC,GAAG;GAC5C,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;GAChC,IAAI,UAAU,GAAG;IACf,IAAI,CAAC,SAAS,MAAM,OAAO,KAAK;SAC3B,IAAI,QAAQ,SAAS,OAAO,OAAO,KAAK;SACxC,UAAU;GACjB;GACA,KAAK,MAAM,SAAS;EACtB,OAAO,IAAI,SAAS,OAAO,SAAS,KAAK;OACpC,IAAI,SAAS,OAAO,SAAS,KAAK;OAClC,IAAI,UAAU,KAAK,SAAS,KAAK,UAAU;OAC3C,IAAI,UAAU,KAAK,SAAS,KAAK,UAAU;CAClD;AAEF;;AAGA,MAAM,cAAc,UAA8B,UAChD,aAAa,KAAA,KAAa,cAAc,QAAQ,MAAM;;AAGxD,SAAgB,0BACd,UACA,YACA,OACA,WACS;CACT,IAAI,CAAC,OAAO,OAAO;CACnB,KAAK,MAAM,WAAW,UAAU;EAC9B,IAAI,OAAO;EACX,KAAK,MAAM,QAAQ,UAAU,CAAC,OAAO,CAAC,GACpC,IAAI,KAAK,OAAO,YAAY,OAAO;OAC9B,IACH,QACA,KAAK,KAAK,aAAa,SACvB,WAAW,KAAK,UAAU,KAAK,KAC/B,UAAU,IAAI,GAEd,OAAO;EAEX,IAAI,MAAM,OAAO;CACnB;CACA,OAAO;AACT"}

package/dist/assistant-ui/toolkit.d.ts

@@ -0,0 +1,96 @@
+import { type Toolkit } from "@ulearning/ai-sdk";
+import { type MaybeRefOrGetter } from "vue";
+import type { ConsoleEntry, WidgetError } from "../protocol.js";
+import { type UseWidgetOptions } from "../vue/useWidget.js";
+import type { ThemeTokenSources } from "../theme.js";
+import { type WidgetRegistry } from "../tools/registry.js";
+import { type CreateWidgetToolsOptions, type WidgetInstructionsOptions, type WidgetTools } from "../tools/tools.js";
+import type { AnyTool } from "../tools/define.js";
+import type { ToolkitDisplay, WidgetToolkitExtension } from "./extension.js";
+/**
+ * Where theme tokens come from in an assistant-ui app: shadcn/ui variables
+ * first, because Tailwind v4 aliases `--color-accent` to shadcn's muted
+ * `--accent` rather than the primary color.
+ */
+export declare const ASSISTANT_UI_TOKEN_SOURCES: ThemeTokenSources;
+/** The app's assistant-ui (shadcn/ui) theme as widget tokens, kept in sync. */
+export declare function useAssistantUiThemeTokens(element?: Element | null): Readonly<import("vue").ShallowRef<import("../index.js").ThemeTokens>>;
+export type WidgetToolkitOptions = Omit<CreateWidgetToolsOptions, "registry"> & {
+    registry?: WidgetRegistry;
+    /**
+     * `frontend` (default): the tools execute in the browser and the server
+     * forwards their schemas (`frontendTools` from `@ulearning/ai-sdk-adapter`).
+     * `backend`: the server executes `createWidgetTools()` and the toolkit
+     * only renders.
+     */
+    execution?: "frontend" | "backend";
+    /** Options for every widget frame (csp, product, maxHeight, handlers, …). */
+    widget?: Omit<UseWidgetOptions, "tokens" | "initialState">;
+    /** Spec mode: `createSpecToolkit(catalog, { components })` from `generative-frame/spec/assistant-ui`. */
+    spec?: WidgetToolkitExtension;
+    /** More tools for the model, such as data lookups. They execute like the widget tools and render nothing in the thread. */
+    extraTools?: Record<string, AnyTool>;
+    /** Where the theme is read from. Defaults to the document root. */
+    themeElement?: Element | null;
+    /** How the widget tools are presented relative to the reasoning trace. Defaults to `standalone`. */
+    display?: ToolkitDisplay;
+    /**
+     * With frontend execution, `show_widget` and `edit_widget` wait for the
+     * frame to finish rendering and return its errors as `render`. `false`
+     * returns as soon as the code is stored.
+     */
+    renderReport?: RenderReportOptions | false;
+    /** Keep the PNG in `preview_widget` results. Defaults to false. */
+    previewScreenshot?: boolean;
+    /**
+     * The storage id of a widget's frame, from the thread's persisted id and
+     * the `toolCallId` of the `show_widget` call that created it, so a widget
+     * keeps its localStorage across reloads and edits. Defaults to
+     * `<remoteId>:<toolCallId>`, or `aui:<toolCallId>` while the thread has no
+     * remote id; `false` gives every frame a fresh origin. Derive it from host
+     * data only, never from tool arguments the model wrote.
+     */
+    widgetId?: false | ((call: {
+        toolCallId: string;
+        threadId: string | undefined;
+    }) => string);
+};
+export type RenderReportOptions = {
+    /** How long a tool result waits for the frame. Defaults to 10000 ms. */
+    timeoutMs?: number;
+    /** Wait after the code ends so late script errors are caught. Defaults to 300 ms. */
+    settleMs?: number;
+};
+/** How a widget rendered in the thread, attached to tool results as `render`. */
+export type WidgetRenderReport = {
+    status: "rendered";
+    ok: boolean;
+    blank: boolean;
+    height: number;
+    errors: WidgetError[];
+    /** Console warnings and errors, most recent last. */
+    console: ConsoleEntry[];
+    feedback: string;
+} | {
+    status: "timeout";
+    feedback: string;
+};
+export type WidgetToolkit = {
+    /** Pass to `Tools({ toolkit })`, or spread into your own toolkit. */
+    toolkit: Toolkit;
+    /** The tool definitions behind the toolkit, for instructions or the server. */
+    tools: WidgetTools & Record<string, AnyTool>;
+    /** Latest code per widget title. */
+    registry: WidgetRegistry;
+};
+/**
+ * Renders `show_widget`, `edit_widget`, and `render_spec` tool calls in an
+ * assistant-ui thread: widget code streams into a frame from the partial
+ * tool arguments, `sendPrompt` adds its text to the thread composer, and the
+ * frame follows the app's theme. With `execution: "frontend"` the tools run
+ * in the browser too, so the server only forwards their schemas.
+ */
+export declare function createWidgetToolkit(options?: WidgetToolkitOptions): WidgetToolkit;
+/** Adds the widget guidance to the model while this Vue scope is active. */
+export declare function useWidgetInstructions(tools: MaybeRefOrGetter<WidgetTools & Record<string, AnyTool>>, options?: MaybeRefOrGetter<WidgetInstructionsOptions>): void;
+//# sourceMappingURL=toolkit.d.ts.map

package/dist/assistant-ui/toolkit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolkit.d.ts","mappings":"AAAA,OAAO,EAKL,KAAK,OAAO,EAEb,MAAM,mBAAmB;AAC1B,OAAO,EAWL,KAAK,gBAAgB,EACtB,MAAM,KAAK;AAGZ,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAa;AAI5D,OAAO,EAAa,KAAK,gBAAgB,EAAE,MAAM,qBAAkB;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAU;AACjD,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,sBAAmB;AAC7E,OAAO,EAGL,KAAK,wBAAwB,EAI7B,KAAK,yBAAyB,EAC9B,KAAK,WAAW,EACjB,MAAM,mBAAgB;AACvB,OAAO,KAAK,EAAE,OAAO,EAAkB,MAAM,oBAAiB;AAO9D,OAAO,KAAK,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,gBAAa;AAWzE;;;;;AAKA,eAAO,MAAM,0BAA0B,EAAE,iBAexC;AAED;AACA,wBAAgB,yBAAyB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;AAIlE,MAAM,MAAM,oBAAoB,GAAG,IAAI,CACrC,wBAAwB,EACxB,UAAU,CACX,GAAG;IACF,QAAQ,CAAC,EAAE,cAAc;IACzB;;;;;;IAMA,SAAS,CAAC,EAAE,UAAU,GAAG,SAAS;IAClC;IACA,MAAM,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,QAAQ,GAAG,cAAc,CAAC;IAC1D;IACA,IAAI,CAAC,EAAE,sBAAsB;IAC7B;IACA,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACpC;IACA,YAAY,CAAC,EAAE,OAAO,GAAG,IAAI;IAC7B;IACA,OAAO,CAAC,EAAE,cAAc;IACxB;;;;;IAKA,YAAY,CAAC,EAAE,mBAAmB,GAAG,KAAK;IAC1C;IACA,iBAAiB,CAAC,EAAE,OAAO;IAC3B;;;;;;;;IAQA,QAAQ,CAAC,EACL,KAAK,GACL,CAAC,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM;QAAE,QAAQ,EAAE,MAAM,GAAG,SAAS;KAAE,KAAK,MAAM,CAAC;CAC7E;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC;IACA,SAAS,CAAC,EAAE,MAAM;IAClB;IACA,QAAQ,CAAC,EAAE,MAAM;CAClB;AAED;AACA,MAAM,MAAM,kBAAkB,GAC1B;IACE,MAAM,EAAE,UAAU;IAClB,EAAE,EAAE,OAAO;IACX,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,MAAM;IACd,MAAM,EAAE,WAAW,EAAE;IACrB;IACA,OAAO,EAAE,YAAY,EAAE;IACvB,QAAQ,EAAE,MAAM;CACjB,GACD;IAAE,MAAM,EAAE,SAAS;IAAE,QAAQ,EAAE,MAAM;CAAE;AAE3C,MAAM,MAAM,aAAa,GAAG;IAC1B;IACA,OAAO,EAAE,OAAO;IAChB;IACA,KAAK,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5C;IACA,QAAQ,EAAE,cAAc;CACzB;AAuHD;;;;;;;AAOA,wBAAgB,mBAAmB,CACjC,OAAO,GAAE,oBAAyB,GACjC,aAAa;AA2ahB;AACA,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,gBAAgB,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC9D,OAAO,GAAE,gBAAgB,CAAC,yBAAyB,CAAM,GACxD,IAAI","names":[],"ignoreList":[],"sources":["../../src/assistant-ui/toolkit.tsx"],"sourcesContent":[null]}