@assistant-ui/core 0.3.13 → 0.3.15

package/src/model-context/registry.ts

@@ -7,6 +7,7 @@ import {
   type AssistantInstructionsConfig,
 } from "./types";
 import type { Unsubscribe } from "../types/unsubscribe";
+import { notifySubscribers as notifyStateSubscribers } from "../subscribable/subscribable";
 import type {
   ModelContextRegistryToolHandle,
   ModelContextRegistryInstructionHandle,
@@ -75,9 +76,7 @@ export class ModelContextRegistry implements ModelContextProvider {
   }
 
   private notifySubscribers(): void {
-    for (const callback of this._subscribers) {
-      callback();
-    }
+    notifyStateSubscribers(this._subscribers);
   }
 
   addTool<TArgs extends Record<string, unknown>, TResult>(
@@ -144,9 +143,20 @@ export class ModelContextRegistry implements ModelContextProvider {
 
     this._providers.set(id, provider);
 
-    const unsubscribe = provider.subscribe?.(() => {
-      this.notifySubscribers();
-    });
+    let unsubscribe: Unsubscribe | undefined;
+    try {
+      unsubscribe = provider.subscribe?.(() => {
+        this.notifySubscribers();
+      });
+    } catch (error) {
+      this._providers.delete(id);
+      try {
+        this.notifySubscribers();
+      } catch (notifyError) {
+        console.error(notifyError);
+      }
+      throw error;
+    }
     this._providerUnsubscribes.set(id, unsubscribe);
 
     this.notifySubscribers();

package/src/react/RuntimeAdapter.test.ts

@@ -54,6 +54,7 @@ describe("RuntimeAdapter via the neutral store entry", () => {
     const handle = createAssistantClient(
       AuiConfig({ threads: RuntimeAdapter(runtime) }),
     );
+    handle.subscribe(() => {});
     const aui = handle.getClient();
 
     flushTapSync(() => aui.composer.setText("hello"));
@@ -75,6 +76,7 @@ describe("RuntimeAdapter via the neutral store entry", () => {
     const handle = createAssistantClient(
       AuiConfig({ threads: RuntimeAdapter(runtime) }),
     );
+    handle.subscribe(() => {});
 
     // Dev mode double-mounts the root (StrictMode emulation), so assert
     // presence rather than an exact count

package/src/react/RuntimeAdapter.ts

@@ -1,5 +1,5 @@
-import { useEffect } from "react";
 import { useResource, resource } from "@assistant-ui/tap";
+import type { AssistantClient, ScopesConfig } from "@assistant-ui/store";
 import type { AssistantRuntime } from "..";
 import {
   baseRuntimeAdapterTransformScopes,
@@ -8,6 +8,7 @@ import {
 import {
   attachTransformScopes,
   useAssistantClientRef,
+  useAssistantScopeEffect,
 } from "@assistant-ui/store/client";
 import { DataRenderers } from "./client/DataRenderers";
 import { Tools } from "./client/Tools";
@@ -15,11 +16,12 @@ import { Tools } from "./client/Tools";
 const useRuntimeAdapter = (runtime: AssistantRuntime) => {
   const clientRef = useAssistantClientRef();
 
-  useEffect(() => {
-    return runtime.registerModelContextProvider(
-      clientRef.current!.modelContext(),
-    );
-  }, [runtime, clientRef]);
+  useAssistantScopeEffect(
+    "modelContext",
+    () =>
+      runtime.registerModelContextProvider(clientRef.current!.modelContext()),
+    [runtime],
+  );
 
   return useResource(
     ThreadListClient({
@@ -31,7 +33,15 @@ const useRuntimeAdapter = (runtime: AssistantRuntime) => {
 
 export const RuntimeAdapter = resource(useRuntimeAdapter);
 
-attachTransformScopes(useRuntimeAdapter, (scopes, parent) => {
+/**
+ * The scope defaults `RuntimeAdapter` installs when it is used as the `threads`
+ * config entry. Adapter packages that wrap a runtime in their own config entry
+ * attach this to the wrapping resource for scope parity with `RuntimeAdapter`.
+ */
+export const runtimeAdapterTransformScopes = (
+  scopes: ScopesConfig,
+  parent: AssistantClient,
+): void => {
   baseRuntimeAdapterTransformScopes(scopes, parent);
 
   if (!scopes.tools && parent.tools.source === null) {
@@ -41,4 +51,6 @@ attachTransformScopes(useRuntimeAdapter, (scopes, parent) => {
   if (!scopes.dataRenderers && parent.dataRenderers.source === null) {
     scopes.dataRenderers = DataRenderers();
   }
-});
+};
+
+attachTransformScopes(useRuntimeAdapter, runtimeAdapterTransformScopes);

package/src/react/adapters/LocalStorageThreadListAdapter.tsx

@@ -21,7 +21,10 @@ import type {
   ExportedMessageRepository,
   ExportedMessageRepositoryItem,
 } from "../../internal";
-import { RuntimeAdapterProvider } from "../runtimes/RuntimeAdapterProvider";
+import {
+  RuntimeAdapterProvider,
+  type RuntimeAdapters,
+} from "../runtimes/RuntimeAdapterProvider";
 import type { TitleGenerationAdapter } from "./TitleGenerationAdapter";
 
 export type AsyncStorageLike = {
@@ -338,29 +341,40 @@ class AsyncStorageHistoryAdapter implements ThreadHistoryAdapter {
   }
 }
 
+const useLocalStorageThreadAdapters = (
+  storage: AsyncStorageLike,
+  prefix: string,
+  mutationQueue: KeyedMutationQueue,
+): RuntimeAdapters => {
+  const aui = useAui();
+  // Not useEffectEvent: history adapter methods run during render (SSR load).
+  const auiRef = useRef(aui);
+  useEffect(() => {
+    auiRef.current = aui;
+  });
+  const [history] = useState(
+    () =>
+      new AsyncStorageHistoryAdapter(
+        storage,
+        () => auiRef.current,
+        prefix,
+        mutationQueue,
+      ),
+  );
+  return useMemo(() => ({ history }), [history]);
+};
+
 const createHistoryProvider = (
   storage: AsyncStorageLike,
   prefix: string,
   mutationQueue: KeyedMutationQueue,
 ): FC<PropsWithChildren> => {
   const Provider: FC<PropsWithChildren> = ({ children }) => {
-    const aui = useAui();
-    // Not useEffectEvent: history adapter methods run during render (SSR load).
-    const auiRef = useRef(aui);
-    useEffect(() => {
-      auiRef.current = aui;
-    });
-    const [history] = useState(
-      () =>
-        new AsyncStorageHistoryAdapter(
-          storage,
-          () => auiRef.current,
-          prefix,
-          mutationQueue,
-        ),
+    const adapters = useLocalStorageThreadAdapters(
+      storage,
+      prefix,
+      mutationQueue,
     );
-    const adapters = useMemo(() => ({ history }), [history]);
-
     return (
       <RuntimeAdapterProvider adapters={adapters}>
         {children}
@@ -406,6 +420,9 @@ export const createLocalStorageAdapter = (
 
   const adapter: RemoteThreadListAdapter = {
     unstable_Provider: createHistoryProvider(storage, prefix, mutationQueue),
+    unstable_useAdapters: function useLocalStorageAdapters() {
+      return useLocalStorageThreadAdapters(storage, prefix, mutationQueue);
+    },
 
     async list(): Promise<RemoteThreadListResponse> {
       const threads = await loadThreadMetadata();

package/src/react/client/AdaptedRemoteThread.ts

@@ -0,0 +1,41 @@
+import { useEffect, useMemo } from "react";
+import { resource, type ResourceElement } from "@assistant-ui/tap";
+import { useClientResource } from "@assistant-ui/store/client";
+import type { ClientOutput } from "@assistant-ui/store";
+import type { RuntimeAdapters } from "../../runtimes/remote-thread-list/types";
+import { isDevelopment } from "../../store/internal";
+import {
+  useRuntimeAdapters,
+  useRuntimeAdaptersProvider,
+  useStableRuntimeAdapters,
+} from "../runtimes/useRuntimeAdapters";
+
+const useAdaptedRemoteThread = ({
+  useAdapters,
+  thread,
+}: {
+  useAdapters: () => RuntimeAdapters | null | undefined;
+  thread: ResourceElement<ClientOutput<"thread">>;
+}): ClientOutput<"thread"> => {
+  const parent = useRuntimeAdapters();
+  const stableAdapters = useStableRuntimeAdapters(useAdapters());
+
+  const unkeyedHistory =
+    stableAdapters?.history != null && thread.key === undefined;
+  useEffect(() => {
+    if (!isDevelopment || !unkeyedHistory) return;
+    console.warn(
+      "[assistant-ui] RemoteThreadList received a history adapter, but the thread factory is unkeyed. Key the thread resource by thread id (withKey) so switching threads reloads history.",
+    );
+  }, [unkeyedHistory]);
+
+  const merged = useMemo(
+    () => (stableAdapters == null ? parent : { ...parent, ...stableAdapters }),
+    [parent, stableAdapters],
+  );
+  return useRuntimeAdaptersProvider(merged, function useBoundRemoteThread() {
+    return useClientResource(thread).methods;
+  });
+};
+
+export const AdaptedRemoteThread = resource(useAdaptedRemoteThread);

package/src/react/client/InMemoryThreadList.test.tsx

@@ -0,0 +1,148 @@
+// @vitest-environment jsdom
+
+import { act, render } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { resource } from "@assistant-ui/tap";
+import { AuiProvider, useAui, useAuiEvent } from "@assistant-ui/store";
+import { InMemoryThreadList } from "./InMemoryThreadList";
+
+const stubComposer = { getState: () => ({}) };
+const stubSuggestions = { getState: () => ({ suggestions: [] }) };
+const useStubThread = (_props: { threadId: string }) => ({
+  getState: () => ({ isRunning: false }),
+  composer: () => stubComposer,
+  suggestions: () => stubSuggestions,
+});
+const StubThread = resource(useStubThread);
+
+const setup = () => {
+  const selectionChanged = vi.fn();
+  let aui!: ReturnType<typeof useAui>;
+  const Consumer = () => {
+    useAuiEvent("threads.selectionChanged" as never, selectionChanged as never);
+    return null;
+  };
+  const Harness = () => {
+    aui = useAui({
+      threads: InMemoryThreadList({
+        thread: (threadId) => StubThread({ threadId }) as never,
+      }),
+    } as never);
+    return (
+      <AuiProvider value={aui}>
+        <Consumer />
+      </AuiProvider>
+    );
+  };
+  render(<Harness />);
+  return { getAui: () => aui, selectionChanged };
+};
+
+describe("InMemoryThreadList selection events", () => {
+  it("does not emit for the initially selected thread on mount", async () => {
+    const { selectionChanged } = setup();
+    await act(async () => {});
+    expect(selectionChanged).not.toHaveBeenCalled();
+  });
+
+  it("emits on switchToNewThread and on switching back", async () => {
+    const { getAui, selectionChanged } = setup();
+    await act(async () => {});
+
+    await act(async () => {
+      getAui().threads.switchToNewThread();
+    });
+    await act(async () => {});
+
+    const newThreadId = getAui().threads.getState().mainThreadId;
+    expect(newThreadId).not.toBe("main");
+    expect(selectionChanged).toHaveBeenCalledExactlyOnceWith({
+      threadId: newThreadId,
+      previousThreadId: "main",
+    });
+
+    await act(async () => {
+      getAui().threads.switchToThread("main");
+    });
+    await act(async () => {});
+
+    expect(selectionChanged).toHaveBeenCalledTimes(2);
+    expect(selectionChanged).toHaveBeenLastCalledWith({
+      threadId: "main",
+      previousThreadId: newThreadId,
+    });
+  });
+
+  it("emits when deleting the selected thread falls back to another", async () => {
+    const { getAui, selectionChanged } = setup();
+    await act(async () => {});
+
+    await act(async () => {
+      getAui().threads.switchToNewThread();
+    });
+    await act(async () => {});
+
+    const newThreadId = getAui().threads.getState().mainThreadId;
+    selectionChanged.mockClear();
+
+    await act(async () => {
+      getAui().threads.item({ id: newThreadId }).delete();
+    });
+    await act(async () => {});
+
+    expect(getAui().threads.getState().mainThreadId).toBe("main");
+    expect(selectionChanged).toHaveBeenCalledExactlyOnceWith({
+      threadId: "main",
+      previousThreadId: newThreadId,
+    });
+  });
+});
+
+describe("InMemoryThreadList delete", () => {
+  it("notifies onDelete with the removed thread id", async () => {
+    const onDelete = vi.fn();
+    let aui!: ReturnType<typeof useAui>;
+    const Harness = () => {
+      aui = useAui({
+        threads: InMemoryThreadList({
+          thread: (threadId) => StubThread({ threadId }) as never,
+          onDelete,
+        }),
+      } as never);
+      return <AuiProvider value={aui}>{null}</AuiProvider>;
+    };
+    render(<Harness />);
+    await act(async () => {});
+
+    await act(async () => {
+      aui.threads.switchToNewThread();
+    });
+    const doomed = aui.threads.getState().mainThreadId;
+    await act(async () => {
+      aui.threads.item({ id: doomed }).delete();
+    });
+    expect(onDelete).toHaveBeenCalledExactlyOnceWith(doomed);
+  });
+
+  it("starts a fresh thread when the last one is deleted", async () => {
+    let aui!: ReturnType<typeof useAui>;
+    const Harness = () => {
+      aui = useAui({
+        threads: InMemoryThreadList({
+          thread: (threadId) => StubThread({ threadId }) as never,
+        }),
+      } as never);
+      return <AuiProvider value={aui}>{null}</AuiProvider>;
+    };
+    render(<Harness />);
+    await act(async () => {});
+
+    await act(async () => {
+      aui.threads.item({ id: "main" }).delete();
+    });
+    const state = aui.threads.getState();
+    expect(state.threadIds).toHaveLength(1);
+    expect(state.mainThreadId).toBe(state.threadIds[0]);
+    expect(state.mainThreadId).not.toBe("main");
+  });
+});

package/src/react/client/InMemoryThreadList.ts

@@ -0,0 +1,290 @@
+import { useState, useMemo } from "react";
+import { resource, withKey, type ResourceElement } from "@assistant-ui/tap";
+import type {
+  AssistantClient,
+  ClientOutput,
+  ScopesConfig,
+} from "@assistant-ui/store";
+import {
+  useClientLookup,
+  Derived,
+  attachTransformScopes,
+  useClientResource,
+} from "@assistant-ui/store/client";
+import { useThreadSelectionEvents } from "../../store/internal";
+import { generateId } from "../../utils/id";
+import { ModelContext } from "../../store/clients/model-context-client";
+import { Tools } from "./Tools";
+import { DataRenderers } from "./DataRenderers";
+
+const RESOLVED_PROMISE = Promise.resolve();
+
+export type InMemoryThreadListProps = {
+  thread: (threadId: string) => ResourceElement<ClientOutput<"thread">>;
+  onSwitchToThread?: (threadId: string) => void;
+  onSwitchToNewThread?: () => void;
+  onDelete?: (threadId: string) => void;
+};
+
+type ThreadData = {
+  id: string;
+  title?: string;
+  status: "regular" | "archived";
+  custom?: Record<string, unknown> | undefined;
+};
+
+// ThreadListItem Client
+const useThreadListItemClient = (props: {
+  data: ThreadData;
+  isRunning: boolean;
+  onSwitchTo: () => void;
+  onRename: (title: string) => void;
+  onUpdateCustom: (custom: Record<string, unknown> | undefined) => void;
+  onArchive: () => void;
+  onUnarchive: () => void;
+  onDelete: () => void;
+}): ClientOutput<"threadListItem"> => {
+  const {
+    data,
+    isRunning,
+    onSwitchTo,
+    onRename,
+    onUpdateCustom,
+    onArchive,
+    onUnarchive,
+    onDelete,
+  } = props;
+  const state = useMemo(
+    () => ({
+      id: data.id,
+      remoteId: undefined,
+      externalId: undefined,
+      title: data.title,
+      status: data.status,
+      custom: data.custom,
+      isRunning,
+    }),
+    [data.id, data.title, data.status, data.custom, isRunning],
+  );
+
+  return {
+    getState: () => state,
+    switchTo: onSwitchTo,
+    rename: onRename,
+    updateCustom: onUpdateCustom,
+    archive: onArchive,
+    unarchive: onUnarchive,
+    delete: onDelete,
+    generateTitle: () => {},
+    initialize: async () => ({ remoteId: data.id, externalId: undefined }),
+    detach: () => {},
+  };
+};
+
+const ThreadListItemClient = resource(useThreadListItemClient);
+
+// InMemoryThreadList Client
+const useInMemoryThreadList = (
+  props: InMemoryThreadListProps,
+): ClientOutput<"threads"> => {
+  const {
+    thread: threadFactory,
+    onSwitchToThread,
+    onSwitchToNewThread,
+    onDelete,
+  } = props;
+
+  const [{ threads, mainThreadId }, setListState] = useState<{
+    threads: readonly ThreadData[];
+    mainThreadId: string;
+  }>(() => ({
+    threads: [{ id: "main", title: "Main Thread", status: "regular" }],
+    mainThreadId: "main",
+  }));
+  const setThreads = (
+    update: (prev: readonly ThreadData[]) => readonly ThreadData[],
+  ) => setListState((prev) => ({ ...prev, threads: update(prev.threads) }));
+
+  useThreadSelectionEvents(mainThreadId);
+
+  const handleSwitchToThread = (threadId: string) => {
+    setListState((prev) => ({ ...prev, mainThreadId: threadId }));
+    onSwitchToThread?.(threadId);
+  };
+
+  const handleRename = (threadId: string, title: string) => {
+    setThreads((prev) =>
+      prev.map((t) => (t.id === threadId ? { ...t, title } : t)),
+    );
+  };
+
+  const handleArchive = (threadId: string) => {
+    setThreads((prev) =>
+      prev.map((t) =>
+        t.id === threadId ? { ...t, status: "archived" as const } : t,
+      ),
+    );
+  };
+
+  const handleUnarchive = (threadId: string) => {
+    setThreads((prev) =>
+      prev.map((t) =>
+        t.id === threadId ? { ...t, status: "regular" as const } : t,
+      ),
+    );
+  };
+
+  const handleUpdateCustom = (
+    threadId: string,
+    custom: Record<string, unknown> | undefined,
+  ) => {
+    setThreads((prev) =>
+      prev.map((t) => (t.id === threadId ? { ...t, custom } : t)),
+    );
+  };
+
+  const handleDelete = (threadId: string) => {
+    // Deleting the last thread starts a fresh one; the removed id must not
+    // stay selected. The fallback id is minted eagerly so the updater stays
+    // pure under batched deletes.
+    const fallbackId = `thread-${generateId()}`;
+    setListState((prev) => {
+      const remaining = prev.threads.filter((t) => t.id !== threadId);
+      if (remaining.length === 0) {
+        return {
+          threads: [{ id: fallbackId, title: "New Thread", status: "regular" }],
+          mainThreadId: fallbackId,
+        };
+      }
+      return {
+        threads: remaining,
+        mainThreadId:
+          prev.mainThreadId === threadId
+            ? (remaining.find((t) => t.status === "regular") ?? remaining[0]!)
+                .id
+            : prev.mainThreadId,
+      };
+    });
+    onDelete?.(threadId);
+  };
+
+  const handleSwitchToNewThread = () => {
+    const newId = `thread-${generateId()}`;
+    setListState((prev) => ({
+      threads: [
+        ...prev.threads,
+        { id: newId, title: "New Thread", status: "regular" },
+      ],
+      mainThreadId: newId,
+    }));
+    onSwitchToNewThread?.();
+  };
+
+  // Only the main thread is mounted, so it is the only thread that can run.
+  const mainThreadClient = useClientResource(threadFactory(mainThreadId));
+
+  const threadListItems = useClientLookup(
+    threads.map((t) =>
+      withKey(
+        t.id,
+        ThreadListItemClient({
+          data: t,
+          isRunning: t.id === mainThreadId && mainThreadClient.state.isRunning,
+          onSwitchTo: () => handleSwitchToThread(t.id),
+          onRename: (title) => handleRename(t.id, title),
+          onUpdateCustom: (custom) => handleUpdateCustom(t.id, custom),
+          onArchive: () => handleArchive(t.id),
+          onUnarchive: () => handleUnarchive(t.id),
+          onDelete: () => handleDelete(t.id),
+        }),
+      ),
+    ),
+  );
+
+  const state = useMemo(() => {
+    const regularThreads = threads.filter((t) => t.status === "regular");
+    const archivedThreads = threads.filter((t) => t.status === "archived");
+
+    return {
+      mainThreadId,
+      newThreadId: null,
+      isLoading: false,
+      isLoadingMore: false,
+      hasMore: false,
+      threadIds: regularThreads.map((t) => t.id),
+      archivedThreadIds: archivedThreads.map((t) => t.id),
+      threadItems: threadListItems.state,
+      main: mainThreadClient.state,
+    };
+  }, [mainThreadId, threads, threadListItems.state, mainThreadClient.state]);
+
+  return {
+    getState: () => state,
+    switchToThread: handleSwitchToThread,
+    switchToNewThread: handleSwitchToNewThread,
+    getLoadThreadsPromise: () => RESOLVED_PROMISE,
+    reload: () => RESOLVED_PROMISE,
+    reloadMainThread: () =>
+      mainThreadClient.methods.unstable_refetchThread?.() ?? RESOLVED_PROMISE,
+    loadMore: () => RESOLVED_PROMISE,
+    item: (selector) => {
+      if (selector === "main") {
+        const index = threads.findIndex((t) => t.id === mainThreadId);
+        return threadListItems.get({ index: index === -1 ? 0 : index });
+      }
+      if ("id" in selector) {
+        const index = threads.findIndex((t) => t.id === selector.id);
+        return threadListItems.get({ index });
+      }
+      return threadListItems.get(selector);
+    },
+    thread: () => mainThreadClient.methods,
+  };
+};
+
+export const InMemoryThreadList = resource(useInMemoryThreadList);
+
+/**
+ * The scope defaults `InMemoryThreadList` installs when it is used as the
+ * `threads` config entry. Adapter packages that wrap it in their own config
+ * entry attach this to the wrapping resource for scope parity.
+ */
+export const inMemoryThreadListTransformScopes = (
+  scopes: ScopesConfig,
+  parent: AssistantClient,
+): void => {
+  scopes.thread ??= Derived({
+    source: "threads",
+    query: { type: "main" },
+    get: (aui) => aui.threads.thread("main"),
+  });
+  scopes.threadListItem ??= Derived({
+    source: "threads",
+    query: { type: "main" },
+    get: (aui) => aui.threads.item("main"),
+  });
+  scopes.composer ??= Derived({
+    source: "thread",
+    query: {},
+    get: (aui) => aui.threads.thread("main").composer(),
+  });
+
+  if (!scopes.modelContext && parent.modelContext.source === null) {
+    scopes.modelContext = ModelContext();
+  }
+  if (!scopes.tools && parent.tools.source === null) {
+    scopes.tools = Tools({});
+  }
+  if (!scopes.dataRenderers && parent.dataRenderers.source === null) {
+    scopes.dataRenderers = DataRenderers();
+  }
+  if (!scopes.suggestions && parent.suggestions.source === null) {
+    scopes.suggestions = Derived({
+      source: "thread",
+      query: {},
+      get: (aui) => aui.thread.suggestions(),
+    });
+  }
+};
+
+attachTransformScopes(useInMemoryThreadList, inMemoryThreadListTransformScopes);