@assistant-ui/core 0.3.15 → 0.3.17

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

@@ -0,0 +1,88 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it, vi } from "vitest";
+import { renderHook } from "@testing-library/react";
+import type { AssistantCloud } from "assistant-cloud";
+import { createCloudThreadListAdapter } from "./createCloudThreadListAdapter";
+
+const makeCloud = () =>
+  ({
+    threads: {
+      list: vi.fn(async () => ({ threads: [] })),
+      create: vi.fn(async () => ({ thread_id: "remote-1" })),
+      update: vi.fn(async () => {}),
+      delete: vi.fn(async () => {}),
+      get: vi.fn(),
+    },
+    runs: { stream: vi.fn(async () => new ReadableStream()) },
+  }) as unknown as AssistantCloud;
+
+describe("createCloudThreadListAdapter", () => {
+  it("falls back to an in-memory list without a cloud instance", async () => {
+    const create = vi.fn(async () => ({ externalId: "ext-1" }));
+    const adapter = createCloudThreadListAdapter({ create });
+    expect(await adapter.list()).toEqual({ threads: [] });
+    expect(await adapter.initialize("local-1")).toEqual({
+      remoteId: "local-1",
+      externalId: "ext-1",
+    });
+    expect(create).toHaveBeenCalledOnce();
+  });
+
+  it("maps the cloud api and reads callbacks through the getter", async () => {
+    const cloud = makeCloud();
+    const options: {
+      cloud: AssistantCloud;
+      delete?: (threadId: string) => Promise<void>;
+    } = { cloud };
+    const adapter = createCloudThreadListAdapter(() => options);
+
+    await adapter.list();
+    expect(cloud.threads.list).toHaveBeenCalledTimes(2);
+
+    expect(await adapter.initialize("local-1")).toEqual({
+      remoteId: "remote-1",
+      externalId: undefined,
+    });
+
+    await adapter.rename("remote-1", "Renamed");
+    expect(cloud.threads.update).toHaveBeenCalledWith("remote-1", {
+      title: "Renamed",
+    });
+    await adapter.archive("remote-1");
+    expect(cloud.threads.update).toHaveBeenCalledWith("remote-1", {
+      is_archived: true,
+    });
+    await adapter.unarchive("remote-1");
+    expect(cloud.threads.update).toHaveBeenCalledWith("remote-1", {
+      is_archived: false,
+    });
+
+    const onDelete = vi.fn(async () => {});
+    options.delete = onDelete;
+    await adapter.delete("remote-1");
+    expect(onDelete).toHaveBeenCalledWith("remote-1");
+    expect(cloud.threads.delete).toHaveBeenCalledWith("remote-1");
+
+    expect(adapter.unstable_useAdapters).toBeTypeOf("function");
+    expect(adapter.unstable_Provider).toBeUndefined();
+  });
+
+  it("constructs stable history and attachment adapters when the hook runs", () => {
+    const cloud = makeCloud();
+    const adapter = createCloudThreadListAdapter({ cloud });
+    const { result, rerender } = renderHook(() =>
+      adapter.unstable_useAdapters!(),
+    );
+    const first = result.current!;
+    expect(first.history).toBeDefined();
+    expect((first.history as { withFormat?: unknown }).withFormat).toBeTypeOf(
+      "function",
+    );
+    expect(first.attachments).toBeDefined();
+
+    rerender();
+    expect(result.current!.history).toBe(first.history);
+    expect(result.current!.attachments).toBe(first.attachments);
+  });
+});

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/createCloudThreadListAdapterCreateFallback.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from "vitest";
+import { createCloudThreadListAdapterCreateFallback } from "./createCloudThreadListAdapterCreateFallback";
+
+describe("createCloudThreadListAdapterCreateFallback", () => {
+  it("prefers the custom create function", async () => {
+    const create = vi.fn().mockResolvedValue({ externalId: "custom" });
+    const initialize = vi.fn().mockResolvedValue({ externalId: "nested" });
+    const fallback = createCloudThreadListAdapterCreateFallback(create, {
+      source: {},
+      initialize,
+    });
+
+    await expect(fallback()).resolves.toEqual({ externalId: "custom" });
+    expect(initialize).not.toHaveBeenCalled();
+  });
+
+  it("initializes a sourced thread list item", async () => {
+    const result = { externalId: "nested" };
+    const fallback = createCloudThreadListAdapterCreateFallback(undefined, {
+      source: {},
+      initialize: vi.fn().mockResolvedValue(result),
+    });
+
+    await expect(fallback()).resolves.toBe(result);
+  });
+
+  it("falls back to an undefined external ID", async () => {
+    const initialize = vi.fn();
+    const fallback = createCloudThreadListAdapterCreateFallback(undefined, {
+      source: null,
+      initialize,
+    });
+
+    await expect(fallback()).resolves.toEqual({ externalId: undefined });
+    expect(initialize).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,18 @@
+type ThreadData = {
+  externalId: string | undefined;
+};
+
+type ThreadListItem = {
+  source: unknown;
+  initialize: () => Promise<ThreadData>;
+};
+
+export const createCloudThreadListAdapterCreateFallback = (
+  create: (() => Promise<ThreadData>) | undefined,
+  threadListItem: ThreadListItem,
+): (() => Promise<ThreadData>) =>
+  async function createThread() {
+    if (create) return create();
+    if (threadListItem.source) return threadListItem.initialize();
+    return { externalId: undefined };
+  };

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 = [