@assistant-ui/core 0.3.14 → 0.3.16

package/src/tests/external-thread-attachments.test.tsx

@@ -582,3 +582,176 @@ describe("ExternalThread attachments", () => {
     vi.restoreAllMocks();
   });
 });
+
+describe("cancelled edit sessions", () => {
+  const editSetup = (
+    add: (arg: { file: File }) => Promise<PendingAttachment>,
+  ) =>
+    renderThreadWithProps({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      onEdit: () => {},
+      attachmentAdapter: {
+        accept: "*",
+        add,
+        send: async () => ({}) as never,
+        remove: async () => {},
+      },
+    });
+
+  it("does not leak an in-flight add into the next edit session", async () => {
+    let resolveAdd!: (attachment: PendingAttachment) => void;
+    const aui = editSetup(
+      () =>
+        new Promise<PendingAttachment>((resolve) => {
+          resolveAdd = resolve;
+        }),
+    );
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => {
+      composer().beginEdit();
+    });
+    let addPromise!: Promise<void>;
+    await act(async () => {
+      addPromise = composer().addAttachment(
+        new File(["data"], "notes.txt", { type: "text/plain" }),
+      );
+    });
+    await act(async () => {
+      composer().cancel();
+    });
+    await act(async () => {
+      composer().beginEdit();
+    });
+    await act(async () => {
+      resolveAdd({
+        id: "leak-1",
+        type: "document",
+        name: "notes.txt",
+        contentType: "text/plain",
+        file: new File(["data"], "notes.txt", { type: "text/plain" }),
+        status: { type: "pending", reason: "uploading", progress: 0 },
+      } as PendingAttachment);
+      await addPromise.catch(() => {});
+    });
+
+    expect(composer().getState().attachments).toEqual([]);
+  });
+
+  it("adapter-removes the session's pending attachments on cancel, sparing prefilled ones", async () => {
+    const remove = vi.fn(async () => {});
+    const aui = renderThreadWithProps({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [
+            {
+              id: "prefilled-1",
+              type: "document",
+              name: "existing.txt",
+              contentType: "text/plain",
+              content: [],
+              status: { type: "complete" },
+            } as unknown as CompleteAttachment,
+          ],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      onEdit: () => {},
+      attachmentAdapter: {
+        accept: "*",
+        add: async ({ file }: { file: File }) =>
+          ({
+            id: "pending-1",
+            type: "document",
+            name: file.name,
+            contentType: file.type,
+            file,
+            status: { type: "pending", reason: "uploading", progress: 0 },
+          }) as PendingAttachment,
+        send: async () => ({}) as never,
+        remove,
+      },
+    });
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => {
+      composer().beginEdit();
+    });
+    await act(() =>
+      composer().addAttachment(
+        new File(["data"], "notes.txt", { type: "text/plain" }),
+      ),
+    );
+    expect(composer().getState().attachments).toHaveLength(2);
+
+    await act(async () => {
+      composer().cancel();
+    });
+
+    await waitFor(() => expect(remove).toHaveBeenCalledTimes(1));
+    expect(remove).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "pending-1" }),
+    );
+
+    await act(async () => {
+      composer().cancel();
+    });
+    expect(remove).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps the thread composer's in-flight add across a run cancel", async () => {
+    let resolveAdd!: (attachment: PendingAttachment) => void;
+    const aui = renderThreadWithProps({
+      onNew: () => {},
+      onCancel: () => {},
+      attachmentAdapter: {
+        accept: "*",
+        add: () =>
+          new Promise<PendingAttachment>((resolve) => {
+            resolveAdd = resolve;
+          }),
+        send: async () => ({}) as never,
+        remove: async () => {},
+      },
+    });
+    const composer = () => aui().thread().composer();
+
+    let addPromise!: Promise<void>;
+    await act(async () => {
+      addPromise = composer().addAttachment(
+        new File(["data"], "notes.txt", { type: "text/plain" }),
+      );
+    });
+    await act(async () => {
+      composer().cancel();
+    });
+    await act(async () => {
+      resolveAdd({
+        id: "draft-1",
+        type: "document",
+        name: "notes.txt",
+        contentType: "text/plain",
+        file: new File(["data"], "notes.txt", { type: "text/plain" }),
+        status: { type: "pending", reason: "uploading", progress: 0 },
+      } as PendingAttachment);
+      await addPromise;
+    });
+
+    expect(composer().getState().attachments).toMatchObject([
+      { id: "draft-1" },
+    ]);
+  });
+});

package/src/tests/external-thread-isEmpty.test.tsx

@@ -0,0 +1,100 @@
+// @vitest-environment jsdom
+
+import { render } from "@testing-library/react";
+import type { FC } from "react";
+import { describe, it, expect } from "vitest";
+import { AuiIf, useAui, AuiProvider } from "@assistant-ui/store";
+import {
+  ExternalThread,
+  type ExternalThreadProps,
+} from "../store/clients/external-thread";
+import { useThreadIsEmpty } from "../react/primitive-hooks/useThreadIsEmpty";
+
+const HookProbe: FC = () => (
+  <div data-testid="hook">{useThreadIsEmpty() ? "empty" : "not-empty"}</div>
+);
+
+const renderThread = (props: ExternalThreadProps) => {
+  const captured: { aui?: ReturnType<typeof useAui> } = {};
+  const Capture: FC = () => {
+    captured.aui = useAui();
+    return null;
+  };
+  const App: FC<{ threadProps: ExternalThreadProps }> = ({ threadProps }) => {
+    const aui = useAui({ thread: ExternalThread(threadProps) });
+    return (
+      <AuiProvider value={aui}>
+        <Capture />
+        <HookProbe />
+        <AuiIf condition={(s) => s.thread.isEmpty}>
+          <div data-testid="aui-if">empty</div>
+        </AuiIf>
+      </AuiProvider>
+    );
+  };
+  const utils = render(<App threadProps={props} />);
+  return {
+    state: () => captured.aui!.thread.getState(),
+    hookSaysEmpty: () => utils.getByTestId("hook").textContent === "empty",
+    auiIfRendered: () => utils.queryByTestId("aui-if") !== null,
+    rerender: (next: ExternalThreadProps) =>
+      utils.rerender(<App threadProps={next} />),
+  };
+};
+
+const userMessage = (id: string) =>
+  ({
+    id,
+    role: "user",
+    content: [{ type: "text", text: "hi" }],
+    createdAt: new Date(0),
+    metadata: { custom: {} },
+  }) as unknown as ExternalThreadProps["messages"][number];
+
+describe("ExternalThread isEmpty", () => {
+  it("is empty when there are no messages and nothing is loading", () => {
+    const t = renderThread({ messages: [] });
+    expect(t.state().isEmpty).toBe(true);
+    expect(t.hookSaysEmpty()).toBe(true);
+    expect(t.auiIfRendered()).toBe(true);
+  });
+
+  it("is not empty while the adapter is still loading", () => {
+    const t = renderThread({ messages: [], isLoading: true });
+    expect(t.state().isEmpty).toBe(false);
+  });
+
+  it("does not render empty-state consumers while loading", () => {
+    const t = renderThread({ messages: [], isLoading: true });
+    expect(t.hookSaysEmpty()).toBe(false);
+    expect(t.auiIfRendered()).toBe(false);
+  });
+
+  it("is not empty once messages arrive", () => {
+    const t = renderThread({ messages: [userMessage("m1")] });
+    expect(t.state().isEmpty).toBe(false);
+  });
+
+  it("becomes empty when loading finishes with no messages", () => {
+    const t = renderThread({ messages: [], isLoading: true });
+    expect(t.state().isEmpty).toBe(false);
+    expect(t.auiIfRendered()).toBe(false);
+
+    t.rerender({ messages: [], isLoading: false });
+
+    expect(t.state().isEmpty).toBe(true);
+    expect(t.hookSaysEmpty()).toBe(true);
+    expect(t.auiIfRendered()).toBe(true);
+  });
+
+  it("stays non-empty when loading finishes with messages", () => {
+    const t = renderThread({ messages: [], isLoading: true });
+    expect(t.state().isEmpty).toBe(false);
+
+    t.rerender({ messages: [userMessage("m1")], isLoading: false });
+
+    expect(t.state().isEmpty).toBe(false);
+    expect(t.hookSaysEmpty()).toBe(false);
+    expect(t.auiIfRendered()).toBe(false);
+  });
+});

package/src/tests/remote-thread-list-adapter-switch.test.ts

@@ -0,0 +1,383 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+  setStartThreadRuntime,
+} from "./remote-thread-list-test-helpers";
+
+const thread = (remoteId: string) => ({
+  remoteId,
+  externalId: remoteId,
+  status: "regular" as const,
+  title: remoteId,
+});
+
+describe("RemoteThreadList adapter changes", () => {
+  it("clears the selected thread and cached data from the previous adapter", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const listAdapterB = vi.fn(async () => ({
+      threads: [thread("thread-b")],
+    }));
+    const adapterB = makeAdapter({ list: listAdapterB });
+    const core = createCore(adapterA);
+    const started: string[] = [];
+    setStartThreadRuntime(core, async (id) => {
+      started.push(id);
+      return {};
+    });
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+    expect(core.getItemById(core.mainThreadId)?.remoteId).toBe("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+
+    await core.getLoadThreadsPromise();
+    expect(listAdapterB).toHaveBeenCalledTimes(1);
+    expect(core.threadIds).toEqual(["thread-b"]);
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(core.getItemById(core.mainThreadId)?.remoteId).not.toBe("thread-a");
+    expect(started).toContain(core.mainThreadId);
+
+    await expect(core.rename("thread-a", "leaked")).rejects.toThrow(
+      'Thread "thread-a" not found',
+    );
+    expect(adapterB.rename).not.toHaveBeenCalled();
+  });
+
+  it("does not resume an old adapter mutation through the new adapter", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter();
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    const runtimeStart = deferred<unknown>();
+    setStartThreadRuntime(core, () => runtimeStart.promise);
+    const archiveTask = core.archive("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    runtimeStart.resolve({});
+
+    await expect(archiveTask).rejects.toThrow("adapter changed");
+    expect(adapterA.archive).not.toHaveBeenCalled();
+    expect(adapterB.archive).not.toHaveBeenCalled();
+  });
+
+  it("preserves an adapter failure that races an adapter change", async () => {
+    const unarchiveRequest = deferred<void>();
+    const adapterA = makeAdapter({
+      list: async () => ({
+        threads: [{ ...thread("thread-a"), status: "archived" as const }],
+      }),
+      unarchive: vi.fn(() => unarchiveRequest.promise),
+    });
+    const adapterB = makeAdapter();
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    const unarchiveTask = core.unarchive("thread-a");
+    await vi.waitFor(() => expect(adapterA.unarchive).toHaveBeenCalledOnce());
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    const failure = new Error("network error");
+    unarchiveRequest.reject(failure);
+
+    await expect(unarchiveTask).rejects.toBe(failure);
+  });
+
+  it("does not apply a late initialize to the replacement adapter state", async () => {
+    const initializeRequest = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [] }),
+      initialize: vi.fn(() => initializeRequest.promise),
+    });
+    const adapterB = makeAdapter();
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    const localId = core.newThreadId;
+    expect(localId).toBeDefined();
+    const initializeTask = core.initialize(localId!);
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    initializeRequest.resolve({
+      remoteId: "leaked",
+      externalId: "leaked",
+    });
+    await expect(initializeTask).rejects.toThrow("adapter changed");
+    expect(core.getItemById("leaked")).toBeUndefined();
+    expect(core.threadIds).not.toContain("leaked");
+
+    await core.getLoadThreadsPromise();
+    expect(core.getItemById(core.mainThreadId)?.status).toBe("new");
+    expect(core.getItemById(core.mainThreadId)?.remoteId).toBeUndefined();
+    await expect(core.initialize(core.mainThreadId)).resolves.toEqual({
+      remoteId: core.mainThreadId,
+      externalId: core.mainThreadId,
+    });
+  });
+
+  it("selects a controlled thread that arrives on the replacement page", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+    });
+    const core = createCore(adapterA, "thread-a");
+
+    await core.getLoadThreadsPromise();
+    core.__internal_load();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+      threadId: "thread-b",
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.getItemById(core.mainThreadId)?.remoteId).toBe("thread-b");
+  });
+
+  it("keeps the unsent draft runtime across an empty-list adapter swap", async () => {
+    const adapterA = makeAdapter();
+    const adapterB = makeAdapter();
+    const core = createCore(adapterA);
+    const stopped: string[] = [];
+    const hookManager = (
+      core as unknown as {
+        _hookManager: { stopThreadRuntime: (id: string) => void };
+      }
+    )._hookManager;
+    const originalStop = hookManager.stopThreadRuntime.bind(hookManager);
+    hookManager.stopThreadRuntime = (id: string) => {
+      stopped.push(id);
+      originalStop(id);
+    };
+
+    await core.getLoadThreadsPromise();
+    const draftId = core.mainThreadId;
+    expect(core.getItemById(draftId)?.status).toBe("new");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.mainThreadId).toBe(draftId);
+    expect(core.getItemById(draftId)?.status).toBe("new");
+    expect(stopped).not.toContain(draftId);
+  });
+
+  it("stops runtimes for threads missing from the replacement list", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+    });
+    const core = createCore(adapterA);
+    const stopped: string[] = [];
+    const hookManager = (
+      core as unknown as {
+        _hookManager: { stopThreadRuntime: (id: string) => void };
+      }
+    )._hookManager;
+    const originalStop = hookManager.stopThreadRuntime.bind(hookManager);
+    hookManager.stopThreadRuntime = (id: string) => {
+      stopped.push(id);
+      originalStop(id);
+    };
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(stopped).toContain("thread-a");
+    expect(stopped).not.toContain(core.mainThreadId);
+  });
+
+  it("does not reject when a controlled thread is missing from the replacement adapter", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+      fetch: vi.fn(async () => {
+        throw new Error("not found");
+      }),
+    });
+    const core = createCore(adapterA, "thread-a");
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+      threadId: "thread-a",
+    });
+    await expect(core.getLoadThreadsPromise()).resolves.toBeUndefined();
+    await vi.waitFor(() => {
+      expect(adapterB.fetch).toHaveBeenCalledWith("thread-a");
+    });
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(core.getItemById(core.mainThreadId)?.status).toBe("new");
+  });
+
+  it("reuses the preserved unsent draft when the selected thread is missing after swap", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+    });
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    const draftId = core.newThreadId;
+    expect(draftId).toBeDefined();
+    await core.switchToThread("thread-a");
+    expect(core.mainThreadId).toBe("thread-a");
+    expect(core.newThreadId).toBe(draftId);
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.mainThreadId).toBe(draftId);
+    expect(core.newThreadId).toBe(draftId);
+    expect(core.getItemById(draftId!)?.status).toBe("new");
+    expect(
+      Object.values(core.threadItems).filter((item) => item.status === "new"),
+    ).toHaveLength(1);
+  });
+
+  it("does not send a rename through the replacement adapter while its list is pending", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const listB = deferred<{ threads: ReturnType<typeof thread>[] }>();
+    const adapterB = makeAdapter({
+      list: vi.fn(() => listB.promise),
+    });
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await expect(core.rename("thread-a", "leaked")).rejects.toThrow(
+      "adapter changed",
+    );
+    await expect(core.switchToThread("thread-a")).rejects.toThrow(
+      "adapter changed",
+    );
+    expect(adapterB.rename).not.toHaveBeenCalled();
+
+    listB.resolve({ threads: [thread("thread-b")] });
+    await core.getLoadThreadsPromise();
+    expect(adapterB.rename).not.toHaveBeenCalled();
+    expect(core.getItemById("thread-a")).toBeUndefined();
+  });
+
+  it("does not freeze mutations when the replacement list fails", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: vi.fn(async () => {
+        throw new Error("network");
+      }),
+    });
+    const core = createCore(adapterA);
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(core.getItemById(core.mainThreadId)?.status).toBe("new");
+    await expect(core.switchToNewThread()).resolves.toBeUndefined();
+    expect(consoleError).toHaveBeenCalled();
+    consoleError.mockRestore();
+  });
+
+  it("keeps a thread initialized while the replacement list is pending", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const listB = deferred<{ threads: ReturnType<typeof thread>[] }>();
+    const adapterB = makeAdapter({
+      list: vi.fn(() => listB.promise),
+      initialize: vi.fn(async () => ({
+        remoteId: "created-on-b",
+        externalId: "created-on-b",
+      })),
+    });
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    const draftId = core.newThreadId;
+    expect(draftId).toBeDefined();
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await expect(core.initialize(draftId!)).resolves.toEqual({
+      remoteId: "created-on-b",
+      externalId: "created-on-b",
+    });
+
+    listB.resolve({ threads: [thread("thread-b")] });
+    await core.getLoadThreadsPromise();
+
+    expect(core.getItemById(draftId!)?.remoteId).toBe("created-on-b");
+    expect(core.mainThreadId).toBe(draftId);
+    expect(core.threadIds).toContain("created-on-b");
+  });
+});

package/src/tests/single-thread-list-item.test.tsx

@@ -0,0 +1,47 @@
+// @vitest-environment jsdom
+
+import { cleanup, render } from "@testing-library/react";
+import type { FC } from "react";
+import { afterEach, describe, expect, it } from "vitest";
+import { AuiProvider, useAui } from "@assistant-ui/store";
+import { ExternalThread } from "../store/clients/external-thread";
+import { SingleThreadList } from "../store/clients/single-thread-list";
+
+let aui!: ReturnType<typeof useAui>;
+
+const Capture: FC = () => {
+  aui = useAui();
+  return null;
+};
+
+const App: FC = () => {
+  const value = useAui({
+    threads: SingleThreadList({ thread: ExternalThread({ messages: [] }) }),
+  });
+  return (
+    <AuiProvider value={value}>
+      <Capture />
+    </AuiProvider>
+  );
+};
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("SingleThreadList item selectors", () => {
+  it("resolves index selectors within the regular subset only", () => {
+    render(<App />);
+
+    const mainId = aui.threads.item("main").getState().id;
+    expect(aui.threads.item({ index: 0 }).getState().id).toBe(mainId);
+    expect(aui.threads.item({ index: 0, archived: false }).getState().id).toBe(
+      mainId,
+    );
+
+    expect(aui.threads.getState().archivedThreadIds).toEqual([]);
+    expect(() => aui.threads.item({ index: 0, archived: true })).toThrow(
+      "unknown item selector",
+    );
+  });
+});