@assistant-ui/react 0.15.12 → 0.15.13

package/src/client/SingleThreadList.ts

@@ -1,118 +0,0 @@
-import { useMemo, useState } from "react";
-import { resource } from "@assistant-ui/tap";
-import {
-  type ClientElement,
-  type ClientOutput,
-  useClientResource,
-} from "@assistant-ui/store";
-
-const RESOLVED_PROMISE = Promise.resolve();
-const THREAD_ID = "default";
-
-const useSingleThreadListItem = ({
-  isRunning,
-}: {
-  isRunning: boolean;
-}): ClientOutput<"threadListItem"> => {
-  const [custom, setCustom] = useState<Record<string, unknown> | undefined>();
-
-  return {
-    getState: () => ({
-      id: THREAD_ID,
-      remoteId: undefined,
-      externalId: undefined,
-      title: undefined,
-      status: "regular",
-      custom,
-      isRunning,
-    }),
-    switchTo: () => {},
-    rename: () => {},
-    updateCustom: setCustom,
-    archive: () => {},
-    unarchive: () => {},
-    delete: () => {},
-    generateTitle: () => {},
-    initialize: async () => ({ remoteId: THREAD_ID, externalId: undefined }),
-    detach: () => {},
-  };
-};
-
-const SingleThreadListItem = resource(useSingleThreadListItem);
-
-type SingleThreadListProps = {
-  thread: ClientElement<"thread">;
-};
-
-/**
- * A minimal threads scope that wraps a single thread.
- * Automatically provided by ExternalThread when no threads scope exists.
- * Mounts the provided thread resource element.
- */
-const useSingleThreadList = ({
-  thread,
-}: SingleThreadListProps): ClientOutput<"threads"> => {
-  const threadClient = useClientResource(thread);
-  const itemClient = useClientResource(
-    SingleThreadListItem({ isRunning: threadClient.state.isRunning }),
-  );
-
-  const state = useMemo(
-    () => ({
-      mainThreadId: THREAD_ID,
-      newThreadId: null,
-      isLoading: false,
-      isLoadingMore: false,
-      hasMore: false,
-      threadIds: [THREAD_ID],
-      archivedThreadIds: [],
-      threadItems: [itemClient.state],
-      main: threadClient.state,
-    }),
-    [itemClient.state, threadClient.state],
-  );
-
-  return {
-    getState: () => state,
-    switchToThread: () => {
-      throw new Error("SingleThreadList does not support switchToThread");
-    },
-    switchToNewThread: () => {
-      throw new Error("SingleThreadList does not support switchToNewThread");
-    },
-    getLoadThreadsPromise: () => RESOLVED_PROMISE,
-    reload: () => RESOLVED_PROMISE,
-    reloadMainThread: () => RESOLVED_PROMISE,
-    loadMore: () => RESOLVED_PROMISE,
-    item: (selector) => {
-      if (
-        selector !== "main" &&
-        !(
-          typeof selector === "object" &&
-          "id" in selector &&
-          selector.id === THREAD_ID
-        ) &&
-        !(
-          typeof selector === "object" &&
-          "index" in selector &&
-          selector.index === 0
-        )
-      ) {
-        throw new Error(
-          `SingleThreadList: unknown item selector ${JSON.stringify(selector)}`,
-        );
-      }
-      return itemClient.methods;
-    },
-    thread: (selector) => {
-      if (selector !== "main" && selector !== THREAD_ID) {
-        throw new Error(
-          `SingleThreadList: unknown thread selector ${JSON.stringify(selector)}`,
-        );
-      }
-      return threadClient.methods;
-    },
-  };
-};
-
-export const SingleThreadList = resource(useSingleThreadList);

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

@@ -1,370 +0,0 @@
-// @vitest-environment jsdom
-
-import { act, render, waitFor } from "@testing-library/react";
-import type { FC } from "react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { AuiProvider, useAui } from "@assistant-ui/store";
-import type {
-  ExternalThreadMessage,
-  ExternalThreadProps,
-} from "../client/ExternalThread";
-import { ExternalThread } from "../client/ExternalThread";
-
-const renderThreadWithProps = (props: Partial<ExternalThreadProps>) => {
-  const captured: { aui?: ReturnType<typeof useAui> } = {};
-  const Capture: FC = () => {
-    captured.aui = useAui();
-    return null;
-  };
-  const App: FC = () => {
-    const aui = useAui({
-      thread: ExternalThread({ messages: [], isRunning: false, ...props }),
-    });
-    return (
-      <AuiProvider value={aui}>
-        <Capture />
-      </AuiProvider>
-    );
-  };
-
-  render(<App />);
-  return () => captured.aui!;
-};
-
-const renderThread = () => {
-  const captured: { aui?: ReturnType<typeof useAui> } = {};
-  const Capture: FC = () => {
-    captured.aui = useAui();
-    return null;
-  };
-  const App: FC = () => {
-    const aui = useAui({
-      thread: ExternalThread({ messages: [], isRunning: false }),
-    });
-    return (
-      <AuiProvider value={aui}>
-        <Capture />
-      </AuiProvider>
-    );
-  };
-
-  render(<App />);
-  return () => captured.aui!;
-};
-
-describe("ExternalThread attachments", () => {
-  it("adds prepared attachments when File is unavailable", async () => {
-    const aui = renderThread();
-    const fileConstructor = globalThis.File;
-    vi.stubGlobal("File", undefined);
-
-    try {
-      await act(async () => {
-        await aui()
-          .thread()
-          .composer()
-          .addAttachment({
-            name: "notes.txt",
-            contentType: "text/plain",
-            content: [{ type: "text", text: "hello" }],
-          });
-      });
-    } finally {
-      vi.stubGlobal("File", fileConstructor);
-    }
-
-    await waitFor(() => {
-      expect(aui().thread.composer().getState().attachments[0]).toMatchObject({
-        type: "document",
-        name: "notes.txt",
-        contentType: "text/plain",
-        content: [{ type: "text", text: "hello" }],
-      });
-    });
-  });
-
-  it("preserves foreign files that expose content", async () => {
-    const aui = renderThread();
-    const foreignFile = {
-      name: "photo.png",
-      type: "image/png",
-      lastModified: 0,
-      content: [{ type: "text", text: "implementation detail" }],
-    } as File;
-
-    await act(() => aui().thread.composer().addAttachment(foreignFile));
-
-    expect(aui().thread.composer().getState().attachments[0]).toMatchObject({
-      type: "file",
-      name: "photo.png",
-      contentType: "image/png",
-      file: foreignFile,
-    });
-  });
-
-  it("rejects files that do not match the adapter accept string", async () => {
-    const add = vi.fn(async () => ({}) as never);
-    const aui = renderThreadWithProps({
-      attachmentAdapter: {
-        accept: "image/*",
-        add,
-        send: async () => ({}) as never,
-        remove: async () => {},
-      },
-    });
-
-    await expect(
-      aui()
-        .thread()
-        .composer()
-        .addAttachment(
-          new File(["data"], "archive.zip", { type: "application/zip" }),
-        ),
-    ).rejects.toThrow(
-      "File type application/zip is not accepted. Accepted types: image/*",
-    );
-    expect(add).not.toHaveBeenCalled();
-    expect(aui().thread.composer().getState().attachments).toHaveLength(0);
-  });
-
-  it("rejects prepared attachments that do not match the adapter accept string", async () => {
-    const aui = renderThreadWithProps({
-      attachmentAdapter: {
-        accept: ".pdf",
-        add: async () => ({}) as never,
-        send: async () => ({}) as never,
-        remove: async () => {},
-      },
-    });
-
-    await expect(
-      aui()
-        .thread()
-        .composer()
-        .addAttachment({
-          name: "notes.txt",
-          contentType: "text/plain",
-          content: [{ type: "text", text: "hello" }],
-        }),
-    ).rejects.toThrow(
-      "File type text/plain is not accepted. Accepted types: .pdf",
-    );
-    expect(aui().thread.composer().getState().attachments).toHaveLength(0);
-  });
-
-  it("restores the draft when an attachment upload fails on send", async () => {
-    const consoleError = vi
-      .spyOn(console, "error")
-      .mockImplementation(() => {});
-    const sent: unknown[] = [];
-    let rejectSend!: (reason: unknown) => void;
-    const adapter = {
-      accept: "*",
-      add: async ({ file }: { file: File }) => ({
-        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((_resolve, reject) => {
-          rejectSend = reject;
-        }) as never,
-      remove: async () => {},
-    };
-
-    const aui = renderThreadWithProps({
-      attachmentAdapter: adapter,
-      onNew: (message) => sent.push(message),
-    });
-
-    await act(() =>
-      aui()
-        .thread()
-        .composer()
-        .addAttachment(new File(["data"], "notes.txt", { type: "text/plain" })),
-    );
-    await act(async () => {
-      aui().thread.composer().setText("hello");
-    });
-    await act(async () => {
-      aui().thread.composer().send();
-    });
-
-    // The draft is cleared optimistically while the upload runs.
-    expect(aui().thread.composer().getState().text).toBe("");
-
-    await act(async () => {
-      rejectSend(new Error("upload failed"));
-    });
-
-    await waitFor(() => {
-      const state = aui().thread.composer().getState();
-      expect(state.text).toBe("hello");
-      expect(state.attachments).toHaveLength(1);
-    });
-    expect(sent).toHaveLength(0);
-    expect(consoleError).toHaveBeenCalledWith(
-      "Failed to send attachments",
-      expect.any(Error),
-    );
-  });
-
-  it.each([
-    [
-      "clearAttachments",
-      (c: { clearAttachments(): Promise<void> }) => c.clearAttachments(),
-    ],
-    ["reset", (c: { reset(): Promise<void> }) => c.reset()],
-  ] as const)(
-    "calls adapter.remove for pending attachments on %s",
-    async (_name, invoke) => {
-      const remove = vi.fn(async () => {});
-      const adapter = {
-        accept: "*",
-        add: async ({ file }: { file: File }) => ({
-          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: async () => ({}) as never,
-        remove,
-      };
-
-      const aui = renderThreadWithProps({ attachmentAdapter: adapter });
-
-      await act(() =>
-        aui()
-          .thread()
-          .composer()
-          .addAttachment(
-            new File(["data"], "notes.txt", { type: "text/plain" }),
-          ),
-      );
-
-      await act(() => invoke(aui().thread.composer()));
-
-      expect(remove).toHaveBeenCalledTimes(1);
-      expect(remove).toHaveBeenCalledWith(
-        expect.objectContaining({ id: "att-1" }),
-      );
-      expect(aui().thread.composer().getState().attachments).toHaveLength(0);
-    },
-  );
-
-  it("routes edit-composer attachments through the adapter", async () => {
-    const add = vi.fn(async ({ file }: { file: File }) => ({
-      id: "att-edit",
-      type: "file" as const,
-      name: file.name,
-      contentType: file.type,
-      file,
-      status: {
-        type: "requires-action" as const,
-        reason: "composer-send" as const,
-      },
-    }));
-    const aui = renderThreadWithProps({
-      messages: [
-        {
-          id: "u1",
-          role: "user",
-          content: [{ type: "text", text: "hi" }],
-          createdAt: new Date(0),
-          attachments: [],
-          metadata: { custom: {} },
-        } as unknown as ExternalThreadMessage,
-      ],
-      onEdit: () => {},
-      attachmentAdapter: {
-        accept: "*",
-        add,
-        send: async () => ({}) as never,
-        remove: async () => {},
-      },
-    });
-
-    const composer = () => aui().thread.message({ id: "u1" }).composer();
-    await act(async () => {
-      composer().beginEdit();
-    });
-    await act(() =>
-      composer().addAttachment(
-        new File(["data"], "notes.txt", { type: "text/plain" }),
-      ),
-    );
-
-    expect(add).toHaveBeenCalledTimes(1);
-    expect(composer().getState().attachments[0]).toMatchObject({
-      id: "att-edit",
-      name: "notes.txt",
-    });
-  });
-
-  it("merges the failed send into a draft the user already modified", async () => {
-    vi.spyOn(console, "error").mockImplementation(() => {});
-    let rejectSend!: (reason: unknown) => void;
-    const adapter = {
-      accept: "*",
-      add: async ({ file }: { file: File }) => ({
-        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((_resolve, reject) => {
-          rejectSend = reject;
-        }) as never,
-      remove: async () => {},
-    };
-
-    const aui = renderThreadWithProps({
-      attachmentAdapter: adapter,
-      onNew: () => {},
-    });
-
-    await act(() =>
-      aui()
-        .thread()
-        .composer()
-        .addAttachment(new File(["data"], "notes.txt", { type: "text/plain" })),
-    );
-    await act(async () => {
-      aui().thread.composer().setText("hello");
-      aui().thread.composer().send();
-    });
-    await act(async () => {
-      aui().thread.composer().setText("meanwhile");
-    });
-
-    await act(async () => {
-      rejectSend(new Error("upload failed"));
-    });
-
-    const state = aui().thread.composer().getState();
-    expect(state.text).toBe("hello\nmeanwhile");
-    expect(state.attachments).toHaveLength(1);
-    expect(state.attachments[0]).toMatchObject({ id: "att-1" });
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-});

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

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