@assistant-ui/core 0.3.16 → 0.3.17

package/src/tests/external-store-optimistic-id.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi } from "vitest";
+import { ExternalStoreThreadRuntimeCore } from "../runtimes/external-store/external-store-thread-runtime-core";
+import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
+import type { ModelContextProvider } from "../model-context/types";
+import type { ThreadMessage } from "../types/message";
+
+const createContextProvider = (): ModelContextProvider => ({
+  getModelContext: () => ({}),
+});
+
+const createUserMessage = (id: string, text = "Hello"): ThreadMessage =>
+  ({
+    id,
+    role: "user" as const,
+    createdAt: new Date(),
+    content: [{ type: "text" as const, text }],
+    attachments: [],
+    metadata: {
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const createAssistantMessage = (id: string, text = "Hi there"): ThreadMessage =>
+  ({
+    id,
+    role: "assistant" as const,
+    createdAt: new Date(),
+    content: [{ type: "text" as const, text }],
+    status: { type: "complete" as const, reason: "stop" as const },
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const createAdapter = (
+  messages: readonly ThreadMessage[],
+  isRunning: boolean,
+): ExternalStoreAdapter<ThreadMessage> => ({
+  messages,
+  isRunning,
+  onNew: vi.fn(async () => {}),
+});
+
+describe("ExternalStoreThreadRuntimeCore optimistic placeholder id", () => {
+  it("keeps one placeholder id per pending response and issues a fresh one per episode", () => {
+    const u1 = createUserMessage("u1");
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createAdapter([u1], true),
+    );
+    const first = core.messages.at(-1)!;
+    expect(first.role).toBe("assistant");
+    expect(first.content).toHaveLength(0);
+
+    core.__internal_setAdapter(createAdapter([u1], true));
+    core.__internal_setAdapter(createAdapter([u1], true));
+    expect(core.messages.at(-1)!.id).toBe(first.id);
+
+    const u2 = createUserMessage("u2", "follow-up");
+    core.__internal_setAdapter(createAdapter([u1, u2], true));
+    const second = core.messages.at(-1)!;
+    expect(second.role).toBe("assistant");
+    expect(second.id).not.toBe(first.id);
+
+    const a1 = createAssistantMessage("a1");
+    core.__internal_setAdapter(createAdapter([u1, u2, a1], false));
+    expect(core.messages.at(-1)!.id).toBe("a1");
+
+    const u3 = createUserMessage("u3", "again");
+    core.__internal_setAdapter(createAdapter([u1, u2, a1, u3], true));
+    const third = core.messages.at(-1)!;
+    expect(third.role).toBe("assistant");
+    expect(third.id).not.toBe(second.id);
+  });
+});

package/src/tests/external-store-repository-instance.test.ts

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi } from "vitest";
+import { ExternalStoreThreadRuntimeCore } from "../runtimes/external-store/external-store-thread-runtime-core";
+import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
+import type { ModelContextProvider } from "../model-context/types";
+import type { ThreadMessage } from "../types/message";
+import { MessageRepository } from "../runtime/utils/message-repository";
+
+const createContextProvider = (): ModelContextProvider => ({
+  getModelContext: () => ({}),
+});
+
+const createUserMessage = (id: string, text = "Hello"): ThreadMessage =>
+  ({
+    id,
+    role: "user" as const,
+    createdAt: new Date(),
+    content: [{ type: "text" as const, text }],
+    attachments: [],
+    metadata: {
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const createAssistantMessage = (id: string, text = "Hi there"): ThreadMessage =>
+  ({
+    id,
+    role: "assistant" as const,
+    createdAt: new Date(),
+    content: [{ type: "text" as const, text }],
+    status: { type: "complete" as const, reason: "stop" as const },
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const createAdapter = (
+  messages: readonly ThreadMessage[],
+  repository: MessageRepository,
+): ExternalStoreAdapter<ThreadMessage> => ({
+  messages,
+  onNew: vi.fn(async () => {}),
+  unstable_messageRepositoryInstance: repository,
+});
+
+describe("ExternalStoreThreadRuntimeCore repository instance swap", () => {
+  it("keeps each conversation's history in its own repository across swaps", () => {
+    const repoA = new MessageRepository();
+    const repoB = new MessageRepository();
+    const threadA = [
+      createUserMessage("a-u1", "thread a question"),
+      createAssistantMessage("a-m1", "thread a answer"),
+    ];
+    const threadB = [
+      createUserMessage("b-u1", "thread b question"),
+      createAssistantMessage("b-m1", "thread b answer"),
+    ];
+
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createAdapter(threadA, repoA),
+    );
+    expect(core.messages.map((m) => m.id)).toEqual(["a-u1", "a-m1"]);
+
+    core.__internal_setAdapter(createAdapter(threadB, repoB));
+    expect(core.messages.map((m) => m.id)).toEqual(["b-u1", "b-m1"]);
+    expect(core.getBranches("b-u1")).toEqual(["b-u1"]);
+
+    core.__internal_setAdapter(createAdapter(threadA, repoA));
+    expect(core.messages.map((m) => m.id)).toEqual(["a-u1", "a-m1"]);
+    expect(core.getBranches("a-u1")).toEqual(["a-u1"]);
+    expect(repoB.getMessages().map((m) => m.id)).toEqual(["b-u1", "b-m1"]);
+  });
+
+  it("preserves intra-thread branches across a swap through an empty conversation", () => {
+    const repoA = new MessageRepository();
+    const repoB = new MessageRepository();
+    const original = [
+      createUserMessage("a-u1"),
+      createAssistantMessage("a-m1"),
+    ];
+    const edited = [
+      createUserMessage("a-u2", "edited question"),
+      createAssistantMessage("a-m2", "edited answer"),
+    ];
+
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createAdapter(original, repoA),
+    );
+    repoA.addOrUpdateMessage(null, edited[0]!);
+    repoA.addOrUpdateMessage("a-u2", edited[1]!);
+    core.__internal_setAdapter(createAdapter(edited, repoA));
+    expect(core.getBranches("a-u2")).toEqual(["a-u1", "a-u2"]);
+
+    core.__internal_setAdapter(createAdapter([], repoB));
+    expect(core.messages).toHaveLength(0);
+
+    core.__internal_setAdapter(createAdapter(edited, repoA));
+    expect(core.messages.map((m) => m.id)).toEqual(["a-u2", "a-m2"]);
+    expect(core.getBranches("a-u2")).toEqual(["a-u1", "a-u2"]);
+  });
+
+  it("does not adopt anything when the instance is omitted", () => {
+    const messages = [createUserMessage("u1")];
+    const core = new ExternalStoreThreadRuntimeCore(createContextProvider(), {
+      messages,
+      onNew: vi.fn(async () => {}),
+    });
+    expect(core.messages.map((m) => m.id)).toEqual(["u1"]);
+
+    const next = [createUserMessage("u1"), createAssistantMessage("m1")];
+    core.__internal_setAdapter({
+      messages: next,
+      onNew: vi.fn(async () => {}),
+    });
+    expect(core.messages.map((m) => m.id)).toEqual(["u1", "m1"]);
+  });
+
+  it("reconciles a same-reference messages array when only the repository swapped", () => {
+    const repoA = new MessageRepository();
+    const repoB = new MessageRepository();
+    const shared = [createUserMessage("s-u1")];
+
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createAdapter(shared, repoA),
+    );
+    expect(repoA.getMessages().map((m) => m.id)).toEqual(["s-u1"]);
+    expect(repoB.getMessages()).toHaveLength(0);
+
+    core.__internal_setAdapter(createAdapter(shared, repoB));
+    expect(repoB.getMessages().map((m) => m.id)).toEqual(["s-u1"]);
+    expect(core.messages.map((m) => m.id)).toEqual(["s-u1"]);
+  });
+
+  it("re-imports a same-reference repository snapshot when the instance swapped", () => {
+    const repoA = new MessageRepository();
+    const repoB = new MessageRepository();
+    const snapshot = {
+      headId: "s-m1",
+      messages: [
+        { parentId: null, message: createUserMessage("s-u1") },
+        { parentId: "s-u1", message: createAssistantMessage("s-m1") },
+      ],
+    };
+
+    const core = new ExternalStoreThreadRuntimeCore(createContextProvider(), {
+      messageRepository: snapshot,
+      onNew: vi.fn(async () => {}),
+      unstable_messageRepositoryInstance: repoA,
+    });
+    expect(core.messages.map((m) => m.id)).toEqual(["s-u1", "s-m1"]);
+
+    core.__internal_setAdapter({
+      messageRepository: snapshot,
+      onNew: vi.fn(async () => {}),
+      unstable_messageRepositoryInstance: repoB,
+    });
+    expect(core.messages.map((m) => m.id)).toEqual(["s-u1", "s-m1"]);
+    expect(repoB.getMessages().map((m) => m.id)).toEqual(["s-u1", "s-m1"]);
+  });
+});

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

@@ -998,7 +998,7 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
         core.__internal_setAdapter(
           createBaseAdapter({
             unstable_enableToolInvocations: true,
-            isRunning: true,
+            isRunning: false,
             messages: [
               {
                 ...createAssistantMessage("a1"),
@@ -1068,11 +1068,8 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       expect(rejections).toEqual([]);
     });
 
-    it("handles rejected onRespondToToolApproval callbacks", async () => {
+    it("hands a rejected onRespondToToolApproval back to the caller", async () => {
       const error = new Error("approval failed");
-      const consoleError = vi
-        .spyOn(console, "error")
-        .mockImplementation(() => {});
       let callbackCalls = 0;
       const core = new ExternalStoreThreadRuntimeCore(
         contextProvider,
@@ -1085,23 +1082,32 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       );
 
       const rejections = await captureUnhandledRejections(async () => {
-        core.respondToToolApproval({
-          approvalId: "approval-1",
-          approved: true,
-        });
-
-        await vi.waitFor(() =>
-          expect(consoleError).toHaveBeenCalledWith(
-            "[ExternalStoreThreadRuntimeCore] onRespondToToolApproval callback rejected",
-            error,
-          ),
-        );
+        await expect(
+          core.respondToToolApproval({
+            approvalId: "approval-1",
+            approved: true,
+          }),
+        ).rejects.toBe(error);
       });
 
       expect(callbackCalls).toBe(1);
       expect(rejections).toEqual([]);
     });
 
+    it("resolves when a synchronous onRespondToToolApproval accepts", async () => {
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        createBaseAdapter({ onRespondToToolApproval: () => {} }),
+      );
+
+      await expect(
+        core.respondToToolApproval({
+          approvalId: "approval-1",
+          approved: true,
+        }),
+      ).resolves.toBeUndefined();
+    });
+
     it("handles rejected onCancel callbacks", async () => {
       const error = new Error("cancel failed");
       const consoleError = vi

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

@@ -2,7 +2,7 @@
 
 import { act, render, waitFor } from "@testing-library/react";
 import type { FC } from "react";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { AuiProvider, useAui } from "@assistant-ui/store";
 import type {
   ExternalThreadMessage,
@@ -14,6 +14,24 @@ import type {
   PendingAttachment,
 } from "../types/attachment";
 
+const { mockGenerateId, realGenerateId } = vi.hoisted(() => {
+  const realGenerateId = { current: (): string => "" };
+  return {
+    realGenerateId,
+    mockGenerateId: vi.fn(() => realGenerateId.current()),
+  };
+});
+
+vi.mock("../utils/id", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../utils/id")>();
+  realGenerateId.current = actual.generateId;
+  return { ...actual, generateId: mockGenerateId };
+});
+
+beforeEach(() => {
+  mockGenerateId.mockReset();
+});
+
 const renderThreadWithProps = (props: Partial<ExternalThreadProps>) => {
   const captured: { aui?: ReturnType<typeof useAui> } = {};
   const Capture: FC = () => {
@@ -57,6 +75,72 @@ const renderThread = () => {
 };
 
 describe("ExternalThread attachments", () => {
+  it("uses generated IDs unless a prepared attachment supplies one", async () => {
+    const aui = renderThread();
+    mockGenerateId
+      .mockReturnValueOnce("generated-file-id")
+      .mockReturnValueOnce("generated-prepared-id");
+
+    await act(async () => {
+      await aui()
+        .thread()
+        .composer()
+        .addAttachment(new File(["data"], "photo.png", { type: "image/png" }));
+      await aui()
+        .thread()
+        .composer()
+        .addAttachment({
+          name: "notes.txt",
+          contentType: "text/plain",
+          content: [{ type: "text", text: "hello" }],
+        });
+      await aui().thread().composer().addAttachment({
+        id: "provided-id",
+        name: "report.pdf",
+        contentType: "application/pdf",
+        content: [],
+      });
+    });
+
+    await waitFor(() => {
+      expect(
+        aui()
+          .thread()
+          .composer()
+          .getState()
+          .attachments.map((attachment) => attachment.id),
+      ).toEqual(["generated-file-id", "generated-prepared-id", "provided-id"]);
+    });
+    expect(mockGenerateId).toHaveBeenCalledTimes(2);
+  });
+
+  it("generates distinct IDs for attachments without one", async () => {
+    const aui = renderThread();
+
+    await act(async () => {
+      await aui()
+        .thread.composer()
+        .addAttachment(new File(["data"], "photo.png", { type: "image/png" }));
+      await aui()
+        .thread.composer()
+        .addAttachment({
+          name: "notes.txt",
+          contentType: "text/plain",
+          content: [{ type: "text", text: "hello" }],
+        });
+    });
+
+    await waitFor(() =>
+      expect(aui().thread.composer().getState().attachments).toHaveLength(2),
+    );
+    const ids = aui()
+      .thread.composer()
+      .getState()
+      .attachments.map((attachment) => attachment.id);
+    expect(ids.every((id) => id.length > 0)).toBe(true);
+    expect(new Set(ids).size).toBe(2);
+  });
+
   it("adds prepared attachments when File is unavailable", async () => {
     const aui = renderThread();
     const fileConstructor = globalThis.File;

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

@@ -51,6 +51,27 @@ describe("RemoteThreadList adapter changes", () => {
     expect(adapterB.rename).not.toHaveBeenCalled();
   });
 
+  it("clears loading when the replaced adapter's list never settles", async () => {
+    const adapterA = makeAdapter({
+      list: vi.fn(() => new Promise<never>(() => {})),
+    });
+    const adapterB = makeAdapter({
+      list: vi.fn(async () => ({ threads: [thread("thread-b")] })),
+    });
+    const core = createCore(adapterA);
+
+    void core.getLoadThreadsPromise();
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.threadIds).toEqual(["thread-b"]);
+    expect(core.isLoading).toBe(false);
+  });
+
   it("does not resume an old adapter mutation through the new adapter", async () => {
     const adapterA = makeAdapter({
       list: async () => ({ threads: [thread("thread-a")] }),
@@ -378,6 +399,50 @@ describe("RemoteThreadList adapter changes", () => {
 
     expect(core.getItemById(draftId!)?.remoteId).toBe("created-on-b");
     expect(core.mainThreadId).toBe(draftId);
-    expect(core.threadIds).toContain("created-on-b");
+    expect(core.threadIds).toContain(draftId);
+    expect(core.getItemById("created-on-b")?.id).toBe(draftId);
+  });
+
+  it("keeps one slot when the replacement list already carries the initialized thread", 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;
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.initialize(draftId!);
+
+    listB.resolve({
+      threads: [thread("created-on-b"), thread("thread-b")],
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(
+      Object.values(core.threadItems).filter(
+        (item) => item.remoteId === "created-on-b",
+      ),
+    ).toHaveLength(1);
+    expect(core.threadIds).toEqual([draftId, "thread-b"]);
+    expect(core.getItemById("created-on-b")?.id).toBe(draftId);
+
+    await core.delete("created-on-b");
+
+    expect(core.getItemById("created-on-b")).toBeUndefined();
+    expect(core.getItemById(draftId!)).toBeUndefined();
+    expect(core.threadIds).toEqual(["thread-b"]);
   });
 });