@mastra/deployer 0.3.4-alpha.0 → 0.3.4-alpha.2

package/dist/server/index.cjs

@@ -22,6 +22,8 @@ var a2a = require('@mastra/server/handlers/a2a');
 var streaming = require('hono/streaming');
 var agents = require('@mastra/server/handlers/agents');
 var logs = require('@mastra/server/handlers/logs');
+var util = require('util');
+var buffer = require('buffer');
 var memory = require('@mastra/server/handlers/memory');
 var network = require('@mastra/server/handlers/network');
 var agent = require('@mastra/core/agent');
@@ -36,6 +38,7 @@ var workflows = require('@mastra/server/handlers/workflows');
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+var util__default = /*#__PURE__*/_interopDefault(util);
 
 // src/server/index.ts
 var RequestError = class extends Error {
@@ -1111,6 +1114,1923 @@ async function getLogTransports(c2) {
     return handleError(error, "Error getting log Transports");
   }
 }
+var classRegExp = /^([A-Z][a-z0-9]*)+$/;
+var kTypes = [
+  "string",
+  "function",
+  "number",
+  "object",
+  // Accept 'Function' and 'Object' as alternative to the lower cased version.
+  "Function",
+  "Object",
+  "boolean",
+  "bigint",
+  "symbol"
+];
+function determineSpecificType(value) {
+  if (value == null) {
+    return "" + value;
+  }
+  if (typeof value === "function" && value.name) {
+    return `function ${value.name}`;
+  }
+  if (typeof value === "object") {
+    if (value.constructor?.name) {
+      return `an instance of ${value.constructor.name}`;
+    }
+    return `${util__default.default.inspect(value, { depth: -1 })}`;
+  }
+  let inspected = util__default.default.inspect(value, { colors: false });
+  if (inspected.length > 28) {
+    inspected = `${inspected.slice(0, 25)}...`;
+  }
+  return `type ${typeof value} (${inspected})`;
+}
+var ERR_HTTP_BODY_NOT_ALLOWED = class extends Error {
+  constructor() {
+    super("Adding content for this request method or response status is not allowed.");
+  }
+};
+var ERR_HTTP_CONTENT_LENGTH_MISMATCH = class extends Error {
+  constructor(actual, expected) {
+    super(`Response body's content-length of ${actual} byte(s) does not match the content-length of ${expected} byte(s) set in header`);
+  }
+};
+var ERR_HTTP_HEADERS_SENT = class extends Error {
+  constructor(arg) {
+    super(`Cannot ${arg} headers after they are sent to the client`);
+  }
+};
+var ERR_INVALID_ARG_VALUE = class extends TypeError {
+  constructor(name, value, reason = "is invalid") {
+    let inspected = util__default.default.inspect(value);
+    if (inspected.length > 128) {
+      inspected = `${inspected.slice(0, 128)}...`;
+    }
+    const type = name.includes(".") ? "property" : "argument";
+    super(`The ${type} '${name}' ${reason}. Received ${inspected}`);
+  }
+};
+var ERR_INVALID_CHAR = class extends TypeError {
+  constructor(name, field) {
+    let msg = `Invalid character in ${name}`;
+    if (field !== void 0) {
+      msg += ` ["${field}"]`;
+    }
+    super(msg);
+  }
+};
+var ERR_HTTP_INVALID_HEADER_VALUE = class extends TypeError {
+  constructor(value, name) {
+    super(`Invalid value "${value}" for header "${name}"`);
+  }
+};
+var ERR_HTTP_INVALID_STATUS_CODE = class extends RangeError {
+  originalStatusCode;
+  constructor(originalStatusCode) {
+    super(`Invalid status code: ${originalStatusCode}`);
+    this.originalStatusCode = originalStatusCode;
+  }
+};
+var ERR_HTTP_TRAILER_INVALID = class extends Error {
+  constructor() {
+    super(`Trailers are invalid with this transfer encoding`);
+  }
+};
+var ERR_INVALID_ARG_TYPE = class extends TypeError {
+  constructor(name, expected, actual) {
+    if (!Array.isArray(expected)) {
+      expected = [expected];
+    }
+    let msg = "The ";
+    if (name.endsWith(" argument")) {
+      msg += `${name} `;
+    } else {
+      const type = name.includes(".") ? "property" : "argument";
+      msg += `"${name}" ${type} `;
+    }
+    msg += "must be ";
+    const types = [];
+    const instances = [];
+    const other = [];
+    for (const value of expected) {
+      if (kTypes.includes(value)) {
+        types.push(value.toLowerCase());
+      } else if (classRegExp.exec(value) !== null) {
+        instances.push(value);
+      } else {
+        other.push(value);
+      }
+    }
+    if (instances.length > 0) {
+      const pos = types.indexOf("object");
+      if (pos !== -1) {
+        types.splice(pos, 1);
+        instances.push("Object");
+      }
+    }
+    if (types.length > 0) {
+      if (types.length > 2) {
+        const last = types.pop();
+        msg += `one of type ${types.join(", ")}, or ${last}`;
+      } else if (types.length === 2) {
+        msg += `one of type ${types[0]} or ${types[1]}`;
+      } else {
+        msg += `of type ${types[0]}`;
+      }
+      if (instances.length > 0 || other.length > 0)
+        msg += " or ";
+    }
+    if (instances.length > 0) {
+      if (instances.length > 2) {
+        const last = instances.pop();
+        msg += `an instance of ${instances.join(", ")}, or ${last}`;
+      } else {
+        msg += `an instance of ${instances[0]}`;
+        if (instances.length === 2) {
+          msg += ` or ${instances[1]}`;
+        }
+      }
+      if (other.length > 0)
+        msg += " or ";
+    }
+    if (other.length > 0) {
+      if (other.length > 2) {
+        const last = other.pop();
+        msg += `one of ${other.join(", ")}, or ${last}`;
+      } else if (other.length === 2) {
+        msg += `one of ${other[0]} or ${other[1]}`;
+      } else {
+        if (other[0].toLowerCase() !== other[0])
+          msg += "an ";
+        msg += `${other[0]}`;
+      }
+    }
+    msg += `. Received ${determineSpecificType(actual)}`;
+    super(msg);
+  }
+};
+var ERR_INVALID_HTTP_TOKEN = class extends TypeError {
+  constructor(name, field) {
+    super(`${name} must be a valid HTTP token ["${field}"]`);
+  }
+};
+var ERR_METHOD_NOT_IMPLEMENTED = class extends Error {
+  constructor(methodName) {
+    super(`The ${methodName} method is not implemented`);
+  }
+};
+var ERR_STREAM_ALREADY_FINISHED = class extends Error {
+  constructor(methodName) {
+    super(`Cannot call ${methodName} after a stream was finished`);
+  }
+};
+var ERR_STREAM_CANNOT_PIPE = class extends Error {
+  constructor() {
+    super(`Cannot pipe, not readable`);
+  }
+};
+var ERR_STREAM_DESTROYED = class extends Error {
+  constructor(methodName) {
+    super(`Cannot call ${methodName} after a stream was destroyed`);
+  }
+};
+var ERR_STREAM_NULL_VALUES = class extends TypeError {
+  constructor() {
+    super(`May not write null values to stream`);
+  }
+};
+var ERR_STREAM_WRITE_AFTER_END = class extends Error {
+  constructor() {
+    super(`write after end`);
+  }
+};
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/fetch-to-node/http-incoming.js
+var kHeaders = Symbol("kHeaders");
+var kHeadersDistinct = Symbol("kHeadersDistinct");
+var kHeadersCount = Symbol("kHeadersCount");
+var kTrailers = Symbol("kTrailers");
+var kTrailersDistinct = Symbol("kTrailersDistinct");
+var kTrailersCount = Symbol("kTrailersCount");
+var FetchIncomingMessage = class extends stream.Readable {
+  get socket() {
+    return null;
+  }
+  set socket(_val) {
+    throw new ERR_METHOD_NOT_IMPLEMENTED("socket");
+  }
+  httpVersionMajor;
+  httpVersionMinor;
+  httpVersion;
+  complete = false;
+  [kHeaders] = null;
+  [kHeadersDistinct] = null;
+  [kHeadersCount] = 0;
+  rawHeaders = [];
+  [kTrailers] = null;
+  [kTrailersDistinct] = null;
+  [kTrailersCount] = 0;
+  rawTrailers = [];
+  joinDuplicateHeaders = false;
+  aborted = false;
+  upgrade = false;
+  // request (server) only
+  url = "";
+  method;
+  // TODO: Support ClientRequest
+  // statusCode = null;
+  // statusMessage = null;
+  // client = socket;
+  _consuming;
+  _dumped;
+  // The underlying ReadableStream
+  _stream = null;
+  constructor() {
+    const streamOptions = {};
+    super(streamOptions);
+    this._readableState.readingMore = true;
+    this._consuming = false;
+    this._dumped = false;
+  }
+  get connection() {
+    return null;
+  }
+  set connection(_socket) {
+    console.error("No support for IncomingMessage.connection");
+  }
+  get headers() {
+    if (!this[kHeaders]) {
+      this[kHeaders] = {};
+      const src = this.rawHeaders;
+      const dst = this[kHeaders];
+      for (let n2 = 0; n2 < this[kHeadersCount]; n2 += 2) {
+        this._addHeaderLine(src[n2], src[n2 + 1], dst);
+      }
+    }
+    return this[kHeaders];
+  }
+  set headers(val) {
+    this[kHeaders] = val;
+  }
+  get headersDistinct() {
+    if (!this[kHeadersDistinct]) {
+      this[kHeadersDistinct] = {};
+      const src = this.rawHeaders;
+      const dst = this[kHeadersDistinct];
+      for (let n2 = 0; n2 < this[kHeadersCount]; n2 += 2) {
+        this._addHeaderLineDistinct(src[n2], src[n2 + 1], dst);
+      }
+    }
+    return this[kHeadersDistinct];
+  }
+  set headersDistinct(val) {
+    this[kHeadersDistinct] = val;
+  }
+  get trailers() {
+    if (!this[kTrailers]) {
+      this[kTrailers] = {};
+      const src = this.rawTrailers;
+      const dst = this[kTrailers];
+      for (let n2 = 0; n2 < this[kTrailersCount]; n2 += 2) {
+        this._addHeaderLine(src[n2], src[n2 + 1], dst);
+      }
+    }
+    return this[kTrailers];
+  }
+  set trailers(val) {
+    this[kTrailers] = val;
+  }
+  get trailersDistinct() {
+    if (!this[kTrailersDistinct]) {
+      this[kTrailersDistinct] = {};
+      const src = this.rawTrailers;
+      const dst = this[kTrailersDistinct];
+      for (let n2 = 0; n2 < this[kTrailersCount]; n2 += 2) {
+        this._addHeaderLineDistinct(src[n2], src[n2 + 1], dst);
+      }
+    }
+    return this[kTrailersDistinct];
+  }
+  set trailersDistinct(val) {
+    this[kTrailersDistinct] = val;
+  }
+  setTimeout(msecs, callback) {
+    return this;
+  }
+  async _read(n2) {
+    if (!this._consuming) {
+      this._readableState.readingMore = false;
+      this._consuming = true;
+    }
+    if (this._stream == null) {
+      this.complete = true;
+      this.push(null);
+      return;
+    }
+    const reader = this._stream.getReader();
+    try {
+      const data = await reader.read();
+      if (data.done) {
+        this.complete = true;
+        this.push(null);
+      } else {
+        this.push(data.value);
+      }
+    } catch (e2) {
+      this.destroy(e2);
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  _destroy(err, cb) {
+    if (!this.readableEnded || !this.complete) {
+      this.aborted = true;
+      this.emit("aborted");
+    }
+    setTimeout(onError, 0, this, err, cb);
+  }
+  _addHeaderLines(headers, n2) {
+    if (headers?.length) {
+      let dest;
+      if (this.complete) {
+        this.rawTrailers = headers;
+        this[kTrailersCount] = n2;
+        dest = this[kTrailers];
+      } else {
+        this.rawHeaders = headers;
+        this[kHeadersCount] = n2;
+        dest = this[kHeaders];
+      }
+      if (dest) {
+        for (let i2 = 0; i2 < n2; i2 += 2) {
+          this._addHeaderLine(headers[i2], headers[i2 + 1], dest);
+        }
+      }
+    }
+  }
+  // Add the given (field, value) pair to the message
+  //
+  // Per RFC2616, section 4.2 it is acceptable to join multiple instances of the
+  // same header with a ', ' if the header in question supports specification of
+  // multiple values this way. The one exception to this is the Cookie header,
+  // which has multiple values joined with a '; ' instead. If a header's values
+  // cannot be joined in either of these ways, we declare the first instance the
+  // winner and drop the second. Extended header fields (those beginning with
+  // 'x-') are always joined.
+  _addHeaderLine(field, value, dest) {
+    field = matchKnownFields(field);
+    const flag = field.charCodeAt(0);
+    if (flag === 0 || flag === 2) {
+      field = field.slice(1);
+      if (typeof dest[field] === "string") {
+        dest[field] += (flag === 0 ? ", " : "; ") + value;
+      } else {
+        dest[field] = value;
+      }
+    } else if (flag === 1) {
+      if (dest["set-cookie"] !== void 0) {
+        dest["set-cookie"].push(value);
+      } else {
+        dest["set-cookie"] = [value];
+      }
+    } else if (this.joinDuplicateHeaders) {
+      if (dest[field] === void 0) {
+        dest[field] = value;
+      } else {
+        dest[field] += ", " + value;
+      }
+    } else if (dest[field] === void 0) {
+      dest[field] = value;
+    }
+  }
+  _addHeaderLineDistinct(field, value, dest) {
+    field = field.toLowerCase();
+    if (!dest[field]) {
+      dest[field] = [value];
+    } else {
+      dest[field].push(value);
+    }
+  }
+  // Call this instead of resume() if we want to just
+  // dump all the data to /dev/null
+  _dump() {
+    if (!this._dumped) {
+      this._dumped = true;
+      this.removeAllListeners("data");
+      this.resume();
+    }
+  }
+};
+function matchKnownFields(field, lowercased = false) {
+  switch (field.length) {
+    case 3:
+      if (field === "Age" || field === "age")
+        return "age";
+      break;
+    case 4:
+      if (field === "Host" || field === "host")
+        return "host";
+      if (field === "From" || field === "from")
+        return "from";
+      if (field === "ETag" || field === "etag")
+        return "etag";
+      if (field === "Date" || field === "date")
+        return "\0date";
+      if (field === "Vary" || field === "vary")
+        return "\0vary";
+      break;
+    case 6:
+      if (field === "Server" || field === "server")
+        return "server";
+      if (field === "Cookie" || field === "cookie")
+        return "cookie";
+      if (field === "Origin" || field === "origin")
+        return "\0origin";
+      if (field === "Expect" || field === "expect")
+        return "\0expect";
+      if (field === "Accept" || field === "accept")
+        return "\0accept";
+      break;
+    case 7:
+      if (field === "Referer" || field === "referer")
+        return "referer";
+      if (field === "Expires" || field === "expires")
+        return "expires";
+      if (field === "Upgrade" || field === "upgrade")
+        return "\0upgrade";
+      break;
+    case 8:
+      if (field === "Location" || field === "location")
+        return "location";
+      if (field === "If-Match" || field === "if-match")
+        return "\0if-match";
+      break;
+    case 10:
+      if (field === "User-Agent" || field === "user-agent")
+        return "user-agent";
+      if (field === "Set-Cookie" || field === "set-cookie")
+        return "
";
+      if (field === "Connection" || field === "connection")
+        return "\0connection";
+      break;
+    case 11:
+      if (field === "Retry-After" || field === "retry-after")
+        return "retry-after";
+      break;
+    case 12:
+      if (field === "Content-Type" || field === "content-type")
+        return "content-type";
+      if (field === "Max-Forwards" || field === "max-forwards")
+        return "max-forwards";
+      break;
+    case 13:
+      if (field === "Authorization" || field === "authorization")
+        return "authorization";
+      if (field === "Last-Modified" || field === "last-modified")
+        return "last-modified";
+      if (field === "Cache-Control" || field === "cache-control")
+        return "\0cache-control";
+      if (field === "If-None-Match" || field === "if-none-match")
+        return "\0if-none-match";
+      break;
+    case 14:
+      if (field === "Content-Length" || field === "content-length")
+        return "content-length";
+      break;
+    case 15:
+      if (field === "Accept-Encoding" || field === "accept-encoding")
+        return "\0accept-encoding";
+      if (field === "Accept-Language" || field === "accept-language")
+        return "\0accept-language";
+      if (field === "X-Forwarded-For" || field === "x-forwarded-for")
+        return "\0x-forwarded-for";
+      break;
+    case 16:
+      if (field === "Content-Encoding" || field === "content-encoding")
+        return "\0content-encoding";
+      if (field === "X-Forwarded-Host" || field === "x-forwarded-host")
+        return "\0x-forwarded-host";
+      break;
+    case 17:
+      if (field === "If-Modified-Since" || field === "if-modified-since")
+        return "if-modified-since";
+      if (field === "Transfer-Encoding" || field === "transfer-encoding")
+        return "\0transfer-encoding";
+      if (field === "X-Forwarded-Proto" || field === "x-forwarded-proto")
+        return "\0x-forwarded-proto";
+      break;
+    case 19:
+      if (field === "Proxy-Authorization" || field === "proxy-authorization")
+        return "proxy-authorization";
+      if (field === "If-Unmodified-Since" || field === "if-unmodified-since")
+        return "if-unmodified-since";
+      break;
+  }
+  if (lowercased) {
+    return "\0" + field;
+  }
+  return matchKnownFields(field.toLowerCase(), true);
+}
+function onError(self, error, cb) {
+  if (self.listenerCount("error") === 0) {
+    cb();
+  } else {
+    cb(error);
+  }
+}
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/utils/types.js
+function validateString(value, name) {
+  if (typeof value !== "string")
+    throw new ERR_INVALID_ARG_TYPE(name, "string", value);
+}
+var linkValueRegExp = /^(?:<[^>]*>)(?:\s*;\s*[^;"\s]+(?:=(")?[^;"\s]*\1)?)*$/;
+function validateLinkHeaderFormat(value, name) {
+  if (typeof value === "undefined" || !linkValueRegExp.exec(value)) {
+    throw new ERR_INVALID_ARG_VALUE(name, value, 'must be an array or string of format "</styles.css>; rel=preload; as=style"');
+  }
+}
+function validateLinkHeaderValue(hints) {
+  if (typeof hints === "string") {
+    validateLinkHeaderFormat(hints, "hints");
+    return hints;
+  } else if (Array.isArray(hints)) {
+    const hintsLength = hints.length;
+    let result = "";
+    if (hintsLength === 0) {
+      return result;
+    }
+    for (let i2 = 0; i2 < hintsLength; i2++) {
+      const link = hints[i2];
+      validateLinkHeaderFormat(link, "hints");
+      result += link;
+      if (i2 !== hintsLength - 1) {
+        result += ", ";
+      }
+    }
+    return result;
+  }
+  throw new ERR_INVALID_ARG_VALUE("hints", hints, 'must be an array or string of format "</styles.css>; rel=preload; as=style"');
+}
+function isUint8Array(value) {
+  return value != null && value[Symbol.toStringTag] === "Uint8Array";
+}
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/fetch-to-node/internal-http.js
+var kNeedDrain = Symbol("kNeedDrain");
+var kOutHeaders = Symbol("kOutHeaders");
+function utcDate() {
+  return (/* @__PURE__ */ new Date()).toUTCString();
+}
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/fetch-to-node/internal-streams-state.js
+function getDefaultHighWaterMark(objectMode) {
+  return objectMode ? 16 : 64 * 1024;
+}
+
+// ../../node_modules/.pnpm/fetch-to-node@2.1.0/node_modules/fetch-to-node/dist/fetch-to-node/http-common.js
+var tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+function checkIsHttpToken(val) {
+  return tokenRegExp.test(val);
+}
+var headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
+function checkInvalidHeaderChar(val) {
+  return headerCharRegex.test(val);
+}
+var chunkExpression = /(?:^|\W)chunked(?:$|\W)/i;
+var kCorked = Symbol("corked");
+var kChunkedBuffer = Symbol("kChunkedBuffer");
+var kChunkedLength = Symbol("kChunkedLength");
+var kUniqueHeaders = Symbol("kUniqueHeaders");
+var kBytesWritten = Symbol("kBytesWritten");
+var kErrored = Symbol("errored");
+var kHighWaterMark = Symbol("kHighWaterMark");
+var kRejectNonStandardBodyWrites = Symbol("kRejectNonStandardBodyWrites");
+var nop = () => {
+};
+var RE_CONN_CLOSE = /(?:^|\W)close(?:$|\W)/i;
+function isCookieField(s3) {
+  return s3.length === 6 && s3.toLowerCase() === "cookie";
+}
+function isContentDispositionField(s3) {
+  return s3.length === 19 && s3.toLowerCase() === "content-disposition";
+}
+var WrittenDataBuffer = class {
+  [kCorked] = 0;
+  [kHighWaterMark] = getDefaultHighWaterMark();
+  entries = [];
+  onWrite;
+  constructor(params = {}) {
+    this.onWrite = params.onWrite;
+  }
+  write(data, encoding, callback) {
+    this.entries.push({
+      data,
+      length: data.length,
+      encoding,
+      callback,
+      written: false
+    });
+    this._flush();
+    return true;
+  }
+  cork() {
+    this[kCorked]++;
+  }
+  uncork() {
+    this[kCorked]--;
+    this._flush();
+  }
+  _flush() {
+    if (this[kCorked] <= 0) {
+      for (const [index, entry] of this.entries.entries()) {
+        if (!entry.written) {
+          entry.written = true;
+          if (this.onWrite != null) {
+            this.onWrite(index, entry);
+          }
+          if (entry.callback != null) {
+            entry.callback.call(void 0);
+          }
+        }
+      }
+    }
+  }
+  get writableLength() {
+    return this.entries.reduce((acc, entry) => {
+      return acc + (entry.written && entry.length ? entry.length : 0);
+    }, 0);
+  }
+  get writableHighWaterMark() {
+    return this[kHighWaterMark];
+  }
+  get writableCorked() {
+    return this[kCorked];
+  }
+};
+var FetchOutgoingMessage = class extends stream.Writable {
+  req;
+  outputData;
+  outputSize;
+  // Difference from Node.js -
+  // `writtenHeaderBytes` is the number of bytes the header has taken.
+  // Since Node.js writes both the headers and body into the same outgoing
+  // stream, it helps to keep track of this so that we can skip that many bytes
+  // from the beginning of the stream when providing the outgoing stream.
+  writtenHeaderBytes = 0;
+  _last;
+  chunkedEncoding;
+  shouldKeepAlive;
+  maxRequestsOnConnectionReached;
+  _defaultKeepAlive;
+  useChunkedEncodingByDefault;
+  sendDate;
+  _removedConnection;
+  _removedContLen;
+  _removedTE;
+  strictContentLength;
+  [kBytesWritten];
+  _contentLength;
+  _hasBody;
+  _trailer;
+  [kNeedDrain];
+  finished;
+  _headerSent;
+  [kCorked];
+  [kChunkedBuffer];
+  [kChunkedLength];
+  _closed;
+  // Difference from Node.js -
+  // In Node.js, this is a socket object.
+  // [kSocket]: null;
+  _header;
+  [kOutHeaders];
+  _keepAliveTimeout;
+  _maxRequestsPerSocket;
+  _onPendingData;
+  [kUniqueHeaders];
+  [kErrored];
+  [kHighWaterMark];
+  [kRejectNonStandardBodyWrites];
+  _writtenDataBuffer = new WrittenDataBuffer({
+    onWrite: this._onDataWritten.bind(this)
+  });
+  constructor(req, options) {
+    super();
+    this.req = req;
+    this.outputData = [];
+    this.outputSize = 0;
+    this.destroyed = false;
+    this._last = false;
+    this.chunkedEncoding = false;
+    this.shouldKeepAlive = true;
+    this.maxRequestsOnConnectionReached = false;
+    this._defaultKeepAlive = true;
+    this.useChunkedEncodingByDefault = true;
+    this.sendDate = false;
+    this._removedConnection = false;
+    this._removedContLen = false;
+    this._removedTE = false;
+    this.strictContentLength = false;
+    this[kBytesWritten] = 0;
+    this._contentLength = null;
+    this._hasBody = true;
+    this._trailer = "";
+    this[kNeedDrain] = false;
+    this.finished = false;
+    this._headerSent = false;
+    this[kCorked] = 0;
+    this[kChunkedBuffer] = [];
+    this[kChunkedLength] = 0;
+    this._closed = false;
+    this._header = null;
+    this[kOutHeaders] = null;
+    this._keepAliveTimeout = 0;
+    this._onPendingData = nop;
+    this[kErrored] = null;
+    this[kHighWaterMark] = options?.highWaterMark ?? getDefaultHighWaterMark();
+    this[kRejectNonStandardBodyWrites] = options?.rejectNonStandardBodyWrites ?? false;
+    this[kUniqueHeaders] = null;
+  }
+  _renderHeaders() {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("render");
+    }
+    const headersMap = this[kOutHeaders];
+    const headers = {};
+    if (headersMap !== null) {
+      const keys = Object.keys(headersMap);
+      for (let i2 = 0, l2 = keys.length; i2 < l2; i2++) {
+        const key = keys[i2];
+        headers[headersMap[key][0]] = headersMap[key][1];
+      }
+    }
+    return headers;
+  }
+  cork() {
+    this[kCorked]++;
+    if (this._writtenDataBuffer != null) {
+      this._writtenDataBuffer.cork();
+    }
+  }
+  uncork() {
+    this[kCorked]--;
+    if (this._writtenDataBuffer != null) {
+      this._writtenDataBuffer.uncork();
+    }
+    if (this[kCorked] || this[kChunkedBuffer].length === 0) {
+      return;
+    }
+    const buf = this[kChunkedBuffer];
+    for (const { data, encoding, callback } of buf) {
+      this._send(data ?? "", encoding, callback);
+    }
+    this[kChunkedBuffer].length = 0;
+    this[kChunkedLength] = 0;
+  }
+  setTimeout(msecs, callback) {
+    return this;
+  }
+  destroy(error) {
+    if (this.destroyed) {
+      return this;
+    }
+    this.destroyed = true;
+    this[kErrored] = error;
+    return this;
+  }
+  _send(data, encoding, callback, byteLength) {
+    if (!this._headerSent) {
+      const header = this._header;
+      if (typeof data === "string" && (encoding === "utf8" || encoding === "latin1" || !encoding)) {
+        data = header + data;
+      } else {
+        this.outputData.unshift({
+          data: header,
+          encoding: "latin1",
+          callback: void 0
+        });
+        this.outputSize += header.length;
+        this._onPendingData(header.length);
+      }
+      this._headerSent = true;
+      this.writtenHeaderBytes = header.length;
+      const [statusLine, ...headerLines] = this._header.split("\r\n");
+      const STATUS_LINE_REGEXP = /^HTTP\/1\.1 (?<statusCode>\d+) (?<statusMessage>.*)$/;
+      const statusLineResult = STATUS_LINE_REGEXP.exec(statusLine);
+      if (statusLineResult == null) {
+        throw new Error("Unexpected! Status line was " + statusLine);
+      }
+      const { statusCode: statusCodeText, statusMessage } = statusLineResult.groups ?? {};
+      const statusCode = parseInt(statusCodeText, 10);
+      const headers = [];
+      for (const headerLine of headerLines) {
+        if (headerLine !== "") {
+          const pos = headerLine.indexOf(": ");
+          const k = headerLine.slice(0, pos);
+          const v = headerLine.slice(pos + 2);
+          headers.push([k, v]);
+        }
+      }
+      const event = {
+        statusCode,
+        statusMessage,
+        headers
+      };
+      this.emit("_headersSent", event);
+    }
+    return this._writeRaw(data, encoding, callback, byteLength);
+  }
+  _writeRaw(data, encoding, callback, size) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = null;
+    }
+    if (this._writtenDataBuffer != null) {
+      if (this.outputData.length) {
+        this._flushOutput(this._writtenDataBuffer);
+      }
+      return this._writtenDataBuffer.write(data, encoding, callback);
+    }
+    this.outputData.push({ data, encoding, callback });
+    this.outputSize += data.length;
+    this._onPendingData(data.length);
+    return this.outputSize < this[kHighWaterMark];
+  }
+  _onDataWritten(index, entry) {
+    const event = { index, entry };
+    this.emit("_dataWritten", event);
+  }
+  _storeHeader(firstLine, headers) {
+    const state = {
+      connection: false,
+      contLen: false,
+      te: false,
+      date: false,
+      expect: false,
+      trailer: false,
+      header: firstLine
+    };
+    if (headers) {
+      if (headers === this[kOutHeaders]) {
+        for (const key in headers) {
+          const entry = headers[key];
+          processHeader(this, state, entry[0], entry[1], false);
+        }
+      } else if (Array.isArray(headers)) {
+        if (headers.length && Array.isArray(headers[0])) {
+          for (let i2 = 0; i2 < headers.length; i2++) {
+            const entry = headers[i2];
+            processHeader(this, state, entry[0], entry[1], true);
+          }
+        } else {
+          if (headers.length % 2 !== 0) {
+            throw new ERR_INVALID_ARG_VALUE("headers", headers);
+          }
+          for (let n2 = 0; n2 < headers.length; n2 += 2) {
+            processHeader(this, state, headers[n2], headers[n2 + 1], true);
+          }
+        }
+      } else {
+        for (const key in headers) {
+          if (headers.hasOwnProperty(key)) {
+            const _headers = headers;
+            processHeader(this, state, key, _headers[key], true);
+          }
+        }
+      }
+    }
+    let { header } = state;
+    if (this.sendDate && !state.date) {
+      header += "Date: " + utcDate() + "\r\n";
+    }
+    if (this.chunkedEncoding && (this.statusCode === 204 || this.statusCode === 304)) {
+      this.chunkedEncoding = false;
+      this.shouldKeepAlive = false;
+    }
+    if (this._removedConnection) {
+      this._last = !this.shouldKeepAlive;
+    } else if (!state.connection) {
+      const shouldSendKeepAlive = this.shouldKeepAlive && (state.contLen || this.useChunkedEncodingByDefault);
+      if (shouldSendKeepAlive && this.maxRequestsOnConnectionReached) {
+        header += "Connection: close\r\n";
+      } else if (shouldSendKeepAlive) {
+        header += "Connection: keep-alive\r\n";
+        if (this._keepAliveTimeout && this._defaultKeepAlive) {
+          const timeoutSeconds = Math.floor(this._keepAliveTimeout / 1e3);
+          let max = "";
+          if (this._maxRequestsPerSocket && ~~this._maxRequestsPerSocket > 0) {
+            max = `, max=${this._maxRequestsPerSocket}`;
+          }
+          header += `Keep-Alive: timeout=${timeoutSeconds}${max}\r
+`;
+        }
+      } else {
+        this._last = true;
+        header += "Connection: close\r\n";
+      }
+    }
+    if (!state.contLen && !state.te) {
+      if (!this._hasBody) {
+        this.chunkedEncoding = false;
+      } else if (!this.useChunkedEncodingByDefault) {
+        this._last = true;
+      } else if (!state.trailer && !this._removedContLen && typeof this._contentLength === "number") {
+        header += "Content-Length: " + this._contentLength + "\r\n";
+      } else if (!this._removedTE) {
+        header += "Transfer-Encoding: chunked\r\n";
+        this.chunkedEncoding = true;
+      } else {
+        this._last = true;
+      }
+    }
+    if (this.chunkedEncoding !== true && state.trailer) {
+      throw new ERR_HTTP_TRAILER_INVALID();
+    }
+    this._header = header + "\r\n";
+    this._headerSent = false;
+    if (state.expect) {
+      this._send("");
+    }
+  }
+  get _headers() {
+    console.warn("DEP0066: OutgoingMessage.prototype._headers is deprecated");
+    return this.getHeaders();
+  }
+  set _headers(val) {
+    console.warn("DEP0066: OutgoingMessage.prototype._headers is deprecated");
+    if (val == null) {
+      this[kOutHeaders] = null;
+    } else if (typeof val === "object") {
+      const headers = this[kOutHeaders] = /* @__PURE__ */ Object.create(null);
+      const keys = Object.keys(val);
+      for (let i2 = 0; i2 < keys.length; ++i2) {
+        const name = keys[i2];
+        headers[name.toLowerCase()] = [name, val[name]];
+      }
+    }
+  }
+  get connection() {
+    return null;
+  }
+  set connection(_socket) {
+    console.error("No support for OutgoingMessage.connection");
+  }
+  get socket() {
+    return null;
+  }
+  set socket(_socket) {
+    console.error("No support for OutgoingMessage.socket");
+  }
+  get _headerNames() {
+    console.warn("DEP0066: OutgoingMessage.prototype._headerNames is deprecated");
+    const headers = this[kOutHeaders];
+    if (headers !== null) {
+      const out = /* @__PURE__ */ Object.create(null);
+      const keys = Object.keys(headers);
+      for (let i2 = 0; i2 < keys.length; ++i2) {
+        const key = keys[i2];
+        const val = headers[key][0];
+        out[key] = val;
+      }
+      return out;
+    }
+    return null;
+  }
+  set _headerNames(val) {
+    console.warn("DEP0066: OutgoingMessage.prototype._headerNames is deprecated");
+    if (typeof val === "object" && val !== null) {
+      const headers = this[kOutHeaders];
+      if (!headers)
+        return;
+      const keys = Object.keys(val);
+      for (let i2 = 0; i2 < keys.length; ++i2) {
+        const header = headers[keys[i2]];
+        if (header)
+          header[0] = val[keys[i2]];
+      }
+    }
+  }
+  setHeader(name, value) {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("set");
+    }
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
+    let headers = this[kOutHeaders];
+    if (headers === null) {
+      this[kOutHeaders] = headers = { __proto__: null };
+    }
+    headers[name.toLowerCase()] = [name, value];
+    return this;
+  }
+  setHeaders(headers) {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("set");
+    }
+    if (!headers || Array.isArray(headers) || typeof headers.keys !== "function" || typeof headers.get !== "function") {
+      throw new ERR_INVALID_ARG_TYPE("headers", ["Headers", "Map"], headers);
+    }
+    const cookies = [];
+    for (const { 0: key, 1: value } of headers) {
+      if (key === "set-cookie") {
+        if (Array.isArray(value)) {
+          cookies.push(...value);
+        } else {
+          cookies.push(value);
+        }
+        continue;
+      }
+      this.setHeader(key, value);
+    }
+    if (cookies.length) {
+      this.setHeader("set-cookie", cookies);
+    }
+    return this;
+  }
+  appendHeader(name, value) {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("append");
+    }
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
+    const field = name.toLowerCase();
+    const headers = this[kOutHeaders];
+    if (headers === null || !headers[field]) {
+      return this.setHeader(name, value);
+    }
+    if (!Array.isArray(headers[field][1])) {
+      headers[field][1] = [headers[field][1]];
+    }
+    const existingValues = headers[field][1];
+    if (Array.isArray(value)) {
+      for (let i2 = 0, length = value.length; i2 < length; i2++) {
+        existingValues.push(value[i2]);
+      }
+    } else {
+      existingValues.push(value);
+    }
+    return this;
+  }
+  getHeader(name) {
+    validateString(name, "name");
+    const headers = this[kOutHeaders];
+    if (headers === null) {
+      return;
+    }
+    const entry = headers[name.toLowerCase()];
+    return entry?.[1];
+  }
+  getHeaderNames() {
+    return this[kOutHeaders] !== null ? Object.keys(this[kOutHeaders]) : [];
+  }
+  getRawHeaderNames() {
+    const headersMap = this[kOutHeaders];
+    if (headersMap === null)
+      return [];
+    const values = Object.values(headersMap);
+    const headers = Array(values.length);
+    for (let i2 = 0, l2 = values.length; i2 < l2; i2++) {
+      headers[i2] = values[i2][0];
+    }
+    return headers;
+  }
+  getHeaders() {
+    const headers = this[kOutHeaders];
+    const ret = { __proto__: null };
+    if (headers) {
+      const keys = Object.keys(headers);
+      for (let i2 = 0; i2 < keys.length; ++i2) {
+        const key = keys[i2];
+        const val = headers[key][1];
+        ret[key] = val;
+      }
+    }
+    return ret;
+  }
+  hasHeader(name) {
+    validateString(name, "name");
+    return this[kOutHeaders] !== null && !!this[kOutHeaders][name.toLowerCase()];
+  }
+  removeHeader(name) {
+    validateString(name, "name");
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("remove");
+    }
+    const key = name.toLowerCase();
+    switch (key) {
+      case "connection":
+        this._removedConnection = true;
+        break;
+      case "content-length":
+        this._removedContLen = true;
+        break;
+      case "transfer-encoding":
+        this._removedTE = true;
+        break;
+      case "date":
+        this.sendDate = false;
+        break;
+    }
+    if (this[kOutHeaders] !== null) {
+      delete this[kOutHeaders][key];
+    }
+  }
+  _implicitHeader() {
+    throw new ERR_METHOD_NOT_IMPLEMENTED("_implicitHeader()");
+  }
+  get headersSent() {
+    return !!this._header;
+  }
+  write(chunk, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = null;
+    }
+    const ret = write_(this, chunk, encoding, callback, false);
+    if (!ret) {
+      this[kNeedDrain] = true;
+    }
+    return ret;
+  }
+  addTrailers(headers) {
+    this._trailer = "";
+    const isArray = Array.isArray(headers);
+    const keys = isArray ? [...headers.keys()] : Object.keys(headers);
+    for (let i2 = 0, l2 = keys.length; i2 < l2; i2++) {
+      let field, value;
+      if (isArray) {
+        const _headers = headers;
+        const key = keys[i2];
+        field = _headers[key][0];
+        value = _headers[key][1];
+      } else {
+        const _headers = headers;
+        const key = keys[i2];
+        field = key;
+        value = _headers[key];
+      }
+      validateHeaderName(field, "Trailer name");
+      if (Array.isArray(value) && value.length > 1 && (!this[kUniqueHeaders] || !this[kUniqueHeaders].has(field.toLowerCase()))) {
+        for (let j = 0, l3 = value.length; j < l3; j++) {
+          if (checkInvalidHeaderChar(value[j])) {
+            throw new ERR_INVALID_CHAR("trailer content", field);
+          }
+          this._trailer += field + ": " + value[j] + "\r\n";
+        }
+      } else {
+        if (Array.isArray(value)) {
+          value = value.join("; ");
+        }
+        if (checkInvalidHeaderChar(String(value))) {
+          throw new ERR_INVALID_CHAR("trailer content", field);
+        }
+        this._trailer += field + ": " + value + "\r\n";
+      }
+    }
+  }
+  end(chunk, encoding, callback) {
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = null;
+      encoding = null;
+    } else if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = null;
+    }
+    if (chunk) {
+      if (this.finished) {
+        onError2(this, new ERR_STREAM_WRITE_AFTER_END(), typeof callback !== "function" ? nop : callback);
+        return this;
+      }
+      if (this._writtenDataBuffer != null) {
+        this._writtenDataBuffer.cork();
+      }
+      write_(this, chunk, encoding, null, true);
+    } else if (this.finished) {
+      if (typeof callback === "function") {
+        if (!this.writableFinished) {
+          this.on("finish", callback);
+        } else {
+          callback(new ERR_STREAM_ALREADY_FINISHED("end"));
+        }
+      }
+      return this;
+    } else if (!this._header) {
+      if (this._writtenDataBuffer != null) {
+        this._writtenDataBuffer.cork();
+      }
+      this._contentLength = 0;
+      this._implicitHeader();
+    }
+    if (typeof callback === "function")
+      this.once("finish", callback);
+    if (strictContentLength(this) && this[kBytesWritten] !== this._contentLength) {
+      throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten], this._contentLength);
+    }
+    const finish = onFinish.bind(void 0, this);
+    if (this._hasBody && this.chunkedEncoding) {
+      this._send("", "latin1", finish);
+    } else if (!this._headerSent || this.writableLength || chunk) {
+      this._send("", "latin1", finish);
+    } else {
+      setTimeout(finish, 0);
+    }
+    if (this._writtenDataBuffer != null) {
+      this._writtenDataBuffer.uncork();
+    }
+    this[kCorked] = 1;
+    this.uncork();
+    this.finished = true;
+    if (this.outputData.length === 0 && this._writtenDataBuffer != null) {
+      this._finish();
+    }
+    return this;
+  }
+  _finish() {
+    this.emit("prefinish");
+  }
+  // No _flush() implementation?
+  _flush() {
+    if (this._writtenDataBuffer != null) {
+      const ret = this._flushOutput(this._writtenDataBuffer);
+      if (this.finished) {
+        this._finish();
+      } else if (ret && this[kNeedDrain]) {
+        this[kNeedDrain] = false;
+        this.emit("drain");
+      }
+    }
+  }
+  _flushOutput(dataBuffer) {
+    while (this[kCorked]) {
+      this[kCorked]--;
+      dataBuffer.cork();
+    }
+    const outputLength = this.outputData.length;
+    if (outputLength <= 0) {
+      return void 0;
+    }
+    const outputData = this.outputData;
+    dataBuffer.cork();
+    let ret;
+    for (let i2 = 0; i2 < outputLength; i2++) {
+      const { data, encoding, callback } = outputData[i2];
+      outputData[i2].data = null;
+      ret = dataBuffer.write(data ?? "", encoding, callback);
+    }
+    dataBuffer.uncork();
+    this.outputData = [];
+    this._onPendingData(-this.outputSize);
+    this.outputSize = 0;
+    return ret;
+  }
+  flushHeaders() {
+    if (!this._header) {
+      this._implicitHeader();
+    }
+    this._send("");
+  }
+  pipe(destination) {
+    this.emit("error", new ERR_STREAM_CANNOT_PIPE());
+    return destination;
+  }
+};
+function processHeader(self, state, key, value, validate) {
+  if (validate) {
+    validateHeaderName(key);
+  }
+  if (isContentDispositionField(key) && self._contentLength) {
+    if (Array.isArray(value)) {
+      for (let i2 = 0; i2 < value.length; i2++) {
+        value[i2] = String(buffer.Buffer.from(String(value[i2]), "latin1"));
+      }
+    } else {
+      value = String(buffer.Buffer.from(String(value), "latin1"));
+    }
+  }
+  if (Array.isArray(value)) {
+    if ((value.length < 2 || !isCookieField(key)) && (!self[kUniqueHeaders] || !self[kUniqueHeaders].has(key.toLowerCase()))) {
+      for (let i2 = 0; i2 < value.length; i2++) {
+        storeHeader(self, state, key, value[i2], validate);
+      }
+      return;
+    }
+    value = value.join("; ");
+  }
+  storeHeader(self, state, key, String(value), validate);
+}
+function storeHeader(self, state, key, value, validate) {
+  if (validate) {
+    validateHeaderValue(key, value);
+  }
+  state.header += key + ": " + value + "\r\n";
+  matchHeader(self, state, key, value);
+}
+function validateHeaderName(name, label) {
+  if (typeof name !== "string" || !name || !checkIsHttpToken(name)) {
+    throw new ERR_INVALID_HTTP_TOKEN(label || "Header name", name);
+  }
+}
+function validateHeaderValue(name, value) {
+  if (value === void 0) {
+    throw new ERR_HTTP_INVALID_HEADER_VALUE(String(value), name);
+  }
+  if (checkInvalidHeaderChar(String(value))) {
+    throw new ERR_INVALID_CHAR("header content", name);
+  }
+}
+function matchHeader(self, state, field, value) {
+  if (field.length < 4 || field.length > 17)
+    return;
+  field = field.toLowerCase();
+  switch (field) {
+    case "connection":
+      state.connection = true;
+      self._removedConnection = false;
+      if (RE_CONN_CLOSE.exec(value) !== null)
+        self._last = true;
+      else
+        self.shouldKeepAlive = true;
+      break;
+    case "transfer-encoding":
+      state.te = true;
+      self._removedTE = false;
+      if (chunkExpression.exec(value) !== null)
+        self.chunkedEncoding = true;
+      break;
+    case "content-length":
+      state.contLen = true;
+      self._contentLength = +value;
+      self._removedContLen = false;
+      break;
+    case "date":
+    case "expect":
+    case "trailer":
+      state[field] = true;
+      break;
+    case "keep-alive":
+      self._defaultKeepAlive = false;
+      break;
+  }
+}
+function onError2(msg, err, callback) {
+  if (msg.destroyed) {
+    return;
+  }
+  setTimeout(emitErrorNt, 0, msg, err, callback);
+}
+function emitErrorNt(msg, err, callback) {
+  callback(err);
+  if (typeof msg.emit === "function" && !msg.destroyed) {
+    msg.emit("error", err);
+  }
+}
+function strictContentLength(msg) {
+  return msg.strictContentLength && msg._contentLength != null && msg._hasBody && !msg._removedContLen && !msg.chunkedEncoding && !msg.hasHeader("transfer-encoding");
+}
+function write_(msg, chunk, encoding, callback, fromEnd) {
+  if (typeof callback !== "function") {
+    callback = nop;
+  }
+  if (chunk === null) {
+    throw new ERR_STREAM_NULL_VALUES();
+  } else if (typeof chunk !== "string" && !isUint8Array(chunk)) {
+    throw new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
+  }
+  let err = void 0;
+  if (msg.finished) {
+    err = new ERR_STREAM_WRITE_AFTER_END();
+  } else if (msg.destroyed) {
+    err = new ERR_STREAM_DESTROYED("write");
+  }
+  if (err) {
+    if (!msg.destroyed) {
+      onError2(msg, err, callback);
+    } else {
+      setTimeout(callback, 0, err);
+    }
+    return false;
+  }
+  let len = void 0;
+  if (msg.strictContentLength) {
+    len ??= typeof chunk === "string" ? buffer.Buffer.byteLength(chunk, encoding ?? void 0) : chunk.byteLength;
+    if (strictContentLength(msg) && (fromEnd ? msg[kBytesWritten] + len !== msg._contentLength : msg[kBytesWritten] + len > (msg._contentLength ?? 0))) {
+      throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(len + msg[kBytesWritten], msg._contentLength);
+    }
+    msg[kBytesWritten] += len;
+  }
+  if (!msg._header) {
+    if (fromEnd) {
+      len ??= typeof chunk === "string" ? buffer.Buffer.byteLength(chunk, encoding ?? void 0) : chunk.byteLength;
+      msg._contentLength = len;
+    }
+    msg._implicitHeader();
+  }
+  if (!msg._hasBody) {
+    if (msg[kRejectNonStandardBodyWrites]) {
+      throw new ERR_HTTP_BODY_NOT_ALLOWED();
+    } else {
+      setTimeout(callback, 0);
+      return true;
+    }
+  }
+  if (!fromEnd && msg._writtenDataBuffer != null && !msg._writtenDataBuffer.writableCorked) {
+    msg._writtenDataBuffer.cork();
+    setTimeout(connectionCorkNT, 0, msg._writtenDataBuffer);
+  }
+  let ret;
+  if (msg.chunkedEncoding && chunk.length !== 0) {
+    len ??= typeof chunk === "string" ? buffer.Buffer.byteLength(chunk, encoding ?? void 0) : chunk.byteLength;
+    if (msg[kCorked] && msg._headerSent) {
+      msg[kChunkedBuffer].push({ data: chunk, encoding, callback });
+      msg[kChunkedLength] += len;
+      ret = msg[kChunkedLength] < msg[kHighWaterMark];
+    } else {
+      ret = msg._send(chunk, encoding, callback, len);
+    }
+  } else {
+    ret = msg._send(chunk, encoding, callback, len);
+  }
+  return ret;
+}
+function connectionCorkNT(dataBuffer) {
+  dataBuffer.uncork();
+}
+function onFinish(outmsg) {
+  outmsg.emit("finish");
+}
+Object.defineProperties(FetchOutgoingMessage.prototype, {
+  errored: {
+    get() {
+      return this[kErrored];
+    }
+  },
+  closed: {
+    get() {
+      return this._closed;
+    }
+  },
+  writableFinished: {
+    get() {
+      return this.finished && this.outputSize === 0 && (this._writtenDataBuffer == null || this._writtenDataBuffer.writableLength === 0);
+    }
+  },
+  writableObjectMode: {
+    get() {
+      return false;
+    }
+  },
+  writableLength: {
+    get() {
+      return this.outputSize + this[kChunkedLength] + (this._writtenDataBuffer != null ? this._writtenDataBuffer.writableLength : 0);
+    }
+  },
+  writableHighWaterMark: {
+    get() {
+      return this._writtenDataBuffer != null ? this._writtenDataBuffer.writableHighWaterMark : this[kHighWaterMark];
+    }
+  },
+  writableCorked: {
+    get() {
+      return this[kCorked];
+    }
+  },
+  writableEnded: {
+    get() {
+      return this.finished;
+    }
+  },
+  writableNeedDrain: {
+    get() {
+      return !this.destroyed && !this.finished && this[kNeedDrain];
+    }
+  }
+});
+var headerCharRegex2 = /[^\t\x20-\x7e\x80-\xff]/;
+function checkInvalidHeaderChar2(val) {
+  return headerCharRegex2.test(val);
+}
+var STATUS_CODES = {
+  100: "Continue",
+  // RFC 7231 6.2.1
+  101: "Switching Protocols",
+  // RFC 7231 6.2.2
+  102: "Processing",
+  // RFC 2518 10.1 (obsoleted by RFC 4918)
+  103: "Early Hints",
+  // RFC 8297 2
+  200: "OK",
+  // RFC 7231 6.3.1
+  201: "Created",
+  // RFC 7231 6.3.2
+  202: "Accepted",
+  // RFC 7231 6.3.3
+  203: "Non-Authoritative Information",
+  // RFC 7231 6.3.4
+  204: "No Content",
+  // RFC 7231 6.3.5
+  205: "Reset Content",
+  // RFC 7231 6.3.6
+  206: "Partial Content",
+  // RFC 7233 4.1
+  207: "Multi-Status",
+  // RFC 4918 11.1
+  208: "Already Reported",
+  // RFC 5842 7.1
+  226: "IM Used",
+  // RFC 3229 10.4.1
+  300: "Multiple Choices",
+  // RFC 7231 6.4.1
+  301: "Moved Permanently",
+  // RFC 7231 6.4.2
+  302: "Found",
+  // RFC 7231 6.4.3
+  303: "See Other",
+  // RFC 7231 6.4.4
+  304: "Not Modified",
+  // RFC 7232 4.1
+  305: "Use Proxy",
+  // RFC 7231 6.4.5
+  307: "Temporary Redirect",
+  // RFC 7231 6.4.7
+  308: "Permanent Redirect",
+  // RFC 7238 3
+  400: "Bad Request",
+  // RFC 7231 6.5.1
+  401: "Unauthorized",
+  // RFC 7235 3.1
+  402: "Payment Required",
+  // RFC 7231 6.5.2
+  403: "Forbidden",
+  // RFC 7231 6.5.3
+  404: "Not Found",
+  // RFC 7231 6.5.4
+  405: "Method Not Allowed",
+  // RFC 7231 6.5.5
+  406: "Not Acceptable",
+  // RFC 7231 6.5.6
+  407: "Proxy Authentication Required",
+  // RFC 7235 3.2
+  408: "Request Timeout",
+  // RFC 7231 6.5.7
+  409: "Conflict",
+  // RFC 7231 6.5.8
+  410: "Gone",
+  // RFC 7231 6.5.9
+  411: "Length Required",
+  // RFC 7231 6.5.10
+  412: "Precondition Failed",
+  // RFC 7232 4.2
+  413: "Payload Too Large",
+  // RFC 7231 6.5.11
+  414: "URI Too Long",
+  // RFC 7231 6.5.12
+  415: "Unsupported Media Type",
+  // RFC 7231 6.5.13
+  416: "Range Not Satisfiable",
+  // RFC 7233 4.4
+  417: "Expectation Failed",
+  // RFC 7231 6.5.14
+  418: "I'm a Teapot",
+  // RFC 7168 2.3.3
+  421: "Misdirected Request",
+  // RFC 7540 9.1.2
+  422: "Unprocessable Entity",
+  // RFC 4918 11.2
+  423: "Locked",
+  // RFC 4918 11.3
+  424: "Failed Dependency",
+  // RFC 4918 11.4
+  425: "Too Early",
+  // RFC 8470 5.2
+  426: "Upgrade Required",
+  // RFC 2817 and RFC 7231 6.5.15
+  428: "Precondition Required",
+  // RFC 6585 3
+  429: "Too Many Requests",
+  // RFC 6585 4
+  431: "Request Header Fields Too Large",
+  // RFC 6585 5
+  451: "Unavailable For Legal Reasons",
+  // RFC 7725 3
+  500: "Internal Server Error",
+  // RFC 7231 6.6.1
+  501: "Not Implemented",
+  // RFC 7231 6.6.2
+  502: "Bad Gateway",
+  // RFC 7231 6.6.3
+  503: "Service Unavailable",
+  // RFC 7231 6.6.4
+  504: "Gateway Timeout",
+  // RFC 7231 6.6.5
+  505: "HTTP Version Not Supported",
+  // RFC 7231 6.6.6
+  506: "Variant Also Negotiates",
+  // RFC 2295 8.1
+  507: "Insufficient Storage",
+  // RFC 4918 11.5
+  508: "Loop Detected",
+  // RFC 5842 7.2
+  509: "Bandwidth Limit Exceeded",
+  510: "Not Extended",
+  // RFC 2774 7
+  511: "Network Authentication Required"
+  // RFC 6585 6
+};
+var FetchServerResponse = class _FetchServerResponse extends FetchOutgoingMessage {
+  static encoder = new TextEncoder();
+  statusCode = 200;
+  statusMessage;
+  _sent100;
+  _expect_continue;
+  [kOutHeaders] = null;
+  constructor(req, options) {
+    super(req, options);
+    if (req.method === "HEAD") {
+      this._hasBody = false;
+    }
+    this.sendDate = true;
+    this._sent100 = false;
+    this._expect_continue = false;
+    if (req.httpVersionMajor < 1 || req.httpVersionMinor < 1) {
+      this.useChunkedEncodingByDefault = chunkExpression.exec(String(req.headers.te)) !== null;
+      this.shouldKeepAlive = false;
+    }
+    this.fetchResponse = new Promise((resolve) => {
+      let finished = false;
+      this.on("finish", () => {
+        finished = true;
+      });
+      const initialDataChunks = [];
+      const initialDataWrittenHandler = (e2) => {
+        if (finished) {
+          return;
+        }
+        initialDataChunks[e2.index] = this.dataFromDataWrittenEvent(e2);
+      };
+      this.on("_dataWritten", initialDataWrittenHandler);
+      this.on("_headersSent", (e2) => {
+        this.off("_dataWritten", initialDataWrittenHandler);
+        const { statusCode, statusMessage, headers } = e2;
+        resolve(this._toFetchResponse(statusCode, statusMessage, headers, initialDataChunks, finished));
+      });
+    });
+  }
+  dataFromDataWrittenEvent(e2) {
+    const { index, entry } = e2;
+    let { data, encoding } = entry;
+    if (index === 0) {
+      if (typeof data !== "string") {
+        console.error("First chunk should be string, not sure what happened.");
+        throw new ERR_INVALID_ARG_TYPE("packet.data", ["string", "Buffer", "Uint8Array"], data);
+      }
+      data = data.slice(this.writtenHeaderBytes);
+    }
+    if (typeof data === "string") {
+      if (encoding === void 0 || encoding === "utf8" || encoding === "utf-8") {
+        data = _FetchServerResponse.encoder.encode(data);
+      } else {
+        data = buffer.Buffer.from(data, encoding ?? void 0);
+      }
+    }
+    return data ?? buffer.Buffer.from([]);
+  }
+  _finish() {
+    super._finish();
+  }
+  assignSocket(socket) {
+    throw new ERR_METHOD_NOT_IMPLEMENTED("assignSocket");
+  }
+  detachSocket(socket) {
+    throw new ERR_METHOD_NOT_IMPLEMENTED("detachSocket");
+  }
+  writeContinue(callback) {
+    this._writeRaw("HTTP/1.1 100 Continue\r\n\r\n", "ascii", callback);
+    this._sent100 = true;
+  }
+  writeProcessing(callback) {
+    this._writeRaw("HTTP/1.1 102 Processing\r\n\r\n", "ascii", callback);
+  }
+  writeEarlyHints(hints, callback) {
+    let head = "HTTP/1.1 103 Early Hints\r\n";
+    if (hints.link === null || hints.link === void 0) {
+      return;
+    }
+    const link = validateLinkHeaderValue(hints.link);
+    if (link.length === 0) {
+      return;
+    }
+    head += "Link: " + link + "\r\n";
+    for (const key of Object.keys(hints)) {
+      if (key !== "link") {
+        head += key + ": " + hints[key] + "\r\n";
+      }
+    }
+    head += "\r\n";
+    this._writeRaw(head, "ascii", callback);
+  }
+  _implicitHeader() {
+    this.writeHead(this.statusCode);
+  }
+  writeHead(statusCode, reason, obj) {
+    if (this._header) {
+      throw new ERR_HTTP_HEADERS_SENT("write");
+    }
+    const originalStatusCode = statusCode;
+    statusCode |= 0;
+    if (statusCode < 100 || statusCode > 999) {
+      throw new ERR_HTTP_INVALID_STATUS_CODE(originalStatusCode);
+    }
+    if (typeof reason === "string") {
+      this.statusMessage = reason;
+    } else {
+      this.statusMessage ||= STATUS_CODES[statusCode] || "unknown";
+      obj ??= reason;
+    }
+    this.statusCode = statusCode;
+    let headers;
+    if (this[kOutHeaders]) {
+      let k;
+      if (Array.isArray(obj)) {
+        if (obj.length % 2 !== 0) {
+          throw new ERR_INVALID_ARG_VALUE("headers", obj);
+        }
+        for (let n2 = 0; n2 < obj.length; n2 += 2) {
+          k = obj[n2 + 0];
+          this.removeHeader(String(k));
+        }
+        for (let n2 = 0; n2 < obj.length; n2 += 2) {
+          k = obj[n2];
+          if (k) {
+            this.appendHeader(String(k), obj[n2 + 1]);
+          }
+        }
+      } else if (obj) {
+        const keys = Object.keys(obj);
+        for (let i2 = 0; i2 < keys.length; i2++) {
+          k = keys[i2];
+          if (k) {
+            this.setHeader(k, obj[k]);
+          }
+        }
+      }
+      headers = this[kOutHeaders];
+    } else {
+      headers = obj;
+    }
+    if (checkInvalidHeaderChar2(this.statusMessage)) {
+      throw new ERR_INVALID_CHAR("statusMessage");
+    }
+    const statusLine = `HTTP/1.1 ${statusCode} ${this.statusMessage}\r
+`;
+    if (statusCode === 204 || statusCode === 304 || statusCode >= 100 && statusCode <= 199) {
+      this._hasBody = false;
+    }
+    if (this._expect_continue && !this._sent100) {
+      this.shouldKeepAlive = false;
+    }
+    const convertedHeaders = headers && !Array.isArray(headers) ? headers : headers;
+    this._storeHeader(statusLine, convertedHeaders ?? null);
+    return this;
+  }
+  // Docs-only deprecated: DEP0063
+  writeHeader = this.writeHead;
+  fetchResponse;
+  _toFetchResponse(status, statusText, sentHeaders, initialDataChunks, finished) {
+    const headers = new Headers();
+    for (const [header, value] of sentHeaders) {
+      headers.append(header, value);
+    }
+    const _this = this;
+    let body = this._hasBody ? new ReadableStream({
+      start(controller) {
+        for (const dataChunk of initialDataChunks) {
+          controller.enqueue(dataChunk);
+        }
+        if (finished) {
+          controller.close();
+        } else {
+          _this.on("finish", () => {
+            finished = true;
+            controller.close();
+          });
+          _this.on("_dataWritten", (e2) => {
+            if (finished) {
+              return;
+            }
+            const data = _this.dataFromDataWrittenEvent(e2);
+            controller.enqueue(data);
+          });
+        }
+      }
+    }) : null;
+    if (body != null && typeof FixedLengthStream !== "undefined") {
+      const contentLength = parseInt(headers.get("content-length") ?? "", 10);
+      if (contentLength >= 0) {
+        body = body.pipeThrough(new FixedLengthStream(contentLength));
+      }
+    }
+    return new Response(body, {
+      status,
+      statusText,
+      headers
+    });
+  }
+};
+function toReqRes(req, options) {
+  const { createIncomingMessage = () => new FetchIncomingMessage(), createServerResponse = (incoming2) => new FetchServerResponse(incoming2), ctx } = {};
+  const incoming = createIncomingMessage(ctx);
+  const serverResponse = createServerResponse(incoming, ctx);
+  const reqUrl = new URL(req.url);
+  const versionMajor = 1;
+  const versionMinor = 1;
+  incoming.httpVersionMajor = versionMajor;
+  incoming.httpVersionMinor = versionMinor;
+  incoming.httpVersion = `${versionMajor}.${versionMinor}`;
+  incoming.url = reqUrl.pathname + reqUrl.search;
+  incoming.upgrade = false;
+  const headers = [];
+  for (const [headerName, headerValue] of req.headers) {
+    headers.push(headerName);
+    headers.push(headerValue);
+  }
+  incoming._addHeaderLines(headers, headers.length);
+  incoming.method = req.method;
+  incoming._stream = req.body;
+  return {
+    req: incoming,
+    res: serverResponse
+  };
+}
+function toFetchResponse(res) {
+  if (!(res instanceof FetchServerResponse)) {
+    throw new Error("toFetchResponse must be called on a ServerResponse generated by toReqRes");
+  }
+  return res.fetchResponse;
+}
+
+// src/server/handlers/mcp.ts
+var getMastra = (c2) => c2.get("mastra");
+var getMcpServerMessageHandler = async (c2) => {
+  const mastra = getMastra(c2);
+  const serverId = c2.req.param("serverId");
+  const { req, res } = toReqRes(c2.req.raw);
+  const server = mastra.getMCPServer(serverId);
+  if (!server) {
+    return c2.json({ error: `MCP server '${serverId}' not found` }, 404);
+  }
+  try {
+    await server.startHTTP({
+      url: new URL(c2.req.url),
+      httpPath: `/api/servers/${serverId}/mcp`,
+      req,
+      res,
+      options: {
+        sessionIdGenerator: void 0
+      }
+    });
+    const toFetchRes = await toFetchResponse(res);
+    return toFetchRes;
+  } catch (error) {
+    return handleError(error, "Error sending MCP message");
+  }
+};
+var handleMcpServerSseRoutes = async (c2) => {
+  const mastra = getMastra(c2);
+  const serverId = c2.req.param("serverId");
+  const server = mastra.getMCPServer(serverId);
+  if (!server) {
+    return c2.json({ error: `MCP server '${serverId}' not found` }, 404);
+  }
+  const { req, res } = toReqRes(c2.req.raw);
+  const requestUrl = new URL(c2.req.url);
+  const sseConnectionPath = `/api/servers/${serverId}/sse`;
+  const sseMessagePath = `/api/servers/${serverId}/messages`;
+  try {
+    await server.startSSE({
+      url: requestUrl,
+      ssePath: sseConnectionPath,
+      messagePath: sseMessagePath,
+      req,
+      res
+    });
+    if (res.writableEnded || res.headersSent) {
+      return toFetchResponse(res);
+    }
+    c2.get("logger")?.warn(
+      { serverId, path: requestUrl.pathname },
+      "MCP SSE handler: MCPServer.startSSE did not seem to handle the response."
+    );
+    return c2.text("Internal Server Error: MCP SSE request not fully processed by server component", 500);
+  } catch (error) {
+    c2.get("logger")?.error({ err: error, serverId, path: requestUrl.pathname }, "Error in MCP SSE route handler");
+    if (!res.headersSent && !res.writableEnded) {
+      return handleError(error, "Error handling MCP SSE request");
+    }
+  }
+};
 async function getMemoryStatusHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -2724,121 +4644,123 @@ async function createHonoServer(mastra, options = {}) {
     }),
     streamGenerateHandler
   );
-  app.post(
-    "/api/agents/:agentId/instructions",
-    bodyLimit.bodyLimit(bodyLimitOptions),
-    h({
-      description: "Update an agent's instructions",
-      tags: ["agents"],
-      parameters: [
-        {
-          name: "agentId",
-          in: "path",
-          required: true,
-          schema: { type: "string" }
-        }
-      ],
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
-              properties: {
-                instructions: {
-                  type: "string",
-                  description: "New instructions for the agent"
-                }
-              },
-              required: ["instructions"]
-            }
+  if (options.isDev) {
+    app.post(
+      "/api/agents/:agentId/instructions",
+      bodyLimit.bodyLimit(bodyLimitOptions),
+      h({
+        description: "Update an agent's instructions",
+        tags: ["agents"],
+        parameters: [
+          {
+            name: "agentId",
+            in: "path",
+            required: true,
+            schema: { type: "string" }
           }
-        }
-      },
-      responses: {
-        200: {
-          description: "Instructions updated successfully"
-        },
-        403: {
-          description: "Not allowed in non-playground environment"
-        },
-        404: {
-          description: "Agent not found"
-        }
-      }
-    }),
-    setAgentInstructionsHandler
-  );
-  app.post(
-    "/api/agents/:agentId/instructions/enhance",
-    bodyLimit.bodyLimit(bodyLimitOptions),
-    h({
-      description: "Generate an improved system prompt from instructions",
-      tags: ["agents"],
-      parameters: [
-        {
-          name: "agentId",
-          in: "path",
+        ],
+        requestBody: {
           required: true,
-          schema: { type: "string" },
-          description: "ID of the agent whose model will be used for prompt generation"
-        }
-      ],
-      requestBody: {
-        required: true,
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
-              properties: {
-                instructions: {
-                  type: "string",
-                  description: "Instructions to generate a system prompt from"
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  instructions: {
+                    type: "string",
+                    description: "New instructions for the agent"
+                  }
                 },
-                comment: {
-                  type: "string",
-                  description: "Optional comment for the enhanced prompt"
-                }
-              },
-              required: ["instructions"]
+                required: ["instructions"]
+              }
             }
           }
+        },
+        responses: {
+          200: {
+            description: "Instructions updated successfully"
+          },
+          403: {
+            description: "Not allowed in non-playground environment"
+          },
+          404: {
+            description: "Agent not found"
+          }
         }
-      },
-      responses: {
-        200: {
-          description: "Generated system prompt and analysis",
+      }),
+      setAgentInstructionsHandler
+    );
+    app.post(
+      "/api/agents/:agentId/instructions/enhance",
+      bodyLimit.bodyLimit(bodyLimitOptions),
+      h({
+        description: "Generate an improved system prompt from instructions",
+        tags: ["agents"],
+        parameters: [
+          {
+            name: "agentId",
+            in: "path",
+            required: true,
+            schema: { type: "string" },
+            description: "ID of the agent whose model will be used for prompt generation"
+          }
+        ],
+        requestBody: {
+          required: true,
           content: {
             "application/json": {
               schema: {
                 type: "object",
                 properties: {
-                  explanation: {
+                  instructions: {
                     type: "string",
-                    description: "Detailed analysis of the instructions"
+                    description: "Instructions to generate a system prompt from"
                   },
-                  new_prompt: {
+                  comment: {
                     type: "string",
-                    description: "The enhanced system prompt"
+                    description: "Optional comment for the enhanced prompt"
                   }
-                }
+                },
+                required: ["instructions"]
               }
             }
           }
         },
-        400: {
-          description: "Missing or invalid request parameters"
-        },
-        404: {
-          description: "Agent not found"
-        },
-        500: {
-          description: "Internal server error or model response parsing error"
+        responses: {
+          200: {
+            description: "Generated system prompt and analysis",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    explanation: {
+                      type: "string",
+                      description: "Detailed analysis of the instructions"
+                    },
+                    new_prompt: {
+                      type: "string",
+                      description: "The enhanced system prompt"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          400: {
+            description: "Missing or invalid request parameters"
+          },
+          404: {
+            description: "Agent not found"
+          },
+          500: {
+            description: "Internal server error or model response parsing error"
+          }
         }
-      }
-    }),
-    generateSystemPromptHandler
-  );
+      }),
+      generateSystemPromptHandler
+    );
+  }
   app.get(
     "/api/agents/:agentId/speakers",
     async (c2, next) => {
@@ -3256,6 +5178,93 @@ async function createHonoServer(mastra, options = {}) {
     }),
     executeAgentToolHandler
   );
+  app.post(
+    "/api/servers/:serverId/mcp",
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    h({
+      description: "Send a message to an MCP server using Streamable HTTP",
+      tags: ["mcp"],
+      parameters: [
+        {
+          name: "serverId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        content: { "application/json": { schema: { type: "object" } } }
+      },
+      responses: {
+        200: {
+          description: "Streamable HTTP connection processed"
+        },
+        404: {
+          description: "MCP server not found"
+        }
+      }
+    }),
+    getMcpServerMessageHandler
+  );
+  const mcpSseBasePath = "/api/servers/:serverId/sse";
+  const mcpSseMessagePath = "/api/servers/:serverId/messages";
+  app.get(
+    mcpSseBasePath,
+    h({
+      description: "Establish an MCP Server-Sent Events (SSE) connection with a server instance.",
+      tags: ["mcp"],
+      parameters: [
+        {
+          name: "serverId",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+          description: "The ID of the MCP server instance."
+        }
+      ],
+      responses: {
+        200: {
+          description: "SSE connection established. The client will receive events over this connection. (Content-Type: text/event-stream)"
+        },
+        404: { description: "MCP server instance not found." },
+        500: { description: "Internal server error establishing SSE connection." }
+      }
+    }),
+    handleMcpServerSseRoutes
+  );
+  app.post(
+    mcpSseMessagePath,
+    bodyLimit.bodyLimit(bodyLimitOptions),
+    // Apply body limit for messages
+    h({
+      description: "Send a message to an MCP server over an established SSE connection.",
+      tags: ["mcp"],
+      parameters: [
+        {
+          name: "serverId",
+          in: "path",
+          required: true,
+          schema: { type: "string" },
+          description: "The ID of the MCP server instance."
+        }
+      ],
+      requestBody: {
+        description: "JSON-RPC message to send to the MCP server.",
+        required: true,
+        content: { "application/json": { schema: { type: "object" } } }
+        // MCP messages are typically JSON
+      },
+      responses: {
+        200: {
+          description: "Message received and is being processed by the MCP server. The actual result or error will be sent as an SSE event over the established connection."
+        },
+        400: { description: "Bad request (e.g., invalid JSON payload or missing body)." },
+        404: { description: "MCP server instance not found or SSE connection path incorrect." },
+        503: { description: "SSE connection not established with this server, or server unable to process message." }
+      }
+    }),
+    handleMcpServerSseRoutes
+  );
   app.get(
     "/api/memory/status",
     h({