@assistant-ui/react 0.12.10 → 0.12.12

package/src/primitives/threadListItem/ThreadListItemTitle.test.tsx

@@ -0,0 +1,56 @@
+import { describe, expect, it, vi } from "vitest";
+import { renderToStaticMarkup } from "react-dom/server";
+import type { ReactNode } from "react";
+import { ThreadListItemPrimitiveTitle } from "./ThreadListItemTitle";
+
+const mockUseAuiState = vi.fn();
+type UseAuiStateSelector = Parameters<
+  typeof import("@assistant-ui/store")["useAuiState"]
+>[0];
+
+vi.mock("@assistant-ui/store", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@assistant-ui/store")>();
+  return {
+    ...actual,
+    useAuiState: (selector: UseAuiStateSelector) => mockUseAuiState(selector),
+  };
+});
+
+const renderTitle = (
+  title: string | undefined,
+  fallback: ReactNode = "New Chat",
+) => {
+  mockUseAuiState.mockImplementation((selector: UseAuiStateSelector) =>
+    selector({ threadListItem: { title } } as never),
+  );
+
+  return renderToStaticMarkup(
+    <ThreadListItemPrimitiveTitle fallback={fallback} />,
+  );
+};
+
+describe("ThreadListItemPrimitiveTitle", () => {
+  it("renders the thread title text", () => {
+    const html = renderTitle("Weather Inquiry for San Francisco");
+
+    expect(html).toBe("Weather Inquiry for San Francisco");
+  });
+
+  it("renders fallback text when title is missing", () => {
+    const html = renderTitle(undefined, "New Chat");
+
+    expect(html).toBe("New Chat");
+  });
+
+  it("renders fallback text when title is an empty string", () => {
+    const html = renderTitle("", "New Chat");
+
+    expect(html).toBe("New Chat");
+  });
+
+  it("renders ReactNode fallback content", () => {
+    const html = renderTitle(undefined, <em>New Chat</em>);
+
+    expect(html).toBe("<em>New Chat</em>");
+  });
+});

package/src/primitives/threadListItem/ThreadListItemTitle.tsx

@@ -1,19 +1,3 @@
 "use client";
 
-import type { FC, ReactNode } from "react";
-import { useAuiState } from "@assistant-ui/store";
-
-export namespace ThreadListItemPrimitiveTitle {
-  export type Props = {
-    fallback?: ReactNode;
-  };
-}
-
-export const ThreadListItemPrimitiveTitle: FC<
-  ThreadListItemPrimitiveTitle.Props
-> = ({ fallback }) => {
-  const title = useAuiState((s) => s.threadListItem.title);
-  return <>{title || fallback}</>;
-};
-
-ThreadListItemPrimitiveTitle.displayName = "ThreadListItemPrimitive.Title";
+export { ThreadListItemPrimitiveTitle } from "@assistant-ui/core/react";

package/src/primitives/threadListItemMore/ThreadListItemMoreContent.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { ComponentPropsWithoutRef, ComponentRef, forwardRef } from "react";
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
 import { ScopedProps, useDropdownMenuScope } from "./scope";
 
 export namespace ThreadListItemMorePrimitiveContent {

package/src/primitives/threadListItemMore/ThreadListItemMoreItem.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { ComponentPropsWithoutRef, ComponentRef, forwardRef } from "react";
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
 import { ScopedProps, useDropdownMenuScope } from "./scope";
 
 export namespace ThreadListItemMorePrimitiveItem {

package/src/primitives/threadListItemMore/ThreadListItemMoreRoot.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { FC } from "react";
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
 import { ScopedProps, useDropdownMenuScope } from "./scope";
 
 export namespace ThreadListItemMorePrimitiveRoot {

package/src/primitives/threadListItemMore/ThreadListItemMoreSeparator.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { ComponentPropsWithoutRef, ComponentRef, forwardRef } from "react";
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
 import { ScopedProps, useDropdownMenuScope } from "./scope";
 
 export namespace ThreadListItemMorePrimitiveSeparator {

package/src/primitives/threadListItemMore/ThreadListItemMoreTrigger.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { ComponentPropsWithoutRef, ComponentRef, forwardRef } from "react";
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
 import { ScopedProps, useDropdownMenuScope } from "./scope";
 
 export namespace ThreadListItemMorePrimitiveTrigger {

package/src/primitives/threadListItemMore/{scope.tsx → scope.ts}

@@ -1,4 +1,4 @@
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
 import type { Scope } from "@radix-ui/react-context";
 
 export const useDropdownMenuScope: ReturnType<

package/src/tests/BaseComposerRuntimeCore.test.ts

@@ -0,0 +1,423 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { BaseComposerRuntimeCore } from "../legacy-runtime/runtime-cores/composer/BaseComposerRuntimeCore";
+import type { AttachmentAdapter } from "../legacy-runtime/runtime-cores/adapters/attachment";
+import type { DictationAdapter } from "../legacy-runtime/runtime-cores/adapters/speech/SpeechAdapterTypes";
+import type {
+  AppendMessage,
+  CreateAttachment,
+  PendingAttachment,
+} from "@assistant-ui/core";
+
+class TestComposerCore extends BaseComposerRuntimeCore {
+  private _attachmentAdapter: AttachmentAdapter | undefined;
+  private _dictationAdapter: DictationAdapter | undefined;
+  public sentMessages: Array<Omit<AppendMessage, "parentId" | "sourceId">> = [];
+  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;
+  }
+
+  protected handleSend(message: Omit<AppendMessage, "parentId" | "sourceId">) {
+    this.sentMessages.push(message);
+  }
+
+  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-4" } };
+    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 produces empty content array", async () => {
+    await composer.send();
+
+    expect(composer.sentMessages).toHaveLength(1);
+    expect(composer.sentMessages[0]!.content).toEqual([]);
+  });
+
+  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"));
+
+    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);
+    });
+  });
+});

package/src/tests/BaseSubscribable.test.ts

@@ -0,0 +1,54 @@
+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();
+  });
+});