@mcp-ts/sdk 2.3.0 → 2.3.2

package/dist/index.mjs

@@ -4754,8 +4754,13 @@ function createExecuteToolDefinition() {
   };
 }
 async function executeMetaTool(toolName, args, router, callToolFn) {
-  const resolveToolSchema = (name, namespace, options) => {
+  const resolveToolSchema = async (name, namespace, options) => {
     try {
+      if (typeof router.resolveToolSchema === "function") {
+        return {
+          tool: await router.resolveToolSchema(name, namespace, options)
+        };
+      }
       return { tool: router.getToolSchema(name, namespace, options) };
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -4807,13 +4812,12 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
       const searchOptions = { serverId, serverName };
       const selectMatch = query.match(/^select:(.+)$/i);
       if (selectMatch) {
-        await router.listTools({ serverId, serverName, limit: 1 });
         const requested = selectMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
         const found = [];
         const errors = [];
         const namespace = serverId ?? serverName;
         for (const requestedToolName of requested) {
-          const { tool, error } = resolveToolSchema(requestedToolName, namespace, {
+          const { tool, error } = await resolveToolSchema(requestedToolName, namespace, {
             allowServerNameFragment: Boolean(serverName && !serverId)
           });
           if (error) {
@@ -4877,7 +4881,7 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
     case "mcp_get_tool_schema": {
       const name = String(args.toolName ?? "");
       const namespace = String(args.serverId ?? "") || void 0;
-      const { tool, error } = resolveToolSchema(name, namespace);
+      const { tool, error } = await resolveToolSchema(name, namespace);
       if (error) {
         return error;
       }
@@ -4919,7 +4923,7 @@ async function executeMetaTool(toolName, args, router, callToolFn) {
           isError: true
         };
       }
-      const { tool, error } = resolveToolSchema(targetToolName, namespace);
+      const { tool, error } = await resolveToolSchema(targetToolName, namespace);
       if (error) {
         return error;
       }
@@ -5086,7 +5090,7 @@ var ToolRouter = class {
    * If tool name is ambiguous, use namespace to specify the server.
    */
   getToolSchema(toolName, namespace, options = {}) {
-    const matches = this.index.getTool(toolName, namespace, options);
+    const matches = this.getIndexedToolMatches(toolName, namespace, options);
     if (matches.length === 0) return void 0;
     if (matches.length > 1) {
       const servers = matches.map((m) => m.serverId).join(", ");
@@ -5096,6 +5100,14 @@ var ToolRouter = class {
     }
     return matches[0];
   }
+  /**
+   * Resolve the full tool definition by name, ensuring the router index has
+   * been initialized first.
+   */
+  async resolveToolSchema(toolName, namespace, options = {}) {
+    await this.ensureInitialized();
+    return this.getToolSchema(toolName, namespace, options);
+  }
   /**
    * Get compact (schema-less) summaries for all tools.
    */
@@ -5285,6 +5297,23 @@ var ToolRouter = class {
   getDirectlyVisibleTools() {
     return this.allTools.filter((tool) => !this.matchesDeferredTool(tool) || this.matchesPinnedTool(tool.name));
   }
+  getIndexedToolMatches(toolName, namespace, options = {}) {
+    const indexedMatches = this.index.getTool(toolName, namespace, options);
+    if (indexedMatches.length > 0 || !this.matchesPinnedTool(toolName)) {
+      return indexedMatches;
+    }
+    return this.matchTools(this.pinnedTools.filter((tool) => tool.name === toolName), namespace, options);
+  }
+  matchTools(tools, namespace, options = {}) {
+    if (!namespace) return tools;
+    const exactMatches = tools.filter(
+      (tool) => tool.sessionId === namespace || tool.serverId === namespace
+    );
+    if (exactMatches.length > 0) return exactMatches;
+    if (!options.allowServerNameFragment) return [];
+    const namespaceLower = namespace.toLowerCase();
+    return tools.filter((tool) => tool.serverName.toLowerCase().includes(namespaceLower));
+  }
 };
 function globToRegExp(pattern) {
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");