@assistant-ui/core 0.3.11 → 0.3.13

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

@@ -0,0 +1,548 @@
+// @vitest-environment jsdom
+
+// Legacy-runtime parity: part statuses derive from the message status, and
+// imperative composer call sequences observe writes before React re-renders.
+
+import { render, waitFor } from "@testing-library/react";
+import type { FC } from "react";
+import { describe, it, expect, vi } from "vitest";
+import { useAui, AuiProvider } from "@assistant-ui/store";
+import type { ThreadMessage } from "../index";
+import {
+  ExternalThread,
+  type ExternalThreadProps,
+  type ExternalThreadMessage,
+} from "../store/clients/external-thread";
+
+const renderThread = (props: ExternalThreadProps) => {
+  const captured: { aui?: ReturnType<typeof useAui> } = {};
+  const Capture: FC = () => {
+    captured.aui = useAui();
+    return null;
+  };
+  const App: FC<{ threadProps: ExternalThreadProps }> = ({ threadProps }) => {
+    const aui = useAui({ thread: ExternalThread(threadProps) });
+    return (
+      <AuiProvider value={aui}>
+        <Capture />
+      </AuiProvider>
+    );
+  };
+  const utils = render(<App threadProps={props} />);
+  return {
+    aui: () => captured.aui!,
+    rerender: (next: ExternalThreadProps) =>
+      utils.rerender(<App threadProps={next} />),
+  };
+};
+
+const assistantMessageWithContent = (
+  status: ThreadMessage["status"],
+  content: ExternalThreadMessage["content"],
+  id = "a1",
+): ExternalThreadMessage =>
+  ({
+    id,
+    role: "assistant",
+    content,
+    createdAt: new Date(0),
+    status,
+    metadata: { custom: {} },
+  }) as unknown as ExternalThreadMessage;
+
+const assistantMessage = (
+  status: ThreadMessage["status"],
+  result?: string,
+): ExternalThreadMessage =>
+  assistantMessageWithContent(status, [
+    { type: "text", text: "let me check" },
+    {
+      type: "tool-call",
+      toolCallId: "tc1",
+      toolName: "probe_tool",
+      args: {},
+      argsText: "{}",
+      ...(result !== undefined && { result }),
+    },
+  ]);
+
+describe("ExternalThread part status", () => {
+  it("gives an unresolved tool call its message's status", () => {
+    const { aui } = renderThread({
+      messages: [assistantMessage({ type: "running" })],
+      isRunning: true,
+    });
+    const part = (toolCallId: string) =>
+      aui().thread.message({ id: "a1" }).part({ toolCallId }).getState();
+    expect(part("tc1").status).toEqual({ type: "running" });
+  });
+
+  it("uses positional fallback for statusless parts and resolved tool calls", () => {
+    const { aui } = renderThread({
+      messages: [
+        assistantMessage({ type: "running" }, "ok"),
+        assistantMessageWithContent(
+          { type: "running" },
+          [
+            { type: "text", text: "first" },
+            { type: "reasoning", text: "last" },
+          ],
+          "a2",
+        ),
+      ],
+      isRunning: true,
+    });
+    const state = aui().thread.message({ id: "a1" }).getState();
+    expect(state.parts[0]!.status).toEqual({ type: "complete" });
+    expect(state.parts[1]!.status).toEqual({ type: "complete" });
+    const fallbackState = aui().thread.message({ id: "a2" }).getState();
+    expect(fallbackState.parts[0]!.status).toEqual({ type: "complete" });
+    expect(fallbackState.parts[1]!.status).toEqual({ type: "running" });
+  });
+
+  it("honours supplied statuses while the message is running", () => {
+    const { aui } = renderThread({
+      messages: [
+        assistantMessageWithContent({ type: "running" }, [
+          { type: "text", text: "first", status: { type: "running" } },
+          {
+            type: "reasoning",
+            text: "last",
+            status: { type: "complete" },
+          },
+        ]),
+      ],
+      isRunning: true,
+    });
+    const state = aui().thread.message({ id: "a1" }).getState();
+
+    expect(state.parts[0]!.status).toEqual({ type: "running" });
+    expect(state.parts[1]!.status).toEqual({ type: "complete" });
+  });
+
+  it("ignores supplied statuses after the message completes", () => {
+    const { aui } = renderThread({
+      messages: [
+        assistantMessageWithContent({ type: "complete", reason: "stop" }, [
+          { type: "text", text: "truncated", status: { type: "running" } },
+        ]),
+      ],
+      isRunning: false,
+    });
+
+    expect(
+      aui().thread.message({ id: "a1" }).part({ index: 0 }).getState().status,
+    ).toEqual({ type: "complete", reason: "stop" });
+  });
+
+  it("normalizes supplied upstream statuses", () => {
+    const { aui } = renderThread({
+      messages: [
+        assistantMessageWithContent(
+          { type: "running" },
+          // assistant-stream sends shapes core's MessagePartStatus does not
+          // declare (a reason on complete, an unlisted incomplete reason);
+          // the normalizer absorbs them.
+          [
+            {
+              type: "text",
+              text: "done",
+              status: { type: "complete", reason: "unknown" },
+            },
+            {
+              type: "reasoning",
+              text: "interrupted",
+              status: {
+                type: "incomplete",
+                reason: "unknown",
+                error: "upstream error",
+              },
+            },
+          ] as unknown as ExternalThreadMessage["content"],
+        ),
+      ],
+      isRunning: true,
+    });
+    const state = aui().thread.message({ id: "a1" }).getState();
+
+    expect(state.parts[0]!.status).toEqual({ type: "complete" });
+    expect(state.parts[1]!.status).toEqual({
+      type: "incomplete",
+      reason: "other",
+    });
+  });
+
+  it("keeps parts complete on requires-action and user messages", () => {
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+        assistantMessage({ type: "requires-action", reason: "tool-calls" }),
+      ],
+      isRunning: false,
+    });
+    expect(
+      aui().thread.message({ id: "u1" }).part({ index: 0 }).getState().status,
+    ).toEqual({ type: "complete" });
+    expect(
+      aui()
+        .thread()
+        .message({ id: "a1" })
+        .part({ toolCallId: "tc1" })
+        .getState().status,
+    ).toEqual({ type: "requires-action", reason: "tool-calls" });
+    expect(
+      aui().thread.message({ id: "a1" }).part({ index: 0 }).getState().status,
+    ).toEqual({ type: "complete" });
+  });
+});
+
+describe("ExternalThread unset optional callbacks", () => {
+  it("throws a capability error when the callback prop is not set", () => {
+    const { aui } = renderThread({
+      messages: [
+        assistantMessage({ type: "requires-action", reason: "tool-calls" }),
+      ],
+      isRunning: false,
+    });
+    const part = () =>
+      aui().thread.message({ id: "a1" }).part({ toolCallId: "tc1" });
+
+    expect(() => part().addToolResult("ok")).toThrow(
+      "Runtime does not support tool results (onAddToolResult is not set).",
+    );
+    expect(() => part().resumeToolCall(undefined)).toThrow(
+      "Runtime does not support resuming tool calls (onResumeToolCall is not set).",
+    );
+    expect(() => aui().thread.resumeRun()).toThrow(
+      "Runtime does not support resuming runs (onResume is not set).",
+    );
+    expect(() => aui().thread.importExternalState({})).toThrow(
+      "Runtime does not support importing external states (onLoadExternalState is not set).",
+    );
+  });
+});
+
+describe("ExternalThread composer", () => {
+  it("dispatches a synchronous setText + send sequence", async () => {
+    const onNew = vi.fn();
+    const { aui } = renderThread({ messages: [], isRunning: false, onNew });
+
+    aui().thread.composer().setText("hello");
+    aui().thread.composer().send();
+
+    await waitFor(() => expect(onNew).toHaveBeenCalledTimes(1));
+    expect(onNew.mock.calls[0]![0].content).toEqual([
+      { type: "text", text: "hello" },
+    ]);
+    await waitFor(() => expect(aui().thread.getState().composer.text).toBe(""));
+  });
+
+  it("stamps the thread head as parentId on queue-adapter sends", async () => {
+    const enqueue = vi.fn();
+    const steer = vi.fn();
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: true,
+      queue: {
+        items: [],
+        steerItems: [],
+        enqueue,
+        steer,
+        move: vi.fn(),
+        edit: vi.fn(),
+        remove: vi.fn(),
+      },
+    });
+
+    aui().thread.composer().setText("queued");
+    aui().thread.composer().send();
+
+    // mid-run sends default to the steer lane
+    await waitFor(() => expect(steer).toHaveBeenCalledTimes(1));
+    expect(steer.mock.calls[0]![0].parentId).toBe("u1");
+    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();
+    const steer = vi.fn();
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      onEdit,
+      queue: {
+        items: [],
+        steerItems: [],
+        enqueue,
+        steer,
+        move: vi.fn(),
+        edit: vi.fn(),
+        remove: vi.fn(),
+      },
+    });
+
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+    composer().beginEdit();
+    await waitFor(() => expect(composer().getState().isEditing).toBe(true));
+    composer().setText("edited");
+    composer().send();
+
+    await waitFor(() => expect(onEdit).toHaveBeenCalledTimes(1));
+    expect(onEdit.mock.calls[0]![0]).toMatchObject({
+      sourceId: "u1",
+      content: [{ type: "text", text: "edited" }],
+    });
+    expect(enqueue).not.toHaveBeenCalled();
+    expect(steer).not.toHaveBeenCalled();
+  });
+
+  it("dispatches a same-tick beginEdit + setText + send sequence", async () => {
+    const onEdit = vi.fn();
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      onEdit,
+    });
+
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+    composer().beginEdit();
+    composer().setText("edited");
+    composer().send();
+
+    await waitFor(() => expect(onEdit).toHaveBeenCalledTimes(1));
+    expect(onEdit.mock.calls[0]![0]).toMatchObject({
+      sourceId: "u1",
+      content: [{ type: "text", text: "edited" }],
+    });
+    await waitFor(() => expect(composer().getState().isEditing).toBe(false));
+  });
+
+  it("prefills the edit composer from the message on beginEdit", async () => {
+    const onEdit = vi.fn();
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "a1",
+          role: "assistant",
+          content: [{ type: "text", text: "original answer" }],
+          createdAt: new Date(0),
+          attachments: [
+            {
+              id: "att1",
+              type: "file",
+              name: "a.txt",
+              contentType: "text/plain",
+              status: { type: "complete" },
+              content: [],
+            },
+          ],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      onEdit,
+    });
+
+    const composer = () => aui().thread.message({ id: "a1" }).composer();
+    composer().beginEdit();
+    await waitFor(() => {
+      const state = composer().getState();
+      expect(state.text).toBe("original answer");
+      expect(state.role).toBe("assistant");
+      expect(state.attachments).toHaveLength(1);
+    });
+    expect(() => composer().beginEdit()).toThrow("Edit already in progress");
+
+    composer().send();
+    await waitFor(() => expect(onEdit).toHaveBeenCalledTimes(1));
+    expect(onEdit.mock.calls[0]![0]).toMatchObject({
+      sourceId: "a1",
+      content: [{ type: "text", text: "original answer" }],
+    });
+  });
+
+  it("throws on edit-composer send before beginEdit", () => {
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      onEdit: vi.fn(),
+    });
+
+    expect(() => aui().thread.message({ id: "u1" }).composer().send()).toThrow(
+      "Composer is not available",
+    );
+  });
+
+  it("throws on beginEdit when the runtime has no edit handler", () => {
+    const { aui } = renderThread({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      isRunning: false,
+      queue: {
+        items: [],
+        steerItems: [],
+        enqueue: vi.fn(),
+        steer: vi.fn(),
+        move: vi.fn(),
+        edit: vi.fn(),
+        remove: vi.fn(),
+      },
+    });
+
+    expect(() =>
+      aui().thread.message({ id: "u1" }).composer().beginEdit(),
+    ).toThrow("Runtime does not support editing.");
+  });
+
+  it("still refuses to send an empty composer synchronously after a send", async () => {
+    const onNew = vi.fn();
+    const { aui } = renderThread({ messages: [], isRunning: false, onNew });
+
+    aui().thread.composer().send();
+    aui().thread.composer().setText("first");
+    aui().thread.composer().send();
+    aui().thread.composer().send();
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(onNew).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("ExternalThread duplicate message ids", () => {
+  const userMessage = (id: string, text: string): ExternalThreadMessage =>
+    ({
+      id,
+      role: "user",
+      content: [{ type: "text", text }],
+      createdAt: new Date(0),
+      metadata: { custom: {} },
+    }) as unknown as ExternalThreadMessage;
+
+  it("warns and keeps the last occurrence instead of throwing on a duplicate id", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const { aui } = renderThread({
+        messages: [
+          userMessage("u1", "hi"),
+          userMessage("dup", "stale"),
+          userMessage("dup", "fresh"),
+        ],
+      });
+
+      const state = aui().thread.getState();
+      expect(state.messages.map((m) => m.id)).toEqual(["u1", "dup"]);
+
+      const dup = aui().thread.message({ id: "dup" }).getState();
+      expect(dup.parts[0]).toMatchObject({ type: "text", text: "fresh" });
+      expect(warn).toHaveBeenCalledWith(expect.stringContaining('"dup"'));
+    } finally {
+      warn.mockRestore();
+    }
+  });
+});

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");
+  });
+});