@mcp-use/client 2.0.0-beta.12 → 2.0.0-beta.14

package/dist/react/index.js

@@ -251,6 +251,67 @@ var init_rpc_logger = __esm({
   }
 });
 
+// src/react/types.ts
+var PERSISTED_SERVER_CONFIG_KEYS = [
+  "url",
+  "displayName",
+  "enabled",
+  "oauthProxyUrl",
+  "connectionMode",
+  "autoProxyFallback",
+  "callbackUrl",
+  "storageKeyPrefix",
+  "logLevel",
+  "autoRetry",
+  "autoReconnect",
+  "reconnectionOptions",
+  "popupFeatures",
+  "preventAutoAuth",
+  "useRedirectFlow",
+  "protocolNegotiation",
+  "timeout",
+  "clientInfo"
+];
+function pickPersistedServerConfig(source) {
+  const out = {};
+  for (const key of PERSISTED_SERVER_CONFIG_KEYS) {
+    const value = source[key];
+    if (value !== void 0) {
+      out[key] = value;
+    }
+  }
+  if (source.proxyConfig?.proxyAddress !== void 0) {
+    out.proxyConfig = { proxyAddress: source.proxyConfig.proxyAddress };
+  }
+  if (source.oauth) {
+    const oauth = {};
+    if (source.oauth.clientId !== void 0) {
+      oauth.clientId = source.oauth.clientId;
+    }
+    if (source.oauth.clientMetadataUrl !== void 0) {
+      oauth.clientMetadataUrl = source.oauth.clientMetadataUrl;
+    }
+    if (source.oauth.scope !== void 0) {
+      oauth.scope = source.oauth.scope;
+    }
+    if (Object.keys(oauth).length > 0) {
+      out.oauth = oauth;
+    }
+  }
+  return out;
+}
+function pickLiveServerConfig(source) {
+  return {
+    ...pickPersistedServerConfig(source),
+    ...source.headers !== void 0 ? { headers: source.headers } : {},
+    ...source.proxyConfig !== void 0 ? { proxyConfig: source.proxyConfig } : {},
+    ...source.clientOptions !== void 0 ? { clientOptions: source.clientOptions } : {}
+  };
+}
+function toPersistedServerConfig(config) {
+  return pickPersistedServerConfig(config);
+}
+
 // src/react/useMcp.ts
 import { auth as auth2 } from "@modelcontextprotocol/client";
 
@@ -1473,7 +1534,7 @@ var HttpConnector = class extends BaseConnector {
 };
 
 // src/utils/version.ts
-var VERSION = "2.0.0-beta.11";
+var VERSION = "2.0.0-beta.14";
 function getPackageVersion() {
   return VERSION;
 }
@@ -1544,6 +1605,186 @@ function resolveClientOptions(clientOptions) {
   };
 }
 
+// src/auth/storage.ts
+var AUTH_CRYPTO_DATABASE = "mcp-use-oauth-crypto";
+var AUTH_CRYPTO_STORE = "keys";
+var AUTH_CRYPTO_KEY = "aes-gcm-v1";
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+var LocalStorageKVStore = class {
+  fallback = /* @__PURE__ */ new Map();
+  keyPromise;
+  durable = true;
+  async get(key) {
+    if (!this.durable) return this.fallback.get(key) ?? null;
+    let stored;
+    try {
+      stored = localStorage.getItem(key);
+    } catch {
+      this.durable = false;
+      return this.fallback.get(key) ?? null;
+    }
+    if (stored === null) return null;
+    const envelope = parseEncryptedEnvelope(stored);
+    if (!envelope) {
+      await this.set(key, stored);
+      return stored;
+    }
+    try {
+      const cryptoKey = await this.getCryptoKey();
+      const plaintext = await globalThis.crypto.subtle.decrypt(
+        {
+          name: "AES-GCM",
+          iv: decodeBase64(envelope.iv),
+          additionalData: textEncoder.encode(key)
+        },
+        cryptoKey,
+        decodeBase64(envelope.ciphertext)
+      );
+      return textDecoder.decode(plaintext);
+    } catch {
+      await this.remove(key);
+      return null;
+    }
+  }
+  async set(key, value) {
+    if (!this.durable) {
+      this.fallback.set(key, value);
+      return;
+    }
+    try {
+      const cryptoKey = await this.getCryptoKey();
+      const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
+      const ciphertext = await globalThis.crypto.subtle.encrypt(
+        {
+          name: "AES-GCM",
+          iv,
+          additionalData: textEncoder.encode(key)
+        },
+        cryptoKey,
+        textEncoder.encode(value)
+      );
+      const envelope = {
+        v: 1,
+        alg: "A256GCM",
+        iv: encodeBase64(iv),
+        ciphertext: encodeBase64(new Uint8Array(ciphertext))
+      };
+      localStorage.setItem(key, JSON.stringify(envelope));
+      this.fallback.delete(key);
+    } catch {
+      this.durable = false;
+      try {
+        localStorage.removeItem(key);
+      } catch {
+      }
+      this.fallback.set(key, value);
+    }
+  }
+  remove(key) {
+    this.fallback.delete(key);
+    try {
+      localStorage.removeItem(key);
+    } catch {
+      this.durable = false;
+    }
+  }
+  keys() {
+    const out = new Set(this.fallback.keys());
+    if (this.durable) {
+      try {
+        for (let i = 0; i < localStorage.length; i++) {
+          const key = localStorage.key(i);
+          if (key) out.add(key);
+        }
+      } catch {
+        this.durable = false;
+      }
+    }
+    return [...out];
+  }
+  getCryptoKey() {
+    this.keyPromise ??= getOrCreateCryptoKey();
+    return this.keyPromise;
+  }
+};
+function parseEncryptedEnvelope(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object" || !("v" in parsed) || parsed.v !== 1 || !("alg" in parsed) || parsed.alg !== "A256GCM" || !("iv" in parsed) || typeof parsed.iv !== "string" || !("ciphertext" in parsed) || typeof parsed.ciphertext !== "string") {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+async function getOrCreateCryptoKey() {
+  if (!globalThis.crypto?.subtle || typeof indexedDB === "undefined") {
+    throw new Error("Durable browser cryptography is unavailable");
+  }
+  const candidate = await globalThis.crypto.subtle.generateKey(
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+  const database = await openCryptoDatabase();
+  try {
+    return await new Promise((resolve, reject) => {
+      const transaction = database.transaction(AUTH_CRYPTO_STORE, "readwrite");
+      const store = transaction.objectStore(AUTH_CRYPTO_STORE);
+      const request = store.get(AUTH_CRYPTO_KEY);
+      let selected;
+      request.onsuccess = () => {
+        selected = request.result;
+        if (!selected) {
+          selected = candidate;
+          store.put(candidate, AUTH_CRYPTO_KEY);
+        }
+      };
+      request.onerror = () => reject(request.error);
+      transaction.oncomplete = () => {
+        if (selected) resolve(selected);
+        else reject(new Error("OAuth encryption key was not initialized"));
+      };
+      transaction.onerror = () => reject(transaction.error);
+      transaction.onabort = () => reject(transaction.error);
+    });
+  } finally {
+    database.close();
+  }
+}
+function openCryptoDatabase() {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(AUTH_CRYPTO_DATABASE, 1);
+    request.onupgradeneeded = () => {
+      const database = request.result;
+      if (!database.objectStoreNames.contains(AUTH_CRYPTO_STORE)) {
+        database.createObjectStore(AUTH_CRYPTO_STORE);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+    request.onblocked = () => reject(new Error("OAuth encryption database is blocked"));
+  });
+}
+function encodeBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+function decodeBase64(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+// src/auth/session-store.ts
+import { validateClientMetadataUrl } from "@modelcontextprotocol/client";
+
 // src/auth/url.ts
 function sanitizeUrl(raw) {
   const abort = () => {
@@ -1568,29 +1809,7 @@ function sanitizeParam([k, v]) {
   return `${encodeURIComponent(k)}${v.length > 0 ? `=${encodeURIComponent(v)}` : ""}`;
 }
 
-// src/auth/storage.ts
-var LocalStorageKVStore = class {
-  get(key) {
-    return localStorage.getItem(key);
-  }
-  set(key, value) {
-    localStorage.setItem(key, value);
-  }
-  remove(key) {
-    localStorage.removeItem(key);
-  }
-  keys() {
-    const out = [];
-    for (let i = 0; i < localStorage.length; i++) {
-      const k = localStorage.key(i);
-      if (k) out.push(k);
-    }
-    return out;
-  }
-};
-
 // src/auth/session-store.ts
-import { validateClientMetadataUrl } from "@modelcontextprotocol/client";
 var OAuthSessionStore = class _OAuthSessionStore {
   serverUrl;
   storageKeyPrefix;
@@ -1849,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,
@@ -1902,16 +2121,26 @@ async function serializeBody(body) {
   if (body instanceof Blob) return await body.text();
   return body;
 }
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  return value.slice(0, end);
+}
 var BrowserOAuthClientProvider = class {
   serverUrl;
   staticClientInfo;
   session;
+  storage;
   // Browser-only state
   preventAutoAuth;
   useRedirectFlow;
   oauthProxyUrl;
   connectionUrl;
   proxyOAuthRequests;
+  lastAttemptedAuthUrl = null;
+  authorizationPending = false;
   onPopupWindow;
   constructor(serverUrl, options = {}) {
     if (options.staticClientInfo?.client_secret) {
@@ -1920,10 +2149,11 @@ var BrowserOAuthClientProvider = class {
       );
     }
     this.serverUrl = serverUrl;
+    this.storage = new LocalStorageKVStore();
     this.session = new OAuthSessionStore(
       serverUrl,
       { ...options, allowClientSecret: false },
-      new LocalStorageKVStore()
+      this.storage
     );
     this.preventAutoAuth = options.preventAutoAuth;
     this.useRedirectFlow = options.useRedirectFlow;
@@ -1961,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.
@@ -1988,8 +2224,8 @@ var BrowserOAuthClientProvider = class {
       const [doc, ...suffixParts] = rest.split("/");
       if (!doc) return url;
       const suffix = suffixParts.length ? `/${suffixParts.join("/")}` : "";
-      const connectionPath = connection.pathname.replace(/\/+$/, "");
-      const targetPath = target.pathname.replace(/\/+$/, "");
+      const connectionPath = trimTrailingSlashes(connection.pathname);
+      const targetPath = trimTrailingSlashes(target.pathname);
       const newSuffix = suffix && suffix === connectionPath ? targetPath : suffix;
       return `${target.origin}/.well-known/${doc}${newSuffix}${requested.search}`;
     } catch {
@@ -2140,6 +2376,8 @@ var BrowserOAuthClientProvider = class {
     return this.session.tokens(ctx);
   }
   saveTokens(tokens, ctx) {
+    this.lastAttemptedAuthUrl = null;
+    this.authorizationPending = false;
     return this.session.saveTokens(tokens, ctx);
   }
   async clientInformation(ctx) {
@@ -2206,16 +2444,22 @@ var BrowserOAuthClientProvider = class {
    * use `redirectToAuthorization` for that.
    */
   async prepareAuthorizationUrl(authorizationUrl) {
-    return this.session.storeAuthorizationState(authorizationUrl, {
-      extraProviderOptions: {
-        oauthProxyUrl: this.oauthProxyUrl,
-        ...this.clientMetadataUrl ? { clientMetadataUrl: this.clientMetadataUrl } : {},
-        ...this.staticClientInfo ? { staticClientInfo: this.staticClientInfo } : {},
-        ...this.scope ? { scope: this.scope } : {}
-      },
-      flowType: this.useRedirectFlow ? "redirect" : "popup",
-      returnUrl: typeof window !== "undefined" ? window.location.href : void 0
-    });
+    const prepared = await this.session.storeAuthorizationState(
+      authorizationUrl,
+      {
+        extraProviderOptions: {
+          oauthProxyUrl: this.oauthProxyUrl,
+          ...this.clientMetadataUrl ? { clientMetadataUrl: this.clientMetadataUrl } : {},
+          ...this.staticClientInfo ? { staticClientInfo: this.staticClientInfo } : {},
+          ...this.scope ? { scope: this.scope } : {}
+        },
+        flowType: this.useRedirectFlow ? "redirect" : "popup",
+        returnUrl: typeof window !== "undefined" ? window.location.href : void 0
+      }
+    );
+    this.lastAttemptedAuthUrl = prepared;
+    this.authorizationPending = true;
+    return prepared;
   }
   /**
    * Redirects the user agent to the authorization URL, storing necessary state.
@@ -2267,64 +2511,22 @@ var BrowserOAuthClientProvider = class {
    * Retrieves the last URL passed to `redirectToAuthorization`. Useful for manual fallback.
    */
   getLastAttemptedAuthUrl() {
-    const storedUrl = localStorage.getItem(this.getKey("last_auth_url"));
-    if (!storedUrl) return null;
-    const storedCallbackUrl = localStorage.getItem(
-      this.getKey("last_auth_callback_url")
-    );
-    if (storedCallbackUrl !== this.callbackUrl) {
-      console.info(
-        `[${this.storageKeyPrefix}] Recovering stale OAuth state whose callback cannot be verified.`
-      );
-      this.clearStorage();
-      return null;
-    }
-    const sanitized = sanitizeUrl(storedUrl);
-    try {
-      const redirectUri = new URL(sanitized).searchParams.get("redirect_uri");
-      if (redirectUri && new URL(redirectUri).toString() !== new URL(this.callbackUrl).toString()) {
-        console.info(
-          `[${this.storageKeyPrefix}] Recovering stale OAuth state after the Inspector callback path changed.`
-        );
-        this.clearStorage();
-        return null;
-      }
-    } catch {
-      this.clearStorage();
-      return null;
-    }
-    return sanitized;
+    return this.lastAttemptedAuthUrl;
   }
   clearStorage() {
+    this.lastAttemptedAuthUrl = null;
+    this.authorizationPending = false;
     const prefixPattern = `${this.storageKeyPrefix}_${this.serverUrlHash}_`;
-    const statePattern = `${this.storageKeyPrefix}:state_`;
     const keysToRemove = [];
     let count = 0;
-    for (let i = 0; i < localStorage.length; i++) {
-      const key = localStorage.key(i);
-      if (!key) continue;
+    for (const key of this.storage.keys()) {
       if (key.startsWith(prefixPattern)) {
         keysToRemove.push(key);
-      } else if (key.startsWith(statePattern)) {
-        try {
-          const item = localStorage.getItem(key);
-          if (item) {
-            const state = JSON.parse(item);
-            if (state.serverUrlHash === this.serverUrlHash) {
-              keysToRemove.push(key);
-            }
-          }
-        } catch (e) {
-          console.warn(
-            `[${this.storageKeyPrefix}] Error parsing state key ${key} during clearStorage:`,
-            e
-          );
-        }
       }
     }
     const uniqueKeysToRemove = [...new Set(keysToRemove)];
     uniqueKeysToRemove.forEach((key) => {
-      localStorage.removeItem(key);
+      this.storage.remove(key);
       count++;
     });
     return count;
@@ -2355,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,
@@ -2375,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,
@@ -2472,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
@@ -2818,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;
@@ -2836,6 +3085,8 @@ async function waitForBrowserAuthComplete(provider, timeoutMs) {
     );
   }
   if (provider.useRedirectFlow) {
+    await new Promise(() => {
+    });
     return;
   }
   const tokensKey = provider.getKey?.("tokens");
@@ -2852,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?.();
   }
 }
 
@@ -4349,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;
@@ -5062,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;
@@ -5172,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"
                     );
@@ -5181,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?.()
                   });
                 }
@@ -5775,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}".`);
   }
@@ -5796,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);
@@ -5858,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."
       );
@@ -5883,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
@@ -5891,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
@@ -5915,45 +6183,6 @@ import React, {
   useState as useState3
 } from "react";
 
-// src/react/types.ts
-var PERSISTED_SERVER_CONFIG_KEYS = [
-  "url",
-  "displayName",
-  "enabled",
-  "proxyConfig",
-  "oauthProxyUrl",
-  "connectionMode",
-  "autoProxyFallback",
-  "callbackUrl",
-  "storageKeyPrefix",
-  "headers",
-  "logLevel",
-  "autoRetry",
-  "autoReconnect",
-  "reconnectionOptions",
-  "popupFeatures",
-  "preventAutoAuth",
-  "useRedirectFlow",
-  "clientOptions",
-  "protocolNegotiation",
-  "timeout",
-  "clientInfo",
-  "oauth"
-];
-function pickPersistedServerConfig(source) {
-  const out = {};
-  for (const key of PERSISTED_SERVER_CONFIG_KEYS) {
-    const value = source[key];
-    if (value !== void 0) {
-      out[key] = value;
-    }
-  }
-  return out;
-}
-function toPersistedServerConfig(config) {
-  return pickPersistedServerConfig(config);
-}
-
 // src/react/useMcpServerQueues.ts
 import { useCallback as useCallback3, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
 var MAX_NOTIFICATIONS = 500;
@@ -6140,8 +6369,8 @@ function sameSerializedValue(left, right) {
 }
 function isSameMcpServer(left, right) {
   return left.id === right.id && sameSerializedValue(
-    pickPersistedServerConfig(left),
-    pickPersistedServerConfig(right)
+    pickLiveServerConfig(left),
+    pickLiveServerConfig(right)
   ) && left.name === right.name && left.state === right.state && left.error === right.error && left.authUrl === right.authUrl && sameSerializedValue(left.authTokens, right.authTokens) && left.protocolEra === right.protocolEra && left.protocolVersion === right.protocolVersion && sameSerializedValue(left.serverInfo, right.serverInfo) && sameSerializedValue(left.capabilities, right.capabilities) && left.instructions === right.instructions && sameSerializedValue(left.extensions, right.extensions) && sameSerializedValue(left.tools, right.tools) && sameSerializedValue(left.resources, right.resources) && sameSerializedValue(left.resourceTemplates, right.resourceTemplates) && sameSerializedValue(left.prompts, right.prompts) && sameSerializedValue(left.notifications, right.notifications) && left.unreadNotificationCount === right.unreadNotificationCount && sameSerializedValue(
     left.pendingSamplingRequests,
     right.pendingSamplingRequests
@@ -6275,7 +6504,7 @@ function McpServerWrapper({
   }, [onUpdate]);
   useEffect3(() => {
     const server = {
-      ...toPersistedServerConfig(options),
+      ...pickLiveServerConfig(options),
       ...mcp,
       id,
       displayName: displayName || options.displayName || id,
@@ -6622,8 +6851,8 @@ function McpClientProvider({
         ...options
       };
       if (sameSerializedValue(
-        pickPersistedServerConfig(currentConfig.options),
-        pickPersistedServerConfig(updatedOptions)
+        pickLiveServerConfig(currentConfig.options),
+        pickLiveServerConfig(updatedOptions)
       )) {
         return;
       }
@@ -6790,17 +7019,48 @@ var LocalStorageProvider = class {
   getServers() {
     try {
       const stored = localStorage.getItem(this.storageKey);
-      return stored ? JSON.parse(stored) : {};
-    } catch (error) {
-      console.error("[LocalStorageProvider] Failed to load servers:", error);
+      if (!stored) return {};
+      const parsed = JSON.parse(stored);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {};
+      }
+      const sanitized = Object.fromEntries(
+        Object.entries(parsed).flatMap(
+          ([id, config]) => config && typeof config === "object" && !Array.isArray(config) ? [
+            [
+              id,
+              toPersistedServerConfig(config)
+            ]
+          ] : []
+        )
+      );
+      const serialized = JSON.stringify(sanitized);
+      if (serialized !== stored) {
+        try {
+          localStorage.setItem(this.storageKey, serialized);
+        } catch {
+          console.error(
+            "[LocalStorageProvider] Failed to persist sanitized servers."
+          );
+        }
+      }
+      return sanitized;
+    } catch {
+      console.error("[LocalStorageProvider] Failed to load servers.");
       return {};
     }
   }
   setServers(servers) {
     try {
-      localStorage.setItem(this.storageKey, JSON.stringify(servers));
-    } catch (error) {
-      console.error("[LocalStorageProvider] Failed to save servers:", error);
+      const sanitized = Object.fromEntries(
+        Object.entries(servers).map(([id, config]) => [
+          id,
+          toPersistedServerConfig(config)
+        ])
+      );
+      localStorage.setItem(this.storageKey, JSON.stringify(sanitized));
+    } catch {
+      console.error("[LocalStorageProvider] Failed to save servers.");
     }
   }
   setServer(id, config) {
@@ -6818,24 +7078,24 @@ var LocalStorageProvider = class {
     try {
       localStorage.removeItem(this.storageKey);
       localStorage.removeItem(this.metadataKey);
-    } catch (error) {
-      console.error("[LocalStorageProvider] Failed to clear:", error);
+    } catch {
+      console.error("[LocalStorageProvider] Failed to clear.");
     }
   }
   getAllMetadata() {
     try {
       const stored = localStorage.getItem(this.metadataKey);
       return stored ? JSON.parse(stored) : {};
-    } catch (error) {
-      console.error("[LocalStorageProvider] Failed to load metadata:", error);
+    } catch {
+      console.error("[LocalStorageProvider] Failed to load metadata.");
       return {};
     }
   }
   setAllMetadata(metadata) {
     try {
       localStorage.setItem(this.metadataKey, JSON.stringify(metadata));
-    } catch (error) {
-      console.error("[LocalStorageProvider] Failed to save metadata:", error);
+    } catch {
+      console.error("[LocalStorageProvider] Failed to save metadata.");
     }
   }
   getServerMetadata(id) {
@@ -6859,10 +7119,15 @@ var MemoryStorageProvider = class {
     return { ...this.storage };
   }
   setServers(servers) {
-    this.storage = { ...servers };
+    this.storage = Object.fromEntries(
+      Object.entries(servers).map(([id, config]) => [
+        id,
+        toPersistedServerConfig(config)
+      ])
+    );
   }
   setServer(id, config) {
-    this.storage[id] = config;
+    this.storage[id] = toPersistedServerConfig(config);
   }
   removeServer(id) {
     delete this.storage[id];
@@ -6942,32 +7207,58 @@ var OPENAI_FILE_APIS_SCRIPT = `<script>
 })();
 </script>`;
 function injectOpenAiFileApis(html) {
-  if (html.includes("<head>")) {
-    return html.replace("<head>", "<head>" + OPENAI_FILE_APIS_SCRIPT);
-  }
-  if (html.includes("<HEAD>")) {
-    return html.replace("<HEAD>", "<HEAD>" + OPENAI_FILE_APIS_SCRIPT);
-  }
-  if (html.includes("<html>")) {
-    return html.replace(
-      "<html>",
-      "<html><head>" + OPENAI_FILE_APIS_SCRIPT + "</head>"
+  const headEnd = findOpeningConstructEnd(html, "<head");
+  if (headEnd !== void 0) {
+    return insertAt(html, headEnd, OPENAI_FILE_APIS_SCRIPT);
+  }
+  const htmlEnd = findOpeningConstructEnd(html, "<html");
+  if (htmlEnd !== void 0) {
+    return insertAt(
+      html,
+      htmlEnd,
+      "<head>" + OPENAI_FILE_APIS_SCRIPT + "</head>"
     );
   }
-  if (html.includes("<HTML>")) {
-    return html.replace(
-      "<HTML>",
-      "<HTML><head>" + OPENAI_FILE_APIS_SCRIPT + "</head>"
-    );
-  }
-  if (html.includes("<!DOCTYPE") || html.includes("<!doctype")) {
-    return html.replace(
-      /(<!DOCTYPE[^>]*>|<!doctype[^>]*>)/i,
-      "$1<head>" + OPENAI_FILE_APIS_SCRIPT + "</head>"
+  const doctypeEnd = findOpeningConstructEnd(html, "<!doctype");
+  if (doctypeEnd !== void 0) {
+    return insertAt(
+      html,
+      doctypeEnd,
+      "<head>" + OPENAI_FILE_APIS_SCRIPT + "</head>"
     );
   }
   return OPENAI_FILE_APIS_SCRIPT + html;
 }
+function findOpeningConstructEnd(html, lowercasePrefix) {
+  const lowercaseHtml = html.toLowerCase();
+  let searchFrom = 0;
+  while (searchFrom < lowercaseHtml.length) {
+    const start = lowercaseHtml.indexOf(lowercasePrefix, searchFrom);
+    if (start === -1) return void 0;
+    const boundary = lowercaseHtml[start + lowercasePrefix.length];
+    if (boundary === ">" || boundary === " " || boundary === "	" || boundary === "\n" || boundary === "\r" || boundary === "\f") {
+      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;
+  }
+  return void 0;
+}
+function insertAt(value, index, addition) {
+  return value.slice(0, index) + addition + value.slice(index);
+}
 
 // src/react/view/resolve-view-resource.ts
 function resolveViewResource(options) {
@@ -7382,6 +7673,63 @@ var VIEW_DIMENSIONS = {
   FULLSCREEN_HEADER_HEIGHT: 50
 };
 
+// src/react/view/view-host-policy.ts
+function buildDefaultHostCapabilities({
+  hasConnection,
+  hasMessageHandler,
+  hasModelContextHandler,
+  hasLogHandler,
+  messageCapabilities,
+  modelContextCapabilities
+}) {
+  return {
+    openLinks: {},
+    ...hasConnection ? {
+      serverTools: {},
+      serverResources: {}
+    } : {},
+    ...hasLogHandler ? { logging: {} } : {},
+    ...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;
@@ -7401,15 +7749,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",
@@ -7473,6 +7812,8 @@ function ViewRendererBase({
   hostInfo = DEFAULT_HOST_INFO,
   hostContext,
   hostCapabilities,
+  messageCapabilities,
+  modelContextCapabilities,
   cspMode = "widget-declared",
   displayMode: displayModeProp,
   onDisplayModeChange,
@@ -7516,6 +7857,28 @@ function ViewRendererBase({
   );
   const [internalDisplayMode, setInternalDisplayMode] = useState4("inline");
   const displayMode = displayModeProp ?? internalDisplayMode;
+  const effectiveHostCapabilities = useMemo3(
+    () => ({
+      ...buildDefaultHostCapabilities({
+        hasConnection: source.kind === "live",
+        hasMessageHandler: onMessage !== void 0,
+        hasModelContextHandler: onModelContextUpdate !== void 0,
+        hasLogHandler: onLog !== void 0,
+        messageCapabilities,
+        modelContextCapabilities
+      }),
+      ...hostCapabilities
+    }),
+    [
+      hostCapabilities,
+      messageCapabilities,
+      modelContextCapabilities,
+      onLog,
+      onMessage,
+      onModelContextUpdate,
+      source.kind
+    ]
+  );
   const effectiveHostContext = useMemo3(() => {
     if (!hostContext) return hostContext;
     if (hostContext.displayMode === displayMode) return hostContext;
@@ -7741,7 +8104,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
@@ -7750,75 +8113,92 @@ 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 {};
+          };
+        }
         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
         }) => {
@@ -7904,7 +8284,7 @@ function ViewRendererBase({
     resolved,
     activeSandboxUrl,
     hostInfo,
-    hostCapabilities,
+    effectiveHostCapabilities,
     cspMode,
     viewId,
     wrapTransport,
@@ -8070,6 +8450,11 @@ 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.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;
@@ -8094,14 +8479,17 @@ export {
   getAllRpcLogs,
   getRpcLogs,
   getViewResourceUri,
+  isToolVisibleToModel,
   isViewResource,
   isViewTool,
   onMcpAuthorization,
   parseCustomProps,
+  pickPersistedServerConfig,
   resolveViewResource,
   setTelemetrySource,
   specTypeSchemas,
   subscribeToRpcLogs,
+  toPersistedServerConfig,
   useMcp,
   useMcpClient,
   useMcpServer