@mcp-ts/sdk 1.6.2 → 2.1.0

package/dist/shared/index.d.mts

@@ -1,9 +1,9 @@
 export { D as Disposable, a as DisposableStore, E as Emitter, b as Event, M as McpConnectionEvent, c as McpConnectionState, d as McpObservabilityEvent } from '../events-CK3N--3g.mjs';
-export { A as AuthenticationError, C as ConfigurationError, a as ConnectionError, I as InvalidStateError, M as McpError, N as NotConnectedError, R as RpcErrorCode, b as RpcErrorCodes, S as SessionNotFoundError, c as SessionValidationError, T as ToolExecutionError, U as UnauthorizedError, s as sanitizeServerLabel } from '../utils-0qmYrqoa.mjs';
-import { v as ToolInfo } from '../types-rIuN1CQi.mjs';
-export { C as CallToolParams, a as CallToolRequest, b as CallToolResponse, c as ConnectAuthRequiredResponse, d as ConnectErrorResponse, e as ConnectParams, f as ConnectRequest, g as ConnectResponse, h as ConnectResult, i as ConnectSuccessResponse, D as DisconnectParams, j as DisconnectResult, F as FinishAuthParams, k as FinishAuthResult, G as GetPromptParams, L as ListPromptsResult, l as ListResourcesResult, m as ListToolsResponse, n as ListToolsRpcResult, M as McpRpcMethod, o as McpRpcParams, p as McpRpcRequest, q as McpRpcResponse, R as ReadResourceParams, r as RestoreSessionResult, S as SessionInfo, s as SessionListResult, t as SessionParams, T as ToolClient, u as ToolClientProvider, w as TransportType, x as isCallToolSuccess, y as isConnectAuthRequired, z as isConnectError, A as isConnectSuccess, B as isListToolsSuccess } from '../types-rIuN1CQi.mjs';
-import { e as ToolRouter } from '../tool-router-BVaV1udm.mjs';
-export { C as CompactTool, a as CompressionStats, E as EmbedFn, I as IndexedTool, S as SchemaCompressor, T as ToolGroupInfo, b as ToolIndex, c as ToolIndexOptions, d as ToolListResult, f as ToolRouterClientInput, g as ToolRouterOptions, h as ToolRouterStrategy, i as ToolSearchOptions, j as ToolServerSummary, k as ToolSummary } from '../tool-router-BVaV1udm.mjs';
+export { A as AuthenticationError, C as ConfigurationError, a as ConnectionError, I as InvalidStateError, M as McpError, N as NotConnectedError, R as RpcErrorCode, b as RpcErrorCodes, S as SessionNotFoundError, c as SessionValidationError, T as ToolExecutionError, U as UnauthorizedError, s as sanitizeServerLabel } from '../utils-DELRKQPU.mjs';
+import { v as ToolInfo } from '../types-CxFaaZrM.mjs';
+export { C as CallToolParams, a as CallToolRequest, b as CallToolResponse, c as ConnectAuthRequiredResponse, d as ConnectErrorResponse, e as ConnectParams, f as ConnectRequest, g as ConnectResponse, h as ConnectResult, i as ConnectSuccessResponse, D as DisconnectParams, j as DisconnectResult, F as FinishAuthParams, k as FinishAuthResult, G as GetPromptParams, l as GetSessionResult, L as ListPromptsResult, m as ListResourcesResult, n as ListToolsResponse, o as ListToolsRpcResult, M as McpRpcMethod, p as McpRpcParams, q as McpRpcRequest, r as McpRpcResponse, R as ReadResourceParams, S as SessionInfo, s as SessionListResult, t as SessionParams, T as ToolClient, u as ToolClientProvider, w as TransportType, x as isCallToolSuccess, y as isConnectAuthRequired, z as isConnectError, A as isConnectSuccess, B as isListToolsSuccess } from '../types-CxFaaZrM.mjs';
+import { d as ToolRouter } from '../tool-router-BkQnso27.mjs';
+export { C as CompactTool, E as EmbedFn, I as IndexedTool, S as SchemaCompressor, T as ToolGroupInfo, a as ToolIndex, b as ToolIndexOptions, c as ToolListResult, e as ToolRouterClientInput, f as ToolRouterOptions, g as ToolRouterStrategy, h as ToolSearchOptions, i as ToolServerSummary, j as ToolSummary } from '../tool-router-BkQnso27.mjs';
 import { Tool, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 
 /**
@@ -102,8 +102,8 @@ declare function createRegexSearchToolDefinition(): Tool;
  *
  * After discovering tools via `mcp_search_tools` or
  * `mcp_search_tool_regex`, the LLM calls this to load the full
- * inputSchema for a specific tool so it can construct the correct
- * arguments.
+ * input and output schemas for a specific tool so it can construct the
+ * correct arguments and plan around the result shape.
  */
 declare function createGetSchemaToolDefinition(): Tool;
 /**

package/dist/shared/index.d.ts

@@ -1,9 +1,9 @@
 export { D as Disposable, a as DisposableStore, E as Emitter, b as Event, M as McpConnectionEvent, c as McpConnectionState, d as McpObservabilityEvent } from '../events-CK3N--3g.js';
-export { A as AuthenticationError, C as ConfigurationError, a as ConnectionError, I as InvalidStateError, M as McpError, N as NotConnectedError, R as RpcErrorCode, b as RpcErrorCodes, S as SessionNotFoundError, c as SessionValidationError, T as ToolExecutionError, U as UnauthorizedError, s as sanitizeServerLabel } from '../utils-0qmYrqoa.js';
-import { v as ToolInfo } from '../types-rIuN1CQi.js';
-export { C as CallToolParams, a as CallToolRequest, b as CallToolResponse, c as ConnectAuthRequiredResponse, d as ConnectErrorResponse, e as ConnectParams, f as ConnectRequest, g as ConnectResponse, h as ConnectResult, i as ConnectSuccessResponse, D as DisconnectParams, j as DisconnectResult, F as FinishAuthParams, k as FinishAuthResult, G as GetPromptParams, L as ListPromptsResult, l as ListResourcesResult, m as ListToolsResponse, n as ListToolsRpcResult, M as McpRpcMethod, o as McpRpcParams, p as McpRpcRequest, q as McpRpcResponse, R as ReadResourceParams, r as RestoreSessionResult, S as SessionInfo, s as SessionListResult, t as SessionParams, T as ToolClient, u as ToolClientProvider, w as TransportType, x as isCallToolSuccess, y as isConnectAuthRequired, z as isConnectError, A as isConnectSuccess, B as isListToolsSuccess } from '../types-rIuN1CQi.js';
-import { e as ToolRouter } from '../tool-router-Dh2804tM.js';
-export { C as CompactTool, a as CompressionStats, E as EmbedFn, I as IndexedTool, S as SchemaCompressor, T as ToolGroupInfo, b as ToolIndex, c as ToolIndexOptions, d as ToolListResult, f as ToolRouterClientInput, g as ToolRouterOptions, h as ToolRouterStrategy, i as ToolSearchOptions, j as ToolServerSummary, k as ToolSummary } from '../tool-router-Dh2804tM.js';
+export { A as AuthenticationError, C as ConfigurationError, a as ConnectionError, I as InvalidStateError, M as McpError, N as NotConnectedError, R as RpcErrorCode, b as RpcErrorCodes, S as SessionNotFoundError, c as SessionValidationError, T as ToolExecutionError, U as UnauthorizedError, s as sanitizeServerLabel } from '../utils-DELRKQPU.js';
+import { v as ToolInfo } from '../types-CxFaaZrM.js';
+export { C as CallToolParams, a as CallToolRequest, b as CallToolResponse, c as ConnectAuthRequiredResponse, d as ConnectErrorResponse, e as ConnectParams, f as ConnectRequest, g as ConnectResponse, h as ConnectResult, i as ConnectSuccessResponse, D as DisconnectParams, j as DisconnectResult, F as FinishAuthParams, k as FinishAuthResult, G as GetPromptParams, l as GetSessionResult, L as ListPromptsResult, m as ListResourcesResult, n as ListToolsResponse, o as ListToolsRpcResult, M as McpRpcMethod, p as McpRpcParams, q as McpRpcRequest, r as McpRpcResponse, R as ReadResourceParams, S as SessionInfo, s as SessionListResult, t as SessionParams, T as ToolClient, u as ToolClientProvider, w as TransportType, x as isCallToolSuccess, y as isConnectAuthRequired, z as isConnectError, A as isConnectSuccess, B as isListToolsSuccess } from '../types-CxFaaZrM.js';
+import { d as ToolRouter } from '../tool-router-BP8TT9mI.js';
+export { C as CompactTool, E as EmbedFn, I as IndexedTool, S as SchemaCompressor, T as ToolGroupInfo, a as ToolIndex, b as ToolIndexOptions, c as ToolListResult, e as ToolRouterClientInput, f as ToolRouterOptions, g as ToolRouterStrategy, h as ToolSearchOptions, i as ToolServerSummary, j as ToolSummary } from '../tool-router-BP8TT9mI.js';
 import { Tool, CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 
 /**
@@ -102,8 +102,8 @@ declare function createRegexSearchToolDefinition(): Tool;
  *
  * After discovering tools via `mcp_search_tools` or
  * `mcp_search_tool_regex`, the LLM calls this to load the full
- * inputSchema for a specific tool so it can construct the correct
- * arguments.
+ * input and output schemas for a specific tool so it can construct the
+ * correct arguments and plan around the result shape.
  */
 declare function createGetSchemaToolDefinition(): Tool;
 /**

package/dist/shared/index.js

@@ -156,7 +156,7 @@ var ToolExecutionError = class extends McpError {
 };
 var RpcErrorCodes = {
   EXECUTION_ERROR: "EXECUTION_ERROR",
-  MISSING_IDENTITY: "MISSING_IDENTITY",
+  MISSING_USER_ID: "MISSING_USER_ID",
   UNAUTHORIZED: "UNAUTHORIZED",
   NO_CONNECTION: "NO_CONNECTION",
   UNKNOWN_METHOD: "UNKNOWN_METHOD",
@@ -213,17 +213,7 @@ function findToolByName(connections, toolName) {
 }
 
 // src/shared/tool-index.ts
-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 {
+var ToolIndex = class {
   constructor(options = {}) {
     /** All indexed tools keyed by name (supports duplicates). */
     __publicField(this, "tools", /* @__PURE__ */ new Map());
@@ -241,8 +231,6 @@ var ToolIndex = class _ToolIndex {
     __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,
@@ -265,7 +253,6 @@ var ToolIndex = class _ToolIndex {
     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) {
@@ -274,19 +261,17 @@ var ToolIndex = class _ToolIndex {
         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,
         serverId: tool.serverId,
-        sessionId: tool.sessionId,
-        estimatedTokens
+        sessionId: tool.sessionId
       });
-      this.totalTokenCost += estimatedTokens;
-      const text = this.buildSearchableText(tool).toLowerCase();
+      const rawText = this.buildSearchableText(tool);
+      const text = rawText.toLowerCase();
       this.searchTexts.set(docKey, text);
-      const tokens = this.tokenize(text);
+      const tokens = this.tokenize(rawText);
       const tf = /* @__PURE__ */ new Map();
       const uniqueTokens = /* @__PURE__ */ new Set();
       for (const tok of tokens) {
@@ -550,30 +535,6 @@ var ToolIndex = class _ToolIndex {
     }
     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
   // -----------------------------------------------------------------------
@@ -582,18 +543,74 @@ var ToolIndex = class _ToolIndex {
     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);
-          }
+      this.collectSchemaSearchText(tool.inputSchema, parts);
+    }
+    return parts.join(" ");
+  }
+  /** Recursively collect JSON Schema argument names and descriptions. */
+  collectSchemaSearchText(schema, parts, seen = /* @__PURE__ */ new WeakSet()) {
+    if (!schema || typeof schema !== "object") return;
+    if (seen.has(schema)) return;
+    seen.add(schema);
+    if (Array.isArray(schema)) {
+      for (const item of schema) {
+        this.collectSchemaSearchText(item, parts, seen);
+      }
+      return;
+    }
+    const schemaObject = schema;
+    this.pushStringValue(schemaObject.description, parts);
+    this.pushStringValue(schemaObject.title, parts);
+    const properties = schemaObject.properties;
+    if (properties && typeof properties === "object" && !Array.isArray(properties)) {
+      for (const [propertyName, propertySchema] of Object.entries(properties)) {
+        parts.push(propertyName);
+        this.collectSchemaSearchText(propertySchema, parts, seen);
+      }
+    }
+    const patternProperties = schemaObject.patternProperties;
+    if (patternProperties && typeof patternProperties === "object" && !Array.isArray(patternProperties)) {
+      for (const [propertyPattern, propertySchema] of Object.entries(patternProperties)) {
+        parts.push(propertyPattern);
+        this.collectSchemaSearchText(propertySchema, parts, seen);
+      }
+    }
+    const dependentSchemas = schemaObject.dependentSchemas;
+    if (dependentSchemas && typeof dependentSchemas === "object" && !Array.isArray(dependentSchemas)) {
+      for (const [propertyName, dependentSchema] of Object.entries(dependentSchemas)) {
+        parts.push(propertyName);
+        this.collectSchemaSearchText(dependentSchema, parts, seen);
+      }
+    }
+    for (const key of [
+      "items",
+      "additionalProperties",
+      "contains",
+      "propertyNames",
+      "if",
+      "then",
+      "else",
+      "not"
+    ]) {
+      this.collectSchemaSearchText(schemaObject[key], parts, seen);
+    }
+    for (const key of ["allOf", "anyOf", "oneOf", "prefixItems"]) {
+      this.collectSchemaSearchText(schemaObject[key], parts, seen);
+    }
+    for (const key of ["$defs", "definitions"]) {
+      const definitions = schemaObject[key];
+      if (definitions && typeof definitions === "object" && !Array.isArray(definitions)) {
+        for (const [definitionName, definitionSchema] of Object.entries(definitions)) {
+          parts.push(definitionName);
+          this.collectSchemaSearchText(definitionSchema, parts, seen);
         }
       }
     }
-    return parts.join(" ");
+  }
+  pushStringValue(value, parts) {
+    if (typeof value === "string" && value.trim()) {
+      parts.push(value);
+    }
   }
   getDocumentKey(tool) {
     return `${tool.sessionId}::${tool.serverId}::${tool.name}`;
@@ -614,7 +631,7 @@ var ToolIndex = class _ToolIndex {
   }
   /** 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);
+    return text.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((t) => t.length > 1);
   }
   /** Cosine similarity between two vectors. */
   cosineSimilarity(a, b) {
@@ -669,27 +686,6 @@ var SchemaCompressor = class _SchemaCompressor {
     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
@@ -768,7 +764,7 @@ function createRegexSearchToolDefinition() {
 function createGetSchemaToolDefinition() {
   return {
     name: "mcp_get_tool_schema",
-    description: "Get the full input schema (parameters) for a specific tool. Call this after mcp_search_tools to get the parameter details needed to call a tool correctly. Do NOT call the discovered tool directly; after reading the schema, call mcp_execute_tool.",
+    description: "Get the full input schema (parameters) and output schema (result shape) for a specific tool. Call this after mcp_search_tools to get the parameter details needed to call a tool correctly and understand what it returns. Do NOT call the discovered tool directly; after reading the schema, call mcp_execute_tool.",
     inputSchema: {
       type: "object",
       properties: {
@@ -885,7 +881,7 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
         const lines = [];
         if (found.length > 0) {
           lines.push(...found.map(
-            (t, i) => `${i + 1}. **${t.name}** (server: ${t.serverName}, serverId: ${t.serverId})
+            (t, i) => `${i + 1}. **${t.name}** (serverName: ${t.serverName}, serverId: ${t.serverId})
    ${t.description}`
           ));
         }
@@ -913,7 +909,7 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
         serverName: query || void 0
       });
       const text = servers.length === 0 ? "No connected servers found." : servers.map(
-        (server, i) => `${i + 1}. **${server.serverName}** (serverId: ${server.serverId}, sessionId: ${server.sessionId})
+        (server, i) => `${i + 1}. **${server.serverName}** (serverId: ${server.serverId})
    Tool count: ${server.toolCount}`
       ).join("\n");
       return {
@@ -953,6 +949,7 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
         name: tool.name,
         description: tool.description,
         inputSchema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
         executionInstructions: {
           nextTool: "mcp_execute_tool",
           toolName: tool.name,
@@ -1020,9 +1017,8 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
 }
 function formatToolSummaries(tools) {
   return tools.map(
-    (t, i) => `${i + 1}. **${t.name}** (server: ${t.serverName}, serverId: ${t.serverId})
-   ${t.description}
-   Estimated tokens: ${t.estimatedTokens}`
+    (t, i) => `${i + 1}. **${t.name}** (serverName: ${t.serverName}, serverId: ${t.serverId})
+   ${t.description}`
   );
 }
 function isMetaTool(toolName) {
@@ -1049,18 +1045,26 @@ var ToolRouter = class {
     this.options = options;
     __publicField(this, "index");
     __publicField(this, "allTools", []);
+    __publicField(this, "pinnedTools", []);
+    __publicField(this, "discoverableTools", []);
     __publicField(this, "groupsMap", /* @__PURE__ */ new Map());
     __publicField(this, "strategy");
     __publicField(this, "maxTools");
     __publicField(this, "compactSchemas");
     __publicField(this, "activeGroups");
     __publicField(this, "customGroups");
+    __publicField(this, "pinnedToolNames");
+    __publicField(this, "excludeToolMatchers");
     __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.pinnedToolNames = new Set(options.pinnedTools ?? []);
+    this.excludeToolMatchers = (options.excludeTools ?? []).map(
+      (pattern) => globToRegExp(pattern)
+    );
     this.index = new ToolIndex({
       embedFn: options.embedFn,
       keywordWeight: options.keywordWeight
@@ -1081,7 +1085,7 @@ var ToolRouter = class {
     await this.ensureInitialized();
     switch (this.strategy) {
       case "search":
-        return this.getMetaToolDefinitions();
+        return [...this.getMetaToolDefinitions(), ...this.pinnedTools];
       case "groups":
         return this.getGroupFilteredTools();
       case "all":
@@ -1165,26 +1169,6 @@ var ToolRouter = class {
   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;
@@ -1228,8 +1212,11 @@ var ToolRouter = class {
   /** 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);
+    const fetchedTools = await this.fetchAllTools();
+    this.allTools = fetchedTools.filter((tool) => !this.matchesExcludedTool(tool.name));
+    this.pinnedTools = this.allTools.filter((tool) => this.matchesPinnedTool(tool.name));
+    this.discoverableTools = this.allTools.filter((tool) => !this.matchesPinnedTool(tool.name));
+    await this.index.buildIndex(this.discoverableTools);
     this.buildGroups();
     this.initialized = true;
   }
@@ -1328,7 +1315,18 @@ var ToolRouter = class {
       createExecuteToolDefinition()
     ];
   }
+  matchesPinnedTool(toolName) {
+    return this.pinnedToolNames.has(toolName);
+  }
+  matchesExcludedTool(toolName) {
+    return this.excludeToolMatchers.some((matcher) => matcher.test(toolName));
+  }
 };
+function globToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const regexPattern = `^${escaped.replace(/\*/g, ".*")}$`;
+  return new RegExp(regexPattern);
+}
 
 exports.AuthenticationError = AuthenticationError;
 exports.ConfigurationError = ConfigurationError;