@ivotoby/openapi-mcp-server 1.3.0 → 1.4.1

package/README.md

@@ -215,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

@@ -14450,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
    */
@@ -14459,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;
@@ -14479,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(
@@ -14503,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) {
@@ -14794,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
    */
@@ -18145,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
    *
@@ -18155,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;
@@ -18286,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);
   }
 };

package/package.json

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