@mcp-use/client 2.0.0-beta.13 → 2.0.0-beta.15

package/dist/react/index.js

@@ -1534,7 +1534,7 @@ var HttpConnector = class extends BaseConnector {
 };
 
 // src/utils/version.ts
-var VERSION = "2.0.0-beta.13";
+var VERSION = "2.0.0-beta.15";
 function getPackageVersion() {
   return VERSION;
 }
@@ -2068,7 +2068,7 @@ var OAuthSessionStore = class _OAuthSessionStore {
    */
   async storeAuthorizationState(authorizationUrl, opts = {}) {
     const state = globalThis.crypto.randomUUID();
-    const stateKey = `${this.storageKeyPrefix}:state_${state}`;
+    const stateKey = `${this.storageKeyPrefix}_${this.serverUrlHash}_state_${state}`;
     const stateData = {
       serverUrlHash: this.serverUrlHash,
       expiry: Date.now() + 1e3 * 60 * 10,
@@ -2140,6 +2140,7 @@ var BrowserOAuthClientProvider = class {
   connectionUrl;
   proxyOAuthRequests;
   lastAttemptedAuthUrl = null;
+  authorizationPending = false;
   onPopupWindow;
   constructor(serverUrl, options = {}) {
     if (options.staticClientInfo?.client_secret) {
@@ -2190,6 +2191,12 @@ var BrowserOAuthClientProvider = class {
   getKey(keySuffix) {
     return this.session.getKey(keySuffix);
   }
+  get hasPendingFlow() {
+    return this.authorizationPending;
+  }
+  markFlowComplete() {
+    this.authorizationPending = false;
+  }
   /**
    * Re-anchor an SDK-derived OAuth discovery URL from the MCP connection
    * (proxy) origin onto the actual MCP server.
@@ -2370,6 +2377,7 @@ var BrowserOAuthClientProvider = class {
   }
   saveTokens(tokens, ctx) {
     this.lastAttemptedAuthUrl = null;
+    this.authorizationPending = false;
     return this.session.saveTokens(tokens, ctx);
   }
   async clientInformation(ctx) {
@@ -2450,6 +2458,7 @@ var BrowserOAuthClientProvider = class {
       }
     );
     this.lastAttemptedAuthUrl = prepared;
+    this.authorizationPending = true;
     return prepared;
   }
   /**
@@ -2506,15 +2515,13 @@ var BrowserOAuthClientProvider = class {
   }
   clearStorage() {
     this.lastAttemptedAuthUrl = null;
+    this.authorizationPending = false;
     const prefixPattern = `${this.storageKeyPrefix}_${this.serverUrlHash}_`;
-    const statePattern = `${this.storageKeyPrefix}:state_`;
     const keysToRemove = [];
     let count = 0;
     for (const key of this.storage.keys()) {
       if (key.startsWith(prefixPattern)) {
         keysToRemove.push(key);
-      } else if (key.startsWith(statePattern)) {
-        keysToRemove.push(key);
       }
     }
     const uniqueKeysToRemove = [...new Set(keysToRemove)];
@@ -2550,16 +2557,13 @@ var MCPAgentExecutionEvent = class extends BaseTelemetryEvent {
     return {
       // Core execution info
       execution_method: this.data.executionMethod,
-      query: this.data.query,
       query_length: this.data.query.length,
       success: this.data.success,
       // Agent configuration
       model_provider: this.data.modelProvider,
       model_name: this.data.modelName,
       server_count: this.data.serverCount,
-      server_identifiers: this.data.serverIdentifiers,
       total_tools_available: this.data.totalToolsAvailable,
-      tools_available_names: this.data.toolsAvailableNames,
       max_steps_configured: this.data.maxStepsConfigured,
       memory_enabled: this.data.memoryEnabled,
       use_server_manager: this.data.useServerManager,
@@ -2570,8 +2574,6 @@ var MCPAgentExecutionEvent = class extends BaseTelemetryEvent {
       // Execution results (always include, even if null)
       steps_taken: this.data.stepsTaken ?? null,
       tools_used_count: this.data.toolsUsedCount ?? null,
-      tools_used_names: this.data.toolsUsedNames ?? null,
-      response: this.data.response ?? null,
       response_length: this.data.response ? this.data.response.length : null,
       execution_time_ms: this.data.executionTimeMs ?? null,
       error_type: this.data.errorType ?? null,
@@ -2667,21 +2669,72 @@ async function telFetch(url, init) {
 }
 var POSTHOG_HOST = "https://eu.i.posthog.com";
 var POSTHOG_API_KEY = "phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI";
-function capturePostHog(params) {
-  const host = params.host ?? POSTHOG_HOST;
-  const apiKey = params.apiKey ?? POSTHOG_API_KEY;
-  return telFetch(`${host}/i/v0/e/`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    keepalive: true,
-    body: JSON.stringify({
+var CONTENT_PROPERTY = /(^|_)(arguments?|args|body|command|headers?|location|message|query|response|secret|subject|token|uri|url|user_agent)(_|$)/i;
+var IDENTIFYING_PROPERTY = /(^|_)(server_identifiers?|server_names?|servers|tool_names?|tools_(available|used)_names)(_|$)/i;
+var AGGREGATE_PROPERTY = /(_count|_length|_duration(?:_ms)?|_time_ms|(^|_)num_[a-z0-9_]+)$/i;
+function normalizePropertyKey(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-z0-9_$]+/gi, "_").toLowerCase();
+}
+function sanitizeValue(value, seen) {
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      throw new TypeError("Cyclic telemetry properties are not supported");
+    }
+    seen.add(value);
+    const sanitized = value.map((item) => sanitizeValue(item, seen));
+    seen.delete(value);
+    return sanitized;
+  }
+  if (value !== null && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) {
+    if (seen.has(value)) {
+      throw new TypeError("Cyclic telemetry properties are not supported");
+    }
+    seen.add(value);
+    const sanitized = sanitizeProperties(
+      value,
+      seen
+    );
+    seen.delete(value);
+    return sanitized;
+  }
+  return value;
+}
+function sanitizeProperties(properties, seen = /* @__PURE__ */ new WeakSet()) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(properties)) {
+    const normalizedKey = normalizePropertyKey(key);
+    if (AGGREGATE_PROPERTY.test(normalizedKey)) {
+      if (value === null || typeof value === "number") {
+        sanitized[key] = value;
+      }
+      continue;
+    }
+    if (IDENTIFYING_PROPERTY.test(normalizedKey) || CONTENT_PROPERTY.test(normalizedKey)) {
+      continue;
+    }
+    sanitized[key] = sanitizeValue(value, seen);
+  }
+  return sanitized;
+}
+async function capturePostHog(params) {
+  try {
+    const host = params.host ?? POSTHOG_HOST;
+    const apiKey = params.apiKey ?? POSTHOG_API_KEY;
+    const body = JSON.stringify({
       api_key: apiKey,
       event: params.event,
       distinct_id: params.distinctId,
-      properties: params.properties,
+      properties: sanitizeProperties(params.properties),
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    })
-  });
+    });
+    await telFetch(`${host}/i/v0/e/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      keepalive: true,
+      body
+    });
+  } catch {
+  }
 }
 
 // src/telemetry/telemetry.ts
@@ -3013,11 +3066,12 @@ async function completeOAuthFlow(provider, serverUrl, options = {}) {
       throw new Error(`Unexpected OAuth auth() result: ${result}`);
     }
   }
-  if (typeof flowProvider.getAuthorizationCode === "function") {
-    const code = await flowProvider.getAuthorizationCode();
+  if (typeof flowProvider.getAuthorizationResponse === "function" || typeof flowProvider.getAuthorizationCode === "function") {
+    const response = typeof flowProvider.getAuthorizationResponse === "function" ? await flowProvider.getAuthorizationResponse() : { code: await flowProvider.getAuthorizationCode() };
     await auth(provider, {
       serverUrl,
-      authorizationCode: code,
+      authorizationCode: response.code,
+      ...response.iss !== void 0 ? { iss: response.iss } : {},
       fetchFn
     });
     return;
@@ -3031,6 +3085,8 @@ async function waitForBrowserAuthComplete(provider, timeoutMs) {
     );
   }
   if (provider.useRedirectFlow) {
+    await new Promise(() => {
+    });
     return;
   }
   const tokensKey = provider.getKey?.("tokens");
@@ -3047,25 +3103,29 @@ async function waitForBrowserAuthComplete(provider, timeoutMs) {
     } catch {
     }
   }
-  const result = await runAuthPopup({
-    popup: null,
-    state,
-    tokensKey,
-    timeoutMs
-  });
-  switch (result.kind) {
-    case "success":
-      return;
-    case "cancelled":
-      throw new Error("OAuth authentication was cancelled.");
-    case "timeout":
-      throw new Error(
-        `OAuth callback not received within ${timeoutMs}ms. Ensure /oauth/callback calls onMcpAuthorization().`
-      );
-    case "error":
-      throw new Error(result.error);
-    default:
-      throw new Error("Unexpected OAuth popup result");
+  try {
+    const result = await runAuthPopup({
+      popup: null,
+      state,
+      tokensKey,
+      timeoutMs
+    });
+    switch (result.kind) {
+      case "success":
+        return;
+      case "cancelled":
+        throw new Error("OAuth authentication was cancelled.");
+      case "timeout":
+        throw new Error(
+          `OAuth callback not received within ${timeoutMs}ms. Ensure /oauth/callback calls onMcpAuthorization().`
+        );
+      case "error":
+        throw new Error(result.error);
+      default:
+        throw new Error("Unexpected OAuth popup result");
+    }
+  } finally {
+    provider.markFlowComplete?.();
   }
 }
 
@@ -4544,6 +4604,16 @@ function useMcpOperations(params) {
   };
 }
 
+// src/react/token-expiry.ts
+function getOAuthTokenExpiry(tokens) {
+  try {
+    const payload = JSON.parse(atob(tokens.access_token?.split(".")[1] ?? ""));
+    if (typeof payload.exp === "number") return payload.exp * 1e3;
+  } catch {
+  }
+  return typeof tokens.expires_in === "number" ? Date.now() + tokens.expires_in * 1e3 : void 0;
+}
+
 // src/react/useMcp.ts
 var DEFAULT_RECONNECT_DELAY = 3e3;
 var DEFAULT_RETRY_DELAY = 5e3;
@@ -5257,7 +5327,7 @@ function useMcp(options) {
             return "failed";
           }
           if (tokens?.access_token) {
-            const expiresAt = tokens.expires_in ? Date.now() + tokens.expires_in * 1e3 : void 0;
+            const expiresAt = getOAuthTokenExpiry(tokens);
             let tokenEndpoint = null;
             let resource = null;
             let clientCreds = null;
@@ -5367,8 +5437,10 @@ function useMcp(options) {
                   fetchFn: authProviderRef.current.getProxyFetch?.()
                 });
                 if (authResult === "REDIRECT") {
-                  const authCode = await authProviderRef.current.getAuthorizationCode?.();
-                  if (!authCode) {
+                  const flowProvider = authProviderRef.current;
+                  const authResponse = await flowProvider.getAuthorizationResponse?.();
+                  const authCode = authResponse?.code ?? await flowProvider.getAuthorizationCode?.();
+                  if (typeof authCode !== "string") {
                     throw new Error(
                       "Authorization code not captured by headless provider"
                     );
@@ -5376,6 +5448,7 @@ function useMcp(options) {
                   await auth2(authProviderRef.current, {
                     serverUrl: url,
                     authorizationCode: authCode,
+                    ...authResponse?.iss !== void 0 ? { iss: authResponse.iss } : {},
                     fetchFn: authProviderRef.current.getProxyFetch?.()
                   });
                 }
@@ -5970,20 +6043,14 @@ function renderResult(title, message, error, returnUrl) {
   }
   document.body.appendChild(container);
 }
-function findStoredState(state) {
-  const defaultKey = `mcp:auth:state_${state}`;
-  let key = localStorage.getItem(defaultKey) ? defaultKey : null;
-  if (!key) {
-    const suffix = `:state_${state}`;
-    for (let index = 0; index < localStorage.length; index++) {
-      const candidate = localStorage.key(index);
-      if (candidate?.endsWith(suffix)) {
-        key = candidate;
-        break;
-      }
-    }
-  }
-  const serialized = key ? localStorage.getItem(key) : null;
+async function findStoredState(state) {
+  const store = new LocalStorageKVStore();
+  const legacySuffix = `:state_${state}`;
+  const scopedSuffix = `_state_${state}`;
+  const key = (await store.keys()).find(
+    (candidate) => candidate.endsWith(legacySuffix) || candidate.endsWith(scopedSuffix)
+  );
+  const serialized = key ? await store.get(key) : null;
   if (!key || !serialized) {
     throw new Error(`Invalid or expired OAuth state "${state}".`);
   }
@@ -5991,10 +6058,10 @@ function findStoredState(state) {
   try {
     value = JSON.parse(serialized);
   } catch {
-    localStorage.removeItem(key);
+    await store.remove(key);
     throw new Error("Failed to parse stored OAuth state.");
   }
-  return { key, value };
+  return { key, value, store };
 }
 function redirectWithError(returnUrl, message) {
   const url = new URL(returnUrl);
@@ -6053,17 +6120,19 @@ async function completeAuthorization() {
   const callbackParams = new URLSearchParams(window.location.search);
   const state = callbackParams.get("state");
   let stateKey = null;
+  let stateStore = null;
   let storedState = null;
   let provider = null;
   try {
     if (!state) {
       throw new Error("OAuth callback is missing the state parameter.");
     }
-    const stored = findStoredState(state);
+    const stored = await findStoredState(state);
     stateKey = stored.key;
+    stateStore = stored.store;
     storedState = stored.value;
     if (!storedState.expiry || storedState.expiry < Date.now()) {
-      localStorage.removeItem(stateKey);
+      await stateStore.remove(stateKey);
       throw new Error(
         "OAuth state has expired. Please start authentication again."
       );
@@ -6078,7 +6147,7 @@ async function completeAuthorization() {
       fetch: provider.getProxyFetch()
     });
     await transport.finishAuth(callbackParams);
-    localStorage.removeItem(stateKey);
+    await stateStore.remove(stateKey);
     signalResult(true, void 0, storedState, {
       state,
       serverUrlHash: storedState.serverUrlHash
@@ -6086,8 +6155,12 @@ async function completeAuthorization() {
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     console.error("[mcp-callback] OAuth callback failed:", error);
-    if (stateKey) localStorage.removeItem(stateKey);
-    if (provider) localStorage.removeItem(provider.getKey("last_auth_url"));
+    if (stateKey && stateStore) await stateStore.remove(stateKey);
+    if (provider) {
+      await (stateStore ?? new LocalStorageKVStore()).remove(
+        provider.getKey("last_auth_url")
+      );
+    }
     signalResult(false, message, storedState, {
       state,
       serverUrlHash: storedState?.serverUrlHash
@@ -6963,7 +7036,13 @@ var LocalStorageProvider = class {
       );
       const serialized = JSON.stringify(sanitized);
       if (serialized !== stored) {
-        localStorage.setItem(this.storageKey, serialized);
+        try {
+          localStorage.setItem(this.storageKey, serialized);
+        } catch {
+          console.error(
+            "[LocalStorageProvider] Failed to persist sanitized servers."
+          );
+        }
       }
       return sanitized;
     } catch {
@@ -7158,8 +7237,20 @@ function findOpeningConstructEnd(html, lowercasePrefix) {
     if (start === -1) return void 0;
     const boundary = lowercaseHtml[start + lowercasePrefix.length];
     if (boundary === ">" || boundary === " " || boundary === "	" || boundary === "\n" || boundary === "\r" || boundary === "\f") {
-      const end = lowercaseHtml.indexOf(">", start + lowercasePrefix.length);
-      return end === -1 ? void 0 : end + 1;
+      let quote;
+      for (let index = start + lowercasePrefix.length; index < html.length; index++) {
+        const character = html[index];
+        if (quote) {
+          if (character === quote) quote = void 0;
+          continue;
+        }
+        if (character === '"' || character === "'") {
+          quote = character;
+          continue;
+        }
+        if (character === ">") return index + 1;
+      }
+      return void 0;
     }
     searchFrom = start + lowercasePrefix.length;
   }
@@ -7216,6 +7307,11 @@ function resolveViewResource(options) {
 }
 
 // src/react/view/sandbox-blob-url.ts
+function buildViewSandboxUrl(sandboxDocumentUrl, options) {
+  const url = new URL(sandboxDocumentUrl.href);
+  applySandboxSearchParams(url, options);
+  return url;
+}
 function applySandboxSearchParams(url, options) {
   const { cspMode, permissions, widgetCsp } = options;
   url.searchParams.set(
@@ -7582,6 +7678,67 @@ var VIEW_DIMENSIONS = {
   FULLSCREEN_HEADER_HEIGHT: 50
 };
 
+// src/react/view/view-host-policy.ts
+function buildDefaultHostCapabilities({
+  hasConnection,
+  hasMessageHandler,
+  hasModelContextHandler,
+  hasLogHandler,
+  hasSamplingHandler,
+  hasDownloadHandler,
+  messageCapabilities,
+  modelContextCapabilities
+}) {
+  return {
+    openLinks: {},
+    ...hasConnection ? {
+      serverTools: {},
+      serverResources: {}
+    } : {},
+    ...hasLogHandler ? { logging: {} } : {},
+    ...hasSamplingHandler ? { sampling: {} } : {},
+    ...hasDownloadHandler ? { downloadFile: {} } : {},
+    ...hasModelContextHandler ? { updateModelContext: modelContextCapabilities ?? { text: {} } } : {},
+    ...hasMessageHandler ? { message: messageCapabilities ?? { text: {} } } : {}
+  };
+}
+function isToolVisibleToModel(tool) {
+  if (!tool._meta || typeof tool._meta !== "object") return true;
+  const ui = tool._meta.ui;
+  if (!ui || typeof ui !== "object") return true;
+  const visibility = ui.visibility;
+  return !Array.isArray(visibility) || visibility.some((value) => value === "model");
+}
+async function dispatchUiMessage(handler, content) {
+  if (!handler) {
+    throw new Error("This host surface does not support ui/message");
+  }
+  if (content.length === 0) {
+    throw new Error("ui/message requires at least one content block");
+  }
+  await handler(content);
+}
+function resolveRequestedDisplayMode({
+  requested,
+  current,
+  hostAvailable,
+  appAvailable
+}) {
+  const hostModes = hostAvailable ?? ["inline"];
+  const appModes = appAvailable ?? ["inline"];
+  return hostModes.includes(requested) && appModes.includes(requested) ? requested : current;
+}
+function assertAppCanCallTool(tools, name) {
+  const tool = tools?.find((candidate) => candidate.name === name);
+  if (!tool) {
+    throw new Error(`Tool "${name}" is not available to this app`);
+  }
+  const visibility = tool._meta?.ui?.visibility;
+  if (visibility && !visibility.includes("app")) {
+    throw new Error(`Tool "${name}" is not available to this app`);
+  }
+}
+
 // src/react/view/view-detection.ts
 function getViewResourceUri(toolMeta) {
   const uri = toolMeta?.ui;
@@ -7601,15 +7758,6 @@ function isViewResource(mimeType) {
 var DEFAULT_HOST_INFO = { name: "mcp-use-client", version: "2.0.0" };
 var DEFAULT_TOOL_CALL_TIMEOUT = 6e5;
 var SANDBOX_PROXY_READY = "ui/notifications/sandbox-proxy-ready";
-var DEFAULT_HOST_CAPABILITIES = {
-  openLinks: {},
-  serverTools: {},
-  serverResources: {},
-  logging: {},
-  updateModelContext: { text: {} },
-  // ponytail: always advertised; bridge.onmessage no-ops when onMessage unset
-  message: { text: {} }
-};
 function CloseIcon() {
   return /* @__PURE__ */ React2.createElement(
     "svg",
@@ -7673,12 +7821,17 @@ function ViewRendererBase({
   hostInfo = DEFAULT_HOST_INFO,
   hostContext,
   hostCapabilities,
+  messageCapabilities,
+  modelContextCapabilities,
   cspMode = "widget-declared",
   displayMode: displayModeProp,
   onDisplayModeChange,
   inlineMaxWidth = 768,
   chromeless,
   onMessage,
+  onSamplingRequest,
+  onDownloadFile,
+  onAppToolsChanged,
   onModelContextUpdate,
   onLog,
   onReady,
@@ -7716,6 +7869,37 @@ function ViewRendererBase({
   );
   const [internalDisplayMode, setInternalDisplayMode] = useState4("inline");
   const displayMode = displayModeProp ?? internalDisplayMode;
+  const hasMessageHandler = onMessage !== void 0;
+  const hasModelContextHandler = onModelContextUpdate !== void 0;
+  const hasLogHandler = onLog !== void 0;
+  const hasSamplingHandler = onSamplingRequest !== void 0;
+  const hasDownloadHandler = onDownloadFile !== void 0;
+  const effectiveHostCapabilities = useMemo3(
+    () => ({
+      ...buildDefaultHostCapabilities({
+        hasConnection: source.kind === "live",
+        hasMessageHandler,
+        hasModelContextHandler,
+        hasLogHandler,
+        hasSamplingHandler,
+        hasDownloadHandler,
+        messageCapabilities,
+        modelContextCapabilities
+      }),
+      ...hostCapabilities
+    }),
+    [
+      hostCapabilities,
+      hasLogHandler,
+      hasSamplingHandler,
+      hasDownloadHandler,
+      hasMessageHandler,
+      hasModelContextHandler,
+      messageCapabilities,
+      modelContextCapabilities,
+      source.kind
+    ]
+  );
   const effectiveHostContext = useMemo3(() => {
     if (!hostContext) return hostContext;
     if (hostContext.displayMode === displayMode) return hostContext;
@@ -7725,6 +7909,12 @@ function ViewRendererBase({
   hostContextRef.current = effectiveHostContext;
   const onMessageRef = useRef4(onMessage);
   onMessageRef.current = onMessage;
+  const onSamplingRequestRef = useRef4(onSamplingRequest);
+  onSamplingRequestRef.current = onSamplingRequest;
+  const onDownloadFileRef = useRef4(onDownloadFile);
+  onDownloadFileRef.current = onDownloadFile;
+  const onAppToolsChangedRef = useRef4(onAppToolsChanged);
+  onAppToolsChangedRef.current = onAppToolsChanged;
   const toolInputRef = useRef4(toolInput);
   toolInputRef.current = toolInput;
   const partialToolInputRef = useRef4(partialToolInput);
@@ -7941,7 +8131,7 @@ function ViewRendererBase({
         await readyPromise;
         if (disposed) return;
         const capabilities = {
-          ...hostCapabilities ?? DEFAULT_HOST_CAPABILITIES,
+          ...effectiveHostCapabilities,
           sandbox: {
             csp: cspMode === "permissive" ? void 0 : resolved.csp,
             permissions: resolved.permissions
@@ -7950,75 +8140,110 @@ function ViewRendererBase({
         bridge = new AppBridge(null, hostInfo, capabilities, {
           hostContext: hostContextRef.current
         });
-        bridge.onmessage = async ({
-          content
-        }) => {
-          if (content.length > 0 && onMessageRef.current) {
-            onMessageRef.current(content);
-          }
-          return {};
-        };
+        if (capabilities.message) {
+          bridge.onmessage = async ({
+            content
+          }) => {
+            await dispatchUiMessage(onMessageRef.current, content);
+            return {};
+          };
+        }
+        if (capabilities.sampling) {
+          bridge.oncreatesamplingmessage = async (params) => {
+            const handler = onSamplingRequestRef.current;
+            if (!handler) {
+              throw new Error("This host surface does not support sampling");
+            }
+            return handler(params);
+          };
+        }
+        if (capabilities.downloadFile) {
+          bridge.ondownloadfile = async (params) => {
+            const handler = onDownloadFileRef.current;
+            if (!handler) {
+              throw new Error("This host surface does not support downloads");
+            }
+            return handler(params);
+          };
+        }
         bridge.onopenlink = async ({ url }) => {
           if (url) window.open(url, "_blank", "noopener,noreferrer");
           return {};
         };
-        bridge.oncalltool = (async ({
-          name,
-          arguments: args
-        }) => {
-          const conn = connectionRef.current;
-          if (!conn) throw new Error("Server connection not available");
-          try {
-            return await conn.callTool(name, args || {}, {
-              timeout: toolCallTimeout,
-              resetTimeoutOnProgress: true
-            });
-          } catch (error) {
-            bridge?.sendToolCancelled({
-              reason: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-          }
-        });
-        bridge.onreadresource = (async ({
-          uri
-        }) => {
-          const conn = connectionRef.current;
-          if (!conn) throw new Error("Server connection not available");
-          return await conn.readResource(uri);
-        });
-        bridge.onlistresources = (async () => {
-          const conn = connectionRef.current;
-          if (!conn) throw new Error("Server connection not available");
-          return { resources: [...conn.resources ?? []] };
-        });
+        if (capabilities.serverTools) {
+          bridge.oncalltool = (async ({
+            name,
+            arguments: args
+          }) => {
+            const conn = connectionRef.current;
+            if (!conn) throw new Error("Server connection not available");
+            assertAppCanCallTool(conn.tools, name);
+            try {
+              return await conn.callTool(name, args || {}, {
+                timeout: toolCallTimeout,
+                resetTimeoutOnProgress: true
+              });
+            } catch (error) {
+              bridge?.sendToolCancelled({
+                reason: error instanceof Error ? error.message : String(error)
+              });
+              throw error;
+            }
+          });
+        }
+        if (capabilities.serverResources) {
+          bridge.onreadresource = (async ({
+            uri
+          }) => {
+            const conn = connectionRef.current;
+            if (!conn) throw new Error("Server connection not available");
+            return await conn.readResource(uri);
+          });
+          bridge.onlistresources = (async () => {
+            const conn = connectionRef.current;
+            if (!conn) throw new Error("Server connection not available");
+            return { resources: [...conn.resources ?? []] };
+          });
+        }
         bridge.onrequestdisplaymode = async ({
           mode
         }) => {
           const requested = mode ?? "inline";
-          const available = hostContextRef.current?.availableDisplayModes ?? [
-            "inline",
-            "pip",
-            "fullscreen"
-          ];
-          const effective = available.includes(requested) ? requested : displayModeRef.current;
+          const effective = resolveRequestedDisplayMode({
+            requested,
+            current: displayModeRef.current,
+            hostAvailable: hostContextRef.current?.availableDisplayModes,
+            appAvailable: bridge?.getAppCapabilities()?.availableDisplayModes
+          });
           await handleDisplayModeChangeRef.current(effective);
           return { mode: effective };
         };
-        bridge.onupdatemodelcontext = async ({
-          content,
-          structuredContent
-        }) => {
-          onModelContextUpdateRef.current?.({ content, structuredContent });
-          return {};
-        };
-        bridge.onloggingmessage = async ({
-          level,
-          data
-        }) => {
-          onLogRef.current?.({ level, data });
-          return {};
-        };
+        if (capabilities.updateModelContext) {
+          bridge.onupdatemodelcontext = async ({
+            content,
+            structuredContent
+          }) => {
+            if (!onModelContextUpdateRef.current) {
+              throw new Error(
+                "This host surface does not support model context updates"
+              );
+            }
+            await onModelContextUpdateRef.current({
+              content,
+              structuredContent
+            });
+            return {};
+          };
+        }
+        if (capabilities.logging) {
+          bridge.onloggingmessage = async ({
+            level,
+            data
+          }) => {
+            onLogRef.current?.({ level, data });
+            return {};
+          };
+        }
         bridge.onsizechange = async ({
           height
         }) => {
@@ -8028,6 +8253,35 @@ function ViewRendererBase({
             onInlineHeightChangeRef.current?.(height);
           }
         };
+        let publishedAppToolsSignature = null;
+        const publishAppTools = async () => {
+          const handler = onAppToolsChangedRef.current;
+          if (!bridge || !handler) return;
+          const appCapabilities = bridge.getAppCapabilities();
+          if (!appCapabilities?.tools) {
+            handler(null);
+            return;
+          }
+          const result = await bridge.listTools({});
+          if (disposed || !bridge) return;
+          const signature = JSON.stringify(result.tools);
+          if (signature === publishedAppToolsSignature) return;
+          publishedAppToolsSignature = signature;
+          const currentBridge = bridge;
+          handler({
+            tools: result.tools,
+            callTool: (name, args) => currentBridge.callTool({
+              name,
+              arguments: args ?? {}
+            })
+          });
+        };
+        bridge.setNotificationHandler(
+          "notifications/tools/list_changed",
+          async () => {
+            await publishAppTools();
+          }
+        );
         const initPromise = hookInitialized(bridge);
         let transport = new PostMessageTransport(
           iframe.contentWindow,
@@ -8048,9 +8302,11 @@ function ViewRendererBase({
         bridgeRef.current = bridge;
         setInitCount((c) => c + 1);
         onLifecycleChangeRef.current?.({ status: "initialized" });
+        await publishAppTools();
         const currentPartialToolInput = partialToolInputRef.current;
-        if (currentPartialToolInput) {
-          bridge.sendToolInputPartial({
+        const hasCompletedToolResult = toolOutputRef.current !== void 0 && toolOutputRef.current !== null;
+        if (currentPartialToolInput && !hasCompletedToolResult) {
+          await bridge.sendToolInputPartial({
             arguments: currentPartialToolInput
           });
         } else {
@@ -8058,14 +8314,14 @@ function ViewRendererBase({
             ...toolInputRef.current,
             ...parseCustomProps(customPropsRef.current)
           };
-          bridge.sendToolInput({ arguments: mergedArgs });
+          await bridge.sendToolInput({ arguments: mergedArgs });
         }
         const toolResultPayload = buildToolResultPayload(
           toolOutputRef.current,
           customPropsRef.current
         );
         if (toolResultPayload) {
-          bridge.sendToolResult(toolResultPayload);
+          await bridge.sendToolResult(toolResultPayload);
         }
         onLifecycleChangeRef.current?.({ status: "ready" });
       } catch (err) {
@@ -8082,6 +8338,7 @@ function ViewRendererBase({
       disposed = true;
       const toClose = bridge;
       bridgeRef.current = null;
+      onAppToolsChangedRef.current?.(null);
       if (!toClose) return;
       onLifecycleChangeRef.current?.({ status: "tearing-down" });
       void (async () => {
@@ -8104,7 +8361,7 @@ function ViewRendererBase({
     resolved,
     activeSandboxUrl,
     hostInfo,
-    hostCapabilities,
+    effectiveHostCapabilities,
     cspMode,
     viewId,
     wrapTransport,
@@ -8114,33 +8371,37 @@ function ViewRendererBase({
   useEffect5(() => {
     const bridge = bridgeRef.current;
     if (!bridge || initCount === 0 || !effectiveHostContext) return;
-    bridge.setHostContext(effectiveHostContext);
+    void bridge.setHostContext(effectiveHostContext);
   }, [effectiveHostContext, initCount]);
   useEffect5(() => {
     const bridge = bridgeRef.current;
-    if (!bridge || initCount === 0 || !partialToolInput) return;
-    bridge.sendToolInputPartial({ arguments: partialToolInput });
-  }, [initCount, partialToolInput]);
+    if (!bridge || initCount === 0 || !partialToolInput || toolOutput !== void 0 && toolOutput !== null) {
+      return;
+    }
+    void bridge.sendToolInputPartial({ arguments: partialToolInput });
+  }, [initCount, partialToolInput, toolOutput]);
   useEffect5(() => {
     const bridge = bridgeRef.current;
-    if (!bridge || initCount === 0 || partialToolInput) return;
+    if (!bridge || initCount === 0 || partialToolInput && (toolOutput === void 0 || toolOutput === null)) {
+      return;
+    }
     const mergedArgs = {
       ...toolInput,
       ...parseCustomProps(customProps)
     };
-    bridge.sendToolInput({ arguments: mergedArgs });
-  }, [initCount, toolInput, partialToolInput, customProps]);
+    void bridge.sendToolInput({ arguments: mergedArgs });
+  }, [initCount, toolInput, partialToolInput, customProps, toolOutput]);
   useEffect5(() => {
     const bridge = bridgeRef.current;
     if (!bridge || initCount === 0) return;
     const toolResultPayload = buildToolResultPayload(toolOutput, customProps);
     if (!toolResultPayload) return;
-    bridge.sendToolResult(toolResultPayload);
+    void bridge.sendToolResult(toolResultPayload);
   }, [initCount, toolOutput, customProps]);
   useEffect5(() => {
     const bridge = bridgeRef.current;
     if (!bridge || initCount === 0 || !cancelled) return;
-    bridge.sendToolCancelled({ reason: "Cancelled by user" });
+    void bridge.sendToolCancelled({ reason: "Cancelled by user" });
   }, [cancelled, initCount]);
   const readyFiredRef = useRef4(false);
   useEffect5(() => {
@@ -8270,6 +8531,14 @@ function viewRendererAreEqual(prev, next) {
   if (prev.customProps !== next.customProps) return false;
   if (prev.hostContext !== next.hostContext) return false;
   if (prev.hostCapabilities !== next.hostCapabilities) return false;
+  if (prev.messageCapabilities !== next.messageCapabilities) return false;
+  if (prev.modelContextCapabilities !== next.modelContextCapabilities)
+    return false;
+  if (prev.onMessage !== next.onMessage) return false;
+  if (prev.onSamplingRequest !== next.onSamplingRequest) return false;
+  if (prev.onDownloadFile !== next.onDownloadFile) return false;
+  if (prev.onAppToolsChanged !== next.onAppToolsChanged) return false;
+  if (prev.onModelContextUpdate !== next.onModelContextUpdate) return false;
   if (prev.cspMode !== next.cspMode) return false;
   if (prev.mockOpenAiFileApis !== next.mockOpenAiFileApis) return false;
   if (prev.onInlineHeightChange !== next.onInlineHeightChange) return false;
@@ -8288,12 +8557,15 @@ export {
   Tel,
   Telemetry,
   ViewRenderer,
+  buildSandboxProxyBlobHtml,
   buildViewSandboxBlobUrl,
+  buildViewSandboxUrl,
   clearRpcLogs,
   detectFavicon,
   getAllRpcLogs,
   getRpcLogs,
   getViewResourceUri,
+  isToolVisibleToModel,
   isViewResource,
   isViewTool,
   onMcpAuthorization,