@assistant-ui/react 0.15.16 → 0.15.18

package/src/mcp-apps/app-frame.test.tsx

@@ -0,0 +1,349 @@
+// @vitest-environment jsdom
+import { act, startTransition, Suspense } from "react";
+import { cleanup, render } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type {
+  SandboxBridge,
+  SandboxHostProps,
+} from "../sandbox-host/SandboxHost";
+import type { CreateMcpAppBridgeOptions, McpAppBridge } from "./bridge";
+import { MCP_APP_MIME_TYPE, type McpAppHostContext } from "./types";
+
+const { sandboxHostMock, createMcpAppBridgeMock } = vi.hoisted(() => ({
+  sandboxHostMock: vi.fn(),
+  createMcpAppBridgeMock: vi.fn(),
+}));
+
+vi.mock("../sandbox-host/SandboxHost", () => ({
+  SandboxHost: sandboxHostMock,
+}));
+
+vi.mock("./bridge", async (importOriginal) => ({
+  ...(await importOriginal()),
+  createMcpAppBridge: createMcpAppBridgeMock,
+}));
+
+import { McpAppFrame } from "./app-frame";
+
+describe("McpAppFrame", () => {
+  afterEach(() => {
+    cleanup();
+    vi.clearAllMocks();
+  });
+
+  it("keeps bridge options scoped to committed renders", async () => {
+    let committedCreateBridge: SandboxHostProps["createBridge"] | null = null;
+    sandboxHostMock.mockImplementation((props: SandboxHostProps) => {
+      committedCreateBridge ??= props.createBridge;
+      return null;
+    });
+    const bridge: McpAppBridge = {
+      onMessage: vi.fn(),
+      dispose: vi.fn(),
+      notifyToolInput: vi.fn(),
+      notifyToolResult: vi.fn(),
+      notifyHostContextChanged: vi.fn(),
+    };
+    createMcpAppBridgeMock.mockReturnValue(bridge);
+    const callToolA = vi.fn();
+    const callToolB = vi.fn();
+    const interruptedRender = vi.fn();
+    const pending = new Promise<never>(() => {});
+    const Block = () => {
+      interruptedRender();
+      throw pending;
+    };
+    const view = (
+      workspace: string,
+      callTool: typeof callToolA,
+      blocked: boolean,
+    ) => (
+      <Suspense fallback={null}>
+        <McpAppFrame
+          app={{ resourceUri: "ui://example/widget" }}
+          resource={{
+            uri: "ui://example/widget",
+            mimeType: MCP_APP_MIME_TYPE,
+            html: "",
+          }}
+          handlers={{ callTool }}
+          hostContext={{ workspace }}
+        />
+        {blocked ? <Block /> : null}
+      </Suspense>
+    );
+    const rendered = render(view("workspace-a", callToolA, false));
+
+    act(() => {
+      startTransition(() =>
+        rendered.rerender(view("workspace-b", callToolB, true)),
+      );
+    });
+    expect(interruptedRender).toHaveBeenCalled();
+    expect(committedCreateBridge).not.toBeNull();
+
+    const sandboxBridge: SandboxBridge = committedCreateBridge!(
+      {
+        iframe: document.createElement("iframe"),
+        origin: "https://widget.example",
+        sendMessage: vi.fn(),
+      },
+      { setHeight: vi.fn() },
+    );
+    const options = createMcpAppBridgeMock.mock
+      .calls[0]![0] as CreateMcpAppBridgeOptions;
+    expect(options.hostContext).toEqual({ workspace: "workspace-a" });
+    await options.handlers?.callTool?.({ name: "search" });
+    expect(callToolA).toHaveBeenCalledOnce();
+    expect(callToolB).not.toHaveBeenCalled();
+
+    sandboxBridge.dispose();
+  });
+
+  it("only notifies the widget when host context actually changes", () => {
+    let createBridge: SandboxHostProps["createBridge"] | null = null;
+    sandboxHostMock.mockImplementation((props: SandboxHostProps) => {
+      createBridge ??= props.createBridge;
+      return null;
+    });
+    const bridge: McpAppBridge = {
+      onMessage: vi.fn(),
+      dispose: vi.fn(),
+      notifyToolInput: vi.fn(),
+      notifyToolResult: vi.fn(),
+      notifyHostContextChanged: vi.fn(),
+    };
+    createMcpAppBridgeMock.mockReturnValue(bridge);
+
+    const view = (hostContext: McpAppHostContext) => (
+      <McpAppFrame
+        app={{ resourceUri: "ui://example/widget" }}
+        resource={{
+          uri: "ui://example/widget",
+          mimeType: MCP_APP_MIME_TYPE,
+          html: "",
+        }}
+        hostContext={hostContext}
+      />
+    );
+    const rendered = render(
+      view({ displayMode: "inline", availableDisplayModes: ["inline", "pip"] }),
+    );
+
+    const sandboxBridge = createBridge!(
+      {
+        iframe: document.createElement("iframe"),
+        origin: "https://widget.example",
+        sendMessage: vi.fn(),
+      },
+      { setHeight: vi.fn() },
+    );
+    const options = createMcpAppBridgeMock.mock
+      .calls[0]![0] as CreateMcpAppBridgeOptions;
+    options.handlers?.onInitialized?.();
+
+    rendered.rerender(
+      view({ displayMode: "inline", availableDisplayModes: ["inline", "pip"] }),
+    );
+    expect(bridge.notifyHostContextChanged).not.toHaveBeenCalled();
+
+    rendered.rerender(
+      view({
+        displayMode: "fullscreen",
+        availableDisplayModes: ["inline", "pip"],
+      }),
+    );
+    expect(bridge.notifyHostContextChanged).toHaveBeenCalledTimes(1);
+    expect(bridge.notifyHostContextChanged).toHaveBeenCalledWith({
+      displayMode: "fullscreen",
+      availableDisplayModes: ["inline", "pip"],
+    });
+
+    sandboxBridge.dispose();
+  });
+  it("cancels a queued host context that returns to the delivered value", () => {
+    let createBridge: SandboxHostProps["createBridge"] | null = null;
+    sandboxHostMock.mockImplementation((props: SandboxHostProps) => {
+      createBridge ??= props.createBridge;
+      return null;
+    });
+    const bridge: McpAppBridge = {
+      onMessage: vi.fn(),
+      dispose: vi.fn(),
+      notifyToolInput: vi.fn(),
+      notifyToolResult: vi.fn(),
+      notifyHostContextChanged: vi.fn(),
+    };
+    createMcpAppBridgeMock.mockReturnValue(bridge);
+
+    const view = (hostContext: McpAppHostContext) => (
+      <McpAppFrame
+        app={{ resourceUri: "ui://example/widget" }}
+        resource={{
+          uri: "ui://example/widget",
+          mimeType: MCP_APP_MIME_TYPE,
+          html: "",
+        }}
+        hostContext={hostContext}
+      />
+    );
+    const rendered = render(view({ displayMode: "inline" }));
+
+    const sandboxBridge = createBridge!(
+      {
+        iframe: document.createElement("iframe"),
+        origin: "https://widget.example",
+        sendMessage: vi.fn(),
+      },
+      { setHeight: vi.fn() },
+    );
+
+    rendered.rerender(view({ displayMode: "fullscreen" }));
+    rendered.rerender(view({ displayMode: "inline" }));
+
+    const options = createMcpAppBridgeMock.mock
+      .calls[0]![0] as CreateMcpAppBridgeOptions;
+    options.handlers?.onInitialized?.();
+
+    expect(bridge.notifyHostContextChanged).not.toHaveBeenCalled();
+
+    sandboxBridge.dispose();
+  });
+
+  it("treats an equal host context as unchanged when it is not strict JSON", () => {
+    let createBridge: SandboxHostProps["createBridge"] | null = null;
+    sandboxHostMock.mockImplementation((props: SandboxHostProps) => {
+      createBridge ??= props.createBridge;
+      return null;
+    });
+    const bridge: McpAppBridge = {
+      onMessage: vi.fn(),
+      dispose: vi.fn(),
+      notifyToolInput: vi.fn(),
+      notifyToolResult: vi.fn(),
+      notifyHostContextChanged: vi.fn(),
+    };
+    createMcpAppBridgeMock.mockReturnValue(bridge);
+
+    const view = () => (
+      <McpAppFrame
+        app={{ resourceUri: "ui://example/widget" }}
+        resource={{
+          uri: "ui://example/widget",
+          mimeType: MCP_APP_MIME_TYPE,
+          html: "",
+        }}
+        hostContext={{ displayMode: "inline", workspace: undefined }}
+      />
+    );
+    const rendered = render(view());
+
+    const sandboxBridge = createBridge!(
+      {
+        iframe: document.createElement("iframe"),
+        origin: "https://widget.example",
+        sendMessage: vi.fn(),
+      },
+      { setHeight: vi.fn() },
+    );
+    const options = createMcpAppBridgeMock.mock
+      .calls[0]![0] as CreateMcpAppBridgeOptions;
+    options.handlers?.onInitialized?.();
+
+    rendered.rerender(view());
+    expect(bridge.notifyHostContextChanged).not.toHaveBeenCalled();
+
+    sandboxBridge.dispose();
+  });
+  it("notifies when a context value changes behind an unchanged key set", () => {
+    let createBridge: SandboxHostProps["createBridge"] | null = null;
+    sandboxHostMock.mockImplementation((props: SandboxHostProps) => {
+      createBridge ??= props.createBridge;
+      return null;
+    });
+    const bridge: McpAppBridge = {
+      onMessage: vi.fn(),
+      dispose: vi.fn(),
+      notifyToolInput: vi.fn(),
+      notifyToolResult: vi.fn(),
+      notifyHostContextChanged: vi.fn(),
+    };
+    createMcpAppBridgeMock.mockReturnValue(bridge);
+
+    const view = (updatedAt: Date) => (
+      <McpAppFrame
+        app={{ resourceUri: "ui://example/widget" }}
+        resource={{
+          uri: "ui://example/widget",
+          mimeType: MCP_APP_MIME_TYPE,
+          html: "",
+        }}
+        hostContext={{ updatedAt }}
+      />
+    );
+    const rendered = render(view(new Date(1)));
+
+    const sandboxBridge = createBridge!(
+      {
+        iframe: document.createElement("iframe"),
+        origin: "https://widget.example",
+        sendMessage: vi.fn(),
+      },
+      { setHeight: vi.fn() },
+    );
+    const options = createMcpAppBridgeMock.mock
+      .calls[0]![0] as CreateMcpAppBridgeOptions;
+    options.handlers?.onInitialized?.();
+
+    rendered.rerender(view(new Date(2)));
+    expect(bridge.notifyHostContextChanged).toHaveBeenCalledTimes(1);
+
+    sandboxBridge.dispose();
+  });
+
+  it("does not repeat the empty context the bridge already delivered", () => {
+    let createBridge: SandboxHostProps["createBridge"] | null = null;
+    sandboxHostMock.mockImplementation((props: SandboxHostProps) => {
+      createBridge ??= props.createBridge;
+      return null;
+    });
+    const bridge: McpAppBridge = {
+      onMessage: vi.fn(),
+      dispose: vi.fn(),
+      notifyToolInput: vi.fn(),
+      notifyToolResult: vi.fn(),
+      notifyHostContextChanged: vi.fn(),
+    };
+    createMcpAppBridgeMock.mockReturnValue(bridge);
+
+    const view = (hostContext?: McpAppHostContext) => (
+      <McpAppFrame
+        app={{ resourceUri: "ui://example/widget" }}
+        resource={{
+          uri: "ui://example/widget",
+          mimeType: MCP_APP_MIME_TYPE,
+          html: "",
+        }}
+        {...(hostContext === undefined ? {} : { hostContext })}
+      />
+    );
+    const rendered = render(view());
+
+    const sandboxBridge = createBridge!(
+      {
+        iframe: document.createElement("iframe"),
+        origin: "https://widget.example",
+        sendMessage: vi.fn(),
+      },
+      { setHeight: vi.fn() },
+    );
+    const options = createMcpAppBridgeMock.mock
+      .calls[0]![0] as CreateMcpAppBridgeOptions;
+    options.handlers?.onInitialized?.();
+
+    rendered.rerender(view({}));
+    expect(bridge.notifyHostContextChanged).not.toHaveBeenCalled();
+
+    sandboxBridge.dispose();
+  });
+});

package/src/mcp-apps/app-frame.tsx

@@ -1,6 +1,11 @@
 "use client";
 
-import { type MutableRefObject, useEffect, useRef } from "react";
+import {
+  type MutableRefObject,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+} from "react";
 import { type McpAppBridge, createMcpAppBridge } from "./bridge";
 import {
   SandboxHost,
@@ -13,11 +18,48 @@ import type {
   McpAppFrameProps,
   McpAppHostContext,
 } from "./types";
+import { isRecord } from "@assistant-ui/core/internal";
 
 const DEFAULT_PRODUCT = "assistant-ui-mcp-app";
 const INIT_TIMEOUT_MS = 5000;
 const DEFAULT_MAX_HEIGHT = 800;
 
+// Only a plain object can be compared by its own keys. Structured clone carries
+// a Date, Map, or class instance to the widget intact, and those expose no
+// enumerable keys, so walking them would report two different values as equal.
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (!isRecord(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === null || prototype === Object.prototype;
+};
+
+// Hosts commonly rebuild an equal context object on every render, and the
+// widget cannot tell a repeated notification apart from a real change. The
+// open index signature on McpAppHostContext admits values JSON rejects (an
+// undefined property value is enough), so leaves the walk cannot compare fall
+// back to identity rather than failing the whole comparison.
+const isSameHostContext = (a: unknown, b: unknown, depth = 0): boolean => {
+  if (Object.is(a, b)) return true;
+  if (depth > 100) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return (
+      Array.isArray(a) &&
+      Array.isArray(b) &&
+      a.length === b.length &&
+      a.every((item, index) => isSameHostContext(item, b[index], depth + 1))
+    );
+  }
+  if (!isPlainObject(a) || !isPlainObject(b)) return false;
+  const aKeys = Object.keys(a);
+  return (
+    aKeys.length === Object.keys(b).length &&
+    aKeys.every(
+      (key) =>
+        Object.hasOwn(b, key) && isSameHostContext(a[key], b[key], depth + 1),
+    )
+  );
+};
+
 function useBridgeNotify<T>(
   value: T | undefined,
   bridgeRef: MutableRefObject<McpAppBridge | null>,
@@ -25,18 +67,24 @@ function useBridgeNotify<T>(
   pendingRef: MutableRefObject<T | undefined>,
   lastSentRef: MutableRefObject<T | undefined>,
   notify: (bridge: McpAppBridge, v: T) => void,
+  isEqual: (sent: T | undefined, next: T) => boolean = Object.is,
 ) {
   useEffect(() => {
     if (!bridgeRef.current) return;
-    if (value === undefined) return;
-    if (lastSentRef.current === value) return;
+    // Nothing to deliver, either because there is no value or because the
+    // widget already holds it; a queued value here is superseded and would
+    // otherwise flush after initialization as a stale update.
+    if (value === undefined || isEqual(lastSentRef.current, value)) {
+      pendingRef.current = undefined;
+      return;
+    }
     if (!widgetReadyRef.current) {
       pendingRef.current = value;
       return;
     }
     notify(bridgeRef.current, value);
     lastSentRef.current = value;
-    // oxlint-disable-next-line react/exhaustive-deps -- refs are stable; notify is assumed stable; re-run only when value changes
+    // oxlint-disable-next-line react/exhaustive-deps -- refs are stable; notify and isEqual are assumed stable; re-run only when value changes
   }, [value]);
 }
 
@@ -121,14 +169,22 @@ export function McpAppFrame({
     undefined,
   );
 
-  const liveRef = useRef<LiveSnapshot>(null!);
-  liveRef.current = {
+  const liveRef = useRef<LiveSnapshot>({
     handlers,
     hostInfo,
     hostContext,
     input,
     output,
-  };
+  });
+  useLayoutEffect(() => {
+    liveRef.current = {
+      handlers,
+      hostInfo,
+      hostContext,
+      input,
+      output,
+    };
+  }, [handlers, hostInfo, hostContext, input, output]);
 
   const createBridge = (
     frame: SandboxHostFrame,
@@ -195,8 +251,10 @@ export function McpAppFrame({
 
     if (current.input !== undefined) pendingInputRef.current = current.input;
     if (current.output !== undefined) pendingOutputRef.current = current.output;
-    // hostContext is delivered inside the ui/initialize response; subsequent
-    // changes flow through useBridgeNotify's pending path.
+    // hostContext is delivered inside the ui/initialize response, where the
+    // bridge defaults it to {}; recording that same normalized value keeps the
+    // first later change from repeating what the widget already holds.
+    lastSentHostContextRef.current = current.hostContext ?? {};
 
     return {
       onMessage: bridge.onMessage,
@@ -241,6 +299,7 @@ export function McpAppFrame({
     pendingHostContextRef,
     lastSentHostContextRef,
     (b, v) => b.notifyHostContextChanged(v),
+    isSameHostContext,
   );
 
   return (

package/src/mcp-apps/bridge.ts

@@ -1,5 +1,5 @@
 import type { SandboxHostFrame } from "../sandbox-host/SandboxHost";
-import { invokeCallbackSafely } from "../utils/invokeCallbackSafely";
+import { invokeUserCallback } from "@assistant-ui/core/internal";
 import {
   MCP_APP_PROTOCOL_VERSION,
   type McpAppBridgeHandlers,
@@ -125,7 +125,12 @@ export function createMcpAppBridge(
   };
 
   const reportError = (error: Error) => {
-    invokeCallbackSafely(() => handlers.onError?.(error), "MCP App onError");
+    invokeUserCallback(
+      "assistant-ui",
+      "MCP App onError",
+      handlers.onError?.bind(handlers),
+      error,
+    );
   };
 
   const handleRequest = async (req: McpAppJsonRpcRequest) => {

package/src/mcp-apps/index.ts

@@ -1,4 +1,8 @@
-export { McpAppRenderer, type McpAppRendererOptions } from "./McpAppRenderer";
+export {
+  McpAppRenderer,
+  type McpAppPartOptions,
+  type McpAppRendererOptions,
+} from "./McpAppRenderer";
 export { McpAppsRemoteHost } from "./McpAppsRemoteHost";
 export { getMcpAppFromToolPart } from "./utils";
 export type {
@@ -13,5 +17,6 @@ export type {
   McpAppsHost,
   McpAppsRemoteHostOptions,
   McpAppToolCallParams,
+  McpAppBridgeHandlers,
   ToolCallMessagePartMcpMetadata,
 } from "./types";

package/src/model-context/frame/AssistantFrame.test.ts

@@ -27,7 +27,7 @@ describe("AssistantFrame Integration", () => {
             parentHandler({
               data,
               source: iframeWindow,
-              origin: "*",
+              origin: window.location.origin,
             } as MessageEvent);
           });
         }
@@ -44,7 +44,7 @@ describe("AssistantFrame Integration", () => {
             iframeHandler({
               data,
               source: parentWindow, // parent window is the source for subscription
-              origin: "*",
+              origin: window.location.origin,
             } as MessageEvent);
           });
         }
@@ -104,7 +104,7 @@ describe("AssistantFrame Integration", () => {
             type: "model-context-request",
           }),
         }),
-        "*",
+        window.location.origin,
       );
     });
 

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; providers share a fail-closed origin policy
+1. **Origin Validation**: Both sides default to the current page's origin and can specify an exact `targetOrigin` for cross-origin frames; 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/model-context/frame/useAssistantFrameHost.ts

@@ -20,7 +20,7 @@ type UseAssistantFrameHostOptions = {
  *
  *   useAssistantFrameHost({
  *     iframeRef,
- *     targetOrigin: "https://trusted-domain.com", // optional
+ *     targetOrigin: "https://trusted-domain.com",
  *   });
  *
  *   return <iframe ref={iframeRef} src="..." />;
@@ -29,7 +29,7 @@ type UseAssistantFrameHostOptions = {
  */
 export const useAssistantFrameHost = ({
   iframeRef,
-  targetOrigin = "*",
+  targetOrigin,
   register,
 }: UseAssistantFrameHostOptions): void => {
   useEffect(() => {

package/src/model-context/makeAssistantVisible.tsx

@@ -12,7 +12,7 @@ import {
   useContext,
 } from "react";
 import { useAui } from "@assistant-ui/store";
-import { useComposedRefs } from "@radix-ui/react-compose-refs";
+import { useComposedRefs } from "radix-ui/internal";
 import { tool } from "@assistant-ui/core";
 
 const click = tool({

package/src/primitives/actionBar/ActionBarCopy.tsx

@@ -2,7 +2,7 @@
 
 import { forwardRef } from "react";
 import type { ActionButtonProps } from "../../utils/createActionButton";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { Primitive } from "../../utils/Primitive";
 import { useActionBarCopy } from "@assistant-ui/core/react";
 import { useAuiState } from "@assistant-ui/store";

package/src/primitives/actionBar/ActionBarExportMarkdown.tsx

@@ -2,7 +2,7 @@
 
 import { forwardRef, useCallback } from "react";
 import type { ActionButtonProps } from "../../utils/createActionButton";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { Primitive } from "../../utils/Primitive";
 import { useAuiState, useAui } from "@assistant-ui/store";
 

package/src/primitives/actionBar/ActionBarFeedbackNegative.tsx

@@ -2,7 +2,7 @@
 
 import { forwardRef } from "react";
 import type { ActionButtonProps } from "../../utils/createActionButton";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { Primitive } from "../../utils/Primitive";
 import { useAuiState } from "@assistant-ui/store";
 import { useActionBarFeedbackNegative as useActionBarFeedbackNegativeBehavior } from "@assistant-ui/core/react";

package/src/primitives/actionBar/ActionBarFeedbackPositive.tsx

@@ -2,7 +2,7 @@
 
 import { forwardRef } from "react";
 import type { ActionButtonProps } from "../../utils/createActionButton";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { useAuiState } from "@assistant-ui/store";
 import { Primitive } from "../../utils/Primitive";
 import { useActionBarFeedbackPositive as useActionBarFeedbackPositiveBehavior } from "@assistant-ui/core/react";

package/src/primitives/actionBar/ActionBarStopSpeaking.tsx

@@ -3,7 +3,7 @@
 import { forwardRef } from "react";
 import type { ActionButtonProps } from "../../utils/createActionButton";
 import { Primitive } from "../../utils/Primitive";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { useActionBarStopSpeaking as useActionBarStopSpeakingBehavior } from "@assistant-ui/core/react";
 
 const useActionBarStopSpeaking = () => {

package/src/primitives/actionBarMore/scope.ts

@@ -1,8 +1,8 @@
 import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
-import type { Scope } from "@radix-ui/react-context";
+import type { Context } from "radix-ui/internal";
 
 export const useDropdownMenuScope: ReturnType<
   typeof DropdownMenuPrimitive.createDropdownMenuScope
 > = DropdownMenuPrimitive.createDropdownMenuScope();
 
-export type ScopedProps<P> = P & { __scopeActionBarMore?: Scope };
+export type ScopedProps<P> = P & { __scopeActionBarMore?: Context.Scope };

package/src/primitives/assistantModal/AssistantModalContent.tsx

@@ -6,7 +6,7 @@ import {
   forwardRef,
 } from "react";
 import { Popover as PopoverPrimitive } from "radix-ui";
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import type { WithRenderPropProps } from "../../utils/Primitive";
 import { PopoverRenderContent } from "./popoverRenderPrimitives";
 import { type ScopedProps, usePopoverScope } from "./scope";

package/src/primitives/assistantModal/scope.ts

@@ -1,7 +1,7 @@
 import { Popover as PopoverPrimitive } from "radix-ui";
-import type { Scope } from "@radix-ui/react-context";
+import type { Context } from "radix-ui/internal";
 
 export const usePopoverScope: ReturnType<
   typeof PopoverPrimitive.createPopoverScope
 > = PopoverPrimitive.createPopoverScope();
-export type ScopedProps<P> = P & { __scopeAssistantModal?: Scope };
+export type ScopedProps<P> = P & { __scopeAssistantModal?: Context.Scope };

package/src/primitives/composer/ComposerAttachmentDropzone.tsx

@@ -9,7 +9,7 @@ import {
   isValidElement,
 } from "react";
 
-import { composeEventHandlers } from "@radix-ui/primitive";
+import { composeEventHandlers } from "radix-ui/internal";
 import { Slot } from "radix-ui";
 import type React from "react";
 import { useAui } from "@assistant-ui/store";