@assistant-ui/core 0.2.22 → 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.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}`,

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

@@ -3,6 +3,7 @@
 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";
@@ -11,11 +12,53 @@ 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

package/src/runtime/api/assistant-runtime.ts

@@ -31,7 +31,10 @@ export class AssistantRuntimeImpl implements AssistantRuntime {
 
   public readonly _thread: ThreadRuntime;
 
-  public constructor(private readonly _core: AssistantRuntimeCore) {
+  private readonly _core: AssistantRuntimeCore;
+
+  constructor(_core: AssistantRuntimeCore) {
+    this._core = _core;
     this.threads = new ThreadListRuntimeImpl(_core.threads);
     this._thread = this.threads.main;
 

package/src/runtime/api/attachment-runtime.ts

@@ -49,7 +49,10 @@ export abstract class AttachmentRuntimeImpl<
 
   public abstract get source(): Source;
 
-  constructor(private _core: AttachmentSnapshotBinding<Source>) {
+  private _core: AttachmentSnapshotBinding<Source>;
+
+  constructor(_core: AttachmentSnapshotBinding<Source>) {
+    this._core = _core;
     this.__internal_bindMethods();
   }
 
@@ -73,11 +76,14 @@ export abstract class AttachmentRuntimeImpl<
 abstract class ComposerAttachmentRuntime<
   Source extends "thread-composer" | "edit-composer",
 > extends AttachmentRuntimeImpl<Source> {
+  private _composerApi: ComposerRuntimeCoreBinding;
+
   constructor(
     core: AttachmentSnapshotBinding<Source>,
-    private _composerApi: ComposerRuntimeCoreBinding,
+    _composerApi: ComposerRuntimeCoreBinding,
   ) {
     super(core);
+    this._composerApi = _composerApi;
   }
 
   public remove() {

package/src/runtime/api/composer-runtime.ts

@@ -251,7 +251,11 @@ export abstract class ComposerRuntimeImpl implements ComposerRuntime {
 
   public abstract get type(): "edit" | "thread";
 
-  constructor(protected _core: ComposerRuntimeCoreBinding) {}
+  protected _core: ComposerRuntimeCoreBinding;
+
+  constructor(_core: ComposerRuntimeCoreBinding) {
+    this._core = _core;
+  }
 
   protected __internal_bindMethods() {
     this.setText = this.setText.bind(this);
@@ -483,10 +487,9 @@ export class EditComposerRuntimeImpl
   }
 
   private _getState;
-  constructor(
-    core: EditComposerRuntimeCoreBinding,
-    private _beginEdit: () => void,
-  ) {
+  private _beginEdit: () => void;
+
+  constructor(core: EditComposerRuntimeCoreBinding, _beginEdit: () => void) {
     const stateBinding = new LazyMemoizeSubject({
       path: core.path,
       getState: () => getEditComposerState(core.getState()),
@@ -498,6 +501,7 @@ export class EditComposerRuntimeImpl
       getState: () => core.getState(),
       subscribe: (callback) => stateBinding.subscribe(callback),
     });
+    this._beginEdit = _beginEdit;
 
     this._getState = stateBinding.getState.bind(stateBinding);