@ivotoby/openapi-mcp-server 1.2.2 → 1.4.0

package/README.md

@@ -126,6 +126,7 @@ The server can be configured through environment variables or command line argum
 - `HTTP_HOST` - Host for HTTP transport (default: "127.0.0.1")
 - `ENDPOINT_PATH` - Endpoint path for HTTP transport (default: "/mcp")
 - `TOOLS_MODE` - Tools loading mode: "all" (load all endpoint-based tools) or "dynamic" (load only meta-tools) (default: "all")
+- `DISABLE_ABBREVIATION` - Disable name optimization (this could throw errors when name is > 64 chars)
 
 ### Command Line Arguments
 
@@ -139,7 +140,8 @@ npx @ivotoby/openapi-mcp-server \
   --transport http \
   --port 3000 \
   --host 127.0.0.1 \
-  --path /mcp
+  --path /mcp \
+  --disable-abbreviation true
 ```
 
 ### OpenAPI Schema Processing
@@ -213,7 +215,7 @@ To see debug logs:
 
 2. When using HTTP transport:
    ```bash
-   npx @ivotoby/openapi-mcp-server --transport http 2>debug.log
+   npx @ivotoby/openapi-mcp-server --transport http &2>debug.log
    ```
 
 ## For Developers

package/dist/bundle.js

@@ -14373,6 +14373,13 @@ var WORD_ABBREVIATIONS = {
 
 // src/openapi-loader.ts
 var OpenAPISpecLoader = class {
+  /**
+   * Disable name optimization
+   */
+  disableAbbreviation;
+  constructor(config) {
+    this.disableAbbreviation = config?.disableAbbreviation ?? false;
+  }
   /**
    * Load an OpenAPI specification from a file path or URL
    */
@@ -14443,6 +14450,33 @@ var OpenAPISpecLoader = class {
     }
     return schemaObj;
   }
+  /**
+   * Determine the appropriate JSON Schema type for a parameter
+   * @param paramSchema The OpenAPI schema object after inlining
+   * @param paramName The name of the parameter (for logging purposes)
+   * @returns The determined type string, or undefined if the type should be omitted
+   */
+  determineParameterType(paramSchema, paramName) {
+    if (Object.keys(paramSchema).length === 0 && typeof paramSchema !== "boolean") {
+      console.warn(
+        `Parameter '${paramName}' schema was empty after inlining (potential cycle or unresolvable ref), defaulting to string.`
+      );
+      return "string";
+    }
+    if (typeof paramSchema === "boolean") {
+      return "boolean";
+    }
+    if (paramSchema.type) {
+      return paramSchema.type;
+    }
+    const hasProperties = "properties" in paramSchema && paramSchema.properties && Object.keys(paramSchema.properties).length > 0;
+    const hasItems = paramSchema.type === "array" && !!paramSchema.items;
+    const hasComposition = "allOf" in paramSchema && paramSchema.allOf && paramSchema.allOf.length > 0 || "anyOf" in paramSchema && paramSchema.anyOf && paramSchema.anyOf.length > 0 || "oneOf" in paramSchema && paramSchema.oneOf && paramSchema.oneOf.length > 0;
+    if (!hasProperties && !hasItems && !hasComposition) {
+      return "string";
+    }
+    return void 0;
+  }
   /**
    * Parse an OpenAPI specification into a map of tools
    */
@@ -14452,7 +14486,10 @@ var OpenAPISpecLoader = class {
       if (!pathItem) continue;
       for (const [method, operation] of Object.entries(pathItem)) {
         if (method === "parameters" || !operation) continue;
-        if (!["get", "put", "post", "delete", "options", "head", "patch", "trace"].includes(method)) {
+        if (!["get", "post", "put", "patch", "delete", "options", "head"].includes(
+          method.toLowerCase()
+        )) {
+          console.warn(`Skipping non-HTTP method "${method}" for path ${path}`);
           continue;
         }
         const op = operation;
@@ -14472,22 +14509,35 @@ var OpenAPISpecLoader = class {
         if (op.parameters) {
           for (const param of op.parameters) {
             let paramObj;
-            if (!("name" in param)) {
-              if ("$ref" in param && typeof param.$ref === "string") {
-                const refMatch = param.$ref.match(/^#\/components\/parameters\/(.+)$/);
-                if (refMatch && spec.components?.parameters) {
-                  const paramName = refMatch[1];
-                  const resolvedParam = spec.components.parameters[paramName];
-                  if (!resolvedParam || !("name" in resolvedParam)) continue;
+            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 parameter reference or invalid structure: ${param.$ref}`
+                  );
                   continue;
                 }
               } else {
+                console.warn(`Could not parse parameter reference: ${param.$ref}`);
                 continue;
               }
-            } else {
+            } else if ("name" in param && "in" in param) {
               paramObj = param;
+            } else {
+              console.warn(
+                "Skipping parameter due to missing 'name' or 'in' properties and not being a valid $ref:",
+                param
+              );
+              continue;
+            }
+            if (!paramObj) {
+              console.warn("Failed to process a parameter (paramObj is undefined):", param);
+              continue;
             }
             if (paramObj.schema) {
               const paramSchema = this.inlineSchema(
@@ -14496,16 +14546,20 @@ var OpenAPISpecLoader = class {
                 /* @__PURE__ */ new Set()
               );
               const paramDef = {
-                description: paramObj.description || `${paramObj.name} parameter`
+                description: paramObj.description || `${paramObj.name} parameter`,
+                "x-parameter-location": paramObj.in
+                // Store parameter location (path, query, etc.)
               };
-              if (paramSchema.type) {
-                paramDef.type = paramSchema.type;
-              } else {
-                paramDef.type = "string";
+              const paramType = this.determineParameterType(paramSchema, paramObj.name);
+              if (paramType !== void 0) {
+                paramDef.type = paramType;
               }
-              for (const [key, value] of Object.entries(paramSchema)) {
-                if (key === "type" || key === "description") continue;
-                paramDef[key] = value;
+              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) {
@@ -14649,14 +14703,20 @@ var OpenAPISpecLoader = class {
     return finalName;
   }
   abbreviateOperationId(originalId, maxLength = 64) {
+    maxLength = this.disableAbbreviation ? Number.MAX_SAFE_INTEGER : maxLength;
     const {
       currentName: sanitizedName,
       originalWasLong,
       errorName
     } = this._initialSanitizeAndValidate(originalId, maxLength);
     if (errorName) return errorName;
-    let processedName = this._performSemanticAbbreviation(sanitizedName);
-    processedName = this._applyVowelRemovalIfOverLength(processedName, maxLength);
+    let processedName;
+    if (this.disableAbbreviation) {
+      processedName = this.splitCombined(sanitizedName).join("-");
+    } else {
+      processedName = this._performSemanticAbbreviation(sanitizedName);
+      processedName = this._applyVowelRemovalIfOverLength(processedName, maxLength);
+    }
     processedName = this._truncateAndApplyHashIfNeeded(
       processedName,
       originalId,
@@ -14673,7 +14733,9 @@ var ToolsManager = class {
   constructor(config) {
     this.config = config;
     this.config.toolsMode = this.config.toolsMode || "all";
-    this.specLoader = new OpenAPISpecLoader();
+    this.specLoader = new OpenAPISpecLoader({
+      disableAbbreviation: this.config.disableAbbreviation
+    });
   }
   tools = /* @__PURE__ */ new Map();
   specLoader;
@@ -14779,6 +14841,13 @@ var ToolsManager = class {
   getAllTools() {
     return Array.from(this.tools.values());
   }
+  /**
+   * Get all available tools with their IDs
+   * Returns array of [toolId, tool] pairs
+   */
+  getToolsWithIds() {
+    return Array.from(this.tools.entries());
+  }
   /**
    * Find a tool by ID or name
    */
@@ -18130,6 +18199,24 @@ var ApiClient = class {
     });
   }
   axiosInstance;
+  toolsMap = /* @__PURE__ */ new Map();
+  /**
+   * Set the available tools for the client
+   *
+   * @param tools - Map of tool ID to tool definition
+   */
+  setTools(tools) {
+    this.toolsMap = tools;
+  }
+  /**
+   * Get a tool definition by ID
+   *
+   * @param toolId - The tool ID
+   * @returns The tool definition if found
+   */
+  getToolDefinition(toolId) {
+    return this.toolsMap.get(toolId);
+  }
   /**
    * Execute an API call based on the tool ID and parameters
    *
@@ -18140,15 +18227,57 @@ var ApiClient = class {
   async executeApiCall(toolId, params) {
     try {
       const { method, path } = this.parseToolId(toolId);
+      const toolDef = this.getToolDefinition(toolId);
+      const paramsCopy = { ...params };
+      let resolvedPath = path;
+      const escapeRegExp = (str2) => {
+        return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      };
+      if (toolDef?.inputSchema?.properties) {
+        for (const [key, value] of Object.entries(paramsCopy)) {
+          const paramDef = toolDef.inputSchema.properties[key];
+          const paramDef_any = paramDef;
+          const paramLocation = paramDef_any?.["x-parameter-location"];
+          if (paramLocation === "path") {
+            const escapedKey = escapeRegExp(key);
+            const paramRegex = new RegExp(`\\{${escapedKey}\\}|:${escapedKey}(?:\\/|$)`, "g");
+            if (paramRegex.test(resolvedPath)) {
+              resolvedPath = resolvedPath.replace(
+                paramRegex,
+                (match) => encodeURIComponent(value) + (match.endsWith("/") ? "/" : "")
+              );
+            } else {
+              resolvedPath = resolvedPath.replace(`/${key}`, `/${encodeURIComponent(value)}`);
+            }
+            delete paramsCopy[key];
+          }
+        }
+      } else {
+        for (const key of Object.keys(paramsCopy)) {
+          const value = paramsCopy[key];
+          const escapedKey = escapeRegExp(key);
+          const paramRegex = new RegExp(`\\{${escapedKey}\\}|:${escapedKey}(?:\\/|$)`, "g");
+          if (paramRegex.test(resolvedPath)) {
+            resolvedPath = resolvedPath.replace(
+              paramRegex,
+              (match) => encodeURIComponent(value) + (match.endsWith("/") ? "/" : "")
+            );
+            delete paramsCopy[key];
+          } else if (resolvedPath.includes(`/${key}`)) {
+            resolvedPath = resolvedPath.replace(`/${key}`, `/${encodeURIComponent(value)}`);
+            delete paramsCopy[key];
+          }
+        }
+      }
       const config = {
         method: method.toLowerCase(),
-        url: path,
+        url: resolvedPath,
         headers: this.headers
       };
       if (["get", "delete", "head", "options"].includes(method.toLowerCase())) {
-        config.params = this.processQueryParams(params);
+        config.params = this.processQueryParams(paramsCopy);
       } else {
-        config.data = params;
+        config.data = paramsCopy;
       }
       const response = await this.axiosInstance(config);
       return response.data;
@@ -18271,6 +18400,11 @@ var OpenAPIServer = class {
    */
   async start(transport) {
     await this.toolsManager.initialize();
+    const toolsMap = /* @__PURE__ */ new Map();
+    for (const [toolId, tool] of this.toolsManager.getToolsWithIds()) {
+      toolsMap.set(toolId, tool);
+    }
+    this.apiClient.setTools(toolsMap);
     await this.server.connect(transport);
   }
 };
@@ -23191,6 +23325,9 @@ function loadConfig() {
     type: "array",
     string: true,
     description: "Import only tools for specified HTTP methods (e.g., get, post)"
+  }).option("disable-abbreviation", {
+    type: "boolean",
+    description: "Disable name optimization"
   }).help().parseSync();
   let transportType;
   if (argv.transport === "http" || process.env.TRANSPORT_TYPE === "http") {
@@ -23203,6 +23340,7 @@ function loadConfig() {
   const endpointPath = argv.path || process.env.ENDPOINT_PATH || "/mcp";
   const apiBaseUrl = argv["api-base-url"] || process.env.API_BASE_URL;
   const openApiSpec = argv["openapi-spec"] || process.env.OPENAPI_SPEC_PATH;
+  const disableAbbreviation = argv["disable-abbreviation"] || (process.env.DISABLE_ABBREVIATION ? process.env.DISABLE_ABBREVIATION === "true" : false);
   if (!apiBaseUrl) {
     throw new Error("API base URL is required (--api-base-url or API_BASE_URL)");
   }
@@ -23224,7 +23362,8 @@ function loadConfig() {
     includeTags: argv.tag,
     includeResources: argv.resource,
     includeOperations: argv.operation,
-    toolsMode: argv.tools || process.env.TOOLS_MODE || "all"
+    toolsMode: argv.tools || process.env.TOOLS_MODE || "all",
+    disableAbbreviation: disableAbbreviation ? true : void 0
   };
 }
 

package/package.json

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