@assistant-ui/core 0.3.16 → 0.3.17

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

@@ -0,0 +1,236 @@
+declare const process: { env: Record<string, string | undefined> };
+
+import { type RefObject, useMemo, useState } from "react";
+import { AssistantCloud } from "assistant-cloud";
+import type {
+  RemoteThreadListAdapter,
+  RuntimeAdapters,
+} from "../../../runtimes/remote-thread-list/types";
+import { InMemoryThreadListAdapter } from "../../../runtimes/remote-thread-list/adapter/in-memory";
+import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
+import { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";
+import { isRecord } from "../../../utils/json/is-json";
+
+type ThreadData = {
+  externalId: string | undefined;
+};
+
+export type CloudThreadListAdapterOptions = {
+  cloud?: AssistantCloud | undefined;
+
+  create?: (() => Promise<ThreadData>) | undefined;
+  delete?: ((threadId: string) => Promise<void>) | undefined;
+};
+
+const toCustom = (value: unknown): Record<string, unknown> | undefined =>
+  isRecord(value) ? value : undefined;
+
+const baseUrl =
+  typeof process !== "undefined" &&
+  process?.env?.NEXT_PUBLIC_ASSISTANT_BASE_URL;
+export const autoCloud = baseUrl
+  ? new AssistantCloud({ baseUrl, anonymous: true })
+  : undefined;
+
+export const useCloudRuntimeAdapters = (
+  cloudRef: RefObject<AssistantCloud>,
+): RuntimeAdapters => {
+  const history = useAssistantCloudThreadHistoryAdapter(cloudRef);
+  const [attachments] = useState(
+    () => new CloudFileAttachmentAdapter(() => cloudRef.current),
+  );
+  return useMemo(
+    () => ({
+      history,
+      attachments,
+    }),
+    [history, attachments],
+  );
+};
+
+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;
+  }
+};
+
+/**
+ * Builds the `RemoteThreadListAdapter` for an assistant-cloud backend without
+ * requiring a hook call site, so plain code (a Vue or Svelte setup function,
+ * a module-level config) can construct it. Options are read through the
+ * getter on every call, so a stable adapter can follow changing `create` and
+ * `delete` callbacks; swapping to a different `cloud` instance requires a new
+ * adapter (and `reload()` on the list). Without a `cloud` instance (and
+ * without `NEXT_PUBLIC_ASSISTANT_BASE_URL`), the adapter falls back to an
+ * in-memory list. `useCloudThreadListAdapter` wraps this for the React
+ * hook signature.
+ */
+export const createCloudThreadListAdapter = (
+  options:
+    | CloudThreadListAdapterOptions
+    | (() => CloudThreadListAdapterOptions),
+): RemoteThreadListAdapter => {
+  const getOptions = typeof options === "function" ? options : () => options;
+
+  const unstable_useAdapters = function useCloudAdapters(): RuntimeAdapters {
+    return useCloudRuntimeAdapters({
+      get current() {
+        return getOptions().cloud ?? autoCloud!;
+      },
+    });
+  };
+
+  const cloud = getOptions().cloud ?? autoCloud;
+  if (!cloud) {
+    const inMemory = new InMemoryThreadListAdapter();
+    inMemory.initialize = async (threadId: string) => {
+      const result = await getOptions().create?.();
+      return { remoteId: threadId, externalId: result?.externalId };
+    };
+    return inMemory;
+  }
+
+  return {
+    list: async ({ 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" as const) : ("regular" as const),
+          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),
+        })),
+        nextCursor:
+          activeNext || archivedNext
+            ? JSON.stringify({
+                a: activeNext,
+                r: archivedNext,
+                ...(activeNext === undefined ? { ae: true } : {}),
+                ...(archivedNext === undefined ? { re: true } : {}),
+              })
+            : undefined,
+      };
+    },
+
+    initialize: async () => {
+      const createTask = getOptions().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 getOptions().delete?.(threadId);
+      return cloud.threads.delete(threadId);
+    },
+
+    generateTitle: async (threadId, messages) => {
+      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" as const)
+          : ("regular" as const),
+        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_useAdapters,
+  };
+};

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

@@ -1,8 +1,15 @@
 // @vitest-environment jsdom
 
-import { renderHook } from "@testing-library/react";
+import { act, render, renderHook } from "@testing-library/react";
 import type { AssistantCloud } from "assistant-cloud";
+import {
+  startTransition,
+  Suspense,
+  useInsertionEffect,
+  type ReactNode,
+} from "react";
 import { describe, expect, it, vi } from "vitest";
+import type { RemoteThreadListAdapter } from "../../../runtimes/remote-thread-list/types";
 import { useCloudThreadListAdapter } from "./useCloudThreadListAdapter";
 
 const makeThread = (id: string) => ({
@@ -18,7 +25,89 @@ const makeThread = (id: string) => ({
   workspace_id: "workspace-1",
 });
 
+const Suspend = ({ pending }: { pending: Promise<never> }) => {
+  throw pending;
+};
+
 describe("useCloudThreadListAdapter", () => {
+  it("keeps operations scoped to the committed Cloud options", async () => {
+    const deleteA = vi.fn(async () => {});
+    const deleteB = vi.fn(async () => {});
+    const cloudDeleteA = vi.fn(async () => {});
+    const cloudDeleteB = vi.fn(async () => {});
+    const cloudA = {
+      threads: { delete: cloudDeleteA },
+    } as unknown as AssistantCloud;
+    const cloudB = {
+      threads: { delete: cloudDeleteB },
+    } as unknown as AssistantCloud;
+    const committed: { current: RemoteThreadListAdapter | null } = {
+      current: null,
+    };
+    const renderB = vi.fn();
+    let suspend = false;
+    const pending = new Promise<never>(() => {});
+
+    const App = ({
+      cloud,
+      onDelete,
+    }: {
+      cloud: AssistantCloud;
+      onDelete: (threadId: string) => Promise<void>;
+    }) => {
+      const adapter = useCloudThreadListAdapter({
+        cloud,
+        delete: onDelete,
+      });
+      if (cloud === cloudB) renderB();
+      useInsertionEffect(() => {
+        committed.current = adapter;
+      }, [adapter]);
+      return null;
+    };
+    const Boundary = ({ children }: { children: ReactNode }) => (
+      <Suspense fallback={null}>
+        {children}
+        {suspend ? <Suspend pending={pending} /> : null}
+      </Suspense>
+    );
+    const view = render(
+      <Boundary>
+        <App cloud={cloudA} onDelete={deleteA} />
+      </Boundary>,
+    );
+
+    act(() => {
+      suspend = true;
+      startTransition(() => {
+        view.rerender(
+          <Boundary>
+            <App cloud={cloudB} onDelete={deleteB} />
+          </Boundary>,
+        );
+      });
+    });
+    expect(renderB).toHaveBeenCalled();
+
+    await committed.current!.delete!("thread-1");
+
+    expect(deleteA).toHaveBeenCalledWith("thread-1");
+    expect(deleteB).not.toHaveBeenCalled();
+    expect(cloudDeleteA).toHaveBeenCalledWith("thread-1");
+    expect(cloudDeleteB).not.toHaveBeenCalled();
+
+    suspend = false;
+    view.rerender(
+      <Boundary>
+        <App cloud={cloudB} onDelete={deleteB} />
+      </Boundary>,
+    );
+    await committed.current!.delete!("thread-2");
+
+    expect(deleteB).toHaveBeenCalledWith("thread-2");
+    expect(cloudDeleteB).toHaveBeenCalledWith("thread-2");
+  });
+
   it("loads archived Cloud threads alongside regular threads", async () => {
     const activeThreads = [makeThread("active-1")];
     const archivedThreads = [

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

@@ -1,257 +1,52 @@
-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 { useCallback, useInsertionEffect, useMemo, useRef } from "react";
 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,
-  type RuntimeAdapters,
-} from "../RuntimeAdapterProvider";
-import { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";
-import { isRecord } from "../../../utils/json/is-json";
-
-type ThreadData = {
-  externalId: string | undefined;
-};
-
-type CloudThreadListAdapterOptions = {
-  cloud?: AssistantCloud | undefined;
-
-  create?: (() => Promise<ThreadData>) | undefined;
-  delete?: ((threadId: string) => Promise<void>) | undefined;
-};
-
-const toCustom = (value: unknown): Record<string, unknown> | undefined =>
-  isRecord(value) ? value : undefined;
-
-const baseUrl =
-  typeof process !== "undefined" &&
-  process?.env?.NEXT_PUBLIC_ASSISTANT_BASE_URL;
-const autoCloud = baseUrl
-  ? new AssistantCloud({ baseUrl, anonymous: true })
-  : undefined;
-
-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],
-  );
-};
+  autoCloud,
+  createCloudThreadListAdapter,
+  type CloudThreadListAdapterOptions,
+  useCloudRuntimeAdapters,
+} from "./createCloudThreadListAdapter";
 
 export const useCloudThreadListAdapter = (
   adapter: CloudThreadListAdapterOptions,
 ): RemoteThreadListAdapter => {
   const adapterRef = useRef(adapter);
-  useEffect(() => {
+  useInsertionEffect(() => {
     adapterRef.current = adapter;
   }, [adapter]);
 
-  const unstable_useAdapters = useCallback(function useCloudAdapters() {
-    return useCloudThreadListAdapters(adapterRef);
-  }, []);
+  const cloud = adapter.cloud ?? autoCloud;
+  const base = useMemo(
+    () =>
+      createCloudThreadListAdapter(() => ({
+        ...adapterRef.current,
+        cloud,
+      })),
+    // oxlint-disable-next-line react-hooks/exhaustive-deps -- the factory pins the cloud instance; changing callbacks are read from the committed ref
+    [cloud],
+  );
+
+  const cloudRef = useMemo(
+    () => ({
+      get current() {
+        return adapterRef.current.cloud ?? autoCloud!;
+      },
+    }),
+    [],
+  );
 
-  const unstable_Provider = useCallback<FC<PropsWithChildren>>(
-    function Provider({ children }) {
-      const adapters = useCloudThreadListAdapters(adapterRef);
-      return (
-        <RuntimeAdapterProvider adapters={adapters}>
-          {children}
-        </RuntimeAdapterProvider>
-      );
+  const unstable_useAdapters = useCallback(
+    function useCloudAdapters() {
+      return useCloudRuntimeAdapters(cloudRef);
     },
-    [],
+    [cloudRef],
   );
 
-  const cloud = adapter.cloud ?? autoCloud;
   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 };
-      };
-      return inMemory;
-    }
-
+    if (base.unstable_useAdapters === undefined) return base;
     return {
-      list: async ({ 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",
-            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),
-          })),
-          nextCursor:
-            activeNext || archivedNext
-              ? JSON.stringify({
-                  a: activeNext,
-                  r: archivedNext,
-                  ...(activeNext === undefined ? { ae: true } : {}),
-                  ...(archivedNext === undefined ? { re: true } : {}),
-                })
-              : undefined,
-        };
-      },
-
-      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,
+      ...base,
       unstable_useAdapters,
     };
-  }, [cloud, unstable_Provider, unstable_useAdapters]);
+  }, [base, unstable_useAdapters]);
 };

package/src/react/runtimes/external-message-converter.ts

@@ -131,6 +131,7 @@ export const useExternalMessageConverter = <T extends WeakKey>({
             message: cache,
             generatedFallbackMessages,
           },
+          state.metadata.cancelledMessageIds,
         ),
     );