@assistant-ui/core 0.2.22 → 0.3.0

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

@@ -6,20 +6,22 @@ import { describe, expect, it, vi } from "vitest";
 import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
 
 const mocks = vi.hoisted(() => {
-  const threadListItem = {
-    getState: () => ({ remoteId: "thread-1" }),
-  };
+  const makeClient = (remoteId: string) =>
+    ({
+      threadListItem: {
+        getState: () => ({ remoteId }),
+      },
+    }) as unknown as import("@assistant-ui/store").AssistantClient;
 
   return {
-    assistantClient: {
-      threadListItem: () => threadListItem,
-    },
+    makeClient,
+    aui: makeClient("thread-1"),
   };
 });
 
 vi.mock("@assistant-ui/store", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/store")>()),
-  useAui: () => mocks.assistantClient,
+  useAui: () => mocks.aui,
 }));
 
 const makeCloud = () =>
@@ -33,6 +35,7 @@ const makeCloud = () =>
 
 describe("useAssistantCloudThreadHistoryAdapter", () => {
   it("refreshes formatted persistence when the Cloud client changes", async () => {
+    mocks.aui = mocks.makeClient("thread-1");
     const firstCloud = makeCloud();
     const secondCloud = makeCloud();
     const cloudRef = { current: firstCloud };
@@ -66,4 +69,26 @@ describe("useAssistantCloudThreadHistoryAdapter", () => {
       format: "test",
     });
   });
+
+  it("resolves the aui client at call time instead of capturing it", async () => {
+    mocks.aui = mocks.makeClient("thread-1");
+    const cloud = makeCloud();
+    const cloudRef = { current: cloud };
+    const { result, rerender } = renderHook(() =>
+      useAssistantCloudThreadHistoryAdapter(cloudRef),
+    );
+
+    await result.current.load();
+    expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-1", {
+      format: "aui/v0",
+    });
+
+    mocks.aui = mocks.makeClient("thread-2");
+    rerender();
+
+    await result.current.load();
+    expect(cloud.threads.messages.list).toHaveBeenCalledWith("thread-2", {
+      format: "aui/v0",
+    });
+  });
 });

package/src/react/runtimes/cloud/AssistantCloudThreadHistoryAdapter.ts

@@ -1,4 +1,4 @@
-import { type RefObject, useState } from "react";
+import { type RefObject, useEffect, useRef, useState } from "react";
 import type {
   GenericThreadHistoryAdapter,
   ThreadHistoryAdapter,
@@ -13,22 +13,31 @@ import {
   createFormattedPersistence,
 } from "assistant-cloud";
 import { auiV0Decode, auiV0Encode } from "./auiV0";
-import { type AssistantClient, useAui } from "@assistant-ui/store";
-import type { ThreadListItemMethods } from "../../../store/scopes/thread-list-item";
+import { type AssistantClient, getClientId, useAui } from "@assistant-ui/store";
 
 const globalPersistence = new WeakMap<
-  ThreadListItemMethods,
+  getClientId.ClientId,
   CloudMessagePersistence
 >();
 
 class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
+  private cloudRef: RefObject<AssistantCloud>;
+  private auiRef: RefObject<AssistantClient>;
+
   constructor(
-    private cloudRef: RefObject<AssistantCloud>,
-    private aui: AssistantClient,
-  ) {}
+    cloudRef: RefObject<AssistantCloud>,
+    auiRef: RefObject<AssistantClient>,
+  ) {
+    this.cloudRef = cloudRef;
+    this.auiRef = auiRef;
+  }
+
+  private get aui(): AssistantClient {
+    return this.auiRef.current;
+  }
 
   private get _persistence(): CloudMessagePersistence {
-    const key = this.aui.threadListItem();
+    const key = getClientId(this.aui.threadListItem);
     if (!globalPersistence.has(key)) {
       globalPersistence.set(
         key,
@@ -49,11 +58,11 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     return {
       // Note: callers must also call reportTelemetry() for run tracking
       async append(item: MessageFormatItem<TMessage>) {
-        const { remoteId } = await adapter.aui.threadListItem().initialize();
+        const { remoteId } = await adapter.aui.threadListItem.initialize();
         await formatted.append(remoteId, item);
       },
       async update(item: MessageFormatItem<TMessage>, localMessageId: string) {
-        const remoteId = adapter.aui.threadListItem().getState().remoteId;
+        const remoteId = adapter.aui.threadListItem.getState().remoteId;
         if (!remoteId) return;
         await formatted.update?.(remoteId, item, localMessageId);
       },
@@ -79,7 +88,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
         );
       },
       async load(): Promise<MessageFormatRepository<TMessage>> {
-        const remoteId = adapter.aui.threadListItem().getState().remoteId;
+        const remoteId = adapter.aui.threadListItem.getState().remoteId;
         if (!remoteId) return { messages: [] };
         return formatted.load(remoteId);
       },
@@ -87,7 +96,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   }
 
   async append({ parentId, message }: ExportedMessageRepositoryItem) {
-    const { remoteId } = await this.aui.threadListItem().initialize();
+    const { remoteId } = await this.aui.threadListItem.initialize();
     const encoded = auiV0Encode(message);
     await this._persistence.append(
       remoteId,
@@ -102,6 +111,21 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     }
   }
 
+  async update(item: ExportedMessageRepositoryItem) {
+    if (!this._persistence.isPersisted(item.message.id)) {
+      return this.append(item);
+    }
+    const { message } = item;
+    const remoteId = this.aui.threadListItem.getState().remoteId;
+    if (!remoteId) return;
+    const encoded = auiV0Encode(message);
+    await this._persistence.update(remoteId, message.id, "aui/v0", encoded);
+
+    if (this.cloudRef.current.telemetry.enabled) {
+      this._maybeReportRun(remoteId, "aui/v0", encoded);
+    }
+  }
+
   async delete() {
     throw new Error(
       "Assistant Cloud does not support deleting thread messages yet.",
@@ -109,7 +133,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   }
 
   async load() {
-    const remoteId = this.aui.threadListItem().getState().remoteId;
+    const remoteId = this.aui.threadListItem.getState().remoteId;
     if (!remoteId) return { messages: [] };
     const messages = await this._persistence.load(remoteId, "aui/v0");
     return {
@@ -132,7 +156,7 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
   ) {
     if (!this.cloudRef.current.telemetry.enabled) return;
 
-    const remoteId = this.aui.threadListItem().getState().remoteId;
+    const remoteId = this.aui.threadListItem.getState().remoteId;
     if (!remoteId) return;
 
     const extracted = extractRunTelemetry(format, runMessages);
@@ -341,7 +365,7 @@ const AUI_STATUS_MAP: Record<string, TelemetryData["status"]> = {
   incomplete: "incomplete",
 };
 
-function extractAuiV0<T>(content: T): TelemetryData | null {
+export function extractAuiV0<T>(content: T): TelemetryData | null {
   const msg = content as {
     role?: string;
     status?: { type: string };
@@ -369,6 +393,9 @@ function extractAuiV0<T>(content: T): TelemetryData | null {
   };
 
   if (msg.role !== "assistant") return null;
+  // A paused (requires-action) write is not a finished run; reporting it would
+  // mislabel it "completed" and double-count steps once the terminal write reports.
+  if (msg.status?.type === "requires-action") return null;
 
   const toolCalls = msg.content
     ?.filter((p) => p.type === "tool-call" && p.toolName && p.toolCallId)
@@ -789,8 +816,12 @@ export function useAssistantCloudThreadHistoryAdapter(
   cloudRef: RefObject<AssistantCloud>,
 ): ThreadHistoryAdapter {
   const aui = useAui();
+  const auiRef = useRef(aui);
+  useEffect(() => {
+    auiRef.current = aui;
+  });
   const [adapter] = useState(
-    () => new AssistantCloudThreadHistoryAdapter(cloudRef, aui),
+    () => new AssistantCloudThreadHistoryAdapter(cloudRef, auiRef),
   );
   return adapter;
 }

package/src/react/runtimes/cloud/CloudFileAttachmentAdapter.ts

@@ -19,7 +19,11 @@ const guessAttachmentType = (
 export class CloudFileAttachmentAdapter implements AttachmentAdapter {
   public accept = "*";
 
-  constructor(private cloud: AssistantCloud) {}
+  private cloud: AssistantCloud;
+
+  constructor(cloud: AssistantCloud) {
+    this.cloud = cloud;
+  }
 
   private uploadedUrls = new Map<string, string>();
 

package/src/react/runtimes/cloud/auiV0.ts

@@ -6,6 +6,7 @@ import type {
   SourceProviderMetadata,
   ThreadMessage,
   TextMessagePart,
+  ToolApprovalOption,
   Unstable_AudioMessagePart,
 } from "../../../types/message";
 import type { CompleteAttachment } from "../../../types/attachment";
@@ -18,6 +19,16 @@ import type {
 } from "assistant-stream/utils";
 import type { ExportedMessageRepositoryItem } from "../../../runtime/utils/message-repository";
 
+type AuiV0ToolApproval = {
+  readonly id: string;
+  readonly approved?: boolean;
+  readonly reason?: string;
+  readonly isAutomatic?: boolean;
+  readonly options?: readonly ToolApprovalOption[];
+  readonly optionId?: string;
+  readonly resolution?: "cancelled" | "expired";
+};
+
 type AuiV0MessagePart =
   | {
       readonly type: "text";
@@ -51,6 +62,7 @@ type AuiV0MessagePart =
       readonly args: ReadonlyJSONObject;
       readonly result?: ReadonlyJSONValue;
       readonly isError?: true;
+      readonly approval?: AuiV0ToolApproval;
     }
   | {
       readonly type: "tool-call";
@@ -59,6 +71,7 @@ type AuiV0MessagePart =
       readonly argsText: string;
       readonly result?: ReadonlyJSONValue;
       readonly isError?: true;
+      readonly approval?: AuiV0ToolApproval;
     }
   | {
       readonly type: "image";
@@ -216,6 +229,7 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
               ? { result: part.result as ReadonlyJSONValue }
               : undefined),
             ...(part.isError ? { isError: true } : undefined),
+            ...(part.approval ? { approval: part.approval } : undefined),
           };
         }
 

package/src/react/runtimes/cloud/useCloudThreadListAdapter.tsx

@@ -76,94 +76,96 @@ export const useCloudThreadListAdapter = (
   );
 
   const cloud = adapter.cloud ?? autoCloud;
-  if (!cloud) {
-    const ref = adapterRef;
-    const inMemory = new InMemoryThreadListAdapter();
-    inMemory.initialize = async (threadId: string) => {
-      const result = await ref.current.create?.();
-      return { remoteId: threadId, externalId: result?.externalId };
-    };
-    return inMemory;
-  }
-
-  return {
-    list: async () => {
-      const { threads } = await cloud.threads.list();
-      return {
-        threads: threads.map((t) => ({
-          status: t.is_archived ? "archived" : "regular",
-          remoteId: t.id,
-          title: t.title,
-          lastMessageAt: t.last_message_at
-            ? new Date(t.last_message_at)
-            : undefined,
-          externalId: t.external_id ?? undefined,
-          custom: toCustom(t.metadata),
-        })),
+  return useMemo<RemoteThreadListAdapter>(() => {
+    if (!cloud) {
+      const ref = adapterRef;
+      const inMemory = new InMemoryThreadListAdapter();
+      inMemory.initialize = async (threadId: string) => {
+        const result = await ref.current.create?.();
+        return { remoteId: threadId, externalId: result?.externalId };
       };
-    },
-
-    initialize: async () => {
-      const createTask = adapter.create?.() ?? Promise.resolve();
-      const t = await createTask;
-      const external_id = t ? t.externalId : undefined;
-      const { thread_id: remoteId } = await cloud.threads.create({
-        last_message_at: new Date(),
-        external_id,
-      });
-
-      return { externalId: external_id, remoteId: remoteId };
-    },
-
-    rename: async (threadId, newTitle) => {
-      return cloud.threads.update(threadId, { title: newTitle });
-    },
-    updateCustom: async (threadId, custom) => {
-      return cloud.threads.update(threadId, { metadata: custom ?? null });
-    },
-    archive: async (threadId) => {
-      return cloud.threads.update(threadId, { is_archived: true });
-    },
-    unarchive: async (threadId) => {
-      return cloud.threads.update(threadId, { is_archived: false });
-    },
-    delete: async (threadId) => {
-      await adapter.delete?.(threadId);
-      return cloud.threads.delete(threadId);
-    },
-
-    generateTitle: async (threadId, messages) => {
-      // Filter messages to only include content types the title generator understands
-      // (reasoning, source, etc. are not needed for title generation)
-      // TODO serialize these to a more efficient format
-      const filteredMessages = messages.map((msg) => ({
-        ...msg,
-        content: msg.content.filter(
-          (part) => part.type === "text" || part.type === "tool-call",
-        ),
-      }));
-
-      return cloud.runs.stream({
-        thread_id: threadId,
-        assistant_id: "system/thread_title",
-        messages: filteredMessages,
-      });
-    },
-
-    fetch: async (threadId: string) => {
-      const thread = await cloud.threads.get(threadId);
-      return {
-        status: thread.is_archived ? "archived" : "regular",
-        remoteId: thread.id,
-        title: thread.title,
-        lastMessageAt: thread.last_message_at
-          ? new Date(thread.last_message_at)
-          : undefined,
-        externalId: thread.external_id ?? undefined,
-        custom: toCustom(thread.metadata),
-      };
-    },
+      return inMemory;
+    }
+
+    return {
+      list: async () => {
+        const { threads } = await cloud.threads.list();
+        return {
+          threads: threads.map((t) => ({
+            status: t.is_archived ? "archived" : "regular",
+            remoteId: t.id,
+            title: t.title,
+            lastMessageAt: t.last_message_at
+              ? new Date(t.last_message_at)
+              : undefined,
+            externalId: t.external_id ?? undefined,
+            custom: toCustom(t.metadata),
+          })),
+        };
+      },
+
+      initialize: async () => {
+        const createTask = adapterRef.current.create?.() ?? Promise.resolve();
+        const t = await createTask;
+        const external_id = t ? t.externalId : undefined;
+        const { thread_id: remoteId } = await cloud.threads.create({
+          last_message_at: new Date(),
+          external_id,
+        });
+
+        return { externalId: external_id, remoteId: remoteId };
+      },
+
+      rename: async (threadId, newTitle) => {
+        return cloud.threads.update(threadId, { title: newTitle });
+      },
+      updateCustom: async (threadId, custom) => {
+        return cloud.threads.update(threadId, { metadata: custom ?? null });
+      },
+      archive: async (threadId) => {
+        return cloud.threads.update(threadId, { is_archived: true });
+      },
+      unarchive: async (threadId) => {
+        return cloud.threads.update(threadId, { is_archived: false });
+      },
+      delete: async (threadId) => {
+        await adapterRef.current.delete?.(threadId);
+        return cloud.threads.delete(threadId);
+      },
+
+      generateTitle: async (threadId, messages) => {
+        // Filter messages to only include content types the title generator understands
+        // (reasoning, source, etc. are not needed for title generation)
+        // TODO serialize these to a more efficient format
+        const filteredMessages = messages.map((msg) => ({
+          ...msg,
+          content: msg.content.filter(
+            (part) => part.type === "text" || part.type === "tool-call",
+          ),
+        }));
+
+        return cloud.runs.stream({
+          thread_id: threadId,
+          assistant_id: "system/thread_title",
+          messages: filteredMessages,
+        });
+      },
+
+      fetch: async (threadId: string) => {
+        const thread = await cloud.threads.get(threadId);
+        return {
+          status: thread.is_archived ? "archived" : "regular",
+          remoteId: thread.id,
+          title: thread.title,
+          lastMessageAt: thread.last_message_at
+            ? new Date(thread.last_message_at)
+            : undefined,
+          externalId: thread.external_id ?? undefined,
+          custom: toCustom(thread.metadata),
+        };
+      },
 
-    unstable_Provider,
-  };
+      unstable_Provider,
+    };
+  }, [cloud, unstable_Provider]);
 };

package/src/react/runtimes/createRuntimeExtras.test.ts

@@ -6,7 +6,7 @@ type Extras = { value: number; greet: () => string };
 
 const clientWith = (extras: unknown) =>
   ({
-    thread: () => ({ getState: () => ({ extras }) }),
+    thread: { getState: () => ({ extras }) },
   }) as unknown as AssistantClient;
 
 describe("createRuntimeExtras", () => {

package/src/react/runtimes/createRuntimeExtras.ts

@@ -46,7 +46,7 @@ export const createRuntimeExtras = <T extends object>(
     is(extras) ? extras : undefined;
 
   const get = (client: AssistantClient): T =>
-    assert(client.thread().getState().extras);
+    assert(client.thread.getState().extras);
 
   function use<S>(
     select?: (extras: T) => S,