@assistant-ui/react 0.15.11 → 0.15.13

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

@@ -1,204 +0,0 @@
-// @vitest-environment jsdom
-
-import { act, render, waitFor } from "@testing-library/react";
-import type { FC } from "react";
-import { describe, expect, it, vi } from "vitest";
-import { AuiProvider, useAui } from "@assistant-ui/store";
-import type { FeedbackAdapter } from "@assistant-ui/core";
-import type {
-  ExternalThreadMessage,
-  ExternalThreadProps,
-} from "../client/ExternalThread";
-import { ExternalThread } from "../client/ExternalThread";
-
-const MESSAGES = [
-  {
-    id: "u1",
-    role: "user",
-    content: [{ type: "text", text: "hi" }],
-    createdAt: new Date(0),
-    attachments: [],
-    metadata: { custom: {} },
-  },
-  {
-    id: "a1",
-    role: "assistant",
-    content: [{ type: "text", text: "hello there" }],
-    createdAt: new Date(0),
-    metadata: { custom: {} },
-  },
-] as unknown as readonly ExternalThreadMessage[];
-
-const createFakeAdapter = () => {
-  const submit = vi.fn();
-  const adapter: FeedbackAdapter = { submit };
-  return { adapter, submit };
-};
-
-const renderThreadWithProps = (props: Partial<ExternalThreadProps>) => {
-  const captured: { aui?: ReturnType<typeof useAui> } = {};
-  const Capture: FC = () => {
-    captured.aui = useAui();
-    return null;
-  };
-  const App: FC<{ props: Partial<ExternalThreadProps> }> = ({ props }) => {
-    const aui = useAui({
-      thread: ExternalThread({
-        messages: MESSAGES,
-        isRunning: false,
-        ...props,
-      }),
-    });
-    return (
-      <AuiProvider value={aui}>
-        <Capture />
-      </AuiProvider>
-    );
-  };
-
-  const view = render(<App props={props} />);
-  return {
-    aui: () => captured.aui!,
-    rerender: (nextProps: Partial<ExternalThreadProps>) =>
-      view.rerender(<App props={nextProps} />),
-  };
-};
-
-describe("ExternalThread feedback", () => {
-  it("reports the feedback capability based on adapter presence", () => {
-    const { aui: withoutAdapter } = renderThreadWithProps({});
-    expect(withoutAdapter().thread.getState().capabilities.feedback).toBe(
-      false,
-    );
-
-    const { adapter } = createFakeAdapter();
-    const { aui: withAdapter } = renderThreadWithProps({
-      feedbackAdapter: adapter,
-    });
-    expect(withAdapter().thread.getState().capabilities.feedback).toBe(true);
-  });
-
-  it("throws on submitFeedback when no adapter is configured", () => {
-    const { aui } = renderThreadWithProps({});
-    expect(() =>
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" }),
-    ).toThrow("Feedback adapter not configured");
-  });
-
-  it("submits feedback to the adapter and marks the assistant message", async () => {
-    const { adapter, submit } = createFakeAdapter();
-    const { aui } = renderThreadWithProps({ feedbackAdapter: adapter });
-
-    await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
-    });
-
-    expect(submit).toHaveBeenCalledTimes(1);
-    expect(submit).toHaveBeenCalledWith({
-      message: MESSAGES[1],
-      type: "positive",
-    });
-    await waitFor(() => {
-      expect(
-        aui().thread.message({ id: "a1" }).getState().metadata
-          .submittedFeedback,
-      ).toEqual({ type: "positive" });
-    });
-
-    await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "negative" });
-    });
-
-    expect(submit).toHaveBeenLastCalledWith({
-      message: MESSAGES[1],
-      type: "negative",
-    });
-    await waitFor(() => {
-      expect(
-        aui().thread.message({ id: "a1" }).getState().metadata
-          .submittedFeedback,
-      ).toEqual({ type: "negative" });
-    });
-  });
-
-  it("prefers owner-supplied submittedFeedback over the local overlay", async () => {
-    const { adapter } = createFakeAdapter();
-    const { aui, rerender } = renderThreadWithProps({
-      feedbackAdapter: adapter,
-    });
-
-    await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
-    });
-    await waitFor(() => {
-      expect(
-        aui().thread.message({ id: "a1" }).getState().metadata
-          .submittedFeedback,
-      ).toEqual({ type: "positive" });
-    });
-
-    const ownerMessages = [
-      MESSAGES[0]!,
-      {
-        ...MESSAGES[1]!,
-        metadata: { custom: {}, submittedFeedback: { type: "negative" } },
-      },
-    ] as unknown as readonly ExternalThreadMessage[];
-    await act(async () => {
-      rerender({ feedbackAdapter: adapter, messages: ownerMessages });
-    });
-
-    expect(
-      aui().thread.message({ id: "a1" }).getState().metadata.submittedFeedback,
-    ).toEqual({ type: "negative" });
-  });
-
-  it("re-rates an owner-marked message locally, then honors an owner clear", async () => {
-    const { adapter } = createFakeAdapter();
-    const ratedMessages = [
-      MESSAGES[0]!,
-      {
-        ...MESSAGES[1]!,
-        metadata: { custom: {}, submittedFeedback: { type: "positive" } },
-      },
-    ] as unknown as readonly ExternalThreadMessage[];
-    const { aui, rerender } = renderThreadWithProps({
-      feedbackAdapter: adapter,
-      messages: ratedMessages,
-    });
-
-    await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "negative" });
-    });
-    await waitFor(() => {
-      expect(
-        aui().thread.message({ id: "a1" }).getState().metadata
-          .submittedFeedback,
-      ).toEqual({ type: "negative" });
-    });
-
-    await act(async () => {
-      rerender({ feedbackAdapter: adapter, messages: MESSAGES });
-    });
-    expect(
-      aui().thread.message({ id: "a1" }).getState().metadata.submittedFeedback,
-    ).toBeUndefined();
-  });
-
-  it("submits user message feedback without marking the message", async () => {
-    const { adapter, submit } = createFakeAdapter();
-    const { aui } = renderThreadWithProps({ feedbackAdapter: adapter });
-
-    await act(async () => {
-      aui().thread.message({ id: "u1" }).submitFeedback({ type: "negative" });
-    });
-
-    expect(submit).toHaveBeenCalledWith({
-      message: MESSAGES[0],
-      type: "negative",
-    });
-    expect(
-      aui().thread.message({ id: "u1" }).getState().metadata.submittedFeedback,
-    ).toBeUndefined();
-  });
-});

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

@@ -1,494 +0,0 @@
-// @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 "@assistant-ui/core";
-import {
-  ExternalThread,
-  type ExternalThreadProps,
-  type ExternalThreadMessage,
-} from "../client/ExternalThread";
-
-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("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();
-    }
-  });
-});