Fix the executeTool function to use tool meta data instead of trying to reverse engineer from toolName

Author: stevenpeh-tw

mcp-openapi/src/package-info.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
 
 // Interface for package.json structure
 interface PackageInfo {
@@ -18,15 +19,19 @@ function loadPackageInfo(): PackageInfo {
     return packageInfo;
   }
 
+  // Get ES module equivalent of __dirname
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+
+  // Look for package.json in the project root
+  // Try multiple possible locations to be robust
+  const possiblePaths = [
+    path.resolve(process.cwd(), 'package.json'),
+    path.resolve(__dirname, '..', 'package.json'),
+    path.resolve(__dirname, '..', '..', 'package.json')
+  ];
+
   try {
-    // Look for package.json in the project root
-    // Try multiple possible locations to be robust
-    const possiblePaths = [
-      path.resolve(process.cwd(), 'package.json'),
-      path.resolve(__dirname, '..', 'package.json'),
-      path.resolve(__dirname, '..', '..', 'package.json')
-    ];
-    
     let packageJsonPath: string | null = null;
     for (const possiblePath of possiblePaths) {
       if (fs.existsSync(possiblePath)) {

mcp-openapi/src/server.ts

@@ -215,13 +215,13 @@ export class MCPOpenAPIServer {
     // Add server info resource for querying capabilities
     this.addServerInfoResource();
 
+    // Update telemetry context with the newly generated tools and resources
+    this.updateTelemetryContext();
+
     // DEBUG: Show detailed MCP capabilities generated from OpenAPI specs
     this.telemetry.printMCPCapabilitiesDebug(
       this.getSpecFileName.bind(this),
-      this.determineMCPType.bind(this),
-      this.getToolName.bind(this),
-      this.hasOverride.bind(this),
-      this.isHttpMethod.bind(this)
+      this.hasOverride.bind(this)
     );
   }
 
@@ -390,17 +390,7 @@ export class MCPOpenAPIServer {
     return toolName;
   }
 
-  private getActualHttpMethod(abbreviatedMethod: string): string {
-    // Convert abbreviated method names (from tool names) back to HTTP methods
-    const methodMap: Record<string, string> = {
-      'get': 'get',
-      'create': 'post',
-      'update': 'put',
-      'patch': 'patch',
-      'delete': 'delete'
-    };
-    return methodMap[abbreviatedMethod] || abbreviatedMethod;
-  }
+
 
   private hasOverride(specId: string, path: string, method: string): boolean {
     return this.config.overrides.some(o => 
@@ -478,7 +468,13 @@ export class MCPOpenAPIServer {
     return {
       name: toolName,
       description: description,
-      inputSchema: this.buildInputSchema(operation, pathPattern)
+      inputSchema: this.buildInputSchema(operation, pathPattern),
+      _metadata: {
+        specId,
+        pathPattern,
+        method,
+        operation
+      }
     };
   }
 
@@ -667,26 +663,10 @@ export class MCPOpenAPIServer {
       method = toolOverride.method;
       specId = toolOverride.specId;
     } else {
-      // Parse tool name to get spec, method, and path (fallback for non-override tools)
-      const toolParts = toolName.split('_');
-      specId = toolParts[0];
-      const abbreviatedMethod = toolParts[1];
-      
-      // Convert abbreviated method back to actual HTTP method
-      method = this.getActualHttpMethod(abbreviatedMethod);
-      const pathParts = toolParts.slice(2);
-      
-      // Find the original path pattern
-      const spec = this.specs.get(specId);
-      if (!spec) {
-        throw new Error(`Spec ${specId} not found`);
-      }
-
-      const foundPattern = this.findPathPattern(spec, pathParts);
-      if (!foundPattern) {
-        throw new Error(`Could not determine path pattern for tool ${toolName}`);
-      }
-      pathPattern = foundPattern;
+      // Use stored metadata instead of parsing tool name
+      specId = tool._metadata.specId;
+      pathPattern = tool._metadata.pathPattern;
+      method = tool._metadata.method;
     }
 
     // Verify spec exists
@@ -838,17 +818,7 @@ export class MCPOpenAPIServer {
     }
   }
 
-  private findPathPattern(spec: OpenAPISpec, pathParts: string[]): string | null {
-    // This is a simplified approach - in practice, you might want more sophisticated matching
-    for (const pathPattern of Object.keys(spec.paths)) {
-      const sanitized = this.sanitizePath(pathPattern);
-      const reconstructed = pathParts.join('_');
-      if (sanitized.includes(reconstructed) || reconstructed.includes(sanitized.replace(/^_+|_+$/g, ''))) {
-        return pathPattern;
-      }
-    }
-    return null;
-  }
+
 
   private async readResource(uri: string, userContext?: { token?: string }, resourceParams?: Record<string, any>) {
     // Handle special server info resource

mcp-openapi/src/telemetry.ts

@@ -110,10 +110,7 @@ export class Telemetry {
 
   printMCPCapabilitiesDebug(
     getSpecFileName: (specId: string) => string,
-    determineMCPType: (specId: string, path: string, method: string, operation: any) => 'tool' | 'resource',
-    getToolName: (specId: string, pathPattern: string, method: string, operation: any) => string,
-    hasOverride: (specId: string, path: string, method: string) => boolean,
-    isHttpMethod: (method: string) => boolean
+    hasOverride: (specId: string, path: string, method: string) => boolean
   ): void {
     if (!this.context.options.verbose) {
       return;
@@ -135,46 +132,42 @@ export class Telemetry {
       isOverridden: boolean;
     }> = [];
 
-    // Collect tool details
-    for (const [specId, spec] of this.context.specs) {
+    // Collect tool details - use actual created tools with their metadata
+    for (const tool of this.context.tools) {
+      const { specId, pathPattern, method } = tool._metadata;
       const specFile = getSpecFileName(specId);
 
-      for (const [pathPattern, pathItem] of Object.entries(spec.paths)) {
-        for (const [method, operation] of Object.entries(pathItem)) {
-          if (isHttpMethod(method)) {
-            const mcpType = determineMCPType(specId, pathPattern, method, operation);
-            
-            if (mcpType === 'tool') {
-              const tool = this.context.tools.find(t => t.name === getToolName(specId, pathPattern, method, operation));
-              if (tool) {
-                generationDetails.push({
-                  specId,
-                  specFile,
-                  path: pathPattern,
-                  method: method.toUpperCase(),
-                  mcpType: 'tool',
-                  mcpName: tool.name,
-                  description: tool.description,
-                  isOverridden: hasOverride(specId, pathPattern, method)
-                });
-              }
-            } else if (mcpType === 'resource') {
-              const resource = this.context.resources.find(r => r.uri === `${specId}://${pathPattern.startsWith('/') ? pathPattern.substring(1) : pathPattern}`);
-              if (resource) {
-                generationDetails.push({
-                  specId,
-                  specFile,
-                  path: pathPattern,
-                  method: method.toUpperCase(),
-                  mcpType: 'resource',
-                  mcpName: resource.name,
-                  description: resource.description,
-                  isOverridden: hasOverride(specId, pathPattern, method)
-                });
-              }
-            }
-          }
-        }
+      generationDetails.push({
+        specId,
+        specFile,
+        path: pathPattern,
+        method: method.toUpperCase(),
+        mcpType: 'tool',
+        mcpName: tool.name,
+        description: tool.description,
+        isOverridden: hasOverride(specId, pathPattern, method)
+      });
+    }
+
+    // Collect resource details - use actual created resources
+    for (const resource of this.context.resources) {
+      // Extract specId and path from resource URI (format: specId://path)
+      const uriParts = resource.uri.split('://');
+      if (uriParts.length === 2) {
+        const specId = uriParts[0];
+        const pathPattern = '/' + uriParts[1];
+        const specFile = getSpecFileName(specId);
+        
+        generationDetails.push({
+          specId,
+          specFile,
+          path: pathPattern,
+          method: 'GET', // Resources are typically GET operations
+          mcpType: 'resource',
+          mcpName: resource.name,
+          description: resource.description,
+          isOverridden: false // For now, assume resources don't have overrides in this context
+        });
       }
     }
 

mcp-openapi/src/types.ts

@@ -56,6 +56,13 @@ export interface MCPTool {
     properties: Record<string, any>;
     required: string[];
   };
+  // Metadata for tool execution (not exposed in MCP protocol)
+  _metadata: {
+    specId: string;
+    pathPattern: string;
+    method: string;
+    operation: any;
+  };
 }
 
 export interface MCPResource {