@assistant-ui/core 0.3.14 → 0.3.16

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");
@@ -528,6 +576,83 @@ describe("MessageRepository", () => {
     });
   });
 
+  describe("ExportedMessageRepository auto status", () => {
+    const pendingToolCall: ThreadMessageLike = {
+      id: "a1",
+      role: "assistant",
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "t1",
+          toolName: "search",
+          args: {},
+          argsText: "{}",
+          approval: { id: "a1" },
+        },
+      ],
+    };
+
+    it("fromArray reports requires-action for an unresolved approval", () => {
+      const result = ExportedMessageRepository.fromArray([pendingToolCall]);
+      expect(result.messages[0]!.message.status).toMatchObject({
+        type: "requires-action",
+        reason: "interrupt",
+      });
+    });
+
+    it("fromBranchableArray reports requires-action for an unresolved approval", () => {
+      const result = ExportedMessageRepository.fromBranchableArray([
+        { message: pendingToolCall, parentId: null },
+      ]);
+      expect(result.messages[0]!.message.status).toMatchObject({
+        type: "requires-action",
+        reason: "interrupt",
+      });
+    });
+
+    it("fromArray reports requires-action with reason tool-calls for a resultless tool call", () => {
+      const result = ExportedMessageRepository.fromArray([
+        {
+          ...pendingToolCall,
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "t1",
+              toolName: "search",
+              args: {},
+              argsText: "{}",
+            },
+          ],
+        },
+      ]);
+      expect(result.messages[0]!.message.status).toMatchObject({
+        type: "requires-action",
+        reason: "tool-calls",
+      });
+    });
+
+    it("keeps complete for a resolved tool call", () => {
+      const result = ExportedMessageRepository.fromArray([
+        {
+          ...pendingToolCall,
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "t1",
+              toolName: "search",
+              args: {},
+              argsText: "{}",
+              result: "ok",
+            },
+          ],
+        },
+      ]);
+      expect(result.messages[0]!.message.status).toMatchObject({
+        type: "complete",
+      });
+    });
+  });
+
   describe("ExportedMessageRepository.fromBranchableArray", () => {
     it("should create a branching tree structure", () => {
       const items = [

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-load-race.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  createCore,
+  makeAdapter,
+  deferred,
+} from "./remote-thread-list-test-helpers";
+import {
+  preserveMidLoadTransitions,
+  createThreadMappingId,
+  type RemoteThreadState,
+} from "../runtimes/remote-thread-list/remote-thread-state";
+
+type ListResult = Awaited<ReturnType<ReturnType<typeof makeAdapter>["list"]>>;
+
+describe("RemoteThreadListThreadListRuntimeCore load race", () => {
+  it("keeps a thread initialized during the list() flight at the top", async () => {
+    const listDeferred = deferred<ListResult>();
+    const adapter = makeAdapter({ list: vi.fn(() => listDeferred.promise) });
+    const core = createCore(adapter);
+
+    const loadPromise = core.getLoadThreadsPromise();
+
+    await core.switchToNewThread();
+    const newId = core.newThreadId!;
+    await core.initialize(newId);
+    expect(core.threadIds).toContain(newId);
+
+    listDeferred.resolve({
+      threads: [
+        { status: "regular", remoteId: "t1", externalId: "t1", title: "One" },
+      ],
+    });
+    await loadPromise;
+
+    expect(core.getItemById(newId)?.status).toBe("regular");
+    expect(core.threadIds[0]).toBe(newId);
+    expect(core.threadIds).toContain("t1");
+  });
+});
+
+describe("preserveMidLoadTransitions", () => {
+  const stateWith = (
+    data: {
+      id: string;
+      remoteId?: string;
+      status: "new" | "regular" | "archived";
+      localOrigin?: true;
+    }[],
+    lists: { threadIds?: string[]; archivedThreadIds?: string[] } = {},
+  ): RemoteThreadState => ({
+    isLoading: false,
+    isLoadingMore: false,
+    cursor: undefined,
+    newThreadId: undefined,
+    threadIds: lists.threadIds ?? [],
+    archivedThreadIds: lists.archivedThreadIds ?? [],
+    threadIdMap: Object.fromEntries(
+      data.map((d) => [d.id, createThreadMappingId(d.id)]),
+    ),
+    threadData: Object.fromEntries(
+      data.map((d) => [
+        createThreadMappingId(d.id),
+        {
+          id: d.id,
+          remoteId: d.remoteId,
+          externalId: undefined,
+          status: d.status,
+          ...(d.localOrigin ? { localOrigin: true as const } : {}),
+          initializeTask: Promise.resolve({
+            remoteId: d.remoteId ?? d.id,
+            externalId: undefined,
+          }),
+        },
+      ]),
+    ) as RemoteThreadState["threadData"],
+  });
+
+  it("does not resurrect a thread the server already knew and omitted", () => {
+    const state = stateWith([{ id: "t1", remoteId: "t1", status: "regular" }]);
+    const result = preserveMidLoadTransitions(
+      state,
+      { threadIds: ["t1"], archivedThreadIds: [] },
+      new Map([["t1", "regular"]]),
+    );
+    expect(result.threadIds).toEqual([]);
+  });
+
+  it("does not duplicate a thread the response contains by remoteId", () => {
+    const state = stateWith(
+      [
+        {
+          id: "__LOCALID_1",
+          remoteId: "remote-1",
+          status: "regular",
+          localOrigin: true,
+        },
+      ],
+      { threadIds: ["remote-1"] },
+    );
+    const result = preserveMidLoadTransitions(
+      state,
+      { threadIds: ["__LOCALID_1"], archivedThreadIds: [] },
+      new Map(),
+    );
+    expect(result.threadIds).toEqual(["remote-1"]);
+  });
+
+  it("prepends a mid-flight transition ahead of listed threads", () => {
+    const state = stateWith(
+      [
+        { id: "local-1", remoteId: "remote-1", status: "regular" },
+        { id: "t1", remoteId: "t1", status: "regular" },
+      ],
+      { threadIds: ["t1"] },
+    );
+    const result = preserveMidLoadTransitions(
+      state,
+      { threadIds: ["local-1", "t1"], archivedThreadIds: [] },
+      new Map([
+        ["local-1", "new"],
+        ["t1", "regular"],
+      ]),
+    );
+    expect(result.threadIds).toEqual(["local-1", "t1"]);
+  });
+
+  it("orders multiple rescued threads by their live pre-response order", () => {
+    const state = stateWith(
+      [
+        {
+          id: "__LOCALID_1",
+          remoteId: "remote-1",
+          status: "regular",
+          localOrigin: true,
+        },
+        {
+          id: "__LOCALID_2",
+          remoteId: "remote-2",
+          status: "regular",
+          localOrigin: true,
+        },
+      ],
+      { threadIds: ["t1"] },
+    );
+    const result = preserveMidLoadTransitions(
+      state,
+      { threadIds: ["__LOCALID_2", "__LOCALID_1"], archivedThreadIds: [] },
+      new Map(),
+    );
+    expect(result.threadIds).toEqual(["__LOCALID_2", "__LOCALID_1", "t1"]);
+  });
+
+  it("leaves a fetched non-local thread governed by the response", () => {
+    const state = stateWith([{ id: "t9", remoteId: "t9", status: "regular" }], {
+      threadIds: ["t1"],
+    });
+    const result = preserveMidLoadTransitions(
+      state,
+      { threadIds: ["t1", "t9"], archivedThreadIds: [] },
+      new Map(),
+    );
+    expect(result.threadIds).toEqual(["t1"]);
+  });
+
+  it("does not trust a remote id that mimics the local prefix", () => {
+    const state = stateWith(
+      [{ id: "__LOCALID_evil", remoteId: "__LOCALID_evil", status: "regular" }],
+      { threadIds: ["t1"] },
+    );
+    const result = preserveMidLoadTransitions(
+      state,
+      { threadIds: ["t1", "__LOCALID_evil"], archivedThreadIds: [] },
+      new Map(),
+    );
+    expect(result.threadIds).toEqual(["t1"]);
+  });
+
+  it("re-inserts an archived mid-flight transition", () => {
+    const state = stateWith([
+      {
+        id: "__LOCALID_1",
+        remoteId: "remote-1",
+        status: "archived",
+        localOrigin: true,
+      },
+    ]);
+    const result = preserveMidLoadTransitions(
+      state,
+      { threadIds: [], archivedThreadIds: ["__LOCALID_1"] },
+      new Map([["__LOCALID_1", "new"]]),
+    );
+    expect(result.archivedThreadIds).toEqual(["__LOCALID_1"]);
+  });
+});

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/RemoteThreadListThreadListRuntimeCore-title-race.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
+
+describe("RemoteThreadListThreadListRuntimeCore title generation", () => {
+  it("keeps a generated title when an earlier rename completes during another update", async () => {
+    const reloadRequest = deferred<{
+      threads: {
+        status: "regular";
+        remoteId: string;
+        externalId: string;
+        title: string;
+      }[];
+    }>();
+    const adapter = makeAdapter({
+      list: vi
+        .fn()
+        .mockResolvedValueOnce({
+          threads: [
+            {
+              status: "regular" as const,
+              remoteId: "thread-1",
+              externalId: "thread-1",
+              title: "New chat",
+            },
+          ],
+        })
+        .mockImplementationOnce(() => reloadRequest.promise),
+      generateTitle: vi.fn(
+        async () =>
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue({
+                type: "part-start",
+                path: [0],
+                part: { type: "text" },
+              });
+              controller.enqueue({
+                type: "text-delta",
+                path: [0],
+                textDelta: "Generated Title",
+              });
+              controller.enqueue({ type: "part-finish", path: [0] });
+              controller.close();
+            },
+          }) as never,
+      ),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    const internals = core as unknown as {
+      _hookManager: { getThreadRuntimeCore: () => { messages: never[] } };
+    };
+    internals._hookManager.getThreadRuntimeCore = () => ({ messages: [] });
+
+    const overlappingUpdate = core.reload();
+
+    await core.rename("thread-1", "Instant name");
+    await core.generateTitle("thread-1");
+
+    expect(core.getItemById("thread-1")?.title).toBe("Generated Title");
+
+    reloadRequest.resolve({
+      threads: [
+        {
+          status: "regular",
+          remoteId: "thread-1",
+          externalId: "thread-1",
+          title: "New chat",
+        },
+      ],
+    });
+    await overlappingUpdate;
+
+    expect(core.getItemById("thread-1")?.title).toBe("Generated Title");
+  });
+
+  it("does not apply a generated title after the adapter changes", async () => {
+    const adapterA = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "thread-1",
+            externalId: "thread-1",
+            title: "Adapter A title",
+          },
+        ],
+      })),
+      generateTitle: vi.fn(
+        async () =>
+          new ReadableStream({
+            start(controller) {
+              controller.enqueue({
+                type: "part-start",
+                path: [0],
+                part: { type: "text" },
+              });
+              controller.enqueue({
+                type: "text-delta",
+                path: [0],
+                textDelta: "Generated by adapter A",
+              });
+              controller.enqueue({ type: "part-finish", path: [0] });
+              controller.close();
+            },
+          }) as never,
+      ),
+    });
+    const adapterB = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "thread-1",
+            externalId: "thread-1",
+            title: "Adapter B title",
+          },
+        ],
+      })),
+    });
+    const core = createCore(adapterA);
+    await core.getLoadThreadsPromise();
+
+    const internals = core as unknown as {
+      _hookManager: { getThreadRuntimeCore: () => { messages: never[] } };
+    };
+    internals._hookManager.getThreadRuntimeCore = () => ({ messages: [] });
+
+    let replacementLoad: Promise<void> | undefined;
+    let adapterChanged = false;
+    const unsubscribe = core.subscribe(() => {
+      if (
+        adapterChanged ||
+        core.getItemById("thread-1")?.title !== "Generated by adapter A"
+      ) {
+        return;
+      }
+      adapterChanged = true;
+      core.__internal_setOptions({
+        adapter: adapterB,
+        runtimeHook: () => ({}) as never,
+      });
+      replacementLoad = core.getLoadThreadsPromise();
+    });
+
+    await core.generateTitle("thread-1");
+    unsubscribe();
+    expect(adapterChanged).toBe(true);
+    await replacementLoad;
+
+    expect(core.getItemById("thread-1")?.title).toBe("Adapter B title");
+  });
+});

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