@assistant-ui/core 0.2.21 → 0.2.23

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

@@ -76,94 +76,96 @@ export const useCloudThreadListAdapter = (
   );
 
   const cloud = adapter.cloud ?? autoCloud;
-  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;
-  }
-
-  return {
-    list: async () => {
-      const { threads } = await cloud.threads.list();
-      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),
-        })),
+  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 };
       };
-    },
-
-    initialize: async () => {
-      const createTask = adapter.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 adapter.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),
-      };
-    },
+      return inMemory;
+    }
+
+    return {
+      list: async () => {
+        const { threads } = await cloud.threads.list();
+        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),
+          })),
+        };
+      },
+
+      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,
-  };
+      unstable_Provider,
+    };
+  }, [cloud, unstable_Provider]);
 };

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

@@ -0,0 +1,346 @@
+import { describe, it, expect } from "vitest";
+import { convertExternalMessages } from "./external-message-converter";
+import type { useExternalMessageConverter } from "./external-message-converter";
+import { isErrorMessageId } from "../../utils/id";
+
+describe("convertExternalMessages", () => {
+  describe("reasoning part merging", () => {
+    it("should merge reasoning parts with the same parentId", () => {
+      const messages = [
+        {
+          id: "msg1",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "reasoning" as const,
+              text: "First reasoning",
+              parentId: "parent1",
+            },
+          ],
+        },
+        {
+          id: "msg2",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "reasoning" as const,
+              text: "Second reasoning",
+              parentId: "parent1",
+            },
+          ],
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+      expect(result[0]!.role).toBe("assistant");
+
+      const reasoningParts = result[0]!.content.filter(
+        (p) => p.type === "reasoning",
+      );
+      expect(reasoningParts).toHaveLength(1);
+      expect((reasoningParts[0] as any).text).toBe(
+        "First reasoning\n\nSecond reasoning",
+      );
+      expect((reasoningParts[0] as any).parentId).toBe("parent1");
+    });
+
+    it("should keep reasoning parts without parentId separate", () => {
+      const messages = [
+        {
+          id: "msg1",
+          role: "assistant" as const,
+          content: [{ type: "reasoning" as const, text: "First reasoning" }],
+        },
+        {
+          id: "msg2",
+          role: "assistant" as const,
+          content: [{ type: "reasoning" as const, text: "Second reasoning" }],
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+
+      const reasoningParts = result[0]!.content.filter(
+        (p) => p.type === "reasoning",
+      );
+      expect(reasoningParts).toHaveLength(2);
+      expect((reasoningParts[0] as any).text).toBe("First reasoning");
+      expect((reasoningParts[1] as any).text).toBe("Second reasoning");
+    });
+
+    it("should keep reasoning parts with different parentIds separate", () => {
+      const messages = [
+        {
+          id: "msg1",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "reasoning" as const,
+              text: "Reasoning for parent1",
+              parentId: "parent1",
+            },
+          ],
+        },
+        {
+          id: "msg2",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "reasoning" as const,
+              text: "Reasoning for parent2",
+              parentId: "parent2",
+            },
+          ],
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+
+      const reasoningParts = result[0]!.content.filter(
+        (p) => p.type === "reasoning",
+      );
+      expect(reasoningParts).toHaveLength(2);
+      expect((reasoningParts[0] as any).parentId).toBe("parent1");
+      expect((reasoningParts[1] as any).parentId).toBe("parent2");
+    });
+
+    it("should still merge tool results with matching tool calls", () => {
+      const messages = [
+        {
+          id: "msg1",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "tool-call" as const,
+              toolCallId: "tc1",
+              toolName: "search",
+              args: { query: "test" },
+              argsText: '{"query":"test"}',
+            },
+          ],
+        },
+        {
+          role: "tool" as const,
+          toolCallId: "tc1",
+          result: { data: "result" },
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+
+      const toolCallParts = result[0]!.content.filter(
+        (p) => p.type === "tool-call",
+      );
+      expect(toolCallParts).toHaveLength(1);
+      expect((toolCallParts[0] as any).result).toEqual({ data: "result" });
+    });
+
+    it("should merge duplicate tool calls by toolCallId across assistant messages", () => {
+      const messages = [
+        {
+          id: "msg1",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "tool-call" as const,
+              toolCallId: "tc1",
+              toolName: "search",
+              args: { query: "old" },
+              argsText: '{"query":"old"',
+            },
+          ],
+        },
+        {
+          id: "msg2",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "tool-call" as const,
+              toolCallId: "tc1",
+              toolName: "search",
+              args: { query: "new" },
+              argsText: '{"query":"new"}',
+            },
+          ],
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+      expect(result[0]!.role).toBe("assistant");
+      const toolCallParts = result[0]!.content.filter(
+        (p) => p.type === "tool-call",
+      );
+      expect(toolCallParts).toHaveLength(1);
+      expect((toolCallParts[0] as any).args).toEqual({ query: "new" });
+      expect((toolCallParts[0] as any).argsText).toBe('{"query":"new"}');
+    });
+
+    it("should ignore orphaned tool results without throwing", () => {
+      const messages = [
+        {
+          id: "msg1",
+          role: "assistant" as const,
+          content: "First response",
+        },
+        {
+          role: "tool" as const,
+          toolCallId: "missing-tool-call",
+          toolName: "search",
+          result: { data: "orphan result" },
+        },
+        {
+          id: "msg2",
+          role: "assistant" as const,
+          content: "Second response",
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+      expect(result).toHaveLength(1);
+      expect(result[0]!.role).toBe("assistant");
+
+      const textParts = result[0]!.content.filter((p) => p.type === "text");
+      expect(textParts).toHaveLength(2);
+      expect((textParts[0] as any).text).toBe("First response");
+      expect((textParts[1] as any).text).toBe("Second response");
+    });
+  });
+
+  describe("synthetic error message", () => {
+    it("should create synthetic error message when error exists and no messages", () => {
+      const messages: never[] = [];
+      const callback: useExternalMessageConverter.Callback<never> = (msg) =>
+        msg;
+
+      const result = convertExternalMessages(messages, callback, false, {
+        error: "API key is missing",
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0]!.role).toBe("assistant");
+      expect(result[0]!.content).toHaveLength(0);
+      expect(result[0]!.status).toEqual({
+        type: "incomplete",
+        reason: "error",
+        error: "API key is missing",
+      });
+      expect(isErrorMessageId(result[0]!.id)).toBe(true);
+    });
+
+    it("should create synthetic error message when error exists and last message is user", () => {
+      const messages = [
+        {
+          id: "user1",
+          role: "user" as const,
+          content: "Hello",
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {
+        error: { message: "Invalid API key" },
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result[0]!.role).toBe("user");
+      expect(result[1]!.role).toBe("assistant");
+      expect(result[1]!.content).toHaveLength(0);
+      expect(result[1]!.status).toEqual({
+        type: "incomplete",
+        reason: "error",
+        error: { message: "Invalid API key" },
+      });
+      expect(isErrorMessageId(result[1]!.id)).toBe(true);
+    });
+
+    it("should not create synthetic error message when last message is assistant", () => {
+      const messages = [
+        {
+          id: "user1",
+          role: "user" as const,
+          content: "Hello",
+        },
+        {
+          id: "assistant1",
+          role: "assistant" as const,
+          content: "Hi there",
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {
+        error: "Connection error",
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result[0]!.role).toBe("user");
+      expect(result[1]!.role).toBe("assistant");
+      expect(result[1]!.id).toBe("assistant1");
+      expect(result[1]!.status).toMatchObject({
+        type: "incomplete",
+        reason: "error",
+        error: "Connection error",
+      });
+      expect(isErrorMessageId(result[1]!.id)).toBe(false);
+    });
+
+    it("should not create synthetic message when no error", () => {
+      const messages = [
+        {
+          id: "user1",
+          role: "user" as const,
+          content: "Hello",
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+      expect(result[0]!.role).toBe("user");
+    });
+  });
+});

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

@@ -99,4 +99,25 @@ describe("useExternalMessageConverter", () => {
       text: "HELLO",
     });
   });
+
+  it.each([
+    ["false", false],
+    ["zero", 0],
+    ["an empty string", ""],
+  ])("preserves %s assistant state", (_label, state) => {
+    const callback: useExternalMessageConverter.Callback<TestMessage> = (
+      message,
+    ) => ({
+      role: message.role,
+      id: message.id,
+      content: [{ type: "text", text: message.text }],
+      ...(message.role === "assistant"
+        ? { metadata: { unstable_state: state } }
+        : undefined),
+    });
+
+    const { result } = renderConverter({ callback });
+
+    expect(result.current[1]?.metadata.unstable_state).toBe(state);
+  });
 });

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

@@ -118,7 +118,7 @@ const joinExternalMessages = (
         const toolCall = assistantMessage.content[
           toolCallIdx
         ]! as ToolCallMessagePart;
-        if (output.toolName !== undefined) {
+        if (output.toolName != null) {
           if (toolCall.toolName !== output.toolName)
             throw new Error(
               `Tool call name ${output.toolCallId} ${output.toolName} does not match existing tool call ${toolCall.toolName}`,
@@ -170,7 +170,7 @@ const joinExternalMessages = (
 
             if (output.metadata) {
               assistantMessage.metadata ??= {};
-              if (output.metadata.unstable_state) {
+              if (output.metadata.unstable_state !== undefined) {
                 assistantMessage.metadata.unstable_state =
                   output.metadata.unstable_state;
               }

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

@@ -0,0 +1,99 @@
+// @vitest-environment jsdom
+
+import { render, waitFor } from "@testing-library/react";
+import { StrictMode } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { AssistantCloud } from "assistant-cloud";
+import type { ChatModelAdapter } from "../../runtime/utils/chat-model-adapter";
+import { AssistantRuntimeProvider } from "../AssistantRuntimeProvider";
+import { useLocalRuntime } from "./useLocalRuntime";
+
+const chatModel: ChatModelAdapter = {
+  run: async () => ({ content: [] }),
+};
+
+const makeCloud = () =>
+  ({
+    threads: {
+      list: vi.fn().mockResolvedValue({ threads: [] }),
+    },
+  }) as unknown as AssistantCloud;
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("useLocalRuntime", () => {
+  it("keeps the Cloud thread list loaded across unrelated rerenders", async () => {
+    const firstCloud = makeCloud();
+    const secondCloud = makeCloud();
+
+    const App = ({
+      cloud,
+      label,
+    }: {
+      cloud: AssistantCloud;
+      label: string;
+    }) => {
+      const runtime = useLocalRuntime(chatModel, { cloud });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <div>{label}</div>
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    const { rerender } = render(<App cloud={firstCloud} label="first" />);
+
+    await waitFor(() => {
+      expect(firstCloud.threads.list).toHaveBeenCalledOnce();
+    });
+
+    rerender(<App cloud={firstCloud} label="second" />);
+    expect(firstCloud.threads.list).toHaveBeenCalledOnce();
+
+    rerender(<App cloud={secondCloud} label="third" />);
+    await waitFor(() => {
+      expect(secondCloud.threads.list).toHaveBeenCalledOnce();
+    });
+    expect(firstCloud.threads.list).toHaveBeenCalledOnce();
+  });
+
+  it("handles rejected history loads", async () => {
+    const error = new Error("history unavailable");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const history = {
+      load: vi.fn().mockRejectedValue(error),
+      append: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const App = () => {
+      const runtime = useLocalRuntime(chatModel, { adapters: { history } });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <div />
+        </AssistantRuntimeProvider>
+      );
+    };
+
+    const renderApp = () => (
+      <StrictMode>
+        <App />
+      </StrictMode>
+    );
+    const { rerender } = render(renderApp());
+
+    await waitFor(() => {
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] local thread history load failed:",
+        error,
+      );
+    });
+
+    rerender(renderApp());
+    expect(history.load).toHaveBeenCalledTimes(1);
+    expect(consoleError).toHaveBeenCalledTimes(1);
+  });
+});