@assistant-ui/core 0.3.14 → 0.3.15

package/src/react/client/RemoteThreadList.test.ts

@@ -542,6 +542,202 @@ describe("RemoteThreadList", () => {
     handle.destroy();
   });
 
+  it("resets selection when reload follows a different adapter instance", async () => {
+    const methodsA = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "regular" as const, remoteId: "thread-a", title: "A" },
+        ],
+      })),
+    });
+    const methodsB = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "regular" as const, remoteId: "thread-b", title: "B" },
+        ],
+      })),
+    });
+    let adapter: RemoteThreadListAdapter = { ...methodsA };
+    const listeners = new Set<() => void>();
+    const source: AssistantConfigSource = {
+      getConfig: () =>
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => StubThread({ threadId: id }) as never,
+          }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      },
+    };
+    const handle = createAssistantClient(source);
+    handle.subscribe(() => {});
+    await handle.getClient().threads.getLoadThreadsPromise();
+    flushTapSync(() => handle.getClient().threads.switchToThread("thread-a"));
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.item("main").getState().remoteId).toBe(
+        "thread-a",
+      );
+    });
+
+    adapter = { ...methodsB };
+    for (const listener of listeners) listener();
+    await vi.waitFor(async () => {
+      flushTapSync(() => {});
+      await handle.getClient().threads.reload();
+      expect(handle.getClient().threads.getState().threadIds).toEqual([
+        "thread-b",
+      ]);
+    });
+    expect(
+      handle.getClient().threads.item("main").getState().remoteId,
+    ).not.toBe("thread-a");
+    expect(handle.getClient().threads.item("main").getState().status).toBe(
+      "new",
+    );
+    expect(methodsB.list).toHaveBeenCalled();
+    handle.destroy();
+  });
+
+  it("does not reset again when retrying a failed replacement load", async () => {
+    const methodsA = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "regular" as const, remoteId: "thread-a", title: "A" },
+        ],
+      })),
+    });
+    const methodsB = makeAdapter({
+      list: vi
+        .fn()
+        .mockRejectedValueOnce(new Error("network"))
+        .mockResolvedValueOnce({
+          threads: [
+            { status: "regular" as const, remoteId: "thread-b", title: "B" },
+          ],
+        }),
+    });
+    let adapter: RemoteThreadListAdapter = { ...methodsA };
+    const listeners = new Set<() => void>();
+    const source: AssistantConfigSource = {
+      getConfig: () =>
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => StubThread({ threadId: id }) as never,
+          }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      },
+    };
+    const handle = createAssistantClient(source);
+    handle.subscribe(() => {});
+    await handle.getClient().threads.getLoadThreadsPromise();
+    flushTapSync(() => handle.getClient().threads.switchToThread("thread-a"));
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.item("main").getState().remoteId).toBe(
+        "thread-a",
+      );
+    });
+
+    adapter = { ...methodsB };
+    for (const listener of listeners) listener();
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    try {
+      await vi.waitFor(async () => {
+        flushTapSync(() => {});
+        await handle.getClient().threads.reload();
+        expect(handle.getClient().threads.item("main").getState().status).toBe(
+          "new",
+        );
+      });
+      const mainAfterFailure = handle
+        .getClient()
+        .threads.getState().mainThreadId;
+      await handle.getClient().threads.reload();
+      await vi.waitFor(() => {
+        expect(handle.getClient().threads.getState().threadIds).toEqual([
+          "thread-b",
+        ]);
+      });
+      expect(handle.getClient().threads.getState().mainThreadId).toBe(
+        mainAfterFailure,
+      );
+    } finally {
+      consoleError.mockRestore();
+    }
+    handle.destroy();
+  });
+
+  it("does not send a superseded rename through the replacement adapter", async () => {
+    const initializeRequest = deferred<{
+      remoteId: string;
+      externalId: string | undefined;
+    }>();
+    const methodsA = makeAdapter({
+      list: vi.fn(async () => ({ threads: [] })),
+      initialize: vi.fn(() => initializeRequest.promise),
+    });
+    const methodsB = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "regular" as const, remoteId: "thread-b", title: "B" },
+        ],
+      })),
+    });
+    let adapter: RemoteThreadListAdapter = { ...methodsA };
+    const listeners = new Set<() => void>();
+    const source: AssistantConfigSource = {
+      getConfig: () =>
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => StubThread({ threadId: id }) as never,
+          }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      },
+    };
+    const handle = createAssistantClient(source);
+    handle.subscribe(() => {});
+    await handle.getClient().threads.getLoadThreadsPromise();
+    const initializeTask = handle.getClient().threads.item("main").initialize();
+    const renameTask = handle.getClient().threads.item("main").rename("leaked");
+
+    adapter = { ...methodsB };
+    for (const listener of listeners) listener();
+    await vi.waitFor(async () => {
+      flushTapSync(() => {});
+      await handle.getClient().threads.reload();
+      expect(handle.getClient().threads.getState().threadIds).toEqual([
+        "thread-b",
+      ]);
+    });
+    initializeRequest.resolve({
+      remoteId: "leaked",
+      externalId: undefined,
+    });
+    await expect(initializeTask).rejects.toThrow("adapter changed");
+    await expect(renameTask).rejects.toThrow("adapter changed");
+    expect(methodsA.rename).not.toHaveBeenCalled();
+    expect(methodsB.rename).not.toHaveBeenCalled();
+    handle.destroy();
+  });
+
   it("exposes useAdapters adapters to the thread factory", async () => {
     const history = dummyHistory();
     const capture: { adapters: RuntimeAdapters | null } = { adapters: null };

package/src/react/client/RemoteThreadList.ts

@@ -28,6 +28,7 @@ import type {
   RemoteThreadInitializeResponse,
   RemoteThreadListAdapter,
 } from "../../runtimes/remote-thread-list/types";
+import { ThreadListAdapterChangedError } from "../../runtimes/remote-thread-list/adapter-changed";
 import type { ThreadMessage } from "../../types/message";
 import { AssistantMessageStream } from "assistant-stream";
 import { handleThreadListAction } from "../../store/runtime-clients/handle-thread-list-action";
@@ -52,7 +53,7 @@ const EMPTY_LIST: RemoteThreadState = {
 
 export type RemoteThreadListProps = {
   /**
-   * Swapping this to a different backing store does not reload the list. Call `reload()` after a genuine swap. A recreated object for the same store is a no-op.
+   * Swapping this to a different backing store does not reload the list. Call `reload()` after a genuine swap. A recreated object for the same store is a no-op. `reload()` after a different adapter instance resets selection and cached records before loading.
    */
   adapter: RemoteThreadListAdapter;
   /**
@@ -359,6 +360,8 @@ const useRemoteThreadList = (
       initialMainId: seeded.id,
       session: {
         adapter,
+        adapterAtLoad: adapter,
+        adapterGeneration: 0,
         loadGeneration: 0,
         switchGeneration: 0,
         loadPromise: undefined as Promise<void> | undefined,
@@ -375,6 +378,9 @@ const useRemoteThreadList = (
     };
   });
 
+  // Config updates can invoke `reload()` in the same turn as the re-render, before the effect below runs.
+  session.adapter = adapter;
+
   const listState = useSyncExternalStore(
     (onStoreChange) => store.subscribe(onStoreChange),
     () => store.value,
@@ -417,12 +423,14 @@ const useRemoteThreadList = (
   const getLoadThreadsPromise = useCallback(() => {
     if (session.loadPromise) return session.loadPromise;
     const generation = session.loadGeneration;
+    const adapter = session.adapter;
     session.loadPromise = store
       .optimisticUpdate({
-        execute: () => session.adapter.list(),
+        execute: () => adapter.list(),
         loading: (state) => ({ ...state, isLoading: true }),
         then: (state, page) => {
           if (generation !== session.loadGeneration) return state;
+          session.adapterAtLoad = adapter;
           const fresh = classifyThreads(page.threads, {
             threadIds: [],
             archivedThreadIds: [],
@@ -460,15 +468,34 @@ const useRemoteThreadList = (
   }, [session, store]);
 
   const reload = useCallback(() => {
+    const adapterChanged = adapter !== session.adapterAtLoad;
     session.loadGeneration++;
     session.loadPromise = undefined;
     session.loadMorePromise = undefined;
-    store.update({
-      ...store.baseValue,
-      cursor: undefined,
-    });
+    if (adapterChanged) {
+      session.adapterGeneration++;
+      session.switchGeneration++;
+      session.switchTask = undefined;
+      session.adapterAtLoad = adapter;
+      const seeded = seedNewThread(EMPTY_LIST);
+      store.reset({ ...seeded.state, isLoading: true });
+      assignMainThreadId(seeded.id);
+      notifyRemoteId(undefined, true);
+    } else {
+      store.update({
+        ...store.baseValue,
+        cursor: undefined,
+      });
+    }
     return getLoadThreadsPromise();
-  }, [getLoadThreadsPromise, session, store]);
+  }, [
+    adapter,
+    assignMainThreadId,
+    getLoadThreadsPromise,
+    notifyRemoteId,
+    session,
+    store,
+  ]);
 
   useEffect(() => {
     void getLoadThreadsPromise();
@@ -516,6 +543,7 @@ const useRemoteThreadList = (
         },
       })
       .catch((error: unknown) => {
+        if (generation !== session.loadGeneration) return;
         console.error("[assistant-ui] thread list loadMore failed:", error);
       })
       .then(() => {
@@ -689,18 +717,34 @@ const useRemoteThreadList = (
     [session, store, switchToNewThread],
   );
 
+  const requireAdapterGeneration = useCallback(
+    (generation: number) => {
+      if (generation !== session.adapterGeneration) {
+        throw new ThreadListAdapterChangedError();
+      }
+    },
+    [session],
+  );
+
   const initialize = useCallback(
     async (threadId: string) => {
+      const currentAdapter = session.adapter;
+      const adapterGeneration = session.adapterGeneration;
       if (store.value.newThreadId !== threadId) {
         const data = getThreadData(store.value, threadId);
         if (!data) throw threadNotFoundError(threadId, "initializing it");
         if (data.status === "new") {
           throw threadStatusError(threadId, data.status, "be initialized here");
         }
-        return toInitializeResult(await data.initializeTask);
+        const result = toInitializeResult(await data.initializeTask);
+        requireAdapterGeneration(adapterGeneration);
+        return result;
       }
       const result = await store.optimisticUpdate({
-        execute: () => session.adapter.initialize(threadId),
+        execute: () => {
+          requireAdapterGeneration(adapterGeneration);
+          return currentAdapter.initialize(threadId);
+        },
         optimistic: (state) => updateStatusReducer(state, threadId, "regular"),
         loading: (state, task) => {
           const mappingId = createThreadMappingId(threadId);
@@ -716,6 +760,7 @@ const useRemoteThreadList = (
           };
         },
         then: (state, { remoteId, externalId }) => {
+          if (adapterGeneration !== session.adapterGeneration) return state;
           const data = getThreadData(state, threadId);
           if (!data) return state;
           const mappingId = createThreadMappingId(threadId);
@@ -737,16 +782,19 @@ const useRemoteThreadList = (
           };
         },
       });
+      requireAdapterGeneration(adapterGeneration);
       if (threadId === session.mainThreadId) {
         notifyRemoteId(result.remoteId, true);
       }
       return toInitializeResult(result);
     },
-    [notifyRemoteId, session, store],
+    [notifyRemoteId, requireAdapterGeneration, session, store],
   );
 
   const rename = useCallback(
     (threadIdOrRemoteId: string, newTitle: string) => {
+      const currentAdapter = session.adapter;
+      const adapterGeneration = session.adapterGeneration;
       const data = getThreadData(store.value, threadIdOrRemoteId);
       if (!data) throw threadNotFoundError(threadIdOrRemoteId, "renaming it");
       if (data.status === "new") {
@@ -755,7 +803,8 @@ const useRemoteThreadList = (
       return store.optimisticUpdate({
         execute: async () => {
           const { remoteId } = await data.initializeTask;
-          return session.adapter.rename(remoteId, newTitle);
+          requireAdapterGeneration(adapterGeneration);
+          return currentAdapter.rename(remoteId, newTitle);
         },
         optimistic: (state) => {
           const current = getThreadData(state, threadIdOrRemoteId);
@@ -773,7 +822,7 @@ const useRemoteThreadList = (
         },
       });
     },
-    [session, store],
+    [requireAdapterGeneration, session, store],
   );
 
   const updateCustom = useCallback(
@@ -781,6 +830,8 @@ const useRemoteThreadList = (
       threadIdOrRemoteId: string,
       custom: Record<string, unknown> | undefined,
     ) => {
+      const currentAdapter = session.adapter;
+      const adapterGeneration = session.adapterGeneration;
       const data = getThreadData(store.value, threadIdOrRemoteId);
       if (!data) {
         throw threadNotFoundError(
@@ -795,7 +846,7 @@ const useRemoteThreadList = (
           "update custom metadata",
         );
       }
-      if (!session.adapter.updateCustom) {
+      if (!currentAdapter.updateCustom) {
         throw new Error(
           "Remote thread list adapter does not support updating custom metadata",
         );
@@ -803,7 +854,7 @@ const useRemoteThreadList = (
       return store.optimisticUpdate({
         execute: async () => {
           const { remoteId } = await data.initializeTask;
-          const currentAdapter = session.adapter;
+          requireAdapterGeneration(adapterGeneration);
           if (!currentAdapter.updateCustom) {
             throw new Error(
               "Remote thread list adapter does not support updating custom metadata",
@@ -827,30 +878,36 @@ const useRemoteThreadList = (
         },
       });
     },
-    [session, store],
+    [requireAdapterGeneration, session, store],
   );
 
   const archive = useCallback(
     async (threadIdOrRemoteId: string) => {
+      const currentAdapter = session.adapter;
+      const adapterGeneration = session.adapterGeneration;
       const data = getThreadData(store.value, threadIdOrRemoteId);
       if (!data) throw threadNotFoundError(threadIdOrRemoteId, "archiving it");
       if (data.status !== "regular") {
         throw threadStatusError(threadIdOrRemoteId, data.status, "be archived");
       }
       await ensureNotMain(data.id);
+      requireAdapterGeneration(adapterGeneration);
       return store.optimisticUpdate({
         execute: async () => {
           const { remoteId } = await data.initializeTask;
-          return session.adapter.archive(remoteId);
+          requireAdapterGeneration(adapterGeneration);
+          return currentAdapter.archive(remoteId);
         },
         optimistic: (state) => updateStatusReducer(state, data.id, "archived"),
       });
     },
-    [ensureNotMain, session, store],
+    [ensureNotMain, requireAdapterGeneration, session, store],
   );
 
   const unarchive = useCallback(
     (threadIdOrRemoteId: string) => {
+      const currentAdapter = session.adapter;
+      const adapterGeneration = session.adapterGeneration;
       const data = getThreadData(store.value, threadIdOrRemoteId);
       if (!data)
         throw threadNotFoundError(threadIdOrRemoteId, "unarchiving it");
@@ -865,36 +922,43 @@ const useRemoteThreadList = (
         execute: async () => {
           try {
             const { remoteId } = await data.initializeTask;
-            return await session.adapter.unarchive(remoteId);
+            requireAdapterGeneration(adapterGeneration);
+            return await currentAdapter.unarchive(remoteId);
           } catch (error) {
-            await ensureNotMain(data.id);
+            if (adapterGeneration === session.adapterGeneration) {
+              await ensureNotMain(data.id);
+            }
             throw error;
           }
         },
         optimistic: (state) => updateStatusReducer(state, data.id, "regular"),
       });
     },
-    [ensureNotMain, session, store],
+    [ensureNotMain, requireAdapterGeneration, session, store],
   );
 
   const deleteThread = useCallback(
     async (threadIdOrRemoteId: string) => {
+      const currentAdapter = session.adapter;
+      const adapterGeneration = session.adapterGeneration;
       const data = getThreadData(store.value, threadIdOrRemoteId);
       if (!data) throw threadNotFoundError(threadIdOrRemoteId, "deleting it");
       if (data.status !== "regular" && data.status !== "archived") {
         throw threadStatusError(threadIdOrRemoteId, data.status, "be deleted");
       }
       await ensureNotMain(data.id);
+      requireAdapterGeneration(adapterGeneration);
       onDelete?.(data.id);
       return store.optimisticUpdate({
         execute: async () => {
           const { remoteId } = await data.initializeTask;
-          return session.adapter.delete(remoteId);
+          requireAdapterGeneration(adapterGeneration);
+          return currentAdapter.delete(remoteId);
         },
         optimistic: (state) => updateStatusReducer(state, data.id, "deleted"),
       });
     },
-    [ensureNotMain, onDelete, session, store],
+    [ensureNotMain, onDelete, requireAdapterGeneration, session, store],
   );
 
   const generateTitle = useCallback(
@@ -902,6 +966,8 @@ const useRemoteThreadList = (
       threadIdOrRemoteId: string,
       messages: readonly ThreadMessage[] | undefined,
     ) => {
+      const currentAdapter = session.adapter;
+      const adapterGeneration = session.adapterGeneration;
       const data = getThreadData(store.value, threadIdOrRemoteId);
       if (!data) {
         throw threadNotFoundError(threadIdOrRemoteId, "generating its title");
@@ -914,10 +980,13 @@ const useRemoteThreadList = (
         );
       }
       const { remoteId } = await data.initializeTask;
+      requireAdapterGeneration(adapterGeneration);
       if (!isSameThread(store.value, data.id, session.mainThreadId)) return;
       if (!messages) return;
-      const stream = await session.adapter.generateTitle(remoteId, messages);
+      const stream = await currentAdapter.generateTitle(remoteId, messages);
+      requireAdapterGeneration(adapterGeneration);
       await applyTitleStream(stream, (newTitle) => {
+        if (adapterGeneration !== session.adapterGeneration) return;
         const state = store.baseValue;
         const current = getThreadData(state, data.id);
         if (!current) return;
@@ -933,7 +1002,7 @@ const useRemoteThreadList = (
         });
       });
     },
-    [session, store],
+    [requireAdapterGeneration, session, store],
   );
 
   const { mainThreadClient, itemOrder, threadListItems } =

package/src/react/primitive-hooks/useActionBarCopy.test.ts

@@ -82,6 +82,21 @@ describe("useActionBarCopy", () => {
     expect(mocks.setIsCopied).not.toHaveBeenCalled();
   });
 
+  it("does not report copy success when the clipboard handler throws synchronously", async () => {
+    const copyToClipboard = vi.fn(() => {
+      throw new TypeError(
+        "Cannot read properties of undefined (reading 'writeText')",
+      );
+    });
+    const { result } = renderHook(() => useActionBarCopy({ copyToClipboard }));
+
+    expect(() => result.current.copy()).not.toThrow();
+    await Promise.resolve();
+
+    expect(copyToClipboard).toHaveBeenCalledWith("Hello");
+    expect(mocks.setIsCopied).not.toHaveBeenCalled();
+  });
+
   it("keeps copy success visible for the full duration after copying again", async () => {
     vi.useFakeTimers();
     const copyToClipboard = vi.fn();

package/src/react/primitive-hooks/useActionBarCopy.ts

@@ -40,9 +40,19 @@ export const useActionBarCopy = ({
     if (!valueToCopy) return;
     const scopeGeneration = scopeGenerationRef.current;
 
-    // The rejection handler swallows clipboard write failures (permission denied,
-    // API unavailable) so they don't surface as unhandled promise rejections.
-    Promise.resolve(copyToClipboard(valueToCopy)).then(
+    // The writer runs synchronously inside the press so the user-gesture gating
+    // of navigator.clipboard survives (WebKit scopes it to the stack); the try
+    // contains a synchronously throwing caller-supplied writer, and the rejection
+    // handler swallows clipboard failures (permission denied, API unavailable) so
+    // they don't surface as unhandled rejections.
+    let write: void | Promise<void>;
+    try {
+      write = copyToClipboard(valueToCopy);
+    } catch {
+      return;
+    }
+
+    Promise.resolve(write).then(
       () => {
         if (scopeGeneration !== scopeGenerationRef.current) return;
 

package/src/react/primitive-hooks/useThreadIsEmpty.ts

@@ -1,5 +1,8 @@
 import { useAuiState } from "@assistant-ui/store";
 
+/**
+ * @deprecated Use `useAuiState((s) => s.thread.isEmpty)` instead.
+ */
 export const useThreadIsEmpty = (): boolean => {
   return useAuiState((s) => s.thread.isEmpty);
 };

package/src/react/primitive-hooks/useThreadIsRunning.ts

@@ -1,5 +1,8 @@
 import { useAuiState } from "@assistant-ui/store";
 
+/**
+ * @deprecated Use `useAuiState((s) => s.thread.isRunning)` instead.
+ */
 export const useThreadIsRunning = (): boolean => {
   return useAuiState((s) => s.thread.isRunning);
 };

package/src/react/runtimes/RemoteThreadListHookInstanceManager.tsx

@@ -173,6 +173,18 @@ export class RemoteThreadListHookInstanceManager extends BaseSubscribable {
       this._trackRunning(instance);
     }
     this._notifySubscribers();
+    if (previousRuntime !== undefined && previousRuntime !== runtime) {
+      for (const callback of this.replacedSubscribers) callback();
+    }
+  }
+
+  private replacedSubscribers = new Set<() => void>();
+
+  public __internal_subscribeRuntimeReplaced(
+    callback: () => void,
+  ): Unsubscribe {
+    this.replacedSubscribers.add(callback);
+    return () => this.replacedSubscribers.delete(callback);
   }
 
   private _trackRunning(instance: RemoteThreadListHookInstance) {