@assistant-ui/core 0.3.17 → 0.3.19

package/dist/react/runtimes/useRemoteThreadListRuntime.js

@@ -4,7 +4,7 @@ import { AssistantRuntimeImpl } from "../../runtime/api/assistant-runtime.js";
 import { useSubscribable } from "../../store/runtime-clients/useSubscribable.js";
 import { RemoteThreadListThreadListRuntimeCore } from "./RemoteThreadListThreadListRuntimeCore.js";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
-import { useCallback, useEffect, useEffectEvent, useMemo, useRef, useState } from "@assistant-ui/tap/react-shim";
+import { useCallback, useEffect, useEffectEvent, useInsertionEffect, useMemo, useRef, useState } from "@assistant-ui/tap/react-shim";
 import { useAui } from "@assistant-ui/store";
 //#region src/react/runtimes/useRemoteThreadListRuntime.ts
 var RemoteThreadListRuntimeCore = class extends BaseAssistantRuntimeCore {
@@ -18,7 +18,7 @@ var RemoteThreadListRuntimeCore = class extends BaseAssistantRuntimeCore {
 	}
 };
 const useRemoteThreadListRuntimeImpl = (options) => {
-	const $ = c(10);
+	const $ = c(18);
 	let t0;
 	if ($[0] !== options) {
 		t0 = () => new RemoteThreadListRuntimeCore(options);
@@ -27,30 +27,70 @@ const useRemoteThreadListRuntimeImpl = (options) => {
 	} else t0 = $[1];
 	const [runtime] = useState(t0);
 	let t1;
-	if ($[2] !== options || $[3] !== runtime.threads) {
-		t1 = () => {
+	if ($[2] !== runtime.threads) {
+		t1 = () => () => queueMicrotask(() => runtime.threads.__internal_dispose());
+		$[2] = runtime.threads;
+		$[3] = t1;
+	} else t1 = $[3];
+	let t2;
+	if ($[4] !== runtime) {
+		t2 = [runtime];
+		$[4] = runtime;
+		$[5] = t2;
+	} else t2 = $[5];
+	useInsertionEffect(t1, t2);
+	let t3;
+	if ($[6] !== options || $[7] !== runtime.threads) {
+		t3 = () => {
 			runtime.threads.__internal_setOptions(options);
 			runtime.threads.__internal_load();
 		};
-		$[2] = options;
-		$[3] = runtime.threads;
-		$[4] = t1;
-	} else t1 = $[4];
-	let t2;
-	if ($[5] !== options || $[6] !== runtime) {
-		t2 = [runtime, options];
-		$[5] = options;
-		$[6] = runtime;
-		$[7] = t2;
-	} else t2 = $[7];
-	useEffect(t1, t2);
-	let t3;
-	if ($[8] !== runtime) {
-		t3 = new AssistantRuntimeImpl(runtime);
-		$[8] = runtime;
-		$[9] = t3;
-	} else t3 = $[9];
-	return t3;
+		$[6] = options;
+		$[7] = runtime.threads;
+		$[8] = t3;
+	} else t3 = $[8];
+	let t4;
+	if ($[9] !== options || $[10] !== runtime) {
+		t4 = [runtime, options];
+		$[9] = options;
+		$[10] = runtime;
+		$[11] = t4;
+	} else t4 = $[11];
+	useEffect(t3, t4);
+	let t5;
+	if ($[12] !== runtime.threads) {
+		t5 = () => {
+			if (typeof window === "undefined" || typeof document === "undefined") return;
+			const reloadAfterError = () => {
+				if (runtime.threads.loadError !== void 0) runtime.threads.reload();
+			};
+			const reloadAfterVisible = () => {
+				if (document.visibilityState === "visible") reloadAfterError();
+			};
+			window.addEventListener("online", reloadAfterError);
+			document.addEventListener("visibilitychange", reloadAfterVisible);
+			return () => {
+				window.removeEventListener("online", reloadAfterError);
+				document.removeEventListener("visibilitychange", reloadAfterVisible);
+			};
+		};
+		$[12] = runtime.threads;
+		$[13] = t5;
+	} else t5 = $[13];
+	let t6;
+	if ($[14] !== runtime) {
+		t6 = [runtime];
+		$[14] = runtime;
+		$[15] = t6;
+	} else t6 = $[15];
+	useEffect(t5, t6);
+	let t7;
+	if ($[16] !== runtime) {
+		t7 = new AssistantRuntimeImpl(runtime);
+		$[16] = runtime;
+		$[17] = t7;
+	} else t7 = $[17];
+	return t7;
 };
 const useRemoteThreadListRuntime = (options) => {
 	const [runtimeHookStore] = useState(() => new WritableSubscribable(options.runtimeHook));
@@ -66,7 +106,7 @@ const useRemoteThreadListRuntime = (options) => {
 		})();
 	}, [runtimeHookStore]);
 	const onThreadIdChange = useEffectEvent((threadId) => {
-		options.onThreadIdChange?.(threadId);
+		return options.onThreadIdChange?.(threadId);
 	});
 	const stableOptions = useMemo(() => ({
 		adapter: options.adapter,

package/dist/react/runtimes/useRemoteThreadListRuntime.js.map

@@ -1 +1 @@
-{"version":3,"file":"useRemoteThreadListRuntime.js","names":["useState","useEffect","useMemo","useRef","useCallback","useEffectEvent","BaseAssistantRuntimeCore","AssistantRuntimeImpl","RemoteThreadListOptions","AssistantRuntimeCore","AssistantRuntime","RemoteThreadListThreadListRuntimeCore","WritableSubscribable","useSubscribable","useAui","RemoteThreadListRuntimeCore","threads","constructor","options","_contextProvider","RenderComponent","__internal_RenderComponent","useRemoteThreadListRuntimeImpl","$","_c","t0","runtime","t1","__internal_setOptions","__internal_load","t2","t3","useRemoteThreadListRuntime","runtimeHookStore","runtimeHook","setState","initialThreadIdRef","initialThreadId","stableRuntimeHook","useCommittedRuntimeHook","subscribe","getState","getServerSnapshot","onThreadIdChange","threadId","stableOptions","adapter","allowNesting","current","aui","isNested","threadListItem","source","Error"],"sources":["../../../src/react/runtimes/useRemoteThreadListRuntime.ts"],"sourcesContent":["import {\n  useState,\n  useEffect,\n  useMemo,\n  useRef,\n  useCallback,\n  useEffectEvent,\n} from \"react\";\nimport { BaseAssistantRuntimeCore } from \"../../runtime/base/base-assistant-runtime-core\";\nimport { AssistantRuntimeImpl } from \"../../runtime/api/assistant-runtime\";\nimport type { RemoteThreadListOptions } from \"../../runtimes/remote-thread-list/types\";\nimport type { AssistantRuntimeCore } from \"../../runtime/interfaces/assistant-runtime-core\";\nimport type { AssistantRuntime } from \"../../runtime/api/assistant-runtime\";\nimport { RemoteThreadListThreadListRuntimeCore } from \"./RemoteThreadListThreadListRuntimeCore\";\nimport { WritableSubscribable } from \"../../subscribable/subscribable\";\nimport { useSubscribable } from \"../../store/runtime-clients/useSubscribable\";\nimport { useAui } from \"@assistant-ui/store\";\n\nclass RemoteThreadListRuntimeCore\n  extends BaseAssistantRuntimeCore\n  implements AssistantRuntimeCore\n{\n  public readonly threads;\n\n  constructor(options: RemoteThreadListOptions) {\n    super();\n    this.threads = new RemoteThreadListThreadListRuntimeCore(\n      options,\n      this._contextProvider,\n    );\n  }\n\n  public get RenderComponent() {\n    return this.threads.__internal_RenderComponent;\n  }\n}\n\nconst useRemoteThreadListRuntimeImpl = (\n  options: RemoteThreadListOptions,\n): AssistantRuntime => {\n  const [runtime] = useState(() => new RemoteThreadListRuntimeCore(options));\n  useEffect(() => {\n    runtime.threads.__internal_setOptions(options);\n    runtime.threads.__internal_load();\n  }, [runtime, options]);\n\n  return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);\n};\n\nexport const useRemoteThreadListRuntime = (\n  options: RemoteThreadListOptions,\n): AssistantRuntime => {\n  const [runtimeHookStore] = useState(\n    () => new WritableSubscribable(options.runtimeHook),\n  );\n  useEffect(() => {\n    runtimeHookStore.setState(options.runtimeHook);\n  }, [runtimeHookStore, options.runtimeHook]);\n\n  const initialThreadIdRef = useRef(options.initialThreadId);\n\n  // Thread resources subscribe to the store rather than reading a ref, so a\n  // hook published at commit reaches exactly the resources that use it and an\n  // abandoned render publishes nothing. The store pins its server snapshot to\n  // the constructor value for hydration, which tap reads on any never-mounted\n  // fiber, so the live state serves as the server snapshot here.\n  const stableRuntimeHook = useCallback(\n    function useCommittedRuntimeHook() {\n      return useSubscribable({\n        subscribe: runtimeHookStore.subscribe,\n        getState: runtimeHookStore.getState,\n        getServerSnapshot: runtimeHookStore.getState,\n      })();\n    },\n    [runtimeHookStore],\n  );\n\n  const onThreadIdChange = useEffectEvent((threadId: string | undefined) => {\n    options.onThreadIdChange?.(threadId);\n  });\n\n  const stableOptions = useMemo<RemoteThreadListOptions>(\n    () => ({\n      adapter: options.adapter,\n      allowNesting: options.allowNesting,\n      threadId: options.threadId,\n      initialThreadId: initialThreadIdRef.current,\n      runtimeHook: stableRuntimeHook,\n      onThreadIdChange,\n    }),\n    [\n      options.adapter,\n      options.allowNesting,\n      options.threadId,\n      stableRuntimeHook,\n    ],\n  );\n\n  const aui = useAui();\n  const isNested = aui.threadListItem.source !== null;\n\n  if (isNested) {\n    if (!stableOptions.allowNesting) {\n      throw new Error(\n        \"useRemoteThreadListRuntime cannot be nested inside another RemoteThreadListRuntime. \" +\n          \"Set allowNesting: true to allow nesting (the inner runtime will become a no-op).\",\n      );\n    }\n\n    // If allowNesting is true and already inside a thread list context,\n    // just call the runtimeHook directly (no-op behavior)\n    return options.runtimeHook();\n  }\n\n  const runtime = useRemoteThreadListRuntimeImpl(stableOptions);\n\n  return runtime;\n};\n"],"mappings":";;;;;;;;;AAkBA,IAAMe,8BAAN,cACUT,yBAEV;CACE;CAEAW,YAAYC,SAAkC;EAC5C,MAAM;EACN,KAAKF,UAAU,IAAIL,sCACjBO,SACA,KAAKC,gBACP;CACF;CAEA,IAAWC,kBAAkB;EAC3B,OAAO,KAAKJ,QAAQK;CACtB;AACF;AAEA,MAAMC,kCAAiCJ,YAAA;CAAA,MAAAK,IAAAC,EAAA,EAAA;CAAA,IAAAC;CAAA,IAAAF,EAAA,OAAAL,SAAA;EAGVO,WAAM,IAAIV,4BAA4BG,OAAO;EAACK,EAAA,KAAAL;EAAAK,EAAA,KAAAE;CAAA,OAAAA,KAAAF,EAAA;CAAzE,MAAA,CAAAG,WAAkB1B,SAASyB,EAA8C;CAAE,IAAAE;CAAA,IAAAJ,EAAA,OAAAL,WAAAK,EAAA,OAAAG,QAAAV,SAAA;EACjEW,WAAA;GACRD,QAAOV,QAAQY,sBAAuBV,OAAO;GAC7CQ,QAAOV,QAAQa,gBAAiB;EAAC;EAClCN,EAAA,KAAAL;EAAAK,EAAA,KAAAG,QAAAV;EAAAO,EAAA,KAAAI;CAAA,OAAAA,KAAAJ,EAAA;CAAA,IAAAO;CAAA,IAAAP,EAAA,OAAAL,WAAAK,EAAA,OAAAG,SAAA;EAAEI,KAAA,CAACJ,SAASR,OAAO;EAACK,EAAA,KAAAL;EAAAK,EAAA,KAAAG;EAAAH,EAAA,KAAAO;CAAA,OAAAA,KAAAP,EAAA;CAHrBtB,UAAU0B,IAGPG,EAAkB;CAAC,IAAAC;CAAA,IAAAR,EAAA,OAAAG,SAAA;EAEDK,KAAA,IAAIxB,qBAAqBmB,OAAO;EAACH,EAAA,KAAAG;EAAAH,EAAA,KAAAQ;CAAA,OAAAA,KAAAR,EAAA;CAAA,OAAjCQ;AAAiC;AAGxD,MAAaC,8BACXd,YACqB;CACrB,MAAM,CAACe,oBAAoBjC,eACnB,IAAIY,qBAAqBM,QAAQgB,WAAW,CACpD;CACAjC,gBAAgB;EACdgC,iBAAiBE,SAASjB,QAAQgB,WAAW;CAC/C,GAAG,CAACD,kBAAkBf,QAAQgB,WAAW,CAAC;CAE1C,MAAME,qBAAqBjC,OAAOe,QAAQmB,eAAe;CAOzD,MAAMC,oBAAoBlC,YACxB,SAASmC,0BAA0B;EACjC,OAAO1B,gBAAgB;GACrB2B,WAAWP,iBAAiBO;GAC5BC,UAAUR,iBAAiBQ;GAC3BC,mBAAmBT,iBAAiBQ;EACtC,CAAC,CAAC,CAAC;CACL,GACA,CAACR,gBAAgB,CACnB;CAEA,MAAMU,mBAAmBtC,gBAAgBuC,aAAiC;EACxE1B,QAAQyB,mBAAmBC,QAAQ;CACrC,CAAC;CAED,MAAMC,gBAAgB3C,eACb;EACL4C,SAAS5B,QAAQ4B;EACjBC,cAAc7B,QAAQ6B;EACtBH,UAAU1B,QAAQ0B;EAClBP,iBAAiBD,mBAAmBY;EACpCd,aAAaI;EACbK;CACF,IACA;EACEzB,QAAQ4B;EACR5B,QAAQ6B;EACR7B,QAAQ0B;EACRN;CAAiB,CAErB;CAKA,IAHYxB,OACKmC,CAAG,CAACE,eAAeC,WAAW,MAEjC;EACZ,IAAI,CAACP,cAAcE,cACjB,MAAM,IAAIM,MACR,sKAEF;EAKF,OAAOnC,QAAQgB,YAAY;CAC7B;CAIA,OAFgBZ,+BAA+BuB,aAExCnB;AACT"}
+{"version":3,"file":"useRemoteThreadListRuntime.js","names":["useState","useEffect","useInsertionEffect","useMemo","useRef","useCallback","useEffectEvent","BaseAssistantRuntimeCore","AssistantRuntimeImpl","RemoteThreadListOptions","AssistantRuntimeCore","AssistantRuntime","RemoteThreadListThreadListRuntimeCore","WritableSubscribable","useSubscribable","useAui","RemoteThreadListRuntimeCore","threads","constructor","options","_contextProvider","RenderComponent","__internal_RenderComponent","useRemoteThreadListRuntimeImpl","$","_c","t0","runtime","t1","queueMicrotask","__internal_dispose","t2","t3","__internal_setOptions","__internal_load","t4","t5","window","document","reloadAfterError","loadError","undefined","reload","reloadAfterVisible","visibilityState","addEventListener","removeEventListener","t6","t7","useRemoteThreadListRuntime","runtimeHookStore","runtimeHook","setState","initialThreadIdRef","initialThreadId","stableRuntimeHook","useCommittedRuntimeHook","subscribe","getState","getServerSnapshot","onThreadIdChange","threadId","stableOptions","adapter","allowNesting","current","aui","isNested","threadListItem","source","Error"],"sources":["../../../src/react/runtimes/useRemoteThreadListRuntime.ts"],"sourcesContent":["import {\n  useState,\n  useEffect,\n  useInsertionEffect,\n  useMemo,\n  useRef,\n  useCallback,\n  useEffectEvent,\n} from \"react\";\nimport { BaseAssistantRuntimeCore } from \"../../runtime/base/base-assistant-runtime-core\";\nimport { AssistantRuntimeImpl } from \"../../runtime/api/assistant-runtime\";\nimport type { RemoteThreadListOptions } from \"../../runtimes/remote-thread-list/types\";\nimport type { AssistantRuntimeCore } from \"../../runtime/interfaces/assistant-runtime-core\";\nimport type { AssistantRuntime } from \"../../runtime/api/assistant-runtime\";\nimport { RemoteThreadListThreadListRuntimeCore } from \"./RemoteThreadListThreadListRuntimeCore\";\nimport { WritableSubscribable } from \"../../subscribable/subscribable\";\nimport { useSubscribable } from \"../../store/runtime-clients/useSubscribable\";\nimport { useAui } from \"@assistant-ui/store\";\n\nclass RemoteThreadListRuntimeCore\n  extends BaseAssistantRuntimeCore\n  implements AssistantRuntimeCore\n{\n  public readonly threads;\n\n  constructor(options: RemoteThreadListOptions) {\n    super();\n    this.threads = new RemoteThreadListThreadListRuntimeCore(\n      options,\n      this._contextProvider,\n    );\n  }\n\n  public get RenderComponent() {\n    return this.threads.__internal_RenderComponent;\n  }\n}\n\nconst useRemoteThreadListRuntimeImpl = (\n  options: RemoteThreadListOptions,\n): AssistantRuntime => {\n  const [runtime] = useState(() => new RemoteThreadListRuntimeCore(options));\n\n  // Insertion-effect cleanup runs only when React deletes the fiber, so a\n  // hidden <Activity> or a re-suspended boundary keeps the threads alive; the\n  // disposal is deferred to a microtask because it notifies subscribers and\n  // React forbids scheduling updates from an insertion effect.\n  useInsertionEffect(\n    () => () => queueMicrotask(() => runtime.threads.__internal_dispose()),\n    [runtime],\n  );\n\n  useEffect(() => {\n    runtime.threads.__internal_setOptions(options);\n    runtime.threads.__internal_load();\n  }, [runtime, options]);\n\n  useEffect(() => {\n    if (typeof window === \"undefined\" || typeof document === \"undefined\") {\n      return;\n    }\n\n    const reloadAfterError = () => {\n      if (runtime.threads.loadError !== undefined) {\n        void runtime.threads.reload();\n      }\n    };\n    const reloadAfterVisible = () => {\n      if (document.visibilityState === \"visible\") reloadAfterError();\n    };\n\n    window.addEventListener(\"online\", reloadAfterError);\n    document.addEventListener(\"visibilitychange\", reloadAfterVisible);\n    return () => {\n      window.removeEventListener(\"online\", reloadAfterError);\n      document.removeEventListener(\"visibilitychange\", reloadAfterVisible);\n    };\n  }, [runtime]);\n\n  return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);\n};\n\nexport const useRemoteThreadListRuntime = (\n  options: RemoteThreadListOptions,\n): AssistantRuntime => {\n  const [runtimeHookStore] = useState(\n    () => new WritableSubscribable(options.runtimeHook),\n  );\n  useEffect(() => {\n    runtimeHookStore.setState(options.runtimeHook);\n  }, [runtimeHookStore, options.runtimeHook]);\n\n  const initialThreadIdRef = useRef(options.initialThreadId);\n\n  // Thread resources subscribe to the store rather than reading a ref, so a\n  // hook published at commit reaches exactly the resources that use it and an\n  // abandoned render publishes nothing. The store pins its server snapshot to\n  // the constructor value for hydration, which tap reads on any never-mounted\n  // fiber, so the live state serves as the server snapshot here.\n  const stableRuntimeHook = useCallback(\n    function useCommittedRuntimeHook() {\n      return useSubscribable({\n        subscribe: runtimeHookStore.subscribe,\n        getState: runtimeHookStore.getState,\n        getServerSnapshot: runtimeHookStore.getState,\n      })();\n    },\n    [runtimeHookStore],\n  );\n\n  const onThreadIdChange = useEffectEvent((threadId: string | undefined) => {\n    return options.onThreadIdChange?.(threadId);\n  });\n\n  const stableOptions = useMemo<RemoteThreadListOptions>(\n    () => ({\n      adapter: options.adapter,\n      allowNesting: options.allowNesting,\n      threadId: options.threadId,\n      initialThreadId: initialThreadIdRef.current,\n      runtimeHook: stableRuntimeHook,\n      onThreadIdChange,\n    }),\n    [\n      options.adapter,\n      options.allowNesting,\n      options.threadId,\n      stableRuntimeHook,\n    ],\n  );\n\n  const aui = useAui();\n  const isNested = aui.threadListItem.source !== null;\n\n  if (isNested) {\n    if (!stableOptions.allowNesting) {\n      throw new Error(\n        \"useRemoteThreadListRuntime cannot be nested inside another RemoteThreadListRuntime. \" +\n          \"Set allowNesting: true to allow nesting (the inner runtime will become a no-op).\",\n      );\n    }\n\n    // If allowNesting is true and already inside a thread list context,\n    // just call the runtimeHook directly (no-op behavior)\n    return options.runtimeHook();\n  }\n\n  const runtime = useRemoteThreadListRuntimeImpl(stableOptions);\n\n  return runtime;\n};\n"],"mappings":"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"}

package/dist/react/utils/groupParts.d.ts

@@ -41,8 +41,10 @@ declare const GROUPBY_MEMO_KEY: unique symbol;
  *   `display: "standalone"`). Resolving the registry-driven cases reads the
  *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence
  *   over the `"tool-call"` entry.
+ *
+ * A `"tool-call:<name>"` entry matches tool calls by tool name and takes precedence over the plain `"tool-call"` entry, while `"standalone-tool-call"` still wins first.
  */
-type GroupPartType = PartState["type"] | "standalone-tool-call";
+type GroupPartType = PartState["type"] | "standalone-tool-call" | `tool-call:${string}`;
 /**
  * Build a `groupBy` from a `part.type → group-key path` lookup.
  * Parts whose type isn't in the map are left ungrouped. The returned
@@ -56,11 +58,14 @@ type GroupPartType = PartState["type"] | "standalone-tool-call";
  * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the
  * `groupBy` function — the helper needs nothing threaded into it.
  *
+ * A `"tool-call:<name>"` entry matches tool calls by tool name and takes precedence over the plain `"tool-call"` entry, while `"standalone-tool-call"` still wins first.
+ *
  * @example
  * ```tsx
  * <MessagePrimitive.GroupedParts
  *   groupBy={groupPartByType({
  *     reasoning: ["group-thought", "group-reasoning"],
+ *     "tool-call:task": ["group-subagents"],
  *     "tool-call": ["group-thought", "group-tool"],
  *     "standalone-tool-call": [],
  *   })}

package/dist/react/utils/groupParts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"groupParts.d.ts","names":[],"sources":["../../../src/react/utils/groupParts.ts"],"mappings":";;;;;;;;;KAUY;;WAED,UAAU;;;;;;;;;;;;;;;;;;;;cAsBR;;;;;;;;;;;;;KAgBR,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BR,kBAAmB,gCAC9B,KAAK,QAAQ,SAAS,OAAO,wBAAwB,gBAClD,MAAM,WAAW,UAAU,4BAA4B;KA2BhD,YAAY,iBAAiB;UAExB;WACN;;WAEA;;WAEA;;;;;WAKA;;WAEA;WACA,mBAAmB;;UAGb;WACN;;WAEA;;WAEA;;;;;WAKA;;;;;;;;;cAiCE,iBACX,uCACA,uDACU"}
+{"version":3,"file":"groupParts.d.ts","names":[],"sources":["../../../src/react/utils/groupParts.ts"],"mappings":";;;;;;;;;KAUY;;WAED,UAAU;;;;;;;;;;;;;;;;;;;;cAsBR;;;;;;;;;;;;;;;KAkBR,gBACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCS,kBAAmB,gCAC9B,KAAK,QAAQ,SAAS,OAAO,wBAAwB,gBAClD,MAAM,WAAW,UAAU,4BAA4B;KA8BhD,YAAY,iBAAiB;UAExB;WACN;;WAEA;;WAEA;;;;;WAKA;;WAEA;WACA,mBAAmB;;UAGb;WACN;;WAEA;;WAEA;;;;;WAKA;;;;;;;;;cAiCE,iBACX,uCACA,uDACU"}

package/dist/react/utils/groupParts.js

@@ -32,11 +32,14 @@ const GROUPBY_MEMO_KEY = Symbol.for("@assistant-ui/groupBy.memoKey");
 * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the
 * `groupBy` function — the helper needs nothing threaded into it.
 *
+* A `"tool-call:<name>"` entry matches tool calls by tool name and takes precedence over the plain `"tool-call"` entry, while `"standalone-tool-call"` still wins first.
+*
 * @example
 * ```tsx
 * <MessagePrimitive.GroupedParts
 *   groupBy={groupPartByType({
 *     reasoning: ["group-thought", "group-reasoning"],
+*     "tool-call:task": ["group-subagents"],
 *     "tool-call": ["group-thought", "group-tool"],
 *     "standalone-tool-call": [],
 *   })}
@@ -50,6 +53,9 @@ const groupPartByType = (map) => {
 	const fn = ((part, context) => {
 		if (part.type === "tool-call") {
 			if ((isMcpAppUri(part.mcp?.app?.resourceUri) || (context?.toolUIs?.[part.toolName]?.[0]?.standalone ?? false)) && lookup["standalone-tool-call"] !== void 0) return lookup["standalone-tool-call"];
+			const toolCallPath = lookup[`tool-call:${part.toolName}`];
+			if (toolCallPath !== void 0) return toolCallPath;
+			return lookup["tool-call"] ?? [];
 		}
 		return lookup[part.type] ?? [];
 	});

package/dist/react/utils/groupParts.js.map

@@ -1 +1 @@
-{"version":3,"file":"groupParts.js","names":["isMcpAppUri","PartState","ToolsState","GroupByContext","toolUIs","GROUPBY_MEMO_KEY","Symbol","for","GroupPartType","groupPartByType","map","Partial","Readonly","Record","TKey","part","context","lookup","fn","type","isMcpApp","mcp","app","resourceUri","isStandalone","toolName","standalone","undefined","sortedKeys","Object","keys","sort","sortedEntries","k","JSON","stringify","GroupNode","GroupNodeGroup","GroupNodePart","key","nodeKey","idKey","indices","children","index","BuildFrame","nextChildIdx","claimed","Set","makeChildNodeKey","parent","idx","String","claimIdKey","frame","id","has","add","buildGroupTree","paths","partIds","root","stack","closeTop","closing","pop","length","push","i","path","common","top","s"],"sources":["../../../src/react/utils/groupParts.ts"],"sourcesContent":["import { isMcpAppUri } from \"../../types/message\";\nimport type { PartState } from \"../../store/scopes/part\";\nimport type { ToolsState } from \"../types/scopes/tools\";\n\n/**\n * Registry context passed to a `groupBy` function as its second argument by\n * `<MessagePrimitive.GroupedParts>`. Carries the live tool-UI registry so a\n * `groupBy` can resolve registry-driven grouping (e.g. standalone tool calls)\n * without the part itself having to carry that information.\n */\nexport type GroupByContext = {\n  /** Tool UIs registered in the tool-UI registry, keyed by tool name. */\n  readonly toolUIs?: ToolsState[\"toolUIs\"];\n};\n\n/**\n * Hierarchical adjacent-coalescing grouping for message parts.\n *\n * Given a group path per part (from `groupBy`), builds a tree of group\n * nodes wrapping individual parts. Adjacent parts sharing a path prefix\n * coalesce into the same group; ungrouped parts are direct children of\n * the root.\n *\n * Each node gets a structural `nodeKey` built from sibling indices\n * (`\"0.1.0\"`), stable under append-only streaming.\n */\n\n/**\n * Symbol attached to memoizable `groupBy` functions (e.g. those returned\n * by {@link groupPartByType}). Carries a string fingerprint of the config\n * so `MessagePrimitive.GroupedParts` can memo the tree on\n * `[parts, memoKey]` across renders — even when the helper call site\n * reconstructs the function each render.\n */\nexport const GROUPBY_MEMO_KEY: unique symbol = Symbol.for(\n  \"@assistant-ui/groupBy.memoKey\",\n);\n\n/**\n * Synthetic part-type keys recognized by {@link groupPartByType}, in\n * addition to real {@link PartState} types:\n *\n * - `\"standalone-tool-call\"` — a tool-call whose UI should be presented on its\n *   own, outside the chain-of-thought grouping. Matches MCP-app tool calls plus\n *   any tool-call whose registered UI opts into standalone display (human\n *   tools, the built-in generative-UI tool, and tools that set\n *   `display: \"standalone\"`). Resolving the registry-driven cases reads the\n *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence\n *   over the `\"tool-call\"` entry.\n */\ntype GroupPartType = PartState[\"type\"] | \"standalone-tool-call\";\n\n/**\n * Build a `groupBy` from a `part.type → group-key path` lookup.\n * Parts whose type isn't in the map are left ungrouped. The returned\n * function carries a stable {@link GROUPBY_MEMO_KEY} fingerprint so\n * `<MessagePrimitive.GroupedParts>` can memoize its tree across renders.\n *\n * The synthetic `\"standalone-tool-call\"` key matches tool calls that should\n * render outside the chain-of-thought grouping. MCP-app calls are detected from\n * the part alone; the registry-driven cases (human tools, the generative-UI\n * tool, `display: \"standalone\"` opt-ins) are resolved from the\n * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the\n * `groupBy` function — the helper needs nothing threaded into it.\n *\n * @example\n * ```tsx\n * <MessagePrimitive.GroupedParts\n *   groupBy={groupPartByType({\n *     reasoning: [\"group-thought\", \"group-reasoning\"],\n *     \"tool-call\": [\"group-thought\", \"group-tool\"],\n *     \"standalone-tool-call\": [],\n *   })}\n * >\n *   {({ part, children }) => { ... }}\n * </MessagePrimitive.GroupedParts>\n * ```\n */\nexport const groupPartByType = <TKey extends `group-${string}`>(\n  map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>,\n): ((part: PartState, context?: GroupByContext) => readonly TKey[]) => {\n  const lookup = map as Readonly<Record<string, readonly TKey[] | undefined>>;\n  const fn = ((part, context) => {\n    if (part.type === \"tool-call\") {\n      const isMcpApp = isMcpAppUri(part.mcp?.app?.resourceUri);\n      // Read the first registration's flag — the same one `resolveToolRender`\n      // renders — so grouping and rendering never disagree for a tool name.\n      const isStandalone =\n        isMcpApp ||\n        (context?.toolUIs?.[part.toolName]?.[0]?.standalone ?? false);\n      if (isStandalone && lookup[\"standalone-tool-call\"] !== undefined) {\n        return lookup[\"standalone-tool-call\"]!;\n      }\n    }\n    return lookup[part.type] ?? [];\n  }) as ((part: PartState, context?: GroupByContext) => readonly TKey[]) & {\n    [GROUPBY_MEMO_KEY]?: string;\n  };\n  // Sort keys so the fingerprint is insensitive to map insertion order —\n  // two maps with the same key/value pairs but different declaration order\n  // would otherwise hash differently and invalidate the memo unnecessarily.\n  const sortedKeys = Object.keys(map).sort();\n  const sortedEntries = sortedKeys.map((k) => [k, map[k as keyof typeof map]]);\n  fn[GROUPBY_MEMO_KEY] = `groupPartByType:${JSON.stringify(sortedEntries)}`;\n  return fn;\n};\n\nexport type GroupNode = GroupNodeGroup | GroupNodePart;\n\nexport interface GroupNodeGroup {\n  readonly type: \"group\";\n  /** Current-level group key (last segment of the path). */\n  readonly key: string;\n  /** Structural React key: sibling-index path, e.g. `\"0.1.0\"`. */\n  readonly nodeKey: string;\n  /**\n   * Identity key (`\"id:<partId>\"`) from the group's first part; undefined\n   * when absent or already claimed by an earlier sibling.\n   */\n  readonly idKey: string | undefined;\n  /** Indices of parts in this subtree, in order. */\n  readonly indices: readonly number[];\n  readonly children: readonly GroupNode[];\n}\n\nexport interface GroupNodePart {\n  readonly type: \"part\";\n  /** Index of the part in the message. */\n  readonly index: number;\n  /** Structural React key: sibling-index path within parent. */\n  readonly nodeKey: string;\n  /**\n   * Identity key (`\"id:<partId>\"`); undefined when absent or already\n   * claimed by an earlier sibling.\n   */\n  readonly idKey: string | undefined;\n}\n\ninterface BuildFrame {\n  key: string;\n  nodeKey: string;\n  indices: number[];\n  children: GroupNode[];\n  nextChildIdx: number;\n  claimed: Set<string>;\n}\n\nconst makeChildNodeKey = (parent: BuildFrame): string => {\n  const idx = parent.nextChildIdx++;\n  return parent.nodeKey === \"\" ? String(idx) : `${parent.nodeKey}.${idx}`;\n};\n\nconst claimIdKey = (\n  frame: BuildFrame,\n  id: string | undefined,\n): string | undefined => {\n  if (id === undefined || frame.claimed.has(id)) return undefined;\n  frame.claimed.add(id);\n  return `id:${id}`;\n};\n\n/**\n * Build the group tree from an array of normalized group paths.\n * `paths[i]` is the path for part `i`. The output tree contains one\n * `part` node per part and one `group` node per coalesced run.\n * `partIds[i]` optionally carries a stable identity for part `i` (e.g. a\n * tool call id), from which nodes derive an `idKey`.\n */\nexport const buildGroupTree = (\n  paths: readonly (readonly string[])[],\n  partIds?: readonly (string | undefined)[],\n): readonly GroupNode[] => {\n  const root: BuildFrame = {\n    key: \"\",\n    nodeKey: \"\",\n    indices: [],\n    children: [],\n    nextChildIdx: 0,\n    claimed: new Set(),\n  };\n  const stack: BuildFrame[] = [root];\n\n  const closeTop = (): void => {\n    const closing = stack.pop()!;\n    const parent = stack[stack.length - 1]!;\n    parent.children.push({\n      type: \"group\",\n      key: closing.key,\n      nodeKey: closing.nodeKey,\n      idKey: claimIdKey(parent, partIds?.[closing.indices[0]!]),\n      indices: closing.indices,\n      children: closing.children,\n    });\n  };\n\n  for (let i = 0; i < paths.length; i++) {\n    const path = paths[i]!;\n\n    // Find the longest prefix shared between currently-open groups\n    // (excluding root) and this part's path.\n    let common = 0;\n    while (\n      common < stack.length - 1 &&\n      common < path.length &&\n      stack[common + 1]!.key === path[common]\n    ) {\n      common++;\n    }\n\n    // Close groups not on this path.\n    while (stack.length - 1 > common) {\n      closeTop();\n    }\n\n    // Open new groups down to the part's depth.\n    while (stack.length - 1 < path.length) {\n      const parent = stack[stack.length - 1]!;\n      stack.push({\n        key: path[stack.length - 1]!,\n        nodeKey: makeChildNodeKey(parent),\n        indices: [],\n        children: [],\n        nextChildIdx: 0,\n        claimed: new Set(),\n      });\n    }\n\n    // Push this part as a leaf in the deepest open group (or root).\n    const top = stack[stack.length - 1]!;\n    top.children.push({\n      type: \"part\",\n      index: i,\n      nodeKey: makeChildNodeKey(top),\n      idKey: claimIdKey(top, partIds?.[i]),\n    });\n\n    // Record the part index in every open ancestor group.\n    for (let s = 1; s < stack.length; s++) {\n      stack[s]!.indices.push(i);\n    }\n  }\n\n  // Close any still-open groups.\n  while (stack.length > 1) {\n    closeTop();\n  }\n\n  return root.children;\n};\n"],"mappings":"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"}
+{"version":3,"file":"groupParts.js","names":["isMcpAppUri","PartState","ToolsState","GroupByContext","toolUIs","GROUPBY_MEMO_KEY","Symbol","for","GroupPartType","groupPartByType","map","Partial","Readonly","Record","TKey","part","context","lookup","fn","type","isMcpApp","mcp","app","resourceUri","isStandalone","toolName","standalone","undefined","toolCallPath","sortedKeys","Object","keys","sort","sortedEntries","k","JSON","stringify","GroupNode","GroupNodeGroup","GroupNodePart","key","nodeKey","idKey","indices","children","index","BuildFrame","nextChildIdx","claimed","Set","makeChildNodeKey","parent","idx","String","claimIdKey","frame","id","has","add","buildGroupTree","paths","partIds","root","stack","closeTop","closing","pop","length","push","i","path","common","top","s"],"sources":["../../../src/react/utils/groupParts.ts"],"sourcesContent":["import { isMcpAppUri } from \"../../types/message\";\nimport type { PartState } from \"../../store/scopes/part\";\nimport type { ToolsState } from \"../types/scopes/tools\";\n\n/**\n * Registry context passed to a `groupBy` function as its second argument by\n * `<MessagePrimitive.GroupedParts>`. Carries the live tool-UI registry so a\n * `groupBy` can resolve registry-driven grouping (e.g. standalone tool calls)\n * without the part itself having to carry that information.\n */\nexport type GroupByContext = {\n  /** Tool UIs registered in the tool-UI registry, keyed by tool name. */\n  readonly toolUIs?: ToolsState[\"toolUIs\"];\n};\n\n/**\n * Hierarchical adjacent-coalescing grouping for message parts.\n *\n * Given a group path per part (from `groupBy`), builds a tree of group\n * nodes wrapping individual parts. Adjacent parts sharing a path prefix\n * coalesce into the same group; ungrouped parts are direct children of\n * the root.\n *\n * Each node gets a structural `nodeKey` built from sibling indices\n * (`\"0.1.0\"`), stable under append-only streaming.\n */\n\n/**\n * Symbol attached to memoizable `groupBy` functions (e.g. those returned\n * by {@link groupPartByType}). Carries a string fingerprint of the config\n * so `MessagePrimitive.GroupedParts` can memo the tree on\n * `[parts, memoKey]` across renders — even when the helper call site\n * reconstructs the function each render.\n */\nexport const GROUPBY_MEMO_KEY: unique symbol = Symbol.for(\n  \"@assistant-ui/groupBy.memoKey\",\n);\n\n/**\n * Synthetic part-type keys recognized by {@link groupPartByType}, in\n * addition to real {@link PartState} types:\n *\n * - `\"standalone-tool-call\"` — a tool-call whose UI should be presented on its\n *   own, outside the chain-of-thought grouping. Matches MCP-app tool calls plus\n *   any tool-call whose registered UI opts into standalone display (human\n *   tools, the built-in generative-UI tool, and tools that set\n *   `display: \"standalone\"`). Resolving the registry-driven cases reads the\n *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence\n *   over the `\"tool-call\"` entry.\n *\n * A `\"tool-call:<name>\"` entry matches tool calls by tool name and takes precedence over the plain `\"tool-call\"` entry, while `\"standalone-tool-call\"` still wins first.\n */\ntype GroupPartType =\n  | PartState[\"type\"]\n  | \"standalone-tool-call\"\n  | `tool-call:${string}`;\n\n/**\n * Build a `groupBy` from a `part.type → group-key path` lookup.\n * Parts whose type isn't in the map are left ungrouped. The returned\n * function carries a stable {@link GROUPBY_MEMO_KEY} fingerprint so\n * `<MessagePrimitive.GroupedParts>` can memoize its tree across renders.\n *\n * The synthetic `\"standalone-tool-call\"` key matches tool calls that should\n * render outside the chain-of-thought grouping. MCP-app calls are detected from\n * the part alone; the registry-driven cases (human tools, the generative-UI\n * tool, `display: \"standalone\"` opt-ins) are resolved from the\n * {@link GroupByContext} that `<MessagePrimitive.GroupedParts>` passes to the\n * `groupBy` function — the helper needs nothing threaded into it.\n *\n * A `\"tool-call:<name>\"` entry matches tool calls by tool name and takes precedence over the plain `\"tool-call\"` entry, while `\"standalone-tool-call\"` still wins first.\n *\n * @example\n * ```tsx\n * <MessagePrimitive.GroupedParts\n *   groupBy={groupPartByType({\n *     reasoning: [\"group-thought\", \"group-reasoning\"],\n *     \"tool-call:task\": [\"group-subagents\"],\n *     \"tool-call\": [\"group-thought\", \"group-tool\"],\n *     \"standalone-tool-call\": [],\n *   })}\n * >\n *   {({ part, children }) => { ... }}\n * </MessagePrimitive.GroupedParts>\n * ```\n */\nexport const groupPartByType = <TKey extends `group-${string}`>(\n  map: Partial<Readonly<Record<GroupPartType, readonly TKey[]>>>,\n): ((part: PartState, context?: GroupByContext) => readonly TKey[]) => {\n  const lookup = map as Readonly<Record<string, readonly TKey[] | undefined>>;\n  const fn = ((part, context) => {\n    if (part.type === \"tool-call\") {\n      const isMcpApp = isMcpAppUri(part.mcp?.app?.resourceUri);\n      // Read the first registration's flag — the same one `resolveToolRender`\n      // renders — so grouping and rendering never disagree for a tool name.\n      const isStandalone =\n        isMcpApp ||\n        (context?.toolUIs?.[part.toolName]?.[0]?.standalone ?? false);\n      if (isStandalone && lookup[\"standalone-tool-call\"] !== undefined) {\n        return lookup[\"standalone-tool-call\"]!;\n      }\n      const toolCallPath = lookup[`tool-call:${part.toolName}`];\n      if (toolCallPath !== undefined) return toolCallPath;\n      return lookup[\"tool-call\"] ?? [];\n    }\n    return lookup[part.type] ?? [];\n  }) as ((part: PartState, context?: GroupByContext) => readonly TKey[]) & {\n    [GROUPBY_MEMO_KEY]?: string;\n  };\n  // Sort keys so the fingerprint is insensitive to map insertion order —\n  // two maps with the same key/value pairs but different declaration order\n  // would otherwise hash differently and invalidate the memo unnecessarily.\n  const sortedKeys = Object.keys(map).sort();\n  const sortedEntries = sortedKeys.map((k) => [k, map[k as keyof typeof map]]);\n  fn[GROUPBY_MEMO_KEY] = `groupPartByType:${JSON.stringify(sortedEntries)}`;\n  return fn;\n};\n\nexport type GroupNode = GroupNodeGroup | GroupNodePart;\n\nexport interface GroupNodeGroup {\n  readonly type: \"group\";\n  /** Current-level group key (last segment of the path). */\n  readonly key: string;\n  /** Structural React key: sibling-index path, e.g. `\"0.1.0\"`. */\n  readonly nodeKey: string;\n  /**\n   * Identity key (`\"id:<partId>\"`) from the group's first part; undefined\n   * when absent or already claimed by an earlier sibling.\n   */\n  readonly idKey: string | undefined;\n  /** Indices of parts in this subtree, in order. */\n  readonly indices: readonly number[];\n  readonly children: readonly GroupNode[];\n}\n\nexport interface GroupNodePart {\n  readonly type: \"part\";\n  /** Index of the part in the message. */\n  readonly index: number;\n  /** Structural React key: sibling-index path within parent. */\n  readonly nodeKey: string;\n  /**\n   * Identity key (`\"id:<partId>\"`); undefined when absent or already\n   * claimed by an earlier sibling.\n   */\n  readonly idKey: string | undefined;\n}\n\ninterface BuildFrame {\n  key: string;\n  nodeKey: string;\n  indices: number[];\n  children: GroupNode[];\n  nextChildIdx: number;\n  claimed: Set<string>;\n}\n\nconst makeChildNodeKey = (parent: BuildFrame): string => {\n  const idx = parent.nextChildIdx++;\n  return parent.nodeKey === \"\" ? String(idx) : `${parent.nodeKey}.${idx}`;\n};\n\nconst claimIdKey = (\n  frame: BuildFrame,\n  id: string | undefined,\n): string | undefined => {\n  if (id === undefined || frame.claimed.has(id)) return undefined;\n  frame.claimed.add(id);\n  return `id:${id}`;\n};\n\n/**\n * Build the group tree from an array of normalized group paths.\n * `paths[i]` is the path for part `i`. The output tree contains one\n * `part` node per part and one `group` node per coalesced run.\n * `partIds[i]` optionally carries a stable identity for part `i` (e.g. a\n * tool call id), from which nodes derive an `idKey`.\n */\nexport const buildGroupTree = (\n  paths: readonly (readonly string[])[],\n  partIds?: readonly (string | undefined)[],\n): readonly GroupNode[] => {\n  const root: BuildFrame = {\n    key: \"\",\n    nodeKey: \"\",\n    indices: [],\n    children: [],\n    nextChildIdx: 0,\n    claimed: new Set(),\n  };\n  const stack: BuildFrame[] = [root];\n\n  const closeTop = (): void => {\n    const closing = stack.pop()!;\n    const parent = stack[stack.length - 1]!;\n    parent.children.push({\n      type: \"group\",\n      key: closing.key,\n      nodeKey: closing.nodeKey,\n      idKey: claimIdKey(parent, partIds?.[closing.indices[0]!]),\n      indices: closing.indices,\n      children: closing.children,\n    });\n  };\n\n  for (let i = 0; i < paths.length; i++) {\n    const path = paths[i]!;\n\n    // Find the longest prefix shared between currently-open groups\n    // (excluding root) and this part's path.\n    let common = 0;\n    while (\n      common < stack.length - 1 &&\n      common < path.length &&\n      stack[common + 1]!.key === path[common]\n    ) {\n      common++;\n    }\n\n    // Close groups not on this path.\n    while (stack.length - 1 > common) {\n      closeTop();\n    }\n\n    // Open new groups down to the part's depth.\n    while (stack.length - 1 < path.length) {\n      const parent = stack[stack.length - 1]!;\n      stack.push({\n        key: path[stack.length - 1]!,\n        nodeKey: makeChildNodeKey(parent),\n        indices: [],\n        children: [],\n        nextChildIdx: 0,\n        claimed: new Set(),\n      });\n    }\n\n    // Push this part as a leaf in the deepest open group (or root).\n    const top = stack[stack.length - 1]!;\n    top.children.push({\n      type: \"part\",\n      index: i,\n      nodeKey: makeChildNodeKey(top),\n      idKey: claimIdKey(top, partIds?.[i]),\n    });\n\n    // Record the part index in every open ancestor group.\n    for (let s = 1; s < stack.length; s++) {\n      stack[s]!.indices.push(i);\n    }\n  }\n\n  // Close any still-open groups.\n  while (stack.length > 1) {\n    closeTop();\n  }\n\n  return root.children;\n};\n"],"mappings":"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"}

package/dist/react/utils/useJSONEqual.d.ts

@@ -1,4 +1,6 @@
+import { ReadonlyJSONValue } from "assistant-stream/utils";
 //#region src/react/utils/useJSONEqual.d.ts
+declare function useJSONEqualValue<T extends ReadonlyJSONValue>(value: T): T;
 /**
  * Like `useShallow`, but with JSON deep-equality. Use when a selector derives an
  * equal-but-fresh value on every store update — e.g. folding over
@@ -7,5 +9,5 @@
  */
 declare function useJSONEqual<S, U>(selector: (state: S) => U): (state: S) => U;
 //#endregion
-export { useJSONEqual };
+export { useJSONEqual, useJSONEqualValue };
 //# sourceMappingURL=useJSONEqual.d.ts.map

package/dist/react/utils/useJSONEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useJSONEqual.d.ts","names":[],"sources":["../../../src/react/utils/useJSONEqual.ts"],"mappings":";;;;;;;iBASgB,aAAa,GAAG,GAAG,WAAW,OAAO,MAAM,KAAK,OAAO,MAAM"}
+{"version":3,"file":"useJSONEqual.d.ts","names":[],"sources":["../../../src/react/utils/useJSONEqual.ts"],"mappings":";;iBAIgB,kBAAkB,UAAU,mBAAmB,OAAO,IAAI;;;;;;;iBAc1D,aAAa,GAAG,GAAG,WAAW,OAAO,MAAM,KAAK,OAAO,MAAM"}

package/dist/react/utils/useJSONEqual.js

@@ -2,6 +2,11 @@ import { isJSONValueEqual } from "../../utils/json/is-json-equal.js";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import { useRef } from "@assistant-ui/tap/react-shim";
 //#region src/react/utils/useJSONEqual.ts
+function useJSONEqualValue(value) {
+	const prev = useRef(value);
+	if (prev.current !== value && !isJSONValueEqual(prev.current, value)) prev.current = value;
+	return prev.current;
+}
 /**
 * Like `useShallow`, but with JSON deep-equality. Use when a selector derives an
 * equal-but-fresh value on every store update — e.g. folding over
@@ -25,6 +30,6 @@ function useJSONEqual(selector) {
 	return t0;
 }
 //#endregion
-export { useJSONEqual };
+export { useJSONEqual, useJSONEqualValue };
 
 //# sourceMappingURL=useJSONEqual.js.map

package/dist/react/utils/useJSONEqual.js.map

@@ -1 +1 @@
-{"version":3,"file":"useJSONEqual.js","names":["useRef","isJSONValueEqual","useJSONEqual","selector","$","_c","prev","undefined","t0","state","next","current"],"sources":["../../../src/react/utils/useJSONEqual.ts"],"sourcesContent":["import { useRef } from \"react\";\nimport { isJSONValueEqual } from \"../../utils/json/is-json-equal\";\n\n/**\n * Like `useShallow`, but with JSON deep-equality. Use when a selector derives an\n * equal-but-fresh value on every store update — e.g. folding over\n * `thread.messages`, whose identity changes on every streaming token — where a\n * shallow compare would re-render regardless.\n */\nexport function useJSONEqual<S, U>(selector: (state: S) => U): (state: S) => U {\n  const prev = useRef<U | undefined>(undefined);\n  return (state) => {\n    const next = selector(state);\n    if (prev.current !== undefined && isJSONValueEqual(prev.current, next)) {\n      return prev.current;\n    }\n    prev.current = next;\n    return next;\n  };\n}\n"],"mappings":";;;;;;;;;;AASA,SAAOE,aAAAC,UAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACL,MAAAC,OAAaN,OAAsBO,KAAAA,CAAS;CAAE,IAAAC;CAAA,IAAAJ,EAAA,OAAAD,UAAA;EACvCK,MAAAC,UAAA;GACL,MAAAC,OAAaP,SAASM,KAAK;GAC3B,IAAIH,KAAIK,YAAaJ,KAAAA,KAAaN,iBAAiBK,KAAIK,SAAUD,IAAI,GAAC,OAC7DJ,KAAIK;GAEbL,KAAIK,UAAWD;GAAH,OACLA;EAAI;EACZN,EAAA,KAAAD;EAAAC,EAAA,KAAAI;CAAA,OAAAA,KAAAJ,EAAA;CAAA,OAPMI;AAON"}
+{"version":3,"file":"useJSONEqual.js","names":["useRef","ReadonlyJSONValue","isJSONValueEqual","useJSONEqualValue","value","T","prev","current","useJSONEqual","selector","$","_c","undefined","t0","state","next"],"sources":["../../../src/react/utils/useJSONEqual.ts"],"sourcesContent":["import { useRef } from \"react\";\nimport type { ReadonlyJSONValue } from \"assistant-stream/utils\";\nimport { isJSONValueEqual } from \"../../utils/json/is-json-equal\";\n\nexport function useJSONEqualValue<T extends ReadonlyJSONValue>(value: T): T {\n  const prev = useRef(value);\n  if (prev.current !== value && !isJSONValueEqual(prev.current, value)) {\n    prev.current = value;\n  }\n  return prev.current;\n}\n\n/**\n * Like `useShallow`, but with JSON deep-equality. Use when a selector derives an\n * equal-but-fresh value on every store update — e.g. folding over\n * `thread.messages`, whose identity changes on every streaming token — where a\n * shallow compare would re-render regardless.\n */\nexport function useJSONEqual<S, U>(selector: (state: S) => U): (state: S) => U {\n  const prev = useRef<U | undefined>(undefined);\n  return (state) => {\n    const next = selector(state);\n    if (prev.current !== undefined && isJSONValueEqual(prev.current, next)) {\n      return prev.current;\n    }\n    prev.current = next;\n    return next;\n  };\n}\n"],"mappings":";;;;AAIA,SAAgBG,kBAA+CC,OAAa;CAC1E,MAAME,OAAON,OAAOI,KAAK;CACzB,IAAIE,KAAKC,YAAYH,SAAS,CAACF,iBAAiBI,KAAKC,SAASH,KAAK,GACjEE,KAAKC,UAAUH;CAEjB,OAAOE,KAAKC;AACd;;;;;;;AAQA,SAAOC,aAAAC,UAAA;CAAA,MAAAC,IAAAC,EAAA,CAAA;CACL,MAAAL,OAAaN,OAAsBY,KAAAA,CAAS;CAAE,IAAAC;CAAA,IAAAH,EAAA,OAAAD,UAAA;EACvCI,MAAAC,UAAA;GACL,MAAAC,OAAaN,SAASK,KAAK;GAC3B,IAAIR,KAAIC,YAAaK,KAAAA,KAAaV,iBAAiBI,KAAIC,SAAUQ,IAAI,GAAC,OAC7DT,KAAIC;GAEbD,KAAIC,UAAWQ;GAAH,OACLA;EAAI;EACZL,EAAA,KAAAD;EAAAC,EAAA,KAAAG;CAAA,OAAAA,KAAAH,EAAA;CAAA,OAPMG;AAON"}

package/dist/react/utils/useJSONSchemaDependency.d.ts

@@ -0,0 +1,7 @@
+import { Unstable_InteractableStateSchema } from "../types/scopes/interactables.js";
+import { ReadonlyJSONValue } from "assistant-stream/utils";
+//#region src/react/utils/useJSONSchemaDependency.d.ts
+declare function useJSONSchemaDependency(schema: Unstable_InteractableStateSchema): ReadonlyJSONValue;
+//#endregion
+export { useJSONSchemaDependency };
+//# sourceMappingURL=useJSONSchemaDependency.d.ts.map

package/dist/react/utils/useJSONSchemaDependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useJSONSchemaDependency.d.ts","names":[],"sources":["../../../src/react/utils/useJSONSchemaDependency.ts"],"mappings":";;;iBAOgB,wBACd,QAAQ,mCACP"}

package/dist/react/utils/useJSONSchemaDependency.js

@@ -0,0 +1,20 @@
+import { isJSONValue } from "../../utils/json/is-json.js";
+import { useJSONEqualValue } from "./useJSONEqual.js";
+import { toJSONSchema } from "assistant-stream";
+import { useMemo } from "@assistant-ui/tap/react-shim";
+//#region src/react/utils/useJSONSchemaDependency.ts
+function useJSONSchemaDependency(schema) {
+	const normalizedSchema = useMemo(() => {
+		try {
+			const jsonSchema = toJSONSchema(schema);
+			return isJSONValue(jsonSchema) ? jsonSchema : null;
+		} catch {
+			return null;
+		}
+	}, [schema]);
+	return useJSONEqualValue(normalizedSchema);
+}
+//#endregion
+export { useJSONSchemaDependency };
+
+//# sourceMappingURL=useJSONSchemaDependency.js.map

package/dist/react/utils/useJSONSchemaDependency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useJSONSchemaDependency.js","names":["useMemo","toJSONSchema","ReadonlyJSONValue","isJSONValue","Unstable_InteractableStateSchema","useJSONEqualValue","useJSONSchemaDependency","schema","normalizedSchema","jsonSchema"],"sources":["../../../src/react/utils/useJSONSchemaDependency.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { toJSONSchema } from \"assistant-stream\";\nimport type { ReadonlyJSONValue } from \"assistant-stream/utils\";\nimport { isJSONValue } from \"../../utils/json/is-json\";\nimport type { Unstable_InteractableStateSchema } from \"../types/scopes/interactables\";\nimport { useJSONEqualValue } from \"./useJSONEqual\";\n\nexport function useJSONSchemaDependency(\n  schema: Unstable_InteractableStateSchema,\n): ReadonlyJSONValue {\n  const normalizedSchema = useMemo(() => {\n    try {\n      const jsonSchema = toJSONSchema(schema);\n      return isJSONValue(jsonSchema) ? jsonSchema : null;\n    } catch {\n      // Opaque schemas share one fallback so rebuilt instances do not churn registration.\n      return null;\n    }\n  }, [schema]);\n\n  return useJSONEqualValue(normalizedSchema);\n}\n"],"mappings":";;;;;AAOA,SAAgBM,wBACdC,QACmB;CACnB,MAAMC,mBAAmBR,cAAc;EACrC,IAAI;GACF,MAAMS,aAAaR,aAAaM,MAAM;GACtC,OAAOJ,YAAYM,UAAU,IAAIA,aAAa;EAChD,QAAQ;GAEN,OAAO;EACT;CACF,GAAG,CAACF,MAAM,CAAC;CAEX,OAAOF,kBAAkBG,gBAAgB;AAC3C"}

package/dist/runtime/api/thread-list-item-runtime.d.ts

@@ -21,6 +21,10 @@ type ThreadListItemEventPayload = {
 };
 type ThreadListItemEventType = keyof ThreadListItemEventPayload;
 type ThreadListItemEventCallback<E extends ThreadListItemEventType> = (payload: ThreadListItemEventPayload[E]) => void;
+type ThreadListItemGenerateTitleOptions = {
+  /** Marks a generation started by the automatic title trigger. */
+  automatic?: boolean;
+};
 type ThreadListItemRuntime = {
   readonly path: ThreadListItemRuntimePath;
   getState(): ThreadListItemState;
@@ -28,7 +32,7 @@ type ThreadListItemRuntime = {
     remoteId: string;
     externalId: string | undefined;
   }>;
-  generateTitle(): Promise<void>;
+  generateTitle(options?: ThreadListItemGenerateTitleOptions): Promise<void>;
   switchTo(options?: {
     unarchive?: boolean;
   }): Promise<void>;
@@ -62,12 +66,12 @@ declare class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
     remoteId: string;
     externalId: string | undefined;
   }>;
-  generateTitle(): Promise<void>;
+  generateTitle(options?: ThreadListItemGenerateTitleOptions): Promise<void>;
   unstable_on<E extends ThreadListItemEventType>(event: E, callback: ThreadListItemEventCallback<E>): Unsubscribe;
   subscribe(callback: () => void): Unsubscribe;
   detach(): void;
   __internal_getRuntime(): ThreadListItemRuntime;
 }
 //#endregion
-export { ThreadListItemEventCallback, ThreadListItemEventPayload, ThreadListItemEventType, ThreadListItemRuntime, ThreadListItemRuntimeImpl, type ThreadListItemState, ThreadListItemStateBinding, type ThreadListItemStatus };
+export { ThreadListItemEventCallback, ThreadListItemEventPayload, ThreadListItemEventType, ThreadListItemGenerateTitleOptions, ThreadListItemRuntime, ThreadListItemRuntimeImpl, type ThreadListItemState, ThreadListItemStateBinding, type ThreadListItemStatus };
 //# sourceMappingURL=thread-list-item-runtime.d.ts.map

package/dist/runtime/api/thread-list-item-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thread-list-item-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/thread-list-item-runtime.ts"],"mappings":";;;;;;;KAMY;;;;;;EAMV,YAAY;;;;;;EAMZ,cAAc;;KAGJ,gCAAgC;KAEhC,4BAA4B,UAAU,4BAChD,SAAS,2BAA2B;KAQ1B;WACD,MAAM;EACf,YAAY;EAEZ,cAAc;IAAU;IAAkB;;EAC1C,iBAAiB;EAEjB,SAAS;IAAY;MAAwB;EAC7C,OAAO,mBAAmB;EAC1B,aAAa,QAAQ,sCAAsC;EAC3D,WAAW;EACX,aAAa;EACb,UAAU;EAEV;EAEA,UAAU,uBAAuB;EAEjC,YAAY,UAAU,yBACpB,OAAO,GACP,UAAU,4BAA4B,KACrC;EAEH,yBAAyB;;KAGf,6BAA6B,sBACvC,qBACA;cAGW,qCAAqC;MACrC,QAAI;UAIP;UACA;EAGN,YAAA,OAAO,4BACP,oBAAoB;YAOZ;EAeH,YAAY;EAIZ,SAAS;IAAY;MAAwB;EAK7C,OAAO,mBAAmB;EAM1B,aACL,QAAQ,sCACP;EAWI,WAAW;EAMX,aAAa;EAMb,UAAU;EAMV,cAAc;IACnB;IACA;;EAMK,iBAAiB;EAKjB,YAAY,UAAU,yBAC3B,OAAO,GACP,UAAU,4BAA4B,KAAE;EAsBnC,UAAU,uBAAuB;EAIjC;EAMA,yBAAyB"}
+{"version":3,"file":"thread-list-item-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/thread-list-item-runtime.ts"],"mappings":";;;;;;;KAMY;;;;;;EAMV,YAAY;;;;;;EAMZ,cAAc;;KAGJ,gCAAgC;KAEhC,4BAA4B,UAAU,4BAChD,SAAS,2BAA2B;KAQ1B;;EAEV;;KAGU;WACD,MAAM;EACf,YAAY;EAEZ,cAAc;IAAU;IAAkB;;EAC1C,cAAc,UAAU,qCAAqC;EAE7D,SAAS;IAAY;MAAwB;EAC7C,OAAO,mBAAmB;EAC1B,aAAa,QAAQ,sCAAsC;EAC3D,WAAW;EACX,aAAa;EACb,UAAU;EAEV;EAEA,UAAU,uBAAuB;EAEjC,YAAY,UAAU,yBACpB,OAAO,GACP,UAAU,4BAA4B,KACrC;EAEH,yBAAyB;;KAGf,6BAA6B,sBACvC,qBACA;cAGW,qCAAqC;MACrC,QAAI;UAIP;UACA;EAGN,YAAA,OAAO,4BACP,oBAAoB;YAOZ;EAeH,YAAY;EAIZ,SAAS;IAAY;MAAwB;EAK7C,OAAO,mBAAmB;EAM1B,aACL,QAAQ,sCACP;EAWI,WAAW;EAMX,aAAa;EAMb,UAAU;EAMV,cAAc;IACnB;IACA;;EAMK,cACL,UAAU,qCACT;EAKI,YAAY,UAAU,yBAC3B,OAAO,GACP,UAAU,4BAA4B,KAAE;EAsBnC,UAAU,uBAAuB;EAIjC;EAMA,yBAAyB"}

package/dist/runtime/api/thread-list-item-runtime.js

@@ -57,9 +57,9 @@ var ThreadListItemRuntimeImpl = class {
 		const state = this._core.getState();
 		return this._threadListBinding.initialize(state.id);
 	}
-	generateTitle() {
+	generateTitle(options) {
 		const state = this._core.getState();
-		return this._threadListBinding.generateTitle(state.id);
+		return this._threadListBinding.generateTitle(state.id, options);
 	}
 	unstable_on(event, callback) {
 		let prevIsMain = this._core.getState().isMain;

package/dist/runtime/api/thread-list-item-runtime.js.map

@@ -1 +1 @@
-{"version":3,"file":"thread-list-item-runtime.js","names":["Unsubscribe","SubscribableWithState","ThreadListItemRuntimePath","ThreadListRuntimeCoreBinding","notifyEventListeners","ThreadListItemEventPayload","switchedTo","Record","switchedAway","ThreadListItemEventType","ThreadListItemEventCallback","payload","E","ThreadListItemState","ThreadListItemStatus","ThreadListItemRuntime","path","getState","initialize","Promise","remoteId","externalId","generateTitle","switchTo","options","unarchive","rename","newTitle","updateCustom","custom","archive","delete","detach","subscribe","callback","unstable_on","event","__internal_getRuntime","ThreadListItemStateBinding","ThreadListItemRuntimeImpl","_core","_threadListBinding","constructor","__internal_bindMethods","bind","state","switchToThread","id","Error","prevIsMain","isMain","prevThreadId","currentState","newIsMain","newThreadId"],"sources":["../../../src/runtime/api/thread-list-item-runtime.ts"],"sourcesContent":["import type { Unsubscribe } from \"../../types/unsubscribe\";\nimport type { SubscribableWithState } from \"../../subscribable/subscribable\";\nimport type { ThreadListItemRuntimePath } from \"./paths\";\nimport type { ThreadListRuntimeCoreBinding } from \"./thread-list-runtime\";\nimport { notifyEventListeners } from \"../../utils/notify-event-listeners\";\n\nexport type ThreadListItemEventPayload = {\n  /**\n   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the\n   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward\n   * compatibility.\n   */\n  switchedTo: Record<string, never>;\n  /**\n   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the\n   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward\n   * compatibility.\n   */\n  switchedAway: Record<string, never>;\n};\n\nexport type ThreadListItemEventType = keyof ThreadListItemEventPayload;\n\nexport type ThreadListItemEventCallback<E extends ThreadListItemEventType> = (\n  payload: ThreadListItemEventPayload[E],\n) => void;\n\nimport type { ThreadListItemState } from \"./bindings\";\nimport type { ThreadListItemStatus } from \"../interfaces/thread-list-runtime-core\";\n\nexport type { ThreadListItemState, ThreadListItemStatus };\n\nexport type ThreadListItemRuntime = {\n  readonly path: ThreadListItemRuntimePath;\n  getState(): ThreadListItemState;\n\n  initialize(): Promise<{ remoteId: string; externalId: string | undefined }>;\n  generateTitle(): Promise<void>;\n\n  switchTo(options?: { unarchive?: boolean }): Promise<void>;\n  rename(newTitle: string): Promise<void>;\n  updateCustom(custom: Record<string, unknown> | undefined): Promise<void>;\n  archive(): Promise<void>;\n  unarchive(): Promise<void>;\n  delete(): Promise<void>;\n\n  detach(): void;\n\n  subscribe(callback: () => void): Unsubscribe;\n\n  unstable_on<E extends ThreadListItemEventType>(\n    event: E,\n    callback: ThreadListItemEventCallback<E>,\n  ): Unsubscribe;\n\n  __internal_getRuntime(): ThreadListItemRuntime;\n};\n\nexport type ThreadListItemStateBinding = SubscribableWithState<\n  ThreadListItemState,\n  ThreadListItemRuntimePath\n>;\n\nexport class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {\n  public get path() {\n    return this._core.path;\n  }\n\n  private _core: ThreadListItemStateBinding;\n  private _threadListBinding: ThreadListRuntimeCoreBinding;\n\n  constructor(\n    _core: ThreadListItemStateBinding,\n    _threadListBinding: ThreadListRuntimeCoreBinding,\n  ) {\n    this._core = _core;\n    this._threadListBinding = _threadListBinding;\n    this.__internal_bindMethods();\n  }\n\n  protected __internal_bindMethods() {\n    this.switchTo = this.switchTo.bind(this);\n    this.rename = this.rename.bind(this);\n    this.updateCustom = this.updateCustom.bind(this);\n    this.archive = this.archive.bind(this);\n    this.unarchive = this.unarchive.bind(this);\n    this.delete = this.delete.bind(this);\n    this.initialize = this.initialize.bind(this);\n    this.generateTitle = this.generateTitle.bind(this);\n    this.subscribe = this.subscribe.bind(this);\n    this.unstable_on = this.unstable_on.bind(this);\n    this.getState = this.getState.bind(this);\n    this.detach = this.detach.bind(this);\n  }\n\n  public getState(): ThreadListItemState {\n    return this._core.getState();\n  }\n\n  public switchTo(options?: { unarchive?: boolean }): Promise<void> {\n    const state = this._core.getState();\n    return this._threadListBinding.switchToThread(state.id, options);\n  }\n\n  public rename(newTitle: string): Promise<void> {\n    const state = this._core.getState();\n\n    return this._threadListBinding.rename(state.id, newTitle);\n  }\n\n  public updateCustom(\n    custom: Record<string, unknown> | undefined,\n  ): Promise<void> {\n    const state = this._core.getState();\n    if (!this._threadListBinding.updateCustom) {\n      throw new Error(\n        \"Thread list runtime does not support updating custom metadata\",\n      );\n    }\n\n    return this._threadListBinding.updateCustom(state.id, custom);\n  }\n\n  public archive(): Promise<void> {\n    const state = this._core.getState();\n\n    return this._threadListBinding.archive(state.id);\n  }\n\n  public unarchive(): Promise<void> {\n    const state = this._core.getState();\n\n    return this._threadListBinding.unarchive(state.id);\n  }\n\n  public delete(): Promise<void> {\n    const state = this._core.getState();\n\n    return this._threadListBinding.delete(state.id);\n  }\n\n  public initialize(): Promise<{\n    remoteId: string;\n    externalId: string | undefined;\n  }> {\n    const state = this._core.getState();\n    return this._threadListBinding.initialize(state.id);\n  }\n\n  public generateTitle(): Promise<void> {\n    const state = this._core.getState();\n    return this._threadListBinding.generateTitle(state.id);\n  }\n\n  public unstable_on<E extends ThreadListItemEventType>(\n    event: E,\n    callback: ThreadListItemEventCallback<E>,\n  ) {\n    let prevIsMain = this._core.getState().isMain;\n    let prevThreadId = this._core.getState().id;\n    return this.subscribe(() => {\n      const currentState = this._core.getState();\n      const newIsMain = currentState.isMain;\n      const newThreadId = currentState.id;\n      if (prevIsMain === newIsMain && prevThreadId === newThreadId) return;\n      prevIsMain = newIsMain;\n      prevThreadId = newThreadId;\n\n      if (event === \"switchedTo\" && !newIsMain) return;\n      if (event === \"switchedAway\" && newIsMain) return;\n      notifyEventListeners(\n        [callback as (payload?: unknown) => void],\n        {},\n        `Thread list item \"${event}\"`,\n      );\n    });\n  }\n\n  public subscribe(callback: () => void): Unsubscribe {\n    return this._core.subscribe(callback);\n  }\n\n  public detach(): void {\n    const state = this._core.getState();\n\n    this._threadListBinding.detach(state.id);\n  }\n\n  public __internal_getRuntime(): ThreadListItemRuntime {\n    return this;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"thread-list-item-runtime.js","names":["Unsubscribe","SubscribableWithState","ThreadListItemRuntimePath","ThreadListRuntimeCoreBinding","notifyEventListeners","ThreadListItemEventPayload","switchedTo","Record","switchedAway","ThreadListItemEventType","ThreadListItemEventCallback","payload","E","ThreadListItemState","ThreadListItemStatus","ThreadListItemGenerateTitleOptions","automatic","ThreadListItemRuntime","path","getState","initialize","Promise","remoteId","externalId","generateTitle","options","switchTo","unarchive","rename","newTitle","updateCustom","custom","archive","delete","detach","subscribe","callback","unstable_on","event","__internal_getRuntime","ThreadListItemStateBinding","ThreadListItemRuntimeImpl","_core","_threadListBinding","constructor","__internal_bindMethods","bind","state","switchToThread","id","Error","prevIsMain","isMain","prevThreadId","currentState","newIsMain","newThreadId"],"sources":["../../../src/runtime/api/thread-list-item-runtime.ts"],"sourcesContent":["import type { Unsubscribe } from \"../../types/unsubscribe\";\nimport type { SubscribableWithState } from \"../../subscribable/subscribable\";\nimport type { ThreadListItemRuntimePath } from \"./paths\";\nimport type { ThreadListRuntimeCoreBinding } from \"./thread-list-runtime\";\nimport { notifyEventListeners } from \"../../utils/notify-event-listeners\";\n\nexport type ThreadListItemEventPayload = {\n  /**\n   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the\n   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward\n   * compatibility.\n   */\n  switchedTo: Record<string, never>;\n  /**\n   * @deprecated State-derivable. Compare `s.threads.mainThreadId` against the\n   * item's `s.threadListItem.id` via `useAuiState` instead. Kept for backward\n   * compatibility.\n   */\n  switchedAway: Record<string, never>;\n};\n\nexport type ThreadListItemEventType = keyof ThreadListItemEventPayload;\n\nexport type ThreadListItemEventCallback<E extends ThreadListItemEventType> = (\n  payload: ThreadListItemEventPayload[E],\n) => void;\n\nimport type { ThreadListItemState } from \"./bindings\";\nimport type { ThreadListItemStatus } from \"../interfaces/thread-list-runtime-core\";\n\nexport type { ThreadListItemState, ThreadListItemStatus };\n\nexport type ThreadListItemGenerateTitleOptions = {\n  /** Marks a generation started by the automatic title trigger. */\n  automatic?: boolean;\n};\n\nexport type ThreadListItemRuntime = {\n  readonly path: ThreadListItemRuntimePath;\n  getState(): ThreadListItemState;\n\n  initialize(): Promise<{ remoteId: string; externalId: string | undefined }>;\n  generateTitle(options?: ThreadListItemGenerateTitleOptions): Promise<void>;\n\n  switchTo(options?: { unarchive?: boolean }): Promise<void>;\n  rename(newTitle: string): Promise<void>;\n  updateCustom(custom: Record<string, unknown> | undefined): Promise<void>;\n  archive(): Promise<void>;\n  unarchive(): Promise<void>;\n  delete(): Promise<void>;\n\n  detach(): void;\n\n  subscribe(callback: () => void): Unsubscribe;\n\n  unstable_on<E extends ThreadListItemEventType>(\n    event: E,\n    callback: ThreadListItemEventCallback<E>,\n  ): Unsubscribe;\n\n  __internal_getRuntime(): ThreadListItemRuntime;\n};\n\nexport type ThreadListItemStateBinding = SubscribableWithState<\n  ThreadListItemState,\n  ThreadListItemRuntimePath\n>;\n\nexport class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {\n  public get path() {\n    return this._core.path;\n  }\n\n  private _core: ThreadListItemStateBinding;\n  private _threadListBinding: ThreadListRuntimeCoreBinding;\n\n  constructor(\n    _core: ThreadListItemStateBinding,\n    _threadListBinding: ThreadListRuntimeCoreBinding,\n  ) {\n    this._core = _core;\n    this._threadListBinding = _threadListBinding;\n    this.__internal_bindMethods();\n  }\n\n  protected __internal_bindMethods() {\n    this.switchTo = this.switchTo.bind(this);\n    this.rename = this.rename.bind(this);\n    this.updateCustom = this.updateCustom.bind(this);\n    this.archive = this.archive.bind(this);\n    this.unarchive = this.unarchive.bind(this);\n    this.delete = this.delete.bind(this);\n    this.initialize = this.initialize.bind(this);\n    this.generateTitle = this.generateTitle.bind(this);\n    this.subscribe = this.subscribe.bind(this);\n    this.unstable_on = this.unstable_on.bind(this);\n    this.getState = this.getState.bind(this);\n    this.detach = this.detach.bind(this);\n  }\n\n  public getState(): ThreadListItemState {\n    return this._core.getState();\n  }\n\n  public switchTo(options?: { unarchive?: boolean }): Promise<void> {\n    const state = this._core.getState();\n    return this._threadListBinding.switchToThread(state.id, options);\n  }\n\n  public rename(newTitle: string): Promise<void> {\n    const state = this._core.getState();\n\n    return this._threadListBinding.rename(state.id, newTitle);\n  }\n\n  public updateCustom(\n    custom: Record<string, unknown> | undefined,\n  ): Promise<void> {\n    const state = this._core.getState();\n    if (!this._threadListBinding.updateCustom) {\n      throw new Error(\n        \"Thread list runtime does not support updating custom metadata\",\n      );\n    }\n\n    return this._threadListBinding.updateCustom(state.id, custom);\n  }\n\n  public archive(): Promise<void> {\n    const state = this._core.getState();\n\n    return this._threadListBinding.archive(state.id);\n  }\n\n  public unarchive(): Promise<void> {\n    const state = this._core.getState();\n\n    return this._threadListBinding.unarchive(state.id);\n  }\n\n  public delete(): Promise<void> {\n    const state = this._core.getState();\n\n    return this._threadListBinding.delete(state.id);\n  }\n\n  public initialize(): Promise<{\n    remoteId: string;\n    externalId: string | undefined;\n  }> {\n    const state = this._core.getState();\n    return this._threadListBinding.initialize(state.id);\n  }\n\n  public generateTitle(\n    options?: ThreadListItemGenerateTitleOptions,\n  ): Promise<void> {\n    const state = this._core.getState();\n    return this._threadListBinding.generateTitle(state.id, options);\n  }\n\n  public unstable_on<E extends ThreadListItemEventType>(\n    event: E,\n    callback: ThreadListItemEventCallback<E>,\n  ) {\n    let prevIsMain = this._core.getState().isMain;\n    let prevThreadId = this._core.getState().id;\n    return this.subscribe(() => {\n      const currentState = this._core.getState();\n      const newIsMain = currentState.isMain;\n      const newThreadId = currentState.id;\n      if (prevIsMain === newIsMain && prevThreadId === newThreadId) return;\n      prevIsMain = newIsMain;\n      prevThreadId = newThreadId;\n\n      if (event === \"switchedTo\" && !newIsMain) return;\n      if (event === \"switchedAway\" && newIsMain) return;\n      notifyEventListeners(\n        [callback as (payload?: unknown) => void],\n        {},\n        `Thread list item \"${event}\"`,\n      );\n    });\n  }\n\n  public subscribe(callback: () => void): Unsubscribe {\n    return this._core.subscribe(callback);\n  }\n\n  public detach(): void {\n    const state = this._core.getState();\n\n    this._threadListBinding.detach(state.id);\n  }\n\n  public __internal_getRuntime(): ThreadListItemRuntime {\n    return this;\n  }\n}\n"],"mappings":"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"}

package/dist/runtime/api/thread-list-runtime.d.ts

@@ -10,6 +10,8 @@ type ThreadListState = {
   readonly threadIds: readonly string[];
   readonly archivedThreadIds: readonly string[];
   readonly isLoading: boolean;
+  /** The error thrown by the most recent thread list load that failed, cleared when a later load starts. */
+  readonly loadError: unknown;
   readonly isLoadingMore: boolean;
   readonly hasMore: boolean;
   readonly threadItems: Readonly<Record<string, Omit<ThreadListItemState, "isMain" | "threadId" | "isRunning">>>;
@@ -72,6 +74,7 @@ declare class ThreadListRuntimeImpl implements ThreadListRuntime {
   private _mainThreadListItemRuntime;
   readonly main: ThreadRuntime;
   get mainItem(): ThreadListItemRuntimeImpl;
+  private _createItemStateBinding;
   getById(threadId: string): ThreadRuntime;
   getItemByIndex(idx: number): ThreadListItemRuntimeImpl;
   getArchivedItemByIndex(idx: number): ThreadListItemRuntimeImpl;

package/dist/runtime/api/thread-list-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thread-list-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/thread-list-runtime.ts"],"mappings":";;;;;;KA4BY;WACD;WACA;WACA;WACA;WACA;WACA;WACA;WACA,aAAa,SACpB,eAEE,KAAK;;KAKC;EACV,YAAY;EAEZ,UAAU,uBAAuB;WAExB,MAAM;EACf,QAAQ,mBAAmB;WAElB,UAAU;EACnB,YAAY,mBAAmB;EAC/B,eAAe,cAAc;EAC7B,uBAAuB,cAAc;EAErC,eACE,kBACA;IAAY;MACX;EACH,qBAAqB;;;;;;;EAQrB,+BACE,WAAW,OAAO,kCACjB;EAEH,yBAAyB;EACzB,UAAU;;;;;;;;;;;;EAYV,oBAAoB;EACpB,YAAY;;KAuCF,+BAA+B;cAE9B,iCAAiC;UACpC;UACA;UACA;UACA;EAMN,YAAA,OAAO,8BACP,uBACE,SAAS,0BACT,uBAAuB,iCACpB;YA0CG;EAiBH,eACL,kBACA;IAAY;MACX;EAII,qBAAqB;EAIrB,+BACL,WAAW,OAAO,kCACjB;EAMI,yBAAyB;EAIzB,UAAU;EAIV,oBAAoB;EAIpB,YAAY;EAIZ,YAAY;EAIZ,UAAU,uBAAuB;UAIhC;WAEQ,MAAM;MAEX,YAAQ;EAIZ,QAAQ,mBAAgB;EAcxB,eAAe,cAAW;EAgB1B,uBAAuB,cAAW;EAmBlC,YAAY,mBAAgB"}
+{"version":3,"file":"thread-list-runtime.d.ts","names":[],"sources":["../../../src/runtime/api/thread-list-runtime.ts"],"mappings":";;;;;;KA6BY;WACD;WACA;WACA;WACA;WACA;;WAEA;WACA;WACA;WACA,aAAa,SACpB,eAEE,KAAK;;KAKC;EACV,YAAY;EAEZ,UAAU,uBAAuB;WAExB,MAAM;EACf,QAAQ,mBAAmB;WAElB,UAAU;EACnB,YAAY,mBAAmB;EAC/B,eAAe,cAAc;EAC7B,uBAAuB,cAAc;EAErC,eACE,kBACA;IAAY;MACX;EACH,qBAAqB;;;;;;;EAQrB,+BACE,WAAW,OAAO,kCACjB;EAEH,yBAAyB;EACzB,UAAU;;;;;;;;;;;;EAYV,oBAAoB;EACpB,YAAY;;KAwCF,+BAA+B;cAE9B,iCAAiC;UACpC;UACA;UACA;UACA;EAMN,YAAA,OAAO,8BACP,uBACE,SAAS,0BACT,uBAAuB,iCACpB;YA0CG;EAiBH,eACL,kBACA;IAAY;MACX;EAII,qBAAqB;EAIrB,+BACL,WAAW,OAAO,kCACjB;EAMI,yBAAyB;EAIzB,UAAU;EAIV,oBAAoB;EAIpB,YAAY;EAIZ,YAAY;EAIZ,UAAU,uBAAuB;UAIhC;WAEQ,MAAM;MAEX,YAAQ;UAIX;EAeD,QAAQ,mBAAgB;EAcxB,eAAe,cAAW;EAgB1B,uBAAuB,cAAW;EAmBlC,YAAY,mBAAgB"}

package/dist/runtime/api/thread-list-runtime.js

@@ -11,6 +11,7 @@ const getThreadListState = (threadList) => {
 		threadIds: threadList.threadIds,
 		archivedThreadIds: threadList.archivedThreadIds,
 		isLoading: threadList.isLoading,
+		loadError: threadList.loadError,
 		isLoadingMore: threadList.isLoadingMore ?? false,
 		hasMore: threadList.hasMore ?? false,
 		threadItems: threadList.threadItems
@@ -114,6 +115,21 @@ var ThreadListRuntimeImpl = class {
 	get mainItem() {
 		return this._mainThreadListItemRuntime;
 	}
+	_createItemStateBinding(threadId) {
+		return new ShallowMemoizeSubject({
+			path: {
+				ref: `threadItems[threadId=${threadId}]`,
+				threadSelector: {
+					type: "threadId",
+					threadId
+				}
+			},
+			getState: () => {
+				return getThreadListItemState(this._core, threadId);
+			},
+			subscribe: (callback) => this._core.subscribe(callback)
+		});
+	}
 	getById(threadId) {
 		return new this._runtimeFactory(new NestedSubscriptionSubject({
 			path: {
@@ -125,7 +141,7 @@ var ThreadListRuntimeImpl = class {
 			},
 			getState: () => this._core.getThreadRuntimeCore(threadId),
 			subscribe: (callback) => this._core.subscribe(callback)
-		}), this.mainItem);
+		}), this._createItemStateBinding(threadId));
 	}
 	getItemByIndex(idx) {
 		return new ThreadListItemRuntimeImpl(new ShallowMemoizeSubject({
@@ -158,19 +174,7 @@ var ThreadListRuntimeImpl = class {
 		}), this._core);
 	}
 	getItemById(threadId) {
-		return new ThreadListItemRuntimeImpl(new ShallowMemoizeSubject({
-			path: {
-				ref: `threadItems[threadId=${threadId}]`,
-				threadSelector: {
-					type: "threadId",
-					threadId
-				}
-			},
-			getState: () => {
-				return getThreadListItemState(this._core, threadId);
-			},
-			subscribe: (callback) => this._core.subscribe(callback)
-		}), this._core);
+		return new ThreadListItemRuntimeImpl(this._createItemStateBinding(threadId), this._core);
 	}
 };
 //#endregion