@ivotoby/openapi-mcp-server 0.1.0 → 1.1.0

package/dist/bundle.js

@@ -296,9 +296,9 @@ var require_combined_stream = __commonJS({
   }
 });
 
-// node_modules/mime-db/db.json
+// node_modules/form-data/node_modules/mime-db/db.json
 var require_db = __commonJS({
-  "node_modules/mime-db/db.json"(exports, module) {
+  "node_modules/form-data/node_modules/mime-db/db.json"(exports, module) {
     module.exports = {
       "application/1d-interleaved-parityfec": {
         source: "iana"
@@ -8821,16 +8821,16 @@ var require_db = __commonJS({
   }
 });
 
-// node_modules/mime-db/index.js
+// node_modules/form-data/node_modules/mime-db/index.js
 var require_mime_db = __commonJS({
-  "node_modules/mime-db/index.js"(exports, module) {
+  "node_modules/form-data/node_modules/mime-db/index.js"(exports, module) {
     module.exports = require_db();
   }
 });
 
-// node_modules/mime-types/index.js
+// node_modules/form-data/node_modules/mime-types/index.js
 var require_mime_types = __commonJS({
-  "node_modules/mime-types/index.js"(exports) {
+  "node_modules/form-data/node_modules/mime-types/index.js"(exports) {
     "use strict";
     var db = require_mime_db();
     var extname2 = __require("path").extname;
@@ -9127,6 +9127,852 @@ var require_asynckit = __commonJS({
   }
 });
 
+// node_modules/es-object-atoms/index.js
+var require_es_object_atoms = __commonJS({
+  "node_modules/es-object-atoms/index.js"(exports, module) {
+    "use strict";
+    module.exports = Object;
+  }
+});
+
+// node_modules/es-errors/index.js
+var require_es_errors = __commonJS({
+  "node_modules/es-errors/index.js"(exports, module) {
+    "use strict";
+    module.exports = Error;
+  }
+});
+
+// node_modules/es-errors/eval.js
+var require_eval = __commonJS({
+  "node_modules/es-errors/eval.js"(exports, module) {
+    "use strict";
+    module.exports = EvalError;
+  }
+});
+
+// node_modules/es-errors/range.js
+var require_range = __commonJS({
+  "node_modules/es-errors/range.js"(exports, module) {
+    "use strict";
+    module.exports = RangeError;
+  }
+});
+
+// node_modules/es-errors/ref.js
+var require_ref = __commonJS({
+  "node_modules/es-errors/ref.js"(exports, module) {
+    "use strict";
+    module.exports = ReferenceError;
+  }
+});
+
+// node_modules/es-errors/syntax.js
+var require_syntax = __commonJS({
+  "node_modules/es-errors/syntax.js"(exports, module) {
+    "use strict";
+    module.exports = SyntaxError;
+  }
+});
+
+// node_modules/es-errors/type.js
+var require_type = __commonJS({
+  "node_modules/es-errors/type.js"(exports, module) {
+    "use strict";
+    module.exports = TypeError;
+  }
+});
+
+// node_modules/es-errors/uri.js
+var require_uri = __commonJS({
+  "node_modules/es-errors/uri.js"(exports, module) {
+    "use strict";
+    module.exports = URIError;
+  }
+});
+
+// node_modules/math-intrinsics/abs.js
+var require_abs = __commonJS({
+  "node_modules/math-intrinsics/abs.js"(exports, module) {
+    "use strict";
+    module.exports = Math.abs;
+  }
+});
+
+// node_modules/math-intrinsics/floor.js
+var require_floor = __commonJS({
+  "node_modules/math-intrinsics/floor.js"(exports, module) {
+    "use strict";
+    module.exports = Math.floor;
+  }
+});
+
+// node_modules/math-intrinsics/max.js
+var require_max = __commonJS({
+  "node_modules/math-intrinsics/max.js"(exports, module) {
+    "use strict";
+    module.exports = Math.max;
+  }
+});
+
+// node_modules/math-intrinsics/min.js
+var require_min = __commonJS({
+  "node_modules/math-intrinsics/min.js"(exports, module) {
+    "use strict";
+    module.exports = Math.min;
+  }
+});
+
+// node_modules/math-intrinsics/pow.js
+var require_pow = __commonJS({
+  "node_modules/math-intrinsics/pow.js"(exports, module) {
+    "use strict";
+    module.exports = Math.pow;
+  }
+});
+
+// node_modules/math-intrinsics/round.js
+var require_round = __commonJS({
+  "node_modules/math-intrinsics/round.js"(exports, module) {
+    "use strict";
+    module.exports = Math.round;
+  }
+});
+
+// node_modules/math-intrinsics/isNaN.js
+var require_isNaN = __commonJS({
+  "node_modules/math-intrinsics/isNaN.js"(exports, module) {
+    "use strict";
+    module.exports = Number.isNaN || function isNaN2(a) {
+      return a !== a;
+    };
+  }
+});
+
+// node_modules/math-intrinsics/sign.js
+var require_sign = __commonJS({
+  "node_modules/math-intrinsics/sign.js"(exports, module) {
+    "use strict";
+    var $isNaN = require_isNaN();
+    module.exports = function sign(number) {
+      if ($isNaN(number) || number === 0) {
+        return number;
+      }
+      return number < 0 ? -1 : 1;
+    };
+  }
+});
+
+// node_modules/gopd/gOPD.js
+var require_gOPD = __commonJS({
+  "node_modules/gopd/gOPD.js"(exports, module) {
+    "use strict";
+    module.exports = Object.getOwnPropertyDescriptor;
+  }
+});
+
+// node_modules/gopd/index.js
+var require_gopd = __commonJS({
+  "node_modules/gopd/index.js"(exports, module) {
+    "use strict";
+    var $gOPD = require_gOPD();
+    if ($gOPD) {
+      try {
+        $gOPD([], "length");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    module.exports = $gOPD;
+  }
+});
+
+// node_modules/es-define-property/index.js
+var require_es_define_property = __commonJS({
+  "node_modules/es-define-property/index.js"(exports, module) {
+    "use strict";
+    var $defineProperty = Object.defineProperty || false;
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, "a", { value: 1 });
+      } catch (e) {
+        $defineProperty = false;
+      }
+    }
+    module.exports = $defineProperty;
+  }
+});
+
+// node_modules/has-symbols/shams.js
+var require_shams = __commonJS({
+  "node_modules/has-symbols/shams.js"(exports, module) {
+    "use strict";
+    module.exports = function hasSymbols() {
+      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
+        return false;
+      }
+      if (typeof Symbol.iterator === "symbol") {
+        return true;
+      }
+      var obj = {};
+      var sym = Symbol("test");
+      var symObj = Object(sym);
+      if (typeof sym === "string") {
+        return false;
+      }
+      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+        return false;
+      }
+      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+        return false;
+      }
+      var symVal = 42;
+      obj[sym] = symVal;
+      for (var _ in obj) {
+        return false;
+      }
+      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
+        return false;
+      }
+      var syms = Object.getOwnPropertySymbols(obj);
+      if (syms.length !== 1 || syms[0] !== sym) {
+        return false;
+      }
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyDescriptor === "function") {
+        var descriptor = (
+          /** @type {PropertyDescriptor} */
+          Object.getOwnPropertyDescriptor(obj, sym)
+        );
+        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
+// node_modules/has-symbols/index.js
+var require_has_symbols = __commonJS({
+  "node_modules/has-symbols/index.js"(exports, module) {
+    "use strict";
+    var origSymbol = typeof Symbol !== "undefined" && Symbol;
+    var hasSymbolSham = require_shams();
+    module.exports = function hasNativeSymbols() {
+      if (typeof origSymbol !== "function") {
+        return false;
+      }
+      if (typeof Symbol !== "function") {
+        return false;
+      }
+      if (typeof origSymbol("foo") !== "symbol") {
+        return false;
+      }
+      if (typeof Symbol("bar") !== "symbol") {
+        return false;
+      }
+      return hasSymbolSham();
+    };
+  }
+});
+
+// node_modules/get-proto/Reflect.getPrototypeOf.js
+var require_Reflect_getPrototypeOf = __commonJS({
+  "node_modules/get-proto/Reflect.getPrototypeOf.js"(exports, module) {
+    "use strict";
+    module.exports = typeof Reflect !== "undefined" && Reflect.getPrototypeOf || null;
+  }
+});
+
+// node_modules/get-proto/Object.getPrototypeOf.js
+var require_Object_getPrototypeOf = __commonJS({
+  "node_modules/get-proto/Object.getPrototypeOf.js"(exports, module) {
+    "use strict";
+    var $Object = require_es_object_atoms();
+    module.exports = $Object.getPrototypeOf || null;
+  }
+});
+
+// node_modules/function-bind/implementation.js
+var require_implementation = __commonJS({
+  "node_modules/function-bind/implementation.js"(exports, module) {
+    "use strict";
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var toStr = Object.prototype.toString;
+    var max = Math.max;
+    var funcType = "[object Function]";
+    var concatty = function concatty2(a, b) {
+      var arr = [];
+      for (var i = 0; i < a.length; i += 1) {
+        arr[i] = a[i];
+      }
+      for (var j = 0; j < b.length; j += 1) {
+        arr[j + a.length] = b[j];
+      }
+      return arr;
+    };
+    var slicy = function slicy2(arrLike, offset) {
+      var arr = [];
+      for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) {
+        arr[j] = arrLike[i];
+      }
+      return arr;
+    };
+    var joiny = function(arr, joiner) {
+      var str = "";
+      for (var i = 0; i < arr.length; i += 1) {
+        str += arr[i];
+        if (i + 1 < arr.length) {
+          str += joiner;
+        }
+      }
+      return str;
+    };
+    module.exports = function bind2(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.apply(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+      }
+      var args = slicy(arguments, 1);
+      var bound;
+      var binder = function() {
+        if (this instanceof bound) {
+          var result = target.apply(
+            this,
+            concatty(args, arguments)
+          );
+          if (Object(result) === result) {
+            return result;
+          }
+          return this;
+        }
+        return target.apply(
+          that,
+          concatty(args, arguments)
+        );
+      };
+      var boundLength = max(0, target.length - args.length);
+      var boundArgs = [];
+      for (var i = 0; i < boundLength; i++) {
+        boundArgs[i] = "$" + i;
+      }
+      bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+      if (target.prototype) {
+        var Empty = function Empty2() {
+        };
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+      }
+      return bound;
+    };
+  }
+});
+
+// node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+  "node_modules/function-bind/index.js"(exports, module) {
+    "use strict";
+    var implementation = require_implementation();
+    module.exports = Function.prototype.bind || implementation;
+  }
+});
+
+// node_modules/call-bind-apply-helpers/functionCall.js
+var require_functionCall = __commonJS({
+  "node_modules/call-bind-apply-helpers/functionCall.js"(exports, module) {
+    "use strict";
+    module.exports = Function.prototype.call;
+  }
+});
+
+// node_modules/call-bind-apply-helpers/functionApply.js
+var require_functionApply = __commonJS({
+  "node_modules/call-bind-apply-helpers/functionApply.js"(exports, module) {
+    "use strict";
+    module.exports = Function.prototype.apply;
+  }
+});
+
+// node_modules/call-bind-apply-helpers/reflectApply.js
+var require_reflectApply = __commonJS({
+  "node_modules/call-bind-apply-helpers/reflectApply.js"(exports, module) {
+    "use strict";
+    module.exports = typeof Reflect !== "undefined" && Reflect && Reflect.apply;
+  }
+});
+
+// node_modules/call-bind-apply-helpers/actualApply.js
+var require_actualApply = __commonJS({
+  "node_modules/call-bind-apply-helpers/actualApply.js"(exports, module) {
+    "use strict";
+    var bind2 = require_function_bind();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var $reflectApply = require_reflectApply();
+    module.exports = $reflectApply || bind2.call($call, $apply);
+  }
+});
+
+// node_modules/call-bind-apply-helpers/index.js
+var require_call_bind_apply_helpers = __commonJS({
+  "node_modules/call-bind-apply-helpers/index.js"(exports, module) {
+    "use strict";
+    var bind2 = require_function_bind();
+    var $TypeError = require_type();
+    var $call = require_functionCall();
+    var $actualApply = require_actualApply();
+    module.exports = function callBindBasic(args) {
+      if (args.length < 1 || typeof args[0] !== "function") {
+        throw new $TypeError("a function is required");
+      }
+      return $actualApply(bind2, $call, args);
+    };
+  }
+});
+
+// node_modules/dunder-proto/get.js
+var require_get = __commonJS({
+  "node_modules/dunder-proto/get.js"(exports, module) {
+    "use strict";
+    var callBind = require_call_bind_apply_helpers();
+    var gOPD = require_gopd();
+    var hasProtoAccessor;
+    try {
+      hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */
+      [].__proto__ === Array.prototype;
+    } catch (e) {
+      if (!e || typeof e !== "object" || !("code" in e) || e.code !== "ERR_PROTO_ACCESS") {
+        throw e;
+      }
+    }
+    var desc = !!hasProtoAccessor && gOPD && gOPD(
+      Object.prototype,
+      /** @type {keyof typeof Object.prototype} */
+      "__proto__"
+    );
+    var $Object = Object;
+    var $getPrototypeOf = $Object.getPrototypeOf;
+    module.exports = desc && typeof desc.get === "function" ? callBind([desc.get]) : typeof $getPrototypeOf === "function" ? (
+      /** @type {import('./get')} */
+      function getDunder(value) {
+        return $getPrototypeOf(value == null ? value : $Object(value));
+      }
+    ) : false;
+  }
+});
+
+// node_modules/get-proto/index.js
+var require_get_proto = __commonJS({
+  "node_modules/get-proto/index.js"(exports, module) {
+    "use strict";
+    var reflectGetProto = require_Reflect_getPrototypeOf();
+    var originalGetProto = require_Object_getPrototypeOf();
+    var getDunderProto = require_get();
+    module.exports = reflectGetProto ? function getProto(O) {
+      return reflectGetProto(O);
+    } : originalGetProto ? function getProto(O) {
+      if (!O || typeof O !== "object" && typeof O !== "function") {
+        throw new TypeError("getProto: not an object");
+      }
+      return originalGetProto(O);
+    } : getDunderProto ? function getProto(O) {
+      return getDunderProto(O);
+    } : null;
+  }
+});
+
+// node_modules/hasown/index.js
+var require_hasown = __commonJS({
+  "node_modules/hasown/index.js"(exports, module) {
+    "use strict";
+    var call = Function.prototype.call;
+    var $hasOwn = Object.prototype.hasOwnProperty;
+    var bind2 = require_function_bind();
+    module.exports = bind2.call(call, $hasOwn);
+  }
+});
+
+// node_modules/get-intrinsic/index.js
+var require_get_intrinsic = __commonJS({
+  "node_modules/get-intrinsic/index.js"(exports, module) {
+    "use strict";
+    var undefined2;
+    var $Object = require_es_object_atoms();
+    var $Error = require_es_errors();
+    var $EvalError = require_eval();
+    var $RangeError = require_range();
+    var $ReferenceError = require_ref();
+    var $SyntaxError = require_syntax();
+    var $TypeError = require_type();
+    var $URIError = require_uri();
+    var abs = require_abs();
+    var floor = require_floor();
+    var max = require_max();
+    var min = require_min();
+    var pow = require_pow();
+    var round = require_round();
+    var sign = require_sign();
+    var $Function = Function;
+    var getEvalledConstructor = function(expressionSyntax) {
+      try {
+        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+      } catch (e) {
+      }
+    };
+    var $gOPD = require_gopd();
+    var $defineProperty = require_es_define_property();
+    var throwTypeError = function() {
+      throw new $TypeError();
+    };
+    var ThrowTypeError = $gOPD ? function() {
+      try {
+        arguments.callee;
+        return throwTypeError;
+      } catch (calleeThrows) {
+        try {
+          return $gOPD(arguments, "callee").get;
+        } catch (gOPDthrows) {
+          return throwTypeError;
+        }
+      }
+    }() : throwTypeError;
+    var hasSymbols = require_has_symbols()();
+    var getProto = require_get_proto();
+    var $ObjectGPO = require_Object_getPrototypeOf();
+    var $ReflectGPO = require_Reflect_getPrototypeOf();
+    var $apply = require_functionApply();
+    var $call = require_functionCall();
+    var needsEval = {};
+    var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
+    var INTRINSICS = {
+      __proto__: null,
+      "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
+      "%Array%": Array,
+      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
+      "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
+      "%AsyncFromSyncIteratorPrototype%": undefined2,
+      "%AsyncFunction%": needsEval,
+      "%AsyncGenerator%": needsEval,
+      "%AsyncGeneratorFunction%": needsEval,
+      "%AsyncIteratorPrototype%": needsEval,
+      "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
+      "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
+      "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
+      "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
+      "%Boolean%": Boolean,
+      "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
+      "%Date%": Date,
+      "%decodeURI%": decodeURI,
+      "%decodeURIComponent%": decodeURIComponent,
+      "%encodeURI%": encodeURI,
+      "%encodeURIComponent%": encodeURIComponent,
+      "%Error%": $Error,
+      "%eval%": eval,
+      // eslint-disable-line no-eval
+      "%EvalError%": $EvalError,
+      "%Float16Array%": typeof Float16Array === "undefined" ? undefined2 : Float16Array,
+      "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
+      "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
+      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
+      "%Function%": $Function,
+      "%GeneratorFunction%": needsEval,
+      "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
+      "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
+      "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
+      "%isFinite%": isFinite,
+      "%isNaN%": isNaN,
+      "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,
+      "%JSON%": typeof JSON === "object" ? JSON : undefined2,
+      "%Map%": typeof Map === "undefined" ? undefined2 : Map,
+      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+      "%Math%": Math,
+      "%Number%": Number,
+      "%Object%": $Object,
+      "%Object.getOwnPropertyDescriptor%": $gOPD,
+      "%parseFloat%": parseFloat,
+      "%parseInt%": parseInt,
+      "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
+      "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
+      "%RangeError%": $RangeError,
+      "%ReferenceError%": $ReferenceError,
+      "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
+      "%RegExp%": RegExp,
+      "%Set%": typeof Set === "undefined" ? undefined2 : Set,
+      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
+      "%String%": String,
+      "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
+      "%Symbol%": hasSymbols ? Symbol : undefined2,
+      "%SyntaxError%": $SyntaxError,
+      "%ThrowTypeError%": ThrowTypeError,
+      "%TypedArray%": TypedArray,
+      "%TypeError%": $TypeError,
+      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
+      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
+      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
+      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
+      "%URIError%": $URIError,
+      "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
+      "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
+      "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet,
+      "%Function.prototype.call%": $call,
+      "%Function.prototype.apply%": $apply,
+      "%Object.defineProperty%": $defineProperty,
+      "%Object.getPrototypeOf%": $ObjectGPO,
+      "%Math.abs%": abs,
+      "%Math.floor%": floor,
+      "%Math.max%": max,
+      "%Math.min%": min,
+      "%Math.pow%": pow,
+      "%Math.round%": round,
+      "%Math.sign%": sign,
+      "%Reflect.getPrototypeOf%": $ReflectGPO
+    };
+    if (getProto) {
+      try {
+        null.error;
+      } catch (e) {
+        errorProto = getProto(getProto(e));
+        INTRINSICS["%Error.prototype%"] = errorProto;
+      }
+    }
+    var errorProto;
+    var doEval = function doEval2(name) {
+      var value;
+      if (name === "%AsyncFunction%") {
+        value = getEvalledConstructor("async function () {}");
+      } else if (name === "%GeneratorFunction%") {
+        value = getEvalledConstructor("function* () {}");
+      } else if (name === "%AsyncGeneratorFunction%") {
+        value = getEvalledConstructor("async function* () {}");
+      } else if (name === "%AsyncGenerator%") {
+        var fn = doEval2("%AsyncGeneratorFunction%");
+        if (fn) {
+          value = fn.prototype;
+        }
+      } else if (name === "%AsyncIteratorPrototype%") {
+        var gen = doEval2("%AsyncGenerator%");
+        if (gen && getProto) {
+          value = getProto(gen.prototype);
+        }
+      }
+      INTRINSICS[name] = value;
+      return value;
+    };
+    var LEGACY_ALIASES = {
+      __proto__: null,
+      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+      "%ArrayPrototype%": ["Array", "prototype"],
+      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+      "%ArrayProto_values%": ["Array", "prototype", "values"],
+      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+      "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+      "%BooleanPrototype%": ["Boolean", "prototype"],
+      "%DataViewPrototype%": ["DataView", "prototype"],
+      "%DatePrototype%": ["Date", "prototype"],
+      "%ErrorPrototype%": ["Error", "prototype"],
+      "%EvalErrorPrototype%": ["EvalError", "prototype"],
+      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+      "%FunctionPrototype%": ["Function", "prototype"],
+      "%Generator%": ["GeneratorFunction", "prototype"],
+      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+      "%JSONParse%": ["JSON", "parse"],
+      "%JSONStringify%": ["JSON", "stringify"],
+      "%MapPrototype%": ["Map", "prototype"],
+      "%NumberPrototype%": ["Number", "prototype"],
+      "%ObjectPrototype%": ["Object", "prototype"],
+      "%ObjProto_toString%": ["Object", "prototype", "toString"],
+      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+      "%PromisePrototype%": ["Promise", "prototype"],
+      "%PromiseProto_then%": ["Promise", "prototype", "then"],
+      "%Promise_all%": ["Promise", "all"],
+      "%Promise_reject%": ["Promise", "reject"],
+      "%Promise_resolve%": ["Promise", "resolve"],
+      "%RangeErrorPrototype%": ["RangeError", "prototype"],
+      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+      "%RegExpPrototype%": ["RegExp", "prototype"],
+      "%SetPrototype%": ["Set", "prototype"],
+      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+      "%StringPrototype%": ["String", "prototype"],
+      "%SymbolPrototype%": ["Symbol", "prototype"],
+      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+      "%TypeErrorPrototype%": ["TypeError", "prototype"],
+      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+      "%URIErrorPrototype%": ["URIError", "prototype"],
+      "%WeakMapPrototype%": ["WeakMap", "prototype"],
+      "%WeakSetPrototype%": ["WeakSet", "prototype"]
+    };
+    var bind2 = require_function_bind();
+    var hasOwn = require_hasown();
+    var $concat = bind2.call($call, Array.prototype.concat);
+    var $spliceApply = bind2.call($apply, Array.prototype.splice);
+    var $replace = bind2.call($call, String.prototype.replace);
+    var $strSlice = bind2.call($call, String.prototype.slice);
+    var $exec = bind2.call($call, RegExp.prototype.exec);
+    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+    var reEscapeChar = /\\(\\)?/g;
+    var stringToPath = function stringToPath2(string) {
+      var first = $strSlice(string, 0, 1);
+      var last = $strSlice(string, -1);
+      if (first === "%" && last !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+      } else if (last === "%" && first !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+      }
+      var result = [];
+      $replace(string, rePropName, function(match, number, quote, subString) {
+        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+      });
+      return result;
+    };
+    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
+      var intrinsicName = name;
+      var alias;
+      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+        alias = LEGACY_ALIASES[intrinsicName];
+        intrinsicName = "%" + alias[0] + "%";
+      }
+      if (hasOwn(INTRINSICS, intrinsicName)) {
+        var value = INTRINSICS[intrinsicName];
+        if (value === needsEval) {
+          value = doEval(intrinsicName);
+        }
+        if (typeof value === "undefined" && !allowMissing) {
+          throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
+        }
+        return {
+          alias,
+          name: intrinsicName,
+          value
+        };
+      }
+      throw new $SyntaxError("intrinsic " + name + " does not exist!");
+    };
+    module.exports = function GetIntrinsic(name, allowMissing) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new $TypeError("intrinsic name must be a non-empty string");
+      }
+      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+        throw new $TypeError('"allowMissing" argument must be a boolean');
+      }
+      if ($exec(/^%?[^%]*%?$/, name) === null) {
+        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+      }
+      var parts = stringToPath(name);
+      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+      var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+      var intrinsicRealName = intrinsic.name;
+      var value = intrinsic.value;
+      var skipFurtherCaching = false;
+      var alias = intrinsic.alias;
+      if (alias) {
+        intrinsicBaseName = alias[0];
+        $spliceApply(parts, $concat([0, 1], alias));
+      }
+      for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+        var part = parts[i];
+        var first = $strSlice(part, 0, 1);
+        var last = $strSlice(part, -1);
+        if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
+          throw new $SyntaxError("property names with quotes must have matching quotes");
+        }
+        if (part === "constructor" || !isOwn) {
+          skipFurtherCaching = true;
+        }
+        intrinsicBaseName += "." + part;
+        intrinsicRealName = "%" + intrinsicBaseName + "%";
+        if (hasOwn(INTRINSICS, intrinsicRealName)) {
+          value = INTRINSICS[intrinsicRealName];
+        } else if (value != null) {
+          if (!(part in value)) {
+            if (!allowMissing) {
+              throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
+            }
+            return void undefined2;
+          }
+          if ($gOPD && i + 1 >= parts.length) {
+            var desc = $gOPD(value, part);
+            isOwn = !!desc;
+            if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+              value = desc.get;
+            } else {
+              value = value[part];
+            }
+          } else {
+            isOwn = hasOwn(value, part);
+            value = value[part];
+          }
+          if (isOwn && !skipFurtherCaching) {
+            INTRINSICS[intrinsicRealName] = value;
+          }
+        }
+      }
+      return value;
+    };
+  }
+});
+
+// node_modules/has-tostringtag/shams.js
+var require_shams2 = __commonJS({
+  "node_modules/has-tostringtag/shams.js"(exports, module) {
+    "use strict";
+    var hasSymbols = require_shams();
+    module.exports = function hasToStringTagShams() {
+      return hasSymbols() && !!Symbol.toStringTag;
+    };
+  }
+});
+
+// node_modules/es-set-tostringtag/index.js
+var require_es_set_tostringtag = __commonJS({
+  "node_modules/es-set-tostringtag/index.js"(exports, module) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
+    var hasToStringTag = require_shams2()();
+    var hasOwn = require_hasown();
+    var $TypeError = require_type();
+    var toStringTag2 = hasToStringTag ? Symbol.toStringTag : null;
+    module.exports = function setToStringTag(object, value) {
+      var overrideIfSet = arguments.length > 2 && !!arguments[2] && arguments[2].force;
+      var nonConfigurable = arguments.length > 2 && !!arguments[2] && arguments[2].nonConfigurable;
+      if (typeof overrideIfSet !== "undefined" && typeof overrideIfSet !== "boolean" || typeof nonConfigurable !== "undefined" && typeof nonConfigurable !== "boolean") {
+        throw new $TypeError("if provided, the `overrideIfSet` and `nonConfigurable` options must be booleans");
+      }
+      if (toStringTag2 && (overrideIfSet || !hasOwn(object, toStringTag2))) {
+        if ($defineProperty) {
+          $defineProperty(object, toStringTag2, {
+            configurable: !nonConfigurable,
+            enumerable: false,
+            value,
+            writable: false
+          });
+        } else {
+          object[toStringTag2] = value;
+        }
+      }
+    };
+  }
+});
+
 // node_modules/form-data/lib/populate.js
 var require_populate = __commonJS({
   "node_modules/form-data/lib/populate.js"(exports, module) {
@@ -9145,13 +9991,14 @@ var require_form_data = __commonJS({
     var CombinedStream = require_combined_stream();
     var util3 = __require("util");
     var path = __require("path");
-    var http2 = __require("http");
+    var http3 = __require("http");
     var https2 = __require("https");
     var parseUrl = __require("url").parse;
     var fs = __require("fs");
     var Stream = __require("stream").Stream;
     var mime = require_mime_types();
     var asynckit = require_asynckit();
+    var setToStringTag = require_es_set_tostringtag();
     var populate = require_populate();
     module.exports = FormData3;
     util3.inherits(FormData3, CombinedStream);
@@ -9201,7 +10048,7 @@ var require_form_data = __commonJS({
       }
       this._valueLength += valueLength;
       this._overheadLength += Buffer.byteLength(header) + FormData3.LINE_BREAK.length;
-      if (!value || !value.path && !(value.readable && value.hasOwnProperty("httpVersion")) && !(value instanceof Stream)) {
+      if (!value || !value.path && !(value.readable && Object.prototype.hasOwnProperty.call(value, "httpVersion")) && !(value instanceof Stream)) {
         return;
       }
       if (!options.knownLength) {
@@ -9209,7 +10056,7 @@ var require_form_data = __commonJS({
       }
     };
     FormData3.prototype._lengthRetriever = function(value, callback) {
-      if (value.hasOwnProperty("fd")) {
+      if (Object.prototype.hasOwnProperty.call(value, "fd")) {
         if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
           callback(null, value.end + 1 - (value.start ? value.start : 0));
         } else {
@@ -9223,9 +10070,9 @@ var require_form_data = __commonJS({
             callback(null, fileSize);
           });
         }
-      } else if (value.hasOwnProperty("httpVersion")) {
+      } else if (Object.prototype.hasOwnProperty.call(value, "httpVersion")) {
         callback(null, +value.headers["content-length"]);
-      } else if (value.hasOwnProperty("httpModule")) {
+      } else if (Object.prototype.hasOwnProperty.call(value, "httpModule")) {
         value.on("response", function(response) {
           value.pause();
           callback(null, +response.headers["content-length"]);
@@ -9253,16 +10100,17 @@ var require_form_data = __commonJS({
       }
       var header;
       for (var prop in headers) {
-        if (!headers.hasOwnProperty(prop)) continue;
-        header = headers[prop];
-        if (header == null) {
-          continue;
-        }
-        if (!Array.isArray(header)) {
-          header = [header];
-        }
-        if (header.length) {
-          contents += prop + ": " + header.join("; ") + FormData3.LINE_BREAK;
+        if (Object.prototype.hasOwnProperty.call(headers, prop)) {
+          header = headers[prop];
+          if (header == null) {
+            continue;
+          }
+          if (!Array.isArray(header)) {
+            header = [header];
+          }
+          if (header.length) {
+            contents += prop + ": " + header.join("; ") + FormData3.LINE_BREAK;
+          }
         }
       }
       return "--" + this.getBoundary() + FormData3.LINE_BREAK + contents + FormData3.LINE_BREAK;
@@ -9273,7 +10121,7 @@ var require_form_data = __commonJS({
         filename = path.normalize(options.filepath).replace(/\\/g, "/");
       } else if (options.filename || value.name || value.path) {
         filename = path.basename(options.filename || value.name || value.path);
-      } else if (value.readable && value.hasOwnProperty("httpVersion")) {
+      } else if (value.readable && Object.prototype.hasOwnProperty.call(value, "httpVersion")) {
         filename = path.basename(value.client._httpMessage.path || "");
       }
       if (filename) {
@@ -9289,7 +10137,7 @@ var require_form_data = __commonJS({
       if (!contentType && value.path) {
         contentType = mime.lookup(value.path);
       }
-      if (!contentType && value.readable && value.hasOwnProperty("httpVersion")) {
+      if (!contentType && value.readable && Object.prototype.hasOwnProperty.call(value, "httpVersion")) {
         contentType = value.headers["content-type"];
       }
       if (!contentType && (options.filepath || options.filename)) {
@@ -9319,7 +10167,7 @@ var require_form_data = __commonJS({
         "content-type": "multipart/form-data; boundary=" + this.getBoundary()
       };
       for (header in userHeaders) {
-        if (userHeaders.hasOwnProperty(header)) {
+        if (Object.prototype.hasOwnProperty.call(userHeaders, header)) {
           formHeaders[header.toLowerCase()] = userHeaders[header];
         }
       }
@@ -9415,7 +10263,7 @@ var require_form_data = __commonJS({
       if (options.protocol == "https:") {
         request = https2.request(options);
       } else {
-        request = http2.request(options);
+        request = http3.request(options);
       }
       this.getLength(function(err, length) {
         if (err && err !== "Unknown stream") {
@@ -9450,6 +10298,7 @@ var require_form_data = __commonJS({
     FormData3.prototype.toString = function() {
       return "[object FormData]";
     };
+    setToStringTag(FormData3, "FormData");
   }
 });
 
@@ -10311,7 +11160,7 @@ var require_follow_redirects = __commonJS({
   "node_modules/follow-redirects/index.js"(exports, module) {
     var url2 = __require("url");
     var URL2 = url2.URL;
-    var http2 = __require("http");
+    var http3 = __require("http");
     var https2 = __require("https");
     var Writable = __require("stream").Writable;
     var assert = __require("assert");
@@ -10797,7 +11646,7 @@ var require_follow_redirects = __commonJS({
     function isURL(value) {
       return URL2 && value instanceof URL2;
     }
-    module.exports = wrap2({ http: http2, https: https2 });
+    module.exports = wrap2({ http: http3, https: https2 });
     module.exports.wrap = wrap2;
   }
 });
@@ -10807,10 +11656,7 @@ 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 } from "@modelcontextprotocol/sdk/types.js";
 
 // node_modules/axios/lib/helpers/bind.js
 function bind(fn, thisArg) {
@@ -14146,12 +14992,12 @@ var OpenAPISpecLoader = class {
       for (const [method, operation] of Object.entries(pathItem)) {
         if (method === "parameters" || !operation) continue;
         const op = operation;
-        const cleanPath = path.replace(/^\//, "");
-        const toolId = `${method.toUpperCase()}-${cleanPath}`.replace(
+        const cleanPath = path.replace(/^\//, "").replace(/\{([^}]+)\}/g, "$1");
+        const toolId = `${method.toUpperCase()}-${cleanPath}`.replace(/[^a-zA-Z0-9-]/g, "-");
+        const name = (op.operationId || op.summary || `${method.toUpperCase()} ${path}`).replace(
           /[^a-zA-Z0-9-]/g,
           "-"
         );
-        const name = (op.operationId || op.summary || `${method.toUpperCase()} ${path}`).replace(/[^a-zA-Z0-9-]/g, "-");
         const tool = {
           name,
           description: op.description || `Make a ${method.toUpperCase()} request to ${path}`,
@@ -14161,19 +15007,24 @@ var OpenAPISpecLoader = class {
           }
         };
         if (op.parameters) {
+          const requiredParams = [];
           for (const param of op.parameters) {
             if ("name" in param && "in" in param) {
               const paramSchema = param.schema;
-              tool.inputSchema.properties[param.name] = {
-                type: paramSchema.type || "string",
-                description: param.description || `${param.name} parameter`
-              };
-              if (param.required) {
-                tool.inputSchema.required = tool.inputSchema.required || [];
-                tool.inputSchema.required.push(param.name);
+              if (tool.inputSchema && tool.inputSchema.properties) {
+                tool.inputSchema.properties[param.name] = {
+                  type: paramSchema.type || "string",
+                  description: param.description || `${param.name} parameter`
+                };
+              }
+              if (param.required === true) {
+                requiredParams.push(param.name);
               }
             }
           }
+          if (requiredParams.length > 0 && tool.inputSchema) {
+            tool.inputSchema.required = requiredParams;
+          }
         }
         tools.set(toolId, tool);
       }
@@ -14234,12 +15085,11 @@ var ToolsManager = class {
 var ApiClient = class {
   /**
    * Create a new API client
-   * 
+   *
    * @param baseUrl - Base URL for the API
    * @param headers - Optional headers to include with every request
    */
   constructor(baseUrl, headers = {}) {
-    this.baseUrl = baseUrl;
     this.headers = headers;
     this.axiosInstance = axios_default.create({
       baseURL: baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`
@@ -14248,7 +15098,7 @@ var ApiClient = class {
   axiosInstance;
   /**
    * Execute an API call based on the tool ID and parameters
-   * 
+   *
    * @param toolId - The tool ID in format METHOD-path-parts
    * @param params - Parameters for the API call
    * @returns The API response data
@@ -14280,7 +15130,7 @@ var ApiClient = class {
   }
   /**
    * Parse a tool ID into HTTP method and path
-   * 
+   *
    * @param toolId - Tool ID in format METHOD-path-parts
    * @returns Object containing method and path
    */
@@ -14292,7 +15142,7 @@ var ApiClient = class {
   /**
    * Process query parameters for GET requests
    * Converts arrays to comma-separated strings
-   * 
+   *
    * @param params - The original parameters
    * @returns Processed parameters
    */
@@ -14311,13 +15161,18 @@ var ApiClient = class {
 
 // src/server.ts
 var OpenAPIServer = class {
+  server;
+  toolsManager;
+  apiClient;
   constructor(config) {
-    this.config = config;
     this.server = new Server(
       { name: config.name, version: config.version },
       {
         capabilities: {
-          tools: {}
+          tools: {
+            list: true,
+            execute: true
+          }
         }
       }
     );
@@ -14325,9 +15180,6 @@ var OpenAPIServer = class {
     this.apiClient = new ApiClient(config.apiBaseUrl, config.headers);
     this.initializeHandlers();
   }
-  server;
-  toolsManager;
-  apiClient;
   /**
    * Initialize request handlers
    */
@@ -14341,7 +15193,7 @@ var OpenAPIServer = class {
       const { id, name, arguments: params } = request.params;
       console.error("Received request:", request.params);
       console.error("Using parameters from arguments:", params);
-      const idOrName = id || name;
+      const idOrName = typeof id === "string" ? id : typeof name === "string" ? name : "";
       if (!idOrName) {
         throw new Error("Tool ID or name is required");
       }
@@ -14355,10 +15207,7 @@ var OpenAPIServer = class {
       const { toolId, tool } = toolInfo;
       console.error(`Executing tool: ${toolId} (${tool.name})`);
       try {
-        const result = await this.apiClient.executeApiCall(
-          toolId,
-          params || {}
-        );
+        const result = await this.apiClient.executeApiCall(toolId, params || {});
         return {
           content: [
             {
@@ -19253,7 +20102,22 @@ function parseHeaders(headerStr) {
   return headers;
 }
 function loadConfig() {
-  const argv = yargs_default(hideBin(process.argv)).option("api-base-url", {
+  const argv = yargs_default(hideBin(process.argv)).option("transport", {
+    alias: "t",
+    type: "string",
+    choices: ["stdio", "http"],
+    description: "Transport type to use (stdio or http)"
+  }).option("port", {
+    alias: "p",
+    type: "number",
+    description: "HTTP port for HTTP transport"
+  }).option("host", {
+    type: "string",
+    description: "HTTP host for HTTP transport"
+  }).option("path", {
+    type: "string",
+    description: "HTTP endpoint path for HTTP transport"
+  }).option("api-base-url", {
     alias: "u",
     type: "string",
     description: "Base URL for the API"
@@ -19273,18 +20137,23 @@ function loadConfig() {
     alias: "v",
     type: "string",
     description: "Server version"
-  }).help().argv;
+  }).help().parseSync();
+  let transportType;
+  if (argv.transport === "http" || process.env.TRANSPORT_TYPE === "http") {
+    transportType = "http";
+  } else {
+    transportType = "stdio";
+  }
+  const httpPort = argv.port ?? (process.env.HTTP_PORT ? parseInt(process.env.HTTP_PORT, 10) : 3e3);
+  const httpHost = argv.host || process.env.HTTP_HOST || "127.0.0.1";
+  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;
   if (!apiBaseUrl) {
-    throw new Error(
-      "API base URL is required (--api-base-url or API_BASE_URL)"
-    );
+    throw new Error("API base URL is required (--api-base-url or API_BASE_URL)");
   }
   if (!openApiSpec) {
-    throw new Error(
-      "OpenAPI spec is required (--openapi-spec or OPENAPI_SPEC_PATH)"
-    );
+    throw new Error("OpenAPI spec is required (--openapi-spec or OPENAPI_SPEC_PATH)");
   }
   const headers = parseHeaders(argv.headers || process.env.API_HEADERS);
   return {
@@ -19292,18 +20161,582 @@ function loadConfig() {
     version: argv.version || process.env.SERVER_VERSION || "1.0.0",
     apiBaseUrl,
     openApiSpec,
-    headers
+    headers,
+    transportType,
+    httpPort,
+    httpHost,
+    endpointPath
   };
 }
 
+// src/transport/StreamableHttpServerTransport.ts
+import {
+  isInitializeRequest,
+  isJSONRPCRequest,
+  isJSONRPCResponse
+} from "@modelcontextprotocol/sdk/types.js";
+import * as http2 from "http";
+import { randomUUID } from "crypto";
+var StreamableHttpServerTransport = class {
+  // Maps request IDs to session IDs
+  /**
+   * Initialize a new StreamableHttpServerTransport
+   *
+   * @param port HTTP port to listen on
+   * @param host Host to bind to (default: 127.0.0.1)
+   * @param endpointPath Endpoint path (default: /mcp)
+   */
+  constructor(port, host = "127.0.0.1", endpointPath = "/mcp") {
+    this.port = port;
+    this.host = host;
+    this.endpointPath = endpointPath;
+    this.server = http2.createServer(this.handleRequest.bind(this));
+  }
+  server;
+  sessions = /* @__PURE__ */ new Map();
+  started = false;
+  maxBodySize = 4 * 1024 * 1024;
+  // 4MB max request size
+  requestSessionMap = /* @__PURE__ */ new Map();
+  /**
+   * Callback when message is received
+   */
+  onmessage;
+  /**
+   * Callback when error occurs
+   */
+  onerror;
+  /**
+   * Callback when transport closes
+   */
+  onclose;
+  /**
+   * Start the transport
+   */
+  async start() {
+    if (this.started) {
+      throw new Error("Transport already started");
+    }
+    return new Promise((resolve5, 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();
+      });
+      this.server.on("error", (err) => {
+        reject(err);
+        if (this.onerror) {
+          this.onerror(err);
+        }
+      });
+    });
+  }
+  /**
+   * Close the transport
+   */
+  async close() {
+    for (const session of this.sessions.values()) {
+      for (const response of session.activeResponses) {
+        try {
+          response.end();
+        } catch (err) {
+        }
+      }
+    }
+    this.sessions.clear();
+    return new Promise((resolve5, reject) => {
+      this.server.close((err) => {
+        if (err) {
+          reject(err instanceof Error ? err : new Error(String(err)));
+        } else {
+          this.started = false;
+          if (this.onclose) {
+            this.onclose();
+          }
+          resolve5();
+        }
+      });
+    });
+  }
+  /**
+   * Send message to client(s)
+   *
+   * @param message JSON-RPC message
+   */
+  async send(message) {
+    console.error(`StreamableHttpServerTransport: Sending message: ${JSON.stringify(message)}`);
+    let targetSessionId;
+    let messageIdForThisResponse = null;
+    if (isJSONRPCResponse(message) && message.id !== null) {
+      messageIdForThisResponse = message.id;
+      targetSessionId = this.requestSessionMap.get(messageIdForThisResponse);
+      console.error(
+        `StreamableHttpServerTransport: Potential target session for response ID ${messageIdForThisResponse}: ${targetSessionId}`
+      );
+      if (targetSessionId && this.initResponseHandlers.has(targetSessionId)) {
+        console.error(
+          `StreamableHttpServerTransport: Session ${targetSessionId} has initResponseHandlers. Invoking them for message ID ${messageIdForThisResponse}.`
+        );
+        const handlers = this.initResponseHandlers.get(targetSessionId);
+        [...handlers].forEach((handler) => handler(message));
+        if (!this.requestSessionMap.has(messageIdForThisResponse)) {
+          console.error(
+            `StreamableHttpServerTransport: Response for ID ${messageIdForThisResponse} was handled by an initResponseHandler (e.g., synchronous POST response for initialize or tools/list).`
+          );
+          return;
+        } else {
+          console.error(
+            `StreamableHttpServerTransport: Response for ID ${messageIdForThisResponse} was NOT exclusively handled by an initResponseHandler or handler did not remove from requestSessionMap. Proceeding to GET stream / broadcast if applicable.`
+          );
+        }
+      }
+      if (this.requestSessionMap.has(messageIdForThisResponse)) {
+        console.error(
+          `StreamableHttpServerTransport: Deleting request ID ${messageIdForThisResponse} from requestSessionMap as it's being processed for GET stream or broadcast.`
+        );
+        this.requestSessionMap.delete(messageIdForThisResponse);
+      }
+    }
+    if (!targetSessionId) {
+      const idForLog = messageIdForThisResponse !== null ? messageIdForThisResponse : isJSONRPCRequest(message) ? message.id : "N/A";
+      console.warn(
+        `StreamableHttpServerTransport: No specific target session for message (ID: ${idForLog}). Broadcasting to all applicable sessions.`
+      );
+      for (const [sid, session2] of this.sessions.entries()) {
+        if (session2.initialized && session2.activeResponses.size > 0) {
+          this.sendMessageToSession(sid, session2, message);
+        }
+      }
+      return;
+    }
+    const session = this.sessions.get(targetSessionId);
+    if (session && session.activeResponses.size > 0) {
+      console.error(
+        `StreamableHttpServerTransport: Sending message (ID: ${messageIdForThisResponse}) to GET stream for session ${targetSessionId} (${session.activeResponses.size} active connections).`
+      );
+      this.sendMessageToSession(targetSessionId, session, message);
+    } else if (targetSessionId) {
+      console.error(
+        `StreamableHttpServerTransport: No active GET connections for session ${targetSessionId} to send message (ID: ${messageIdForThisResponse}). Message might not be delivered if not handled by POST.`
+      );
+    }
+  }
+  /**
+   * Helper method to send a message to a specific session
+   */
+  sendMessageToSession(sessionId, session, message) {
+    const messageStr = `data: ${JSON.stringify(message)}
+
+`;
+    for (const response of session.activeResponses) {
+      try {
+        response.write(messageStr);
+      } catch (err) {
+        session.activeResponses.delete(response);
+        if (this.onerror) {
+          this.onerror(new Error(`Failed to write to response: ${err.message}`));
+        }
+      }
+    }
+  }
+  /**
+   * Handle HTTP request
+   */
+  handleRequest(req, res) {
+    if (req.url !== this.endpointPath) {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    this.validateOrigin(req, res);
+    switch (req.method) {
+      case "POST":
+        this.handlePostRequest(req, res);
+        break;
+      case "GET":
+        this.handleGetRequest(req, res);
+        break;
+      case "DELETE":
+        this.handleDeleteRequest(req, res);
+        break;
+      default:
+        res.writeHead(405, { Allow: "POST, GET, DELETE" });
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Method not allowed"
+            },
+            id: null
+          })
+        );
+    }
+  }
+  /**
+   * Validate origin header to prevent DNS rebinding attacks
+   */
+  validateOrigin(req, res) {
+    const origin2 = req.headers.origin;
+    if (!origin2) {
+      return true;
+    }
+    try {
+      const originUrl = new URL(origin2);
+      const isLocalhost = originUrl.hostname === "localhost" || originUrl.hostname === "127.0.0.1";
+      if (!isLocalhost) {
+        res.writeHead(403);
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Origin not allowed"
+            },
+            id: null
+          })
+        );
+        return false;
+      }
+      return true;
+    } catch (err) {
+      res.writeHead(400);
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32e3,
+            message: "Invalid origin"
+          },
+          id: null
+        })
+      );
+      return false;
+    }
+  }
+  /**
+   * Handle POST request
+   */
+  handlePostRequest(req, res) {
+    const contentType = req.headers["content-type"];
+    if (!contentType || !contentType.includes("application/json")) {
+      res.writeHead(415);
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32e3,
+            message: "Unsupported Media Type: Content-Type must be application/json"
+          },
+          id: null
+        })
+      );
+      return;
+    }
+    let body = "";
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > this.maxBodySize) {
+        res.writeHead(413);
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Request entity too large"
+            },
+            id: null
+          })
+        );
+        req.destroy();
+        return;
+      }
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        const message = JSON.parse(body);
+        if (isInitializeRequest(message)) {
+          this.handleInitializeRequest(message, req, res);
+        } else if (isJSONRPCRequest(message) && message.method === "tools/list") {
+          const sessionId = req.headers["mcp-session-id"];
+          if (!sessionId || !this.sessions.has(sessionId)) {
+            res.writeHead(400);
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Invalid session. A valid Mcp-Session-Id header is required."
+                },
+                id: "id" in message ? message.id : null
+              })
+            );
+            return;
+          }
+          const session = this.sessions.get(sessionId);
+          if (message.id !== void 0 && message.id !== null) {
+            this.requestSessionMap.set(message.id, sessionId);
+            if (!session.pendingRequests) {
+              session.pendingRequests = /* @__PURE__ */ new Set();
+            }
+            session.pendingRequests.add(message.id);
+          }
+          const responseHandler = (responseMessage) => {
+            if (isJSONRPCResponse(responseMessage) && responseMessage.id === message.id) {
+              res.setHeader("Content-Type", "application/json");
+              res.writeHead(200);
+              res.end(JSON.stringify(responseMessage));
+              this.removeInitResponseHandler(sessionId, responseHandler);
+              if (message.id !== void 0 && message.id !== null) {
+                this.requestSessionMap.delete(message.id);
+                session.pendingRequests.delete(message.id);
+              }
+            }
+          };
+          this.addInitResponseHandler(sessionId, responseHandler);
+          if (session.messageHandler) {
+            session.messageHandler(message);
+          } else {
+            this.removeInitResponseHandler(sessionId, responseHandler);
+            res.writeHead(500);
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: {
+                  code: -32603,
+                  message: "Internal error: No message handler available"
+                },
+                id: "id" in message ? message.id : null
+              })
+            );
+          }
+        } else {
+          const sessionId = req.headers["mcp-session-id"];
+          if (!sessionId || !this.sessions.has(sessionId)) {
+            res.writeHead(400);
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: {
+                  code: -32e3,
+                  message: "Invalid session. A valid Mcp-Session-Id header is required."
+                },
+                id: "id" in message ? message.id : null
+              })
+            );
+            return;
+          }
+          const session = this.sessions.get(sessionId);
+          if (isJSONRPCRequest(message)) {
+            if (session.messageHandler) {
+              if (message.id !== void 0 && message.id !== null) {
+                this.requestSessionMap.set(message.id, sessionId);
+                if (!session.pendingRequests) {
+                  session.pendingRequests = /* @__PURE__ */ new Set();
+                }
+                session.pendingRequests.add(message.id);
+              }
+              session.messageHandler(message);
+              res.writeHead(202);
+              res.end();
+            }
+          } else {
+            if (session.messageHandler) {
+              session.messageHandler(message);
+              res.writeHead(202);
+              res.end();
+            }
+          }
+        }
+      } catch (err) {
+        res.writeHead(400);
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32700,
+              message: "Parse error",
+              data: String(err)
+            },
+            id: null
+          })
+        );
+        if (this.onerror) {
+          this.onerror(new Error(`Parse error: ${String(err)}`));
+        }
+      }
+    });
+    req.on("error", (err) => {
+      if (this.onerror) {
+        this.onerror(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  /**
+   * Handle initialization request
+   */
+  handleInitializeRequest(message, _req, res) {
+    const sessionId = randomUUID();
+    this.sessions.set(sessionId, {
+      // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+      messageHandler: this.onmessage || (() => {
+      }),
+      activeResponses: /* @__PURE__ */ new Set(),
+      initialized: true,
+      pendingRequests: /* @__PURE__ */ new Set()
+    });
+    if ("id" in message && message.id !== null && message.id !== void 0) {
+      this.requestSessionMap.set(message.id, sessionId);
+    }
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Mcp-Session-Id", sessionId);
+    const responseHandler = (responseMessage) => {
+      if (isJSONRPCResponse(responseMessage) && "id" in message && responseMessage.id === message.id) {
+        res.writeHead(200);
+        res.end(JSON.stringify(responseMessage));
+        this.removeInitResponseHandler(sessionId, responseHandler);
+        this.requestSessionMap.delete(message.id);
+      }
+    };
+    this.addInitResponseHandler(sessionId, responseHandler);
+    if (this.onmessage) {
+      this.onmessage(message);
+    } else {
+      this.removeInitResponseHandler(sessionId, responseHandler);
+      res.writeHead(500);
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: "Internal error: No message handler available"
+          },
+          id: "id" in message ? message.id : null
+        })
+      );
+    }
+  }
+  /**
+   * Add initialize response handler
+   */
+  initResponseHandlers = /* @__PURE__ */ new Map();
+  addInitResponseHandler(sessionId, handler) {
+    if (!this.initResponseHandlers.has(sessionId)) {
+      this.initResponseHandlers.set(sessionId, []);
+    }
+    this.initResponseHandlers.get(sessionId).push(handler);
+  }
+  removeInitResponseHandler(sessionId, handler) {
+    if (this.initResponseHandlers.has(sessionId)) {
+      const handlers = this.initResponseHandlers.get(sessionId);
+      const index = handlers.indexOf(handler);
+      if (index !== -1) {
+        handlers.splice(index, 1);
+      }
+      if (handlers.length === 0) {
+        this.initResponseHandlers.delete(sessionId);
+      }
+    }
+  }
+  /**
+   * Handle GET request (streaming connection)
+   */
+  handleGetRequest(req, res) {
+    const sessionId = req.headers["mcp-session-id"];
+    if (!sessionId || !this.sessions.has(sessionId)) {
+      res.writeHead(400);
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32e3,
+            message: "Invalid session. A valid Mcp-Session-Id header is required."
+          },
+          id: null
+        })
+      );
+      return;
+    }
+    const session = this.sessions.get(sessionId);
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("Cache-Control", "no-cache, no-transform");
+    res.setHeader("Transfer-Encoding", "chunked");
+    res.setHeader("Mcp-Session-Id", sessionId);
+    res.writeHead(200);
+    session.activeResponses.add(res);
+    req.on("close", () => {
+      session.activeResponses.delete(res);
+    });
+    res.on("error", (err) => {
+      session.activeResponses.delete(res);
+      if (this.onerror) {
+        this.onerror(err);
+      }
+    });
+  }
+  /**
+   * Handle DELETE request (session termination)
+   */
+  handleDeleteRequest(req, res) {
+    const sessionId = req.headers["mcp-session-id"];
+    if (!sessionId || !this.sessions.has(sessionId)) {
+      res.writeHead(400);
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32e3,
+            message: "Invalid session. A valid Mcp-Session-Id header is required."
+          },
+          id: null
+        })
+      );
+      return;
+    }
+    const session = this.sessions.get(sessionId);
+    for (const response of session.activeResponses) {
+      try {
+        response.end();
+      } catch (err) {
+      }
+    }
+    if (session.pendingRequests) {
+      for (const requestId of session.pendingRequests) {
+        this.requestSessionMap.delete(requestId);
+      }
+    }
+    this.sessions.delete(sessionId);
+    res.writeHead(204);
+    res.end();
+  }
+};
+
 // src/index.ts
 async function main() {
   try {
     const config = loadConfig();
     const server = new OpenAPIServer(config);
-    const transport = new StdioServerTransport();
-    await server.start(transport);
-    console.error("OpenAPI MCP Server running on stdio");
+    let transport;
+    if (config.transportType === "http") {
+      transport = new StreamableHttpServerTransport(
+        config.httpPort,
+        config.httpHost,
+        config.endpointPath
+      );
+      await server.start(transport);
+      console.error(
+        `OpenAPI MCP Server running on http://${config.httpHost}:${config.httpPort}${config.endpointPath}`
+      );
+    } else {
+      transport = new StdioServerTransport();
+      await server.start(transport);
+      console.error("OpenAPI MCP Server running on stdio");
+    }
   } catch (error) {
     console.error("Failed to start server:", error);
     process.exit(1);
@@ -19314,6 +20747,7 @@ export {
   ApiClient,
   OpenAPIServer,
   OpenAPISpecLoader,
+  StreamableHttpServerTransport,
   ToolsManager,
   loadConfig,
   parseHeaders