@assistant-ui/core 0.3.20 → 0.3.21

package/src/react/runtimes/assistant-transport/useAssistantTransportRuntime.ts

@@ -36,9 +36,9 @@ import { useConvertedState } from "./useConvertedState";
 import type { ToolExecutionStatus } from "../../../runtimes/tool-invocations/ToolInvocationTracker";
 import { createRequestHeaders } from "../../../runtimes/assistant-transport/utils";
 import { useRemoteThreadListRuntime } from "../useRemoteThreadListRuntime";
-import { InMemoryThreadListAdapter } from "../../../runtimes/remote-thread-list/adapter/in-memory";
 import { useAui, useAuiState } from "@assistant-ui/store";
 import type { UserExternalState } from "../../../types/augmentations";
+import { useCloudThreadListAdapter } from "../cloud/useCloudThreadListAdapter";
 
 const convertAppendMessageToCommand = (
   message: AppendMessage,
@@ -102,6 +102,17 @@ const readResumeState = async <T>(
   return { runId: value.runId, state: value.state as T };
 };
 
+// Rejects as soon as the signal aborts; a started operation keeps running.
+const abortable = <T>(signal: AbortSignal, start: () => Promise<T>) =>
+  new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(signal.reason);
+    if (signal.aborted) return onAbort();
+    signal.addEventListener("abort", onAbort, { once: true });
+    void start()
+      .then(resolve, reject)
+      .finally(() => signal.removeEventListener("abort", onAbort));
+  });
+
 const symbolAssistantTransportExtras = Symbol("assistant-transport-extras");
 type AssistantTransportExtras = {
   [symbolAssistantTransportExtras]: true;
@@ -173,7 +184,7 @@ const useAssistantTransportThreadRuntime = <T>(
     });
   };
 
-  const threadId = useAuiState((s) => s.threadListItem.remoteId);
+  const aui = useAui();
 
   const runManager = useRunManager({
     onRun: async (signal: AbortSignal) => {
@@ -189,6 +200,15 @@ const useAssistantTransportThreadRuntime = <T>(
       const parentId = isResume ? undefined : parentIdRef.current;
       if (!isResume) parentIdRef.current = undefined;
 
+      // Only a thread without a remote id waits for its initialization, and a
+      // resume, which reconnects to an existing run, never creates the thread.
+      const threadId =
+        aui.threadListItem.getState().remoteId ??
+        (isResume
+          ? undefined
+          : (await abortable(signal, () => aui.threadListItem.initialize()))
+              .remoteId);
+
       const headers = await createRequestHeaders(options.headers);
       let resumeState: { runId: string; state: T } | undefined;
       if (isResume && options.resumeStateApi) {
@@ -208,18 +228,19 @@ const useAssistantTransportThreadRuntime = <T>(
         resumeState = retained;
       }
 
-      const bodyValue =
+      // `typeof` narrows the `object` member to `Function`, whose call returns `any`; the annotation keeps `sendCommandsBody` checked against its type.
+      const bodyValue: object | undefined =
         typeof options.body === "function"
           ? await options.body()
           : options.body;
       const context = runtime.thread.getModelContext();
 
-      let requestBody: Record<string, unknown> = {
+      const sendCommandsBody: SendCommandsRequestBody = {
         commands,
         ...(resumeState === undefined && { state: agentStateRef.current }),
         system: context.system,
         tools: context.tools ? toToolsJSONSchema(context.tools) : undefined,
-        threadId,
+        ...(threadId !== undefined && { threadId }),
         ...(parentId !== undefined && {
           parentId,
         }),
@@ -232,10 +253,10 @@ const useAssistantTransportThreadRuntime = <T>(
         ...(bodyValue ?? {}),
       };
 
+      let requestBody: Record<string, unknown> = sendCommandsBody;
       if (options.prepareSendCommandsRequest) {
-        requestBody = await options.prepareSendCommandsRequest(
-          requestBody as SendCommandsRequestBody,
-        );
+        requestBody =
+          await options.prepareSendCommandsRequest(sendCommandsBody);
       }
 
       if (resumeState !== undefined) {
@@ -343,6 +364,7 @@ const useAssistantTransportThreadRuntime = <T>(
       ];
 
       commandQueue.reset();
+      parentIdRef.current = undefined;
 
       options.onCancel?.({
         commands: cmds,
@@ -359,6 +381,7 @@ const useAssistantTransportThreadRuntime = <T>(
       const queuedCmds = [...commandQueue.state.queued];
 
       commandQueue.reset();
+      parentIdRef.current = undefined;
 
       try {
         await options.onError?.(error as Error, {
@@ -472,11 +495,12 @@ const useAssistantTransportThreadRuntime = <T>(
 export const useAssistantTransportRuntime = <T>(
   options: AssistantTransportOptions<T>,
 ): AssistantRuntime => {
+  const adapter = useCloudThreadListAdapter({ cloud: options.cloud });
   const runtime = useRemoteThreadListRuntime({
     runtimeHook: function RuntimeHook() {
       return useAssistantTransportThreadRuntime(options);
     },
-    adapter: new InMemoryThreadListAdapter(),
+    adapter,
     allowNesting: true,
   });
   return runtime;

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.copy.integration.test.tsx

@@ -0,0 +1,289 @@
+// @vitest-environment jsdom
+
+import { act, render, waitFor } from "@testing-library/react";
+import type { AssistantCloud } from "assistant-cloud";
+import { useSyncExternalStore } from "react";
+import { describe, expect, it, vi } from "vitest";
+import type { AssistantRuntime } from "../../../runtime/api/assistant-runtime";
+import type { ExternalStoreAdapter } from "../../../runtimes/external-store/external-store-adapter";
+import type { ThreadMessage } from "../../../types/message";
+import { AssistantRuntimeProvider } from "../../AssistantRuntimeProvider";
+import { useExternalStoreRuntime } from "../useExternalStoreRuntime";
+import { useRemoteThreadListRuntime } from "../useRemoteThreadListRuntime";
+import { useCloudThreadListAdapter } from "./useCloudThreadListAdapter";
+
+const user = (id: string): ThreadMessage => ({
+  id,
+  role: "user",
+  content: [{ type: "text", text: id }],
+  attachments: [],
+  createdAt: new Date(0),
+  metadata: { custom: {} },
+});
+
+const assistant = (id: string): ThreadMessage =>
+  ({
+    id,
+    role: "assistant",
+    content: [
+      { type: "text", text: id },
+      {
+        type: "tool-call",
+        toolCallId: "call-1",
+        toolName: "choose",
+        args: {},
+        argsText: "{}",
+      },
+    ],
+    status: { type: "complete", reason: "stop" },
+    createdAt: new Date(0),
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const makeCloud = (
+  telemetry: { enabled?: boolean; messages?: boolean } = {},
+) => {
+  let threadCount = 0;
+  const listMessages = vi.fn().mockResolvedValue({ messages: [] });
+  const createMessage = vi.fn().mockImplementation(async () => ({
+    message_id: `cloud-message-${createMessage.mock.calls.length}`,
+  }));
+  const cloud = {
+    threads: {
+      list: vi.fn().mockResolvedValue({ threads: [] }),
+      create: vi.fn().mockImplementation(async () => ({
+        thread_id: `cloud-${++threadCount}`,
+      })),
+      update: vi.fn().mockResolvedValue(undefined),
+      delete: vi.fn().mockResolvedValue(undefined),
+      get: vi.fn(),
+      messages: {
+        list: listMessages,
+        create: createMessage,
+        update: vi.fn().mockResolvedValue(undefined),
+      },
+    },
+    events: { track: vi.fn() },
+    telemetry: { enabled: true, ...telemetry },
+    runs: {
+      report: vi.fn().mockResolvedValue(undefined),
+      stream: vi.fn(
+        async () =>
+          new ReadableStream({
+            start(controller) {
+              controller.close();
+            },
+          }),
+      ),
+    },
+    registerSdk: vi.fn(),
+  } as unknown as AssistantCloud;
+  return { cloud, listMessages, createMessage };
+};
+
+const settle = async () => {
+  await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  });
+};
+
+const setup = (
+  cloud: AssistantCloud,
+  { persistsHistory = false }: { persistsHistory?: boolean } = {},
+) => {
+  const subscribers = new Set<() => void>();
+  let store: ExternalStoreAdapter<ThreadMessage> = {
+    messages: [],
+    isRunning: false,
+    onNew: async () => {},
+    ...(persistsHistory ? { unstable_persistsHistory: true } : undefined),
+  };
+  const subscribe = (callback: () => void) => {
+    subscribers.add(callback);
+    return () => subscribers.delete(callback);
+  };
+  const getSnapshot = () => store;
+  const useControlledExternalStoreRuntime = () =>
+    useExternalStoreRuntime(useSyncExternalStore(subscribe, getSnapshot));
+  let runtime!: AssistantRuntime;
+  const Harness = () => {
+    const adapter = useCloudThreadListAdapter({ cloud });
+    runtime = useRemoteThreadListRuntime({
+      adapter,
+      runtimeHook: useControlledExternalStoreRuntime,
+    });
+    return (
+      <AssistantRuntimeProvider runtime={runtime}>
+        {null}
+      </AssistantRuntimeProvider>
+    );
+  };
+  const view = render(<Harness />);
+  const update = (next: Partial<ExternalStoreAdapter<ThreadMessage>>) => {
+    act(() => {
+      store = { ...store, ...next };
+      for (const subscriber of subscribers) subscriber();
+    });
+  };
+  const ready = async () => {
+    await waitFor(() =>
+      expect(runtime.threads.mainItem.getState().id).toBeDefined(),
+    );
+    await settle();
+  };
+  return { getRuntime: () => runtime, ready, update, view };
+};
+
+describe("Assistant Cloud external-store transcript copy", () => {
+  it("copies a settled turn and only the new messages from the next turn", async () => {
+    const { cloud, listMessages, createMessage } = makeCloud();
+    const app = setup(cloud);
+    const firstUser = user("user-1");
+    const firstReply = assistant("assistant-1");
+
+    await app.ready();
+    app.update({ isRunning: true, messages: [firstUser] });
+    app.update({ isRunning: false, messages: [firstUser, firstReply] });
+    await settle();
+    await waitFor(() => expect(createMessage).toHaveBeenCalledTimes(2));
+
+    const firstTurn = createMessage.mock.calls.map(([, body]) => body);
+    expect(firstTurn).toMatchObject([
+      { format: "aui/v0", external_id: "user-1" },
+      {
+        format: "aui/v0",
+        external_id: "assistant-1",
+        parent_external_id: "user-1",
+      },
+    ]);
+    expect(firstTurn[0]).not.toHaveProperty("parent_external_id");
+    expect(listMessages).toHaveBeenCalledOnce();
+
+    const secondUser = user("user-2");
+    const secondReply = assistant("assistant-2");
+    app.update({ isRunning: true });
+    app.update({
+      isRunning: false,
+      messages: [firstUser, firstReply, secondUser, secondReply],
+    });
+    await settle();
+    await waitFor(() => expect(createMessage).toHaveBeenCalledTimes(4));
+
+    const writes = createMessage.mock.calls.map(([, body]) => body);
+    expect(writes.map((body) => body.external_id)).toEqual([
+      "user-1",
+      "assistant-1",
+      "user-2",
+      "assistant-2",
+    ]);
+    expect(writes.slice(2)).toMatchObject([
+      {
+        format: "aui/v0",
+        external_id: "user-2",
+        parent_external_id: "assistant-1",
+      },
+      {
+        format: "aui/v0",
+        external_id: "assistant-2",
+        parent_external_id: "user-2",
+      },
+    ]);
+    expect(listMessages).toHaveBeenCalledOnce();
+    app.view.unmount();
+  });
+
+  it("rewrites a copied reply with a recorded tool interaction", async () => {
+    const { cloud, listMessages, createMessage } = makeCloud();
+    const app = setup(cloud);
+    const firstUser = user("user-1");
+    const firstReply = assistant("assistant-1");
+
+    await app.ready();
+    app.update({ isRunning: true, messages: [firstUser] });
+    app.update({ isRunning: false, messages: [firstUser, firstReply] });
+    await settle();
+    await waitFor(() => expect(createMessage).toHaveBeenCalledTimes(2));
+
+    await act(async () => {
+      await app
+        .getRuntime()
+        .thread.getMessageById("assistant-1")
+        .getMessagePartByToolCallId("call-1").unstable_recordInteraction!({
+        type: "action",
+        payload: { choice: "yes" },
+      });
+    });
+
+    await waitFor(() => expect(createMessage).toHaveBeenCalledTimes(3));
+    const copied = createMessage.mock.calls[2]![1];
+    const copiedToolCall = copied.content.content.find(
+      (part: { type: string }) => part.type === "tool-call",
+    );
+    expect(copied).toMatchObject({ external_id: "assistant-1" });
+    expect(copiedToolCall).toMatchObject({
+      unstable_interactions: {
+        entries: [{ type: "action", payload: { choice: "yes" } }],
+      },
+    });
+    expect(firstReply.content[1]).not.toHaveProperty("unstable_interactions");
+    expect(
+      app.getRuntime().thread.getMessageById("assistant-1").getState()
+        .content[1],
+    ).not.toHaveProperty("unstable_interactions");
+    expect(listMessages).toHaveBeenCalledOnce();
+    app.view.unmount();
+  });
+
+  it("neither copies a turn nor records a tool interaction when Cloud message telemetry is disabled", async () => {
+    const { cloud, listMessages, createMessage } = makeCloud({
+      messages: false,
+    });
+    const app = setup(cloud);
+    const firstUser = user("user-1");
+
+    await app.ready();
+    app.update({ isRunning: true, messages: [firstUser] });
+    app.update({
+      isRunning: false,
+      messages: [firstUser, assistant("assistant-1")],
+    });
+    await settle();
+
+    await expect(
+      app
+        .getRuntime()
+        .thread.getMessageById("assistant-1")
+        .getMessagePartByToolCallId("call-1").unstable_recordInteraction!({
+        type: "action",
+        payload: { choice: "yes" },
+      }),
+    ).rejects.toThrow("Runtime does not support recording tool interactions.");
+    expect(listMessages).not.toHaveBeenCalled();
+    expect(createMessage).not.toHaveBeenCalled();
+    app.view.unmount();
+  });
+
+  it("does not copy a finished turn from a store that persists history", async () => {
+    const { cloud, listMessages, createMessage } = makeCloud();
+    const app = setup(cloud, { persistsHistory: true });
+    const firstUser = user("user-1");
+
+    await app.ready();
+    app.update({ isRunning: true, messages: [firstUser] });
+    app.update({
+      isRunning: false,
+      messages: [firstUser, assistant("assistant-1")],
+    });
+    await settle();
+
+    expect(listMessages).not.toHaveBeenCalled();
+    expect(createMessage).not.toHaveBeenCalled();
+    app.view.unmount();
+  });
+});