@assistant-ui/core 0.3.14 → 0.3.15

package/src/tests/MessageRepository.test.ts

@@ -180,6 +180,24 @@ describe("MessageRepository", () => {
   });
 
   describe("Branch management", () => {
+    const createLongBranchMessages = (
+      messageCount: number,
+    ): Array<{ message: ThreadMessage; parentId: string | null }> => {
+      const messages: Array<{
+        message: ThreadMessage;
+        parentId: string | null;
+      }> = [{ message: createTestMessage({ id: "root" }), parentId: null }];
+
+      for (let index = 0; index < messageCount; index++) {
+        messages.push({
+          message: createTestMessage({ id: `branch-${index}` }),
+          parentId: index === 0 ? "root" : `branch-${index - 1}`,
+        });
+      }
+
+      return messages;
+    };
+
     it("should create multiple branches from a parent message", () => {
       const parent = createTestMessage({ id: "parent-id" });
       const branch1 = createTestMessage({ id: "branch1-id" });
@@ -222,6 +240,36 @@ describe("MessageRepository", () => {
       expect(messages2.map((m) => m.id)).toEqual(["parent-id", "branch2-id"]);
     });
 
+    it("should operate on a long message history without overflowing the stack", () => {
+      const messageCount = 30_000;
+      const messages = createLongBranchMessages(messageCount);
+
+      messages.push({
+        message: createTestMessage({ id: "alternate" }),
+        parentId: "root",
+      });
+
+      repository.import({ headId: "alternate", messages });
+      repository.switchToBranch("branch-0");
+
+      expect(repository.headId).toBe(`branch-${messageCount - 1}`);
+
+      repository.deleteMessage("branch-0", "root");
+
+      expect(repository.getMessage("branch-1")).toMatchObject({
+        parentId: "root",
+        index: 1,
+      });
+      expect(repository.headId).toBe(`branch-${messageCount - 1}`);
+
+      repository.resetHead("root");
+
+      expect(repository.getMessages().map((message) => message.id)).toEqual([
+        "root",
+      ]);
+      expect(() => repository.getMessage("branch-1")).toThrow();
+    }, 20_000);
+
     it("should throw error when switching to a non-existent branch", () => {
       expect(() => {
         repository.switchToBranch("non-existent-id");

package/src/tests/RemoteThreadListThreadListRuntimeCore-errors.test.ts

@@ -3,10 +3,10 @@ import { createCore, makeAdapter } from "./remote-thread-list-test-helpers";
 import { InMemoryThreadListAdapter } from "../runtimes/remote-thread-list/adapter/in-memory";
 
 describe("RemoteThreadListThreadListRuntimeCore errors", () => {
-  it("includes the requested thread id when a thread is missing", () => {
+  it("includes the requested thread id when a thread is missing", async () => {
     const core = createCore(makeAdapter());
 
-    expect(() => core.rename("missing-thread", "New title")).toThrow(
+    await expect(core.rename("missing-thread", "New title")).rejects.toThrow(
       'Thread "missing-thread" not found while renaming it.',
     );
   });

package/src/tests/RemoteThreadListThreadListRuntimeCore-loadMore.test.ts

@@ -268,6 +268,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     await core.getLoadThreadsPromise();
     expect(secondList).toHaveBeenCalledTimes(1);
     expect(core.threadIds).toEqual(["new"]);
+    expect(core.getItemById("old")).toBeUndefined();
   });
 
   it("ignores an in-flight loadMore response when the adapter swaps mid-flight", async () => {
@@ -289,23 +290,24 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     await core.getLoadThreadsPromise();
     const stale = core.loadMore();
 
-    const secondAdapter = makeAdapter({
-      list: vi.fn<ListFn>(async () => ({
-        threads: [{ status: "regular", remoteId: "ignored", externalId: "x" }],
-      })),
-    });
+    const secondList = vi.fn<ListFn>(async () => ({
+      threads: [{ status: "regular", remoteId: "fresh", externalId: "fresh" }],
+    }));
+    const secondAdapter = makeAdapter({ list: secondList });
     core.__internal_setOptions({
       adapter: secondAdapter,
       runtimeHook: () => ({}) as never,
     });
+    const replacementLoad = core.getLoadThreadsPromise();
 
     slow.resolve({
       threads: [{ status: "regular", remoteId: "stale", externalId: "stale" }],
       nextCursor: "stale-cursor",
     });
     await stale;
+    await replacementLoad;
 
-    expect(core.threadIds).toEqual(["p1"]);
+    expect(core.threadIds).toEqual(["fresh"]);
     expect(core.hasMore).toBe(false);
     expect(core.isLoadingMore).toBe(false);
   });

package/src/tests/empty-thread-core.test.ts

@@ -2,6 +2,12 @@ import { describe, it, expect } from "vitest";
 import { EMPTY_THREAD_CORE } from "../runtimes/remote-thread-list/empty-thread-core";
 
 describe("EMPTY_THREAD_CORE", () => {
+  it("reads no messages, branches, or exported repository", () => {
+    expect(EMPTY_THREAD_CORE.getMessageById("a")).toBeUndefined();
+    expect(EMPTY_THREAD_CORE.getBranches("a")).toEqual([]);
+    expect(EMPTY_THREAD_CORE.export()).toEqual({ messages: [] });
+  });
+
   it("has isLoading=true so it is not mistaken for an empty conversation", () => {
     expect(EMPTY_THREAD_CORE.isLoading).toBe(true);
   });

package/src/tests/external-store-thread-runtime-core-adapter.test.ts

@@ -8,6 +8,7 @@ import type { ModelContextProvider } from "../model-context/types";
 import type { AppendMessage, ThreadMessage } from "../types/message";
 import { createMessageQueue } from "../runtime/queue/message-queue";
 import { getThreadMessageText } from "../utils/text";
+import { invalidateThreadRuntime } from "../runtime/utils/thread-runtime-lifecycle";
 
 const createContextProvider = (): ModelContextProvider => ({
   getModelContext: () => ({}),
@@ -304,6 +305,25 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       expect(texts).not.toContain("partial answer");
     });
 
+    it("does not resync after the runtime is invalidated", async () => {
+      const setMessages = vi.fn();
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        createBaseAdapter({
+          messages: [createAssistantMessage("a1", "partial answer")],
+          isRunning: true,
+          onCancel: vi.fn(),
+          setMessages,
+        }),
+      );
+
+      core.cancelRun();
+      invalidateThreadRuntime(core);
+
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(setMessages).not.toHaveBeenCalled();
+    });
+
     it("re-applies the user leaf rollback when the store updates before the flush", async () => {
       const messages = [createUserMessage("u1", "cancel me")];
       const setMessages = vi.fn();

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");
+  });
+});