@assistant-ui/core 0.3.9 → 0.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/core",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "Framework-agnostic core runtime for assistant-ui",
   "keywords": [
     "assistant",
@@ -59,8 +59,8 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "assistant-stream": "^0.3.35",
-    "nanoid": "^6.0.0"
+    "assistant-stream": "^0.3.37",
+    "nanoid": "^6.0.1"
   },
   "optionalDevDependencies": {
     "@assistant-ui/x-generative-compiler": ">=0.0.3"
@@ -89,17 +89,17 @@
   },
   "devDependencies": {
     "@testing-library/react": "^16.3.2",
-    "@types/react": "^19.2.17",
-    "jsdom": "^29.1.1",
+    "@types/react": "^19.2.18",
+    "jsdom": "^30.0.1",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "vitest": "^4.1.10",
     "zustand": "^5.0.14",
-    "@assistant-ui/tap": "0.9.10",
-    "@assistant-ui/vite": "0.0.11",
-    "@assistant-ui/store": "0.3.7",
-    "@assistant-ui/x-buildutils": "0.0.21",
-    "assistant-cloud": "0.1.38"
+    "@assistant-ui/store": "0.3.8",
+    "@assistant-ui/tap": "0.9.11",
+    "@assistant-ui/vite": "0.0.12",
+    "@assistant-ui/x-buildutils": "0.0.22",
+    "assistant-cloud": "0.1.39"
   },
   "publishConfig": {
     "access": "public",

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

@@ -0,0 +1,49 @@
+// @vitest-environment jsdom
+
+import { renderHook } from "@testing-library/react";
+import type { AssistantCloud } from "assistant-cloud";
+import { describe, expect, it, vi } from "vitest";
+import { useCloudThreadListAdapter } from "./useCloudThreadListAdapter";
+
+const makeThread = (id: string) => ({
+  id,
+  title: id,
+  is_archived: false,
+  external_id: null,
+  metadata: null,
+  last_message_at: new Date(0),
+  created_at: new Date(0),
+  updated_at: new Date(0),
+  project_id: "project-1",
+  workspace_id: "workspace-1",
+});
+
+describe("useCloudThreadListAdapter", () => {
+  it("exposes full Cloud pages through the remote thread cursor", async () => {
+    const firstPage = Array.from({ length: 20 }, (_, index) =>
+      makeThread(`thread-${index + 1}`),
+    );
+    const secondPage = [makeThread("thread-21")];
+    const list = vi
+      .fn()
+      .mockResolvedValueOnce({ threads: firstPage })
+      .mockResolvedValueOnce({ threads: secondPage });
+    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
+
+    const first = await result.current.list();
+    expect(list).toHaveBeenNthCalledWith(1, { limit: 20 });
+    expect(first.threads).toHaveLength(20);
+    expect(first.nextCursor).toBe("thread-20");
+
+    const second = await result.current.list({ after: first.nextCursor });
+    expect(list).toHaveBeenNthCalledWith(2, {
+      limit: 20,
+      after: "thread-20",
+    });
+    expect(second.threads.map((thread) => thread.remoteId)).toEqual([
+      "thread-21",
+    ]);
+    expect(second.nextCursor).toBeUndefined();
+  });
+});

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

@@ -37,6 +37,8 @@ const autoCloud = baseUrl
   ? new AssistantCloud({ baseUrl, anonymous: true })
   : undefined;
 
+const CLOUD_THREAD_PAGE_SIZE = 20;
+
 export const useCloudThreadListAdapter = (
   adapter: CloudThreadListAdapterOptions,
 ): RemoteThreadListAdapter => {
@@ -88,8 +90,11 @@ export const useCloudThreadListAdapter = (
     }
 
     return {
-      list: async () => {
-        const { threads } = await cloud.threads.list();
+      list: async ({ after } = {}) => {
+        const { threads } = await cloud.threads.list({
+          limit: CLOUD_THREAD_PAGE_SIZE,
+          ...(after ? { after } : {}),
+        });
         return {
           threads: threads.map((t) => ({
             status: t.is_archived ? "archived" : "regular",
@@ -101,6 +106,10 @@ export const useCloudThreadListAdapter = (
             externalId: t.external_id ?? undefined,
             custom: toCustom(t.metadata),
           })),
+          nextCursor:
+            threads.length === CLOUD_THREAD_PAGE_SIZE
+              ? threads.at(-1)?.id
+              : undefined,
         };
       },
 

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

@@ -343,4 +343,75 @@ describe("convertExternalMessages", () => {
       expect(result[0]!.role).toBe("user");
     });
   });
+
+  describe("invalid converter output", () => {
+    it("throws a descriptive error when the callback returns undefined", () => {
+      const messages = [{ id: "m1", type: "remove" }];
+      const callback = (() =>
+        undefined) as unknown as useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      >;
+
+      expect(() =>
+        convertExternalMessages(messages, callback, false, {}),
+      ).toThrowError(
+        /returned an invalid message \(undefined\) for input \{"id":"m1","type":"remove"\}/,
+      );
+    });
+
+    it("throws a descriptive error when the callback returns an array containing undefined", () => {
+      const messages = [{ id: "m1", role: "user" as const, content: "hi" }];
+      const callback = ((msg: (typeof messages)[number]) => [
+        msg,
+        undefined,
+      ]) as unknown as useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      >;
+
+      expect(() =>
+        convertExternalMessages(messages, callback, false, {}),
+      ).toThrowError(/returned an invalid message \(undefined\)/);
+    });
+
+    it("throws a descriptive error when the callback returns an unsupported role", () => {
+      const messages = [{ id: "m1", role: "user" as const, content: "hi" }];
+      const callback = (() => ({
+        role: "other",
+        content: "hi",
+      })) as unknown as useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      >;
+
+      expect(() =>
+        convertExternalMessages(messages, callback, false, {}),
+      ).toThrowError(/returned an invalid message \(\{"role":"other"/);
+    });
+
+    it("throws a descriptive error when the callback returns a message without content", () => {
+      const messages = [{ id: "m1", role: "user" as const, content: "hi" }];
+      const callback = (() => ({
+        role: "user",
+      })) as unknown as useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      >;
+
+      expect(() =>
+        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

@@ -100,6 +100,15 @@ describe("useExternalMessageConverter", () => {
     });
   });
 
+  it("throws the descriptive converter error when the callback returns an invalid message", () => {
+    const bad = (() =>
+      undefined) as unknown as useExternalMessageConverter.Callback<TestMessage>;
+
+    expect(() => renderConverter({ callback: bad })).toThrowError(
+      /External message converter: the converter callback returned an invalid message \(undefined\) for input \{"id":"u1"/,
+    );
+  });
+
   it.each([
     ["false", false],
     ["zero", 0],

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

@@ -76,6 +76,39 @@ type CallbackResult<T> = {
   outputs: useExternalMessageConverter.Message[];
 };
 
+const stringifyForError = (value: unknown) => {
+  let text;
+  try {
+    text = value instanceof Error ? String(value) : JSON.stringify(value);
+  } catch {
+    /* circular */
+  }
+  text ??= String(value);
+  return text.length > 200 ? `${text.slice(0, 200)}…` : text;
+};
+
+const toCallbackOutputs = (
+  output:
+    | useExternalMessageConverter.Message
+    | useExternalMessageConverter.Message[],
+  input: unknown,
+): useExternalMessageConverter.Message[] => {
+  const outputs = Array.isArray(output) ? output : [output];
+  for (const o of outputs) {
+    const valid =
+      typeof o === "object" &&
+      o !== null &&
+      (o.role === "tool" ||
+        ((o.role === "assistant" || o.role === "user" || o.role === "system") &&
+          (typeof o.content === "string" || Array.isArray(o.content))));
+    if (!valid)
+      throw new Error(
+        `External message converter: the converter callback returned an invalid message (${stringifyForError(o)}) for input ${stringifyForError(input)}. Return an empty array to skip a message.`,
+      );
+  }
+  return outputs;
+};
+
 type CallbackCacheEntry<T> = CallbackResult<T> & {
   metadata: useExternalMessageConverter.Metadata;
   callback: useExternalMessageConverter.Callback<T>;
@@ -354,7 +387,7 @@ export const convertExternalMessages = <T extends WeakKey>(
   const callbackResults: CallbackResult<T>[] = [];
   for (const message of messages) {
     const output = callback(message, metadata);
-    const outputs = Array.isArray(output) ? output : [output];
+    const outputs = toCallbackOutputs(output, message);
     const result = { input: message, outputs };
     callbackResults.push(result);
   }
@@ -444,7 +477,7 @@ export const useExternalMessageConverter = <T extends WeakKey>({
         result.callback !== state.callback
       ) {
         const output = state.callback(message, state.metadata);
-        const outputs = Array.isArray(output) ? output : [output];
+        const outputs = toCallbackOutputs(output, message);
         result = {
           input: message,
           outputs,

package/src/runtimes/local/local-thread-runtime-core.test.ts

@@ -1186,12 +1186,10 @@ describe("LocalThreadRuntimeCore runs", () => {
   };
 
   it("appends the user message and the adapter result", async () => {
-    const run = vi.fn(
-      async (): Promise<ChatModelRunResult> => ({
-        content: [{ type: "text", text: "Hello!" }],
-        status: { type: "complete", reason: "stop" },
-      }),
-    );
+    const run = vi.fn(async (): Promise<ChatModelRunResult> => ({
+      content: [{ type: "text", text: "Hello!" }],
+      status: { type: "complete", reason: "stop" },
+    }));
     const thread = createPlainThread({ run });
 
     await thread.append(userMessage("Hi"));
@@ -1247,23 +1245,21 @@ describe("LocalThreadRuntimeCore runs", () => {
   });
 
   it("does not run again after a tool result once maxSteps is reached", async () => {
-    const run = vi.fn(
-      async (): Promise<ChatModelRunResult> => ({
-        content: [
-          {
-            type: "tool-call",
-            toolCallId: "tc1",
-            toolName: "myTool",
-            args: {},
-            argsText: "{}",
-          },
-        ],
-        status: { type: "requires-action", reason: "tool-calls" },
-        metadata: {
-          steps: [{ usage: { promptTokens: 10, completionTokens: 5 } }],
+    const run = vi.fn(async (): Promise<ChatModelRunResult> => ({
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "tc1",
+          toolName: "myTool",
+          args: {},
+          argsText: "{}",
         },
-      }),
-    );
+      ],
+      status: { type: "requires-action", reason: "tool-calls" },
+      metadata: {
+        steps: [{ usage: { promptTokens: 10, completionTokens: 5 } }],
+      },
+    }));
     const thread = createPlainThread({ run }, { maxSteps: 1 });
 
     await thread.append(userMessage("Tool call"));