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

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.13";
 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;
@@ -1902,16 +2121,25 @@ 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;
   onPopupWindow;
   constructor(serverUrl, options = {}) {
     if (options.staticClientInfo?.client_secret) {
@@ -1920,10 +2148,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;
@@ -1988,8 +2217,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 +2369,7 @@ var BrowserOAuthClientProvider = class {
     return this.session.tokens(ctx);
   }
   saveTokens(tokens, ctx) {
+    this.lastAttemptedAuthUrl = null;
     return this.session.saveTokens(tokens, ctx);
   }
   async clientInformation(ctx) {
@@ -2206,16 +2436,21 @@ 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;
+    return prepared;
   }
   /**
    * Redirects the user agent to the authorization URL, storing necessary state.
@@ -2267,64 +2502,24 @@ 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;
     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
-          );
-        }
+        keysToRemove.push(key);
       }
     }
     const uniqueKeysToRemove = [...new Set(keysToRemove)];
     uniqueKeysToRemove.forEach((key) => {
-      localStorage.removeItem(key);
+      this.storage.remove(key);
       count++;
     });
     return count;
@@ -5915,45 +6110,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 +6296,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 +6431,7 @@ function McpServerWrapper({
   }, [onUpdate]);
   useEffect3(() => {
     const server = {
-      ...toPersistedServerConfig(options),
+      ...pickLiveServerConfig(options),
       ...mcp,
       id,
       displayName: displayName || options.displayName || id,
@@ -6622,8 +6778,8 @@ function McpClientProvider({
         ...options
       };
       if (sameSerializedValue(
-        pickPersistedServerConfig(currentConfig.options),
-        pickPersistedServerConfig(updatedOptions)
+        pickLiveServerConfig(currentConfig.options),
+        pickLiveServerConfig(updatedOptions)
       )) {
         return;
       }
@@ -6790,17 +6946,42 @@ 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) {
+        localStorage.setItem(this.storageKey, serialized);
+      }
+      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 +6999,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 +7040,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 +7128,46 @@ 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") {
+      const end = lowercaseHtml.indexOf(">", start + lowercasePrefix.length);
+      return end === -1 ? void 0 : end + 1;
+    }
+    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) {
@@ -8098,10 +8298,12 @@ export {
   isViewTool,
   onMcpAuthorization,
   parseCustomProps,
+  pickPersistedServerConfig,
   resolveViewResource,
   setTelemetrySource,
   specTypeSchemas,
   subscribeToRpcLogs,
+  toPersistedServerConfig,
   useMcp,
   useMcpClient,
   useMcpServer