@assistant-ui/core 0.3.13 → 0.3.15

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

@@ -14,6 +14,12 @@ import {
 } from "assistant-cloud";
 import { auiV0Decode, auiV0Encode } from "./auiV0";
 import { type AssistantClient, getClientId, useAui } from "@assistant-ui/store";
+import type { ThreadListItemMethods } from "../../../store/scopes/thread-list-item";
+
+type CloudThreadListItem = Pick<
+  ThreadListItemMethods,
+  "getState" | "initialize"
+>;
 
 const globalPersistence = new WeakMap<
   getClientId.ClientId,
@@ -36,8 +42,10 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     return this.getAui();
   }
 
-  private get _persistence(): CloudMessagePersistence {
-    const key = getClientId(this.aui.threadListItem);
+  private getPersistence(
+    threadListItem: CloudThreadListItem = this.aui.threadListItem,
+  ): CloudMessagePersistence {
+    const key = getClientId(threadListItem);
     if (!globalPersistence.has(key)) {
       globalPersistence.set(
         key,
@@ -47,24 +55,57 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
     return globalPersistence.get(key)!;
   }
 
+  private get _persistence(): CloudMessagePersistence {
+    return this.getPersistence();
+  }
+
+  private tryGetKeyedThreadListItem(): CloudThreadListItem | undefined {
+    const live = this.aui.threadListItem;
+    if (!live.source) return undefined;
+    const id = live.getState().id;
+    if (id === undefined) return undefined;
+    return this.aui.threads.item({ id });
+  }
+
   withFormat<TMessage, TStorageFormat extends Record<string, unknown>>(
     formatAdapter: MessageFormatAdapter<TMessage, TStorageFormat>,
   ): GenericThreadHistoryAdapter<TMessage> {
     const adapter = this;
-    const formatted = createFormattedPersistence(
-      this._persistence,
-      formatAdapter,
-    );
+    let threadListItem: CloudThreadListItem | undefined;
+    const pinCurrent = () => {
+      const next = adapter.tryGetKeyedThreadListItem();
+      if (next) threadListItem = next;
+      return threadListItem;
+    };
+    const resolvePinned = () => threadListItem ?? pinCurrent();
+    const getFormatted = () =>
+      createFormattedPersistence(adapter._persistence, formatAdapter);
+    const getTargetFormatted = (item: CloudThreadListItem) =>
+      createFormattedPersistence(adapter.getPersistence(item), formatAdapter);
     return {
-      // Note: callers must also call reportTelemetry() for run tracking
+      pin() {
+        pinCurrent();
+      },
       async append(item: MessageFormatItem<TMessage>) {
-        const { remoteId } = await adapter.aui.threadListItem.initialize();
-        await formatted.append(remoteId, item);
+        const pinned = resolvePinned();
+        if (!pinned) {
+          throw new Error(
+            "Cannot persist cloud history without a thread list item.",
+          );
+        }
+        const remoteId =
+          pinned.getState().remoteId ?? (await pinned.initialize()).remoteId;
+        await getTargetFormatted(pinned).append(remoteId, item);
       },
       async update(item: MessageFormatItem<TMessage>, localMessageId: string) {
-        const remoteId = adapter.aui.threadListItem.getState().remoteId;
-        if (!remoteId) return;
-        await formatted.update?.(remoteId, item, localMessageId);
+        const pinned = resolvePinned();
+        const remoteId = pinned?.getState().remoteId;
+        if (!remoteId || !pinned) return;
+        await getTargetFormatted(pinned).update?.(
+          remoteId,
+          item,
+          localMessageId,
+        );
       },
       async delete() {
         throw new Error(
@@ -85,12 +126,15 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
           formatAdapter.format,
           encodedRunMessages,
           options,
+          resolvePinned(),
         );
       },
       async load(): Promise<MessageFormatRepository<TMessage>> {
-        const remoteId = adapter.aui.threadListItem.getState().remoteId;
+        pinCurrent();
+        const live = adapter.aui.threadListItem;
+        const remoteId = live.source ? live.getState().remoteId : undefined;
         if (!remoteId) return { messages: [] };
-        return formatted.load(remoteId);
+        return getFormatted().load(remoteId);
       },
     };
   }
@@ -153,10 +197,12 @@ class AssistantCloudThreadHistoryAdapter implements ThreadHistoryAdapter {
       durationMs?: number;
       stepTimestamps?: StepTimestamp[];
     },
+    threadListItem?: CloudThreadListItem,
   ) {
     if (!this.cloudRef.current.telemetry.enabled) return;
 
-    const remoteId = this.aui.threadListItem.getState().remoteId;
+    const remoteId = (threadListItem ?? this.aui.threadListItem).getState()
+      .remoteId;
     if (!remoteId) return;
 
     const extracted = extractRunTelemetry(format, runMessages);

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

@@ -19,10 +19,12 @@ const guessAttachmentType = (
 export class CloudFileAttachmentAdapter implements AttachmentAdapter {
   public accept = "*";
 
-  private cloud: AssistantCloud;
+  private getCloud: () => AssistantCloud;
 
-  constructor(cloud: AssistantCloud) {
-    this.cloud = cloud;
+  constructor(cloud: AssistantCloud);
+  constructor(getCloud: () => AssistantCloud);
+  constructor(cloud: AssistantCloud | (() => AssistantCloud)) {
+    this.getCloud = typeof cloud === "function" ? cloud : () => cloud;
   }
 
   private uploadedUrls = new Map<string, string>();
@@ -46,7 +48,7 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
 
     try {
       const { signedUrl, publicUrl } =
-        await this.cloud.files.generatePresignedUploadUrl({
+        await this.getCloud().files.generatePresignedUploadUrl({
           filename: file.name,
         });
       const res = await fetch(signedUrl, {

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

@@ -79,6 +79,11 @@ type AuiV0MessagePart =
       readonly mimeType: string;
       readonly filename?: string;
       readonly sourceType?: "url" | "id";
+    }
+  | {
+      readonly type: "data";
+      readonly name: string;
+      readonly data: ReadonlyJSONValue;
     };
 
 type AuiV0AttachmentPart =
@@ -296,8 +301,19 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
             ...(part.sourceType ? { sourceType: part.sourceType } : undefined),
           };
 
+        case "data": {
+          if (!isJSONValue(part.data)) {
+            console.warn(`data part is not JSON! ${JSON.stringify(part)}`);
+          }
+          return {
+            type: "data",
+            name: part.name,
+            data: part.data as ReadonlyJSONValue,
+          };
+        }
+
         default: {
-          const unhandledType: "audio" | "data" | "generative-ui" = type;
+          const unhandledType: "audio" | "generative-ui" = type;
           throw new Error(
             `Message part type not supported by aui/v0: ${unhandledType}`,
           );

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

@@ -19,7 +19,38 @@ const makeThread = (id: string) => ({
 });
 
 describe("useCloudThreadListAdapter", () => {
-  it("exposes full Cloud pages through the remote thread cursor", async () => {
+  it("loads archived Cloud threads alongside regular threads", async () => {
+    const activeThreads = [makeThread("active-1")];
+    const archivedThreads = [
+      { ...makeThread("archived-1"), is_archived: true },
+    ];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: activeThreads })
+      .mockResolvedValueOnce({ threads: archivedThreads });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const page = await result.current.list();
+
+    expect(list).toHaveBeenNthCalledWith(1, { limit: 20 });
+    expect(list).toHaveBeenNthCalledWith(2, {
+      is_archived: true,
+      limit: 20,
+    });
+    expect(page.threads.map((thread) => thread.remoteId)).toEqual([
+      "active-1",
+      "archived-1",
+    ]);
+    expect(
+      page.threads.find((thread) => thread.remoteId === "active-1")?.status,
+    ).toBe("regular");
+    expect(
+      page.threads.find((thread) => thread.remoteId === "archived-1")?.status,
+    ).toBe("archived");
+  });
+
+  it("continues the active list once the archived list is exhausted", async () => {
     const firstPage = Array.from({ length: 20 }, (_, index) =>
       makeThread(`thread-${index + 1}`),
     );
@@ -27,17 +58,20 @@ describe("useCloudThreadListAdapter", () => {
     const list = vi
       .fn()
       .mockResolvedValueOnce({ threads: firstPage })
+      .mockResolvedValueOnce({ threads: [] })
       .mockResolvedValueOnce({ threads: secondPage });
     const cloud = { threads: { list } } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const first = await result.current.list();
     expect(list).toHaveBeenNthCalledWith(1, { limit: 20 });
+    expect(list).toHaveBeenNthCalledWith(2, { is_archived: true, limit: 20 });
     expect(first.threads).toHaveLength(20);
-    expect(first.nextCursor).toBe("thread-20");
+    expect(JSON.parse(first.nextCursor!)).toEqual({ a: "thread-20", re: true });
 
     const second = await result.current.list({ after: first.nextCursor });
-    expect(list).toHaveBeenNthCalledWith(2, {
+    expect(list).toHaveBeenCalledTimes(3);
+    expect(list).toHaveBeenNthCalledWith(3, {
       limit: 20,
       after: "thread-20",
     });
@@ -46,4 +80,65 @@ describe("useCloudThreadListAdapter", () => {
     ]);
     expect(second.nextCursor).toBeUndefined();
   });
+
+  it("paginates both legs without dropping or duplicating items", async () => {
+    const activePage1 = Array.from({ length: 20 }, (_, index) =>
+      makeThread(`a-${index + 1}`),
+    );
+    const archivedPage1 = Array.from({ length: 20 }, (_, index) => ({
+      ...makeThread(`r-${index + 1}`),
+      is_archived: true,
+    }));
+    const activePage2 = [makeThread("a-21")];
+    const archivedPage2 = [{ ...makeThread("r-21"), is_archived: true }];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: activePage1 })
+      .mockResolvedValueOnce({ threads: archivedPage1 })
+      .mockResolvedValueOnce({ threads: activePage2 })
+      .mockResolvedValueOnce({ threads: archivedPage2 });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const page1 = await result.current.list();
+    expect(page1.threads).toHaveLength(40);
+    expect(JSON.parse(page1.nextCursor!)).toEqual({ a: "a-20", r: "r-20" });
+
+    const page2 = await result.current.list({ after: page1.nextCursor });
+    expect(list).toHaveBeenNthCalledWith(3, { limit: 20, after: "a-20" });
+    expect(list).toHaveBeenNthCalledWith(4, {
+      is_archived: true,
+      limit: 20,
+      after: "r-20",
+    });
+    expect(page2.threads.map((thread) => thread.remoteId)).toEqual([
+      "a-21",
+      "r-21",
+    ]);
+    expect(page2.nextCursor).toBeUndefined();
+  });
+
+  it("accepts a legacy bare-id cursor for the active list", async () => {
+    const activeThreads = [makeThread("thread-21")];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: activeThreads })
+      .mockResolvedValueOnce({ threads: [] });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const page = await result.current.list({ after: "thread-20" });
+
+    expect(list).toHaveBeenNthCalledWith(1, {
+      limit: 20,
+      after: "thread-20",
+    });
+    expect(list).toHaveBeenNthCalledWith(2, {
+      is_archived: true,
+      limit: 20,
+    });
+    expect(page.threads.map((thread) => thread.remoteId)).toEqual([
+      "thread-21",
+    ]);
+  });
 });

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

@@ -3,16 +3,21 @@ declare const process: { env: Record<string, string | undefined> };
 import {
   type FC,
   type PropsWithChildren,
+  type RefObject,
   useCallback,
   useEffect,
   useMemo,
   useRef,
+  useState,
 } from "react";
 import { AssistantCloud } from "assistant-cloud";
 import type { RemoteThreadListAdapter } from "../../../runtimes/remote-thread-list/types";
 import { InMemoryThreadListAdapter } from "../../../runtimes/remote-thread-list/adapter/in-memory";
 import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
-import { RuntimeAdapterProvider } from "../RuntimeAdapterProvider";
+import {
+  RuntimeAdapterProvider,
+  type RuntimeAdapters,
+} from "../RuntimeAdapterProvider";
 import { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";
 import { isRecord } from "../../../utils/json/is-json";
 
@@ -39,6 +44,58 @@ const autoCloud = baseUrl
 
 const CLOUD_THREAD_PAGE_SIZE = 20;
 
+type CloudListCursor = {
+  activeCursor: string | undefined;
+  archivedCursor: string | undefined;
+  activeExhausted: boolean;
+  archivedExhausted: boolean;
+};
+
+const parseListCursor = (after: string | undefined): CloudListCursor => {
+  const fallback: CloudListCursor = {
+    activeCursor: after,
+    archivedCursor: undefined,
+    activeExhausted: false,
+    archivedExhausted: false,
+  };
+  if (!after || !after.startsWith("{")) return fallback;
+  try {
+    const parsed = JSON.parse(after);
+    if (!isRecord(parsed)) return fallback;
+    return {
+      activeCursor: typeof parsed.a === "string" ? parsed.a : undefined,
+      archivedCursor: typeof parsed.r === "string" ? parsed.r : undefined,
+      activeExhausted: parsed.ae === true,
+      archivedExhausted: parsed.re === true,
+    };
+  } catch {
+    return fallback;
+  }
+};
+
+const useCloudThreadListAdapters = (
+  adapterRef: RefObject<CloudThreadListAdapterOptions>,
+): RuntimeAdapters => {
+  const history = useAssistantCloudThreadHistoryAdapter({
+    get current() {
+      return adapterRef.current.cloud ?? autoCloud!;
+    },
+  });
+  const [attachments] = useState(
+    () =>
+      new CloudFileAttachmentAdapter(
+        () => adapterRef.current.cloud ?? autoCloud!,
+      ),
+  );
+  return useMemo(
+    () => ({
+      history,
+      attachments,
+    }),
+    [history, attachments],
+  );
+};
+
 export const useCloudThreadListAdapter = (
   adapter: CloudThreadListAdapterOptions,
 ): RemoteThreadListAdapter => {
@@ -47,27 +104,13 @@ export const useCloudThreadListAdapter = (
     adapterRef.current = adapter;
   }, [adapter]);
 
+  const unstable_useAdapters = useCallback(function useCloudAdapters() {
+    return useCloudThreadListAdapters(adapterRef);
+  }, []);
+
   const unstable_Provider = useCallback<FC<PropsWithChildren>>(
     function Provider({ children }) {
-      const history = useAssistantCloudThreadHistoryAdapter({
-        get current() {
-          return adapterRef.current.cloud ?? autoCloud!;
-        },
-      });
-      const cloudInstance = adapterRef.current.cloud ?? autoCloud!;
-      const attachments = useMemo(
-        () => new CloudFileAttachmentAdapter(cloudInstance),
-        [cloudInstance],
-      );
-
-      const adapters = useMemo(
-        () => ({
-          history,
-          attachments,
-        }),
-        [history, attachments],
-      );
-
+      const adapters = useCloudThreadListAdapters(adapterRef);
       return (
         <RuntimeAdapterProvider adapters={adapters}>
           {children}
@@ -91,10 +134,38 @@ export const useCloudThreadListAdapter = (
 
     return {
       list: async ({ after } = {}) => {
-        const { threads } = await cloud.threads.list({
-          limit: CLOUD_THREAD_PAGE_SIZE,
-          ...(after ? { after } : {}),
-        });
+        const {
+          activeCursor,
+          archivedCursor,
+          activeExhausted,
+          archivedExhausted,
+        } = parseListCursor(after);
+        const [{ threads: activeThreads }, { threads: archivedThreads }] =
+          await Promise.all([
+            activeExhausted
+              ? Promise.resolve({ threads: [] })
+              : cloud.threads.list({
+                  limit: CLOUD_THREAD_PAGE_SIZE,
+                  ...(activeCursor ? { after: activeCursor } : {}),
+                }),
+            archivedExhausted
+              ? Promise.resolve({ threads: [] })
+              : cloud.threads.list({
+                  is_archived: true,
+                  limit: CLOUD_THREAD_PAGE_SIZE,
+                  ...(archivedCursor ? { after: archivedCursor } : {}),
+                }),
+          ]);
+        const activeNext =
+          !activeExhausted && activeThreads.length === CLOUD_THREAD_PAGE_SIZE
+            ? activeThreads.at(-1)?.id
+            : undefined;
+        const archivedNext =
+          !archivedExhausted &&
+          archivedThreads.length === CLOUD_THREAD_PAGE_SIZE
+            ? archivedThreads.at(-1)?.id
+            : undefined;
+        const threads = [...activeThreads, ...archivedThreads];
         return {
           threads: threads.map((t) => ({
             status: t.is_archived ? "archived" : "regular",
@@ -107,8 +178,13 @@ export const useCloudThreadListAdapter = (
             custom: toCustom(t.metadata),
           })),
           nextCursor:
-            threads.length === CLOUD_THREAD_PAGE_SIZE
-              ? threads.at(-1)?.id
+            activeNext || archivedNext
+              ? JSON.stringify({
+                  a: activeNext,
+                  r: archivedNext,
+                  ...(activeNext === undefined ? { ae: true } : {}),
+                  ...(archivedNext === undefined ? { re: true } : {}),
+                })
               : undefined,
         };
       },
@@ -175,6 +251,7 @@ export const useCloudThreadListAdapter = (
       },
 
       unstable_Provider,
+      unstable_useAdapters,
     };
-  }, [cloud, unstable_Provider]);
+  }, [cloud, unstable_Provider, unstable_useAdapters]);
 };

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

@@ -0,0 +1,56 @@
+// @vitest-environment jsdom
+
+import { renderHook } from "@testing-library/react";
+import type { AssistantCloud } from "assistant-cloud";
+import { describe, expect, it, vi } from "vitest";
+import type { AssistantRuntime } from "../../../runtime/api/assistant-runtime";
+import { useCloudThreadListRuntime } from "./useCloudThreadListRuntime";
+
+const mocks = vi.hoisted(() => ({
+  useCloudThreadListAdapter: vi.fn(),
+  useRemoteThreadListRuntime: vi.fn(),
+}));
+
+vi.mock("./useCloudThreadListAdapter", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./useCloudThreadListAdapter")>()),
+  useCloudThreadListAdapter: mocks.useCloudThreadListAdapter,
+}));
+
+vi.mock("../useRemoteThreadListRuntime", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("../useRemoteThreadListRuntime")>()),
+  useRemoteThreadListRuntime: mocks.useRemoteThreadListRuntime,
+}));
+
+describe("useCloudThreadListRuntime", () => {
+  it("forwards cloud options to the adapter and nests the runtime hook", () => {
+    const cloud = { threads: {} } as AssistantCloud;
+    const runtimeHook = () => ({}) as AssistantRuntime;
+    const create = vi.fn();
+    const del = vi.fn();
+    const adapter = { list: vi.fn() };
+    const runtime = { kind: "runtime" };
+    mocks.useCloudThreadListAdapter.mockReturnValue(adapter);
+    mocks.useRemoteThreadListRuntime.mockReturnValue(runtime);
+
+    const { result } = renderHook(() =>
+      useCloudThreadListRuntime({
+        cloud,
+        runtimeHook,
+        create,
+        delete: del,
+      }),
+    );
+
+    expect(mocks.useCloudThreadListAdapter).toHaveBeenCalledWith({
+      cloud,
+      create,
+      delete: del,
+    });
+    expect(mocks.useRemoteThreadListRuntime).toHaveBeenCalledWith({
+      runtimeHook,
+      adapter,
+      allowNesting: true,
+    });
+    expect(result.current).toBe(runtime);
+  });
+});

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

@@ -0,0 +1,31 @@
+"use client";
+
+import type { AssistantCloud } from "assistant-cloud";
+import type { AssistantRuntime } from "../../../runtime/api/assistant-runtime";
+import { useRemoteThreadListRuntime } from "../useRemoteThreadListRuntime";
+import { useCloudThreadListAdapter } from "./useCloudThreadListAdapter";
+
+type ThreadData = {
+  externalId: string;
+};
+
+type CloudThreadListAdapter = {
+  cloud: AssistantCloud;
+
+  runtimeHook: () => AssistantRuntime;
+
+  create?(): Promise<ThreadData>;
+  delete?(threadId: string): Promise<void>;
+};
+
+export function useCloudThreadListRuntime({
+  runtimeHook,
+  ...adapterOptions
+}: CloudThreadListAdapter) {
+  const adapter = useCloudThreadListAdapter(adapterOptions);
+  return useRemoteThreadListRuntime({
+    runtimeHook,
+    adapter,
+    allowNesting: true,
+  });
+}