@assistant-ui/core 0.3.16 → 0.3.18

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-list-runtime-core.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it, vi } from "vitest";
 import { ExternalStoreThreadListRuntimeCore } from "../runtimes/external-store/external-store-thread-list-runtime-core";
 import type { ExternalStoreThreadRuntimeCore } from "../runtimes/external-store/external-store-thread-runtime-core";
 import { ExternalStoreThreadRuntimeCore as ExternalStoreThreadRuntimeCoreImpl } from "../runtimes/external-store/external-store-thread-runtime-core";
+import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-store-runtime-core";
 import type { ExternalStoreThreadListAdapter } from "../runtimes/external-store/external-store-adapter";
 import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
 import type { ModelContextProvider } from "../model-context/types";
@@ -109,10 +110,56 @@ describe("ExternalStoreThreadListRuntimeCore - construction", () => {
     // Two empty-adapter constructions should share the frozen DEFAULT_THREAD_DATA
     // singleton rather than each getting a fresh `{ ... }` clone.
     expect(a.threadItems).toBe(b.threadItems);
+    expect(Object.getPrototypeOf(a.threadItems)).toBeNull();
   });
+
+  it.each(["__proto__", "constructor", "toString"])(
+    "returns undefined for an absent prototype-named thread id %s",
+    (threadId) => {
+      const core = new ExternalStoreThreadListRuntimeCore(
+        makeAdapter(),
+        makeFactory(),
+      );
+
+      expect(core.getItemById(threadId)).toBeUndefined();
+      expect(Object.hasOwn(core.threadItems, threadId)).toBe(false);
+    },
+  );
 });
 
 describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
+  it("updates subscribed loading state when thread ids and arrays stay unchanged", () => {
+    const threadList = makeAdapter({
+      threadId: "thread-alpha",
+      threads: [{ id: "thread-alpha", status: "regular" }],
+      archivedThreads: [],
+      isLoading: true,
+    });
+    const adapter: ExternalStoreAdapter = {
+      messages: [],
+      onNew: async () => {},
+      adapters: { threadList },
+    };
+    const core = new ExternalStoreRuntimeCore(adapter);
+    const runtime = new ThreadListRuntimeImpl(core.threads);
+    const seen: boolean[] = [];
+    const unsubscribe = runtime.subscribe(() => {
+      seen.push(runtime.getState().isLoading);
+    });
+    expect(runtime.getState().isLoading).toBe(true);
+
+    for (const isLoading of [false, true, undefined, false]) {
+      core.setAdapter({
+        ...adapter,
+        adapters: { threadList: { ...threadList, isLoading } },
+      });
+    }
+
+    expect(seen).toEqual([false, true, false]);
+    expect(runtime.getState().isLoading).toBe(false);
+    unsubscribe();
+  });
+
   it("updates mainThreadId when adapter.threadId changes", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha" }),
@@ -198,6 +245,42 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
     expect(item?.id).toBe("thread-beta");
   });
 
+  it.each(["__proto__", "constructor", "toString"])(
+    "synthesizes a main entry for a prototype-named thread id %s",
+    (threadId) => {
+      const core = new ExternalStoreThreadListRuntimeCore(
+        makeAdapter({ threadId }),
+        makeFactory(),
+      );
+
+      expect(core.getItemById(threadId)).toEqual(
+        expect.objectContaining({ id: threadId, status: "regular" }),
+      );
+      expect(Object.hasOwn(core.threadItems, threadId)).toBe(true);
+      expect(Object.getPrototypeOf(core.threadItems)).toBeNull();
+    },
+  );
+
+  it.each(["regular", "archived"] as const)(
+    "preserves a prototype-named %s adapter entry",
+    (status) => {
+      const adapter: ExternalStoreThreadListAdapter =
+        status === "regular"
+          ? { threads: [{ id: "__proto__", status }] }
+          : { archivedThreads: [{ id: "__proto__", status }] };
+      const core = new ExternalStoreThreadListRuntimeCore(
+        makeAdapter(adapter),
+        makeFactory(),
+      );
+
+      expect(core.getItemById("__proto__")).toEqual(
+        expect.objectContaining({ id: "__proto__", status }),
+      );
+      expect(Object.hasOwn(core.threadItems, "__proto__")).toBe(true);
+      expect(Object.getPrototypeOf(core.threadItems)).toBeNull();
+    },
+  );
+
   it("does not retain stale synthesized entries across mainThreadId switches", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha" }),

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

@@ -160,26 +160,35 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       expect(onNew).not.toHaveBeenCalled();
     });
 
-    it("throws when adapter has no onEdit and parentId differs from head", async () => {
-      const messages = [createUserMessage("u1"), createAssistantMessage("a1")];
-      const adapter = createBaseAdapter({ messages });
-      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+    it.each(["u1", null])(
+      "rejects parent %s without onEdit",
+      async (parentId) => {
+        const messages = [
+          createUserMessage("u1"),
+          createAssistantMessage("a1"),
+        ];
+        const adapter = createBaseAdapter({ messages });
+        const core = new ExternalStoreThreadRuntimeCore(
+          contextProvider,
+          adapter,
+        );
 
-      const appendMessage: AppendMessage = {
-        role: "user",
-        content: [{ type: "text", text: "Edit" }],
-        attachments: [],
-        createdAt: new Date(),
-        parentId: "u1",
-        sourceId: null,
-        runConfig: undefined,
-        metadata: { custom: {} },
-      } as AppendMessage;
+        const appendMessage: AppendMessage = {
+          role: "user",
+          content: [{ type: "text", text: "Edit" }],
+          attachments: [],
+          createdAt: new Date(),
+          parentId,
+          sourceId: null,
+          runConfig: undefined,
+          metadata: { custom: {} },
+        } as AppendMessage;
 
-      await expect(core.append(appendMessage)).rejects.toThrow(
-        "Runtime does not support editing messages.",
-      );
-    });
+        await expect(core.append(appendMessage)).rejects.toThrow(
+          "Runtime does not support editing messages.",
+        );
+      },
+    );
   });
 
   describe("startRun", () => {
@@ -998,7 +1007,7 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
         core.__internal_setAdapter(
           createBaseAdapter({
             unstable_enableToolInvocations: true,
-            isRunning: true,
+            isRunning: false,
             messages: [
               {
                 ...createAssistantMessage("a1"),
@@ -1068,11 +1077,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 +1091,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,8 +2,9 @@
 
 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 { CompositeAttachmentAdapter } from "../adapters/attachment";
 import type {
   ExternalThreadMessage,
   ExternalThreadProps,
@@ -14,6 +15,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 +76,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;
@@ -320,6 +405,53 @@ describe("ExternalThread attachments", () => {
     },
   );
 
+  it("preserves pending attachments when adapter removal fails", async () => {
+    const error = new Error("remove failed");
+    const remove = vi.fn(async () => {
+      throw error;
+    });
+    const file = new File(["data"], "notes.txt", { type: "text/plain" });
+    const adapter = {
+      accept: "*",
+      add: async () => ({
+        id: "att-1",
+        type: "file" as const,
+        name: file.name,
+        contentType: file.type,
+        file,
+        status: {
+          type: "requires-action" as const,
+          reason: "composer-send" as const,
+        },
+      }),
+      send: async () => ({}) as never,
+      remove,
+    };
+    const aui = renderThreadWithProps({ attachmentAdapter: adapter });
+    const composer = () => aui().thread.composer();
+
+    await act(() => composer().addAttachment(file));
+    await waitFor(() =>
+      expect(composer().getState().attachments).toHaveLength(1),
+    );
+
+    await expect(
+      act(() => composer().attachment({ id: "att-1" }).remove()),
+    ).rejects.toBe(error);
+
+    expect(remove).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "att-1" }),
+    );
+    expect(composer().getState().attachments).toHaveLength(1);
+    await waitFor(() =>
+      expect(composer().getState().attachments[0]?.status).toEqual({
+        type: "incomplete",
+        reason: "error",
+        message: "remove failed",
+      }),
+    );
+  });
+
   it.each([
     [
       "clearAttachments",
@@ -526,6 +658,97 @@ describe("ExternalThread attachments", () => {
     });
   });
 
+  it("removes complete edit attachments without adapter cleanup", async () => {
+    const remove = vi.fn(async () => {});
+    const completeAttachment = {
+      id: "image-1",
+      type: "image",
+      name: "image",
+      content: [{ type: "image", image: "data:image/png;base64,data" }],
+      status: { type: "complete" },
+    } as unknown as CompleteAttachment;
+    const aui = renderThreadWithProps({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [completeAttachment],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      onEdit: () => {},
+      attachmentAdapter: new CompositeAttachmentAdapter([
+        {
+          accept: "image/*",
+          add: async () => {
+            throw new Error("not used");
+          },
+          send: async () => {
+            throw new Error("not used");
+          },
+          remove,
+        },
+      ]),
+    });
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => composer().beginEdit());
+    await waitFor(() =>
+      expect(composer().getState().attachments).toHaveLength(1),
+    );
+    await act(() => composer().attachment({ id: "image-1" }).remove());
+
+    expect(remove).not.toHaveBeenCalled();
+    expect(composer().getState().attachments).toEqual([]);
+  });
+
+  it("calls adapter.remove for pending edit attachments", async () => {
+    const remove = vi.fn(async () => {});
+    const file = new File(["data"], "notes.txt", { type: "text/plain" });
+    const aui = 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: async () => ({
+          id: "pending-1",
+          type: "document" as const,
+          name: file.name,
+          contentType: file.type,
+          file,
+          status: {
+            type: "requires-action" as const,
+            reason: "composer-send" as const,
+          },
+        }),
+        send: async () => ({}) as never,
+        remove,
+      },
+    });
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => composer().beginEdit());
+    await act(() => composer().addAttachment(file));
+    await act(() => composer().attachment({ id: "pending-1" }).remove());
+
+    expect(remove).toHaveBeenCalledTimes(1);
+    expect(remove).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "pending-1" }),
+    );
+    expect(composer().getState().attachments).toEqual([]);
+  });
+
   it("merges the failed send into a draft the user already modified", async () => {
     vi.spyOn(console, "error").mockImplementation(() => {});
     let rejectSend!: (reason: unknown) => void;

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

@@ -229,6 +229,29 @@ describe("ExternalThread unset optional callbacks", () => {
   });
 });
 
+describe("ExternalThread append parent selection", () => {
+  it("passes an explicit null parent to the host", () => {
+    const onNew = vi.fn();
+    const { aui } = renderThread({
+      messages: [assistantMessage({ type: "complete", reason: "stop" })],
+      onNew,
+    });
+
+    aui().thread.append({
+      parentId: null,
+      content: [{ type: "text", text: "new root" }],
+      startRun: false,
+    });
+
+    expect(onNew).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        parentId: null,
+        content: [{ type: "text", text: "new root" }],
+      }),
+    );
+  });
+});
+
 describe("ExternalThread composer", () => {
   it("dispatches a synchronous setText + send sequence", async () => {
     const onNew = vi.fn();