@assistant-ui/core 0.2.21 → 0.2.23

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/default-edit-composer-runtime-core.test.ts

@@ -4,11 +4,13 @@ import type { AppendMessage, ThreadMessage } from "../types/message";
 import type { CompleteAttachment } from "../types/attachment";
 import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
 
-const makeRuntime = (options?: {
-  messages?: ThreadMessage[];
-  composerMetadata?: Record<string, unknown>;
-}) => {
-  const append = vi.fn();
+const makeRuntime = (
+  options?: {
+    messages?: ThreadMessage[];
+    composerMetadata?: Record<string, unknown>;
+  },
+  append = vi.fn(),
+) => {
   const runtime = {
     append,
     composer: { runConfig: {} },
@@ -375,6 +377,42 @@ describe("DefaultEditComposerRuntimeCore", () => {
       expect(endEdit).toHaveBeenCalledTimes(1);
     });
 
+    it("tracks the append task while exiting edit mode immediately", async () => {
+      let resolveAppend!: () => void;
+      const appendTask = new Promise<void>((resolve) => {
+        resolveAppend = resolve;
+      });
+      const { runtime } = makeRuntime(
+        undefined,
+        vi.fn(() => appendTask),
+      );
+      const endEdit = vi.fn();
+      const composer = new DefaultEditComposerRuntimeCore(runtime, endEdit, {
+        parentId: null,
+        message: makeUserMessage(),
+      });
+
+      const sendTask = composer.handleSend({
+        createdAt: new Date(),
+        role: "user",
+        content: [{ type: "text", text: "changed" }],
+        attachments: [],
+        runConfig: {},
+        metadata: { custom: {} },
+      });
+      let settled = false;
+      void sendTask.then(() => {
+        settled = true;
+      });
+      await Promise.resolve();
+
+      expect(endEdit).toHaveBeenCalledTimes(1);
+      expect(settled).toBe(false);
+
+      resolveAppend();
+      await sendTask;
+    });
+
     it("invokes endEditCallback on cancel", () => {
       const endEdit = vi.fn();
       const { runtime } = makeRuntime();

package/src/tests/event-subscription-listener-errors.test.ts

@@ -0,0 +1,205 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  ThreadComposerRuntimeImpl,
+  type ThreadComposerRuntimeCoreBinding,
+} from "../runtime/api/composer-runtime";
+import {
+  ThreadRuntimeImpl,
+  type ThreadListItemRuntimeBinding,
+  type ThreadRuntimeCoreBinding,
+} from "../runtime/api/thread-runtime";
+import { ThreadListItemRuntimeImpl } from "../runtime/api/thread-list-item-runtime";
+import type { ThreadListRuntimeCoreBinding } from "../runtime/api/thread-list-runtime";
+import { ReadonlyThreadRuntimeCore } from "../runtimes/readonly/ReadonlyThreadRuntimeCore";
+import type { Unsubscribe } from "../types/unsubscribe";
+
+type EventListener = (payload?: unknown) => unknown;
+
+class GuardedEventSource {
+  private listeners = new Set<EventListener>();
+
+  public unstable_on = (
+    _event: string,
+    listener: EventListener,
+  ): Unsubscribe => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+
+  public emit(payload?: unknown) {
+    for (const listener of this.listeners) {
+      try {
+        const result = listener(payload);
+        if (
+          typeof result === "object" &&
+          result !== null &&
+          "then" in result &&
+          typeof result.then === "function"
+        ) {
+          void Promise.resolve(result).catch((error) => {
+            console.error("[test source] listener error", error);
+          });
+        }
+      } catch (error) {
+        console.error("[test source] listener error", error);
+      }
+    }
+  }
+}
+
+type RuntimeHarness = {
+  subscribe: (listener: EventListener) => Unsubscribe;
+  emit: () => void;
+  errorContext: string;
+};
+
+const makeComposerHarness = (): RuntimeHarness => {
+  const source = new GuardedEventSource();
+  const binding = {
+    path: {
+      ref: "test.composer",
+      threadSelector: { type: "main" },
+      composerSource: "thread",
+    },
+    getState: () => ({ unstable_on: source.unstable_on }),
+    subscribe: () => () => {},
+  } as unknown as ThreadComposerRuntimeCoreBinding;
+  const runtime = new ThreadComposerRuntimeImpl(binding);
+
+  return {
+    subscribe: (listener) =>
+      runtime.unstable_on("attachmentAdd", listener as never),
+    emit: () => source.emit({}),
+    errorContext: 'Runtime event "attachmentAdd"',
+  };
+};
+
+const makeThreadHarness = (): RuntimeHarness => {
+  const source = new GuardedEventSource();
+  const core = new ReadonlyThreadRuntimeCore();
+  core.unstable_on = source.unstable_on as typeof core.unstable_on;
+
+  const path = {
+    ref: "test.thread",
+    threadSelector: { type: "main" as const },
+  };
+  const threadBinding: ThreadRuntimeCoreBinding = {
+    path,
+    getState: () => core,
+    subscribe: (listener) => core.subscribe(listener),
+    outerSubscribe: (listener) => core.subscribe(listener),
+  };
+  const threadListItemBinding: ThreadListItemRuntimeBinding = {
+    path,
+    getState: () => ({
+      id: "test",
+      remoteId: undefined,
+      externalId: undefined,
+      isMain: true,
+      status: "regular",
+      title: undefined,
+    }),
+    subscribe: () => () => {},
+  };
+  const runtime = new ThreadRuntimeImpl(threadBinding, threadListItemBinding);
+
+  return {
+    subscribe: (listener) => runtime.unstable_on("initialize", listener),
+    emit: () => source.emit({}),
+    errorContext: 'Runtime event "initialize"',
+  };
+};
+
+const makeThreadListItemHarness = (): RuntimeHarness => {
+  let isMain = true;
+  const stateListeners = new Set<() => void>();
+  const binding = {
+    path: {
+      ref: "test.threadListItem",
+      threadSelector: { type: "main" as const },
+    },
+    getState: () => ({
+      id: "test",
+      remoteId: undefined,
+      externalId: undefined,
+      isMain,
+      status: "regular" as const,
+      title: undefined,
+    }),
+    subscribe: (listener: () => void) => {
+      stateListeners.add(listener);
+      return () => stateListeners.delete(listener);
+    },
+  } as unknown as ThreadListItemRuntimeBinding;
+  const runtime = new ThreadListItemRuntimeImpl(
+    binding,
+    {} as ThreadListRuntimeCoreBinding,
+  );
+
+  return {
+    subscribe: (listener) =>
+      runtime.unstable_on("switchedAway", listener as never),
+    emit: () => {
+      isMain = !isMain;
+      for (const listener of [...stateListeners]) listener();
+    },
+    errorContext: 'Thread list item "switchedAway"',
+  };
+};
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe.each([
+  ["composer", makeComposerHarness],
+  ["thread", makeThreadHarness],
+  ["thread list item", makeThreadListItemHarness],
+] as const)("%s public unstable_on", (_name, makeHarness) => {
+  it("continues notifying sibling listeners after a synchronous error", () => {
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const harness = makeHarness();
+    const sibling = vi.fn();
+
+    harness.subscribe(() => {
+      throw new Error("listener failed");
+    });
+    harness.subscribe(sibling);
+
+    harness.emit();
+
+    expect(sibling).toHaveBeenCalledOnce();
+  });
+
+  it.each(["object", "function"] as const)(
+    "handles rejected %s thenables returned by listeners",
+    async (thenableType) => {
+      const consoleError = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      const harness = makeHarness();
+      const listenerError = new Error("async listener failed");
+      const then = vi.fn(
+        (
+          _resolve: (value?: unknown) => void,
+          reject: (reason?: unknown) => void,
+        ) => reject(listenerError),
+      );
+      const thenable =
+        thenableType === "function"
+          ? Object.assign(() => {}, { then })
+          : { then };
+
+      harness.subscribe(() => thenable);
+      harness.emit();
+
+      await vi.waitFor(() => {
+        expect(then).toHaveBeenCalledOnce();
+        expect(consoleError).toHaveBeenCalledWith(
+          expect.stringContaining(harness.errorContext),
+          listenerError,
+        );
+      });
+    },
+  );
+});