@mcp-ts/sdk 1.3.10 → 1.5.0

package/dist/index.js

@@ -1794,13 +1794,24 @@ var MCPClient = class _MCPClient {
       }
     } catch (error) {
       if (error instanceof auth_js.UnauthorizedError || error instanceof Error && error.message.toLowerCase().includes("unauthorized")) {
-        this.emitStateChange("AUTHENTICATING");
-        console.log(`[MCPClient] Saving session ${this.sessionId} with 10min TTL (OAuth pending)`);
-        await this.saveSession(Math.floor(STATE_EXPIRATION_MS / 1e3), false);
         let authUrl = "";
         if (this.oauthProvider) {
-          authUrl = this.oauthProvider.authUrl || "";
+          authUrl = (this.oauthProvider.authUrl || "").trim();
+        }
+        if (!authUrl) {
+          const detail = error instanceof Error && error.message.trim().length > 0 ? error.message.trim() : "Unauthorized";
+          const message = detail.toLowerCase() === "unauthorized" ? "OAuth authorization URL not available" : `OAuth authorization URL not available: ${detail}`;
+          this.emitError(message, "auth");
+          this.emitStateChange("FAILED");
+          try {
+            await storage.removeSession(this.identity, this.sessionId);
+          } catch {
+          }
+          throw new Error(message);
         }
+        this.emitStateChange("AUTHENTICATING");
+        console.log(`[MCPClient] Saving session ${this.sessionId} with 10min TTL (OAuth pending)`);
+        await this.saveSession(Math.floor(STATE_EXPIRATION_MS / 1e3), false);
         if (this.serverId) {
           this._onConnectionEvent.fire({
             type: "auth_required",
@@ -2253,7 +2264,9 @@ var MCPClient = class _MCPClient {
    * @returns Server name or undefined
    */
   getServerName() {
-    return this.serverName;
+    const info = this.client?.getServerVersion();
+    console.log("server info ->", info);
+    return info?.title ?? info?.name ?? this.serverName;
   }
   /**
    * Gets the server ID
@@ -3353,22 +3366,92 @@ var SSEClient = class {
 
 // src/client/core/app-host.ts
 init_cjs_shims();
-var HOST_INFO = { name: "mcp-ts-host", version: "1.0.0" };
-var SANDBOX_PERMISSIONS = [
-  "allow-scripts",
-  // Required for app JavaScript execution
-  "allow-forms",
-  // Required for form submissions
-  "allow-same-origin",
-  // Required for Blob URL correctness
-  "allow-modals",
-  // Required for dialogs/alerts
-  "allow-popups",
-  // Required for opening links
-  "allow-downloads"
-  // Required for file downloads
-].join(" ");
-var MCP_URI_SCHEMES = ["ui://", "mcp-app://"];
+
+// src/client/utils/app-host-utils.ts
+init_cjs_shims();
+
+// src/client/core/constants.ts
+init_cjs_shims();
+var SANDBOX_PROXY_READY_METHOD = "ui/notifications/sandbox-proxy-ready";
+var SANDBOX_RESOURCE_READY_METHOD = "ui/notifications/sandbox-resource-ready";
+var APP_HOST_DEFAULTS = {
+  /** Default timeout for waiting for the sandbox proxy to be ready (ms). */
+  SANDBOX_TIMEOUT_MS: 1e4,
+  /** Default host info reported to guest apps. */
+  HOST_INFO: { name: "mcp-ts-host", version: "1.0.0" },
+  /** Supported MCP App URI schemes. */
+  URI_SCHEMES: ["ui://", "mcp-app://"],
+  /** Default theme for the host context. */
+  THEME: "dark",
+  /** Default platform for the host context. */
+  PLATFORM: "web",
+  /** Default max height for the iframe container (px). */
+  MAX_HEIGHT: 6e3
+};
+
+// src/client/utils/app-host-utils.ts
+var DEFAULT_SANDBOX_TIMEOUT_MS = APP_HOST_DEFAULTS.SANDBOX_TIMEOUT_MS;
+async function setupSandboxProxyIframe(iframe, sandboxProxyUrl) {
+  iframe.style.width = "100%";
+  iframe.style.height = "100%";
+  iframe.style.border = "none";
+  iframe.style.backgroundColor = "transparent";
+  iframe.setAttribute("sandbox", "allow-scripts allow-same-origin allow-forms allow-modals allow-popups allow-downloads");
+  const onReady = new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      window.removeEventListener("message", messageListener);
+      iframe.removeEventListener("error", errorListener);
+    };
+    const timeoutId = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        cleanup();
+        reject(new Error("Timed out waiting for sandbox proxy iframe to be ready"));
+      }
+    }, DEFAULT_SANDBOX_TIMEOUT_MS);
+    const messageListener = (event) => {
+      if (event.source === iframe.contentWindow) {
+        if (event.data?.method === SANDBOX_PROXY_READY_METHOD) {
+          if (!settled) {
+            settled = true;
+            clearTimeout(timeoutId);
+            cleanup();
+            resolve();
+          }
+        }
+      }
+    };
+    const errorListener = () => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeoutId);
+        cleanup();
+        reject(new Error("Failed to load sandbox proxy iframe"));
+      }
+    };
+    window.addEventListener("message", messageListener);
+    iframe.addEventListener("error", errorListener);
+  });
+  iframe.src = sandboxProxyUrl.href;
+  return { onReady };
+}
+
+// src/client/core/app-host.ts
+var DEFAULT_MCP_APP_CSP = {
+  "default-src": "'self'",
+  "script-src": "'self' 'unsafe-inline' 'unsafe-eval' https: blob:",
+  "style-src": "'self' 'unsafe-inline' https:",
+  "connect-src": "'self' https: wss:",
+  "img-src": "'self' data: https: blob:",
+  "font-src": "'self' data: https:",
+  "media-src": "'self' https: blob:",
+  "frame-src": "'none'",
+  "object-src": "'none'",
+  "base-uri": "'self'"
+};
+var HOST_INFO = APP_HOST_DEFAULTS.HOST_INFO;
+var MCP_URI_SCHEMES = APP_HOST_DEFAULTS.URI_SCHEMES;
 var AppHost = class {
   constructor(client, iframe, options) {
     this.client = client;
@@ -3377,10 +3460,12 @@ var AppHost = class {
     __publicField(this, "sessionId");
     __publicField(this, "resourceCache", /* @__PURE__ */ new Map());
     __publicField(this, "debug");
-    /** Callback for app messages (e.g., chat messages from the app) */
+    __publicField(this, "sandboxConfig");
+    __publicField(this, "options");
     __publicField(this, "onAppMessage");
-    this.debug = options?.debug ?? false;
-    this.configureSandbox();
+    this.options = options || {};
+    this.debug = this.options.debug ?? false;
+    this.sandboxConfig = this.options.sandbox;
     this.bridge = this.initializeBridge();
   }
   // ============================================
@@ -3407,19 +3492,35 @@ var AppHost = class {
     }
   }
   /**
-   * Launch an MCP App from a URL or MCP resource URI.
+   * Launch an MCP App from a URL, MCP resource URI, or RAW HTML.
    * Loads the HTML first, then establishes bridge connection.
    */
-  async launch(url, sessionId) {
+  async launch(source, sessionId) {
     if (sessionId) this.sessionId = sessionId;
     const initializedPromise = this.onAppReady();
-    if (this.isMcpUri(url)) {
-      await this.launchMcpApp(url);
-    } else {
-      this.iframe.src = url;
+    let htmlToRender = source.html;
+    if (!htmlToRender && source.uri) {
+      if (this.isMcpUri(source.uri)) {
+        htmlToRender = await this.readMcpAppHtml(source.uri);
+      }
+    }
+    if (!htmlToRender && source.uri && !this.isMcpUri(source.uri)) {
+      this.iframe.setAttribute("sandbox", "allow-scripts allow-same-origin allow-forms allow-modals allow-popups allow-downloads");
+      this.iframe.src = source.uri;
+      await this.onIframeReady();
+      await this.connectBridge();
+    } else if (htmlToRender) {
+      if (!this.sandboxConfig) {
+        throw new Error("Sandbox configuration requires a proxy URL to render HTML safely.");
+      }
+      await this.launchSandboxedHtml(htmlToRender, this.sandboxConfig);
+      await this.connectBridge();
+      this.log("Sending HTML resource to sandbox proxy (MCP Apps notification)");
+      await this.bridge.sendSandboxResourceReady({
+        html: htmlToRender,
+        csp: this.sandboxConfig.csp
+      });
     }
-    await this.onIframeReady();
-    await this.connectBridge();
     this.log("Waiting for app initialization");
     await Promise.race([
       initializedPromise,
@@ -3430,6 +3531,19 @@ var AppHost = class {
     ]);
     this.log("App launched and ready");
   }
+  // Set host context manually
+  setHostContext(context) {
+    this.options.hostContext = context;
+    if (this.bridge) {
+      this.bridge.setHostContext(context);
+    }
+  }
+  // Send streaming inputs manually
+  sendToolInputPartial(params) {
+    if (this.bridge) {
+      this.bridge.sendToolInputPartial(params);
+    }
+  }
   /**
    * Wait for app to signal initialization complete
    */
@@ -3480,14 +3594,17 @@ var AppHost = class {
     this.log("Sending tool cancellation to app");
     this.bridge.sendToolCancelled({ reason });
   }
+  /**
+   * Tell the guest UI the resource is being torn down (unload / cleanup).
+   * Forwards to {@link AppBridge.teardownResource} on `@modelcontextprotocol/ext-apps/app-bridge`.
+   */
+  teardownResource(params = {}) {
+    this.log("Sending resource teardown to app");
+    this.bridge.teardownResource(params);
+  }
   // ============================================
   // Private: Initialization
   // ============================================
-  configureSandbox() {
-    if (this.iframe.sandbox.value !== SANDBOX_PERMISSIONS) {
-      this.iframe.sandbox.value = SANDBOX_PERMISSIONS;
-    }
-  }
   initializeBridge() {
     const bridge = new appBridge.AppBridge(
       null,
@@ -3496,12 +3613,10 @@ var AppHost = class {
         openLinks: {},
         serverTools: {},
         logging: {},
-        // Declare support for model context updates
         updateModelContext: { text: {} }
       },
       {
-        // Initial host context
-        hostContext: {
+        hostContext: this.options.hostContext || {
           theme: "dark",
           platform: "web",
           containerDimensions: { maxHeight: 6e3 },
@@ -3510,19 +3625,56 @@ var AppHost = class {
         }
       }
     );
+    bridge.fallbackRequestHandler = this.options.onFallbackRequest;
     bridge.oncalltool = (params) => this.handleToolCall(params);
-    bridge.onopenlink = this.handleOpenLink.bind(this);
-    bridge.onmessage = this.handleMessage.bind(this);
-    bridge.onloggingmessage = (params) => this.log(`App log [${params.level}]: ${params.data}`);
+    if (this.options.onReadResource) {
+      bridge.onreadresource = async (params) => {
+        const resp = await this.options.onReadResource(params.uri);
+        return {
+          contents: resp.contents.map((c) => ({
+            uri: params.uri,
+            text: c.text,
+            blob: c.blob
+          }))
+        };
+      };
+    }
+    bridge.onopenlink = async (params, extra) => {
+      if (this.options.onOpenLink) {
+        return await this.options.onOpenLink(params, extra);
+      }
+      return this.handleOpenLink(params);
+    };
+    bridge.onmessage = async (params, extra) => {
+      if (this.options.onMessage) {
+        return await this.options.onMessage(params, extra);
+      }
+      return this.handleMessage(params);
+    };
+    bridge.onloggingmessage = (params) => {
+      this.log(`App log [${params.level}]: ${params.data}`);
+      if (this.options.onLoggingMessage) {
+        this.options.onLoggingMessage(params);
+      }
+    };
     bridge.onupdatemodelcontext = async () => ({});
-    bridge.onsizechange = async ({ width, height }) => {
-      if (height !== void 0) this.iframe.style.height = `${height}px`;
-      if (width !== void 0) this.iframe.style.minWidth = `min(${width}px, 100%)`;
+    bridge.onsizechange = async (params) => {
+      const { width, height } = params;
+      if (height !== void 0 && height > 0) {
+        this.iframe.style.height = `${height}px`;
+      }
+      if (width !== void 0 && width > 0) this.iframe.style.minWidth = `min(${width}px, 100%)`;
+      if (this.options.onSizeChanged) {
+        this.options.onSizeChanged(params);
+      }
       return {};
     };
-    bridge.onrequestdisplaymode = async (params) => ({
-      mode: params.mode === "fullscreen" ? "fullscreen" : "inline"
-    });
+    bridge.onrequestdisplaymode = async (params, extra) => {
+      if (this.options.onRequestDisplayMode) {
+        return await this.options.onRequestDisplayMode(params, extra);
+      }
+      return { mode: params.mode === "fullscreen" ? "fullscreen" : "inline" };
+    };
     return bridge;
   }
   async connectBridge() {
@@ -3536,6 +3688,9 @@ var AppHost = class {
       this.log("Bridge connected successfully");
     } catch (error) {
       this.log("Bridge connection failed", "error");
+      if (this.options.onError) {
+        this.options.onError(error instanceof Error ? error : new Error(String(error)));
+      }
       throw error;
     }
   }
@@ -3543,8 +3698,11 @@ var AppHost = class {
   // Private: Bridge Event Handlers
   // ============================================
   async handleToolCall(params) {
-    if (!this.client.isConnected()) {
-      throw new Error("Client disconnected");
+    if (this.options.onCallTool) {
+      return await this.options.onCallTool(params);
+    }
+    if (!this.client || !this.client.isConnected()) {
+      throw new Error("Client disconnected or not provided");
     }
     const sessionId = await this.getSessionId();
     if (!sessionId) {
@@ -3568,13 +3726,19 @@ var AppHost = class {
   // ============================================
   // Private: Resource Loading
   // ============================================
-  async launchMcpApp(uri) {
-    if (!this.client.isConnected()) {
-      throw new Error("Client must be connected");
+  async launchSandboxedHtml(html, config) {
+    const sandboxUrlString = config.url instanceof URL ? config.url.href : config.url;
+    const url = new URL(sandboxUrlString, globalThis.location?.href);
+    if (config.csp && Object.keys(config.csp).length > 0) {
+      url.searchParams.set("csp", JSON.stringify(config.csp));
     }
+    const { onReady } = await setupSandboxProxyIframe(this.iframe, url);
+    await onReady;
+  }
+  async readMcpAppHtml(uri) {
     const sessionId = await this.getSessionId();
-    if (!sessionId) {
-      throw new Error("No active session");
+    if (!sessionId && !this.options.onReadResource) {
+      throw new Error("No active session.");
     }
     const response = await this.fetchResourceWithCache(sessionId, uri);
     if (!response?.contents?.length) {
@@ -3585,10 +3749,18 @@ var AppHost = class {
     if (!html) {
       throw new Error(`Invalid content in resource: ${uri}`);
     }
-    const blob = new Blob([html], { type: "text/html" });
-    this.iframe.src = URL.createObjectURL(blob);
+    return html;
   }
   async fetchResourceWithCache(sessionId, uri) {
+    if (this.options.onReadResource) {
+      return await this.options.onReadResource(uri);
+    }
+    if (!sessionId) {
+      throw new Error("No active session");
+    }
+    if (!this.client) {
+      throw new Error("No client to read resource from");
+    }
     if (this.hasClientCache()) {
       return this.client.getOrFetchResource(sessionId, uri);
     }
@@ -3601,8 +3773,11 @@ var AppHost = class {
   }
   async preloadResource(uri) {
     try {
+      if (this.options.onReadResource) {
+        return await this.options.onReadResource(uri);
+      }
       const sessionId = await this.getSessionId();
-      if (!sessionId) return null;
+      if (!sessionId || !this.client) return null;
       return await this.client.readResource(sessionId, uri);
     } catch (error) {
       this.log(`Preload failed for ${uri}`, "warn");
@@ -3614,6 +3789,7 @@ var AppHost = class {
   // ============================================
   async getSessionId() {
     if (this.sessionId) return this.sessionId;
+    if (!this.client) return void 0;
     const result = await this.client.getSessions();
     return result.sessions?.[0]?.sessionId;
   }
@@ -3621,6 +3797,7 @@ var AppHost = class {
     return MCP_URI_SCHEMES.some((scheme) => url.startsWith(scheme));
   }
   hasClientCache() {
+    if (!this.client) return false;
     return "getOrFetchResource" in this.client && typeof this.client.getOrFetchResource === "function";
   }
   extractUiResourceUri(tool) {
@@ -3689,6 +3866,877 @@ function findToolByName(connections, toolName) {
   return void 0;
 }
 
+// src/shared/tool-router.ts
+init_cjs_shims();
+
+// src/shared/tool-index.ts
+init_cjs_shims();
+var CALIBRATION_DIVISOR = 3.6;
+function classifyChar(ch) {
+  const code = ch.charCodeAt(0);
+  if (code <= 32 || ch === "{" || ch === "}" || ch === "[" || ch === "]" || ch === ":" || ch === ",") return 1;
+  if (code >= 33 && code <= 47) return 1.5;
+  if (code >= 48 && code <= 57) return 2;
+  if (code >= 65 && code <= 90) return 3.5;
+  if (code >= 97 && code <= 122) return 4;
+  return 2.5;
+}
+var ToolIndex = class _ToolIndex {
+  constructor(options = {}) {
+    /** All indexed tools keyed by name (supports duplicates). */
+    __publicField(this, "tools", /* @__PURE__ */ new Map());
+    /** Precomputed lightweight summaries keyed by document. */
+    __publicField(this, "toolSummaries", /* @__PURE__ */ new Map());
+    /** Pre-computed search text for keyword matching (lowercase), keyed by document. */
+    __publicField(this, "searchTexts", /* @__PURE__ */ new Map());
+    /** Pre-computed IDF values per token (computed once on build). */
+    __publicField(this, "idf", /* @__PURE__ */ new Map());
+    /** Per-tool TF vectors (Map<token, tf>). */
+    __publicField(this, "tfVectors", /* @__PURE__ */ new Map());
+    /** Optional: pre-computed embedding vectors per tool. */
+    __publicField(this, "embeddings", /* @__PURE__ */ new Map());
+    /** BM25: document lengths in tokens for each tool. */
+    __publicField(this, "docLengths", /* @__PURE__ */ new Map());
+    /** BM25: average document length across the entire index. */
+    __publicField(this, "avgDocLength", 0);
+    /** Cached total estimated token cost across all indexed tools. */
+    __publicField(this, "totalTokenCost", 0);
+    __publicField(this, "options");
+    this.options = {
+      embedFn: options.embedFn ?? void 0,
+      keywordWeight: options.keywordWeight ?? 0.4
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Indexing
+  // -----------------------------------------------------------------------
+  /**
+   * Build (or rebuild) the index from the given tool set.
+   * Call this after connecting / reconnecting to MCP servers.
+   */
+  async buildIndex(tools) {
+    this.tools.clear();
+    this.toolSummaries.clear();
+    this.searchTexts.clear();
+    this.idf.clear();
+    this.tfVectors.clear();
+    this.embeddings.clear();
+    this.docLengths.clear();
+    this.avgDocLength = 0;
+    this.totalTokenCost = 0;
+    const allTokenSets = /* @__PURE__ */ new Map();
+    let totalLength = 0;
+    for (const tool of tools) {
+      const docKey = this.getDocumentKey(tool);
+      if (!this.tools.has(tool.name)) {
+        this.tools.set(tool.name, []);
+      }
+      this.tools.get(tool.name).push(tool);
+      const estimatedTokens = _ToolIndex.estimateTokens(tool);
+      this.toolSummaries.set(docKey, {
+        name: tool.name,
+        description: tool.description ?? "",
+        serverName: tool.serverName,
+        sessionId: tool.sessionId,
+        estimatedTokens
+      });
+      this.totalTokenCost += estimatedTokens;
+      const text = this.buildSearchableText(tool).toLowerCase();
+      this.searchTexts.set(docKey, text);
+      const tokens = this.tokenize(text);
+      const tf = /* @__PURE__ */ new Map();
+      const uniqueTokens = /* @__PURE__ */ new Set();
+      for (const tok of tokens) {
+        tf.set(tok, (tf.get(tok) ?? 0) + 1);
+        uniqueTokens.add(tok);
+      }
+      const maxTf = Math.max(...tf.values(), 1);
+      for (const [k, v] of tf) {
+        tf.set(k, v / maxTf);
+      }
+      this.tfVectors.set(docKey, tf);
+      allTokenSets.set(docKey, uniqueTokens);
+      const length = tokens.length;
+      this.docLengths.set(docKey, length);
+      totalLength += length;
+    }
+    this.avgDocLength = totalLength / (tools.length || 1);
+    const totalDocs = tools.length || 1;
+    const dfCounts = /* @__PURE__ */ new Map();
+    for (const tokenSet of allTokenSets.values()) {
+      for (const tok of tokenSet) {
+        dfCounts.set(tok, (dfCounts.get(tok) ?? 0) + 1);
+      }
+    }
+    for (const [tok, df] of dfCounts) {
+      this.idf.set(tok, Math.log(totalDocs / df) + 1);
+    }
+    if (this.options.embedFn) {
+      const names = [...this.searchTexts.keys()];
+      const texts = names.map((n) => this.searchTexts.get(n));
+      try {
+        const vectors = await this.options.embedFn(texts);
+        for (let i = 0; i < names.length; i++) {
+          if (vectors[i]) {
+            this.embeddings.set(names[i], vectors[i]);
+          }
+        }
+      } catch (err) {
+        console.warn("[ToolIndex] Embedding generation failed, falling back to keyword-only search:", err);
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Search
+  // -----------------------------------------------------------------------
+  /**
+   * Search the index and return the top-K most relevant tools.
+   *
+   * When an `embedFn` is configured the final score is a weighted blend of
+   * keyword TF-IDF similarity and embedding cosine-similarity:
+   *
+   *   `score = keywordWeight × keyword_score + (1 - keywordWeight) × cosine_score`
+   */
+  async search(query, topK = 5) {
+    if (this.tools.size === 0) return [];
+    const queryLower = query.toLowerCase();
+    const queryTokens = this.tokenize(queryLower);
+    const keywordScores = /* @__PURE__ */ new Map();
+    const k1 = 1.2;
+    const b = 0.75;
+    for (const [docKey, docTf] of this.tfVectors) {
+      let score = 0;
+      const docLen = this.docLengths.get(docKey) ?? 0;
+      for (const tok of queryTokens) {
+        const tfVal = docTf.get(tok) ?? 0;
+        if (tfVal === 0) continue;
+        const idf = this.idf.get(tok) ?? 0;
+        const numerator = tfVal * (k1 + 1);
+        const denominator = tfVal + k1 * (1 - b + b * (docLen / this.avgDocLength));
+        score += idf * (numerator / denominator);
+      }
+      keywordScores.set(docKey, score);
+    }
+    let embeddingScores = null;
+    if (this.options.embedFn && this.embeddings.size > 0) {
+      try {
+        const [queryEmbedding] = await this.options.embedFn([queryLower]);
+        if (queryEmbedding) {
+          embeddingScores = /* @__PURE__ */ new Map();
+          for (const [docKey, vec] of this.embeddings) {
+            embeddingScores.set(docKey, this.cosineSimilarity(queryEmbedding, vec));
+          }
+        }
+      } catch {
+      }
+    }
+    const kw = this.options.keywordWeight;
+    const finalScores = [];
+    for (const docKey of this.toolSummaries.keys()) {
+      const kwScore = keywordScores.get(docKey) ?? 0;
+      const embScore = embeddingScores?.get(docKey) ?? 0;
+      const score = embeddingScores ? kw * kwScore + (1 - kw) * embScore : kwScore;
+      if (score > 0) {
+        finalScores.push({ docKey, score });
+      }
+    }
+    finalScores.sort((a, b2) => b2.score - a.score);
+    return finalScores.slice(0, topK).map(({ docKey }) => {
+      return this.toolSummaries.get(docKey);
+    });
+  }
+  /**
+   * Search tools using a regex pattern.
+   * Matches against name, description, and parameter metadata.
+   */
+  searchRegex(pattern, topK = 5) {
+    if (this.tools.size === 0) return [];
+    try {
+      let flags = "";
+      let cleanPattern = pattern;
+      if (pattern.includes("(?i)")) {
+        flags = "i";
+        cleanPattern = pattern.replace(/\(\?i\)/g, "");
+      }
+      const regex = new RegExp(cleanPattern, flags || void 0);
+      const matches = [];
+      for (const [docKey, text] of this.searchTexts) {
+        const tool = this.toolSummaries.get(docKey);
+        if (!tool) continue;
+        if (regex.test(text) || regex.test(tool.name)) {
+          let score = 1;
+          if (tool.name === cleanPattern) score = 10;
+          else if (tool.name.startsWith(cleanPattern)) score = 5;
+          else if (tool.name.toLowerCase().includes(cleanPattern.toLowerCase())) score = 2;
+          matches.push({ docKey, score });
+        }
+      }
+      matches.sort((a, b) => b.score - a.score);
+      return matches.slice(0, topK).map(({ docKey }) => {
+        return this.toolSummaries.get(docKey);
+      });
+    } catch (err) {
+      console.warn("[ToolIndex] Regex search failed:", err);
+      return [];
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Accessors
+  // -----------------------------------------------------------------------
+  /**
+   * Get tool definition(s) by name.
+   * If namespace is provided, it tries to match sessionId or serverName.
+   */
+  getTool(name, namespace) {
+    const list = this.tools.get(name) ?? [];
+    if (!namespace) return list;
+    return list.filter((t) => t.sessionId === namespace || t.serverName === namespace);
+  }
+  /** All indexed tool names. */
+  getToolNames() {
+    return [...this.tools.keys()];
+  }
+  /** Number of indexed tools (including duplicates). */
+  get size() {
+    let count = 0;
+    for (const list of this.tools.values()) {
+      count += list.length;
+    }
+    return count;
+  }
+  /** Total estimated token cost of all indexed tool schemas. */
+  getTotalTokenCost() {
+    return this.totalTokenCost;
+  }
+  // -----------------------------------------------------------------------
+  // Static Helpers
+  // -----------------------------------------------------------------------
+  /**
+   * Estimate token count of a tool's full schema (name + description + inputSchema).
+   *
+   * Uses character-class weighted counting calibrated against cl100k_base.
+   * Accuracy is typically within ±10% for JSON Schema payloads.
+   */
+  static estimateTokens(tool) {
+    const parts = [tool.name];
+    if (tool.description) parts.push(tool.description);
+    if (tool.inputSchema) parts.push(JSON.stringify(tool.inputSchema));
+    const text = parts.join(" ");
+    let weightedLen = 0;
+    for (let i = 0; i < text.length; i++) {
+      weightedLen += 1 / classifyChar(text[i]);
+    }
+    return Math.ceil(weightedLen / (1 / CALIBRATION_DIVISOR));
+  }
+  // -----------------------------------------------------------------------
+  // Internals
+  // -----------------------------------------------------------------------
+  /** Build a single searchable string from tool metadata. */
+  buildSearchableText(tool) {
+    const parts = [tool.name];
+    if (tool.description) parts.push(tool.description);
+    if (tool.inputSchema && typeof tool.inputSchema === "object") {
+      const schema = tool.inputSchema;
+      const props = schema.properties;
+      if (props) {
+        for (const [key, val] of Object.entries(props)) {
+          parts.push(key);
+          if (val && typeof val === "object" && val.description) {
+            parts.push(val.description);
+          }
+        }
+      }
+    }
+    return parts.join(" ");
+  }
+  getDocumentKey(tool) {
+    return `${tool.sessionId}::${tool.serverName}::${tool.name}`;
+  }
+  /** Simple whitespace + camelCase + snake_case tokenizer. */
+  tokenize(text) {
+    return text.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((t) => t.length > 1);
+  }
+  /** Cosine similarity between two vectors. */
+  cosineSimilarity(a, b) {
+    const len = Math.min(a.length, b.length);
+    let dot = 0;
+    let magA = 0;
+    let magB = 0;
+    for (let i = 0; i < len; i++) {
+      dot += a[i] * b[i];
+      magA += a[i] * a[i];
+      magB += b[i] * b[i];
+    }
+    const denom = Math.sqrt(magA) * Math.sqrt(magB);
+    return denom > 0 ? dot / denom : 0;
+  }
+};
+
+// src/shared/schema-compressor.ts
+init_cjs_shims();
+var SchemaCompressor = class _SchemaCompressor {
+  /**
+   * Convert a full MCP Tool definition to a compact summary.
+   *
+   * The compact form omits `inputSchema` entirely and optionally generates
+   * a short `parameterHint` from the schema's top-level properties.
+   */
+  static toCompact(tool) {
+    const compact = {
+      name: tool.name,
+      description: tool.description
+    };
+    if (tool.inputSchema && typeof tool.inputSchema === "object") {
+      const schema = tool.inputSchema;
+      if (schema.properties) {
+        const required = new Set(schema.required ?? []);
+        const parts = [];
+        for (const [key, val] of Object.entries(schema.properties)) {
+          const type = val?.type ?? "any";
+          const enumSuffix = val?.enum && Array.isArray(val.enum) ? `: ${val.enum.map((e) => `'${e}'`).join(" | ")}` : `: ${type}`;
+          parts.push(required.has(key) ? `${key}${enumSuffix}` : `${key}?${enumSuffix}`);
+        }
+        if (parts.length > 0) {
+          compact.parameterHint = `(${parts.join(", ")})`;
+        }
+      }
+    }
+    return compact;
+  }
+  /**
+   * Convert an array of tools to compact form, optionally limiting the count.
+   */
+  static compactAll(tools, options) {
+    const limited = options?.maxTools ? tools.slice(0, options.maxTools) : tools;
+    return limited.map((t) => _SchemaCompressor.toCompact(t));
+  }
+  /**
+   * Estimate token savings from using compact vs full tool schemas.
+   */
+  static estimateSavings(tools) {
+    let fullTokens = 0;
+    let compactTokens = 0;
+    for (const tool of tools) {
+      fullTokens += ToolIndex.estimateTokens(tool);
+      const compact = _SchemaCompressor.toCompact(tool);
+      const text = [compact.name, compact.description ?? "", compact.parameterHint ?? ""].join(" ");
+      compactTokens += Math.ceil(text.length / 4);
+    }
+    const saved = fullTokens - compactTokens;
+    const pct = fullTokens > 0 ? (saved / fullTokens * 100).toFixed(1) : "0.0";
+    return {
+      fullTokens,
+      compactTokens,
+      savedTokens: saved,
+      savingsPercent: `${pct}%`
+    };
+  }
+};
+
+// src/shared/meta-tools.ts
+init_cjs_shims();
+function createSearchToolDefinition() {
+  return {
+    name: "mcp_search_tool_bm25",
+    description: 'Search the catalog of available tools using BM25 natural language ranking. Returns tool names, descriptions, and server info. Use this FIRST to find relevant tools before calling them. Example queries: "database query", "send email", "github pull request".',
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "Natural language description of the capability you need."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results to return (default: 5, max: 20)."
+        }
+      },
+      required: ["query"]
+    }
+  };
+}
+function createRegexSearchToolDefinition() {
+  return {
+    name: "mcp_search_tool_regex",
+    description: 'Search the catalog of available tools using a Python-style regex pattern. Matches against tool names, descriptions, and parameter descriptions. Example patterns: "^github_", "weather", "(?i)slack".',
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: 'Regex pattern to search for (e.g., "^get_.*_data", "database").'
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of results to return (default: 5, max: 20)."
+        }
+      },
+      required: ["query"]
+    }
+  };
+}
+function createGetSchemaToolDefinition() {
+  return {
+    name: "mcp_get_tool_schema",
+    description: "Get the full input schema (parameters) for a specific tool. Call this after mcp_search_tool_bm25 to get the parameter details needed to call a tool correctly.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        toolName: {
+          type: "string",
+          description: "The exact tool name returned by mcp_search_tool_bm25."
+        },
+        serverName: {
+          type: "string",
+          description: "Optional: The server name provided in mcp_search_tool_bm25. Required if multiple tools have the same name."
+        }
+      },
+      required: ["toolName"]
+    }
+  };
+}
+function createExecuteToolDefinition() {
+  return {
+    name: "mcp_execute_tool",
+    description: "Execute a tool that was discovered via mcp_search_tool_bm25. You MUST call mcp_get_tool_schema first to know the correct parameters. Pass the exact tool name and its arguments.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        toolName: {
+          type: "string",
+          description: "The exact tool name from mcp_search_tool_bm25 results."
+        },
+        serverName: {
+          type: "string",
+          description: "Optional: The server name provided in mcp_search_tool_bm25. Required if multiple tools have the same name."
+        },
+        args: {
+          type: "object",
+          description: "Arguments matching the tool's inputSchema. Omit or pass {} if the tool takes no parameters.",
+          additionalProperties: true
+        }
+      },
+      required: ["toolName"]
+    }
+  };
+}
+async function executeMetaTool(toolName, args, router, callToolFn) {
+  const resolveToolSchema = (name, namespace) => {
+    try {
+      return { tool: router.getToolSchema(name, namespace) };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return {
+        error: {
+          content: [{ type: "text", text: errorMessage }],
+          isError: true
+        }
+      };
+    }
+  };
+  switch (toolName) {
+    case "mcp_search_tool_bm25": {
+      const query = String(args.query ?? "");
+      const limit = Math.min(Number(args.limit) || 5, 20);
+      const results = await router.searchTools(query, limit);
+      const text = results.length === 0 ? "No tools found matching your query. Try different keywords." : results.map(
+        (t, i) => `${i + 1}. **${t.name}** (server: ${t.serverName})
+   ${t.description}
+   Estimated tokens: ${t.estimatedTokens}`
+      ).join("\n");
+      return {
+        content: [{ type: "text", text }],
+        isError: false
+      };
+    }
+    case "mcp_search_tool_regex": {
+      const pattern = String(args.query ?? "");
+      const limit = Math.min(Number(args.limit) || 5, 20);
+      const results = await router.searchToolsRegex(pattern, limit);
+      const text = results.length === 0 ? "No tools matched your regex pattern. Try a broader pattern." : results.map(
+        (t, i) => `${i + 1}. **${t.name}** (server: ${t.serverName})
+   ${t.description}
+   Estimated tokens: ${t.estimatedTokens}`
+      ).join("\n");
+      return {
+        content: [{ type: "text", text }],
+        isError: false
+      };
+    }
+    case "mcp_get_tool_schema": {
+      const name = String(args.toolName ?? "");
+      const namespace = String(args.serverName ?? "") || void 0;
+      const { tool, error } = resolveToolSchema(name, namespace);
+      if (error) {
+        return error;
+      }
+      if (!tool) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Tool "${name}" not found. Use mcp_search_tool_bm25 to find available tools first.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const schema = {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(schema, null, 2) }],
+        isError: false
+      };
+    }
+    case "mcp_execute_tool": {
+      const targetToolName = String(args.toolName ?? "");
+      const namespace = String(args.serverName ?? "") || void 0;
+      const toolArgs = args.args ?? {};
+      if (!targetToolName) {
+        return {
+          content: [{ type: "text", text: 'Missing required parameter "toolName". Specify which tool to execute.' }],
+          isError: true
+        };
+      }
+      const { tool, error } = resolveToolSchema(targetToolName, namespace);
+      if (error) {
+        return error;
+      }
+      if (!tool) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Tool "${targetToolName}" not found. Use mcp_search_tool_bm25 to discover available tools first.`
+            }
+          ],
+          isError: true
+        };
+      }
+      if (!callToolFn) {
+        return {
+          content: [{ type: "text", text: "Tool execution is not available. No callToolFn was configured." }],
+          isError: true
+        };
+      }
+      try {
+        const result = await callToolFn(targetToolName, toolArgs, namespace);
+        if (result && typeof result === "object" && "content" in result) {
+          return result;
+        }
+        const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+        return {
+          content: [{ type: "text", text }],
+          isError: false
+        };
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Tool execution failed: ${errorMessage}` }],
+          isError: true
+        };
+      }
+    }
+    default:
+      return null;
+  }
+}
+function isMetaTool(toolName) {
+  return toolName === "mcp_search_tool_bm25" || toolName === "mcp_search_tool_regex" || toolName === "mcp_get_tool_schema" || toolName === "mcp_execute_tool";
+}
+function resolveMetaToolProxy(toolName, args) {
+  if (toolName === "mcp_execute_tool") {
+    const innerName = args?.toolName;
+    const innerArgs = args?.args;
+    return {
+      toolName: typeof innerName === "string" && innerName ? innerName : toolName,
+      args: innerArgs && typeof innerArgs === "object" && !Array.isArray(innerArgs) ? innerArgs : {}
+    };
+  }
+  const match = toolName.match(/(?:tool_[^_]+_)?(.+)$/);
+  const resolvedName = match?.[1] ?? toolName;
+  return { toolName: resolvedName, args: args ?? {} };
+}
+
+// src/shared/tool-router.ts
+var ToolRouter = class {
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+    __publicField(this, "index");
+    __publicField(this, "allTools", []);
+    __publicField(this, "groupsMap", /* @__PURE__ */ new Map());
+    __publicField(this, "strategy");
+    __publicField(this, "maxTools");
+    __publicField(this, "compactSchemas");
+    __publicField(this, "activeGroups");
+    __publicField(this, "customGroups");
+    __publicField(this, "initialized", false);
+    this.strategy = options.strategy ?? "all";
+    this.maxTools = options.maxTools ?? 40;
+    this.compactSchemas = options.compactSchemas ?? false;
+    this.activeGroups = new Set(options.activeGroups ?? []);
+    this.customGroups = options.groups;
+    this.index = new ToolIndex({
+      embedFn: options.embedFn,
+      keywordWeight: options.keywordWeight
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Core Public API
+  // -----------------------------------------------------------------------
+  /**
+   * Get tools filtered by the current strategy.
+   * This is the main method adapters should call.
+   *
+   * - `all`    → returns all tools (unchanged behavior)
+   * - `search` → returns only meta-tools (mcp_search_tool_bm25, mcp_get_tool_schema, mcp_execute_tool)
+   * - `groups` → returns tools from active groups only
+   */
+  async getFilteredTools() {
+    await this.ensureInitialized();
+    switch (this.strategy) {
+      case "search":
+        return this.getMetaToolDefinitions();
+      case "groups":
+        return this.getGroupFilteredTools();
+      case "all":
+      default:
+        if (this.compactSchemas) {
+          return this.allTools.map((t) => {
+            const compact = SchemaCompressor.toCompact(t);
+            return {
+              name: compact.name,
+              description: (compact.description ?? "") + (compact.parameterHint ? ` Parameters: ${compact.parameterHint}` : ""),
+              inputSchema: { type: "object", properties: {} }
+            };
+          });
+        }
+        return [...this.allTools];
+    }
+  }
+  /**
+   * Search tools by natural-language query.
+   * Works regardless of strategy.
+   */
+  async searchTools(query, topK) {
+    await this.ensureInitialized();
+    return this.index.search(query, topK ?? this.maxTools);
+  }
+  /**
+   * Search tools by regex pattern.
+   * Matches against name, description, and parameter metadata.
+   */
+  async searchToolsRegex(pattern, topK) {
+    await this.ensureInitialized();
+    return this.index.searchRegex(pattern, topK ?? this.maxTools);
+  }
+  /**
+   * Get the full tool definition by name.
+   * If tool name is ambiguous, use namespace to specify the server.
+   */
+  getToolSchema(toolName, namespace) {
+    const matches = this.index.getTool(toolName, namespace);
+    if (matches.length === 0) return void 0;
+    if (matches.length > 1) {
+      const servers = matches.map((m) => m.serverName).join(", ");
+      throw new Error(
+        `Tool "${toolName}" is provided by multiple servers: [${servers}]. Please specify the desired "serverName" as a namespace.`
+      );
+    }
+    return matches[0];
+  }
+  /**
+   * Get compact (schema-less) summaries for all tools.
+   */
+  getCompactTools() {
+    return SchemaCompressor.compactAll(this.allTools);
+  }
+  // -----------------------------------------------------------------------
+  // Group Management
+  // -----------------------------------------------------------------------
+  /** Get all available groups with their tool lists and active status. */
+  getGroups() {
+    return new Map(this.groupsMap);
+  }
+  /** Activate specific groups. Pass empty array to activate all. */
+  setActiveGroups(groups) {
+    this.activeGroups = new Set(groups);
+    for (const [name, info] of this.groupsMap) {
+      info.active = this.activeGroups.size === 0 || this.activeGroups.has(name);
+    }
+  }
+  /** Get the names of currently active groups. */
+  getActiveGroups() {
+    return [...this.activeGroups];
+  }
+  // -----------------------------------------------------------------------
+  // Stats & Introspection
+  // -----------------------------------------------------------------------
+  /** Total token cost of all tools if loaded without filtering. */
+  getTotalTokenCost() {
+    return this.index.getTotalTokenCost();
+  }
+  /** Estimate token cost of the currently filtered tool set. */
+  async getFilteredTokenCost() {
+    const tools = await this.getFilteredTools();
+    let total = 0;
+    for (const tool of tools) {
+      total += ToolIndex.estimateTokens(tool);
+    }
+    return total;
+  }
+  /** Get compression stats showing savings from current strategy. */
+  getCompressionStats() {
+    return SchemaCompressor.estimateSavings(this.allTools);
+  }
+  /** Number of total indexed tools. */
+  get totalToolCount() {
+    return this.allTools.length;
+  }
+  /** Change strategy at runtime. */
+  setStrategy(strategy) {
+    this.strategy = strategy;
+  }
+  /**
+   * Force a re-index of tools from all connected clients.
+   * Call this after adding/removing MCP server connections.
+   */
+  async refresh() {
+    this.initialized = false;
+    await this.ensureInitialized();
+  }
+  /**
+   * Execute a tool by routing to the correct MCP client.
+   * Used by the `mcp_execute_tool` meta-tool to proxy tool calls.
+   */
+  async callTool(toolName, args, namespace) {
+    await this.ensureInitialized();
+    const indexedTool = this.getToolSchema(toolName, namespace);
+    if (!indexedTool) {
+      throw new Error(
+        `Tool "${toolName}" not found${namespace ? ` on server "${namespace}"` : ""}. Use mcp_search_tool_bm25 or mcp_search_tool_regex to discover available tools.`
+      );
+    }
+    const clients = this.getClients();
+    const targetClient = clients.find(
+      (c) => typeof c.getSessionId === "function" && c.getSessionId() === indexedTool.sessionId
+    ) ?? clients.find((c) => c.isConnected());
+    if (!targetClient) {
+      throw new Error(`No connected client found for tool "${toolName}"`);
+    }
+    return await targetClient.callTool(toolName, args);
+  }
+  // -----------------------------------------------------------------------
+  // Internals
+  // -----------------------------------------------------------------------
+  /** Lazy initialization — fetches tools from all connected clients. */
+  async ensureInitialized() {
+    if (this.initialized) return;
+    this.allTools = await this.fetchAllTools();
+    await this.index.buildIndex(this.allTools);
+    this.buildGroups();
+    this.initialized = true;
+  }
+  /** Fetch tools from all connected MCP clients. */
+  async fetchAllTools() {
+    const clients = this.getClients();
+    const result = [];
+    for (const client of clients) {
+      if (!client.isConnected()) continue;
+      try {
+        const { tools } = await client.listTools();
+        const serverId = typeof client.getServerId === "function" ? client.getServerId() ?? "unknown" : "unknown";
+        const serverName = (typeof client.getServerName === "function" ? client.getServerName() : void 0) ?? serverId;
+        const sessionId = typeof client.getSessionId === "function" ? client.getSessionId() ?? "unknown" : "unknown";
+        for (const tool of tools) {
+          result.push({
+            ...tool,
+            serverName,
+            sessionId
+          });
+        }
+      } catch (err) {
+        console.warn("[ToolRouter] Failed to fetch tools from client:", err);
+      }
+    }
+    return result;
+  }
+  /** Resolve the client input to a flat array of ToolClient instances. */
+  getClients() {
+    if (Array.isArray(this.client)) {
+      return this.client;
+    }
+    if (typeof this.client.getClients === "function") {
+      return this.client.getClients();
+    }
+    return [this.client];
+  }
+  /** Build group map from custom config or auto-detect from server names. */
+  buildGroups() {
+    this.groupsMap.clear();
+    if (this.customGroups) {
+      for (const [name, tools] of Object.entries(this.customGroups)) {
+        this.groupsMap.set(name, {
+          tools,
+          active: this.activeGroups.size === 0 || this.activeGroups.has(name)
+        });
+      }
+    } else {
+      const serverTools = /* @__PURE__ */ new Map();
+      for (const tool of this.allTools) {
+        const group = tool.serverName;
+        if (!serverTools.has(group)) {
+          serverTools.set(group, []);
+        }
+        serverTools.get(group).push(tool.name);
+      }
+      for (const [serverName, tools] of serverTools) {
+        this.groupsMap.set(serverName, {
+          tools,
+          active: this.activeGroups.size === 0 || this.activeGroups.has(serverName)
+        });
+      }
+    }
+  }
+  /** Return only tools belonging to currently active groups. */
+  getGroupFilteredTools() {
+    const activeToolNames = /* @__PURE__ */ new Set();
+    for (const [, info] of this.groupsMap) {
+      if (info.active) {
+        for (const name of info.tools) {
+          activeToolNames.add(name);
+        }
+      }
+    }
+    const filtered = this.allTools.filter((t) => activeToolNames.has(t.name));
+    if (this.compactSchemas) {
+      return filtered.slice(0, this.maxTools).map((t) => {
+        const compact = SchemaCompressor.toCompact(t);
+        return {
+          name: compact.name,
+          description: (compact.description ?? "") + (compact.parameterHint ? ` Parameters: ${compact.parameterHint}` : ""),
+          inputSchema: { type: "object", properties: {} }
+        };
+      });
+    }
+    return filtered.slice(0, this.maxTools);
+  }
+  /** The 4 meta-tool definitions exposed in `search` strategy. */
+  getMetaToolDefinitions() {
+    return [
+      createSearchToolDefinition(),
+      createRegexSearchToolDefinition(),
+      createGetSchemaToolDefinition(),
+      createExecuteToolDefinition()
+    ];
+  }
+};
+
+exports.APP_HOST_DEFAULTS = APP_HOST_DEFAULTS;
 exports.AppHost = AppHost;
 exports.AuthenticationError = AuthenticationError;
 exports.ConfigurationError = ConfigurationError;
@@ -3697,6 +4745,7 @@ exports.DEFAULT_CLIENT_NAME = DEFAULT_CLIENT_NAME;
 exports.DEFAULT_CLIENT_URI = DEFAULT_CLIENT_URI;
 exports.DEFAULT_HEARTBEAT_INTERVAL_MS = DEFAULT_HEARTBEAT_INTERVAL_MS;
 exports.DEFAULT_LOGO_URI = DEFAULT_LOGO_URI;
+exports.DEFAULT_MCP_APP_CSP = DEFAULT_MCP_APP_CSP;
 exports.DEFAULT_POLICY_URI = DEFAULT_POLICY_URI;
 exports.DisposableStore = DisposableStore;
 exports.Emitter = Emitter;
@@ -3709,20 +4758,30 @@ exports.MultiSessionClient = MultiSessionClient;
 exports.NotConnectedError = NotConnectedError;
 exports.REDIS_KEY_PREFIX = REDIS_KEY_PREFIX;
 exports.RpcErrorCodes = RpcErrorCodes;
+exports.SANDBOX_PROXY_READY_METHOD = SANDBOX_PROXY_READY_METHOD;
+exports.SANDBOX_RESOURCE_READY_METHOD = SANDBOX_RESOURCE_READY_METHOD;
 exports.SESSION_TTL_SECONDS = SESSION_TTL_SECONDS;
 exports.SOFTWARE_ID = SOFTWARE_ID;
 exports.SOFTWARE_VERSION = SOFTWARE_VERSION;
 exports.SSEClient = SSEClient;
 exports.SSEConnectionManager = SSEConnectionManager;
 exports.STATE_EXPIRATION_MS = STATE_EXPIRATION_MS;
+exports.SchemaCompressor = SchemaCompressor;
 exports.SessionNotFoundError = SessionNotFoundError;
 exports.SessionValidationError = SessionValidationError;
 exports.StorageOAuthClientProvider = StorageOAuthClientProvider;
 exports.TOKEN_EXPIRY_BUFFER_MS = TOKEN_EXPIRY_BUFFER_MS;
 exports.ToolExecutionError = ToolExecutionError;
+exports.ToolIndex = ToolIndex;
+exports.ToolRouter = ToolRouter;
 exports.UnauthorizedError = UnauthorizedError;
+exports.createExecuteToolDefinition = createExecuteToolDefinition;
+exports.createGetSchemaToolDefinition = createGetSchemaToolDefinition;
 exports.createNextMcpHandler = createNextMcpHandler;
+exports.createRegexSearchToolDefinition = createRegexSearchToolDefinition;
 exports.createSSEHandler = createSSEHandler;
+exports.createSearchToolDefinition = createSearchToolDefinition;
+exports.executeMetaTool = executeMetaTool;
 exports.findToolByName = findToolByName;
 exports.getToolUiResourceUri = getToolUiResourceUri;
 exports.isCallToolSuccess = isCallToolSuccess;
@@ -3730,6 +4789,8 @@ exports.isConnectAuthRequired = isConnectAuthRequired;
 exports.isConnectError = isConnectError;
 exports.isConnectSuccess = isConnectSuccess;
 exports.isListToolsSuccess = isListToolsSuccess;
+exports.isMetaTool = isMetaTool;
+exports.resolveMetaToolProxy = resolveMetaToolProxy;
 exports.sanitizeServerLabel = sanitizeServerLabel;
 exports.storage = storage;
 //# sourceMappingURL=index.js.map