@assistant-ui/core 0.3.14 → 0.3.16

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

@@ -44,6 +44,35 @@ 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 => {
@@ -105,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",
@@ -121,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,
         };
       },

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