@assistant-ui/core 0.3.13 → 0.3.14

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

@@ -0,0 +1,1026 @@
+import { useState } from "react";
+import { describe, expect, it, vi } from "vitest";
+import { flushTapSync, resource, withKey } from "@assistant-ui/tap";
+import { useAui } from "@assistant-ui/store";
+import {
+  AuiConfig,
+  createAssistantClient,
+  type AssistantConfigSource,
+} from "@assistant-ui/store/client";
+import type { ThreadHistoryAdapter } from "../../adapters/thread-history";
+import type { RemoteThreadListAdapter } from "../../runtimes/remote-thread-list/types";
+import {
+  useRuntimeAdapters,
+  type RuntimeAdapters,
+} from "../runtimes/RuntimeAdapterProvider";
+import { RemoteThreadList } from "./RemoteThreadList";
+
+const stubComposer = { getState: () => ({}) };
+const stubSuggestions = { getState: () => ({ suggestions: [] }) };
+
+const deferred = <T>() => {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
+
+const useStubThread = (props: {
+  threadId: string;
+  refetch?: (() => Promise<void>) | undefined;
+  isRunning?: boolean | undefined;
+}) => ({
+  getState: () => ({
+    isRunning: props.isRunning === true,
+    messages: [],
+  }),
+  composer: () => stubComposer,
+  suggestions: () => stubSuggestions,
+  unstable_refetchThread: props.refetch,
+});
+const StubThread = resource(useStubThread);
+
+const dummyHistory = (): ThreadHistoryAdapter => ({
+  load: async () => ({ messages: [] }),
+  append: async () => {},
+});
+
+const useHistoryAdapters = (history: ThreadHistoryAdapter) => () => ({
+  history,
+});
+
+const useCapturingThread = (props: {
+  threadId: string;
+  capture: { adapters: RuntimeAdapters | null };
+}) => {
+  props.capture.adapters = useRuntimeAdapters();
+  return useStubThread(props);
+};
+const CapturingThread = resource(useCapturingThread);
+
+const useCountingThread = (props: {
+  threadId: string;
+  mounts: { n: number };
+}) => {
+  useState(() => {
+    props.mounts.n += 1;
+    return props.mounts.n;
+  });
+  return useStubThread(props);
+};
+const CountingThread = resource(useCountingThread);
+
+const useHistoryLoadingThread = (props: { threadId: string }) => {
+  const adapters = useRuntimeAdapters();
+  useState(() => {
+    void adapters?.history?.load();
+    return true;
+  });
+  return useStubThread(props);
+};
+const HistoryLoadingThread = resource(useHistoryLoadingThread);
+
+const makeAdapter = (
+  overrides: Partial<RemoteThreadListAdapter> = {},
+): RemoteThreadListAdapter => ({
+  list: vi.fn(async () => ({ threads: [] })),
+  initialize: vi.fn(async (threadId: string) => ({
+    remoteId: `remote-${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({
+        start(controller) {
+          controller.close();
+        },
+      }) as never,
+  ),
+  fetch: vi.fn(async (id: string) => ({
+    status: "regular" as const,
+    remoteId: id,
+    externalId: undefined,
+    title: id,
+  })),
+  ...overrides,
+});
+
+const mountList = (
+  adapter: RemoteThreadListAdapter,
+  threadId?: string,
+  refetch?: () => Promise<void>,
+  onSwitchToThread?: (id: string) => void,
+) => {
+  const onThreadIdChange = vi.fn();
+  const handle = createAssistantClient(
+    AuiConfig({
+      threads: RemoteThreadList({
+        adapter,
+        thread: (id) => StubThread({ threadId: id, refetch }) as never,
+        threadId,
+        onThreadIdChange,
+        onSwitchToThread,
+      }),
+    }),
+  );
+  handle.subscribe(() => {});
+  return { handle, onThreadIdChange };
+};
+
+describe("RemoteThreadList", () => {
+  it("loads adapter threads on a standalone client", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "regular" as const, remoteId: "t1", title: "One" },
+          { status: "archived" as const, remoteId: "t2", title: "Two" },
+        ],
+      })),
+    });
+    const { handle } = mountList(adapter);
+    await handle.getClient().threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      const state = handle.getClient().threads.getState();
+      expect(state.threadIds).toEqual(["t1"]);
+      expect(state.archivedThreadIds).toEqual(["t2"]);
+      expect(state.isLoading).toBe(false);
+    });
+    const state = handle.getClient().threads.getState();
+    expect(adapter.list).toHaveBeenCalledOnce();
+    expect(state.newThreadId).toMatch(/^__LOCALID_/);
+    expect(state.mainThreadId).toBe(state.newThreadId);
+    handle.destroy();
+  });
+
+  it("switches away when unarchiving the main thread fails", async () => {
+    const error = new Error("unarchive failed");
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "archived" as const, remoteId: "t1", title: "One" },
+        ],
+      })),
+      unarchive: vi.fn(async () => {
+        throw error;
+      }),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().archivedThreadIds).toEqual(["t1"]);
+    });
+
+    flushTapSync(() =>
+      aui.threads.item({ id: "t1" }).switchTo({ unarchive: false }),
+    );
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+
+    await expect(aui.threads.item({ id: "t1" }).unarchive()).rejects.toBe(
+      error,
+    );
+    expect(aui.threads.item({ id: "t1" }).getState().status).toBe("archived");
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).not.toBe("t1");
+    });
+    handle.destroy();
+  });
+
+  it("restores an initialized draft's archived thread when unarchive fails", async () => {
+    const error = new Error("unarchive failed");
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          { status: "archived" as const, remoteId: "t1", title: "One" },
+        ],
+      })),
+      unarchive: vi.fn(async () => {
+        throw error;
+      }),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().archivedThreadIds).toContain("t1");
+    });
+    await aui.threads.item("main").initialize();
+
+    flushTapSync(() =>
+      aui.threads.item({ id: "t1" }).switchTo({ unarchive: false }),
+    );
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).toBe("t1");
+    });
+
+    await expect(aui.threads.item({ id: "t1" }).unarchive()).rejects.toBe(
+      error,
+    );
+    await vi.waitFor(() => {
+      expect(aui.threads.getState().mainThreadId).not.toBe("t1");
+    });
+    expect(aui.threads.item({ id: "t1" }).getState().status).toBe("archived");
+    expect(aui.threads.getState().archivedThreadIds).toContain("t1");
+    expect(aui.threads.getState().threadIds).not.toContain("t1");
+    handle.destroy();
+  });
+
+  it("switches to a listed thread and back to a new thread", 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();
+
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+    });
+
+    flushTapSync(() => handle.getClient().threads.switchToNewThread());
+    const afterNew = handle.getClient().threads.getState();
+    expect(afterNew.mainThreadId).toBe(afterNew.newThreadId);
+    expect(afterNew.threadIds).toContain("t1");
+    handle.destroy();
+  });
+
+  it("initializes a new thread through the adapter", async () => {
+    const adapter = makeAdapter();
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+
+    const result = await aui.threads.item("main").initialize();
+    expect(adapter.initialize).toHaveBeenCalledWith(localId);
+    expect(result.remoteId).toBe(`remote-${localId}`);
+    await vi.waitFor(() => {
+      const state = handle.getClient().threads.getState();
+      expect(state.threadIds).toContain(localId);
+      expect(state.newThreadId).toBeNull();
+      expect(handle.getClient().threads.item("main").getState().remoteId).toBe(
+        `remote-${localId}`,
+      );
+    });
+    handle.destroy();
+  });
+
+  it("fetches an unknown thread id on switch", async () => {
+    const adapter = makeAdapter();
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+
+    flushTapSync(() => aui.threads.switchToThread("missing"));
+    await vi.waitFor(() => {
+      expect(adapter.fetch).toHaveBeenCalledWith("missing");
+      expect(handle.getClient().threads.getState().mainThreadId).toBe(
+        "missing",
+      );
+      expect(handle.getClient().threads.getState().threadIds).toContain(
+        "missing",
+      );
+    });
+    handle.destroy();
+  });
+
+  it("renames and deletes through the adapter", 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(handle.getClient().threads.getState().threadIds).toEqual(["t1"]);
+    });
+
+    flushTapSync(() =>
+      handle.getClient().threads.item({ id: "t1" }).rename("Renamed"),
+    );
+    await vi.waitFor(() => {
+      expect(adapter.rename).toHaveBeenCalledWith("t1", "Renamed");
+      expect(
+        handle.getClient().threads.item({ id: "t1" }).getState().title,
+      ).toBe("Renamed");
+    });
+
+    const draftId = handle.getClient().threads.getState().mainThreadId;
+    flushTapSync(() => handle.getClient().threads.item({ id: "t1" }).delete());
+    await vi.waitFor(() => {
+      expect(adapter.delete).toHaveBeenCalledWith("t1");
+      expect(handle.getClient().threads.getState().threadIds).not.toContain(
+        "t1",
+      );
+      expect(handle.getClient().threads.getState().mainThreadId).toBe(draftId);
+    });
+    handle.destroy();
+  });
+
+  it("opens a controlled threadId without echoing it back", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    const { handle, onThreadIdChange } = mountList(adapter, "t1");
+    await handle.getClient().threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+    });
+    expect(onThreadIdChange).not.toHaveBeenCalled();
+    handle.destroy();
+  });
+
+  it("keeps the latest switch when an earlier fetch resolves last", async () => {
+    const fetchB = deferred<{
+      status: "regular";
+      remoteId: string;
+      externalId: undefined;
+      title: string;
+    }>();
+    const fetchC = deferred<{
+      status: "regular";
+      remoteId: string;
+      externalId: undefined;
+      title: string;
+    }>();
+    const adapter = makeAdapter({
+      fetch: vi.fn((id: string) =>
+        id === "thread-b" ? fetchB.promise : fetchC.promise,
+      ),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+
+    flushTapSync(() => aui.threads.switchToThread("thread-b"));
+    flushTapSync(() => aui.threads.switchToThread("thread-c"));
+    fetchC.resolve({
+      status: "regular",
+      remoteId: "thread-c",
+      externalId: undefined,
+      title: "thread-c",
+    });
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).toBe(
+        "thread-c",
+      );
+    });
+    fetchB.resolve({
+      status: "regular",
+      remoteId: "thread-b",
+      externalId: undefined,
+      title: "thread-b",
+    });
+    await vi.waitFor(() => {
+      expect(adapter.fetch).toHaveBeenCalledWith("thread-b");
+    });
+    expect(handle.getClient().threads.getState().mainThreadId).toBe("thread-c");
+    handle.destroy();
+  });
+
+  it("resolves item(main) after reload without aliasing another thread", 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();
+    adapter.list = vi.fn(async () => ({
+      threads: [
+        { status: "regular" as const, remoteId: "other", title: "Other" },
+        {
+          status: "regular" as const,
+          remoteId: `remote-${localId}`,
+          title: "Mine",
+        },
+      ],
+    }));
+    await handle.getClient().threads.reload();
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().threadIds).toEqual([
+        "other",
+        `remote-${localId}`,
+      ]);
+    });
+    expect(handle.getClient().threads.item("main").getState().remoteId).toBe(
+      `remote-${localId}`,
+    );
+    expect(handle.getClient().threads.item("main").getState().title).toBe(
+      "Mine",
+    );
+    handle.destroy();
+  });
+
+  it("keeps item(main) isRunning after reload remaps the local id", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({ threads: [] })),
+    });
+    const handle = createAssistantClient(
+      AuiConfig({
+        threads: RemoteThreadList({
+          adapter,
+          thread: (id) =>
+            StubThread({ threadId: id, isRunning: true }) as never,
+        }),
+      }),
+    );
+    handle.subscribe(() => {});
+    await handle.getClient().threads.getLoadThreadsPromise();
+    const localId = handle.getClient().threads.getState().mainThreadId;
+    await handle.getClient().threads.item("main").initialize();
+    adapter.list = vi.fn(async () => ({
+      threads: [
+        {
+          status: "regular" as const,
+          remoteId: `remote-${localId}`,
+          title: "Mine",
+        },
+      ],
+    }));
+    await handle.getClient().threads.reload();
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.item("main").getState().remoteId).toBe(
+        `remote-${localId}`,
+      );
+    });
+    expect(handle.getClient().threads.item("main").getState().isRunning).toBe(
+      true,
+    );
+    handle.destroy();
+  });
+
+  it("switches away when deleting the remapped main thread by remote id", 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 handle.getClient().threads.reload();
+    await vi.waitFor(() => {
+      expect(
+        handle.getClient().threads.item({ id: remoteId }).getState().remoteId,
+      ).toBe(remoteId);
+    });
+    flushTapSync(() =>
+      handle.getClient().threads.item({ id: remoteId }).delete(),
+    );
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).not.toBe(
+        localId,
+      );
+      expect(handle.getClient().threads.getState().threadIds).not.toContain(
+        remoteId,
+      );
+    });
+    expect(() =>
+      handle.getClient().threads.item("main").getState(),
+    ).not.toThrow();
+    handle.destroy();
+  });
+
+  it("does not reload when the adapter object is recreated", async () => {
+    const methods = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    let adapter: RemoteThreadListAdapter = { ...methods };
+    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();
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().threadIds).toEqual(["t1"]);
+    });
+    expect(methods.list).toHaveBeenCalledTimes(1);
+    adapter = { ...methods };
+    for (const listener of listeners) listener();
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().threadIds).toEqual(["t1"]);
+    });
+    expect(methods.list).toHaveBeenCalledTimes(1);
+    handle.destroy();
+  });
+
+  it("exposes useAdapters adapters to the thread factory", async () => {
+    const history = dummyHistory();
+    const capture: { adapters: RuntimeAdapters | null } = { adapters: null };
+    const adapter = makeAdapter({
+      unstable_useAdapters: useHistoryAdapters(history),
+    });
+    const handle = createAssistantClient(
+      AuiConfig({
+        threads: RemoteThreadList({
+          adapter,
+          thread: (id) => CapturingThread({ threadId: id, capture }) as never,
+        }),
+      }),
+    );
+    handle.subscribe(() => {});
+    await handle.getClient().threads.getLoadThreadsPromise();
+    expect(capture.adapters?.history).toBe(history);
+    handle.destroy();
+  });
+
+  it("does not warn when useAdapters is supplied and the factory is keyed", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const adapter = makeAdapter({
+        unstable_Provider: () => null,
+        unstable_useAdapters: useHistoryAdapters(dummyHistory()),
+      });
+      const handle = createAssistantClient(
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => withKey(id, StubThread({ threadId: id }) as never),
+          }),
+        }),
+      );
+      handle.subscribe(() => {});
+      await handle.getClient().threads.getLoadThreadsPromise();
+      flushTapSync(() => {});
+      expect(warn).not.toHaveBeenCalled();
+      handle.destroy();
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("warns when Provider is supplied without useAdapters", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const adapter = makeAdapter({
+        unstable_Provider: () => null,
+      });
+      const { handle } = mountList(adapter);
+      await handle.getClient().threads.getLoadThreadsPromise();
+      expect(warn).toHaveBeenCalledWith(
+        expect.stringContaining("unstable_useAdapters"),
+      );
+      handle.destroy();
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("warns when a history adapter arrives with an unkeyed thread factory", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const adapter = makeAdapter({
+        unstable_useAdapters: useHistoryAdapters(dummyHistory()),
+      });
+      const handle = createAssistantClient(
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => StubThread({ threadId: id }) as never,
+          }),
+        }),
+      );
+      handle.subscribe(() => {});
+      await handle.getClient().threads.getLoadThreadsPromise();
+      flushTapSync(() => {});
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining("unkeyed"));
+      handle.destroy();
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("picks up a swapped useAdapters hook on a config update", async () => {
+    const firstHistory = dummyHistory();
+    const secondHistory = dummyHistory();
+    const capture: { adapters: RuntimeAdapters | null } = { adapters: null };
+    let adapter = makeAdapter({
+      unstable_useAdapters: useHistoryAdapters(firstHistory),
+    });
+    const listeners = new Set<() => void>();
+    const source: AssistantConfigSource = {
+      getConfig: () =>
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => CapturingThread({ threadId: id, capture }) as never,
+          }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      },
+    };
+    const handle = createAssistantClient(source);
+    handle.subscribe(() => {});
+    await handle.getClient().threads.getLoadThreadsPromise();
+    expect(capture.adapters?.history).toBe(firstHistory);
+    adapter = makeAdapter({
+      unstable_useAdapters: useHistoryAdapters(secondHistory),
+    });
+    for (const listener of listeners) listener();
+    await vi.waitFor(() => {
+      expect(capture.adapters?.history).toBe(secondHistory);
+    });
+    handle.destroy();
+  });
+
+  it("lets useAdapters read the assistant client via useAui after mount", async () => {
+    const seen: { aui: ReturnType<typeof useAui> | null } = { aui: null };
+    const adapter = makeAdapter({
+      unstable_useAdapters: function useAdapters() {
+        seen.aui = useAui();
+        return { history: dummyHistory() };
+      },
+    });
+    const { handle } = mountList(adapter);
+    await handle.getClient().threads.getLoadThreadsPromise();
+    expect(seen.aui?.threadListItem.getState().id).toBe(
+      handle.getClient().threads.getState().mainThreadId,
+    );
+    handle.destroy();
+  });
+
+  it("does not remount useAdapters when switching an unkeyed thread", async () => {
+    let mounts = 0;
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+      unstable_useAdapters: function useAdapters() {
+        useState(() => {
+          mounts += 1;
+          return mounts;
+        });
+        return { history: dummyHistory() };
+      },
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    const afterLoad = mounts;
+    expect(afterLoad).toBeGreaterThan(0);
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+    });
+    expect(mounts).toBe(afterLoad);
+    handle.destroy();
+  });
+
+  it("keeps unkeyed thread mount count independent of useAdapters", async () => {
+    const run = async (
+      mounts: { n: number },
+      useAdapters?: RemoteThreadListAdapter["unstable_useAdapters"],
+    ) => {
+      const adapter = makeAdapter({
+        list: vi.fn(async () => ({
+          threads: [
+            { status: "regular" as const, remoteId: "t1", title: "One" },
+          ],
+        })),
+        unstable_useAdapters: useAdapters,
+      });
+      const handle = createAssistantClient(
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => CountingThread({ threadId: id, mounts }) as never,
+          }),
+        }),
+      );
+      handle.subscribe(() => {});
+      const aui = handle.getClient();
+      await aui.threads.getLoadThreadsPromise();
+      flushTapSync(() => aui.threads.switchToThread("t1"));
+      await vi.waitFor(() => {
+        expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+      });
+      handle.destroy();
+    };
+    const withoutHook = { n: 0 };
+    const withHook = { n: 0 };
+    await run(withoutHook);
+    await run(withHook, useHistoryAdapters(dummyHistory()));
+    expect(withHook.n).toBe(withoutHook.n);
+  });
+
+  it("forwards a caller key onto the useAdapters wrapper", async () => {
+    const run = async (
+      mounts: { n: number },
+      useAdapters?: RemoteThreadListAdapter["unstable_useAdapters"],
+    ) => {
+      const adapter = makeAdapter({
+        list: vi.fn(async () => ({
+          threads: [
+            { status: "regular" as const, remoteId: "t1", title: "One" },
+          ],
+        })),
+        unstable_useAdapters: useAdapters,
+      });
+      const handle = createAssistantClient(
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) =>
+              withKey(id, CountingThread({ threadId: id, mounts }) as never),
+          }),
+        }),
+      );
+      handle.subscribe(() => {});
+      const aui = handle.getClient();
+      await aui.threads.getLoadThreadsPromise();
+      flushTapSync(() => aui.threads.switchToThread("t1"));
+      await vi.waitFor(() => {
+        expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+      });
+      handle.destroy();
+    };
+    const withoutHook = { n: 0 };
+    const withHook = { n: 0 };
+    await run(withoutHook);
+    await run(withHook, useHistoryAdapters(dummyHistory()));
+    expect(withHook.n).toBe(withoutHook.n);
+    expect(withHook.n).toBeGreaterThan(1);
+  });
+
+  it("loads history for the second thread when the factory is keyed", async () => {
+    const load = vi.fn(async () => ({ messages: [] }));
+    const history: ThreadHistoryAdapter = {
+      load,
+      append: 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" },
+        ],
+      })),
+      unstable_useAdapters: useHistoryAdapters(history),
+    });
+    const handle = createAssistantClient(
+      AuiConfig({
+        threads: RemoteThreadList({
+          adapter,
+          thread: (id) =>
+            withKey(id, HistoryLoadingThread({ threadId: id }) as never),
+          threadId: "t1",
+        }),
+      }),
+    );
+    handle.subscribe(() => {});
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    await vi.waitFor(() => {
+      expect(load).toHaveBeenCalled();
+    });
+    const afterFirst = load.mock.calls.length;
+    flushTapSync(() => aui.threads.switchToThread("t2"));
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).toBe("t2");
+    });
+    await vi.waitFor(() => {
+      expect(load.mock.calls.length).toBeGreaterThan(afterFirst);
+    });
+    handle.destroy();
+  });
+
+  it("does not re-emit onSwitchToNewThread when the draft is already main", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    const listeners = new Set<() => void>();
+    let threadId: string | undefined = "t1";
+    const onSwitchToNewThread = vi.fn();
+    const source: AssistantConfigSource = {
+      getConfig: () =>
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => StubThread({ threadId: id }) as never,
+            threadId,
+            onThreadIdChange: (id) => {
+              threadId = id;
+              for (const listener of listeners) listener();
+            },
+            onSwitchToNewThread,
+          }),
+        }),
+      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().mainThreadId).toBe("t1");
+    });
+    flushTapSync(() => handle.getClient().threads.switchToNewThread());
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).not.toBe("t1");
+    });
+    expect(onSwitchToNewThread).toHaveBeenCalledTimes(1);
+    handle.destroy();
+  });
+
+  it("does not refetch a draft from reloadMainThread", async () => {
+    const refetch = vi.fn(async () => {});
+    const { handle } = mountList(makeAdapter(), undefined, refetch);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    expect(aui.threads.item("main").getState().status).toBe("new");
+    await aui.threads.reloadMainThread();
+    expect(refetch).not.toHaveBeenCalled();
+    handle.destroy();
+  });
+
+  it("keeps the selected thread when config callbacks are recreated", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    const listeners = new Set<() => void>();
+    let onThreadIdChange = vi.fn();
+    const source: AssistantConfigSource = {
+      getConfig: () =>
+        AuiConfig({
+          threads: RemoteThreadList({
+            adapter,
+            thread: (id) => StubThread({ threadId: id }) as never,
+            onThreadIdChange,
+          }),
+        }),
+      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("t1"));
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+    });
+    onThreadIdChange = vi.fn();
+    for (const listener of listeners) listener();
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+    });
+    expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+    handle.destroy();
+  });
+
+  it("does not re-emit onSwitchToThread for the already selected thread", async () => {
+    const onSwitchToThread = vi.fn();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [{ status: "regular" as const, remoteId: "t1", title: "One" }],
+      })),
+    });
+    const { handle } = mountList(
+      adapter,
+      undefined,
+      undefined,
+      onSwitchToThread,
+    );
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    flushTapSync(() => aui.threads.switchToThread("t1"));
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+    });
+    onSwitchToThread.mockClear();
+    flushTapSync(() => handle.getClient().threads.switchToThread("t1"));
+    expect(onSwitchToThread).not.toHaveBeenCalled();
+    handle.destroy();
+  });
+
+  it("keeps item(main) resolvable after a same-tick switch then delete", 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(handle.getClient().threads.getState().threadIds).toEqual(["t1"]);
+    });
+    flushTapSync(() => {
+      handle.getClient().threads.switchToThread("t1");
+      handle.getClient().threads.item({ id: "t1" }).delete();
+    });
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().threadIds).not.toContain(
+        "t1",
+      );
+    });
+    expect(handle.getClient().threads.getState().mainThreadId).not.toBe("t1");
+    expect(() =>
+      handle.getClient().threads.item("main").getState(),
+    ).not.toThrow();
+    handle.destroy();
+  });
+
+  it("keeps item(main) resolvable when deleting a thread mid-initialize", async () => {
+    const initialize = deferred<{
+      remoteId: string;
+      externalId: undefined;
+    }>();
+    const adapter = makeAdapter({
+      initialize: vi.fn(() => initialize.promise),
+    });
+    const { handle } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+    const pending = aui.threads.item("main").initialize();
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.item("main").getState().status).toBe(
+        "regular",
+      );
+    });
+    flushTapSync(() =>
+      handle.getClient().threads.item({ id: localId }).delete(),
+    );
+    initialize.resolve({
+      remoteId: `remote-${localId}`,
+      externalId: undefined,
+    });
+    await vi.waitFor(() => {
+      expect(handle.getClient().threads.getState().mainThreadId).not.toBe(
+        localId,
+      );
+    });
+    expect(() =>
+      handle.getClient().threads.item("main").getState(),
+    ).not.toThrow();
+    await pending;
+    handle.destroy();
+  });
+
+  it("emits onThreadIdChange after initialize settles", async () => {
+    const adapter = makeAdapter();
+    const { handle, onThreadIdChange } = mountList(adapter);
+    const aui = handle.getClient();
+    await aui.threads.getLoadThreadsPromise();
+    const localId = aui.threads.getState().mainThreadId;
+    await aui.threads.item("main").initialize();
+    await vi.waitFor(() => {
+      expect(onThreadIdChange).toHaveBeenCalledWith(`remote-${localId}`);
+    });
+    handle.destroy();
+  });
+});