@assistant-ui/react 0.15.14 → 0.15.16

package/src/mcp-apps/bridge.test.ts

@@ -124,6 +124,53 @@ describe("createMcpAppBridge", () => {
     bridge.dispose();
   });
 
+  it.each([
+    [
+      "throws",
+      () => {
+        throw new Error("error callback failed");
+      },
+    ],
+    ["rejects", () => Promise.reject(new Error("error callback failed"))],
+  ])(
+    "returns an error response when onError %s",
+    async (_behavior, onErrorCallback) => {
+      const { frame, captured } = makeFrame();
+      const callTool = vi.fn().mockRejectedValue(new Error("tool failed"));
+      const consoleError = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      const onError = vi.fn(onErrorCallback);
+      const bridge = createMcpAppBridge({
+        frame,
+        handlers: { callTool, onError },
+      });
+
+      deliver(bridge, {
+        jsonrpc: "2.0",
+        id: 8,
+        method: "tools/call",
+        params: { name: "search" },
+      });
+      await flush();
+
+      expect(onError).toHaveBeenCalledWith(new Error("tool failed"));
+      expect(captured).toEqual([
+        {
+          jsonrpc: "2.0",
+          id: 8,
+          error: { code: -32603, message: "tool failed" },
+        },
+      ]);
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] MCP App onError callback threw an error",
+        new Error("error callback failed"),
+      );
+      consoleError.mockRestore();
+      bridge.dispose();
+    },
+  );
+
   it("rejects tools/call for disallowed tool with -32602", async () => {
     const { frame, captured } = makeFrame();
     const callTool = vi.fn();
@@ -244,6 +291,60 @@ describe("createMcpAppBridge", () => {
     bridge.dispose();
   });
 
+  it("isolates throwing notification handlers and reports their errors", () => {
+    const { frame, captured } = makeFrame();
+    const initializedError = new Error("initialized callback failed");
+    const sizeChangeError = new Error("size change callback failed");
+    const teardownError = new Error("teardown callback failed");
+    const onError = vi.fn();
+    const bridge = createMcpAppBridge({
+      frame,
+      handlers: {
+        onInitialized: () => {
+          throw initializedError;
+        },
+        onSizeChange: () => {
+          throw sizeChangeError;
+        },
+        onLog: () => {
+          throw "log callback failed";
+        },
+        onRequestTeardown: () => {
+          throw teardownError;
+        },
+        onError,
+      },
+    });
+
+    expect(() => {
+      deliver(bridge, {
+        jsonrpc: "2.0",
+        method: "notifications/initialized",
+      });
+      deliver(bridge, {
+        jsonrpc: "2.0",
+        method: "notifications/size_changed",
+      });
+      deliver(bridge, {
+        jsonrpc: "2.0",
+        method: "notifications/log",
+      });
+      deliver(bridge, {
+        jsonrpc: "2.0",
+        method: "notifications/request_teardown",
+      });
+    }).not.toThrow();
+
+    expect(onError.mock.calls.map(([error]) => error)).toEqual([
+      initializedError,
+      sizeChangeError,
+      new Error("log callback failed"),
+      teardownError,
+    ]);
+    expect(captured).toEqual([]);
+    bridge.dispose();
+  });
+
   it("notifyToolInput / notifyToolResult / notifyHostContextChanged post both legacy and 2026-01-26 notifications", () => {
     const { frame, captured } = makeFrame();
     const bridge = createMcpAppBridge({ frame });
@@ -428,4 +529,56 @@ describe("createMcpAppBridge", () => {
     expect(onRequestTeardown).toHaveBeenCalledWith({ reason: "done" });
     bridge.dispose();
   });
+
+  it("isolates a throwing onError from widget error notifications", () => {
+    const { frame } = makeFrame();
+    const callbackError = new Error("error callback failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    const onError = vi.fn(() => {
+      throw callbackError;
+    });
+    const bridge = createMcpAppBridge({
+      frame,
+      handlers: { callTool: vi.fn(), onError },
+    });
+
+    expect(() =>
+      deliver(bridge, {
+        jsonrpc: "2.0",
+        method: "notifications/error",
+        params: { message: "kaboom" },
+      }),
+    ).not.toThrow();
+
+    expect(onError).toHaveBeenCalledWith(new Error("kaboom"));
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] MCP App onError callback threw an error",
+      callbackError,
+    );
+    consoleError.mockRestore();
+    bridge.dispose();
+  });
+
+  it("preserves the onError receiver", () => {
+    const { frame } = makeFrame();
+    const handlers = {
+      calls: 0,
+      onError() {
+        expect(this).toBe(handlers);
+        this.calls += 1;
+      },
+    };
+    const bridge = createMcpAppBridge({ frame, handlers });
+
+    deliver(bridge, {
+      jsonrpc: "2.0",
+      method: "notifications/error",
+      params: { message: "kaboom" },
+    });
+
+    expect(handlers.calls).toBe(1);
+    bridge.dispose();
+  });
 });

package/src/mcp-apps/bridge.ts

@@ -1,4 +1,5 @@
 import type { SandboxHostFrame } from "../sandbox-host/SandboxHost";
+import { invokeCallbackSafely } from "../utils/invokeCallbackSafely";
 import {
   MCP_APP_PROTOCOL_VERSION,
   type McpAppBridgeHandlers,
@@ -123,6 +124,10 @@ export function createMcpAppBridge(
     });
   };
 
+  const reportError = (error: Error) => {
+    invokeCallbackSafely(() => handlers.onError?.(error), "MCP App onError");
+  };
+
   const handleRequest = async (req: McpAppJsonRpcRequest) => {
     try {
       const params = req.params;
@@ -376,42 +381,49 @@ export function createMcpAppBridge(
       }
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err));
-      handlers.onError?.(error);
+      reportError(error);
       errorResponse(req.id, JSONRPC_ERROR.internalError, error.message);
     }
   };
 
   const handleNotification = (note: McpAppJsonRpcNotification) => {
-    switch (normalizeMethod(note.method)) {
-      case "notifications/initialized": {
-        handlers.onInitialized?.();
-        return;
-      }
-      case "notifications/size_changed": {
-        const p = (note.params ?? {}) as { width?: number; height?: number };
-        handlers.onSizeChange?.({
-          ...(typeof p.width === "number" ? { width: p.width } : {}),
-          ...(typeof p.height === "number" ? { height: p.height } : {}),
-        });
-        return;
-      }
-      case "notifications/log": {
-        handlers.onLog?.(note.params);
-        return;
-      }
-      case "notifications/request_teardown": {
-        handlers.onRequestTeardown?.(note.params);
-        return;
-      }
-      case "notifications/error": {
-        const p = (note.params ?? {}) as { message?: string };
-        handlers.onError?.(
-          new Error(typeof p.message === "string" ? p.message : "Widget error"),
-        );
-        return;
+    try {
+      switch (normalizeMethod(note.method)) {
+        case "notifications/initialized": {
+          handlers.onInitialized?.();
+          return;
+        }
+        case "notifications/size_changed": {
+          const p = (note.params ?? {}) as { width?: number; height?: number };
+          handlers.onSizeChange?.({
+            ...(typeof p.width === "number" ? { width: p.width } : {}),
+            ...(typeof p.height === "number" ? { height: p.height } : {}),
+          });
+          return;
+        }
+        case "notifications/log": {
+          handlers.onLog?.(note.params);
+          return;
+        }
+        case "notifications/request_teardown": {
+          handlers.onRequestTeardown?.(note.params);
+          return;
+        }
+        case "notifications/error": {
+          const p = (note.params ?? {}) as { message?: string };
+          reportError(
+            new Error(
+              typeof p.message === "string" ? p.message : "Widget error",
+            ),
+          );
+          return;
+        }
+        default:
+          return;
       }
-      default:
-        return;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      reportError(error);
     }
   };
 

package/src/model-context/frame/SPEC_AssistantFrame.md

@@ -88,7 +88,7 @@ All messages are wrapped with a channel identifier to avoid conflicts with other
 
 #### Security Considerations
 
-1. **Origin Validation**: Both sides can specify `targetOrigin` to restrict message sources
+1. **Origin Validation**: Both sides can specify `targetOrigin` to restrict message sources; providers share a fail-closed origin policy
 2. **Window Reference**: Host (parent) only accepts messages from the specific iframe window it's connected to
 3. **Message Channel**: Using a unique channel identifier prevents cross-talk with other postMessage users
 

package/src/primitives/actionBar/ActionBarExportMarkdown.test.tsx

@@ -0,0 +1,67 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import type * as AssistantStore from "@assistant-ui/store";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { ActionBarPrimitiveExportMarkdown } from "./ActionBarExportMarkdown";
+
+const { getCopyText } = vi.hoisted(() => ({
+  getCopyText: vi.fn(() => "# Exported message"),
+}));
+
+(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
+
+vi.mock("@assistant-ui/store", async (importOriginal) => {
+  const actual = await importOriginal<typeof AssistantStore>();
+  return {
+    ...actual,
+    useAui: () => ({ message: { getCopyText } }),
+    useAuiState: () => true,
+  };
+});
+
+describe("ActionBarPrimitiveExportMarkdown", () => {
+  let container: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    getCopyText.mockClear();
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(async () => {
+    await act(async () => {
+      root.unmount();
+    });
+    container.remove();
+    vi.restoreAllMocks();
+  });
+
+  it("handles rejected asynchronous exports", async () => {
+    const error = new Error("remote save failed");
+    const onExport = vi.fn().mockRejectedValue(error);
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    await act(async () => {
+      root.render(
+        <ActionBarPrimitiveExportMarkdown onExport={onExport}>
+          Export
+        </ActionBarPrimitiveExportMarkdown>,
+      );
+    });
+
+    await act(async () => {
+      container.querySelector("button")!.click();
+    });
+
+    expect(onExport).toHaveBeenCalledWith("# Exported message");
+    expect(errorSpy).toHaveBeenCalledWith(
+      "[assistant-ui] markdown export failed:",
+      error,
+    );
+  });
+});

package/src/primitives/actionBar/ActionBarExportMarkdown.tsx

@@ -61,7 +61,9 @@ export const ActionBarPrimitiveExportMarkdown = forwardRef<
       ref={forwardedRef}
       disabled={disabled || !callback}
       onClick={composeEventHandlers(onClick, () => {
-        callback?.();
+        void callback?.().catch((error: unknown) => {
+          console.error("[assistant-ui] markdown export failed:", error);
+        });
       })}
     />
   );

package/src/primitives/actionBar/ActionBarStopSpeaking.tsx

@@ -2,7 +2,6 @@
 
 import { forwardRef } from "react";
 import type { ActionButtonProps } from "../../utils/createActionButton";
-import { useEscapeKeydown } from "@radix-ui/react-use-escape-keydown";
 import { Primitive } from "../../utils/Primitive";
 import { composeEventHandlers } from "@radix-ui/primitive";
 import { useActionBarStopSpeaking as useActionBarStopSpeakingBehavior } from "@assistant-ui/core/react";
@@ -24,14 +23,6 @@ export const ActionBarPrimitiveStopSpeaking = forwardRef<
 >((props, ref) => {
   const callback = useActionBarStopSpeaking();
 
-  // TODO this stops working if the user is not hovering over an older message
-  useEscapeKeydown((e) => {
-    if (callback) {
-      e.preventDefault();
-      callback();
-    }
-  });
-
   return (
     <Primitive.button
       type="button"

package/src/primitives/branchPicker/BranchPickerRoot.tsx

@@ -6,7 +6,7 @@ import {
   forwardRef,
   type ComponentPropsWithoutRef,
 } from "react";
-import { MessagePrimitiveIf as If } from "../message/MessageIf";
+import { AuiIf } from "@assistant-ui/store";
 
 export namespace BranchPickerPrimitiveRoot {
   export type Element = ComponentRef<typeof Primitive.div>;
@@ -42,9 +42,11 @@ export const BranchPickerPrimitiveRoot = forwardRef<
   BranchPickerPrimitiveRoot.Props
 >(({ hideWhenSingleBranch, ...rest }, ref) => {
   return (
-    <If hasBranches={hideWhenSingleBranch ? true : undefined}>
+    <AuiIf
+      condition={(s) => !hideWhenSingleBranch || s.message.branchCount >= 2}
+    >
       <Primitive.div {...rest} ref={ref} />
-    </If>
+    </AuiIf>
   );
 });
 

package/src/primitives/composer/ComposerDictationTranscript.tsx

@@ -21,11 +21,11 @@ export namespace ComposerPrimitiveDictationTranscript {
  *
  * @example
  * ```tsx
- * <ComposerPrimitive.If dictation>
+ * <AuiIf condition={(s) => s.composer.dictation != null}>
  *   <div className="dictation-preview">
  *     <ComposerPrimitive.DictationTranscript />
  *   </div>
- * </ComposerPrimitive.If>
+ * </AuiIf>
  * ```
  */
 export const ComposerPrimitiveDictationTranscript = forwardRef<

package/src/primitives/composer/ComposerInput.tsx

@@ -346,7 +346,7 @@ export const ComposerPrimitiveInput = forwardRef<
       )
         return undefined;
 
-      return aui.on("threadListItem.switchedTo", focus);
+      return aui.on("threads.selectionChanged", focus);
     }, [unstable_focusOnThreadSwitched, focus, aui]);
 
     useEffect(() => {

package/src/primitives/composer/trigger/triggerSelectionResource.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it, vi } from "vitest";
+import { createTapRoot, flushTapSync, useResource } from "@assistant-ui/tap";
+import type {
+  Unstable_DirectiveFormatter,
+  Unstable_TriggerItem,
+} from "@assistant-ui/core";
+import type { AssistantClient } from "@assistant-ui/store";
+import { TriggerDetectionResource } from "./triggerDetectionResource";
+import {
+  TriggerSelectionResource,
+  type TriggerBehavior,
+} from "./triggerSelectionResource";
+
+const item: Unstable_TriggerItem = {
+  id: "file",
+  type: "file",
+  label: "file.txt",
+};
+
+const formatter: Unstable_DirectiveFormatter = {
+  serialize: () => "@file.txt",
+  parse: () => [],
+};
+
+const makeAui = (textRef: { value: string }) => {
+  const setText = vi.fn((value: string) => {
+    textRef.value = value;
+  });
+
+  return {
+    aui: {
+      composer: {
+        getState: () => ({ text: textRef.value }),
+        setText,
+      },
+    } as unknown as AssistantClient,
+    setText,
+  };
+};
+
+const render = ({
+  behavior,
+  text,
+  trigger,
+}: {
+  behavior: TriggerBehavior;
+  text: string;
+  trigger: { offset: number; query: string };
+}) => {
+  const textRef = { value: text };
+  const { aui, setText } = makeAui(textRef);
+  const setCursorPosition = vi.fn();
+  const onSelected = vi.fn();
+  const root = createTapRoot(function Root() {
+    return useResource(
+      TriggerSelectionResource({
+        behavior,
+        trigger,
+        aui,
+        triggerChar: "@",
+        setCursorPosition,
+        onSelected,
+      }),
+    );
+  });
+
+  return { root, setText, setCursorPosition, onSelected };
+};
+
+describe("TriggerSelectionResource", () => {
+  it("resynchronizes the cursor after inserting a directive", () => {
+    const { root, setText, setCursorPosition, onSelected } = render({
+      behavior: { kind: "directive", formatter },
+      text: "@file tail",
+      trigger: { offset: 0, query: "file" },
+    });
+
+    root.getValue().selectItem(item);
+
+    expect(setText).toHaveBeenCalledWith("@file.txt tail");
+    expect(setCursorPosition).toHaveBeenCalledWith("@file.txt".length + 1);
+    expect(onSelected).toHaveBeenCalledOnce();
+  });
+
+  it("resynchronizes the cursor after removing an action", () => {
+    const { root, setText, setCursorPosition } = render({
+      behavior: {
+        kind: "action",
+        formatter,
+        onExecute: vi.fn(),
+        removeOnExecute: true,
+      },
+      text: "before @file tail",
+      trigger: { offset: 7, query: "file" },
+    });
+
+    root.getValue().selectItem(item);
+
+    expect(setText).toHaveBeenCalledWith("before tail");
+    expect(setCursorPosition).toHaveBeenCalledWith(7);
+  });
+
+  it("does not rewrite composer text on a second select after insertion", () => {
+    const textRef = { value: "@fil" };
+    const { aui, setText } = makeAui(textRef);
+    const onSelected = vi.fn();
+    const root = createTapRoot(function Root() {
+      const detection = useResource(
+        TriggerDetectionResource({
+          text: textRef.value,
+          triggerChar: "@",
+        }),
+      );
+      return useResource(
+        TriggerSelectionResource({
+          behavior: { kind: "directive", formatter },
+          trigger: detection.trigger,
+          aui,
+          triggerChar: "@",
+          setCursorPosition: detection.setCursorPosition,
+          onSelected,
+        }),
+      );
+    });
+
+    flushTapSync(() => {
+      root.getValue().selectItem(item);
+    });
+    root.getValue().selectItem(item);
+
+    expect(setText).toHaveBeenCalledOnce();
+    expect(setText).toHaveBeenCalledWith("@file.txt ");
+    expect(textRef.value).toBe("@file.txt ");
+  });
+});

package/src/primitives/composer/trigger/triggerSelectionResource.ts

@@ -83,6 +83,7 @@ const useTriggerSelectionResource = ({
       aui.composer.setText(
         before + directive + (after.startsWith(" ") ? after : ` ${after}`),
       );
+      setCursorPosition(before.length + directive.length + 1);
     };
 
     if (behavior.kind === "directive") {
@@ -93,6 +94,7 @@ const useTriggerSelectionResource = ({
         aui.composer.setText(
           before + (after.startsWith(" ") ? after.slice(1) : after),
         );
+        setCursorPosition(before.length);
       } else {
         // Leave directive chip in the composer as an audit trail
         insertDirective();