@assistant-ui/react 0.15.17 → 0.15.18

package/src/mcp-apps/McpAppRenderer.tsx

@@ -6,10 +6,13 @@ import {
   useMemo,
   useRef,
   useState,
-  type MutableRefObject,
   type ReactNode,
 } from "react";
-import type { McpAppMetadata } from "@assistant-ui/core";
+import type {
+  McpAppMetadata,
+  TextMessagePart,
+  ToolCallMessagePart,
+} from "@assistant-ui/core";
 import type {
   ToolCallMessagePartComponent,
   ToolCallMessagePartProps,
@@ -30,13 +33,11 @@ import type {
 import { getMcpAppFromToolPart } from "./utils";
 import { isRecord } from "@assistant-ui/core/internal";
 
-export type McpAppRendererOptions = {
-  /**
-   * Provides the data-plane operations the widget can request
-   * (`loadResource`, `callTool`, `readResource`, `listResources`). Use
-   * `McpAppsRemoteHost({ url })` for the default HTTP-route convention.
-   */
-  host: ResourceElement<McpAppsHost>;
+/**
+ * Options that apply to a single MCP app. `McpAppRenderer` takes them as
+ * thread-wide defaults, and its `forPart` resolver overrides them for one part.
+ */
+export type McpAppPartOptions = {
   /** Sandbox + container styling. Passes through to SafeContentFrame. */
   sandbox?: McpAppSandboxConfig;
   /**
@@ -51,6 +52,10 @@ export type McpAppRendererOptions = {
   /**
    * Optional widget interaction and lifecycle handlers. Data-plane handlers
    * (`callTool`, `readResource`, `listResources`) always use `host`.
+   *
+   * Which handlers a widget may call is captured when its frame mounts, so a
+   * `forPart` resolver returns the same handler keys for a part on every
+   * render even when the implementations change.
    */
   handlers?: Omit<
     McpAppBridgeHandlers,
@@ -64,6 +69,26 @@ export type McpAppRendererOptions = {
   errorFallback?: ReactNode | ((error: Error) => ReactNode);
 };
 
+export type McpAppRendererOptions = McpAppPartOptions & {
+  /**
+   * Provides the data-plane operations the widget can request
+   * (`loadResource`, `callTool`, `readResource`, `listResources`). Use
+   * `McpAppsRemoteHost({ url })` for the default HTTP-route convention.
+   */
+  host: ResourceElement<McpAppsHost>;
+  /**
+   * Resolves the options for one part. Each returned value replaces the
+   * thread-wide option of the same name, so a host can give every MCP app its
+   * own display mode and answer `requestDisplayMode` for the part that asked.
+   *
+   * `handlers` is the exception and merges per key. Its keys are capabilities
+   * negotiated with the widget rather than data, so replacing the whole bag to
+   * add one handler would withdraw the others from that part's widget with
+   * nothing to observe it by.
+   */
+  forPart?: (part: ToolCallMessagePart) => McpAppPartOptions;
+};
+
 type LoadedResourceState = {
   host: McpAppsHost;
   resourceUri: string;
@@ -72,7 +97,31 @@ type LoadedResourceState = {
   error?: Error;
 };
 
-type UseHostStore = UseBoundStore<StoreApi<{ host: McpAppsHost }>>;
+type RendererState = {
+  host: McpAppsHost;
+  options: McpAppRendererOptions;
+};
+
+type UseRendererStore = UseBoundStore<StoreApi<RendererState>>;
+
+// Callers pass options as an object literal, so the resource hands this a fresh
+// identity on every run; comparing the values keeps an unchanged run from
+// re-rendering every mounted part. `host` is excluded because it is an element
+// rebuilt on every run, and the store carries the resolved host separately.
+const isSameOptions = (
+  a: McpAppRendererOptions,
+  b: McpAppRendererOptions,
+): boolean => {
+  const aKeys = Object.keys(a).filter((key) => key !== "host");
+  const bKeys = Object.keys(b).filter((key) => key !== "host");
+  if (aKeys.length !== bKeys.length) return false;
+  const aValues = a as Record<string, unknown>;
+  const bValues = b as Record<string, unknown>;
+  return aKeys.every(
+    (key) =>
+      Object.hasOwn(bValues, key) && Object.is(aValues[key], bValues[key]),
+  );
+};
 
 function getInput(part: {
   status: { type: string };
@@ -92,27 +141,67 @@ const defaultOpenLink = ({ url }: { url: string }) => {
   window.open(url, "_blank", "noopener,noreferrer");
 };
 
-function extractSendMessageText(params: unknown): string | undefined {
-  if (typeof params === "string") return params;
+function extractSendMessageTexts(params: unknown): string[] | undefined {
+  if (typeof params === "string") return [params];
   if (!params || typeof params !== "object") return undefined;
   const obj = params as Record<string, unknown>;
-  if (typeof obj["prompt"] === "string") return obj["prompt"];
-  if (typeof obj["text"] === "string") return obj["text"];
-  if (typeof obj["message"] === "string") return obj["message"];
+  if (typeof obj["prompt"] === "string") return [obj["prompt"]];
+  if (typeof obj["text"] === "string") return [obj["text"]];
+  if (typeof obj["message"] === "string") return [obj["message"]];
+  if (Array.isArray(obj["content"])) {
+    return obj["content"]
+      .filter(
+        (block): block is { type: "text"; text: string } =>
+          isRecord(block) &&
+          block["type"] === "text" &&
+          typeof block["text"] === "string",
+      )
+      .map((block) => block.text);
+  }
   return undefined;
 }
 
+function extractSendMessageContent(
+  params: unknown,
+): { content: TextMessagePart[] } | { reason: string } {
+  const texts = extractSendMessageTexts(params);
+  if (!texts) return { reason: "unrecognised params shape" };
+  const content = texts
+    .filter((text) => text !== "")
+    .map((text): TextMessagePart => ({ type: "text", text }));
+  if (content.length === 0) {
+    return { reason: "no text content to append" };
+  }
+  return { content };
+}
+
+function resolvePartOptions(
+  options: McpAppRendererOptions,
+  part: ToolCallMessagePartProps,
+): McpAppRendererOptions {
+  const overrides = options.forPart?.(part);
+  if (!overrides) return options;
+  const handlers =
+    options.handlers && overrides.handlers
+      ? { ...options.handlers, ...overrides.handlers }
+      : (overrides.handlers ?? options.handlers);
+  return {
+    ...options,
+    ...overrides,
+    ...(handlers === undefined ? {} : { handlers }),
+  };
+}
+
 function InlineRenderer({
   part,
-  useHostStore,
-  optionsRef,
+  useRendererStore,
 }: {
   part: ToolCallMessagePartProps;
-  useHostStore: UseHostStore;
-  optionsRef: MutableRefObject<McpAppRendererOptions>;
+  useRendererStore: UseRendererStore;
 }) {
-  const opts = optionsRef.current;
   const aui = useAui();
+  const rendererOptions = useRendererStore((state) => state.options);
+  const opts = resolvePartOptions(rendererOptions, part);
   const app = getMcpAppFromToolPart(part);
   const cachedAppRef = useRef<McpAppMetadata | undefined>(undefined);
   useLayoutEffect(() => {
@@ -122,7 +211,7 @@ function InlineRenderer({
 
   const [loadedResource, setLoadedResource] = useState<LoadedResourceState>();
 
-  const host = useHostStore((state) => state.host);
+  const host = useRendererStore((state) => state.host);
   const resourceUri = appForRender?.resourceUri;
   const serverId = appForRender?.serverId;
   const callerHandlers = opts.handlers;
@@ -133,12 +222,16 @@ function InlineRenderer({
     const targetUri = resourceUri;
     const targetServerId = serverId;
 
-    targetHost
-      .loadResource({
-        uri: targetUri,
-        ...(targetServerId ? { serverId: targetServerId } : {}),
-      })
-      .then((res) => {
+    // Host changes are published later in this passive flush. Defer until that
+    // publication lands, then verify this effect still owns the current host.
+    const loadResource = async () => {
+      await Promise.resolve();
+      if (cancelled || useRendererStore.getState().host !== targetHost) return;
+      try {
+        const res = await targetHost.loadResource({
+          uri: targetUri,
+          ...(targetServerId ? { serverId: targetServerId } : {}),
+        });
         if (!cancelled)
           setLoadedResource({
             host: targetHost,
@@ -148,8 +241,7 @@ function InlineRenderer({
               : {}),
             resource: res,
           });
-      })
-      .catch((error: unknown) => {
+      } catch (error: unknown) {
         if (!cancelled) {
           setLoadedResource({
             host: targetHost,
@@ -160,12 +252,14 @@ function InlineRenderer({
             error: error instanceof Error ? error : new Error(String(error)),
           });
         }
-      });
+      }
+    };
+    void loadResource();
 
     return () => {
       cancelled = true;
     };
-  }, [host, resourceUri, serverId]);
+  }, [host, resourceUri, serverId, useRendererStore]);
 
   const bridgeHandlers = useMemo<McpAppBridgeHandlers>(
     () => ({
@@ -174,32 +268,34 @@ function InlineRenderer({
       sendMessage:
         callerHandlers?.sendMessage ??
         ((params) => {
-          const text = extractSendMessageText(params);
-          if (!text) return { ok: false, reason: "unrecognised params shape" };
-          aui.thread.append({ content: [{ type: "text", text }] });
+          const result = extractSendMessageContent(params);
+          if ("reason" in result) {
+            return { isError: true, ok: false, reason: result.reason };
+          }
+          aui.thread.append({ content: result.content });
           return { ok: true };
         }),
       callTool: (params) =>
-        useHostStore.getState().host.callTool({
+        useRendererStore.getState().host.callTool({
           ...params,
           ...(serverId ? { serverId } : {}),
         }),
       readResource: (params) =>
-        useHostStore.getState().host.readResource({
+        useRendererStore.getState().host.readResource({
           ...params,
           ...(serverId ? { serverId } : {}),
         }),
       listResources: (params) => {
         if (!serverId) {
-          return useHostStore.getState().host.listResources(params);
+          return useRendererStore.getState().host.listResources(params);
         }
-        return useHostStore.getState().host.listResources({
+        return useRendererStore.getState().host.listResources({
           ...(isRecord(params) ? params : {}),
           serverId,
         });
       },
     }),
-    [aui, callerHandlers, serverId, useHostStore],
+    [aui, callerHandlers, serverId, useRendererStore],
   );
 
   const loadedResourceForApp =
@@ -253,27 +349,26 @@ const useMcpAppRenderer = (
 ): { readonly render: ToolCallMessagePartComponent } => {
   const host = useResource(options.host);
 
-  const optionsRef = useRef<McpAppRendererOptions>(options);
-  optionsRef.current = options;
-
-  const [useHostStore] = useState(() =>
-    create<{ host: McpAppsHost }>(() => ({ host })),
+  // The rendered component identity has to stay stable, or every part remounts
+  // its frame; options reach the parts through the store instead of props.
+  const [useRendererStore] = useState(() =>
+    create<RendererState>(() => ({ host, options })),
   );
   useEffect(() => {
-    useHostStore.setState({ host });
-  }, [host, useHostStore]);
+    useRendererStore.setState((prev) =>
+      prev.host === host && isSameOptions(prev.options, options)
+        ? prev
+        : { host, options },
+    );
+  }, [host, options, useRendererStore]);
 
   const render = useMemo((): ToolCallMessagePartComponent => {
     const Render: ToolCallMessagePartComponent = (props) => (
-      <InlineRenderer
-        part={props}
-        useHostStore={useHostStore}
-        optionsRef={optionsRef}
-      />
+      <InlineRenderer part={props} useRendererStore={useRendererStore} />
     );
     Render.displayName = "McpAppRenderer";
     return Render;
-  }, [useHostStore]);
+  }, [useRendererStore]);
 
   return { render };
 };

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

@@ -7,7 +7,7 @@ import type {
   SandboxHostProps,
 } from "../sandbox-host/SandboxHost";
 import type { CreateMcpAppBridgeOptions, McpAppBridge } from "./bridge";
-import { MCP_APP_MIME_TYPE } from "./types";
+import { MCP_APP_MIME_TYPE, type McpAppHostContext } from "./types";
 
 const { sandboxHostMock, createMcpAppBridgeMock } = vi.hoisted(() => ({
   sandboxHostMock: vi.fn(),
@@ -99,4 +99,251 @@ describe("McpAppFrame", () => {
 
     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

@@ -18,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>,
@@ -30,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]);
 }
 
@@ -208,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,
@@ -254,6 +299,7 @@ export function McpAppFrame({
     pendingHostContextRef,
     lastSentHostContextRef,
     (b, v) => b.notifyHostContextChanged(v),
+    isSameHostContext,
   );
 
   return (