@assistant-ui/core 0.3.11 → 0.3.13

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

@@ -0,0 +1,157 @@
+// @vitest-environment jsdom
+
+import { render } 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 { ExternalThreadBranchAdapter, ThreadMessage } from "../index";
+import {
+  ExternalThread,
+  type ExternalThreadProps,
+} from "../store/clients/external-thread";
+
+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;
+
+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 baseProps = (
+  branches?: ExternalThreadBranchAdapter,
+): ExternalThreadProps => ({
+  messages: [message("u1", "user"), message("a2", "assistant")],
+  isRunning: false,
+  ...(branches ? { branches } : {}),
+});
+
+const adapterFor = (
+  ids: readonly string[],
+  switchToBranch = vi.fn(),
+): ExternalThreadBranchAdapter => ({
+  getBranches: (messageId) => (ids.includes(messageId) ? ids : []),
+  switchToBranch,
+});
+
+describe("ExternalThread branches", () => {
+  it("defaults to single-branch state without an adapter", () => {
+    const { aui } = renderThread(baseProps());
+    const state = aui().thread.getState();
+    expect(state.messages[1]!.branchNumber).toBe(1);
+    expect(state.messages[1]!.branchCount).toBe(1);
+    expect(state.capabilities.switchToBranch).toBe(false);
+    expect(() =>
+      aui().thread.message({ index: 1 }).switchToBranch({ position: "next" }),
+    ).not.toThrow();
+  });
+
+  it("derives branchNumber and branchCount from the adapter", () => {
+    const { aui } = renderThread(baseProps(adapterFor(["a1", "a2", "a3"])));
+    const state = aui().thread.getState();
+    expect(state.messages[1]!.branchNumber).toBe(2);
+    expect(state.messages[1]!.branchCount).toBe(3);
+    expect(state.capabilities.switchToBranch).toBe(true);
+  });
+
+  it("resolves previous and next to sibling ids and no-ops at the edges", () => {
+    const switchToBranch = vi.fn();
+    const { aui } = renderThread(
+      baseProps(adapterFor(["a1", "a2", "a3"], switchToBranch)),
+    );
+    const msg = () => aui().thread.message({ index: 1 });
+
+    msg().switchToBranch({ position: "previous" });
+    expect(switchToBranch).toHaveBeenLastCalledWith("a1");
+    msg().switchToBranch({ position: "next" });
+    expect(switchToBranch).toHaveBeenLastCalledWith("a3");
+
+    switchToBranch.mockClear();
+    const edge = renderThread({
+      messages: [message("u1", "user"), message("a1", "assistant")],
+      isRunning: false,
+      branches: adapterFor(["a1", "a2"], switchToBranch),
+    });
+    edge.aui().thread.message({ index: 1 }).switchToBranch({
+      position: "previous",
+    });
+    expect(switchToBranch).not.toHaveBeenCalled();
+  });
+
+  it("forwards an explicit branchId unvalidated but ignores self-switches", () => {
+    const switchToBranch = vi.fn();
+    const { aui } = renderThread(
+      baseProps(adapterFor(["a1", "a2"], switchToBranch)),
+    );
+    const msg = () => aui().thread.message({ index: 1 });
+
+    msg().switchToBranch({ branchId: "not-in-the-list" });
+    expect(switchToBranch).toHaveBeenLastCalledWith("not-in-the-list");
+
+    switchToBranch.mockClear();
+    msg().switchToBranch({ branchId: "a2" });
+    expect(switchToBranch).not.toHaveBeenCalled();
+  });
+
+  it("falls back to single-branch state when getBranches omits the own id", () => {
+    const switchToBranch = vi.fn();
+    const { aui } = renderThread(
+      baseProps({
+        getBranches: () => ["b1", "b2"],
+        switchToBranch,
+      }),
+    );
+    const state = aui().thread.getState();
+    expect(state.messages[1]!.branchNumber).toBe(1);
+    expect(state.messages[1]!.branchCount).toBe(1);
+
+    aui().thread.message({ index: 1 }).switchToBranch({ position: "next" });
+    expect(switchToBranch).not.toHaveBeenCalled();
+  });
+
+  it("keeps message state identity across adapter recreation with equal values", () => {
+    const messages = [message("u1", "user"), message("a2", "assistant")];
+    const { aui, rerender } = renderThread({
+      messages,
+      isRunning: false,
+      branches: adapterFor(["a1", "a2", "a3"]),
+    });
+    const before = aui().thread.getState().messages[1];
+
+    rerender({
+      messages,
+      isRunning: false,
+      branches: adapterFor(["a1", "a2", "a3"]),
+    });
+    const after = aui().thread.getState().messages[1];
+
+    expect(after!.branchNumber).toBe(2);
+    expect(before!.parts[0]).toBe(after!.parts[0]);
+  });
+});

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

@@ -0,0 +1,204 @@
+// @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 "../index";
+import type {
+  ExternalThreadMessage,
+  ExternalThreadProps,
+} from "../store/clients/external-thread";
+import { ExternalThread } from "../store/clients/external-thread";
+
+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();
+  });
+});