@assistant-ui/core 0.3.12 → 0.3.14

package/src/tests/external-thread-attachments.test.tsx

@@ -9,6 +9,10 @@ import type {
   ExternalThreadProps,
 } from "../store/clients/external-thread";
 import { ExternalThread } from "../store/clients/external-thread";
+import type {
+  CompleteAttachment,
+  PendingAttachment,
+} from "../types/attachment";
 
 const renderThreadWithProps = (props: Partial<ExternalThreadProps>) => {
   const captured: { aui?: ReturnType<typeof useAui> } = {};
@@ -215,6 +219,59 @@ describe("ExternalThread attachments", () => {
     );
   });
 
+  it("preserves composer state while attachments are prepared for send", async () => {
+    let resolveSend!: (attachment: CompleteAttachment) => void;
+    const onNew = vi.fn();
+    const file = new File(["data"], "notes.txt", { type: "text/plain" });
+    const adapter = {
+      accept: "*",
+      add: async () => ({
+        id: "att-1",
+        type: "file" as const,
+        name: file.name,
+        contentType: file.type,
+        file,
+        status: {
+          type: "requires-action" as const,
+          reason: "composer-send" as const,
+        },
+      }),
+      send: () =>
+        new Promise<CompleteAttachment>((resolve) => {
+          resolveSend = resolve;
+        }),
+      remove: async () => {},
+    };
+    const aui = renderThreadWithProps({ attachmentAdapter: adapter, onNew });
+    const composer = () => aui().thread.composer();
+
+    await act(() => composer().addAttachment(file));
+    act(() => {
+      composer().setText("first message");
+      composer().setRole("assistant");
+      composer().setRunConfig({ model: "model-a" });
+      composer().send();
+      composer().setRole("system");
+      composer().setRunConfig({ model: "model-b" });
+    });
+    await act(async () => {
+      resolveSend({
+        id: "att-1",
+        type: "file",
+        name: file.name,
+        contentType: file.type,
+        status: { type: "complete" },
+        content: [],
+      });
+    });
+
+    await waitFor(() => expect(onNew).toHaveBeenCalledTimes(1));
+    expect(onNew.mock.calls[0]![0]).toMatchObject({
+      role: "assistant",
+      runConfig: { model: "model-a" },
+    });
+  });
+
   it.each([
     [
       "clearAttachments",
@@ -263,6 +320,163 @@ describe("ExternalThread attachments", () => {
     },
   );
 
+  it.each([
+    [
+      "clearAttachments",
+      (c: { clearAttachments(): Promise<void> }) => c.clearAttachments(),
+    ],
+    ["reset", (c: { reset(): Promise<void> }) => c.reset()],
+  ] as const)(
+    "does not restore an attachment that resolves after %s",
+    async (_name, invoke) => {
+      let resolveAdd!: (attachment: PendingAttachment) => void;
+      const add = vi.fn(
+        () =>
+          new Promise<PendingAttachment>((resolve) => {
+            resolveAdd = resolve;
+          }),
+      );
+      const aui = renderThreadWithProps({
+        attachmentAdapter: {
+          accept: "*",
+          add,
+          send: async () => ({}) as never,
+          remove: async () => {},
+        },
+      });
+      const file = new File(["data"], "notes.txt", { type: "text/plain" });
+
+      let addPromise!: Promise<void>;
+      act(() => {
+        addPromise = aui().thread.composer().addAttachment(file);
+      });
+      await act(() => invoke(aui().thread.composer()));
+      await act(async () => {
+        resolveAdd({
+          id: "att-1",
+          type: "file",
+          name: file.name,
+          contentType: file.type,
+          file,
+          status: { type: "requires-action", reason: "composer-send" },
+        });
+        await addPromise;
+      });
+
+      expect(aui().thread.composer().getState().attachments).toHaveLength(0);
+    },
+  );
+
+  it("stops attachment generator updates after removal", async () => {
+    let resumeAdd!: () => void;
+    const drainedAfterRemoval = vi.fn();
+    const file = new File(["data"], "notes.txt", { type: "text/plain" });
+    const pendingAttachment: PendingAttachment = {
+      id: "att-1",
+      type: "file",
+      name: file.name,
+      contentType: file.type,
+      file,
+      status: { type: "requires-action", reason: "composer-send" },
+    };
+    const add = vi.fn(async function* () {
+      yield pendingAttachment;
+      await new Promise<void>((resolve) => {
+        resumeAdd = resolve;
+      });
+      yield {
+        ...pendingAttachment,
+        status: { type: "running", reason: "uploading", progress: 1 },
+      } satisfies PendingAttachment;
+      drainedAfterRemoval();
+    });
+    const aui = renderThreadWithProps({
+      attachmentAdapter: {
+        accept: "*",
+        add,
+        send: async () => ({}) as never,
+        remove: async () => {},
+      },
+    });
+    const composer = () => aui().thread.composer();
+
+    let addPromise!: Promise<void>;
+    act(() => {
+      addPromise = composer().addAttachment(file);
+    });
+    await waitFor(() =>
+      expect(composer().getState().attachments).toHaveLength(1),
+    );
+    await act(() => composer().attachment({ id: "att-1" }).remove());
+    await act(async () => {
+      resumeAdd();
+      await addPromise;
+    });
+
+    expect(composer().getState().attachments).toHaveLength(0);
+    expect(drainedAfterRemoval).not.toHaveBeenCalled();
+  });
+
+  it("does not restore attachment generator updates after send", async () => {
+    let resumeAdd!: () => void;
+    const drainedAfterSend = vi.fn();
+    const onNew = vi.fn();
+    const file = new File(["data"], "notes.txt", { type: "text/plain" });
+    const pendingAttachment: PendingAttachment = {
+      id: "att-1",
+      type: "file",
+      name: file.name,
+      contentType: file.type,
+      file,
+      status: { type: "requires-action", reason: "composer-send" },
+    };
+    const add = vi.fn(async function* () {
+      yield pendingAttachment;
+      await new Promise<void>((resolve) => {
+        resumeAdd = resolve;
+      });
+      yield {
+        ...pendingAttachment,
+        status: { type: "running", reason: "uploading", progress: 1 },
+      } satisfies PendingAttachment;
+      drainedAfterSend();
+    });
+    const aui = renderThreadWithProps({
+      attachmentAdapter: {
+        accept: "*",
+        add,
+        send: async (attachment) => ({
+          ...attachment,
+          status: { type: "complete" },
+          content: [],
+        }),
+        remove: async () => {},
+      },
+      onNew,
+    });
+    const composer = () => aui().thread.composer();
+
+    let addPromise!: Promise<void>;
+    act(() => {
+      addPromise = composer().addAttachment(file);
+    });
+    await waitFor(() =>
+      expect(composer().getState().attachments).toHaveLength(1),
+    );
+    act(() => {
+      composer().setText("hello");
+      composer().send();
+    });
+    await waitFor(() => expect(onNew).toHaveBeenCalledTimes(1));
+    await act(async () => {
+      resumeAdd();
+      await addPromise;
+    });
+
+    expect(composer().getState().attachments).toHaveLength(0);
+    expect(drainedAfterSend).not.toHaveBeenCalled();
+  });
+
   it("routes edit-composer attachments through the adapter", async () => {
     const add = vi.fn(async ({ file }: { file: File }) => ({
       id: "att-edit",

package/src/tests/external-thread-parity.test.tsx

@@ -279,6 +279,60 @@ describe("ExternalThread composer", () => {
     expect(enqueue).not.toHaveBeenCalled();
   });
 
+  it("pauses the queue on cancel", async () => {
+    const notifyCancelled = vi.fn();
+    const onCancel = vi.fn();
+    const { aui } = renderThread({
+      messages: [],
+      isRunning: true,
+      onCancel,
+      queue: {
+        items: [],
+        steerItems: [],
+        enqueue: vi.fn(),
+        steer: vi.fn(),
+        move: vi.fn(),
+        edit: vi.fn(),
+        remove: vi.fn(),
+        __internal_notifyCancelled: notifyCancelled,
+      },
+    });
+
+    aui().thread.cancelRun();
+
+    expect(notifyCancelled).toHaveBeenCalledTimes(1);
+    expect(onCancel).toHaveBeenCalledTimes(1);
+    expect(notifyCancelled.mock.invocationCallOrder[0]!).toBeLessThan(
+      onCancel.mock.invocationCallOrder[0]!,
+    );
+    expect(aui().thread.getState().capabilities.cancel).toBe(true);
+    expect(aui().thread.composer().getState().canCancel).toBe(true);
+  });
+
+  it("leaves the queue alone when the host cannot cancel", async () => {
+    const notifyCancelled = vi.fn();
+    const { aui } = renderThread({
+      messages: [],
+      isRunning: true,
+      queue: {
+        items: [],
+        steerItems: [],
+        enqueue: vi.fn(),
+        steer: vi.fn(),
+        move: vi.fn(),
+        edit: vi.fn(),
+        remove: vi.fn(),
+        __internal_notifyCancelled: notifyCancelled,
+      },
+    });
+
+    aui().thread.cancelRun();
+
+    expect(notifyCancelled).not.toHaveBeenCalled();
+    expect(aui().thread.getState().capabilities.cancel).toBe(false);
+    expect(aui().thread.composer().getState().canCancel).toBe(false);
+  });
+
   it("routes edit-composer sends to onEdit with sourceId, bypassing the queue", async () => {
     const onEdit = vi.fn();
     const enqueue = vi.fn();

package/src/tests/external-thread-refetch.test.tsx

@@ -0,0 +1,117 @@
+// @vitest-environment jsdom
+
+import { cleanup, render, waitFor } from "@testing-library/react";
+import type { FC } from "react";
+import { useState } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AuiProvider, useAui } from "@assistant-ui/store";
+import { ExternalThread } from "../store/clients/external-thread";
+import type { ThreadMessage } from "../types/message";
+
+const message = (id: string, role: "user" | "assistant"): ThreadMessage =>
+  ({
+    id,
+    role,
+    content: [{ type: "text", text: `text of ${id}` }],
+    createdAt: new Date(1718000000000),
+    ...(role === "assistant"
+      ? { status: { type: "complete", reason: "stop" } }
+      : { attachments: [] }),
+    metadata: { custom: {} },
+  }) as ThreadMessage;
+
+let aui!: ReturnType<typeof useAui>;
+
+const Capture: FC = () => {
+  aui = useAui();
+  return null;
+};
+
+const renderThread = (props: Parameters<typeof ExternalThread>[0]) => {
+  const App: FC = () => {
+    const value = useAui({ thread: ExternalThread(props) });
+    return (
+      <AuiProvider value={value}>
+        <Capture />
+      </AuiProvider>
+    );
+  };
+  render(<App />);
+};
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("ExternalThread refetch", () => {
+  it("routes reloadMainThread to onRefetchThread and reports the capability", async () => {
+    const onRefetchThread = vi.fn(async () => {});
+    renderThread({ messages: [], onRefetchThread });
+
+    await waitFor(() =>
+      expect(
+        aui.threads.thread("main").getState().capabilities.refetchThread,
+      ).toBe(true),
+    );
+
+    await aui.threads.reloadMainThread();
+    expect(onRefetchThread).toHaveBeenCalledTimes(1);
+  });
+
+  it("resolves reloadMainThread without a callback and reports the capability off", async () => {
+    renderThread({ messages: [] });
+
+    await waitFor(() =>
+      expect(
+        aui.threads.thread("main").getState().capabilities.refetchThread,
+      ).toBe(false),
+    );
+
+    await expect(aui.threads.reloadMainThread()).resolves.toBeUndefined();
+  });
+
+  it("propagates a refetch rejection to the caller", async () => {
+    const onRefetchThread = vi.fn(async () => {
+      throw new Error("refetch failed");
+    });
+    renderThread({ messages: [], onRefetchThread });
+
+    await waitFor(() =>
+      expect(
+        aui.threads.thread("main").getState().capabilities.refetchThread,
+      ).toBe(true),
+    );
+
+    await expect(aui.threads.reloadMainThread()).rejects.toThrow(
+      "refetch failed",
+    );
+  });
+
+  it("applies refetched messages in place with the composer draft intact", async () => {
+    const App: FC = () => {
+      const [messages, setMessages] = useState<readonly ThreadMessage[]>([]);
+      const value = useAui({
+        thread: ExternalThread({
+          messages,
+          onRefetchThread: async () => {
+            setMessages([message("a1", "assistant")]);
+          },
+        }),
+      });
+      return (
+        <AuiProvider value={value}>
+          <Capture />
+        </AuiProvider>
+      );
+    };
+    render(<App />);
+
+    aui.thread.composer().setText("draft");
+    await aui.threads.reloadMainThread();
+
+    await waitFor(() =>
+      expect(aui.thread.getState().messages.map((m) => m.id)).toEqual(["a1"]),
+    );
+    expect(aui.thread.composer().getState().text).toBe("draft");
+  });
+});

package/src/tests/external-thread-suggestions.test.tsx

@@ -0,0 +1,59 @@
+// @vitest-environment jsdom
+
+import { cleanup, render } from "@testing-library/react";
+import type { FC, ReactNode } 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 childAui!: ReturnType<typeof useAui>;
+
+const CaptureChild: FC = () => {
+  childAui = useAui();
+  return null;
+};
+
+const Child: FC = () => {
+  const aui = useAui({ thread: ExternalThread({ messages: [] }) });
+  return (
+    <AuiProvider value={aui}>
+      <CaptureChild />
+    </AuiProvider>
+  );
+};
+
+const Parent: FC<{ children: ReactNode }> = ({ children }) => {
+  const aui = useAui({
+    threads: SingleThreadList({ thread: ExternalThread({ messages: [] }) }),
+  });
+  return <AuiProvider value={aui}>{children}</AuiProvider>;
+};
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("ExternalThread suggestions scope", () => {
+  it("derives the scope from its own thread when standalone", () => {
+    render(<Child />);
+
+    expect(childAui.suggestions.getState()).toEqual({ suggestions: [] });
+    expect(childAui.suggestions.getState()).toBe(
+      childAui.thread.suggestions().getState(),
+    );
+  });
+
+  it("derives the scope from its own thread when nested under a threads parent", () => {
+    render(
+      <Parent>
+        <Child />
+      </Parent>,
+    );
+
+    expect(childAui.suggestions.getState()).toEqual({ suggestions: [] });
+    expect(childAui.suggestions.getState()).toBe(
+      childAui.thread.suggestions().getState(),
+    );
+  });
+});

package/src/tests/interactables-toolui-migration.test.tsx

@@ -0,0 +1,66 @@
+// @vitest-environment jsdom
+
+import { act, cleanup, render } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { withKey } from "@assistant-ui/tap";
+import { useAui } from "@assistant-ui/store";
+import { Tools } from "../react/client/Tools";
+import { unstable_Interactables } from "../react/client/Interactables";
+
+type AnyClient = Record<string, any>;
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("interactables update-tool UI registration", () => {
+  it("migrates to a structurally replaced tools scope", async () => {
+    let aui!: AnyClient;
+    const Harness = ({ generation }: { generation: number }) => {
+      aui = useAui({
+        tools: withKey(String(generation), Tools({})),
+        unstable_interactables: unstable_Interactables({}),
+      } as never);
+      return null;
+    };
+    const view = render(<Harness generation={0} />);
+
+    const toolUIs = () =>
+      (aui.tools().getState().toolUIs ?? {}) as Record<string, unknown[]>;
+    // setToolUI lands after the tap scheduler drains its macrotask
+    await act(async () => {
+      aui.unstable_interactables.register({
+        id: "call-1",
+        name: "note",
+        description: "a note",
+        stateSchema: { type: "object", properties: {} },
+        initialState: {},
+        updateRender: () => null,
+      });
+      await vi.waitFor(() => expect(Object.keys(toolUIs())).toHaveLength(1));
+    });
+    const [toolName] = Object.keys(toolUIs());
+    const firstRegistration = toolUIs()[toolName!]![0];
+
+    // A rerender inside an outer act would not land until that act exits,
+    // so the swap happens first and only the scheduler wait is wrapped
+    view.rerender(<Harness generation={1} />);
+
+    // The remounted tools scope starts from fresh state; a registration
+    // object distinct from the pre-swap one proves the retained entry was
+    // re-applied on the replacement instance rather than read stale. It
+    // lands one scheduler macrotask after the swap, once the tap scheduler
+    // drains.
+    await act(async () => {
+      await vi.waitFor(() => {
+        const registration = toolUIs()[toolName!]?.[0];
+        expect(registration).toBeDefined();
+        expect(registration).not.toBe(firstRegistration);
+      });
+    });
+
+    // Post-settle cardinality: a duplicate re-apply would leave a second
+    // registration whose disposer was dropped
+    expect(toolUIs()[toolName!]).toHaveLength(1);
+  });
+});

package/src/tests/message-queue.test.ts

@@ -612,6 +612,34 @@ describe("createMessageQueue", () => {
     expect(cb).toHaveBeenCalled();
   });
 
+  it("isolates subscriber errors while enqueueing", () => {
+    const run = vi.fn();
+    const { adapter, subscribe } = createMessageQueue({ run });
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    subscribe(() => {
+      throw error;
+    });
+    subscribe(laterSubscriber);
+
+    try {
+      expect(() => adapter.enqueue(msg("a"), { steer: false })).not.toThrow();
+      expect(run).toHaveBeenCalledTimes(1);
+      expect(adapter.items).toHaveLength(0);
+      expect(laterSubscriber).toHaveBeenCalledTimes(2);
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] Message queue listener threw an error",
+        error,
+      );
+    } finally {
+      consoleError.mockRestore();
+    }
+  });
+
   it("buffers when a run started outside the queue is marked busy", () => {
     const run = vi.fn();
     const { adapter, notifyBusy, notifyIdle } = createMessageQueue({ run });
@@ -626,3 +654,29 @@ describe("createMessageQueue", () => {
     expect(adapter.items).toHaveLength(0);
   });
 });
+
+describe("createMessageQueue interrupt with a runtime-routed cancel", () => {
+  it("keeps draining when the driver's cancel notifies back", () => {
+    const runs: string[] = [];
+    const controller = createMessageQueue({
+      run: (message) => {
+        runs.push(
+          message.content[0]!.type === "text" ? message.content[0].text : "",
+        );
+      },
+      cancel: () => controller.notifyCancelled(),
+    });
+
+    controller.adapter.enqueue(msg("first"));
+    controller.adapter.enqueue(msg("second"));
+    controller.adapter.steer(msg("steered"));
+
+    expect(runs).toEqual(["first", "steered"]);
+
+    // the interrupted run and the steer run each settle once
+    controller.notifyIdle();
+    controller.notifyIdle();
+
+    expect(runs).toEqual(["first", "steered", "second"]);
+  });
+});