@assistant-ui/react 0.15.13 → 0.15.15

package/src/legacy-runtime/runtime-cores/assistant-transport/transport-delivery.test.tsx

@@ -1,79 +0,0 @@
-// @vitest-environment jsdom
-
-import { act, render, waitFor } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { FC } from "react";
-import { useAssistantTransportRuntime } from "./useAssistantTransportRuntime";
-import type { AssistantRuntime } from "../../runtime/AssistantRuntime";
-import { AssistantRuntimeProvider } from "../../../context";
-import type {
-  AssistantTransportCommand,
-  AssistantTransportStateConverter,
-} from "./types";
-
-const emptySuccessfulResponse = () =>
-  new Response(
-    new ReadableStream<Uint8Array>({
-      start(controller) {
-        controller.close();
-      },
-    }),
-    { status: 200 },
-  );
-
-const setupRuntime = () => {
-  const fetchMock = vi.fn(async () => emptySuccessfulResponse());
-  vi.stubGlobal("fetch", fetchMock);
-
-  const pendingRef: { current: AssistantTransportCommand[] } = { current: [] };
-  const converter: AssistantTransportStateConverter<Record<string, never>> = (
-    _state,
-    { pendingCommands, isSending },
-  ) => {
-    pendingRef.current = pendingCommands;
-    return { messages: [], isRunning: isSending };
-  };
-
-  const runtimeRef: { current: AssistantRuntime | null } = { current: null };
-  const App: FC = () => {
-    const runtime = useAssistantTransportRuntime({
-      initialState: {},
-      api: "http://localhost/api",
-      converter,
-      headers: {},
-    });
-    runtimeRef.current = runtime;
-    return (
-      <AssistantRuntimeProvider runtime={runtime}>
-        {null}
-      </AssistantRuntimeProvider>
-    );
-  };
-
-  return { App, fetchMock, pendingRef, runtimeRef };
-};
-
-describe("assistant transport delivery contracts", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("clears in-transit commands when a run succeeds without state chunks", async () => {
-    const { App, fetchMock, pendingRef, runtimeRef } = setupRuntime();
-
-    await act(async () => {
-      render(<App />);
-    });
-    await waitFor(() => expect(runtimeRef.current).not.toBeNull());
-
-    await act(async () => {
-      runtimeRef.current!.thread.append("m1");
-    });
-
-    await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1));
-    await waitFor(() =>
-      expect(runtimeRef.current!.thread.getState().isRunning).toBe(false),
-    );
-    await waitFor(() => expect(pendingRef.current).toHaveLength(0));
-  });
-});

package/src/legacy-runtime/runtime-cores/assistant-transport/transport-parentid.test.tsx

@@ -1,97 +0,0 @@
-// @vitest-environment jsdom
-
-import { act, render, waitFor } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { FC } from "react";
-import { useAssistantTransportRuntime } from "./useAssistantTransportRuntime";
-import type { AssistantRuntime } from "../../runtime/AssistantRuntime";
-import { AssistantRuntimeProvider } from "../../../context";
-import type {
-  AssistantTransportCommand,
-  AssistantTransportStateConverter,
-} from "./types";
-
-const emptySuccessfulResponse = () =>
-  new Response(
-    new ReadableStream<Uint8Array>({
-      start(controller) {
-        controller.close();
-      },
-    }),
-    { status: 200 },
-  );
-
-const setupRuntime = () => {
-  const requestBodies: Record<string, unknown>[] = [];
-  const fetchMock = vi.fn(
-    async (_url: RequestInfo | URL, init?: RequestInit) => {
-      requestBodies.push(JSON.parse(init!.body as string));
-      return emptySuccessfulResponse();
-    },
-  );
-  vi.stubGlobal("fetch", fetchMock);
-
-  const converter: AssistantTransportStateConverter<Record<string, never>> = (
-    _state,
-    { isSending },
-  ) => ({ messages: [], isRunning: isSending });
-
-  const runtimeRef: { current: AssistantRuntime | null } = { current: null };
-  const App: FC = () => {
-    const runtime = useAssistantTransportRuntime({
-      initialState: {},
-      api: "http://localhost/api",
-      converter,
-      headers: {},
-    });
-    runtimeRef.current = runtime;
-    return (
-      <AssistantRuntimeProvider runtime={runtime}>
-        {null}
-      </AssistantRuntimeProvider>
-    );
-  };
-
-  return { App, fetchMock, requestBodies, runtimeRef };
-};
-
-describe("assistant transport parentId lifetime", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("consumes parentId per run: the append's run carries it, a later sendCommand run omits it", async () => {
-    const { App, fetchMock, requestBodies, runtimeRef } = setupRuntime();
-
-    await act(async () => {
-      render(<App />);
-    });
-    await waitFor(() => expect(runtimeRef.current).not.toBeNull());
-
-    await act(async () => {
-      runtimeRef.current!.thread.append("m1");
-    });
-
-    await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1));
-    await waitFor(() =>
-      expect(runtimeRef.current!.thread.getState().isRunning).toBe(false),
-    );
-    expect(Object.hasOwn(requestBodies[0]!, "parentId")).toBe(true);
-
-    const extras = runtimeRef.current!.thread.getState().extras as {
-      sendCommand: (command: AssistantTransportCommand) => void;
-    };
-    await act(async () => {
-      extras.sendCommand({
-        type: "add-tool-result",
-        toolCallId: "t1",
-        toolName: "tool",
-        result: {},
-        isError: false,
-      });
-    });
-
-    await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(2));
-    expect(Object.hasOwn(requestBodies[1]!, "parentId")).toBe(false);
-  });
-});

package/src/legacy-runtime/runtime-cores/assistant-transport/transport-scheduling.test.ts

@@ -1,307 +0,0 @@
-// @vitest-environment jsdom
-
-import { act, renderHook, waitFor } from "@testing-library/react";
-import { describe, expect, it, vi } from "vitest";
-import { createElement, StrictMode, useRef } from "react";
-import { useCommandQueue } from "./commandQueue";
-import { useRunManager } from "./runManager";
-import type { AssistantTransportCommand } from "./types";
-
-const createMessageCommand = (id: string): AssistantTransportCommand => ({
-  type: "add-message",
-  message: {
-    role: "user",
-    parts: [{ type: "text", text: id }],
-  },
-  parentId: null,
-  sourceId: null,
-});
-
-const createDeferred = () => {
-  let resolve!: () => void;
-  const promise = new Promise<void>((res) => {
-    resolve = res;
-  });
-  return { promise, resolve };
-};
-
-const useTransportSchedulingHarness = (
-  opts: {
-    onRun?: (signal: AbortSignal) => Promise<void> | void;
-    onCancel?: (commands: AssistantTransportCommand[]) => void;
-    onError?: (commands: AssistantTransportCommand[]) => void;
-    onFinish?: () => void;
-  } = {},
-) => {
-  const commandQueueRef = useRef<ReturnType<typeof useCommandQueue> | null>(
-    null,
-  );
-  const runBatchesRef = useRef<AssistantTransportCommand[][]>([]);
-
-  const runManager = useRunManager({
-    onRun: async (signal) => {
-      const batch = commandQueueRef.current!.flush();
-      runBatchesRef.current.push(batch);
-      await opts.onRun?.(signal);
-    },
-    onCancel: () => {
-      const queue = commandQueueRef.current!;
-      const commands = [...queue.state.inTransit, ...queue.state.queued];
-      queue.reset();
-      opts.onCancel?.(commands);
-    },
-    onError: async () => {
-      const queue = commandQueueRef.current!;
-      opts.onError?.([...queue.state.inTransit]);
-    },
-    onFinish: () => opts.onFinish?.(),
-  });
-
-  const commandQueue = useCommandQueue({
-    onQueue: () => runManager.schedule(),
-  });
-  commandQueueRef.current = commandQueue;
-
-  return {
-    commandQueue,
-    runManager,
-    runBatchesRef,
-  };
-};
-
-describe("assistant transport scheduling contracts", () => {
-  it("runs in single-flight mode and schedules exactly one follow-up run", async () => {
-    const gate = createDeferred();
-    const { result } = renderHook(() =>
-      useTransportSchedulingHarness({
-        onRun: () => gate.promise,
-      }),
-    );
-
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("m1"));
-      result.current.commandQueue.enqueue(createMessageCommand("m2"));
-    });
-
-    await waitFor(() => {
-      expect(result.current.runBatchesRef.current).toHaveLength(1);
-    });
-    expect(result.current.runBatchesRef.current[0]).toHaveLength(2);
-
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("m3"));
-    });
-
-    await Promise.resolve();
-    expect(result.current.runBatchesRef.current).toHaveLength(1);
-
-    gate.resolve();
-
-    await waitFor(() => {
-      expect(result.current.runBatchesRef.current).toHaveLength(2);
-    });
-    expect(result.current.runBatchesRef.current[1]).toHaveLength(1);
-  });
-
-  it("can enqueue without scheduling until a run is started", async () => {
-    const { result } = renderHook(() => useTransportSchedulingHarness());
-
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("staged"), {
-        schedule: false,
-      });
-    });
-
-    await Promise.resolve();
-    expect(result.current.runBatchesRef.current).toHaveLength(0);
-
-    act(() => {
-      result.current.runManager.schedule();
-    });
-
-    await waitFor(() => {
-      expect(result.current.runBatchesRef.current).toHaveLength(1);
-    });
-    expect(result.current.runBatchesRef.current[0]).toHaveLength(1);
-  });
-
-  it("onError receives the live in-transit commands at error time", async () => {
-    const seen: AssistantTransportCommand[][] = [];
-    const { result } = renderHook(() =>
-      useTransportSchedulingHarness({
-        onRun: () => {
-          throw new Error("network error");
-        },
-        onError: (commands) => seen.push(commands),
-      }),
-    );
-
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("m1"));
-    });
-
-    // The flush that moved m1 into transit has not re-rendered yet when the
-    // error fires; the queue state must be read live, not from a render snapshot.
-    await waitFor(() => expect(seen).toHaveLength(1));
-    expect(seen[0]).toEqual([createMessageCommand("m1")]);
-  });
-
-  it("settles the run when onFinish throws", async () => {
-    const error = new Error("telemetry failed");
-    const onFinish = vi.fn<() => void>().mockImplementationOnce(() => {
-      throw error;
-    });
-    const consoleError = vi
-      .spyOn(console, "error")
-      .mockImplementation(() => {});
-
-    try {
-      const { result } = renderHook(() =>
-        useTransportSchedulingHarness({ onFinish }),
-      );
-
-      act(() => {
-        result.current.commandQueue.enqueue(createMessageCommand("m1"));
-      });
-
-      await waitFor(() => {
-        expect(result.current.runManager.isRunning).toBe(false);
-      });
-
-      act(() => {
-        result.current.commandQueue.enqueue(createMessageCommand("m2"));
-      });
-
-      await waitFor(() => {
-        expect(result.current.runBatchesRef.current).toHaveLength(2);
-      });
-      expect(consoleError).toHaveBeenCalledWith(
-        "[assistant-ui] Assistant transport onFinish callback threw an error",
-        error,
-      );
-    } finally {
-      consoleError.mockRestore();
-    }
-  });
-
-  it("cancel returns combined in-flight and queued commands", async () => {
-    const onCancel = vi.fn();
-    const { result } = renderHook(() =>
-      useTransportSchedulingHarness({
-        onRun: (signal) =>
-          new Promise<void>((_resolve, reject) => {
-            signal.addEventListener(
-              "abort",
-              () => reject(new Error("aborted")),
-              { once: true },
-            );
-          }),
-        onCancel,
-      }),
-    );
-
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("in-flight"));
-    });
-
-    await waitFor(() => {
-      expect(result.current.runBatchesRef.current).toHaveLength(1);
-    });
-
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("queued"));
-      result.current.runManager.cancel();
-    });
-
-    await waitFor(() => {
-      expect(onCancel).toHaveBeenCalledTimes(1);
-    });
-    expect(onCancel.mock.calls[0]?.[0]).toHaveLength(2);
-  });
-
-  it("unmount aborts the in-flight run without invoking callbacks", async () => {
-    let aborted = false;
-    const onCancel = vi.fn();
-    const onError = vi.fn();
-    const onFinish = vi.fn();
-    const { result, unmount } = renderHook(() =>
-      useTransportSchedulingHarness({
-        onRun: (signal) =>
-          new Promise<void>((_resolve, reject) => {
-            signal.addEventListener(
-              "abort",
-              () => {
-                aborted = true;
-                reject(new Error("aborted"));
-              },
-              { once: true },
-            );
-          }),
-        onCancel,
-        onError,
-        onFinish,
-      }),
-    );
-
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("in-flight"));
-    });
-    await waitFor(() => {
-      expect(result.current.runBatchesRef.current).toHaveLength(1);
-    });
-
-    unmount();
-
-    expect(aborted).toBe(true);
-    await act(async () => {});
-    expect(onCancel).not.toHaveBeenCalled();
-    expect(onError).not.toHaveBeenCalled();
-    expect(onFinish).not.toHaveBeenCalled();
-  });
-
-  it("ignores schedules after unmount", async () => {
-    const { result, unmount } = renderHook(() =>
-      useTransportSchedulingHarness(),
-    );
-
-    unmount();
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("late"));
-    });
-
-    await act(async () => {});
-    expect(result.current.runBatchesRef.current).toHaveLength(0);
-  });
-
-  it("survives StrictMode double-mounting", async () => {
-    const gate = createDeferred();
-    const onFinish = vi.fn();
-    const { result } = renderHook(
-      () =>
-        useTransportSchedulingHarness({ onRun: () => gate.promise, onFinish }),
-      { wrapper: ({ children }) => createElement(StrictMode, null, children) },
-    );
-
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("m1"));
-    });
-    await waitFor(() => {
-      expect(result.current.runBatchesRef.current).toHaveLength(1);
-    });
-
-    // enqueued while the first run is in flight — must restart as a follow-up
-    act(() => {
-      result.current.commandQueue.enqueue(createMessageCommand("m2"));
-    });
-
-    gate.resolve();
-    await waitFor(() => {
-      expect(result.current.runBatchesRef.current).toHaveLength(2);
-    });
-    expect(result.current.runBatchesRef.current[1]).toHaveLength(1);
-    expect(onFinish).toHaveBeenCalled();
-    await waitFor(() => {
-      expect(result.current.runManager.isRunning).toBe(false);
-    });
-  });
-});

package/src/legacy-runtime/runtime-cores/assistant-transport/types.ts

@@ -1,170 +0,0 @@
-import type { ToolModelContentPart } from "assistant-stream";
-import type { ThreadMessage } from "@assistant-ui/core";
-import type { ReadonlyJSONValue } from "assistant-stream/utils";
-import type {
-  AttachmentAdapter,
-  ThreadHistoryAdapter,
-  LanguageModelV1CallSettings,
-  LanguageModelConfig,
-} from "@assistant-ui/core";
-import type { UserCommands } from "../../../augmentations";
-import type { ToolExecutionStatus } from "@assistant-ui/core";
-
-// Message part types
-export type TextPart = {
-  readonly type: "text";
-  readonly text: string;
-};
-
-export type ImagePart = {
-  readonly type: "image";
-  readonly image: string;
-};
-
-export type UserMessagePart = TextPart | ImagePart;
-
-export type UserMessage = {
-  readonly role: "user";
-  readonly parts: readonly UserMessagePart[];
-};
-
-export type AssistantMessage = {
-  readonly role: "assistant";
-  readonly parts: readonly TextPart[];
-};
-
-// Command types
-export type AddMessageCommand = {
-  readonly type: "add-message";
-  readonly message: UserMessage | AssistantMessage;
-  readonly parentId: string | null;
-  readonly sourceId: string | null;
-};
-
-export type AddToolResultCommand = {
-  readonly type: "add-tool-result";
-  readonly toolCallId: string;
-  readonly toolName: string;
-  readonly result: ReadonlyJSONValue;
-  readonly isError: boolean;
-  readonly artifact?: ReadonlyJSONValue;
-  readonly modelContent?: readonly ToolModelContentPart[];
-};
-
-export type AssistantTransportCommand =
-  | AddMessageCommand
-  | AddToolResultCommand
-  | UserCommands;
-
-// State types
-export type AssistantTransportState = {
-  readonly messages: readonly ThreadMessage[];
-  readonly state?: ReadonlyJSONValue;
-  readonly isRunning: boolean;
-};
-
-export type AssistantTransportConnectionMetadata = {
-  pendingCommands: AssistantTransportCommand[];
-  isSending: boolean;
-  toolStatuses: Record<string, ToolExecutionStatus>;
-};
-
-export type AssistantTransportStateConverter<T> = (
-  state: T,
-  connectionMetadata: AssistantTransportConnectionMetadata,
-) => AssistantTransportState;
-
-// Queue types
-export type CommandQueueState = {
-  queued: AssistantTransportCommand[];
-  inTransit: AssistantTransportCommand[];
-};
-
-// For now, queued items are plain commands (runConfig not supported)
-export type QueuedCommand = AssistantTransportCommand;
-
-// Task types
-
-// Options types
-export type HeadersValue = Record<string, string> | Headers;
-
-export type AssistantTransportProtocol = "data-stream" | "assistant-transport";
-
-export type SendCommandsRequestBody = {
-  commands: QueuedCommand[];
-  /** Absent on a resume with `resumeStateApi`; the server replays from its retained snapshot. */
-  state?: unknown;
-  runId?: string;
-  system: string | undefined;
-  tools: Record<string, unknown> | undefined;
-  callSettings: LanguageModelV1CallSettings | undefined;
-  config: LanguageModelConfig | undefined;
-  threadId: string | null;
-  parentId?: string | null;
-  // `callSettings` and `config` fields are also spread at the top level for
-  // backward compatibility (e.g. `body.modelName`). Use the nested objects
-  // instead. The top-level fields will be removed in a future version.
-  [key: string]: unknown;
-};
-
-export type AssistantTransportOptions<T> = {
-  initialState: T;
-  api: string;
-  resumeApi?: string;
-  /** Endpoint that returns the retained initial state and run ID for a resume stream. A 204 response means no run is active and the resume is skipped. */
-  resumeStateApi?: string;
-  protocol?: AssistantTransportProtocol;
-  /**
-   * When `false`, stream decoding and state reconciliation tolerate malformed
-   * input (invalid chunks are dropped with a console log) instead of throwing.
-   * Resume runs always decode leniently. Defaults to `true`.
-   */
-  strict?: boolean;
-  converter: AssistantTransportStateConverter<T>;
-  headers: HeadersValue | (() => Promise<HeadersValue>);
-  body?: object | (() => Promise<object | undefined>);
-  /**
-   * Transform the request body before it is sent to the API.
-   * Receives the fully assembled body and returns the (potentially transformed) body.
-   *
-   * @example
-   * ```ts
-   * prepareSendCommandsRequest: (body) => ({
-   *   ...body,
-   *   trackingId: crypto.randomUUID(),
-   * })
-   * ```
-   */
-  prepareSendCommandsRequest?: (
-    body: SendCommandsRequestBody,
-  ) => Record<string, unknown> | Promise<Record<string, unknown>>;
-  onResponse?: (response: Response) => void;
-  onFinish?: () => void;
-  onError?: (
-    error: Error,
-    params: {
-      commands: AssistantTransportCommand[];
-      updateState: (updater: (state: T) => T) => void;
-    },
-  ) => void | Promise<void>;
-  /**
-   * Called when commands are cancelled.
-   *
-   * When an error occurs, queued commands are automatically cancelled after `onError` settles.
-   * In this case, the `error` parameter contains the error that caused the cancellation.
-   */
-  onCancel?: (params: {
-    commands: AssistantTransportCommand[];
-    updateState: (updater: (state: T) => T) => void;
-    error?: Error;
-  }) => void;
-  capabilities?: {
-    edit?: boolean;
-  };
-  adapters?: {
-    attachments?: AttachmentAdapter | undefined;
-    history?: ThreadHistoryAdapter | undefined;
-  };
-};
-
-// (no task or stream-specific types needed in this module)