@assistant-ui/core 0.3.15 → 0.3.17

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

@@ -542,19 +542,5 @@ describe("convertExternalMessages", () => {
         convertExternalMessages(messages, callback, false, {}),
       ).toThrowError(/returned an invalid message \(\{"role":"user"\}\)/);
     });
-
-    it("tolerates a tool message without toolCallId as an orphaned tool result", () => {
-      const messages = [{ id: "m1", role: "user" as const, content: "hi" }];
-      const callback = ((msg: (typeof messages)[number]) => [
-        msg,
-        { role: "tool", result: "ok" },
-      ]) as unknown as useExternalMessageConverter.Callback<
-        (typeof messages)[number]
-      >;
-
-      const result = convertExternalMessages(messages, callback, false, {});
-      expect(result[0]!.role).toBe("user");
-      expect(result[1]!.content).toHaveLength(0);
-    });
   });
 });

package/src/react/runtimes/external-message-converter.test.tsx

@@ -54,6 +54,83 @@ const renderConverter = (initialProps: Props = {}) =>
   );
 
 describe("useExternalMessageConverter", () => {
+  it("refreshes positional fallback ids when an id-less message is prepended", () => {
+    const idlessConvert: useExternalMessageConverter.Callback<TestMessage> = (
+      message,
+    ) => ({
+      role: message.role,
+      content: [{ type: "text", text: message.text }],
+    });
+
+    const older: TestMessage = { id: "u0", role: "user", text: "older" };
+    const newer: TestMessage = { id: "u1", role: "user", text: "newer" };
+
+    const { result, rerender } = renderHook(
+      ({ messages }: { messages: TestMessage[] }) =>
+        useExternalMessageConverter<TestMessage>({
+          callback: idlessConvert,
+          messages,
+          isRunning: false,
+          metadata: EMPTY,
+        }),
+      { initialProps: { messages: [newer] } },
+    );
+
+    rerender({ messages: [older, newer] });
+
+    const ids = result.current.map((message) => message.id);
+    expect(ids).toEqual([
+      "__external_store_fallback_0",
+      "__external_store_fallback_1",
+    ]);
+    expect(
+      result.current.map((message) => (message.content[0] as any).text),
+    ).toEqual(["older", "newer"]);
+  });
+
+  it("never rewrites a caller-supplied id that matches the generated shape", () => {
+    const explicitConvert: useExternalMessageConverter.Callback<TestMessage> = (
+      message,
+    ) => ({
+      role: message.role,
+      id: message.id === "explicit" ? "__external_store_fallback_0" : undefined,
+      content: [{ type: "text", text: message.text }],
+    });
+
+    const explicit: TestMessage = {
+      id: "explicit",
+      role: "user",
+      text: "kept",
+    };
+    const older: TestMessage = { id: "u0", role: "user", text: "older" };
+
+    const { result, rerender } = renderHook(
+      ({ messages }: { messages: TestMessage[] }) =>
+        useExternalMessageConverter<TestMessage>({
+          callback: explicitConvert,
+          messages,
+          isRunning: false,
+          metadata: EMPTY,
+        }),
+      { initialProps: { messages: [explicit] } },
+    );
+
+    rerender({ messages: [older, explicit] });
+
+    // The caller-supplied id survives untouched — at the cost of colliding
+    // with the id minted for the prepended message, since the caller chose an
+    // id inside the reserved fallback namespace. The full list makes that
+    // trade-off explicit.
+    expect(result.current.map((message) => message.id)).toEqual([
+      "__external_store_fallback_0",
+      "__external_store_fallback_0",
+    ]);
+    const explicitOut = result.current.find(
+      (message) => (message.content[0] as any).text === "kept",
+    );
+    expect(explicitOut?.id).toBe("__external_store_fallback_0");
+  });
+
   it("reuses converted messages across rerenders when inputs are unchanged", () => {
     const { result, rerender } = renderConverter();