@assistant-ui/core 0.3.17 → 0.3.18

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

@@ -88,15 +88,16 @@ const makeAdapter = (
   ...overrides,
 });
 
-const mountBackgroundList = (
+const mountThreadList = (
   adapter: RemoteThreadListAdapter,
   tracker: Tracker,
+  backgroundThreads = true,
 ) => {
   const handle = createAssistantClient(
     AuiConfig({
       threads: RemoteThreadList({
         adapter,
-        backgroundThreads: true,
+        backgroundThreads,
         thread: (id) =>
           withKey(id, TrackedThread({ threadId: id, tracker }) as never),
       }),
@@ -112,7 +113,148 @@ const createTracker = (): Tracker => ({
   running: new Set(),
 });
 
+const deferred = <T>() => {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+};
+
 describe("RemoteThreadList backgroundThreads", () => {
+  it("keeps the running initialized body when its listed duplicate is selected", async () => {
+    const list = deferred<{
+      threads: [
+        {
+          status: "regular";
+          remoteId: string;
+          externalId: string;
+          title: string;
+        },
+      ];
+    }>();
+    const initialize = deferred<{
+      remoteId: string;
+      externalId: undefined;
+    }>();
+    const adapter = makeAdapter({
+      list: vi.fn(() => list.promise),
+      initialize: vi.fn(() => initialize.promise),
+    });
+    const tracker = createTracker();
+    const handle = mountThreadList(adapter, tracker);
+    const aui = handle.getClient();
+    const loadPromise = aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+    tracker.running.add(localId);
+    const initializePromise = aui.threads.item("main").initialize();
+
+    list.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "remote-1",
+          externalId: "remote-1",
+          title: "Listed thread",
+        },
+      ],
+    });
+    await loadPromise;
+    flushTapSync(() => aui.threads.switchToThread("remote-1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("remote-1");
+      expect(tracker.alive.has("remote-1")).toBe(true);
+    });
+    const localMountCount = tracker.mounts.filter(
+      (id) => id === localId,
+    ).length;
+
+    initialize.resolve({ remoteId: "remote-1", externalId: undefined });
+    await initializePromise;
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe(localId);
+      expect(aui.threads.getState().threadIds).toEqual([localId]);
+      expect(tracker.alive.has(localId)).toBe(true);
+      expect(tracker.alive.has("remote-1")).toBe(false);
+    });
+
+    expect(aui.threads.item({ id: "remote-1" }).getState().id).toBe(localId);
+    expect(aui.threads.item("main").getState().id).toBe(localId);
+    expect(aui.threads.item("main").getState().externalId).toBe("remote-1");
+    expect(aui.threads.item("main").getState().title).toBe("Listed thread");
+    expect(aui.threads.item("main").getState().isRunning).toBe(true);
+    expect(tracker.mounts.filter((id) => id === localId)).toHaveLength(
+      localMountCount,
+    );
+    handle.destroy();
+  });
+
+  it("keeps the mounted listed body when an unmounted initialization completes", async () => {
+    const list = deferred<{
+      threads: [
+        {
+          status: "regular";
+          remoteId: string;
+          externalId: string;
+          title: string;
+        },
+      ];
+    }>();
+    const initialize = deferred<{
+      remoteId: string;
+      externalId: undefined;
+    }>();
+    const adapter = makeAdapter({
+      list: vi.fn(() => list.promise),
+      initialize: vi.fn(() => initialize.promise),
+    });
+    const tracker = createTracker();
+    const handle = mountThreadList(adapter, tracker, false);
+    const aui = handle.getClient();
+    const loadPromise = aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+    const initializePromise = aui.threads.item("main").initialize();
+
+    list.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "remote-1",
+          externalId: "external-1",
+          title: "Listed thread",
+        },
+      ],
+    });
+    await loadPromise;
+    flushTapSync(() => aui.threads.switchToThread("remote-1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("remote-1");
+      expect(tracker.alive.has(localId)).toBe(false);
+      expect(tracker.alive.has("remote-1")).toBe(true);
+    });
+    const listedMountCount = tracker.mounts.filter(
+      (id) => id === "remote-1",
+    ).length;
+
+    initialize.resolve({ remoteId: "remote-1", externalId: undefined });
+    await initializePromise;
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("remote-1");
+      expect(aui.threads.getState().threadIds).toEqual(["remote-1"]);
+      expect(tracker.alive.has("remote-1")).toBe(true);
+    });
+
+    expect(aui.threads.item("main").getState()).toMatchObject({
+      id: "remote-1",
+      externalId: "external-1",
+      title: "Listed thread",
+    });
+    expect(tracker.mounts.filter((id) => id === "remote-1")).toHaveLength(
+      listedMountCount,
+    );
+    handle.destroy();
+  });
+
   it("keeps a switched-away thread mounted with live isRunning", async () => {
     const adapter = makeAdapter({
       list: vi.fn(async () => ({
@@ -120,7 +262,7 @@ describe("RemoteThreadList backgroundThreads", () => {
       })),
     });
     const tracker = createTracker();
-    const handle = mountBackgroundList(adapter, tracker);
+    const handle = mountThreadList(adapter, tracker);
     const aui = handle.getClient();
     await aui.threads.getLoadThreadsPromise();
     await vi.waitFor(() => {
@@ -164,7 +306,7 @@ describe("RemoteThreadList backgroundThreads", () => {
       })),
     });
     const tracker = createTracker();
-    const handle = mountBackgroundList(adapter, tracker);
+    const handle = mountThreadList(adapter, tracker);
     const aui = handle.getClient();
     await aui.threads.getLoadThreadsPromise();
     await vi.waitFor(() => {
@@ -260,7 +402,7 @@ describe("RemoteThreadList backgroundThreads", () => {
     });
     const tracker = createTracker();
     tracker.messagesOf = () => [{ status: { type: "complete" } }];
-    const handle = mountBackgroundList(adapter, tracker);
+    const handle = mountThreadList(adapter, tracker);
     const aui = handle.getClient();
     await aui.threads.getLoadThreadsPromise();
     await vi.waitFor(() => {
@@ -350,7 +492,7 @@ describe("RemoteThreadList backgroundThreads", () => {
       list: vi.fn(async () => ({ threads: listed })),
     });
     const tracker = createTracker();
-    const handle = mountBackgroundList(adapter, tracker);
+    const handle = mountThreadList(adapter, tracker);
     const aui = handle.getClient();
     await aui.threads.getLoadThreadsPromise();
     const localId = aui.threads.getState().mainThreadId;

package/src/react/client/RemoteThreadList.concurrent.test.tsx

@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 
-import { createRef, startTransition, Suspense } from "react";
+import { createRef, startTransition, Suspense, useLayoutEffect } from "react";
 import { act, render, waitFor } from "@testing-library/react";
 import { resource, withKey } from "@assistant-ui/tap";
 import {
@@ -68,6 +68,47 @@ const makeAdapter = (): RemoteThreadListAdapter => ({
 });
 
 describe("RemoteThreadList concurrent rendering", () => {
+  it("reloads through the committed adapter from a descendant layout effect", async () => {
+    const adapterA = makeAdapter();
+    const adapterB = makeAdapter();
+
+    const ReloadOnSwap = ({ workspace }: { workspace: string }) => {
+      const aui = useAui();
+      useLayoutEffect(() => {
+        if (workspace === "A") return;
+        void aui.threads.reload();
+      }, [aui, workspace]);
+      return null;
+    };
+    const App = ({
+      adapter,
+      workspace,
+    }: {
+      adapter: RemoteThreadListAdapter;
+      workspace: string;
+    }) => (
+      <AuiProvider
+        config={AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: () => StubThread() as never,
+          }),
+        })}
+      >
+        <ReloadOnSwap workspace={workspace} />
+      </AuiProvider>
+    );
+
+    const view = render(<App adapter={adapterA} workspace="A" />);
+    await waitFor(() => expect(adapterA.list).toHaveBeenCalledOnce());
+
+    act(() => {
+      view.rerender(<App adapter={adapterB} workspace="B" />);
+    });
+    await waitFor(() => expect(adapterB.list).toHaveBeenCalled());
+    expect(adapterA.list).toHaveBeenCalledOnce();
+  });
+
   it("keeps actions scoped to the committed adapter", async () => {
     const adapterA = makeAdapter();
     const adapterB = makeAdapter();

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

@@ -117,6 +117,7 @@ const mountList = (
   threadId?: string,
   refetch?: () => Promise<void>,
   onSwitchToThread?: (id: string) => void,
+  onDelete?: (id: string) => void,
 ) => {
   const onThreadIdChange = vi.fn();
   const handle = createAssistantClient(
@@ -127,6 +128,7 @@ const mountList = (
         threadId,
         onThreadIdChange,
         onSwitchToThread,
+        onDelete,
       }),
     }),
   );
@@ -402,6 +404,141 @@ describe("RemoteThreadList", () => {
     handle.destroy();
   });
 
+  it("clears the deleted thread's title state so a reborn slot can auto-title", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "regular" as const, remoteId: "t1", title: "One" },
+          { status: "regular" as const, remoteId: "t2", title: "Two" },
+        ],
+      })),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t1", "t2"]);
+    });
+
+    await aui.threads.item({ id: "t1" }).rename("Manual title");
+    await aui.threads.item({ id: "t2" }).rename("Kept manual title");
+    await aui.threads.item({ id: "t1" }).delete();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t2"]);
+    });
+
+    // The server still lists t1, so a reload rebirths the slot under the same
+    // remote id; a leaked manual-rename entry would suppress its auto-title.
+    await aui.threads.reload();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t1", "t2"]);
+    });
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+
+    await aui.threads.item({ id: "t1" }).generateTitle({ automatic: true });
+    expect(adapter.generateTitle).toHaveBeenCalledOnce();
+
+    // t2 is the control: a reload that cleared every title state would
+    // generate here as well.
+    flushTapSync(() => aui.threads.switchToThread("t2"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t2");
+    });
+    await aui.threads.item({ id: "t2" }).generateTitle({ automatic: true });
+    expect(adapter.generateTitle).toHaveBeenCalledOnce();
+    handle.destroy();
+  });
+
+  it("preserves an existing title when generation returns no title", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t1"]);
+    });
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+
+    await aui.threads.item({ id: "t1" }).generateTitle();
+    // The list item re-renders a tick after the generation resolves, so an
+    // erasing title write lands only once that render has run.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(adapter.generateTitle).toHaveBeenCalledOnce();
+    expect(aui.threads.item({ id: "t1" }).getState().title).toBe("One");
+    handle.destroy();
+  });
+
+  it("keeps a manual rename made during automatic title generation", async () => {
+    const generatedTitle = deferred<ReadableStream>();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+      generateTitle: vi.fn(async () => generatedTitle.promise as never),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual(["t1"]);
+    });
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+
+    const generation = aui.threads
+      .item({ id: "t1" })
+      .generateTitle({ automatic: true });
+    await vi.waitFor(() => {
+      expect(adapter.generateTitle).toHaveBeenCalledOnce();
+    });
+    await aui.threads.item({ id: "t1" }).rename("Manual title");
+    await vi.waitFor(() => {
+      expect(aui.threads.item({ id: "t1" }).getState().title).toBe(
+        "Manual title",
+      );
+    });
+
+    generatedTitle.resolve(
+      new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "part-start",
+            path: [0],
+            part: { type: "text" },
+          });
+          controller.enqueue({
+            type: "text-delta",
+            path: [0],
+            textDelta: "Generated title",
+          });
+          controller.enqueue({ type: "part-finish", path: [0] });
+          controller.close();
+        },
+      }),
+    );
+    await generation;
+
+    expect(aui.threads.item({ id: "t1" }).getState().title).toBe(
+      "Manual title",
+    );
+    expect(adapter.rename).toHaveBeenNthCalledWith(1, "t1", "Manual title");
+    expect(adapter.rename).toHaveBeenNthCalledWith(2, "t1", "Manual title");
+    handle.destroy();
+  });
+
   it("preserves generated titles across an overlapping reload", async () => {
     const reload = deferred<{
       threads: {
@@ -623,10 +760,17 @@ describe("RemoteThreadList", () => {
   });
 
   it("keeps one slot per remote id across reload and clears it on delete", async () => {
+    const onDelete = vi.fn();
     const adapter = makeAdapter({
       list: vi.fn(async () => ({ threads: [] })),
     });
-    const { handle } = mountList(adapter);
+    const { handle } = mountList(
+      adapter,
+      undefined,
+      undefined,
+      undefined,
+      onDelete,
+    );
     const aui = handle.getClient();
     await aui.threads.getLoadThreadsPromise();
     const localId = aui.threads.getState().mainThreadId;
@@ -646,6 +790,120 @@ describe("RemoteThreadList", () => {
     });
     expect(() => aui.threads.item({ id: localId }).getState()).toThrow();
     expect(() => aui.threads.item({ id: remoteId }).getState()).toThrow();
+    expect(onDelete).toHaveBeenCalledOnce();
+    expect(onDelete).toHaveBeenCalledWith(localId);
+    handle.destroy();
+  });
+
+  it("does not invoke deletion cleanup when the remote deletion fails", async () => {
+    const error = new Error("delete failed");
+    const onDelete = vi.fn();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+      delete: vi.fn(async () => {
+        throw error;
+      }),
+    });
+    const { handle } = mountList(
+      adapter,
+      undefined,
+      undefined,
+      undefined,
+      onDelete,
+    );
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toContain("t1");
+    });
+
+    await expect(aui.threads.item({ id: "t1" }).delete()).rejects.toBe(error);
+
+    expect(aui.threads.getState().threadIds).toContain("t1");
+    expect(onDelete).not.toHaveBeenCalled();
+    handle.destroy();
+  });
+
+  const deleteDuringAdapterSwap = async (
+    replacementThreads: readonly {
+      status: "regular";
+      remoteId: string;
+      title: string;
+    }[],
+  ) => {
+    const removal = deferred<void>();
+    const onDelete = vi.fn();
+    const adapterA = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+      delete: vi.fn(() => removal.promise),
+    });
+    const adapterB = makeAdapter({
+      list: vi.fn(async () => ({ threads: replacementThreads })),
+    });
+    let adapter: RemoteThreadListAdapter = adapterA;
+    const listeners = new Set<() => void>();
+    const source: AssistantConfigSource = {
+      getConfig: () =>
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => StubThread({ threadId: id }) as never,
+            onDelete,
+          }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      },
+    };
+    const handle = createAssistantClient(source);
+    handle.subscribe(() => {});
+    await handle.getClient().threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().threadIds).toContain("t1");
+    });
+
+    const deletion = handle.getClient().threads.item({ id: "t1" }).delete();
+    await vi.waitFor(() => {
+      expect(adapterA.delete).toHaveBeenCalledWith("t1");
+    });
+
+    adapter = adapterB;
+    for (const listener of listeners) listener();
+    await vi.waitFor(async () => {
+      flushTapSync(() => {});
+      await handle.getClient().threads.reload();
+      expect(adapterB.list).toHaveBeenCalled();
+      expect(handle.getClient().threads.getState().threadIds).toEqual(
+        replacementThreads.map((thread) => thread.remoteId),
+      );
+    });
+
+    removal.resolve();
+    await deletion;
+    return { handle, onDelete };
+  };
+
+  it("invokes deletion cleanup when the adapter changes during a successful deletion", async () => {
+    const { handle, onDelete } = await deleteDuringAdapterSwap([]);
+
+    expect(onDelete).toHaveBeenCalledWith("t1");
+    handle.destroy();
+  });
+
+  it("skips deletion cleanup when the replacement adapter re-lists the deleted id", async () => {
+    const { handle, onDelete } = await deleteDuringAdapterSwap([
+      { status: "regular" as const, remoteId: "t1", title: "One" },
+    ]);
+
+    expect(handle.getClient().threads.getState().threadIds).toContain("t1");
+    expect(onDelete).not.toHaveBeenCalled();
     handle.destroy();
   });
 
@@ -873,6 +1131,7 @@ describe("RemoteThreadList", () => {
   });
 
   it("does not reset again when retrying a failed replacement load", async () => {
+    const error = new Error("network");
     const methodsA = makeAdapter({
       list: vi.fn(async () => ({
         threads: [
@@ -883,8 +1142,8 @@ describe("RemoteThreadList", () => {
     const methodsB = makeAdapter({
       list: vi
         .fn()
-        .mockRejectedValueOnce(new Error("network"))
-        .mockResolvedValueOnce({
+        .mockRejectedValueOnce(error)
+        .mockResolvedValue({
           threads: [
             { status: "regular" as const, remoteId: "thread-b", title: "B" },
           ],
@@ -933,6 +1192,7 @@ describe("RemoteThreadList", () => {
       const mainAfterFailure = handle
         .getClient()
         .threads.getState().mainThreadId;
+      expect(handle.getClient().threads.getState().loadError).toBe(error);
       await handle.getClient().threads.reload();
       await vi.waitFor(() => {
         expect(handle.getClient().threads.getState().threadIds).toEqual([
@@ -942,12 +1202,94 @@ describe("RemoteThreadList", () => {
       expect(handle.getClient().threads.getState().mainThreadId).toBe(
         mainAfterFailure,
       );
+      expect(handle.getClient().threads.getState().loadError).toBeUndefined();
     } finally {
       consoleError.mockRestore();
     }
     handle.destroy();
   });
 
+  it("reloads once when the browser comes online after a failed load", async () => {
+    vi.stubGlobal("window", new EventTarget());
+    vi.stubGlobal(
+      "document",
+      Object.assign(new EventTarget(), { visibilityState: "visible" }),
+    );
+    const error = new Error("offline");
+    const firstLoad = deferred<{ threads: [] }>();
+    const list = vi
+      .fn()
+      .mockReturnValueOnce(firstLoad.promise)
+      .mockResolvedValueOnce({ threads: [] });
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const { handle } = mountList(makeAdapter({ list }));
+
+    try {
+      await vi.waitFor(() => expect(list).toHaveBeenCalledTimes(1));
+      firstLoad.reject(error);
+      await vi.waitFor(() =>
+        expect(handle.getClient().threads.getState().loadError).toBe(error),
+      );
+
+      window.dispatchEvent(new Event("online"));
+
+      await vi.waitFor(() => expect(list).toHaveBeenCalledTimes(2));
+      await vi.waitFor(() =>
+        expect(handle.getClient().threads.getState().loadError).toBeUndefined(),
+      );
+      expect(list).toHaveBeenCalledTimes(2);
+    } finally {
+      handle.destroy();
+      consoleError.mockRestore();
+      vi.unstubAllGlobals();
+    }
+  });
+
+  it("retries once when the document becomes visible after a failed load", async () => {
+    vi.stubGlobal("window", new EventTarget());
+    const document = Object.assign(new EventTarget(), {
+      visibilityState: "hidden",
+    });
+    vi.stubGlobal("document", document);
+    const error = new Error("offline");
+    const firstLoad = deferred<{ threads: [] }>();
+    const list = vi
+      .fn()
+      .mockReturnValueOnce(firstLoad.promise)
+      .mockResolvedValueOnce({ threads: [] });
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const { handle } = mountList(makeAdapter({ list }));
+
+    try {
+      await vi.waitFor(() => expect(list).toHaveBeenCalledTimes(1));
+      firstLoad.reject(error);
+      await vi.waitFor(() =>
+        expect(handle.getClient().threads.getState().loadError).toBe(error),
+      );
+
+      document.dispatchEvent(new Event("visibilitychange"));
+      await new Promise((resolve) => setTimeout(resolve, 20));
+      expect(list).toHaveBeenCalledTimes(1);
+
+      document.visibilityState = "visible";
+      document.dispatchEvent(new Event("visibilitychange"));
+
+      await vi.waitFor(() => expect(list).toHaveBeenCalledTimes(2));
+      await vi.waitFor(() =>
+        expect(handle.getClient().threads.getState().loadError).toBeUndefined(),
+      );
+      expect(list).toHaveBeenCalledTimes(2);
+    } finally {
+      handle.destroy();
+      consoleError.mockRestore();
+      vi.unstubAllGlobals();
+    }
+  });
+
   it("does not send a superseded rename through the replacement adapter", async () => {
     const initializeRequest = deferred<{
       remoteId: string;