@assistant-ui/core 0.2.22 → 0.3.0

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/react/types/scopes/tools.ts

@@ -20,12 +20,6 @@ export type ToolsState = {
   /** Registered tool UIs (renderer + presentation options) keyed by tool name. */
   toolUIs: Record<string, readonly ToolRegistration[]>;
   mcpApp?: McpAppResourceOutput | undefined;
-  /**
-   * @deprecated Use {@link toolUIs} instead, whose entries carry the renderer
-   * alongside its presentation options. This component-only map is kept for
-   * back-compat and will be removed in v0.15.
-   */
-  tools: Record<string, ToolCallMessagePartComponent[]>;
 };
 
 export type ToolsMethods = {

package/src/react/utils/groupParts.ts

@@ -47,10 +47,8 @@ export const GROUPBY_MEMO_KEY: unique symbol = Symbol.for(
  *   `display: "standalone"`). Resolving the registry-driven cases reads the
  *   {@link GroupByContext} passed to the `groupBy` function. Takes precedence
  *   over the `"tool-call"` entry.
- * - `"mcp-app"` — **deprecated**, kept for back-compat. Matches only MCP-app
- *   tool calls. Prefer `"standalone-tool-call"`, which is a superset.
  */
-type GroupPartType = PartState["type"] | "standalone-tool-call" | "mcp-app";
+type GroupPartType = PartState["type"] | "standalone-tool-call";
 
 /**
  * Build a `groupBy` from a `part.type → group-key path` lookup.
@@ -93,10 +91,6 @@ export const groupPartByType = <TKey extends `group-${string}`>(
       if (isStandalone && lookup["standalone-tool-call"] !== undefined) {
         return lookup["standalone-tool-call"]!;
       }
-      // TODO(v0.15): drop the deprecated "mcp-app" key (superseded by "standalone-tool-call").
-      if (isMcpApp && lookup["mcp-app"] !== undefined) {
-        return lookup["mcp-app"]!;
-      }
     }
     return lookup[part.type] ?? [];
   }) as ((part: PartState, context?: GroupByContext) => readonly TKey[]) & {

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

package/src/runtime/api/message-part-runtime.ts

@@ -40,11 +40,18 @@ export class MessagePartRuntimeImpl implements MessagePartRuntime {
     return this.contentBinding.path;
   }
 
+  private contentBinding: MessagePartSnapshotBinding;
+  private messageApi: MessageStateBinding | undefined;
+  private threadApi: ThreadRuntimeCoreBinding | undefined;
+
   constructor(
-    private contentBinding: MessagePartSnapshotBinding,
-    private messageApi?: MessageStateBinding,
-    private threadApi?: ThreadRuntimeCoreBinding,
+    contentBinding: MessagePartSnapshotBinding,
+    messageApi?: MessageStateBinding,
+    threadApi?: ThreadRuntimeCoreBinding,
   ) {
+    this.contentBinding = contentBinding;
+    this.messageApi = messageApi;
+    this.threadApi = threadApi;
     this.__internal_bindMethods();
   }
 

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

@@ -134,10 +134,15 @@ export class MessageRuntimeImpl implements MessageRuntime {
     return this._core.path;
   }
 
+  private _core: MessageStateBinding;
+  private _threadBinding: ThreadRuntimeCoreBinding;
+
   constructor(
-    private _core: MessageStateBinding,
-    private _threadBinding: ThreadRuntimeCoreBinding,
+    _core: MessageStateBinding,
+    _threadBinding: ThreadRuntimeCoreBinding,
   ) {
+    this._core = _core;
+    this._threadBinding = _threadBinding;
     this.composer = new EditComposerRuntimeImpl(
       new NestedSubscriptionSubject({
         path: {

package/src/runtime/api/thread-list-item-runtime.ts

@@ -66,10 +66,15 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
     return this._core.path;
   }
 
+  private _core: ThreadListItemStateBinding;
+  private _threadListBinding: ThreadListRuntimeCoreBinding;
+
   constructor(
-    private _core: ThreadListItemStateBinding,
-    private _threadListBinding: ThreadListRuntimeCoreBinding,
+    _core: ThreadListItemStateBinding,
+    _threadListBinding: ThreadListRuntimeCoreBinding,
   ) {
+    this._core = _core;
+    this._threadListBinding = _threadListBinding;
     this.__internal_bindMethods();
   }
 

package/src/runtime/api/thread-list-runtime.ts

@@ -98,13 +98,21 @@ export type ThreadListRuntimeCoreBinding = ThreadListRuntimeCore;
 
 export class ThreadListRuntimeImpl implements ThreadListRuntime {
   private _getState;
+  private _core: ThreadListRuntimeCoreBinding;
+  private _runtimeFactory: new (
+    binding: ThreadRuntimeCoreBinding,
+    threadListItemBinding: ThreadListItemRuntimeBinding,
+  ) => ThreadRuntime;
+
   constructor(
-    private _core: ThreadListRuntimeCoreBinding,
-    private _runtimeFactory: new (
+    _core: ThreadListRuntimeCoreBinding,
+    _runtimeFactory: new (
       binding: ThreadRuntimeCoreBinding,
       threadListItemBinding: ThreadListItemRuntimeBinding,
     ) => ThreadRuntime = ThreadRuntimeImpl,
   ) {
+    this._core = _core;
+    this._runtimeFactory = _runtimeFactory;
     const stateBinding = new LazyMemoizeSubject({
       path: {},
       getState: () => getThreadListState(_core),

package/src/runtime/base/base-thread-runtime-core.ts

@@ -113,7 +113,11 @@ export abstract class BaseThreadRuntimeCore implements ThreadRuntimeCore {
 
   public readonly composer = new DefaultThreadComposerRuntimeCore(this);
 
-  constructor(private readonly _contextProvider: ModelContextProvider) {}
+  private readonly _contextProvider: ModelContextProvider;
+
+  constructor(_contextProvider: ModelContextProvider) {
+    this._contextProvider = _contextProvider;
+  }
 
   public getModelContext() {
     return this._contextProvider.getModelContext();

package/src/runtime/base/default-edit-composer-runtime-core.ts

@@ -31,8 +31,18 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
   private _nonTextPassthrough: readonly ThreadMessage["content"][number][];
   private _parentId: string | null;
   private _sourceId: string | null;
+  private runtime: ThreadRuntimeCore & {
+    adapters?:
+      | {
+          attachments?: AttachmentAdapter | undefined;
+          dictation?: DictationAdapter | undefined;
+        }
+      | undefined;
+  };
+  private endEditCallback: () => void;
+
   constructor(
-    private runtime: ThreadRuntimeCore & {
+    runtime: ThreadRuntimeCore & {
       adapters?:
         | {
             attachments?: AttachmentAdapter | undefined;
@@ -40,10 +50,12 @@ export class DefaultEditComposerRuntimeCore extends BaseComposerRuntimeCore {
           }
         | undefined;
     },
-    private endEditCallback: () => void,
+    endEditCallback: () => void,
     { parentId, message }: { parentId: string | null; message: ThreadMessage },
   ) {
     super();
+    this.runtime = runtime;
+    this.endEditCallback = endEditCallback;
     this._parentId = parentId;
     this._sourceId = message.id;
     this._previousText = getThreadMessageText(message);

package/src/runtime/base/default-thread-composer-runtime-core.ts

@@ -46,8 +46,17 @@ export class DefaultThreadComposerRuntimeCore
     return this.runtime.adapters?.dictation;
   }
 
+  private runtime: Omit<ThreadRuntimeCore, "composer"> & {
+    adapters?:
+      | {
+          attachments?: AttachmentAdapter | undefined;
+          dictation?: DictationAdapter | undefined;
+        }
+      | undefined;
+  };
+
   constructor(
-    private runtime: Omit<ThreadRuntimeCore, "composer"> & {
+    runtime: Omit<ThreadRuntimeCore, "composer"> & {
       adapters?:
         | {
             attachments?: AttachmentAdapter | undefined;
@@ -57,6 +66,7 @@ export class DefaultThreadComposerRuntimeCore
     },
   ) {
     super();
+    this.runtime = runtime;
     this.connect();
   }