@assistant-ui/core 0.3.16 → 0.3.18

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,
         ),
     );
 

package/src/react/runtimes/useExternalStoreRuntime.lifecycle.test.tsx

@@ -5,8 +5,49 @@ import { act, render } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
 import { useExternalStoreRuntime } from "./useExternalStoreRuntime";
 import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
+import type { ThreadMessage } from "../../types/message";
+import { RuntimeAdapterProvider } from "./RuntimeAdapterProvider";
+
+const userMessage: ThreadMessage = {
+  id: "user-1",
+  role: "user",
+  content: [{ type: "text", text: "hello" }],
+  attachments: [],
+  createdAt: new Date(0),
+  metadata: { custom: {} },
+};
 
 describe("useExternalStoreRuntime lifecycle", () => {
+  it("uses feedback supplied by the per-thread adapter context", () => {
+    const submit = vi.fn();
+    const capture: { runtime: AssistantRuntime | null } = { runtime: null };
+    const App = () => {
+      const runtime = useExternalStoreRuntime({
+        messages: [userMessage],
+        onNew: async () => {},
+      });
+      capture.runtime = runtime;
+      return null;
+    };
+
+    render(
+      <RuntimeAdapterProvider adapters={{ feedback: { submit } }}>
+        <App />
+      </RuntimeAdapterProvider>,
+    );
+
+    expect(capture.runtime!.thread.getState().capabilities.feedback).toBe(true);
+    act(() => {
+      capture
+        .runtime!.thread.getMessageById("user-1")
+        .submitFeedback({ type: "positive" });
+    });
+    expect(submit).toHaveBeenCalledWith({
+      message: expect.objectContaining({ id: "user-1" }),
+      type: "positive",
+    });
+  });
+
   it("keeps dispatching appends after StrictMode's simulated remount", async () => {
     const onNew = vi.fn(async () => {});
     const capture: { runtime: AssistantRuntime | null } = { runtime: null };

package/src/react/runtimes/useExternalStoreRuntime.ts

@@ -11,7 +11,15 @@ import { useRuntimeAdapters } from "./RuntimeAdapterProvider";
 export const useExternalStoreRuntime = <T>(
   store: ExternalStoreAdapter<T>,
 ): AssistantRuntime => {
-  const [runtime] = useState(() => new ExternalStoreRuntimeCore(store));
+  const { modelContext, feedback } = useRuntimeAdapters() ?? {};
+  const adaptedStore = useMemo(() => {
+    if (!feedback || store.adapters?.feedback) return store;
+    return {
+      ...store,
+      adapters: { ...store.adapters, feedback },
+    };
+  }, [feedback, store]);
+  const [runtime] = useState(() => new ExternalStoreRuntimeCore(adaptedStore));
 
   useEffect(() => {
     return () => {
@@ -20,11 +28,9 @@ export const useExternalStoreRuntime = <T>(
   }, [runtime]);
 
   useEffect(() => {
-    runtime.setAdapter(store);
+    runtime.setAdapter(adaptedStore);
   });
 
-  const { modelContext } = useRuntimeAdapters() ?? {};
-
   useEffect(() => {
     if (!modelContext) return undefined;
     return runtime.registerModelContextProvider(modelContext);

package/src/react/runtimes/useLocalRuntime.test.tsx

@@ -32,6 +32,26 @@ afterEach(() => {
 });
 
 describe("useLocalRuntime", () => {
+  it("enables feedback for Cloud threads", async () => {
+    const cloud = makeCloud();
+    let runtime: ReturnType<typeof useLocalRuntime> | null = null;
+    const App = () => {
+      runtime = useLocalRuntime(chatModel, { cloud });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <div />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    render(<App />);
+
+    await waitFor(() => {
+      expect(cloud.threads.list).toHaveBeenCalledTimes(2);
+      expect(runtime!.thread.getState().capabilities.feedback).toBe(true);
+    });
+  });
+
   it("surfaces the live thread after mount without user input", async () => {
     const auiRef: { current: ReturnType<typeof useAui> | null } = {
       current: null,

package/src/react/runtimes/useRemoteThreadListRuntime.concurrent.test.tsx

@@ -0,0 +1,216 @@
+// @vitest-environment jsdom
+
+import { act, render } from "@testing-library/react";
+import { startTransition, Suspense, type ReactNode } from "react";
+import { describe, expect, it, vi } from "vitest";
+import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
+import type { AppendMessage } from "../../types/message";
+import { makeAdapter } from "../../tests/remote-thread-list-test-helpers";
+import { AssistantRuntimeProvider } from "../AssistantRuntimeProvider";
+import { useExternalStoreRuntime } from "./useExternalStoreRuntime";
+import { useRemoteThreadListRuntime } from "./useRemoteThreadListRuntime";
+
+const EMPTY_MESSAGES: readonly never[] = [];
+
+const userMessage = (text: string): AppendMessage => ({
+  parentId: null,
+  sourceId: null,
+  runConfig: {},
+  role: "user",
+  content: [{ type: "text", text }],
+  attachments: [],
+  metadata: { custom: {} },
+  createdAt: new Date(),
+  startRun: true,
+});
+
+const getThreadCore = (runtime: AssistantRuntime) =>
+  (
+    runtime.thread as unknown as {
+      __internal_threadBinding: {
+        getState(): { append(message: AppendMessage): Promise<void> };
+      };
+    }
+  ).__internal_threadBinding.getState();
+
+const createHarness = ({ stableHook = false } = {}) => {
+  const adapter = makeAdapter();
+  const onNewA = vi.fn(async () => {});
+  const onNewB = vi.fn(async () => {});
+  const renderB = vi.fn();
+  const renderThreadRuntime = vi.fn();
+  const runtimeRef: { current: AssistantRuntime | null } = { current: null };
+  const pending = new Promise<never>(() => {});
+  let suspend = false;
+
+  const Blocker = () => {
+    if (suspend) throw pending;
+    return null;
+  };
+  // Every shipped adapter passes a fresh function expression, so a hoisted
+  // variant is the only way to exercise an unchanged published hook.
+  const useHoistedThreadRuntime = () => {
+    renderThreadRuntime();
+    return useExternalStoreRuntime({
+      messages: EMPTY_MESSAGES,
+      onNew: onNewA,
+    });
+  };
+  const App = ({
+    onNew,
+    children,
+  }: {
+    onNew: typeof onNewA;
+    children?: ReactNode;
+  }) => {
+    if (onNew === onNewB) renderB();
+    const useThreadRuntime = stableHook
+      ? useHoistedThreadRuntime
+      : () => {
+          renderThreadRuntime();
+          return useExternalStoreRuntime({ messages: EMPTY_MESSAGES, onNew });
+        };
+    const runtime = useRemoteThreadListRuntime({
+      adapter,
+      runtimeHook: useThreadRuntime,
+    });
+    runtimeRef.current = runtime;
+    return (
+      <AssistantRuntimeProvider runtime={runtime}>
+        {children ?? <Blocker />}
+      </AssistantRuntimeProvider>
+    );
+  };
+
+  return {
+    App,
+    onNewA,
+    onNewB,
+    renderB,
+    renderThreadRuntime,
+    runtimeRef,
+    suspend: () => {
+      suspend = true;
+    },
+  };
+};
+
+describe("useRemoteThreadListRuntime concurrent options", () => {
+  it("keeps new threads on the committed runtime hook", async () => {
+    const { App, onNewA, onNewB, renderB, runtimeRef, suspend } =
+      createHarness();
+    const view = render(
+      <Suspense fallback={null}>
+        <App onNew={onNewA} />
+      </Suspense>,
+    );
+
+    await act(async () => {
+      await getThreadCore(runtimeRef.current!).append(userMessage("first"));
+    });
+
+    act(() => {
+      suspend();
+      startTransition(() =>
+        view.rerender(
+          <Suspense fallback={null}>
+            <App onNew={onNewB} />
+          </Suspense>,
+        ),
+      );
+    });
+    expect(renderB).toHaveBeenCalled();
+
+    await act(async () => {
+      await runtimeRef.current!.threads.switchToNewThread();
+      await getThreadCore(runtimeRef.current!).append(userMessage("second"));
+    });
+
+    expect(onNewA).toHaveBeenCalledTimes(2);
+    expect(onNewB).not.toHaveBeenCalled();
+  });
+
+  it("publishes runtime hook changes after a committed render", async () => {
+    const { App, onNewA, onNewB, runtimeRef } = createHarness();
+    const view = render(<App onNew={onNewA} />);
+
+    await act(async () => {
+      await getThreadCore(runtimeRef.current!).append(userMessage("first"));
+    });
+
+    view.rerender(<App onNew={onNewB} />);
+    await act(async () => {
+      await getThreadCore(runtimeRef.current!).append(userMessage("second"));
+    });
+
+    expect(onNewA).toHaveBeenCalledTimes(1);
+    expect(onNewB).toHaveBeenCalledTimes(1);
+  });
+
+  it("costs two passes per provider commit in the documented shape", async () => {
+    // Fresh children on every render, as the AssistantRuntimeProvider JSDoc
+    // example does, so its memo does not block: the host renders once against
+    // the previously committed hook, then the publish adds the corrective pass.
+    const { App, onNewA, renderThreadRuntime } = createHarness();
+    const view = render(<App onNew={onNewA} />);
+
+    await act(async () => {});
+    renderThreadRuntime.mockClear();
+
+    await act(async () => {
+      view.rerender(<App onNew={onNewA} />);
+    });
+
+    expect(renderThreadRuntime).toHaveBeenCalledTimes(2);
+  });
+
+  it("costs one pass when the provider memo blocks the host render", async () => {
+    const { App, onNewA, renderThreadRuntime } = createHarness();
+    const children = <div />;
+    const view = render(<App onNew={onNewA}>{children}</App>);
+
+    await act(async () => {});
+    renderThreadRuntime.mockClear();
+
+    await act(async () => {
+      view.rerender(<App onNew={onNewA}>{children}</App>);
+    });
+
+    expect(renderThreadRuntime).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not re-run thread runtimes when the published hook is unchanged", async () => {
+    const { App, onNewA, renderThreadRuntime } = createHarness({
+      stableHook: true,
+    });
+    const children = <div />;
+    const view = render(<App onNew={onNewA}>{children}</App>);
+
+    await act(async () => {});
+    renderThreadRuntime.mockClear();
+
+    await act(async () => {
+      view.rerender(<App onNew={onNewA}>{children}</App>);
+    });
+
+    expect(renderThreadRuntime).not.toHaveBeenCalled();
+  });
+
+  it("gives a thread created after an options change the committed hook", async () => {
+    const { App, onNewA, onNewB, runtimeRef } = createHarness();
+    const view = render(<App onNew={onNewA} />);
+    await act(async () => {});
+
+    await act(async () => {
+      view.rerender(<App onNew={onNewB} />);
+    });
+
+    await act(async () => {
+      await runtimeRef.current!.threads.switchToNewThread();
+      await getThreadCore(runtimeRef.current!).append(userMessage("first"));
+    });
+
+    expect(onNewB).toHaveBeenCalledTimes(1);
+    expect(onNewA).not.toHaveBeenCalled();
+  });
+});