@mcp-ts/sdk 2.3.0 → 2.3.2

package/dist/{tool-router-CdX8e9bk.d.ts → tool-router-BMzhoNYt.d.ts}

@@ -355,6 +355,11 @@ declare class ToolRouter {
      * If tool name is ambiguous, use namespace to specify the server.
      */
     getToolSchema(toolName: string, namespace?: string, options?: ToolLookupOptions): IndexedTool | undefined;
+    /**
+     * Resolve the full tool definition by name, ensuring the router index has
+     * been initialized first.
+     */
+    resolveToolSchema(toolName: string, namespace?: string, options?: ToolLookupOptions): Promise<IndexedTool | undefined>;
     /**
      * Get compact (schema-less) summaries for all tools.
      */
@@ -395,6 +400,8 @@ declare class ToolRouter {
     private matchesDeferredTool;
     private matchesExcludedTool;
     private getDirectlyVisibleTools;
+    private getIndexedToolMatches;
+    private matchTools;
 }
 
 export { type CompactTool as C, type EmbedFn as E, type IndexedTool as I, SchemaCompressor as S, type ToolGroupInfo as T, ToolIndex as a, type ToolIndexOptions as b, type ToolListResult as c, ToolRouter as d, type ToolRouterClientInput as e, type ToolRouterOptions as f, type ToolRouterStrategy as g, type ToolSearchOptions as h, type ToolServerSummary as i, type ToolSummary as j };

package/dist/{tool-router-C8hIA-tg.d.mts → tool-router-BhHsvBfP.d.mts}

@@ -355,6 +355,11 @@ declare class ToolRouter {
      * If tool name is ambiguous, use namespace to specify the server.
      */
     getToolSchema(toolName: string, namespace?: string, options?: ToolLookupOptions): IndexedTool | undefined;
+    /**
+     * Resolve the full tool definition by name, ensuring the router index has
+     * been initialized first.
+     */
+    resolveToolSchema(toolName: string, namespace?: string, options?: ToolLookupOptions): Promise<IndexedTool | undefined>;
     /**
      * Get compact (schema-less) summaries for all tools.
      */
@@ -395,6 +400,8 @@ declare class ToolRouter {
     private matchesDeferredTool;
     private matchesExcludedTool;
     private getDirectlyVisibleTools;
+    private getIndexedToolMatches;
+    private matchTools;
 }
 
 export { type CompactTool as C, type EmbedFn as E, type IndexedTool as I, SchemaCompressor as S, type ToolGroupInfo as T, ToolIndex as a, type ToolIndexOptions as b, type ToolListResult as c, ToolRouter as d, type ToolRouterClientInput as e, type ToolRouterOptions as f, type ToolRouterStrategy as g, type ToolSearchOptions as h, type ToolServerSummary as i, type ToolSummary as j };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-ts/sdk",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "publishConfig": {
     "access": "public"
   },

package/src/shared/meta-tools.ts

@@ -235,12 +235,23 @@ export async function executeMetaTool(
   router: ToolRouter,
   callToolFn?: CallToolFn
 ): Promise<CallToolResult | null> {
-  const resolveToolSchema = (
+  const resolveToolSchema = async (
     name: string,
     namespace?: string,
     options?: ToolLookupOptions
-  ): { tool?: IndexedTool; error?: CallToolResult } => {
+  ): Promise<{ tool?: IndexedTool; error?: CallToolResult }> => {
     try {
+      if (typeof (router as ToolRouter & { resolveToolSchema?: unknown }).resolveToolSchema === 'function') {
+        return {
+          tool: await (router as ToolRouter & {
+            resolveToolSchema: (
+              toolName: string,
+              namespace?: string,
+              options?: ToolLookupOptions
+            ) => Promise<IndexedTool | undefined>;
+          }).resolveToolSchema(name, namespace, options),
+        };
+      }
       return { tool: router.getToolSchema(name, namespace, options) };
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : String(err);
@@ -307,8 +318,6 @@ export async function executeMetaTool(
       // Fast path: Check for select: prefix
       const selectMatch = query.match(/^select:(.+)$/i);
       if (selectMatch) {
-        await router.listTools({ serverId, serverName, limit: 1 });
-
         const requested = selectMatch[1]!
           .split(',')
           .map((s) => s.trim())
@@ -320,7 +329,7 @@ export async function executeMetaTool(
         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) {
@@ -410,7 +419,7 @@ export async function executeMetaTool(
     case 'mcp_get_tool_schema': {
       const name = String(args.toolName ?? '');
       const namespace = String(args.serverId ?? '') || undefined;
-      const { tool, error } = resolveToolSchema(name, namespace);
+      const { tool, error } = await resolveToolSchema(name, namespace);
 
       if (error) {
         return error;
@@ -461,7 +470,7 @@ export async function executeMetaTool(
       }
 
       // Verify the tool exists in our index
-      const { tool, error } = resolveToolSchema(targetToolName, namespace);
+      const { tool, error } = await resolveToolSchema(targetToolName, namespace);
       if (error) {
         return error;
       }

package/src/shared/tool-router.ts

@@ -274,7 +274,7 @@ export class ToolRouter {
     namespace?: string,
     options: ToolLookupOptions = {}
   ): IndexedTool | undefined {
-    const matches = this.index.getTool(toolName, namespace, options);
+    const matches = this.getIndexedToolMatches(toolName, namespace, options);
 
     if (matches.length === 0) return undefined;
 
@@ -289,6 +289,19 @@ export class ToolRouter {
     return matches[0];
   }
 
+  /**
+   * Resolve the full tool definition by name, ensuring the router index has
+   * been initialized first.
+   */
+  async resolveToolSchema(
+    toolName: string,
+    namespace?: string,
+    options: ToolLookupOptions = {}
+  ): Promise<IndexedTool | undefined> {
+    await this.ensureInitialized();
+    return this.getToolSchema(toolName, namespace, options);
+  }
+
   /**
    * Get compact (schema-less) summaries for all tools.
    */
@@ -533,6 +546,37 @@ export class ToolRouter {
   private getDirectlyVisibleTools(): IndexedTool[] {
     return this.allTools.filter((tool) => !this.matchesDeferredTool(tool) || this.matchesPinnedTool(tool.name));
   }
+
+  private getIndexedToolMatches(
+    toolName: string,
+    namespace?: string,
+    options: ToolLookupOptions = {}
+  ): IndexedTool[] {
+    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);
+  }
+
+  private matchTools(
+    tools: IndexedTool[],
+    namespace?: string,
+    options: ToolLookupOptions = {}
+  ): IndexedTool[] {
+    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: string): RegExp {