@ivotoby/openapi-mcp-server 1.6.1 → 1.8.0

package/dist/cli.js

@@ -14374,14 +14374,17 @@ var WORD_ABBREVIATIONS = {
 // src/utils/tool-id.ts
 function parseToolId(toolId) {
   const [method, pathPart] = toolId.split("::", 2);
-  const path = pathPart ? "/" + pathPart.replace(/-/g, "/") : "";
-  return { method, path };
+  if (!pathPart) {
+    return { method, path: "" };
+  }
+  const path = pathPart.replace(/__/g, "/");
+  return { method, path: "/" + path };
 }
 function sanitizeForToolId(input) {
-  return input.replace(/[^A-Za-z0-9_-]/g, "").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  return input.replace(/[^A-Za-z0-9_-]/g, "").replace(/_{3,}/g, "__").replace(/^[_-]+|[_-]+$/g, "");
 }
 function generateToolId(method, path) {
-  const cleanPath = path.replace(/^\//, "").replace(/\{([^}]+)\}/g, "$1").replace(/\//g, "-");
+  const cleanPath = path.replace(/^\//, "").replace(/\/+/g, "/").replace(/\{([^}]+)\}/g, "$1").replace(/\//g, "__");
   const sanitizedPath = sanitizeForToolId(cleanPath);
   return `${method.toUpperCase()}::${sanitizedPath}`;
 }
@@ -14509,8 +14512,79 @@ var OpenAPISpecLoader = class {
         visited.add(name);
         return this.inlineSchema(comp, components, visited);
       }
+      return {};
     }
     const schemaObj = schema2;
+    if (schemaObj.allOf) {
+      const mergedSchema = {
+        type: "object",
+        properties: {},
+        required: []
+      };
+      for (const subSchema of schemaObj.allOf) {
+        const inlinedSubSchema = this.inlineSchema(
+          subSchema,
+          components,
+          new Set(visited)
+        );
+        if (inlinedSubSchema.properties) {
+          mergedSchema.properties = {
+            ...mergedSchema.properties,
+            ...inlinedSubSchema.properties
+          };
+        }
+        if (inlinedSubSchema.required) {
+          mergedSchema.required = [...mergedSchema.required || [], ...inlinedSubSchema.required];
+        }
+        for (const [key, value] of Object.entries(inlinedSubSchema)) {
+          if (key !== "properties" && key !== "required" && !(key in mergedSchema)) {
+            ;
+            mergedSchema[key] = value;
+          }
+        }
+      }
+      if (mergedSchema.required && mergedSchema.required.length === 0) {
+        delete mergedSchema.required;
+      }
+      return mergedSchema;
+    }
+    if (schemaObj.oneOf) {
+      const inlinedOneOf = schemaObj.oneOf.map(
+        (subSchema) => this.inlineSchema(
+          subSchema,
+          components,
+          new Set(visited)
+        )
+      );
+      return {
+        ...schemaObj,
+        oneOf: inlinedOneOf
+      };
+    }
+    if (schemaObj.anyOf) {
+      const inlinedAnyOf = schemaObj.anyOf.map(
+        (subSchema) => this.inlineSchema(
+          subSchema,
+          components,
+          new Set(visited)
+        )
+      );
+      return {
+        ...schemaObj,
+        anyOf: inlinedAnyOf
+      };
+    }
+    if (schemaObj.not) {
+      const inlinedNot = this.inlineSchema(
+        schemaObj.not,
+        components,
+        new Set(visited)
+      );
+      return {
+        ...schemaObj,
+        not: inlinedNot
+      };
+    }
     if (schemaObj.type === "object" && schemaObj.properties) {
       const newProps = {};
       for (const [propName, propSchema] of Object.entries(schemaObj.properties)) {
@@ -14523,14 +14597,12 @@ var OpenAPISpecLoader = class {
       return { ...schemaObj, properties: newProps };
     }
     if (schemaObj.type === "array" && schemaObj.items) {
-      return {
-        ...schemaObj,
-        items: this.inlineSchema(
-          schemaObj.items,
-          components,
-          new Set(visited)
-        )
-      };
+      const inlinedItems = this.inlineSchema(
+        schemaObj.items,
+        components,
+        new Set(visited)
+      );
+      return { ...schemaObj, items: inlinedItems };
     }
     return schemaObj;
   }
@@ -14561,6 +14633,24 @@ var OpenAPISpecLoader = class {
     }
     return void 0;
   }
+  /**
+   * Extract the primary resource name from an OpenAPI path
+   * Examples:
+   * - "/users" -> "users"
+   * - "/users/{id}" -> "users"
+   * - "/api/v1/users/{id}/posts" -> "posts"
+   * - "/health" -> "health"
+   */
+  extractResourceName(path) {
+    const segments = path.replace(/^\//, "").split("/");
+    for (let i = segments.length - 1; i >= 0; i--) {
+      const segment = segments[i];
+      if (!segment.includes("{") && !segment.includes("}") && segment.length > 0) {
+        return segment;
+      }
+    }
+    return segments[0] || void 0;
+  }
   /**
    * Parse an OpenAPI specification into a map of tools
    */
@@ -14568,6 +14658,41 @@ var OpenAPISpecLoader = class {
     const tools = /* @__PURE__ */ new Map();
     for (const [path, pathItem] of Object.entries(spec.paths)) {
       if (!pathItem) continue;
+      const pathLevelParameters = [];
+      if (pathItem.parameters) {
+        for (const param of pathItem.parameters) {
+          let paramObj;
+          if ("$ref" in param && typeof param.$ref === "string") {
+            const refMatch = param.$ref.match(/^#\/components\/parameters\/(.+)$/);
+            if (refMatch && spec.components?.parameters) {
+              const paramNameFromRef = refMatch[1];
+              const resolvedParam = spec.components.parameters[paramNameFromRef];
+              if (resolvedParam && "name" in resolvedParam && "in" in resolvedParam) {
+                paramObj = resolvedParam;
+              } else {
+                console.warn(
+                  `Could not resolve path-level parameter reference or invalid structure: ${param.$ref}`
+                );
+                continue;
+              }
+            } else {
+              console.warn(`Could not parse path-level parameter reference: ${param.$ref}`);
+              continue;
+            }
+          } else if ("name" in param && "in" in param) {
+            paramObj = param;
+          } else {
+            console.warn(
+              "Skipping path-level parameter due to missing 'name' or 'in' properties and not being a valid $ref:",
+              param
+            );
+            continue;
+          }
+          if (paramObj) {
+            pathLevelParameters.push(paramObj);
+          }
+        }
+      }
       for (const [method, operation] of Object.entries(pathItem)) {
         if (method === "parameters" || !operation) continue;
         if (!["get", "post", "put", "patch", "delete", "options", "head"].includes(
@@ -14586,10 +14711,20 @@ var OpenAPISpecLoader = class {
           inputSchema: {
             type: "object",
             properties: {}
-          }
+          },
+          // Add metadata for filtering
+          tags: op.tags || [],
+          httpMethod: method.toUpperCase(),
+          resourceName: this.extractResourceName(path),
+          originalPath: path
         };
         tool["x-original-path"] = path;
         const requiredParams = [];
+        const parameterMap = /* @__PURE__ */ new Map();
+        for (const pathParam of pathLevelParameters) {
+          const key = `${pathParam.name}::${pathParam.in}`;
+          parameterMap.set(key, pathParam);
+        }
         if (op.parameters) {
           for (const param of op.parameters) {
             let paramObj;
@@ -14619,37 +14754,39 @@ var OpenAPISpecLoader = class {
               );
               continue;
             }
-            if (!paramObj) {
-              console.warn("Failed to process a parameter (paramObj is undefined):", param);
-              continue;
+            if (paramObj) {
+              const key = `${paramObj.name}::${paramObj.in}`;
+              parameterMap.set(key, paramObj);
             }
-            if (paramObj.schema) {
-              const paramSchema = this.inlineSchema(
-                paramObj.schema,
-                spec.components?.schemas,
-                /* @__PURE__ */ new Set()
-              );
-              const paramDef = {
-                description: paramObj.description || `${paramObj.name} parameter`,
-                "x-parameter-location": paramObj.in
-                // Store parameter location (path, query, etc.)
-              };
-              const paramType = this.determineParameterType(paramSchema, paramObj.name);
-              if (paramType !== void 0) {
-                paramDef.type = paramType;
-              }
-              if (typeof paramSchema === "object" && paramSchema !== null) {
-                for (const [key, value] of Object.entries(paramSchema)) {
-                  if (key === "description" && paramDef.description) continue;
-                  if (key === "type" && paramDef.type) continue;
-                  paramDef[key] = value;
-                }
-              }
-              tool.inputSchema.properties[paramObj.name] = paramDef;
-              if (paramObj.required === true) {
-                requiredParams.push(paramObj.name);
+          }
+        }
+        for (const paramObj of parameterMap.values()) {
+          if (paramObj.schema) {
+            const paramSchema = this.inlineSchema(
+              paramObj.schema,
+              spec.components?.schemas,
+              /* @__PURE__ */ new Set()
+            );
+            const paramDef = {
+              description: paramObj.description || `${paramObj.name} parameter`,
+              "x-parameter-location": paramObj.in
+              // Store parameter location (path, query, etc.)
+            };
+            const paramType = this.determineParameterType(paramSchema, paramObj.name);
+            if (paramType !== void 0) {
+              paramDef.type = paramType;
+            }
+            if (typeof paramSchema === "object" && paramSchema !== null) {
+              for (const [key, value] of Object.entries(paramSchema)) {
+                if (key === "description" && paramDef.description) continue;
+                if (key === "type" && paramDef.type) continue;
+                paramDef[key] = value;
               }
             }
+            tool.inputSchema.properties[paramObj.name] = paramDef;
+            if (paramObj.required === true) {
+              requiredParams.push(paramObj.name);
+            }
           }
         }
         if (op.requestBody && "content" in op.requestBody) {
@@ -14667,7 +14804,24 @@ var OpenAPISpecLoader = class {
               spec.components?.schemas,
               /* @__PURE__ */ new Set()
             );
-            if (inlinedSchema.type === "object" && inlinedSchema.properties) {
+            if (inlinedSchema.oneOf || inlinedSchema.anyOf) {
+              const existingProperties = tool.inputSchema.properties || {};
+              const hasExistingProperties = Object.keys(existingProperties).length > 0;
+              if (hasExistingProperties) {
+                const objectSchema = {
+                  type: "object",
+                  properties: existingProperties
+                };
+                if (tool.inputSchema.required) {
+                  objectSchema.required = tool.inputSchema.required;
+                }
+                tool.inputSchema = {
+                  allOf: [objectSchema, inlinedSchema]
+                };
+              } else {
+                tool.inputSchema = inlinedSchema;
+              }
+            } else if (inlinedSchema.type === "object" && inlinedSchema.properties) {
               for (const [propName, propSchema] of Object.entries(inlinedSchema.properties)) {
                 const paramName = tool.inputSchema.properties[propName] ? `body_${propName}` : propName;
                 tool.inputSchema.properties[paramName] = propSchema;
@@ -14704,6 +14858,18 @@ var OpenAPISpecLoader = class {
     });
     return combinedParts.map((p) => p.trim()).filter((p) => p.length > 0);
   }
+  // Helper to split only by underscore and camelCase, but not by numbers
+  // Used when abbreviation is disabled to preserve number-letter combinations like "web3"
+  splitCombinedWithoutNumbers(input) {
+    const underscoreParts = input.split("_");
+    let combinedParts = [];
+    underscoreParts.forEach((part) => {
+      const spacedPart = part.replace(/([A-Z]+)/g, " $1").replace(/([A-Z][a-z])/g, " $1");
+      const splitParts = spacedPart.split(" ").filter((p) => p.length > 0);
+      combinedParts = combinedParts.concat(splitParts);
+    });
+    return combinedParts.map((p) => p.trim()).filter((p) => p.length > 0);
+  }
   _initialSanitizeAndValidate(originalId, maxLength) {
     if (!originalId || originalId.trim().length === 0)
       return { currentName: "", originalWasLong: false, errorName: "unnamed-tool" };
@@ -14796,7 +14962,7 @@ var OpenAPISpecLoader = class {
     if (errorName) return errorName;
     let processedName;
     if (this.disableAbbreviation) {
-      processedName = this.splitCombined(sanitizedName).join("-");
+      processedName = this.splitCombinedWithoutNumbers(sanitizedName).join("-");
     } else {
       processedName = this._performSemanticAbbreviation(sanitizedName);
       processedName = this._applyVowelRemovalIfOverLength(processedName, maxLength);
@@ -14875,46 +15041,62 @@ var ToolsManager = class {
       this.tools = this.createDynamicTools();
       return;
     }
+    if (this.config.toolsMode === "explicit") {
+      const rawTools2 = this.specLoader.parseOpenAPISpec(spec);
+      const filtered2 = /* @__PURE__ */ new Map();
+      if (this.config.includeTools && this.config.includeTools.length > 0) {
+        const includeToolsLower2 = this.config.includeTools.map((t) => t.toLowerCase());
+        for (const [toolId, tool] of rawTools2.entries()) {
+          const toolIdLower = toolId.toLowerCase();
+          const toolNameLower = tool.name.toLowerCase();
+          if (includeToolsLower2.includes(toolIdLower) || includeToolsLower2.includes(toolNameLower)) {
+            filtered2.set(toolId, tool);
+          }
+        }
+      }
+      this.tools = filtered2;
+      for (const [toolId, tool] of this.tools.entries()) {
+        console.error(`Registered tool: ${toolId} (${tool.name})`);
+      }
+      return;
+    }
     const rawTools = this.specLoader.parseOpenAPISpec(spec);
     const filtered = /* @__PURE__ */ new Map();
     const includeToolsLower = this.config.includeTools?.map((t) => t.toLowerCase()) || [];
     const includeOperationsLower = this.config.includeOperations?.map((op) => op.toLowerCase()) || [];
-    const includeResourcesLower = this.config.includeResources || [];
+    const includeResourcesLower = this.config.includeResources?.map((res) => res.toLowerCase()) || [];
     const includeTagsLower = this.config.includeTags?.map((tag) => tag.toLowerCase()) || [];
-    const resourcePathsLower = includeResourcesLower.map((res) => ({
-      exact: `/${res}`.toLowerCase(),
-      prefix: `/${res}/`.toLowerCase()
-    }));
     for (const [toolId, tool] of rawTools.entries()) {
+      const extendedTool = tool;
       if (includeToolsLower.length > 0) {
         const toolIdLower = toolId.toLowerCase();
         const toolNameLower = tool.name.toLowerCase();
         if (!includeToolsLower.includes(toolIdLower) && !includeToolsLower.includes(toolNameLower)) {
           continue;
         }
+        filtered.set(toolId, tool);
+        continue;
       }
       if (includeOperationsLower.length > 0) {
-        const { method } = this.parseToolId(toolId);
-        if (!includeOperationsLower.includes(method.toLowerCase())) {
+        const httpMethod = typeof extendedTool.httpMethod === "string" ? extendedTool.httpMethod.toLowerCase() : void 0;
+        if (!httpMethod || !includeOperationsLower.includes(httpMethod)) {
           continue;
         }
       }
-      if (resourcePathsLower.length > 0) {
-        const { path } = this.parseToolId(toolId);
-        const pathLower = path.toLowerCase();
-        const match = resourcePathsLower.some(
-          (res) => pathLower === res.exact || pathLower.startsWith(res.prefix)
-        );
-        if (!match) continue;
+      if (includeResourcesLower.length > 0) {
+        const resourceName = typeof extendedTool.resourceName === "string" ? extendedTool.resourceName.toLowerCase() : void 0;
+        if (!resourceName || !includeResourcesLower.includes(resourceName)) {
+          continue;
+        }
       }
       if (includeTagsLower.length > 0) {
-        const { method, path } = this.parseToolId(toolId);
-        const methodLower = method.toLowerCase();
-        const pathItem = spec.paths[path];
-        if (!pathItem) continue;
-        const opObj = pathItem[methodLower];
-        const tags = Array.isArray(opObj?.tags) ? opObj.tags : [];
-        if (!tags.some((tag) => includeTagsLower.includes(tag.toLowerCase()))) continue;
+        const toolTags = Array.isArray(extendedTool.tags) ? extendedTool.tags : [];
+        const hasMatchingTag = toolTags.some(
+          (tag) => typeof tag === "string" && includeTagsLower.includes(tag.toLowerCase())
+        );
+        if (!hasMatchingTag) {
+          continue;
+        }
       }
       filtered.set(toolId, tool);
     }
@@ -23443,8 +23625,8 @@ function loadConfig() {
     description: "Server version"
   }).option("tools", {
     type: "string",
-    choices: ["all", "dynamic"],
-    description: "Which tools to load: all or dynamic meta-tools"
+    choices: ["all", "dynamic", "explicit"],
+    description: "Which tools to load: all, dynamic meta-tools, or explicit (only includeTools)"
   }).option("tool", {
     type: "array",
     string: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ivotoby/openapi-mcp-server",
-  "version": "1.6.1",
+  "version": "1.8.0",
   "description": "An MCP server that exposes OpenAPI endpoints as resources",
   "license": "MIT",
   "type": "module",