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

package/dist/unstable/useMessageStallDetection.js

@@ -0,0 +1,92 @@
+"use client";
+import { computed, shallowRef, toValue } from "vue";
+import { useAuiState } from "@ulearning/ai-store";
+import { useIsomorphicLayoutEffect, useShallowSelector } from "@ulearning/ai-store/internal";
+// src/unstable/useMessageStallDetection.ts
+/**
+* Detects mid-run output stalls on the current message: while the message is
+* running, watches its text, reasoning, and tool-argument values plus tool-result
+* availability and reports a stall once they stop changing for `thresholdMs`.
+* Useful for re-surfacing a "still working" indicator during tool think-time or
+* provider stalls, after the first tokens have already streamed.
+*
+* Must be used inside a message scope.
+*
+* @deprecated Experimental since 2026-06-13. Not scheduled for removal; the API may change in any release.
+*/
+function unstable_useMessageStallDetection(options = void 0) {
+	const thresholdMs = computed(() => toValue(options)?.thresholdMs ?? 2e3);
+	const activity = useAuiState(useShallowSelector((s) => {
+		if (!(s.message.status?.type === "running")) return [false];
+		const values = [true, s.message.content.length];
+		for (const part of s.message.content) if (part.type === "text" || part.type === "reasoning") values.push(part.type, part.text);
+		else if (part.type === "tool-call") values.push(part.type, part.argsText, part.result !== void 0);
+		else values.push(part.type);
+		return values;
+	}));
+	const running = computed(() => activity.value[0] === true);
+	let lastActivity = 0;
+	let lastObservedActivity;
+	let observing = false;
+	const stalled = shallowRef(false);
+	const now = shallowRef(0);
+	useIsomorphicLayoutEffect(() => {
+		return () => {
+			observing = false;
+		};
+	}, []);
+	useIsomorphicLayoutEffect(() => {
+		if (!running.value) {
+			observing = false;
+			stalled.value = false;
+			return;
+		}
+		if (!observing || lastObservedActivity !== activity.value) {
+			lastActivity = Date.now();
+			lastObservedActivity = activity.value;
+			observing = true;
+		}
+		let active = true;
+		const stall = () => {
+			if (!active) return;
+			now.value = Date.now();
+			stalled.value = true;
+		};
+		const sinceActivity = Date.now() - lastActivity;
+		if (sinceActivity >= thresholdMs.value) {
+			stall();
+			return;
+		}
+		stalled.value = false;
+		const id = setTimeout(stall, thresholdMs.value - sinceActivity);
+		return () => {
+			active = false;
+			clearTimeout(id);
+		};
+	}, () => [
+		running.value,
+		activity.value,
+		thresholdMs.value
+	]);
+	useIsomorphicLayoutEffect(() => {
+		if (!stalled.value) return void 0;
+		let active = true;
+		const id = setInterval(() => {
+			if (active) now.value = Date.now();
+		}, 1e3);
+		return () => {
+			active = false;
+			clearInterval(id);
+		};
+	}, () => [stalled.value]);
+	return computed(() => !stalled.value ? {
+		stalled: false,
+		stalledForMs: 0
+	} : {
+		stalled: true,
+		stalledForMs: Math.max(0, now.value - lastActivity)
+	});
+}
+export { unstable_useMessageStallDetection };
+
+//# sourceMappingURL=useMessageStallDetection.js.map

package/dist/unstable/useMessageStallDetection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMessageStallDetection.js","names":[],"sources":["../../src/unstable/useMessageStallDetection.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  computed,\n  shallowRef,\n  toValue,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n} from \"vue\";\nimport { useAuiState } from \"@ulearning/ai-store\";\nimport {\n  useIsomorphicLayoutEffect,\n  useShallowSelector,\n} from \"@ulearning/ai-store/internal\";\n\n/** @deprecated Experimental since 2026-06-13. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_MessageStallDetectionOptions = {\n  /**\n   * Milliseconds of unchanged message content before the message counts as\n   * stalled.\n   * @default 2000\n   */\n  thresholdMs?: number | undefined;\n};\n\n/** @deprecated Experimental since 2026-06-13. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_MessageStallDetection = {\n  /** True while the message is running and its content has not changed for at least `thresholdMs`. */\n  stalled: boolean;\n  /** Milliseconds since the last observed content change. `0` while not stalled. */\n  stalledForMs: number;\n};\n\n/**\n * Detects mid-run output stalls on the current message: while the message is\n * running, watches its text, reasoning, and tool-argument values plus tool-result\n * availability and reports a stall once they stop changing for `thresholdMs`.\n * Useful for re-surfacing a \"still working\" indicator during tool think-time or\n * provider stalls, after the first tokens have already streamed.\n *\n * Must be used inside a message scope.\n *\n * @deprecated Experimental since 2026-06-13. Not scheduled for removal; the API may change in any release.\n */\nexport function unstable_useMessageStallDetection(\n  options: MaybeRefOrGetter<\n    Unstable_MessageStallDetectionOptions | undefined\n  > = undefined,\n): ComputedRef<Unstable_MessageStallDetection> {\n  const thresholdMs = computed(() => toValue(options)?.thresholdMs ?? 2000);\n\n  const activity = useAuiState(\n    useShallowSelector((s) => {\n      const running = s.message.status?.type === \"running\";\n      if (!running) return [false];\n\n      const values: unknown[] = [true, s.message.content.length];\n\n      for (const part of s.message.content) {\n        if (part.type === \"text\" || part.type === \"reasoning\") {\n          values.push(part.type, part.text);\n        } else if (part.type === \"tool-call\") {\n          values.push(part.type, part.argsText, part.result !== undefined);\n        } else {\n          values.push(part.type);\n        }\n      }\n      return values;\n    }),\n  );\n\n  const running = computed(() => activity.value[0] === true);\n  let lastActivity = 0;\n  let lastObservedActivity: readonly unknown[] | undefined;\n  let observing = false;\n  const stalled = shallowRef(false);\n  const now = shallowRef(0);\n\n  useIsomorphicLayoutEffect(() => {\n    return () => {\n      observing = false;\n    };\n  }, []);\n\n  useIsomorphicLayoutEffect(\n    () => {\n      if (!running.value) {\n        observing = false;\n        stalled.value = false;\n        return undefined;\n      }\n\n      // KeepAlive may reconnect descendant activation hooks in reverse order.\n      // Observe activity and arm its timer together, so activation cannot compare\n      // the threshold with a timestamp from before the scope was paused.\n      if (!observing || lastObservedActivity !== activity.value) {\n        lastActivity = Date.now();\n        lastObservedActivity = activity.value;\n        observing = true;\n      }\n\n      let active = true;\n      const stall = () => {\n        if (!active) return;\n        now.value = Date.now();\n        stalled.value = true;\n      };\n      const sinceActivity = Date.now() - lastActivity;\n      if (sinceActivity >= thresholdMs.value) {\n        stall();\n        return undefined;\n      }\n\n      stalled.value = false;\n      const id = setTimeout(stall, thresholdMs.value - sinceActivity);\n      return () => {\n        active = false;\n        clearTimeout(id);\n      };\n    },\n    () => [running.value, activity.value, thresholdMs.value],\n  );\n\n  useIsomorphicLayoutEffect(\n    () => {\n      if (!stalled.value) return undefined;\n      let active = true;\n      const id = setInterval(() => {\n        if (active) now.value = Date.now();\n      }, 1000);\n      return () => {\n        active = false;\n        clearInterval(id);\n      };\n    },\n    () => [stalled.value],\n  );\n\n  return computed(() =>\n    !stalled.value\n      ? { stalled: false, stalledForMs: 0 }\n      : {\n          stalled: true,\n          stalledForMs: Math.max(0, now.value - lastActivity),\n        },\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA4CA,SAAgB,kCACd,UAEI,KAAA,GACyC;CAC7C,MAAM,cAAc,eAAe,QAAQ,OAAO,CAAC,EAAE,eAAe,GAAI;CAExE,MAAM,WAAW,YACf,oBAAoB,MAAM;EAExB,IAAI,EADY,EAAE,QAAQ,QAAQ,SAAS,YAC7B,OAAO,CAAC,KAAK;EAE3B,MAAM,SAAoB,CAAC,MAAM,EAAE,QAAQ,QAAQ,MAAM;EAEzD,KAAK,MAAM,QAAQ,EAAE,QAAQ,SAC3B,IAAI,KAAK,SAAS,UAAU,KAAK,SAAS,aACxC,OAAO,KAAK,KAAK,MAAM,KAAK,IAAI;OAC3B,IAAI,KAAK,SAAS,aACvB,OAAO,KAAK,KAAK,MAAM,KAAK,UAAU,KAAK,WAAW,KAAA,CAAS;OAE/D,OAAO,KAAK,KAAK,IAAI;EAGzB,OAAO;CACT,CAAC,CACH;CAEA,MAAM,UAAU,eAAe,SAAS,MAAM,OAAO,IAAI;CACzD,IAAI,eAAe;CACnB,IAAI;CACJ,IAAI,YAAY;CAChB,MAAM,UAAU,WAAW,KAAK;CAChC,MAAM,MAAM,WAAW,CAAC;CAExB,gCAAgC;EAC9B,aAAa;GACX,YAAY;EACd;CACF,GAAG,CAAC,CAAC;CAEL,gCACQ;EACJ,IAAI,CAAC,QAAQ,OAAO;GAClB,YAAY;GACZ,QAAQ,QAAQ;GAChB;EACF;EAKA,IAAI,CAAC,aAAa,yBAAyB,SAAS,OAAO;GACzD,eAAe,KAAK,IAAI;GACxB,uBAAuB,SAAS;GAChC,YAAY;EACd;EAEA,IAAI,SAAS;EACb,MAAM,cAAc;GAClB,IAAI,CAAC,QAAQ;GACb,IAAI,QAAQ,KAAK,IAAI;GACrB,QAAQ,QAAQ;EAClB;EACA,MAAM,gBAAgB,KAAK,IAAI,IAAI;EACnC,IAAI,iBAAiB,YAAY,OAAO;GACtC,MAAM;GACN;EACF;EAEA,QAAQ,QAAQ;EAChB,MAAM,KAAK,WAAW,OAAO,YAAY,QAAQ,aAAa;EAC9D,aAAa;GACX,SAAS;GACT,aAAa,EAAE;EACjB;CACF,SACM;EAAC,QAAQ;EAAO,SAAS;EAAO,YAAY;CAAK,CACzD;CAEA,gCACQ;EACJ,IAAI,CAAC,QAAQ,OAAO,OAAO,KAAA;EAC3B,IAAI,SAAS;EACb,MAAM,KAAK,kBAAkB;GAC3B,IAAI,QAAQ,IAAI,QAAQ,KAAK,IAAI;EACnC,GAAG,GAAI;EACP,aAAa;GACX,SAAS;GACT,cAAc,EAAE;EAClB;CACF,SACM,CAAC,QAAQ,KAAK,CACtB;CAEA,OAAO,eACL,CAAC,QAAQ,QACL;EAAE,SAAS;EAAO,cAAc;CAAE,IAClC;EACE,SAAS;EACT,cAAc,KAAK,IAAI,GAAG,IAAI,QAAQ,YAAY;CACpD,CACN;AACF"}

package/dist/unstable/useModelContextSnapshot.d.ts

@@ -0,0 +1,32 @@
+import { type MaybeRefOrGetter, type ShallowRef } from "vue";
+import type { AssistantClient } from "@ulearning/ai-store";
+import type { Unsubscribe } from "@ulearning/ai-core";
+/**
+ * Where a snapshot comes from and what counts as a change to it. Declared once
+ * per consumer at module scope: the subscription effect keys on this object, so
+ * an inline source without an `isEqual` re-reads itself into a render loop.
+ */
+export type ModelContextSnapshotSource<T> = {
+    /** Seeds the snapshot when it starts disabled. */
+    readonly empty: T;
+    /** Projects the fields the consumer observes out of the live model context. */
+    read(aui: AssistantClient): T;
+    subscribe(aui: AssistantClient, onChange: () => void): Unsubscribe;
+    /**
+     * An equal pair keeps the previous reference. Omitted by a consumer that
+     * re-derives on every notification, where a caller republishing an unchanged
+     * tool set is how it asks to be re-run.
+     */
+    isEqual?(previous: T, next: T): boolean;
+};
+/**
+ * `getModelContext()` rebuilds its result on every call, so a projection of the
+ * fields a consumer observes is held in state and refreshed on notification
+ * rather than read during render. Keeping the previous reference for an equal
+ * projection is what stops a notification carrying no observable change from
+ * invalidating everything derived from it.
+ */
+export declare const useModelContextSnapshot: <T>(aui: MaybeRefOrGetter<AssistantClient>, enabled: MaybeRefOrGetter<boolean>, source: MaybeRefOrGetter<ModelContextSnapshotSource<T>>) => Readonly<ShallowRef<T>>;
+/** Shallow own-key comparison, for a projection whose values are records. */
+export declare const shallowEqualRecords: (previous: Readonly<Record<string, unknown>>, next: Readonly<Record<string, unknown>>) => boolean;
+//# sourceMappingURL=useModelContextSnapshot.d.ts.map

package/dist/unstable/useModelContextSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useModelContextSnapshot.d.ts","mappings":"AAEA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAChB,MAAM,KAAK;AAEZ,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB;AAErD;;;;;AAKA,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI;IAC1C;IACA,QAAQ,CAAC,KAAK,EAAE,CAAC;IACjB;IACA,IAAI,CAAC,GAAG,EAAE,eAAe,GAAG,CAAC;IAC7B,SAAS,CAAC,GAAG,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,WAAW;IAClE;;;;;IAKA,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO;CACxC;AAED;;;;;;;AAOA,eAAO,MAAM,uBAAuB,GAAI,CAAC,EACvC,KAAK,gBAAgB,CAAC,eAAe,CAAC,EACtC,SAAS,gBAAgB,CAAC,OAAO,CAAC,EAClC,QAAQ,gBAAgB,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,KACtD,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CA6BxB;AAED;AACA,eAAO,MAAM,mBAAmB,GAC9B,UAAU,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAC3C,MAAM,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KACtC,OAMF","names":[],"ignoreList":[],"sources":["../../src/unstable/useModelContextSnapshot.ts"],"sourcesContent":[null]}

package/dist/unstable/useModelContextSnapshot.js

@@ -0,0 +1,46 @@
+"use client";
+import { shallowReadonly, shallowRef, toValue } from "vue";
+import { useIsomorphicLayoutEffect } from "@ulearning/ai-store/internal";
+// src/unstable/useModelContextSnapshot.ts
+/**
+* `getModelContext()` rebuilds its result on every call, so a projection of the
+* fields a consumer observes is held in state and refreshed on notification
+* rather than read during render. Keeping the previous reference for an equal
+* projection is what stops a notification carrying no observable change from
+* invalidating everything derived from it.
+*/
+const useModelContextSnapshot = (aui, enabled, source) => {
+	const initialSource = toValue(source);
+	const snapshot = shallowRef(toValue(enabled) ? initialSource.read(toValue(aui)) : initialSource.empty);
+	useIsomorphicLayoutEffect(() => {
+		if (!toValue(enabled)) return void 0;
+		const currentSource = toValue(source);
+		const currentAui = toValue(aui);
+		let active = true;
+		const read = () => {
+			if (!active) return;
+			const next = currentSource.read(currentAui);
+			if (!currentSource.isEqual?.(snapshot.value, next)) snapshot.value = next;
+		};
+		read();
+		const unsubscribe = currentSource.subscribe(currentAui, read);
+		return () => {
+			active = false;
+			unsubscribe();
+		};
+	}, () => [
+		toValue(aui),
+		toValue(enabled),
+		toValue(source)
+	]);
+	return shallowReadonly(snapshot);
+};
+/** Shallow own-key comparison, for a projection whose values are records. */
+const shallowEqualRecords = (previous, next) => {
+	const keys = Object.keys(previous);
+	if (keys.length !== Object.keys(next).length) return false;
+	return keys.every((key) => Object.hasOwn(next, key) && previous[key] === next[key]);
+};
+export { shallowEqualRecords, useModelContextSnapshot };
+
+//# sourceMappingURL=useModelContextSnapshot.js.map

package/dist/unstable/useModelContextSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useModelContextSnapshot.js","names":[],"sources":["../../src/unstable/useModelContextSnapshot.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  shallowRef,\n  shallowReadonly,\n  toValue,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n} from \"vue\";\nimport { useIsomorphicLayoutEffect } from \"@ulearning/ai-store/internal\";\nimport type { AssistantClient } from \"@ulearning/ai-store\";\nimport type { Unsubscribe } from \"@ulearning/ai-core\";\n\n/**\n * Where a snapshot comes from and what counts as a change to it. Declared once\n * per consumer at module scope: the subscription effect keys on this object, so\n * an inline source without an `isEqual` re-reads itself into a render loop.\n */\nexport type ModelContextSnapshotSource<T> = {\n  /** Seeds the snapshot when it starts disabled. */\n  readonly empty: T;\n  /** Projects the fields the consumer observes out of the live model context. */\n  read(aui: AssistantClient): T;\n  subscribe(aui: AssistantClient, onChange: () => void): Unsubscribe;\n  /**\n   * An equal pair keeps the previous reference. Omitted by a consumer that\n   * re-derives on every notification, where a caller republishing an unchanged\n   * tool set is how it asks to be re-run.\n   */\n  isEqual?(previous: T, next: T): boolean;\n};\n\n/**\n * `getModelContext()` rebuilds its result on every call, so a projection of the\n * fields a consumer observes is held in state and refreshed on notification\n * rather than read during render. Keeping the previous reference for an equal\n * projection is what stops a notification carrying no observable change from\n * invalidating everything derived from it.\n */\nexport const useModelContextSnapshot = <T>(\n  aui: MaybeRefOrGetter<AssistantClient>,\n  enabled: MaybeRefOrGetter<boolean>,\n  source: MaybeRefOrGetter<ModelContextSnapshotSource<T>>,\n): Readonly<ShallowRef<T>> => {\n  const initialSource = toValue(source);\n  const snapshot: ShallowRef<T> = shallowRef(\n    toValue(enabled) ? initialSource.read(toValue(aui)) : initialSource.empty,\n  );\n\n  useIsomorphicLayoutEffect(\n    () => {\n      if (!toValue(enabled)) return undefined;\n      const currentSource = toValue(source);\n      const currentAui = toValue(aui);\n      let active = true;\n      const read = () => {\n        if (!active) return;\n        const next = currentSource.read(currentAui);\n        if (!currentSource.isEqual?.(snapshot.value, next))\n          snapshot.value = next;\n      };\n      read();\n      const unsubscribe = currentSource.subscribe(currentAui, read);\n      return () => {\n        active = false;\n        unsubscribe();\n      };\n    },\n    () => [toValue(aui), toValue(enabled), toValue(source)],\n  );\n\n  return shallowReadonly(snapshot);\n};\n\n/** Shallow own-key comparison, for a projection whose values are records. */\nexport const shallowEqualRecords = (\n  previous: Readonly<Record<string, unknown>>,\n  next: Readonly<Record<string, unknown>>,\n): boolean => {\n  const keys = Object.keys(previous);\n  if (keys.length !== Object.keys(next).length) return false;\n  return keys.every(\n    (key) => Object.hasOwn(next, key) && previous[key] === next[key],\n  );\n};\n"],"mappings":";;;;;;;;;;;AAuCA,MAAa,2BACX,KACA,SACA,WAC4B;CAC5B,MAAM,gBAAgB,QAAQ,MAAM;CACpC,MAAM,WAA0B,WAC9B,QAAQ,OAAO,IAAI,cAAc,KAAK,QAAQ,GAAG,CAAC,IAAI,cAAc,KACtE;CAEA,gCACQ;EACJ,IAAI,CAAC,QAAQ,OAAO,GAAG,OAAO,KAAA;EAC9B,MAAM,gBAAgB,QAAQ,MAAM;EACpC,MAAM,aAAa,QAAQ,GAAG;EAC9B,IAAI,SAAS;EACb,MAAM,aAAa;GACjB,IAAI,CAAC,QAAQ;GACb,MAAM,OAAO,cAAc,KAAK,UAAU;GAC1C,IAAI,CAAC,cAAc,UAAU,SAAS,OAAO,IAAI,GAC/C,SAAS,QAAQ;EACrB;EACA,KAAK;EACL,MAAM,cAAc,cAAc,UAAU,YAAY,IAAI;EAC5D,aAAa;GACX,SAAS;GACT,YAAY;EACd;CACF,SACM;EAAC,QAAQ,GAAG;EAAG,QAAQ,OAAO;EAAG,QAAQ,MAAM;CAAC,CACxD;CAEA,OAAO,gBAAgB,QAAQ;AACjC;;AAGA,MAAa,uBACX,UACA,SACY;CACZ,MAAM,OAAO,OAAO,KAAK,QAAQ;CACjC,IAAI,KAAK,WAAW,OAAO,KAAK,IAAI,CAAC,CAAC,QAAQ,OAAO;CACrD,OAAO,KAAK,OACT,QAAQ,OAAO,OAAO,MAAM,GAAG,KAAK,SAAS,SAAS,KAAK,IAC9D;AACF"}

package/dist/unstable/useSlashCommandAdapter.d.ts

@@ -0,0 +1,53 @@
+import { type ComputedRef, type MaybeRefOrGetter } from "vue";
+import type { Unstable_TriggerAdapter, Unstable_TriggerItem } from "@ulearning/ai-core";
+import type { Unstable_IconComponent } from "./useMentionAdapter.js";
+/** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */
+export type Unstable_SlashCommand = {
+    readonly id: string;
+    readonly label?: string | undefined;
+    readonly description?: string | undefined;
+    readonly icon?: string | undefined;
+    readonly execute: () => void;
+};
+/** @deprecated Experimental since 2026-04-06. Not scheduled for removal; the API may change in any release. */
+export type Unstable_UseSlashCommandAdapterOptions = {
+    readonly commands: readonly Unstable_SlashCommand[];
+    /** Strip the trigger text from the composer after executing. @default false */
+    readonly removeOnExecute?: boolean | undefined;
+    /** Maps `metadata.icon` / `category.id` string keys to Vue components. */
+    readonly iconMap?: Record<string, Unstable_IconComponent>;
+    /** Fallback icon when no entry in `iconMap` matches. */
+    readonly fallbackIcon?: Unstable_IconComponent;
+};
+/** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */
+export type Unstable_SlashCommandAction = {
+    readonly onExecute: (item: Unstable_TriggerItem) => void;
+    readonly removeOnExecute?: boolean | undefined;
+};
+/**
+ * Bundles slash command definitions (with inline `execute` callbacks) into
+ * `{adapter, action}` that plug directly into `ComposerTriggerPopover`.
+ * `execute` stays in the hook closure and is never attached to the returned
+ * `TriggerItem`, keeping items serializable.
+ *
+ * @deprecated Experimental since 2026-04-06. Not scheduled for removal; the API may change in any release.
+ *
+ * @example
+ * ```tsx
+ * const slash = unstable_useSlashCommandAdapter({
+ *   commands: [
+ *     { id: "summarize", execute: () => runSummarize(), icon: "FileText" },
+ *     { id: "translate", execute: () => runTranslate(), icon: "Languages" },
+ *   ],
+ * });
+ *
+ * <ComposerTriggerPopover char="/" {...slash} />
+ * ```
+ */
+export declare function unstable_useSlashCommandAdapter(options: MaybeRefOrGetter<Unstable_UseSlashCommandAdapterOptions>): ComputedRef<{
+    adapter: Unstable_TriggerAdapter;
+    action: Unstable_SlashCommandAction;
+    iconMap?: Record<string, Unstable_IconComponent>;
+    fallbackIcon?: Unstable_IconComponent;
+}>;
+//# sourceMappingURL=useSlashCommandAdapter.d.ts.map

package/dist/unstable/useSlashCommandAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSlashCommandAdapter.d.ts","mappings":"AAEA,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACtB,MAAM,KAAK;AAEZ,OAAO,KAAK,EACV,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,oBAAoB;AAC3B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAqB;AAGjE;AACA,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM;IACnB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS;IACnC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS;IACzC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI;CAC7B;AAED;AACA,MAAM,MAAM,sCAAsC,GAAG;IACnD,QAAQ,CAAC,QAAQ,EAAE,SAAS,qBAAqB,EAAE;IACnD;IACA,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS;IAC9C;IACA,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACzD;IACA,QAAQ,CAAC,YAAY,CAAC,EAAE,sBAAsB;CAC/C;AAED;AACA,MAAM,MAAM,2BAA2B,GAAG;IACxC,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,IAAI;IACxD,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS;CAC/C;AAED;;;;;;;;;;;;;;;;;;;;AAoBA,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,gBAAgB,CAAC,sCAAsC,CAAC,GAChE,WAAW,CAAC;IACb,OAAO,EAAE,uBAAuB;IAChC,MAAM,EAAE,2BAA2B;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC;IAChD,YAAY,CAAC,EAAE,sBAAsB;CACtC,CAAC","names":[],"ignoreList":[],"sources":["../../src/unstable/useSlashCommandAdapter.ts"],"sourcesContent":[null]}

package/dist/unstable/useSlashCommandAdapter.js

@@ -0,0 +1,84 @@
+"use client";
+import { matchesTriggerItemQuery } from "../primitives/composer/trigger/matchesTriggerItemQuery.js";
+import { useIsomorphicLayoutEffect } from "../utils/useIsomorphicLayoutEffect.js";
+import { computed, toValue } from "vue";
+// src/unstable/useSlashCommandAdapter.ts
+/**
+* Bundles slash command definitions (with inline `execute` callbacks) into
+* `{adapter, action}` that plug directly into `ComposerTriggerPopover`.
+* `execute` stays in the hook closure and is never attached to the returned
+* `TriggerItem`, keeping items serializable.
+*
+* @deprecated Experimental since 2026-04-06. Not scheduled for removal; the API may change in any release.
+*
+* @example
+* ```tsx
+* const slash = unstable_useSlashCommandAdapter({
+*   commands: [
+*     { id: "summarize", execute: () => runSummarize(), icon: "FileText" },
+*     { id: "translate", execute: () => runTranslate(), icon: "Languages" },
+*   ],
+* });
+*
+* <ComposerTriggerPopover char="/" {...slash} />
+* ```
+*/
+function unstable_useSlashCommandAdapter(options) {
+	const commands = computed(() => toValue(options).commands);
+	const removeOnExecute = computed(() => toValue(options).removeOnExecute);
+	let committedCommands = commands.value;
+	let committedItems;
+	const items = computed(() => {
+		const next = commands.value.map(toItem);
+		return areTriggerItemsEqual(committedItems, next) ? committedItems : next;
+	});
+	useIsomorphicLayoutEffect(() => {
+		committedCommands = commands.value;
+		committedItems = items.value;
+	}, () => [commands.value, items.value]);
+	const adapter = computed(() => {
+		const currentItems = items.value;
+		return {
+			categories: () => [],
+			categoryItems: () => [],
+			search: (query) => {
+				const lower = query.toLowerCase();
+				return currentItems.filter((item) => matchesTriggerItemQuery(item, lower));
+			}
+		};
+	});
+	const action = computed(() => ({
+		onExecute: (item) => {
+			committedCommands.find((command) => command.id === item.id)?.execute();
+		},
+		...removeOnExecute.value !== void 0 ? { removeOnExecute: removeOnExecute.value } : {}
+	}));
+	return computed(() => {
+		const current = toValue(options);
+		return {
+			adapter: adapter.value,
+			action: action.value,
+			...current.iconMap ? { iconMap: current.iconMap } : {},
+			...current.fallbackIcon ? { fallbackIcon: current.fallbackIcon } : {}
+		};
+	});
+}
+function toItem(cmd) {
+	return {
+		id: cmd.id,
+		type: "command",
+		label: cmd.label ?? `/${cmd.id}`,
+		...cmd.description !== void 0 ? { description: cmd.description } : {},
+		...cmd.icon !== void 0 ? { metadata: { icon: cmd.icon } } : {}
+	};
+}
+function areTriggerItemsEqual(previous, next) {
+	if (!previous || previous.length !== next.length) return false;
+	return previous.every((item, index) => {
+		const nextItem = next[index];
+		return nextItem !== void 0 && item.id === nextItem.id && item.label === nextItem.label && item.description === nextItem.description && item.metadata?.icon === nextItem.metadata?.icon;
+	});
+}
+export { unstable_useSlashCommandAdapter };
+
+//# sourceMappingURL=useSlashCommandAdapter.js.map

package/dist/unstable/useSlashCommandAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSlashCommandAdapter.js","names":[],"sources":["../../src/unstable/useSlashCommandAdapter.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  computed,\n  toValue,\n  type ComputedRef,\n  type MaybeRefOrGetter,\n} from \"vue\";\nimport { useIsomorphicLayoutEffect } from \"../utils/useIsomorphicLayoutEffect\";\nimport type {\n  Unstable_TriggerAdapter,\n  Unstable_TriggerItem,\n} from \"@ulearning/ai-core\";\nimport type { Unstable_IconComponent } from \"./useMentionAdapter\";\nimport { matchesTriggerItemQuery } from \"../primitives/composer/trigger/matchesTriggerItemQuery\";\n\n/** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_SlashCommand = {\n  readonly id: string;\n  readonly label?: string | undefined;\n  readonly description?: string | undefined;\n  readonly icon?: string | undefined;\n  readonly execute: () => void;\n};\n\n/** @deprecated Experimental since 2026-04-06. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_UseSlashCommandAdapterOptions = {\n  readonly commands: readonly Unstable_SlashCommand[];\n  /** Strip the trigger text from the composer after executing. @default false */\n  readonly removeOnExecute?: boolean | undefined;\n  /** Maps `metadata.icon` / `category.id` string keys to Vue components. */\n  readonly iconMap?: Record<string, Unstable_IconComponent>;\n  /** Fallback icon when no entry in `iconMap` matches. */\n  readonly fallbackIcon?: Unstable_IconComponent;\n};\n\n/** @deprecated Experimental since 2026-04-15. Not scheduled for removal; the API may change in any release. */\nexport type Unstable_SlashCommandAction = {\n  readonly onExecute: (item: Unstable_TriggerItem) => void;\n  readonly removeOnExecute?: boolean | undefined;\n};\n\n/**\n * Bundles slash command definitions (with inline `execute` callbacks) into\n * `{adapter, action}` that plug directly into `ComposerTriggerPopover`.\n * `execute` stays in the hook closure and is never attached to the returned\n * `TriggerItem`, keeping items serializable.\n *\n * @deprecated Experimental since 2026-04-06. Not scheduled for removal; the API may change in any release.\n *\n * @example\n * ```tsx\n * const slash = unstable_useSlashCommandAdapter({\n *   commands: [\n *     { id: \"summarize\", execute: () => runSummarize(), icon: \"FileText\" },\n *     { id: \"translate\", execute: () => runTranslate(), icon: \"Languages\" },\n *   ],\n * });\n *\n * <ComposerTriggerPopover char=\"/\" {...slash} />\n * ```\n */\nexport function unstable_useSlashCommandAdapter(\n  options: MaybeRefOrGetter<Unstable_UseSlashCommandAdapterOptions>,\n): ComputedRef<{\n  adapter: Unstable_TriggerAdapter;\n  action: Unstable_SlashCommandAction;\n  iconMap?: Record<string, Unstable_IconComponent>;\n  fallbackIcon?: Unstable_IconComponent;\n}> {\n  const commands = computed(() => toValue(options).commands);\n  const removeOnExecute = computed(() => toValue(options).removeOnExecute);\n  let committedCommands = commands.value;\n  let committedItems: readonly Unstable_TriggerItem[] | undefined;\n  const items = computed(() => {\n    const next = commands.value.map(toItem);\n    return areTriggerItemsEqual(committedItems, next) ? committedItems : next;\n  });\n  useIsomorphicLayoutEffect(\n    () => {\n      committedCommands = commands.value;\n      committedItems = items.value;\n    },\n    () => [commands.value, items.value],\n  );\n\n  const adapter = computed<Unstable_TriggerAdapter>(() => {\n    const currentItems = items.value;\n    return {\n      categories: () => [],\n      categoryItems: () => [],\n      search: (query: string) => {\n        const lower = query.toLowerCase();\n        return currentItems.filter((item) =>\n          matchesTriggerItemQuery(item, lower),\n        );\n      },\n    };\n  });\n  const action = computed<Unstable_SlashCommandAction>(() => ({\n    onExecute: (item) => {\n      committedCommands.find((command) => command.id === item.id)?.execute();\n    },\n    ...(removeOnExecute.value !== undefined\n      ? { removeOnExecute: removeOnExecute.value }\n      : {}),\n  }));\n  return computed(() => {\n    const current = toValue(options);\n    return {\n      adapter: adapter.value,\n      action: action.value,\n      ...(current.iconMap ? { iconMap: current.iconMap } : {}),\n      ...(current.fallbackIcon ? { fallbackIcon: current.fallbackIcon } : {}),\n    };\n  });\n}\n\nfunction toItem(cmd: Unstable_SlashCommand): Unstable_TriggerItem {\n  return {\n    id: cmd.id,\n    type: \"command\",\n    label: cmd.label ?? `/${cmd.id}`,\n    ...(cmd.description !== undefined ? { description: cmd.description } : {}),\n    ...(cmd.icon !== undefined ? { metadata: { icon: cmd.icon } } : {}),\n  };\n}\n\nfunction areTriggerItemsEqual(\n  previous: readonly Unstable_TriggerItem[] | undefined,\n  next: readonly Unstable_TriggerItem[],\n): previous is readonly Unstable_TriggerItem[] {\n  if (!previous || previous.length !== next.length) return false;\n\n  return previous.every((item, index) => {\n    const nextItem = next[index];\n    return (\n      nextItem !== undefined &&\n      item.id === nextItem.id &&\n      item.label === nextItem.label &&\n      item.description === nextItem.description &&\n      item.metadata?.icon === nextItem.metadata?.icon\n    );\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,SAAgB,gCACd,SAMC;CACD,MAAM,WAAW,eAAe,QAAQ,OAAO,CAAC,CAAC,QAAQ;CACzD,MAAM,kBAAkB,eAAe,QAAQ,OAAO,CAAC,CAAC,eAAe;CACvE,IAAI,oBAAoB,SAAS;CACjC,IAAI;CACJ,MAAM,QAAQ,eAAe;EAC3B,MAAM,OAAO,SAAS,MAAM,IAAI,MAAM;EACtC,OAAO,qBAAqB,gBAAgB,IAAI,IAAI,iBAAiB;CACvE,CAAC;CACD,gCACQ;EACJ,oBAAoB,SAAS;EAC7B,iBAAiB,MAAM;CACzB,SACM,CAAC,SAAS,OAAO,MAAM,KAAK,CACpC;CAEA,MAAM,UAAU,eAAwC;EACtD,MAAM,eAAe,MAAM;EAC3B,OAAO;GACL,kBAAkB,CAAC;GACnB,qBAAqB,CAAC;GACtB,SAAS,UAAkB;IACzB,MAAM,QAAQ,MAAM,YAAY;IAChC,OAAO,aAAa,QAAQ,SAC1B,wBAAwB,MAAM,KAAK,CACrC;GACF;EACF;CACF,CAAC;CACD,MAAM,SAAS,gBAA6C;EAC1D,YAAY,SAAS;GACnB,kBAAkB,MAAM,YAAY,QAAQ,OAAO,KAAK,EAAE,CAAC,EAAE,QAAQ;EACvE;EACA,GAAI,gBAAgB,UAAU,KAAA,IAC1B,EAAE,iBAAiB,gBAAgB,MAAM,IACzC,CAAC;CACP,EAAE;CACF,OAAO,eAAe;EACpB,MAAM,UAAU,QAAQ,OAAO;EAC/B,OAAO;GACL,SAAS,QAAQ;GACjB,QAAQ,OAAO;GACf,GAAI,QAAQ,UAAU,EAAE,SAAS,QAAQ,QAAQ,IAAI,CAAC;GACtD,GAAI,QAAQ,eAAe,EAAE,cAAc,QAAQ,aAAa,IAAI,CAAC;EACvE;CACF,CAAC;AACH;AAEA,SAAS,OAAO,KAAkD;CAChE,OAAO;EACL,IAAI,IAAI;EACR,MAAM;EACN,OAAO,IAAI,SAAS,IAAI,IAAI;EAC5B,GAAI,IAAI,gBAAgB,KAAA,IAAY,EAAE,aAAa,IAAI,YAAY,IAAI,CAAC;EACxE,GAAI,IAAI,SAAS,KAAA,IAAY,EAAE,UAAU,EAAE,MAAM,IAAI,KAAK,EAAE,IAAI,CAAC;CACnE;AACF;AAEA,SAAS,qBACP,UACA,MAC6C;CAC7C,IAAI,CAAC,YAAY,SAAS,WAAW,KAAK,QAAQ,OAAO;CAEzD,OAAO,SAAS,OAAO,MAAM,UAAU;EACrC,MAAM,WAAW,KAAK;EACtB,OACE,aAAa,KAAA,KACb,KAAK,OAAO,SAAS,MACrB,KAAK,UAAU,SAAS,SACxB,KAAK,gBAAgB,SAAS,eAC9B,KAAK,UAAU,SAAS,SAAS,UAAU;CAE/C,CAAC;AACH"}

package/dist/unstable/webmcp/WebMcpRegistrationResource.d.ts

@@ -0,0 +1,12 @@
+import type { Tool } from "@ulearning/ai-stream";
+import type { WebMcpHost } from "./webmcp-host.js";
+export type WebMcpRegistrationProps = {
+    host: WebMcpHost;
+    name: string;
+    /** Re-registers when it changes; an execute-only edit reads through instead. */
+    signature: string;
+    tool: Tool<any, any>;
+    getCurrentTool: (name: string) => Tool<any, any> | undefined;
+};
+export declare const WebMcpRegistrationResource: import("@ulearning/ai-tap").Resource<string | null, [WebMcpRegistrationProps]>;
+//# sourceMappingURL=WebMcpRegistrationResource.d.ts.map

package/dist/unstable/webmcp/WebMcpRegistrationResource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebMcpRegistrationResource.d.ts","mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB;AAEhD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAe;AAE/C,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,MAAM;IACZ;IACA,SAAS,EAAE,MAAM;IACjB,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC;IACpB,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,SAAS;CAC7D;AA+ED,eAAO,MAAM,0BAA0B,gFAAkC","names":[],"ignoreList":[],"sources":["../../../src/unstable/webmcp/WebMcpRegistrationResource.ts"],"sourcesContent":[null]}

package/dist/unstable/webmcp/WebMcpRegistrationResource.js

@@ -0,0 +1,47 @@
+import { toWebMcpTool } from "./convertTools.js";
+import { resource, useEffect, useRef, useState } from "@ulearning/ai-tap";
+// src/unstable/webmcp/WebMcpRegistrationResource.ts
+const notPermitted = (error) => error?.name === "NotAllowedError";
+const notPermittedMessage = (name) => `[assistant-ui] WebMCP registration for tool "${name}" was not permitted; the page's tools permission is disabled.`;
+const useWebMcpRegistration = ({ host, name, signature, tool, getCurrentTool }) => {
+	const [refused, setRefused] = useState(false);
+	const fallbackToolRef = useRef(tool);
+	useEffect(() => {
+		if (refused) return void 0;
+		const lifecycle = new AbortController();
+		let live = true;
+		let dispose;
+		const refuse = (message, error) => {
+			if (!live) return;
+			live = false;
+			setRefused(true);
+			console.warn(message, error);
+		};
+		try {
+			dispose = host.registerTool(toWebMcpTool(name, () => getCurrentTool(name) ?? fallbackToolRef.current, lifecycle.signal), (error) => refuse(notPermitted(error) ? notPermittedMessage(name) : `[assistant-ui] WebMCP registration for tool "${name}" failed (name may already be registered).`, error));
+		} catch (error) {
+			refuse(notPermitted(error) ? notPermittedMessage(name) : `[assistant-ui] Skipping WebMCP registration for tool "${name}": registerTool failed (name may already be registered).`, error);
+			return;
+		}
+		return () => {
+			live = false;
+			lifecycle.abort();
+			try {
+				dispose();
+			} catch (error) {
+				console.warn(`[assistant-ui] Unregistering WebMCP tool "${name}" failed.`, error);
+			}
+		};
+	}, [
+		getCurrentTool,
+		host,
+		name,
+		signature,
+		refused
+	]);
+	return refused ? null : name;
+};
+const WebMcpRegistrationResource = resource(useWebMcpRegistration);
+export { WebMcpRegistrationResource };
+
+//# sourceMappingURL=WebMcpRegistrationResource.js.map

package/dist/unstable/webmcp/WebMcpRegistrationResource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebMcpRegistrationResource.js","names":[],"sources":["../../../src/unstable/webmcp/WebMcpRegistrationResource.ts"],"sourcesContent":["import { resource, useEffect, useRef, useState } from \"@ulearning/ai-tap\";\nimport type { Tool } from \"@ulearning/ai-stream\";\nimport { toWebMcpTool } from \"./convertTools\";\nimport type { WebMcpHost } from \"./webmcp-host\";\n\nexport type WebMcpRegistrationProps = {\n  host: WebMcpHost;\n  name: string;\n  /** Re-registers when it changes; an execute-only edit reads through instead. */\n  signature: string;\n  tool: Tool<any, any>;\n  getCurrentTool: (name: string) => Tool<any, any> | undefined;\n};\n\n// The explainer specifies NotAllowedError for a page whose tools permission is\n// off, which a cross-origin iframe without allow=\"tools\" reaches routinely. It\n// documents no rejection for a name already taken, so that stays a hedge.\nconst notPermitted = (error: unknown) =>\n  (error as { name?: unknown } | null | undefined)?.name === \"NotAllowedError\";\n\nconst notPermittedMessage = (name: string) =>\n  `[assistant-ui] WebMCP registration for tool \"${name}\" was not permitted; the page's tools permission is disabled.`;\n\nconst useWebMcpRegistration = ({\n  host,\n  name,\n  signature,\n  tool,\n  getCurrentTool,\n}: WebMcpRegistrationProps): string | null => {\n  // A refused name is remembered for as long as the tool stays in the model\n  // context, so a permanent collision warns once rather than on every sync.\n  const [refused, setRefused] = useState(false);\n  const fallbackToolRef = useRef(tool);\n\n  useEffect(() => {\n    if (refused) return undefined;\n\n    const lifecycle = new AbortController();\n    let live = true;\n    let dispose: (() => void) | undefined;\n\n    const refuse = (message: string, error: unknown) => {\n      if (!live) return;\n      live = false;\n      setRefused(true);\n      console.warn(message, error);\n    };\n\n    try {\n      dispose = host.registerTool(\n        toWebMcpTool(\n          name,\n          () => getCurrentTool(name) ?? fallbackToolRef.current,\n          lifecycle.signal,\n        ),\n        (error) =>\n          refuse(\n            notPermitted(error)\n              ? notPermittedMessage(name)\n              : `[assistant-ui] WebMCP registration for tool \"${name}\" failed (name may already be registered).`,\n            error,\n          ),\n      );\n    } catch (error) {\n      refuse(\n        notPermitted(error)\n          ? notPermittedMessage(name)\n          : `[assistant-ui] Skipping WebMCP registration for tool \"${name}\": registerTool failed (name may already be registered).`,\n        error,\n      );\n      return undefined;\n    }\n\n    return () => {\n      live = false;\n      lifecycle.abort();\n      try {\n        dispose();\n      } catch (error) {\n        console.warn(\n          `[assistant-ui] Unregistering WebMCP tool \"${name}\" failed.`,\n          error,\n        );\n      }\n    };\n  }, [getCurrentTool, host, name, signature, refused]);\n\n  return refused ? null : name;\n};\n\nexport const WebMcpRegistrationResource = resource(useWebMcpRegistration);\n"],"mappings":";;;AAiBA,MAAM,gBAAgB,UACnB,OAAiD,SAAS;AAE7D,MAAM,uBAAuB,SAC3B,gDAAgD,KAAK;AAEvD,MAAM,yBAAyB,EAC7B,MACA,MACA,WACA,MACA,qBAC4C;CAG5C,MAAM,CAAC,SAAS,cAAc,SAAS,KAAK;CAC5C,MAAM,kBAAkB,OAAO,IAAI;CAEnC,gBAAgB;EACd,IAAI,SAAS,OAAO,KAAA;EAEpB,MAAM,YAAY,IAAI,gBAAgB;EACtC,IAAI,OAAO;EACX,IAAI;EAEJ,MAAM,UAAU,SAAiB,UAAmB;GAClD,IAAI,CAAC,MAAM;GACX,OAAO;GACP,WAAW,IAAI;GACf,QAAQ,KAAK,SAAS,KAAK;EAC7B;EAEA,IAAI;GACF,UAAU,KAAK,aACb,aACE,YACM,eAAe,IAAI,KAAK,gBAAgB,SAC9C,UAAU,MACZ,IACC,UACC,OACE,aAAa,KAAK,IACd,oBAAoB,IAAI,IACxB,gDAAgD,KAAK,6CACzD,KACF,CACJ;EACF,SAAS,OAAO;GACd,OACE,aAAa,KAAK,IACd,oBAAoB,IAAI,IACxB,yDAAyD,KAAK,2DAClE,KACF;GACA;EACF;EAEA,aAAa;GACX,OAAO;GACP,UAAU,MAAM;GAChB,IAAI;IACF,QAAQ;GACV,SAAS,OAAO;IACd,QAAQ,KACN,6CAA6C,KAAK,YAClD,KACF;GACF;EACF;CACF,GAAG;EAAC;EAAgB;EAAM;EAAM;EAAW;CAAO,CAAC;CAEnD,OAAO,UAAU,OAAO;AAC1B;AAEA,MAAa,6BAA6B,SAAS,qBAAqB"}

package/dist/unstable/webmcp/convertTools.d.ts

@@ -0,0 +1,18 @@
+import { type Tool } from "@ulearning/ai-stream";
+import type { WebMcpCallToolResult, WebMcpToolDescriptor } from "./webmcp-host.js";
+/**
+ * The predicate the WebMCP provider uses when no `filter` is passed: an enabled
+ * frontend tool with a client-side `execute`. A tool authored without a `type`
+ * is included, because `execute` is what distinguishes the deprecated
+ * type-less form from a backend or human tool. A `filter` replaces this, so
+ * pass it through to narrow the default set rather than widen it.
+ */
+export declare const defaultWebMcpFilter: (_name: string, tool: Tool<any, any>) => boolean;
+export declare const toWebMcpInputSchema: (tool: Tool<any, any>) => unknown;
+export declare const toMcpContent: (result: unknown, options: {
+    tool: Tool<any, any>;
+    toolCallId: string;
+    args: Record<string, unknown>;
+}) => Promise<WebMcpCallToolResult>;
+export declare const toWebMcpTool: (name: string, getTool: () => Tool<any, any>, lifecycleSignal?: AbortSignal) => WebMcpToolDescriptor;
+//# sourceMappingURL=convertTools.d.ts.map

package/dist/unstable/webmcp/convertTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertTools.d.ts","mappings":"AAAA,OAAO,EAGL,KAAK,IAAI,EAEV,MAAM,sBAAsB;AAE7B,OAAO,KAAK,EACV,oBAAoB,EAEpB,oBAAoB,EACrB,MAAM,kBAAe;AAEtB;;;;;;;AAOA,eAAO,MAAM,mBAAmB,GAC9B,OAAO,MAAM,EACb,MAAM,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,KACnB,OAGa;AAEhB,eAAO,MAAM,mBAAmB,GAAI,MAAM,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,KAAG,OAGnB;AAwCxC,eAAO,MAAM,YAAY,GACvB,QAAQ,OAAO,EACf,SAAS;IACP,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC;IACpB,UAAU,EAAE,MAAM;IAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAC9B,KACA,OAAO,CAAC,oBAAoB,CAuB9B;AA2ED,eAAO,MAAM,YAAY,GACvB,MAAM,MAAM,EACZ,SAAS,MAAM,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,EAC7B,kBAAkB,WAAW,KAC5B,oBA2ED","names":[],"ignoreList":[],"sources":["../../../src/unstable/webmcp/convertTools.ts"],"sourcesContent":[null]}

package/dist/unstable/webmcp/convertTools.js

@@ -0,0 +1,160 @@
+import { generateId } from "@ulearning/ai-core/internal";
+import { ToolResponse, toJSONSchema } from "@ulearning/ai-stream";
+// src/unstable/webmcp/convertTools.ts
+/**
+* The predicate the WebMCP provider uses when no `filter` is passed: an enabled
+* frontend tool with a client-side `execute`. A tool authored without a `type`
+* is included, because `execute` is what distinguishes the deprecated
+* type-less form from a backend or human tool. A `filter` replaces this, so
+* pass it through to narrow the default set rather than widen it.
+*/
+const defaultWebMcpFilter = (_name, tool) => (tool.type === "frontend" || tool.type === void 0) && !!tool.execute && !tool.disabled;
+const toWebMcpInputSchema = (tool) => tool.parameters ? toJSONSchema(tool.parameters) : {
+	type: "object",
+	properties: {}
+};
+const textContent = (text) => ({
+	type: "text",
+	text
+});
+const errorResult = (message) => ({
+	isError: true,
+	content: [textContent(message)]
+});
+const toText = (value) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "bigint" || typeof value === "symbol") return value.toString();
+	return JSON.stringify(value) ?? String(value);
+};
+const primitiveContent = (value) => [textContent(toText(value))];
+const mapModelContentPart = (part) => {
+	if (part.type === "text") return textContent(part.text ?? "");
+	if (part.type === "file") {
+		if (typeof part.mediaType === "string" && part.mediaType.startsWith("image/")) return {
+			type: "image",
+			data: part.data ?? "",
+			mimeType: part.mediaType
+		};
+		return textContent(part.data ?? "");
+	}
+	return textContent(toText(part));
+};
+const toMcpContent = async (result, options) => {
+	const response = ToolResponse.toResponse(result);
+	if (response.modelContent) {
+		const content = response.modelContent.map(mapModelContentPart);
+		return response.isError ? {
+			isError: true,
+			content
+		} : { content };
+	}
+	if (!response.isError && options.tool.toModelOutput) try {
+		return { content: (await options.tool.toModelOutput({
+			toolCallId: options.toolCallId,
+			input: options.args,
+			output: response.result
+		})).map(mapModelContentPart) };
+	} catch (e) {
+		console.warn("[assistant-ui] toModelOutput threw; falling back to default projection.", e);
+	}
+	const content = primitiveContent(response.result);
+	return response.isError ? {
+		isError: true,
+		content
+	} : { content };
+};
+const isStandardSchema = (schema) => typeof schema === "object" && schema !== null && "~standard" in schema && schema["~standard"].version === 1;
+const TOOL_ABORTED = Symbol("assistant-ui.webmcp-tool-aborted");
+const isThenable = (value) => typeof value?.then === "function";
+const raceWithAbort = async (value, abortSignal) => {
+	let onAbort;
+	const abortPromise = new Promise((resolve) => {
+		onAbort = () => resolve(TOOL_ABORTED);
+		if (abortSignal.aborted) onAbort();
+		else abortSignal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([abortPromise, value]);
+	} finally {
+		abortSignal.removeEventListener("abort", onAbort);
+	}
+};
+const combineAbortSignals = (callerSignal, lifecycleSignal) => {
+	const controller = new AbortController();
+	const teardown = [];
+	const cleanup = () => {
+		while (teardown.length) teardown.pop()();
+	};
+	const abort = (reason) => {
+		cleanup();
+		controller.abort(reason);
+	};
+	const listen = (signal) => {
+		const onAbort = () => abort(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+		teardown.push(() => signal.removeEventListener("abort", onAbort));
+	};
+	if (callerSignal.aborted) abort(callerSignal.reason);
+	else if (lifecycleSignal.aborted) abort(lifecycleSignal.reason);
+	else {
+		listen(callerSignal);
+		listen(lifecycleSignal);
+	}
+	return {
+		signal: controller.signal,
+		cleanup
+	};
+};
+const toWebMcpTool = (name, getTool, lifecycleSignal) => ({
+	name,
+	description: getTool().description ?? "",
+	inputSchema: toWebMcpInputSchema(getTool()),
+	execute: async (rawArgs, context) => {
+		if (lifecycleSignal?.aborted) return errorResult(`Tool "${name}" is no longer registered`);
+		const tool = getTool();
+		let args = rawArgs ?? {};
+		const toolCallId = generateId();
+		let cleanup;
+		try {
+			const callerSignal = context?.signal;
+			let abortSignal;
+			if (callerSignal && lifecycleSignal) {
+				const combined = combineAbortSignals(callerSignal, lifecycleSignal);
+				abortSignal = combined.signal;
+				cleanup = combined.cleanup;
+			} else abortSignal = callerSignal ?? lifecycleSignal;
+			if (abortSignal?.aborted) return errorResult("Tool execution was cancelled.");
+			let executeFn = tool.execute;
+			if (isStandardSchema(tool.parameters)) {
+				const result = tool.parameters["~standard"].validate(args);
+				const validation = isThenable(result) ? abortSignal ? await raceWithAbort(result, abortSignal) : await result : result;
+				if (validation === TOOL_ABORTED) return errorResult("Tool execution was cancelled.");
+				if (validation.issues) {
+					const issues = validation.issues;
+					executeFn = tool.experimental_onSchemaValidationError ?? (() => {
+						throw new Error(`Function parameter validation failed. ${JSON.stringify(issues)}`);
+					});
+				} else args = validation.value;
+			}
+			if (abortSignal?.aborted) return errorResult("Tool execution was cancelled.");
+			if (!executeFn) return errorResult(`Tool "${name}" has no client-side implementation.`);
+			const result = await executeFn(args, {
+				toolCallId,
+				abortSignal: abortSignal ?? new AbortController().signal,
+				human: () => Promise.reject(/* @__PURE__ */ new Error("human input not supported in WebMCP context"))
+			});
+			return await toMcpContent(result, {
+				tool,
+				toolCallId,
+				args
+			});
+		} catch (e) {
+			return errorResult(e instanceof Error ? e.message : String(e));
+		} finally {
+			cleanup?.();
+		}
+	}
+});
+export { defaultWebMcpFilter, toMcpContent, toWebMcpInputSchema, toWebMcpTool };
+
+//# sourceMappingURL=convertTools.js.map