@assistant-ui/core 0.2.22 → 0.3.0

package/src/tests/RemoteThreadListThreadListRuntimeCore-switchToThread-position.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi } from "vitest";
+import type {
+  RemoteThreadListResponse,
+  RemoteThreadMetadata,
+} from "../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
+
+const thread = (id: string): RemoteThreadMetadata => ({
+  status: "regular",
+  remoteId: id,
+  externalId: id,
+  title: id,
+});
+
+const archivedThread = (id: string): RemoteThreadMetadata => ({
+  status: "archived",
+  remoteId: id,
+  externalId: id,
+  title: id,
+});
+
+describe("RemoteThreadListThreadListRuntimeCore.switchToThread position", () => {
+  it("keeps the position a concurrent list() already gave the thread", async () => {
+    const TARGET = "thread-target";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, TARGET);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(TARGET);
+
+    // `list()` resolves first and places TARGET at the top, as the most recent.
+    listDeferred.resolve({
+      threads: [thread(TARGET), thread("thread-a"), thread("thread-b")],
+    });
+    await loadPromise;
+
+    expect(core.threadIds).toEqual([TARGET, "thread-a", "thread-b"]);
+
+    fetchDeferred.resolve(thread(TARGET));
+    await switchPromise;
+
+    // The fetch path must not filter TARGET out of position and re-append it.
+    expect(core.threadIds).toEqual([TARGET, "thread-a", "thread-b"]);
+  });
+
+  it("appends a thread that is genuinely absent from the loaded list", async () => {
+    const TARGET = "thread-target";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, TARGET);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(TARGET);
+
+    // `list()` resolves first but does not include TARGET (e.g. it is past the
+    // first page).
+    listDeferred.resolve({
+      threads: [thread("thread-a"), thread("thread-b")],
+    });
+    await loadPromise;
+
+    expect(core.threadIds).toEqual(["thread-a", "thread-b"]);
+
+    fetchDeferred.resolve(thread(TARGET));
+    await switchPromise;
+
+    // An absent thread may live on an unloaded page; appending keeps it below
+    // every loaded (newer) thread instead of pinning it to the top.
+    expect(core.threadIds).toEqual(["thread-a", "thread-b", TARGET]);
+  });
+
+  it("keeps the position a concurrent list() gave an archived thread", async () => {
+    const TARGET = "thread-target";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, TARGET);
+    // Stub unarchive so auto-unarchive doesn't move the thread into `threadIds`
+    // via `updateStatusReducer`, hiding the position written by the fetch path.
+    (
+      core as unknown as { unarchive: (id: string) => Promise<void> }
+    ).unarchive = async () => {};
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(TARGET);
+
+    listDeferred.resolve({
+      threads: [archivedThread(TARGET), archivedThread("thread-a")],
+    });
+    await loadPromise;
+
+    expect(core.archivedThreadIds).toEqual([TARGET, "thread-a"]);
+
+    fetchDeferred.resolve(archivedThread(TARGET));
+    await switchPromise;
+
+    expect(core.archivedThreadIds).toEqual([TARGET, "thread-a"]);
+  });
+});

package/src/tests/auiV0Encode.test.ts

@@ -53,6 +53,35 @@ describe("auiV0Encode", () => {
     ]);
   });
 
+  it("preserves a pending tool-call approval in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "requires-action", reason: "tool-calls" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "send_email",
+          args: {},
+          argsText: "{}",
+          approval: { id: "a1" },
+        },
+      ],
+    });
+
+    const toolCall = encoded.content.find((p) => p.type === "tool-call");
+    expect(toolCall).toMatchObject({ approval: { id: "a1" } });
+  });
+
   it("preserves user attachments in the core cloud encoder", () => {
     const encoded = auiV0Encode({
       id: "m1",
@@ -129,6 +158,51 @@ describe("auiV0Encode", () => {
 });
 
 describe("auiV0Decode", () => {
+  it("round-trips a pending tool-call approval so a paused run stays resumable", () => {
+    const content = auiV0Encode({
+      id: "local",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "requires-action", reason: "tool-calls" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "send_email",
+          args: {},
+          argsText: "{}",
+          approval: { id: "a1" },
+        },
+      ],
+    });
+
+    const decoded = auiV0Decode({
+      id: "cloud",
+      parent_id: null,
+      height: 0,
+      created_at: new Date("2026-03-15T00:00:00.000Z"),
+      updated_at: new Date("2026-03-15T00:00:00.000Z"),
+      format: "aui/v0",
+      content: content as never,
+    });
+
+    if (decoded.message.role !== "assistant")
+      throw new Error("expected assistant");
+    const toolCall = decoded.message.content.find(
+      (p) => p.type === "tool-call",
+    );
+    expect(toolCall?.type === "tool-call" && toolCall.approval).toEqual({
+      id: "a1",
+    });
+  });
+
   it("restores user attachments from core cloud history", () => {
     const content = auiV0Encode({
       id: "local",

package/src/tests/base-composer-runtime-core.test.ts

@@ -0,0 +1,422 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { BaseComposerRuntimeCore } from "../runtime/base/base-composer-runtime-core";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { DictationAdapter } from "../adapters/speech";
+import type { CreateAttachment, PendingAttachment } from "../types/attachment";
+import type { AppendMessage } from "../types/message";
+import type { SendOptions } from "../runtime/interfaces/composer-runtime-core";
+
+class TestComposerCore extends BaseComposerRuntimeCore {
+  private _attachmentAdapter: AttachmentAdapter | undefined;
+  public sentMessages: Array<Omit<AppendMessage, "parentId" | "sourceId">> = [];
+  public sentOptions: Array<SendOptions | undefined> = [];
+
+  protected getAttachmentAdapter() {
+    return this._attachmentAdapter;
+  }
+  protected getDictationAdapter(): DictationAdapter | undefined {
+    return undefined;
+  }
+
+  setAttachmentAdapter(adapter: AttachmentAdapter | undefined) {
+    this._attachmentAdapter = adapter;
+  }
+
+  get canCancel() {
+    return false;
+  }
+
+  get canSend() {
+    return !this.isEmpty;
+  }
+
+  protected handleSend(
+    message: Omit<AppendMessage, "parentId" | "sourceId">,
+    options?: SendOptions,
+  ) {
+    this.sentMessages.push(message);
+    this.sentOptions.push(options);
+  }
+
+  protected handleCancel() {}
+}
+
+const makePendingAttachment = (
+  id: string,
+  name = "file.txt",
+): PendingAttachment => ({
+  id,
+  type: "file",
+  name,
+  contentType: "text/plain",
+  file: new File(["content"], name),
+  status: { type: "requires-action", reason: "composer-send" },
+});
+
+describe("BaseComposerRuntimeCore", () => {
+  let composer: TestComposerCore;
+
+  beforeEach(() => {
+    composer = new TestComposerCore();
+  });
+
+  it("does not notify when a set value is unchanged", () => {
+    composer.setText("same");
+    const listener = vi.fn();
+    composer.subscribe(listener);
+
+    composer.setText("same");
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("isEmpty returns true for whitespace-only text", () => {
+    composer.setText("   ");
+    expect(composer.isEmpty).toBe(true);
+  });
+
+  it("reset clears text, attachments, role, runConfig, and quote", async () => {
+    composer.setText("hello");
+    composer.setRole("assistant");
+    composer.setRunConfig({ custom: { k: "v" } });
+    composer.setQuote({ text: "q", messageId: "m1" });
+
+    await composer.reset();
+
+    expect(composer.text).toBe("");
+    expect(composer.role).toBe("user");
+    expect(composer.runConfig).toEqual({});
+    expect(composer.quote).toBeUndefined();
+    expect(composer.attachments).toEqual([]);
+  });
+
+  it("reset does not notify when already in default state", async () => {
+    const listener = vi.fn();
+    composer.subscribe(listener);
+
+    await composer.reset();
+    expect(listener).not.toHaveBeenCalled();
+  });
+
+  it("send includes quote in metadata and clears it", async () => {
+    const quote = { text: "quoted", messageId: "m1" };
+    composer.setText("reply");
+    composer.setQuote(quote);
+
+    await composer.send();
+
+    const msg = composer.sentMessages[0]!;
+    expect(msg.metadata).toEqual({ custom: { quote } });
+    expect(composer.quote).toBeUndefined();
+  });
+
+  it("forwards send options to handleSend", async () => {
+    composer.setText("a");
+    await composer.send();
+    composer.setText("b");
+    await composer.send({ startRun: true });
+    composer.setText("c");
+    await composer.send({ startRun: false });
+
+    expect(composer.sentOptions).toEqual([
+      undefined,
+      { startRun: true },
+      { startRun: false },
+    ]);
+  });
+
+  it("removeAttachment removes via adapter", async () => {
+    const pending = makePendingAttachment("att-1");
+    const adapter: AttachmentAdapter = {
+      accept: "*",
+      add: vi.fn().mockResolvedValue(pending),
+      remove: vi.fn().mockResolvedValue(undefined),
+      send: vi.fn(),
+    };
+    composer.setAttachmentAdapter(adapter);
+
+    await composer.addAttachment(new File([""], "f.txt"));
+    expect(composer.attachments).toHaveLength(1);
+
+    await composer.removeAttachment("att-1");
+    expect(composer.attachments).toHaveLength(0);
+    expect(adapter.remove).toHaveBeenCalledWith(pending);
+  });
+
+  it("removeAttachment throws for unknown id", async () => {
+    const adapter: AttachmentAdapter = {
+      accept: "*",
+      add: vi.fn(),
+      remove: vi.fn(),
+      send: vi.fn(),
+    };
+    composer.setAttachmentAdapter(adapter);
+
+    await expect(composer.removeAttachment("nonexistent")).rejects.toThrow(
+      "Attachment not found",
+    );
+  });
+
+  it("unstable_on unsubscribe stops notifications", async () => {
+    const callback = vi.fn();
+    const unsub = composer.unstable_on("send", callback);
+    unsub();
+
+    composer.setText("test");
+    await composer.send();
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  it("attachmentAccept returns adapter accept or default", () => {
+    expect(composer.attachmentAccept).toBe("*");
+
+    const adapter: AttachmentAdapter = {
+      accept: "image/*",
+      add: vi.fn(),
+      remove: vi.fn(),
+      send: vi.fn(),
+    };
+    composer.setAttachmentAdapter(adapter);
+    expect(composer.attachmentAccept).toBe("image/*");
+  });
+
+  describe("CreateAttachment (external source)", () => {
+    const makeCreateAttachment = (
+      overrides?: Partial<CreateAttachment>,
+    ): CreateAttachment => ({
+      name: "external-doc.pdf",
+      content: [{ type: "text", text: "extracted content" }],
+      ...overrides,
+    });
+
+    it("addAttachment with CreateAttachment adds without adapter", async () => {
+      const att = makeCreateAttachment();
+      await composer.addAttachment(att);
+
+      expect(composer.attachments).toHaveLength(1);
+      expect(composer.attachments[0]!.name).toBe("external-doc.pdf");
+      expect(composer.attachments[0]!.status).toEqual({ type: "complete" });
+      expect(composer.attachments[0]!.type).toBe("document");
+    });
+
+    it("addAttachment with CreateAttachment uses provided id and type", async () => {
+      const att = makeCreateAttachment({
+        id: "custom-id",
+        type: "image",
+        contentType: "image/png",
+      });
+      await composer.addAttachment(att);
+
+      expect(composer.attachments[0]!.id).toBe("custom-id");
+      expect(composer.attachments[0]!.type).toBe("image");
+      expect(composer.attachments[0]!.contentType).toBe("image/png");
+    });
+
+    it("addAttachment with CreateAttachment generates id when not provided", async () => {
+      const att = makeCreateAttachment();
+      await composer.addAttachment(att);
+
+      expect(composer.attachments[0]!.id).toBeTruthy();
+      expect(typeof composer.attachments[0]!.id).toBe("string");
+    });
+
+    it("addAttachment with CreateAttachment fires attachmentAdd event", async () => {
+      const callback = vi.fn();
+      composer.unstable_on("attachmentAdd", callback);
+
+      await composer.addAttachment(makeCreateAttachment());
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    it("removeAttachment on complete attachment does not require adapter", async () => {
+      await composer.addAttachment(makeCreateAttachment({ id: "ext-1" }));
+      expect(composer.attachments).toHaveLength(1);
+
+      await composer.removeAttachment("ext-1");
+      expect(composer.attachments).toHaveLength(0);
+    });
+
+    it("isEmpty returns false when external attachment present", async () => {
+      expect(composer.isEmpty).toBe(true);
+
+      await composer.addAttachment(makeCreateAttachment());
+      expect(composer.isEmpty).toBe(false);
+    });
+
+    it("send with mixed pending + complete attachments", async () => {
+      const pending = makePendingAttachment("att-pending");
+      const completedFromAdapter = {
+        id: "att-pending",
+        type: "file" as const,
+        name: "file.txt",
+        contentType: "text/plain",
+        content: [{ type: "text" as const, text: "file content" }],
+        status: { type: "complete" as const },
+      };
+      const adapter: AttachmentAdapter = {
+        accept: "*",
+        add: vi.fn().mockResolvedValue(pending),
+        remove: vi.fn(),
+        send: vi.fn().mockResolvedValue(completedFromAdapter),
+      };
+      composer.setAttachmentAdapter(adapter);
+
+      await composer.addAttachment(new File(["data"], "file.txt"));
+      await composer.addAttachment(makeCreateAttachment({ id: "ext-1" }));
+
+      expect(composer.attachments).toHaveLength(2);
+
+      composer.setText("hello");
+      await composer.send();
+
+      expect(composer.sentMessages).toHaveLength(1);
+      const msg = composer.sentMessages[0]!;
+      expect(msg.attachments).toHaveLength(2);
+      expect(adapter.send).toHaveBeenCalledTimes(1);
+    });
+
+    describe("adapter.accept enforcement", () => {
+      const makeImageAdapter = (): AttachmentAdapter => ({
+        accept: "image/*",
+        add: vi.fn(),
+        remove: vi.fn(),
+        send: vi.fn(),
+      });
+
+      it("rejects external attachment with contentType not matching adapter.accept", async () => {
+        composer.setAttachmentAdapter(makeImageAdapter());
+        const onError = vi.fn();
+        const onAdd = vi.fn();
+        composer.unstable_on("attachmentAddError", onError);
+        composer.unstable_on("attachmentAdd", onAdd);
+
+        await expect(
+          composer.addAttachment(
+            makeCreateAttachment({
+              name: "doc.pdf",
+              contentType: "application/pdf",
+            }),
+          ),
+        ).rejects.toThrow(/File type application\/pdf is not accepted/);
+
+        expect(composer.attachments).toHaveLength(0);
+        expect(onError).toHaveBeenCalledTimes(1);
+        expect(onError).toHaveBeenCalledWith(
+          expect.objectContaining({
+            reason: "not-accepted",
+            message: expect.stringContaining(
+              "File type application/pdf is not accepted",
+            ),
+            error: expect.any(Error),
+          }),
+        );
+        expect(onAdd).not.toHaveBeenCalled();
+      });
+
+      it("accepts external attachment with contentType matching adapter.accept", async () => {
+        composer.setAttachmentAdapter(makeImageAdapter());
+        const onError = vi.fn();
+
+        composer.unstable_on("attachmentAddError", onError);
+        await composer.addAttachment(
+          makeCreateAttachment({
+            name: "photo.png",
+            contentType: "image/png",
+          }),
+        );
+
+        expect(composer.attachments).toHaveLength(1);
+        expect(onError).not.toHaveBeenCalled();
+      });
+
+      it("accepts external attachment when only filename extension matches adapter.accept", async () => {
+        composer.setAttachmentAdapter({
+          accept: ".pdf",
+          add: vi.fn(),
+          remove: vi.fn(),
+          send: vi.fn(),
+        });
+
+        await composer.addAttachment(
+          makeCreateAttachment({ name: "report.pdf" }),
+        );
+
+        expect(composer.attachments).toHaveLength(1);
+      });
+
+      it("rejects external attachment when contentType missing and extension does not match", async () => {
+        composer.setAttachmentAdapter(makeImageAdapter());
+        const onError = vi.fn();
+        composer.unstable_on("attachmentAddError", onError);
+
+        await expect(
+          composer.addAttachment(makeCreateAttachment({ name: "notes.txt" })),
+        ).rejects.toThrow(/is not accepted/);
+
+        expect(onError).toHaveBeenCalledTimes(1);
+      });
+
+      it("adds external attachment without check when no adapter is configured", async () => {
+        await composer.addAttachment(
+          makeCreateAttachment({
+            name: "anything.xyz",
+            contentType: "application/x-anything",
+          }),
+        );
+
+        expect(composer.attachments).toHaveLength(1);
+      });
+
+      it("isolates a throwing attachmentAdd subscriber without firing attachmentAddError", async () => {
+        composer.setAttachmentAdapter(makeImageAdapter());
+        const listenerError = new Error("add subscriber boom");
+        const consoleError = vi
+          .spyOn(console, "error")
+          .mockImplementation(() => {});
+        const onError = vi.fn();
+        composer.unstable_on("attachmentAdd", () => {
+          throw listenerError;
+        });
+        composer.unstable_on("attachmentAddError", onError);
+
+        await expect(
+          composer.addAttachment(
+            makeCreateAttachment({
+              name: "photo.png",
+              contentType: "image/png",
+            }),
+          ),
+        ).resolves.toBeUndefined();
+
+        expect(composer.attachments).toHaveLength(1);
+        expect(onError).not.toHaveBeenCalled();
+        expect(consoleError).toHaveBeenCalledWith(
+          '[assistant-ui] Composer runtime "attachmentAdd" listener threw an error',
+          listenerError,
+        );
+        consoleError.mockRestore();
+      });
+
+      it("does not fire attachmentAddError when a state subscriber throws on add", async () => {
+        composer.setAttachmentAdapter(makeImageAdapter());
+        const onError = vi.fn();
+        composer.subscribe(() => {
+          throw new Error("state subscriber boom");
+        });
+        composer.unstable_on("attachmentAddError", onError);
+
+        await expect(
+          composer.addAttachment(
+            makeCreateAttachment({
+              name: "photo.png",
+              contentType: "image/png",
+            }),
+          ),
+        ).rejects.toThrow("state subscriber boom");
+
+        expect(composer.attachments).toHaveLength(1);
+        expect(onError).not.toHaveBeenCalled();
+      });
+    });
+  });
+});

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

@@ -27,7 +27,7 @@ describe("ExternalStoreThreadListRuntimeCore - construction", () => {
     expect(core.getItemById(core.mainThreadId)).toBeDefined();
   });
 
-  it("picks up mainThreadId from adapter.threadId on construction (regression: #2577)", () => {
+  it("picks up mainThreadId from adapter.threadId on construction", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha" }),
       makeFactory(),
@@ -147,7 +147,7 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
     expect(callback).toHaveBeenCalled();
   });
 
-  it("synthesizes mainThreadId entry after a switch to a threadId not in the threads list (regression: #3971)", () => {
+  it("synthesizes mainThreadId entry after a switch to a threadId not in the threads list", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha" }),
       makeFactory(),
@@ -158,7 +158,7 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
     expect(item?.id).toBe("thread-beta");
   });
 
-  it("does not retain stale synthesized entries across mainThreadId switches (regression: #3971)", () => {
+  it("does not retain stale synthesized entries across mainThreadId switches", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha" }),
       makeFactory(),
@@ -190,7 +190,7 @@ describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl"
     );
   };
 
-  it("reports isMain=true for adapter.threadId on construction (user-visible regression: #2577)", () => {
+  it("reports isMain=true for adapter.threadId on construction", () => {
     const impl = buildImpl({
       threadId: "thread-alpha",
       threads: [
@@ -215,7 +215,7 @@ describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl"
     expect(state.threadIds).toEqual(["thread-alpha", "thread-beta"]);
   });
 
-  it("does not throw when adapter.threadId has no matching threads entry (regression: #3971)", () => {
+  it("does not throw when adapter.threadId has no matching threads entry", () => {
     const impl = buildImpl({ threadId: "thread-alpha" });
     expect(impl.mainItem.getState().id).toBe("thread-alpha");
     expect(impl.mainItem.getState().isMain).toBe(true);
@@ -234,7 +234,7 @@ describe("ExternalStoreThreadListRuntimeCore - switchToThread", () => {
     expect(onSwitchToThread).toHaveBeenCalledWith("thread-beta");
   });
 
-  it("early-returns without calling onSwitchToThread when target equals initial threadId (regression: #2577)", async () => {
+  it("early-returns without calling onSwitchToThread when target equals initial threadId", async () => {
     const onSwitchToThread = vi.fn(async () => {});
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha", onSwitchToThread }),