@assistant-ui/core 0.3.15 → 0.3.17

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;
@@ -582,3 +666,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/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"]);
   });
 });

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

package/src/tests/thread-message-like.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { fromThreadMessageLike } from "../runtime/utils/thread-message-like";
+import {
+  fromThreadMessageLike,
+  type ThreadMessageLike,
+} from "../runtime/utils/thread-message-like";
+import type { ToolCallMessagePartMcpMetadata } from "../types/message";
 
 const fallbackId = "test-id";
 const fallbackStatus = {
@@ -421,3 +425,37 @@ describe("fromThreadMessageLike provider metadata", () => {
     ]);
   });
 });
+
+describe("fromThreadMessageLike MCP app metadata", () => {
+  it("keeps mcp on tool-call parts", () => {
+    const mcp: ToolCallMessagePartMcpMetadata = {
+      app: { resourceUri: "ui://demo/card" },
+    };
+    const message: ThreadMessageLike = {
+      role: "assistant",
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "show_card",
+          args: {},
+          argsText: "{}",
+          mcp,
+        },
+      ],
+    };
+
+    const result = fromThreadMessageLike(message, fallbackId, fallbackStatus);
+
+    expect(result.content).toEqual([
+      {
+        type: "tool-call",
+        toolCallId: "call-1",
+        toolName: "show_card",
+        args: {},
+        argsText: "{}",
+        mcp,
+      },
+    ]);
+  });
+});