@ivotoby/openapi-mcp-server 1.12.0 → 1.12.2

package/dist/cli.js

@@ -8883,11 +8883,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path) {
-      if (!path || typeof path !== "string") {
+    function lookup(path2) {
+      if (!path2 || typeof path2 !== "string") {
         return false;
       }
-      var extension2 = extname2("x." + path).toLowerCase().substr(1);
+      var extension2 = extname2("x." + path2).toLowerCase().substr(1);
       if (!extension2) {
         return false;
       }
@@ -9990,11 +9990,11 @@ var require_form_data = __commonJS({
   "node_modules/form-data/lib/form_data.js"(exports, module) {
     var CombinedStream = require_combined_stream();
     var util3 = __require("util");
-    var path = __require("path");
+    var path2 = __require("path");
     var http3 = __require("http");
     var https2 = __require("https");
     var parseUrl = __require("url").parse;
-    var fs = __require("fs");
+    var fs2 = __require("fs");
     var Stream = __require("stream").Stream;
     var mime = require_mime_types();
     var asynckit = require_asynckit();
@@ -10060,7 +10060,7 @@ var require_form_data = __commonJS({
         if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
           callback(null, value.end + 1 - (value.start ? value.start : 0));
         } else {
-          fs.stat(value.path, function(err, stat) {
+          fs2.stat(value.path, function(err, stat) {
             var fileSize;
             if (err) {
               callback(err);
@@ -10118,11 +10118,11 @@ var require_form_data = __commonJS({
     FormData3.prototype._getContentDisposition = function(value, options) {
       var filename, contentDisposition;
       if (typeof options.filepath === "string") {
-        filename = path.normalize(options.filepath).replace(/\\/g, "/");
+        filename = path2.normalize(options.filepath).replace(/\\/g, "/");
       } else if (options.filename || value.name || value.path) {
-        filename = path.basename(options.filename || value.name || value.path);
+        filename = path2.basename(options.filename || value.name || value.path);
       } else if (value.readable && Object.prototype.hasOwnProperty.call(value, "httpVersion")) {
-        filename = path.basename(value.client._httpMessage.path || "");
+        filename = path2.basename(value.client._httpMessage.path || "");
       }
       if (filename) {
         contentDisposition = 'filename="' + filename + '"';
@@ -11656,7 +11656,14 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
 
 // src/openapi-loader.ts
 import { readFile } from "fs/promises";
@@ -14377,8 +14384,8 @@ function parseToolId(toolId) {
   if (!pathPart) {
     return { method, path: "" };
   }
-  const path = pathPart.replace(/__/g, "/");
-  return { method, path: "/" + path };
+  const path2 = pathPart.replace(/__/g, "/");
+  return { method, path: "/" + path2 };
 }
 function sanitizeForToolId(input) {
   let result = input.replace(/[^A-Za-z0-9_.-]/g, "").replace(/_{3,}/g, "__");
@@ -14388,8 +14395,8 @@ function sanitizeForToolId(input) {
 function collapseExcessiveHyphens(input) {
   return input.replace(/-{4,}/g, "---");
 }
-function generateToolId(method, path) {
-  const cleanPath = path.replace(/^\//, "").replace(/\/+/g, "/").replace(/\{([^}]+)\}/g, "---$1").replace(/\//g, "__");
+function generateToolId(method, path2) {
+  const cleanPath = path2.replace(/^\//, "").replace(/\/+/g, "/").replace(/\{([^}]+)\}/g, "---$1").replace(/\//g, "__");
   const sanitizedPath = sanitizeForToolId(cleanPath);
   return `${method.toUpperCase()}::${sanitizedPath}`;
 }
@@ -14456,7 +14463,7 @@ var OpenAPISpecLoader = class {
    * Load spec content from standard input
    */
   async loadFromStdin() {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       let data = "";
       process.stdin.setEncoding("utf8");
       process.stdin.on("data", (chunk) => {
@@ -14466,7 +14473,7 @@ var OpenAPISpecLoader = class {
         if (data.trim().length === 0) {
           reject(new Error("No data received from stdin"));
         } else {
-          resolve5(data);
+          resolve6(data);
         }
       });
       process.stdin.on("error", (error) => {
@@ -14646,8 +14653,8 @@ var OpenAPISpecLoader = class {
    * - "/api/v1/users/{id}/posts" -> "posts"
    * - "/health" -> "health"
    */
-  extractResourceName(path) {
-    const segments = path.replace(/^\//, "").split("/");
+  extractResourceName(path2) {
+    const segments = path2.replace(/^\//, "").split("/");
     for (let i = segments.length - 1; i >= 0; i--) {
       const segment = segments[i];
       if (!segment.includes("{") && !segment.includes("}") && segment.length > 0) {
@@ -14661,7 +14668,7 @@ var OpenAPISpecLoader = class {
    */
   parseOpenAPISpec(spec) {
     const tools = /* @__PURE__ */ new Map();
-    for (const [path, pathItem] of Object.entries(spec.paths)) {
+    for (const [path2, pathItem] of Object.entries(spec.paths)) {
       if (!pathItem) continue;
       const pathLevelParameters = [];
       if (pathItem.parameters) {
@@ -14703,16 +14710,16 @@ var OpenAPISpecLoader = class {
         if (!["get", "post", "put", "patch", "delete", "options", "head"].includes(
           method.toLowerCase()
         )) {
-          console.warn(`Skipping non-HTTP method "${method}" for path ${path}`);
+          console.warn(`Skipping non-HTTP method "${method}" for path ${path2}`);
           continue;
         }
         const op = operation;
-        const toolId = generateToolId(method, path);
-        const nameSource = op.operationId || op.summary || `${method.toUpperCase()} ${path}`;
+        const toolId = generateToolId(method, path2);
+        const nameSource = op.operationId || op.summary || `${method.toUpperCase()} ${path2}`;
         const name = this.abbreviateOperationId(nameSource);
         const tool = {
           name,
-          description: op.description || `Make a ${method.toUpperCase()} request to ${path}`,
+          description: op.description || `Make a ${method.toUpperCase()} request to ${path2}`,
           inputSchema: {
             type: "object",
             properties: {}
@@ -14720,10 +14727,10 @@ var OpenAPISpecLoader = class {
           // Add metadata for filtering
           tags: op.tags || [],
           httpMethod: method.toUpperCase(),
-          resourceName: this.extractResourceName(path),
-          originalPath: path
+          resourceName: this.extractResourceName(path2),
+          originalPath: path2
         };
-        tool["x-original-path"] = path;
+        tool["x-original-path"] = path2;
         const requiredParams = [];
         const parameterMap = /* @__PURE__ */ new Map();
         for (const pathParam of pathLevelParameters) {
@@ -14794,8 +14801,31 @@ var OpenAPISpecLoader = class {
             }
           }
         }
-        if (op.requestBody && "content" in op.requestBody) {
-          const requestBodyObj = op.requestBody;
+        if (op.requestBody) {
+          let requestBodyObj;
+          if ("$ref" in op.requestBody && typeof op.requestBody.$ref === "string") {
+            const refMatch = op.requestBody.$ref.match(/^#\/components\/requestBodies\/(.+)$/);
+            if (refMatch && spec.components?.requestBodies) {
+              const requestBodyName = refMatch[1];
+              const resolvedRequestBody = spec.components.requestBodies[requestBodyName];
+              if (resolvedRequestBody && "content" in resolvedRequestBody) {
+                requestBodyObj = resolvedRequestBody;
+              } else {
+                console.warn(
+                  `Could not resolve requestBody reference or invalid structure: ${op.requestBody.$ref}`
+                );
+                continue;
+              }
+            } else {
+              console.warn(`Could not parse requestBody reference: ${op.requestBody.$ref}`);
+              continue;
+            }
+          } else if ("content" in op.requestBody) {
+            requestBodyObj = op.requestBody;
+          } else {
+            console.warn("Skipping requestBody due to invalid structure:", op.requestBody);
+            continue;
+          }
           let mediaTypeObj;
           if (requestBodyObj.content["application/json"]) {
             mediaTypeObj = requestBodyObj.content["application/json"];
@@ -15628,9 +15658,9 @@ function isVisitable(thing) {
 function removeBrackets(key) {
   return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
 }
-function renderKey(path, key, dots) {
-  if (!path) return key;
-  return path.concat(key).map(function each(token, i) {
+function renderKey(path2, key, dots) {
+  if (!path2) return key;
+  return path2.concat(key).map(function each(token, i) {
     token = removeBrackets(token);
     return !dots && i ? "[" + token + "]" : token;
   }).join(dots ? "." : "");
@@ -15678,9 +15708,9 @@ function toFormData(obj, formData, options) {
     }
     return value;
   }
-  function defaultVisitor(value, key, path) {
+  function defaultVisitor(value, key, path2) {
     let arr = value;
-    if (value && !path && typeof value === "object") {
+    if (value && !path2 && typeof value === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
         value = JSON.stringify(value);
@@ -15699,7 +15729,7 @@ function toFormData(obj, formData, options) {
     if (isVisitable(value)) {
       return true;
     }
-    formData.append(renderKey(path, key, dots), convertValue(value));
+    formData.append(renderKey(path2, key, dots), convertValue(value));
     return false;
   }
   const stack = [];
@@ -15708,10 +15738,10 @@ function toFormData(obj, formData, options) {
     convertValue,
     isVisitable
   });
-  function build(value, path) {
+  function build(value, path2) {
     if (utils_default.isUndefined(value)) return;
     if (stack.indexOf(value) !== -1) {
-      throw Error("Circular reference detected in " + path.join("."));
+      throw Error("Circular reference detected in " + path2.join("."));
     }
     stack.push(value);
     utils_default.forEach(value, function each(el, key) {
@@ -15719,11 +15749,11 @@ function toFormData(obj, formData, options) {
         formData,
         el,
         utils_default.isString(key) ? key.trim() : key,
-        path,
+        path2,
         exposedHelpers
       );
       if (result === true) {
-        build(el, path ? path.concat(key) : [key]);
+        build(el, path2 ? path2.concat(key) : [key]);
       }
     });
     stack.pop();
@@ -15935,7 +15965,7 @@ var platform_default = {
 // node_modules/axios/lib/helpers/toURLEncodedForm.js
 function toURLEncodedForm(data, options) {
   return toFormData_default(data, new platform_default.classes.URLSearchParams(), Object.assign({
-    visitor: function(value, key, path, helpers) {
+    visitor: function(value, key, path2, helpers) {
       if (platform_default.isNode && utils_default.isBuffer(value)) {
         this.append(key, value.toString("base64"));
         return false;
@@ -15964,11 +15994,11 @@ function arrayToObject(arr) {
   return obj;
 }
 function formDataToJSON(formData) {
-  function buildPath(path, value, target, index) {
-    let name = path[index++];
+  function buildPath(path2, value, target, index) {
+    let name = path2[index++];
     if (name === "__proto__") return true;
     const isNumericKey = Number.isFinite(+name);
-    const isLast = index >= path.length;
+    const isLast = index >= path2.length;
     name = !name && utils_default.isArray(target) ? target.length : name;
     if (isLast) {
       if (utils_default.hasOwnProp(target, name)) {
@@ -15981,7 +16011,7 @@ function formDataToJSON(formData) {
     if (!target[name] || !utils_default.isObject(target[name])) {
       target[name] = [];
     }
-    const result = buildPath(path, value, target[name], index);
+    const result = buildPath(path2, value, target[name], index);
     if (result && utils_default.isArray(target[name])) {
       target[name] = arrayToObject(target[name]);
     }
@@ -16410,10 +16440,10 @@ utils_default.inherits(CanceledError, AxiosError_default, {
 var CanceledError_default = CanceledError;
 
 // node_modules/axios/lib/core/settle.js
-function settle(resolve5, reject, response) {
+function settle(resolve6, reject, response) {
   const validateStatus2 = response.config.validateStatus;
   if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
-    resolve5(response);
+    resolve6(response);
   } else {
     reject(new AxiosError_default(
       "Request failed with status code " + response.status,
@@ -16914,7 +16944,7 @@ function setProxy(options, configProxy, location) {
 }
 var isHttpAdapterSupported = typeof process !== "undefined" && utils_default.kindOf(process) === "process";
 var wrapAsync = (asyncExecutor) => {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let onDone;
     let isDone;
     const done = (value, isRejected) => {
@@ -16924,7 +16954,7 @@ var wrapAsync = (asyncExecutor) => {
     };
     const _resolve = (value) => {
       done(value);
-      resolve5(value);
+      resolve6(value);
     };
     const _reject = (reason) => {
       done(reason, true);
@@ -16944,7 +16974,7 @@ var resolveFamily = ({ address, family }) => {
 };
 var buildAddressEntry = (address, family) => resolveFamily(utils_default.isObject(address) ? address : { address, family });
 var http_default = isHttpAdapterSupported && function httpAdapter(config) {
-  return wrapAsync(async function dispatchHttpRequest(resolve5, reject, onDone) {
+  return wrapAsync(async function dispatchHttpRequest(resolve6, reject, onDone) {
     let { data, lookup, family } = config;
     const { responseType, responseEncoding } = config;
     const method = config.method.toUpperCase();
@@ -16996,7 +17026,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
     if (protocol === "data:") {
       let convertedData;
       if (method !== "GET") {
-        return settle(resolve5, reject, {
+        return settle(resolve6, reject, {
           status: 405,
           statusText: "method not allowed",
           headers: {},
@@ -17018,7 +17048,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       } else if (responseType === "stream") {
         convertedData = stream3.Readable.from(convertedData);
       }
-      return settle(resolve5, reject, {
+      return settle(resolve6, reject, {
         data: convertedData,
         status: 200,
         statusText: "OK",
@@ -17116,9 +17146,9 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       auth = urlUsername + ":" + urlPassword;
     }
     auth && headers.delete("authorization");
-    let path;
+    let path2;
     try {
-      path = buildURL(
+      path2 = buildURL(
         parsed.pathname + parsed.search,
         config.params,
         config.paramsSerializer
@@ -17136,7 +17166,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       false
     );
     const options = {
-      path,
+      path: path2,
       method,
       headers: headers.toJSON(),
       agents: { http: config.httpAgent, https: config.httpsAgent },
@@ -17236,7 +17266,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       };
       if (responseType === "stream") {
         response.data = responseStream;
-        settle(resolve5, reject, response);
+        settle(resolve6, reject, response);
       } else {
         const responseBuffer = [];
         let totalResponseBytes = 0;
@@ -17284,7 +17314,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
           } catch (err) {
             return reject(AxiosError_default.from(err, null, config, response.request, response));
           }
-          settle(resolve5, reject, response);
+          settle(resolve6, reject, response);
         });
       }
       emitter.once("abort", (err) => {
@@ -17366,10 +17396,10 @@ var isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? /* @__PUR
 var cookies_default = platform_default.hasStandardBrowserEnv ? (
   // Standard browser envs support document.cookie
   {
-    write(name, value, expires, path, domain, secure) {
+    write(name, value, expires, path2, domain, secure) {
       const cookie = [name + "=" + encodeURIComponent(value)];
       utils_default.isNumber(expires) && cookie.push("expires=" + new Date(expires).toGMTString());
-      utils_default.isString(path) && cookie.push("path=" + path);
+      utils_default.isString(path2) && cookie.push("path=" + path2);
       utils_default.isString(domain) && cookie.push("domain=" + domain);
       secure === true && cookie.push("secure");
       document.cookie = cookie.join("; ");
@@ -17511,7 +17541,7 @@ var resolveConfig_default = (config) => {
 // node_modules/axios/lib/adapters/xhr.js
 var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
 var xhr_default = isXHRAdapterSupported && function(config) {
-  return new Promise(function dispatchXhrRequest(resolve5, reject) {
+  return new Promise(function dispatchXhrRequest(resolve6, reject) {
     const _config = resolveConfig_default(config);
     let requestData = _config.data;
     const requestHeaders = AxiosHeaders_default.from(_config.headers).normalize();
@@ -17545,7 +17575,7 @@ var xhr_default = isXHRAdapterSupported && function(config) {
         request
       };
       settle(function _resolve(value) {
-        resolve5(value);
+        resolve6(value);
         done();
       }, function _reject(err) {
         reject(err);
@@ -17888,8 +17918,8 @@ var fetch_default = isFetchSupported && (async (config) => {
     responseType = responseType || "text";
     let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config);
     !isStreamResponse && unsubscribe && unsubscribe();
-    return await new Promise((resolve5, reject) => {
-      settle(resolve5, reject, {
+    return await new Promise((resolve6, reject) => {
+      settle(resolve6, reject, {
         data: responseData,
         headers: AxiosHeaders_default.from(response.headers),
         status: response.status,
@@ -18255,8 +18285,8 @@ var CancelToken = class _CancelToken {
       throw new TypeError("executor must be a function.");
     }
     let resolvePromise;
-    this.promise = new Promise(function promiseExecutor(resolve5) {
-      resolvePromise = resolve5;
+    this.promise = new Promise(function promiseExecutor(resolve6) {
+      resolvePromise = resolve6;
     });
     const token = this;
     this.promise.then((cancel) => {
@@ -18269,9 +18299,9 @@ var CancelToken = class _CancelToken {
     });
     this.promise.then = (onfulfilled) => {
       let _resolve;
-      const promise = new Promise((resolve5) => {
-        token.subscribe(resolve5);
-        _resolve = resolve5;
+      const promise = new Promise((resolve6) => {
+        token.subscribe(resolve6);
+        _resolve = resolve6;
       }).then(onfulfilled);
       promise.cancel = function reject() {
         token.unsubscribe(_resolve);
@@ -18598,10 +18628,10 @@ var ApiClient = class {
       if (toolId === "INVOKE-API-ENDPOINT") {
         return this.handleInvokeApiEndpoint(toolId, params);
       }
-      const { method, path } = this.parseToolId(toolId);
+      const { method, path: path2 } = this.parseToolId(toolId);
       const toolDef = this.getToolDefinition(toolId);
       const paramsCopy = { ...params };
-      let resolvedPath = path;
+      let resolvedPath = path2;
       const escapeRegExp = (str2) => {
         return str2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
       };
@@ -18726,7 +18756,7 @@ var ApiClient = class {
   async handleListApiEndpoints() {
     const endpoints = [];
     if (this.openApiSpec) {
-      for (const [path, pathItem] of Object.entries(this.openApiSpec.paths)) {
+      for (const [path2, pathItem] of Object.entries(this.openApiSpec.paths)) {
         if (!pathItem) continue;
         for (const [method, operation] of Object.entries(pathItem)) {
           if (method === "parameters" || !operation) continue;
@@ -18736,7 +18766,7 @@ var ApiClient = class {
           const op = operation;
           endpoints.push({
             method: method.toUpperCase(),
-            path,
+            path: path2,
             summary: op.summary || "",
             description: op.description || "",
             operationId: op.operationId || "",
@@ -18750,13 +18780,13 @@ var ApiClient = class {
           continue;
         }
         try {
-          const { method, path } = this.parseToolId(toolId);
+          const { method, path: path2 } = this.parseToolId(toolId);
           endpoints.push({
             toolId,
             name: tool.name,
             description: tool.description,
             method: method.toUpperCase(),
-            path
+            path: path2
           });
         } catch (error) {
           continue;
@@ -18814,8 +18844,8 @@ var ApiClient = class {
       let matchingToolId;
       for (const [toolId2, tool] of this.toolsMap.entries()) {
         try {
-          const { path } = this.parseToolId(toolId2);
-          if (path === endpoint) {
+          const { path: path2 } = this.parseToolId(toolId2);
+          if (path2 === endpoint) {
             matchingTool = tool;
             matchingToolId = toolId2;
             break;
@@ -18852,8 +18882,8 @@ var ApiClient = class {
       } else if (this.openApiSpec) {
         const pathItem = this.openApiSpec.paths[endpoint];
         if (pathItem && pathItem[method.toLowerCase()]) {
-          const { method: httpMethod, path } = { method: method.toUpperCase(), path: endpoint };
-          return this.makeDirectHttpRequest(httpMethod, path, endpointParams);
+          const { method: httpMethod, path: path2 } = { method: method.toUpperCase(), path: endpoint };
+          return this.makeDirectHttpRequest(httpMethod, path2, endpointParams);
         } else {
           throw new Error(
             `No endpoint found for path '${endpoint}' with method '${method}' in tool '${toolId2}'`
@@ -18882,11 +18912,11 @@ var ApiClient = class {
    * Make a direct HTTP request without going through the tool system
    * Used by dynamic meta-tools when we have OpenAPI spec but no corresponding tool
    */
-  async makeDirectHttpRequest(method, path, params) {
+  async makeDirectHttpRequest(method, path2, params) {
     const authHeaders = await this.authProvider.getAuthHeaders();
     const config = {
       method: method.toLowerCase(),
-      url: path,
+      url: path2,
       headers: authHeaders
     };
     if (isGetLikeMethod(method)) {
@@ -18909,22 +18939,265 @@ var ApiClient = class {
   }
 };
 
+// src/prompts-manager.ts
+var PromptsManager = class {
+  prompts = /* @__PURE__ */ new Map();
+  constructor(config) {
+    if (config.prompts) {
+      for (const prompt of config.prompts) {
+        this.addPrompt(prompt);
+      }
+    }
+  }
+  /**
+   * Add a prompt definition
+   */
+  addPrompt(prompt) {
+    if (!prompt.name) {
+      throw new Error("Prompt name is required");
+    }
+    if (!prompt.template) {
+      throw new Error(`Prompt "${prompt.name}" requires a template`);
+    }
+    this.prompts.set(prompt.name, prompt);
+  }
+  /**
+   * Remove a prompt by name
+   */
+  removePrompt(name) {
+    return this.prompts.delete(name);
+  }
+  /**
+   * Get all prompts in MCP format for listing
+   */
+  getAllPrompts() {
+    return Array.from(this.prompts.values()).map((def) => this.toMCPPrompt(def));
+  }
+  /**
+   * Get a specific prompt with arguments applied
+   */
+  getPrompt(name, args) {
+    const def = this.prompts.get(name);
+    if (!def) {
+      throw new Error(`Prompt not found: ${name}`);
+    }
+    if (def.arguments) {
+      for (const arg of def.arguments) {
+        if (arg.required && (!args || args[arg.name] === void 0)) {
+          throw new Error(`Missing required argument: ${arg.name}`);
+        }
+      }
+    }
+    const renderedText = this.renderTemplate(def.template, args || {});
+    const messages = [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: renderedText
+        }
+      }
+    ];
+    return {
+      description: def.description,
+      messages
+    };
+  }
+  /**
+   * Check if a prompt exists
+   */
+  hasPrompt(name) {
+    return this.prompts.has(name);
+  }
+  /**
+   * Get the count of prompts
+   */
+  get count() {
+    return this.prompts.size;
+  }
+  /**
+   * Convert internal prompt definition to MCP Prompt format
+   */
+  toMCPPrompt(def) {
+    const prompt = {
+      name: def.name,
+      description: def.description
+    };
+    if (def.arguments && def.arguments.length > 0) {
+      prompt.arguments = def.arguments.map(
+        (arg) => ({
+          name: arg.name,
+          description: arg.description,
+          required: arg.required
+        })
+      );
+    }
+    return prompt;
+  }
+  /**
+   * Render a template string by replacing {{argName}} placeholders
+   */
+  renderTemplate(template, args) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, argName) => {
+      if (args[argName] !== void 0) {
+        return args[argName];
+      }
+      return "";
+    });
+  }
+};
+
+// src/resources-manager.ts
+var ResourcesManager = class {
+  resources = /* @__PURE__ */ new Map();
+  constructor(config) {
+    if (config.resources) {
+      for (const resource of config.resources) {
+        this.addResource(resource);
+      }
+    }
+  }
+  /**
+   * Add a resource definition
+   */
+  addResource(resource) {
+    if (!resource.uri) {
+      throw new Error("Resource URI is required");
+    }
+    if (!resource.name) {
+      throw new Error(`Resource "${resource.uri}" requires a name`);
+    }
+    if (!resource.text && !resource.blob && !resource.contentProvider) {
+      throw new Error(
+        `Resource "${resource.uri}" requires content (text, blob, or contentProvider)`
+      );
+    }
+    this.resources.set(resource.uri, resource);
+  }
+  /**
+   * Remove a resource by URI
+   */
+  removeResource(uri) {
+    return this.resources.delete(uri);
+  }
+  /**
+   * Get all resources in MCP format for listing
+   */
+  getAllResources() {
+    return Array.from(this.resources.values()).map((def) => this.toMCPResource(def));
+  }
+  /**
+   * Read a specific resource by URI
+   */
+  async readResource(uri) {
+    const def = this.resources.get(uri);
+    if (!def) {
+      throw new Error(`Resource not found: ${uri}`);
+    }
+    let contents;
+    if (def.contentProvider) {
+      let content;
+      try {
+        content = await def.contentProvider();
+      } catch (error) {
+        throw new Error(
+          `Failed to load content for resource "${uri}": ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (typeof content === "string") {
+        contents = [
+          {
+            uri: def.uri,
+            mimeType: def.mimeType,
+            text: content
+          }
+        ];
+      } else {
+        contents = [
+          {
+            uri: def.uri,
+            mimeType: def.mimeType,
+            blob: content.blob
+          }
+        ];
+      }
+    } else if (def.text !== void 0) {
+      contents = [
+        {
+          uri: def.uri,
+          mimeType: def.mimeType,
+          text: def.text
+        }
+      ];
+    } else if (def.blob !== void 0) {
+      contents = [
+        {
+          uri: def.uri,
+          mimeType: def.mimeType,
+          blob: def.blob
+        }
+      ];
+    } else {
+      throw new Error(`Resource "${uri}" has no content`);
+    }
+    return { contents };
+  }
+  /**
+   * Check if a resource exists
+   */
+  hasResource(uri) {
+    return this.resources.has(uri);
+  }
+  /**
+   * Get the count of resources
+   */
+  get count() {
+    return this.resources.size;
+  }
+  /**
+   * Convert internal resource definition to MCP Resource format
+   */
+  toMCPResource(def) {
+    return {
+      uri: def.uri,
+      name: def.name,
+      description: def.description,
+      mimeType: def.mimeType
+    };
+  }
+};
+
 // src/server.ts
 var OpenAPIServer = class {
   server;
   toolsManager;
   apiClient;
+  promptsManager;
+  resourcesManager;
+  config;
   constructor(config) {
+    this.config = config;
+    if (config.prompts?.length) {
+      this.promptsManager = new PromptsManager({ prompts: config.prompts });
+    }
+    if (config.resources?.length) {
+      this.resourcesManager = new ResourcesManager({ resources: config.resources });
+    }
+    const capabilities = {
+      tools: {
+        list: true,
+        execute: true
+      }
+    };
+    if (this.promptsManager) {
+      capabilities.prompts = {};
+    }
+    if (this.resourcesManager) {
+      capabilities.resources = {};
+    }
     this.server = new Server(
       { name: config.name, version: config.version },
-      {
-        capabilities: {
-          tools: {
-            list: true,
-            execute: true
-          }
-        }
-      }
+      { capabilities }
     );
     this.toolsManager = new ToolsManager(config);
     const authProviderOrHeaders = config.authProvider || new StaticAuthProvider(config.headers);
@@ -18986,6 +19259,25 @@ var OpenAPIServer = class {
         throw error;
       }
     });
+    if (this.promptsManager) {
+      this.server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+        prompts: this.promptsManager.getAllPrompts()
+      }));
+      this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        return this.promptsManager.getPrompt(
+          request.params.name,
+          request.params.arguments
+        );
+      });
+    }
+    if (this.resourcesManager) {
+      this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+        resources: this.resourcesManager.getAllResources()
+      }));
+      this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        return this.resourcesManager.readResource(request.params.uri);
+      });
+    }
   }
   /**
    * Start the server with the given transport
@@ -19003,6 +19295,18 @@ var OpenAPIServer = class {
     }
     await this.server.connect(transport);
   }
+  /**
+   * Get the prompts manager (for library users to add prompts dynamically)
+   */
+  getPromptsManager() {
+    return this.promptsManager;
+  }
+  /**
+   * Get the resources manager (for library users to add resources dynamically)
+   */
+  getResourcesManager() {
+    return this.resourcesManager;
+  }
 };
 
 // node_modules/yargs/lib/platform-shims/esm.mjs
@@ -20281,11 +20585,11 @@ var parser = new YargsParser({
   resolve: resolve2,
   // TODO: figure  out a  way to combine ESM and CJS coverage, such  that
   // we can exercise all the lines below:
-  require: (path) => {
+  require: (path2) => {
     if (typeof __require !== "undefined") {
-      return __require(path);
-    } else if (path.match(/\.json$/)) {
-      return JSON.parse(readFileSync(path, "utf8"));
+      return __require(path2);
+    } else if (path2.match(/\.json$/)) {
+      return JSON.parse(readFileSync(path2, "utf8"));
     } else {
       throw Error("only .json config files are supported in ESM");
     }
@@ -22810,12 +23114,12 @@ var YargsInstance = class {
   async getCompletion(args, done) {
     argsert("<array> [function]", [args, done], arguments.length);
     if (!done) {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve6, reject) => {
         __classPrivateFieldGet(this, _YargsInstance_completion, "f").getCompletion(args, (err, completions) => {
           if (err)
             reject(err);
           else
-            resolve5(completions);
+            resolve6(completions);
         });
       });
     } else {
@@ -23934,6 +24238,18 @@ function loadConfig() {
   }).option("disable-abbreviation", {
     type: "boolean",
     description: "Disable name optimization"
+  }).option("prompts", {
+    type: "string",
+    description: "Path or URL to prompts JSON/YAML file"
+  }).option("prompts-inline", {
+    type: "string",
+    description: "Provide prompts directly as JSON string"
+  }).option("resources", {
+    type: "string",
+    description: "Path or URL to resources JSON/YAML file"
+  }).option("resources-inline", {
+    type: "string",
+    description: "Provide resources directly as JSON string"
   }).help().parseSync();
   let transportType;
   if (argv.transport === "http" || process.env.TRANSPORT_TYPE === "http") {
@@ -24011,7 +24327,11 @@ function loadConfig() {
     includeResources: argv.resource,
     includeOperations: argv.operation,
     toolsMode,
-    disableAbbreviation: disableAbbreviation ? true : void 0
+    disableAbbreviation: disableAbbreviation ? true : void 0,
+    promptsPath: argv.prompts || process.env.PROMPTS_PATH,
+    promptsInline: argv["prompts-inline"] || process.env.PROMPTS_INLINE,
+    resourcesPath: argv.resources || process.env.RESOURCES_PATH,
+    resourcesInline: argv["resources-inline"] || process.env.RESOURCES_INLINE
   };
 }
 
@@ -24080,13 +24400,13 @@ var StreamableHttpServerTransport = class {
     if (this.started) {
       throw new Error("Transport already started");
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       this.server.listen(this.port, this.host, () => {
         this.started = true;
         console.error(
           `Streamable HTTP transport listening on http://${this.host}:${this.port}${this.endpointPath}`
         );
-        resolve5();
+        resolve6();
       });
       this.server.on("error", (err) => {
         reject(err);
@@ -24116,7 +24436,7 @@ var StreamableHttpServerTransport = class {
       }
       return;
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       this.server.close((err) => {
         if (err) {
           reject(err instanceof Error ? err : new Error(String(err)));
@@ -24125,7 +24445,7 @@ var StreamableHttpServerTransport = class {
           if (this.onclose) {
             this.onclose();
           }
-          resolve5();
+          resolve6();
         }
       });
     });
@@ -24607,10 +24927,82 @@ var StreamableHttpServerTransport = class {
   }
 };
 
+// src/content-loader.ts
+import * as fs from "fs";
+import * as path from "path";
+async function loadContent(pathOrUrl, inline) {
+  if (inline) {
+    return inline;
+  }
+  if (!pathOrUrl) {
+    return void 0;
+  }
+  if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+    const response = await axios_default.get(pathOrUrl, {
+      responseType: "text",
+      headers: { Accept: "application/json, application/yaml, text/yaml" }
+    });
+    return response.data;
+  }
+  const absolutePath = path.isAbsolute(pathOrUrl) ? pathOrUrl : path.resolve(process.cwd(), pathOrUrl);
+  return fs.readFileSync(absolutePath, "utf-8");
+}
+function parseContent(content, source) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    try {
+      return js_yaml_default.load(content);
+    } catch (yamlError) {
+      throw new Error(
+        `Failed to parse ${source} as JSON or YAML: ${yamlError}`
+      );
+    }
+  }
+}
+async function loadPrompts(pathOrUrl, inline) {
+  const content = await loadContent(pathOrUrl, inline);
+  if (!content) {
+    return void 0;
+  }
+  const source = inline ? "inline prompts" : pathOrUrl;
+  const prompts = parseContent(content, source);
+  if (!Array.isArray(prompts)) {
+    throw new Error(`Prompts must be an array, got: ${typeof prompts}`);
+  }
+  return prompts;
+}
+async function loadResources(pathOrUrl, inline) {
+  const content = await loadContent(pathOrUrl, inline);
+  if (!content) {
+    return void 0;
+  }
+  const source = inline ? "inline resources" : pathOrUrl;
+  const resources = parseContent(content, source);
+  if (!Array.isArray(resources)) {
+    throw new Error(`Resources must be an array, got: ${typeof resources}`);
+  }
+  return resources;
+}
+
 // src/index.ts
 async function main() {
   try {
     const config = loadConfig();
+    if (config.promptsPath || config.promptsInline) {
+      const prompts = await loadPrompts(config.promptsPath, config.promptsInline);
+      if (prompts) {
+        config.prompts = prompts;
+        console.error(`Loaded ${prompts.length} prompt(s)`);
+      }
+    }
+    if (config.resourcesPath || config.resourcesInline) {
+      const resources = await loadResources(config.resourcesPath, config.resourcesInline);
+      if (resources) {
+        config.resources = resources;
+        console.error(`Loaded ${resources.length} resource(s)`);
+      }
+    }
     const server = new OpenAPIServer(config);
     let transport;
     if (config.transportType === "http") {