@assistant-ui/react 0.14.27 → 0.14.29

package/src/tests/BaseComposerRuntimeCore.test.ts

@@ -1,612 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { BaseComposerRuntimeCore } from "../legacy-runtime/runtime-cores/composer/BaseComposerRuntimeCore";
-import type {
-  AppendMessage,
-  AttachmentAdapter,
-  CreateAttachment,
-  DictationAdapter,
-  PendingAttachment,
-  SendOptions,
-} from "@assistant-ui/core";
-
-class TestComposerCore extends BaseComposerRuntimeCore {
-  private _attachmentAdapter: AttachmentAdapter | undefined;
-  private _dictationAdapter: DictationAdapter | undefined;
-  public sentMessages: Array<Omit<AppendMessage, "parentId" | "sourceId">> = [];
-  public sentOptions: Array<SendOptions | undefined> = [];
-  public cancelCalled = false;
-
-  protected getAttachmentAdapter() {
-    return this._attachmentAdapter;
-  }
-  protected getDictationAdapter() {
-    return this._dictationAdapter;
-  }
-
-  setAttachmentAdapter(adapter: AttachmentAdapter | undefined) {
-    this._attachmentAdapter = adapter;
-  }
-
-  setDictationAdapter(adapter: DictationAdapter | undefined) {
-    this._dictationAdapter = 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() {
-    this.cancelCalled = true;
-  }
-}
-
-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("sets and gets text", () => {
-    composer.setText("hello");
-    expect(composer.text).toBe("hello");
-  });
-
-  it("setText does not notify when value unchanged", () => {
-    composer.setText("same");
-    const listener = vi.fn();
-    composer.subscribe(listener);
-
-    composer.setText("same");
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  it("isEmpty returns true when no text and no attachments", () => {
-    expect(composer.isEmpty).toBe(true);
-  });
-
-  it("isEmpty returns false when text is present", () => {
-    composer.setText("hi");
-    expect(composer.isEmpty).toBe(false);
-  });
-
-  it("isEmpty returns true for whitespace-only text", () => {
-    composer.setText("   ");
-    expect(composer.isEmpty).toBe(true);
-  });
-
-  it("sets and gets role", () => {
-    composer.setRole("assistant");
-    expect(composer.role).toBe("assistant");
-  });
-
-  it("setRole does not notify when value unchanged", () => {
-    composer.setRole("user");
-    const listener = vi.fn();
-    composer.subscribe(listener);
-
-    composer.setRole("user");
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  it("sets and gets runConfig", () => {
-    const config = { custom: { model: "gpt-5.4-nano" } };
-    composer.setRunConfig(config);
-    expect(composer.runConfig).toBe(config);
-  });
-
-  it("sets and gets quote", () => {
-    const quote = { text: "some quote", messageId: "msg-1" };
-    composer.setQuote(quote);
-    expect(composer.quote).toBe(quote);
-  });
-
-  it("setQuote does not notify when value unchanged", () => {
-    const quote = { text: "q", messageId: "m1" };
-    composer.setQuote(quote);
-    const listener = vi.fn();
-    composer.subscribe(listener);
-
-    composer.setQuote(quote);
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  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 nothing when already in default state", async () => {
-    const listener = vi.fn();
-    composer.subscribe(listener);
-
-    await composer.reset();
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  it("send constructs message with text content and fires send event", async () => {
-    composer.setText("hello world");
-
-    await composer.send();
-
-    expect(composer.sentMessages).toHaveLength(1);
-    const msg = composer.sentMessages[0]!;
-    expect(msg.role).toBe("user");
-    expect(msg.content).toEqual([{ type: "text", text: "hello world" }]);
-    expect(msg.attachments).toEqual([]);
-  });
-
-  it("send clears text and attachments after sending", async () => {
-    composer.setText("hello");
-
-    await composer.send();
-
-    expect(composer.text).toBe("");
-    expect(composer.attachments).toEqual([]);
-  });
-
-  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("send with empty text is a no-op", async () => {
-    await composer.send();
-
-    expect(composer.sentMessages).toHaveLength(0);
-  });
-
-  it("addAttachment throws when no adapter", async () => {
-    const file = new File(["data"], "test.txt");
-    await expect(composer.addAttachment(file)).rejects.toThrow(
-      "Attachments are not supported",
-    );
-  });
-
-  it("addAttachment adds via adapter", async () => {
-    const pending = makePendingAttachment("att-1", "test.txt");
-    const adapter: AttachmentAdapter = {
-      accept: "text/*",
-      add: vi.fn().mockResolvedValue(pending),
-      remove: vi.fn().mockResolvedValue(undefined),
-      send: vi.fn(),
-    };
-    composer.setAttachmentAdapter(adapter);
-
-    await composer.addAttachment(
-      new File(["data"], "test.txt", { type: "text/plain" }),
-    );
-
-    expect(composer.attachments).toHaveLength(1);
-    expect(composer.attachments[0]!.id).toBe("att-1");
-  });
-
-  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 registers event listener for send", async () => {
-    const callback = vi.fn();
-    composer.unstable_on("send", callback);
-
-    composer.setText("test");
-    await composer.send();
-
-    expect(callback).toHaveBeenCalledTimes(1);
-  });
-
-  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("unstable_on fires attachmentAdd event", async () => {
-    const callback = vi.fn();
-    composer.unstable_on("attachmentAdd", callback);
-
-    const pending = makePendingAttachment("att-1");
-    const adapter: AttachmentAdapter = {
-      accept: "*",
-      add: vi.fn().mockResolvedValue(pending),
-      remove: vi.fn(),
-      send: vi.fn(),
-    };
-    composer.setAttachmentAdapter(adapter);
-
-    await composer.addAttachment(new File([""], "f.txt"));
-    expect(callback).toHaveBeenCalledTimes(1);
-  });
-
-  it("isEditing is always true", () => {
-    expect(composer.isEditing).toBe(true);
-  });
-
-  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/*");
-  });
-
-  it("cancel delegates to handleCancel", () => {
-    composer.cancel();
-    expect(composer.cancelCalled).toBe(true);
-  });
-
-  it("subscribe notifies on text change", () => {
-    const listener = vi.fn();
-    composer.subscribe(listener);
-
-    composer.setText("new");
-    expect(listener).toHaveBeenCalledTimes(1);
-  });
-
-  it("subscribe returns working unsubscribe function", () => {
-    const listener = vi.fn();
-    const unsub = composer.subscribe(listener);
-    unsub();
-
-    composer.setText("change");
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  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 () => {
-      // No adapter set — should still work
-      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);
-
-      // No adapter set — should still remove complete attachments
-      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);
-
-      // Add a file-based attachment via adapter
-      await composer.addAttachment(new File(["data"], "file.txt"));
-      // Add an external attachment
-      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);
-      // Pending was sent through adapter
-      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 () => {
-        // No adapter — preserves the original "no adapter required" guarantee
-        await composer.addAttachment(
-          makeCreateAttachment({
-            name: "anything.xyz",
-            contentType: "application/x-anything",
-          }),
-        );
-
-        expect(composer.attachments).toHaveLength(1);
-      });
-
-      it("does not let subscriber errors mask the original throw", async () => {
-        composer.setAttachmentAdapter(makeImageAdapter());
-        composer.unstable_on("attachmentAddError", () => {
-          throw new Error("subscriber boom");
-        });
-
-        await expect(
-          composer.addAttachment(
-            makeCreateAttachment({
-              name: "doc.pdf",
-              contentType: "application/pdf",
-            }),
-          ),
-        ).rejects.toThrow(/is not accepted/);
-      });
-
-      it("does not fire attachmentAddError when an attachmentAdd subscriber throws", async () => {
-        composer.setAttachmentAdapter(makeImageAdapter());
-        const onError = vi.fn();
-        composer.unstable_on("attachmentAdd", () => {
-          throw new Error("add subscriber boom");
-        });
-        composer.unstable_on("attachmentAddError", onError);
-
-        await expect(
-          composer.addAttachment(
-            makeCreateAttachment({
-              name: "photo.png",
-              contentType: "image/png",
-            }),
-          ),
-        ).rejects.toThrow("add subscriber boom");
-
-        expect(composer.attachments).toHaveLength(1);
-        expect(onError).not.toHaveBeenCalled();
-      });
-
-      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();
-      });
-    });
-  });
-
-  describe("send options", () => {
-    it("send() passes undefined options by default", async () => {
-      composer.setText("hello");
-      await composer.send();
-
-      expect(composer.sentOptions).toHaveLength(1);
-      expect(composer.sentOptions[0]).toBeUndefined();
-    });
-
-    it("send({ startRun: true }) forwards options to handleSend", async () => {
-      composer.setText("hello");
-      await composer.send({ startRun: true });
-
-      expect(composer.sentOptions).toHaveLength(1);
-      expect(composer.sentOptions[0]).toEqual({ startRun: true });
-    });
-
-    it("send({ startRun: false }) forwards options to handleSend", async () => {
-      composer.setText("hello");
-      await composer.send({ startRun: false });
-
-      expect(composer.sentOptions).toHaveLength(1);
-      expect(composer.sentOptions[0]).toEqual({ startRun: false });
-    });
-  });
-});

package/src/tests/BaseSubscribable.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { BaseSubscribable } from "@assistant-ui/core/internal";
-
-class TestSubscribable extends BaseSubscribable {
-  public notify() {
-    this._notifySubscribers();
-  }
-}
-
-describe("BaseSubscribable", () => {
-  let subscribable: TestSubscribable;
-
-  beforeEach(() => {
-    subscribable = new TestSubscribable();
-  });
-
-  it("subscribe registers a callback that is called on notify", () => {
-    const callback = vi.fn();
-    subscribable.subscribe(callback);
-    subscribable.notify();
-    expect(callback).toHaveBeenCalledOnce();
-  });
-
-  it("unsubscribe stops notifications", () => {
-    const callback = vi.fn();
-    const unsub = subscribable.subscribe(callback);
-    unsub();
-    subscribable.notify();
-    expect(callback).not.toHaveBeenCalled();
-  });
-
-  it("multiple subscribers all get notified", () => {
-    const cb1 = vi.fn();
-    const cb2 = vi.fn();
-    subscribable.subscribe(cb1);
-    subscribable.subscribe(cb2);
-    subscribable.notify();
-    expect(cb1).toHaveBeenCalledOnce();
-    expect(cb2).toHaveBeenCalledOnce();
-  });
-
-  it("subscribe returns an unsubscribe function", () => {
-    const cb1 = vi.fn();
-    const cb2 = vi.fn();
-    const unsub1 = subscribable.subscribe(cb1);
-    subscribable.subscribe(cb2);
-
-    unsub1();
-    subscribable.notify();
-
-    expect(cb1).not.toHaveBeenCalled();
-    expect(cb2).toHaveBeenCalledOnce();
-  });
-});