@assistant-ui/core 0.3.15 → 0.3.17

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

@@ -0,0 +1,274 @@
+// @vitest-environment jsdom
+
+import { createRef, startTransition, Suspense } from "react";
+import { act, render, waitFor } from "@testing-library/react";
+import { resource, withKey } from "@assistant-ui/tap";
+import {
+  AuiConfig,
+  AuiProvider,
+  type AssistantClient,
+  useAui,
+  useAuiState,
+} from "@assistant-ui/store";
+import { describe, expect, it, vi } from "vitest";
+import type { RemoteThreadListAdapter } from "../../runtimes/remote-thread-list/types";
+import { RemoteThreadList } from "./RemoteThreadList";
+
+const composer = { getState: () => ({}) };
+const suggestions = { getState: () => ({ suggestions: [] }) };
+const threadState = { isRunning: false, messages: [] };
+const useStubThread = () => ({
+  getState: () => threadState,
+  composer: () => composer,
+  suggestions: () => suggestions,
+});
+const StubThread = resource(useStubThread);
+
+const useIdentifiedThread = ({
+  id,
+  onRender,
+  onRefetch,
+}: {
+  id: string;
+  onRender: (id: string) => void;
+  onRefetch: (id: string) => void;
+}) => {
+  onRender(id);
+  return {
+    getState: () => ({ isRunning: false, messages: [{ id }] }),
+    composer: () => composer,
+    suggestions: () => suggestions,
+    getModelContext: () => ({ tools: { [id]: {} }, config: {} }),
+    unstable_refetchThread: async () => onRefetch(id),
+  };
+};
+const IdentifiedThread = resource(useIdentifiedThread);
+
+const makeAdapter = (): RemoteThreadListAdapter => ({
+  list: vi.fn(async () => ({
+    threads: [
+      { status: "regular" as const, remoteId: "thread-1", title: "Thread" },
+    ],
+  })),
+  initialize: vi.fn(async (threadId: string) => ({
+    remoteId: threadId,
+    externalId: undefined,
+  })),
+  rename: vi.fn(async () => {}),
+  archive: vi.fn(async () => {}),
+  unarchive: vi.fn(async () => {}),
+  delete: vi.fn(async () => {}),
+  generateTitle: vi.fn(async () => new ReadableStream()),
+  fetch: vi.fn(async (remoteId: string) => ({
+    status: "regular" as const,
+    remoteId,
+    externalId: undefined,
+    title: "Thread",
+  })),
+});
+
+describe("RemoteThreadList concurrent rendering", () => {
+  it("keeps actions scoped to the committed adapter", async () => {
+    const adapterA = makeAdapter();
+    const adapterB = makeAdapter();
+    const clientRef = createRef<AssistantClient>();
+    const never = new Promise<never>(() => {});
+    let suspend = false;
+
+    const Blocker = () => {
+      if (suspend) throw never;
+      return null;
+    };
+    const App = ({ adapter }: { adapter: RemoteThreadListAdapter }) => (
+      <Suspense fallback={null}>
+        <AuiProvider
+          ref={clientRef as never}
+          config={AuiConfig({
+            threads: RemoteThreadList({
+              adapter,
+              thread: () => StubThread() as never,
+            }),
+          })}
+        >
+          <Blocker />
+        </AuiProvider>
+      </Suspense>
+    );
+
+    const view = render(<App adapter={adapterA} />);
+    const client = clientRef.current!;
+    await act(async () => {
+      await client.threads.getLoadThreadsPromise();
+    });
+    await waitFor(() =>
+      expect(client.threads.getState().threadIds).toEqual(["thread-1"]),
+    );
+
+    act(() => {
+      suspend = true;
+      startTransition(() => view.rerender(<App adapter={adapterB} />));
+    });
+    await act(async () => {
+      await client.threads.item({ id: "thread-1" }).rename("Renamed");
+    });
+
+    expect(adapterA.rename).toHaveBeenCalledWith("thread-1", "Renamed");
+    expect(adapterB.rename).not.toHaveBeenCalled();
+  });
+
+  it("does not render the previous thread during an ordinary switch", async () => {
+    const adapter = makeAdapter();
+    adapter.list = vi.fn(async () => ({
+      threads: [
+        {
+          status: "regular" as const,
+          remoteId: "thread-1",
+          title: "Thread 1",
+        },
+        {
+          status: "regular" as const,
+          remoteId: "thread-2",
+          title: "Thread 2",
+        },
+      ],
+    }));
+    const clientRef = createRef<AssistantClient>();
+    const renders: string[] = [];
+    const selectionToolIds: string[] = [];
+
+    const Observer = () => {
+      const aui = useAui();
+      const stateId = useAuiState(
+        (state) => state.thread.messages[0]?.id as string | undefined,
+      );
+      const imperativeId = aui.thread.getState().messages[0]?.id as
+        | string
+        | undefined;
+      renders.push(`${stateId}:${imperativeId}`);
+      return null;
+    };
+    const App = () => (
+      <AuiProvider
+        ref={clientRef as never}
+        config={AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) =>
+              withKey(
+                id,
+                IdentifiedThread({
+                  id,
+                  onRender: () => {},
+                  onRefetch: () => {},
+                }),
+              ) as never,
+          }),
+        })}
+      >
+        <Observer />
+      </AuiProvider>
+    );
+
+    render(<App />);
+    const client = clientRef.current!;
+    await act(async () => {
+      await client.threads.getLoadThreadsPromise();
+      await client.threads.switchToThread("thread-1");
+    });
+    await waitFor(() => expect(renders).toContain("thread-1:thread-1"));
+    const unsubscribe = client.on(
+      "threads.selectionChanged" as never,
+      (() => {
+        selectionToolIds.push(
+          Object.keys(client.thread.getModelContext().tools)[0]!,
+        );
+      }) as never,
+    );
+
+    renders.length = 0;
+    await act(async () => {
+      await client.threads.switchToThread("thread-2");
+    });
+    await waitFor(() => expect(renders).toContain("thread-2:thread-2"));
+
+    expect(renders).not.toContain("thread-2:thread-1");
+    expect(selectionToolIds).toEqual(["thread-2"]);
+    unsubscribe();
+  });
+
+  it("keeps the main thread facade scoped to the committed factory", async () => {
+    const adapter = makeAdapter();
+    const clientRef = createRef<AssistantClient>();
+    const renderWorkspaceB = vi.fn();
+    const refetchThread = vi.fn();
+    const never = new Promise<never>(() => {});
+    let suspend = false;
+
+    const Blocker = () => {
+      if (suspend) throw never;
+      return null;
+    };
+    const App = ({ workspace }: { workspace: string }) => (
+      <Suspense fallback={null}>
+        <AuiProvider
+          ref={clientRef as never}
+          config={AuiConfig({
+            threads: RemoteThreadList({
+              adapter,
+              thread: (id) =>
+                withKey(
+                  workspace,
+                  IdentifiedThread({
+                    id: `${workspace}:${id}`,
+                    onRender: (renderedId) => {
+                      if (renderedId.startsWith("workspace-b:")) {
+                        renderWorkspaceB();
+                      }
+                    },
+                    onRefetch: refetchThread,
+                  }),
+                ) as never,
+            }),
+          })}
+        >
+          <Blocker />
+        </AuiProvider>
+      </Suspense>
+    );
+
+    const view = render(<App workspace="workspace-a" />);
+    const client = clientRef.current!;
+    await act(async () => {
+      await client.threads.getLoadThreadsPromise();
+      await client.threads.switchToThread("thread-1");
+    });
+    await waitFor(() =>
+      expect(client.thread.getState().messages[0]?.id).toBe(
+        "workspace-a:thread-1",
+      ),
+    );
+
+    act(() => {
+      suspend = true;
+      startTransition(() => view.rerender(<App workspace="workspace-b" />));
+    });
+
+    expect(renderWorkspaceB).toHaveBeenCalled();
+    await act(async () => {
+      await client.threads.reloadMainThread();
+    });
+    expect(refetchThread).toHaveBeenLastCalledWith("workspace-a:thread-1");
+
+    suspend = false;
+    view.rerender(<App workspace="workspace-b" />);
+    await waitFor(() =>
+      expect(client.thread.getState().messages[0]?.id).toBe(
+        "workspace-b:thread-1",
+      ),
+    );
+    await act(async () => {
+      await client.threads.reloadMainThread();
+    });
+    expect(refetchThread).toHaveBeenLastCalledWith("workspace-b:thread-1");
+  });
+});

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

@@ -134,6 +134,46 @@ const mountList = (
   return { handle, onThreadIdChange };
 };
 
+const mountArchivedInitializingThread = async () => {
+  const initialize = deferred<{
+    remoteId: string;
+    externalId: undefined;
+  }>();
+  const adapter = makeAdapter({
+    list: vi.fn(async () => ({
+      threads: [
+        {
+          status: "regular" as const,
+          remoteId: "fallback",
+          title: "Fallback",
+        },
+      ],
+    })),
+    initialize: vi.fn(() => initialize.promise),
+  });
+  const { handle } = mountList(adapter);
+  const aui = handle.getClient();
+  await aui.threads.getLoadThreadsPromise();
+  const targetId = aui.threads.getState().mainThreadId;
+  const initialization = aui.threads.item("main").initialize();
+  await vi.waitFor(() => {
+    expect(handle.getClient().threads.item("main").getState().status).toBe(
+      "regular",
+    );
+  });
+  flushTapSync(() => aui.threads.switchToThread("fallback"));
+  await vi.waitFor(() => {
+    expect(handle.getClient().threads.getState().mainThreadId).toBe("fallback");
+  });
+  flushTapSync(() => aui.threads.item({ id: targetId }).archive());
+  await vi.waitFor(() => {
+    expect(handle.getClient().threads.getState().archivedThreadIds).toContain(
+      targetId,
+    );
+  });
+  return { adapter, handle, targetId, initialization, initialize };
+};
+
 describe("RemoteThreadList", () => {
   it("loads adapter threads on a standalone client", async () => {
     const adapter = makeAdapter({
@@ -234,6 +274,37 @@ describe("RemoteThreadList", () => {
     handle.destroy();
   });
 
+  it("keeps a thread initialized during the list() flight after switching away", async () => {
+    const listDeferred =
+      deferred<Awaited<ReturnType<RemoteThreadListAdapter["list"]>>>();
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+
+    const loadPromise = aui.threads.getLoadThreadsPromise();
+    const initializedId = aui.threads.getState().mainThreadId;
+    await aui.threads.item("main").initialize();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toContain(initializedId);
+    });
+
+    listDeferred.resolve({
+      threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+    });
+    await loadPromise;
+
+    flushTapSync(() => aui.threads.switchToNewThread());
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).not.toBe(initializedId);
+    });
+
+    expect(aui.threads.getState().threadIds[0]).toBe(initializedId);
+    expect(aui.threads.getState().threadIds).toContain("t1");
+    handle.destroy();
+  });
+
   it("switches to a listed thread and back to a new thread", async () => {
     const adapter = makeAdapter({
       list: vi.fn(async () => ({
@@ -331,6 +402,128 @@ describe("RemoteThreadList", () => {
     handle.destroy();
   });
 
+  it("preserves generated titles across an overlapping reload", async () => {
+    const reload = deferred<{
+      threads: {
+        status: "regular";
+        remoteId: string;
+        title: string;
+      }[];
+    }>();
+    const adapter = makeAdapter({
+      list: vi
+        .fn()
+        .mockResolvedValueOnce({
+          threads: [
+            { status: "regular" as const, remoteId: "t1", title: "One" },
+          ],
+        })
+        .mockImplementationOnce(() => reload.promise),
+      generateTitle: vi.fn(
+        async () =>
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue({
+                type: "part-start",
+                path: [],
+                part: { type: "text" },
+              });
+              controller.enqueue({
+                type: "text-delta",
+                path: [0],
+                textDelta: "Generated",
+              });
+              controller.enqueue({ type: "part-finish", path: [0] });
+              controller.close();
+            },
+          }) as never,
+      ),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+
+    const reloadPromise = aui.threads.reload();
+    await vi.waitFor(() => {
+      expect(adapter.list).toHaveBeenCalledTimes(2);
+    });
+    await aui.threads.item({ id: "t1" }).rename("Renamed");
+    await aui.threads.item({ id: "t1" }).generateTitle();
+    await vi.waitFor(() => {
+      expect(aui.threads.item({ id: "t1" }).getState().title).toBe("Generated");
+    });
+
+    reload.resolve({
+      threads: [{ status: "regular", remoteId: "t1", title: "One" }],
+    });
+    await reloadPromise;
+    await vi.waitFor(() => {
+      expect(aui.threads.item({ id: "t1" }).getState().title).toBe("Generated");
+    });
+    handle.destroy();
+  });
+
+  it("clears loading when a reload supersedes a hung list", async () => {
+    const adapter = makeAdapter({
+      list: vi
+        .fn()
+        .mockImplementationOnce(() => new Promise<never>(() => {}))
+        .mockResolvedValueOnce({
+          threads: [
+            { status: "regular" as const, remoteId: "fresh", title: "Fresh" },
+          ],
+        }),
+    });
+    const { handle } = mountList(adapter);
+    const threads = handle.getClient().threads;
+
+    void threads.getLoadThreadsPromise();
+    await threads.reload();
+
+    await vi.waitFor(() => {
+      const state = handle.getClient().threads.getState();
+      expect(state.threadIds).toEqual(["fresh"]);
+      expect(state.isLoading).toBe(false);
+    });
+    handle.destroy();
+  });
+
+  it("clears loadingMore when a reload supersedes a hung loadMore", async () => {
+    const adapter = makeAdapter({
+      list: vi
+        .fn()
+        .mockResolvedValueOnce({
+          threads: [
+            { status: "regular" as const, remoteId: "t1", title: "One" },
+          ],
+          nextCursor: "c1",
+        })
+        .mockImplementationOnce(() => new Promise<never>(() => {}))
+        .mockResolvedValueOnce({
+          threads: [
+            { status: "regular" as const, remoteId: "fresh", title: "Fresh" },
+          ],
+        }),
+    });
+    const { handle } = mountList(adapter);
+    const threads = handle.getClient().threads;
+
+    await threads.getLoadThreadsPromise();
+    void threads.loadMore();
+    await threads.reload();
+
+    await vi.waitFor(() => {
+      const state = handle.getClient().threads.getState();
+      expect(state.threadIds).toEqual(["fresh"]);
+      expect(state.isLoadingMore).toBe(false);
+    });
+    handle.destroy();
+  });
+
   it("opens a controlled threadId without echoing it back", async () => {
     const adapter = makeAdapter({
       list: vi.fn(async () => ({
@@ -417,7 +610,7 @@ describe("RemoteThreadList", () => {
     await vi.waitFor(() => {
       expect(handle.getClient().threads.getState().threadIds).toEqual([
         "other",
-        `remote-${localId}`,
+        localId,
       ]);
     });
     expect(handle.getClient().threads.item("main").getState().remoteId).toBe(
@@ -429,6 +622,82 @@ describe("RemoteThreadList", () => {
     handle.destroy();
   });
 
+  it("keeps one slot per remote id across reload and clears it on delete", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({ threads: [] })),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+    await aui.threads.item("main").initialize();
+    const remoteId = `remote-${localId}`;
+    adapter.list = vi.fn(async () => ({
+      threads: [{ status: "regular" as const, remoteId, title: "Mine" }],
+    }));
+    await aui.threads.reload();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual([localId]);
+    });
+
+    await aui.threads.item({ id: remoteId }).delete();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual([]);
+    });
+    expect(() => aui.threads.item({ id: localId }).getState()).toThrow();
+    expect(() => aui.threads.item({ id: remoteId }).getState()).toThrow();
+    handle.destroy();
+  });
+
+  const mountRacedInitialize = async (status: "regular" | "archived") => {
+    const initialize = deferred<{ remoteId: string; externalId: undefined }>();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({ threads: [] })),
+      initialize: vi.fn(() => initialize.promise),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+    const initialization = aui.threads.item("main").initialize();
+
+    adapter.list = vi.fn(async () => ({
+      threads: [{ status, remoteId: "remote-1", title: "Mine" }],
+    }));
+    await aui.threads.reload();
+
+    initialize.resolve({ remoteId: "remote-1", externalId: undefined });
+    await initialization;
+    return { handle, aui, localId };
+  };
+
+  it("collapses a slot the list minted while initialize was in flight", async () => {
+    const { handle, aui, localId } = await mountRacedInitialize("regular");
+
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual([localId]);
+    });
+    expect(aui.threads.item({ id: "remote-1" }).getState().id).toBe(localId);
+
+    await aui.threads.item({ id: "remote-1" }).delete();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual([]);
+    });
+    expect(() => aui.threads.item({ id: localId }).getState()).toThrow();
+    handle.destroy();
+  });
+
+  it("does not leave the collapsed slot in both lists when the race reported it archived", async () => {
+    const { handle, aui, localId } = await mountRacedInitialize("archived");
+
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().threadIds).toEqual([localId]);
+    });
+    expect(aui.threads.getState().archivedThreadIds).toEqual([]);
+    expect(aui.threads.item({ id: "remote-1" }).getState().id).toBe(localId);
+    handle.destroy();
+  });
+
   it("keeps item(main) isRunning after reload remaps the local id", async () => {
     const adapter = makeAdapter({
       list: vi.fn(async () => ({ threads: [] })),
@@ -1170,6 +1439,105 @@ describe("RemoteThreadList", () => {
     handle.destroy();
   });
 
+  it("does not unarchive an archived thread deleted during initialization", async () => {
+    const { adapter, handle, targetId, initialization, initialize } =
+      await mountArchivedInitializingThread();
+    const aui = handle.getClient();
+    flushTapSync(() => aui.threads.switchToThread(targetId));
+    flushTapSync(() => aui.threads.item({ id: targetId }).delete());
+    await vi.waitFor(() => {
+      const state = handle.getClient().threads.getState();
+      expect(state.threadIds).not.toContain(targetId);
+      expect(state.archivedThreadIds).not.toContain(targetId);
+    });
+
+    initialize.resolve({
+      remoteId: `remote-${targetId}`,
+      externalId: undefined,
+    });
+    await initialization;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(adapter.unarchive).not.toHaveBeenCalled();
+    expect(handle.getClient().threads.getState().mainThreadId).toBe("fallback");
+    expect(() =>
+      handle.getClient().threads.item("main").getState(),
+    ).not.toThrow();
+    handle.destroy();
+  });
+
+  it("does not unarchive again when the target became regular during initialization", async () => {
+    const { adapter, handle, targetId, initialization, initialize } =
+      await mountArchivedInitializingThread();
+    const aui = handle.getClient();
+
+    flushTapSync(() => aui.threads.switchToThread(targetId));
+    flushTapSync(() => aui.threads.item({ id: targetId }).unarchive());
+    await vi.waitFor(() => {
+      expect(
+        handle.getClient().threads.item({ id: targetId }).getState().status,
+      ).toBe("regular");
+    });
+
+    initialize.resolve({
+      remoteId: `remote-${targetId}`,
+      externalId: undefined,
+    });
+    await initialization;
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).toBe(targetId);
+    });
+
+    expect(adapter.unarchive).toHaveBeenCalledTimes(1);
+    expect(adapter.unarchive).toHaveBeenCalledWith(`remote-${targetId}`);
+    handle.destroy();
+  });
+
+  it("keeps item(main) resolvable when deleting an archived thread during unarchive", async () => {
+    const unarchive = deferred<void>();
+    const onSwitchToThread = vi.fn();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "archived" as const, remoteId: "t1", title: "One" },
+        ],
+      })),
+      unarchive: vi.fn(() => unarchive.promise),
+    });
+    const { handle } = mountList(
+      adapter,
+      undefined,
+      undefined,
+      onSwitchToThread,
+    );
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    const initialMainThreadId = aui.threads.getState().mainThreadId;
+
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(adapter.unarchive).toHaveBeenCalledWith("t1");
+    });
+    flushTapSync(() => aui.threads.item({ id: "t1" }).delete());
+    await vi.waitFor(() => {
+      const state = handle.getClient().threads.getState();
+      expect(state.threadIds).not.toContain("t1");
+      expect(state.archivedThreadIds).not.toContain("t1");
+    });
+
+    unarchive.resolve();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(handle.getClient().threads.getState().mainThreadId).toBe(
+      initialMainThreadId,
+    );
+    expect(() =>
+      handle.getClient().threads.item("main").getState(),
+    ).not.toThrow();
+    expect(onSwitchToThread).not.toHaveBeenCalled();
+    handle.destroy();
+  });
+
   it("keeps item(main) resolvable when deleting a thread mid-initialize", async () => {
     const initialize = deferred<{
       remoteId: string;