@elizaos/server 1.6.1-alpha.5 → 1.6.1-alpha.6

package/dist/index.js

@@ -370,11 +370,1083 @@ var require_dist = __commonJS((exports) => {
   }
 });
 
+// ../../node_modules/ip-address/dist/common.js
+var require_common = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.isInSubnet = isInSubnet;
+  exports.isCorrect = isCorrect;
+  exports.numberToPaddedHex = numberToPaddedHex;
+  exports.stringToPaddedHex = stringToPaddedHex;
+  exports.testBit = testBit;
+  function isInSubnet(address) {
+    if (this.subnetMask < address.subnetMask) {
+      return false;
+    }
+    if (this.mask(address.subnetMask) === address.mask()) {
+      return true;
+    }
+    return false;
+  }
+  function isCorrect(defaultBits) {
+    return function() {
+      if (this.addressMinusSuffix !== this.correctForm()) {
+        return false;
+      }
+      if (this.subnetMask === defaultBits && !this.parsedSubnet) {
+        return true;
+      }
+      return this.parsedSubnet === String(this.subnetMask);
+    };
+  }
+  function numberToPaddedHex(number) {
+    return number.toString(16).padStart(2, "0");
+  }
+  function stringToPaddedHex(numberString) {
+    return numberToPaddedHex(parseInt(numberString, 10));
+  }
+  function testBit(binaryValue, position) {
+    const { length } = binaryValue;
+    if (position > length) {
+      return false;
+    }
+    const positionInString = length - position;
+    return binaryValue.substring(positionInString, positionInString + 1) === "1";
+  }
+});
+
+// ../../node_modules/ip-address/dist/v4/constants.js
+var require_constants = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.RE_SUBNET_STRING = exports.RE_ADDRESS = exports.GROUPS = exports.BITS = undefined;
+  exports.BITS = 32;
+  exports.GROUPS = 4;
+  exports.RE_ADDRESS = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/g;
+  exports.RE_SUBNET_STRING = /\/\d{1,2}$/;
+});
+
+// ../../node_modules/ip-address/dist/address-error.js
+var require_address_error = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.AddressError = undefined;
+
+  class AddressError extends Error {
+    constructor(message, parseMessage) {
+      super(message);
+      this.name = "AddressError";
+      this.parseMessage = parseMessage;
+    }
+  }
+  exports.AddressError = AddressError;
+});
+
+// ../../node_modules/ip-address/dist/ipv4.js
+var require_ipv4 = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Address4 = undefined;
+  var common = __importStar(require_common());
+  var constants = __importStar(require_constants());
+  var address_error_1 = require_address_error();
+
+  class Address4 {
+    constructor(address) {
+      this.groups = constants.GROUPS;
+      this.parsedAddress = [];
+      this.parsedSubnet = "";
+      this.subnet = "/32";
+      this.subnetMask = 32;
+      this.v4 = true;
+      this.isCorrect = common.isCorrect(constants.BITS);
+      this.isInSubnet = common.isInSubnet;
+      this.address = address;
+      const subnet = constants.RE_SUBNET_STRING.exec(address);
+      if (subnet) {
+        this.parsedSubnet = subnet[0].replace("/", "");
+        this.subnetMask = parseInt(this.parsedSubnet, 10);
+        this.subnet = `/${this.subnetMask}`;
+        if (this.subnetMask < 0 || this.subnetMask > constants.BITS) {
+          throw new address_error_1.AddressError("Invalid subnet mask.");
+        }
+        address = address.replace(constants.RE_SUBNET_STRING, "");
+      }
+      this.addressMinusSuffix = address;
+      this.parsedAddress = this.parse(address);
+    }
+    static isValid(address) {
+      try {
+        new Address4(address);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    parse(address) {
+      const groups = address.split(".");
+      if (!address.match(constants.RE_ADDRESS)) {
+        throw new address_error_1.AddressError("Invalid IPv4 address.");
+      }
+      return groups;
+    }
+    correctForm() {
+      return this.parsedAddress.map((part) => parseInt(part, 10)).join(".");
+    }
+    static fromHex(hex) {
+      const padded = hex.replace(/:/g, "").padStart(8, "0");
+      const groups = [];
+      let i;
+      for (i = 0;i < 8; i += 2) {
+        const h = padded.slice(i, i + 2);
+        groups.push(parseInt(h, 16));
+      }
+      return new Address4(groups.join("."));
+    }
+    static fromInteger(integer) {
+      return Address4.fromHex(integer.toString(16));
+    }
+    static fromArpa(arpaFormAddress) {
+      const leader = arpaFormAddress.replace(/(\.in-addr\.arpa)?\.$/, "");
+      const address = leader.split(".").reverse().join(".");
+      return new Address4(address);
+    }
+    toHex() {
+      return this.parsedAddress.map((part) => common.stringToPaddedHex(part)).join(":");
+    }
+    toArray() {
+      return this.parsedAddress.map((part) => parseInt(part, 10));
+    }
+    toGroup6() {
+      const output = [];
+      let i;
+      for (i = 0;i < constants.GROUPS; i += 2) {
+        output.push(`${common.stringToPaddedHex(this.parsedAddress[i])}${common.stringToPaddedHex(this.parsedAddress[i + 1])}`);
+      }
+      return output.join(":");
+    }
+    bigInt() {
+      return BigInt(`0x${this.parsedAddress.map((n) => common.stringToPaddedHex(n)).join("")}`);
+    }
+    _startAddress() {
+      return BigInt(`0b${this.mask() + "0".repeat(constants.BITS - this.subnetMask)}`);
+    }
+    startAddress() {
+      return Address4.fromBigInt(this._startAddress());
+    }
+    startAddressExclusive() {
+      const adjust = BigInt("1");
+      return Address4.fromBigInt(this._startAddress() + adjust);
+    }
+    _endAddress() {
+      return BigInt(`0b${this.mask() + "1".repeat(constants.BITS - this.subnetMask)}`);
+    }
+    endAddress() {
+      return Address4.fromBigInt(this._endAddress());
+    }
+    endAddressExclusive() {
+      const adjust = BigInt("1");
+      return Address4.fromBigInt(this._endAddress() - adjust);
+    }
+    static fromBigInt(bigInt) {
+      return Address4.fromHex(bigInt.toString(16));
+    }
+    mask(mask) {
+      if (mask === undefined) {
+        mask = this.subnetMask;
+      }
+      return this.getBitsBase2(0, mask);
+    }
+    getBitsBase2(start, end) {
+      return this.binaryZeroPad().slice(start, end);
+    }
+    reverseForm(options) {
+      if (!options) {
+        options = {};
+      }
+      const reversed = this.correctForm().split(".").reverse().join(".");
+      if (options.omitSuffix) {
+        return reversed;
+      }
+      return `${reversed}.in-addr.arpa.`;
+    }
+    isMulticast() {
+      return this.isInSubnet(new Address4("224.0.0.0/4"));
+    }
+    binaryZeroPad() {
+      return this.bigInt().toString(2).padStart(constants.BITS, "0");
+    }
+    groupForV6() {
+      const segments = this.parsedAddress;
+      return this.address.replace(constants.RE_ADDRESS, `<span class="hover-group group-v4 group-6">${segments.slice(0, 2).join(".")}</span>.<span class="hover-group group-v4 group-7">${segments.slice(2, 4).join(".")}</span>`);
+    }
+  }
+  exports.Address4 = Address4;
+});
+
+// ../../node_modules/ip-address/dist/v6/constants.js
+var require_constants2 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.RE_URL_WITH_PORT = exports.RE_URL = exports.RE_ZONE_STRING = exports.RE_SUBNET_STRING = exports.RE_BAD_ADDRESS = exports.RE_BAD_CHARACTERS = exports.TYPES = exports.SCOPES = exports.GROUPS = exports.BITS = undefined;
+  exports.BITS = 128;
+  exports.GROUPS = 8;
+  exports.SCOPES = {
+    0: "Reserved",
+    1: "Interface local",
+    2: "Link local",
+    4: "Admin local",
+    5: "Site local",
+    8: "Organization local",
+    14: "Global",
+    15: "Reserved"
+  };
+  exports.TYPES = {
+    "ff01::1/128": "Multicast (All nodes on this interface)",
+    "ff01::2/128": "Multicast (All routers on this interface)",
+    "ff02::1/128": "Multicast (All nodes on this link)",
+    "ff02::2/128": "Multicast (All routers on this link)",
+    "ff05::2/128": "Multicast (All routers in this site)",
+    "ff02::5/128": "Multicast (OSPFv3 AllSPF routers)",
+    "ff02::6/128": "Multicast (OSPFv3 AllDR routers)",
+    "ff02::9/128": "Multicast (RIP routers)",
+    "ff02::a/128": "Multicast (EIGRP routers)",
+    "ff02::d/128": "Multicast (PIM routers)",
+    "ff02::16/128": "Multicast (MLDv2 reports)",
+    "ff01::fb/128": "Multicast (mDNSv6)",
+    "ff02::fb/128": "Multicast (mDNSv6)",
+    "ff05::fb/128": "Multicast (mDNSv6)",
+    "ff02::1:2/128": "Multicast (All DHCP servers and relay agents on this link)",
+    "ff05::1:2/128": "Multicast (All DHCP servers and relay agents in this site)",
+    "ff02::1:3/128": "Multicast (All DHCP servers on this link)",
+    "ff05::1:3/128": "Multicast (All DHCP servers in this site)",
+    "::/128": "Unspecified",
+    "::1/128": "Loopback",
+    "ff00::/8": "Multicast",
+    "fe80::/10": "Link-local unicast"
+  };
+  exports.RE_BAD_CHARACTERS = /([^0-9a-f:/%])/gi;
+  exports.RE_BAD_ADDRESS = /([0-9a-f]{5,}|:{3,}|[^:]:$|^:[^:]|\/$)/gi;
+  exports.RE_SUBNET_STRING = /\/\d{1,3}(?=%|$)/;
+  exports.RE_ZONE_STRING = /%.*$/;
+  exports.RE_URL = /^\[{0,1}([0-9a-f:]+)\]{0,1}/;
+  exports.RE_URL_WITH_PORT = /\[([0-9a-f:]+)\]:([0-9]{1,5})/;
+});
+
+// ../../node_modules/ip-address/dist/v6/helpers.js
+var require_helpers = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.spanAllZeroes = spanAllZeroes;
+  exports.spanAll = spanAll;
+  exports.spanLeadingZeroes = spanLeadingZeroes;
+  exports.simpleGroup = simpleGroup;
+  function spanAllZeroes(s) {
+    return s.replace(/(0+)/g, '<span class="zero">$1</span>');
+  }
+  function spanAll(s, offset = 0) {
+    const letters = s.split("");
+    return letters.map((n, i) => `<span class="digit value-${n} position-${i + offset}">${spanAllZeroes(n)}</span>`).join("");
+  }
+  function spanLeadingZeroesSimple(group) {
+    return group.replace(/^(0+)/, '<span class="zero">$1</span>');
+  }
+  function spanLeadingZeroes(address) {
+    const groups = address.split(":");
+    return groups.map((g) => spanLeadingZeroesSimple(g)).join(":");
+  }
+  function simpleGroup(addressString, offset = 0) {
+    const groups = addressString.split(":");
+    return groups.map((g, i) => {
+      if (/group-v4/.test(g)) {
+        return g;
+      }
+      return `<span class="hover-group group-${i + offset}">${spanLeadingZeroesSimple(g)}</span>`;
+    });
+  }
+});
+
+// ../../node_modules/ip-address/dist/v6/regular-expressions.js
+var require_regular_expressions = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.ADDRESS_BOUNDARY = undefined;
+  exports.groupPossibilities = groupPossibilities;
+  exports.padGroup = padGroup;
+  exports.simpleRegularExpression = simpleRegularExpression;
+  exports.possibleElisions = possibleElisions;
+  var v6 = __importStar(require_constants2());
+  function groupPossibilities(possibilities) {
+    return `(${possibilities.join("|")})`;
+  }
+  function padGroup(group) {
+    if (group.length < 4) {
+      return `0{0,${4 - group.length}}${group}`;
+    }
+    return group;
+  }
+  exports.ADDRESS_BOUNDARY = "[^A-Fa-f0-9:]";
+  function simpleRegularExpression(groups) {
+    const zeroIndexes = [];
+    groups.forEach((group, i) => {
+      const groupInteger = parseInt(group, 16);
+      if (groupInteger === 0) {
+        zeroIndexes.push(i);
+      }
+    });
+    const possibilities = zeroIndexes.map((zeroIndex) => groups.map((group, i) => {
+      if (i === zeroIndex) {
+        const elision = i === 0 || i === v6.GROUPS - 1 ? ":" : "";
+        return groupPossibilities([padGroup(group), elision]);
+      }
+      return padGroup(group);
+    }).join(":"));
+    possibilities.push(groups.map(padGroup).join(":"));
+    return groupPossibilities(possibilities);
+  }
+  function possibleElisions(elidedGroups, moreLeft, moreRight) {
+    const left = moreLeft ? "" : ":";
+    const right = moreRight ? "" : ":";
+    const possibilities = [];
+    if (!moreLeft && !moreRight) {
+      possibilities.push("::");
+    }
+    if (moreLeft && moreRight) {
+      possibilities.push("");
+    }
+    if (moreRight && !moreLeft || !moreRight && moreLeft) {
+      possibilities.push(":");
+    }
+    possibilities.push(`${left}(:0{1,4}){1,${elidedGroups - 1}}`);
+    possibilities.push(`(0{1,4}:){1,${elidedGroups - 1}}${right}`);
+    possibilities.push(`(0{1,4}:){${elidedGroups - 1}}0{1,4}`);
+    for (let groups = 1;groups < elidedGroups - 1; groups++) {
+      for (let position = 1;position < elidedGroups - groups; position++) {
+        possibilities.push(`(0{1,4}:){${position}}:(0{1,4}:){${elidedGroups - position - groups - 1}}0{1,4}`);
+      }
+    }
+    return groupPossibilities(possibilities);
+  }
+});
+
+// ../../node_modules/ip-address/dist/ipv6.js
+var require_ipv6 = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Address6 = undefined;
+  var common = __importStar(require_common());
+  var constants4 = __importStar(require_constants());
+  var constants6 = __importStar(require_constants2());
+  var helpers = __importStar(require_helpers());
+  var ipv4_1 = require_ipv4();
+  var regular_expressions_1 = require_regular_expressions();
+  var address_error_1 = require_address_error();
+  var common_1 = require_common();
+  function assert(condition) {
+    if (!condition) {
+      throw new Error("Assertion failed.");
+    }
+  }
+  function addCommas(number) {
+    const r = /(\d+)(\d{3})/;
+    while (r.test(number)) {
+      number = number.replace(r, "$1,$2");
+    }
+    return number;
+  }
+  function spanLeadingZeroes4(n) {
+    n = n.replace(/^(0{1,})([1-9]+)$/, '<span class="parse-error">$1</span>$2');
+    n = n.replace(/^(0{1,})(0)$/, '<span class="parse-error">$1</span>$2');
+    return n;
+  }
+  function compact(address, slice) {
+    const s1 = [];
+    const s2 = [];
+    let i;
+    for (i = 0;i < address.length; i++) {
+      if (i < slice[0]) {
+        s1.push(address[i]);
+      } else if (i > slice[1]) {
+        s2.push(address[i]);
+      }
+    }
+    return s1.concat(["compact"]).concat(s2);
+  }
+  function paddedHex(octet) {
+    return parseInt(octet, 16).toString(16).padStart(4, "0");
+  }
+  function unsignByte(b) {
+    return b & 255;
+  }
+
+  class Address6 {
+    constructor(address, optionalGroups) {
+      this.addressMinusSuffix = "";
+      this.parsedSubnet = "";
+      this.subnet = "/128";
+      this.subnetMask = 128;
+      this.v4 = false;
+      this.zone = "";
+      this.isInSubnet = common.isInSubnet;
+      this.isCorrect = common.isCorrect(constants6.BITS);
+      if (optionalGroups === undefined) {
+        this.groups = constants6.GROUPS;
+      } else {
+        this.groups = optionalGroups;
+      }
+      this.address = address;
+      const subnet = constants6.RE_SUBNET_STRING.exec(address);
+      if (subnet) {
+        this.parsedSubnet = subnet[0].replace("/", "");
+        this.subnetMask = parseInt(this.parsedSubnet, 10);
+        this.subnet = `/${this.subnetMask}`;
+        if (Number.isNaN(this.subnetMask) || this.subnetMask < 0 || this.subnetMask > constants6.BITS) {
+          throw new address_error_1.AddressError("Invalid subnet mask.");
+        }
+        address = address.replace(constants6.RE_SUBNET_STRING, "");
+      } else if (/\//.test(address)) {
+        throw new address_error_1.AddressError("Invalid subnet mask.");
+      }
+      const zone = constants6.RE_ZONE_STRING.exec(address);
+      if (zone) {
+        this.zone = zone[0];
+        address = address.replace(constants6.RE_ZONE_STRING, "");
+      }
+      this.addressMinusSuffix = address;
+      this.parsedAddress = this.parse(this.addressMinusSuffix);
+    }
+    static isValid(address) {
+      try {
+        new Address6(address);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    static fromBigInt(bigInt) {
+      const hex = bigInt.toString(16).padStart(32, "0");
+      const groups = [];
+      let i;
+      for (i = 0;i < constants6.GROUPS; i++) {
+        groups.push(hex.slice(i * 4, (i + 1) * 4));
+      }
+      return new Address6(groups.join(":"));
+    }
+    static fromURL(url) {
+      let host;
+      let port = null;
+      let result;
+      if (url.indexOf("[") !== -1 && url.indexOf("]:") !== -1) {
+        result = constants6.RE_URL_WITH_PORT.exec(url);
+        if (result === null) {
+          return {
+            error: "failed to parse address with port",
+            address: null,
+            port: null
+          };
+        }
+        host = result[1];
+        port = result[2];
+      } else if (url.indexOf("/") !== -1) {
+        url = url.replace(/^[a-z0-9]+:\/\//, "");
+        result = constants6.RE_URL.exec(url);
+        if (result === null) {
+          return {
+            error: "failed to parse address from URL",
+            address: null,
+            port: null
+          };
+        }
+        host = result[1];
+      } else {
+        host = url;
+      }
+      if (port) {
+        port = parseInt(port, 10);
+        if (port < 0 || port > 65536) {
+          port = null;
+        }
+      } else {
+        port = null;
+      }
+      return {
+        address: new Address6(host),
+        port
+      };
+    }
+    static fromAddress4(address) {
+      const address4 = new ipv4_1.Address4(address);
+      const mask6 = constants6.BITS - (constants4.BITS - address4.subnetMask);
+      return new Address6(`::ffff:${address4.correctForm()}/${mask6}`);
+    }
+    static fromArpa(arpaFormAddress) {
+      let address = arpaFormAddress.replace(/(\.ip6\.arpa)?\.$/, "");
+      const semicolonAmount = 7;
+      if (address.length !== 63) {
+        throw new address_error_1.AddressError("Invalid 'ip6.arpa' form.");
+      }
+      const parts = address.split(".").reverse();
+      for (let i = semicolonAmount;i > 0; i--) {
+        const insertIndex = i * 4;
+        parts.splice(insertIndex, 0, ":");
+      }
+      address = parts.join("");
+      return new Address6(address);
+    }
+    microsoftTranscription() {
+      return `${this.correctForm().replace(/:/g, "-")}.ipv6-literal.net`;
+    }
+    mask(mask = this.subnetMask) {
+      return this.getBitsBase2(0, mask);
+    }
+    possibleSubnets(subnetSize = 128) {
+      const availableBits = constants6.BITS - this.subnetMask;
+      const subnetBits = Math.abs(subnetSize - constants6.BITS);
+      const subnetPowers = availableBits - subnetBits;
+      if (subnetPowers < 0) {
+        return "0";
+      }
+      return addCommas((BigInt("2") ** BigInt(subnetPowers)).toString(10));
+    }
+    _startAddress() {
+      return BigInt(`0b${this.mask() + "0".repeat(constants6.BITS - this.subnetMask)}`);
+    }
+    startAddress() {
+      return Address6.fromBigInt(this._startAddress());
+    }
+    startAddressExclusive() {
+      const adjust = BigInt("1");
+      return Address6.fromBigInt(this._startAddress() + adjust);
+    }
+    _endAddress() {
+      return BigInt(`0b${this.mask() + "1".repeat(constants6.BITS - this.subnetMask)}`);
+    }
+    endAddress() {
+      return Address6.fromBigInt(this._endAddress());
+    }
+    endAddressExclusive() {
+      const adjust = BigInt("1");
+      return Address6.fromBigInt(this._endAddress() - adjust);
+    }
+    getScope() {
+      let scope = constants6.SCOPES[parseInt(this.getBits(12, 16).toString(10), 10)];
+      if (this.getType() === "Global unicast" && scope !== "Link local") {
+        scope = "Global";
+      }
+      return scope || "Unknown";
+    }
+    getType() {
+      for (const subnet of Object.keys(constants6.TYPES)) {
+        if (this.isInSubnet(new Address6(subnet))) {
+          return constants6.TYPES[subnet];
+        }
+      }
+      return "Global unicast";
+    }
+    getBits(start, end) {
+      return BigInt(`0b${this.getBitsBase2(start, end)}`);
+    }
+    getBitsBase2(start, end) {
+      return this.binaryZeroPad().slice(start, end);
+    }
+    getBitsBase16(start, end) {
+      const length = end - start;
+      if (length % 4 !== 0) {
+        throw new Error("Length of bits to retrieve must be divisible by four");
+      }
+      return this.getBits(start, end).toString(16).padStart(length / 4, "0");
+    }
+    getBitsPastSubnet() {
+      return this.getBitsBase2(this.subnetMask, constants6.BITS);
+    }
+    reverseForm(options) {
+      if (!options) {
+        options = {};
+      }
+      const characters = Math.floor(this.subnetMask / 4);
+      const reversed = this.canonicalForm().replace(/:/g, "").split("").slice(0, characters).reverse().join(".");
+      if (characters > 0) {
+        if (options.omitSuffix) {
+          return reversed;
+        }
+        return `${reversed}.ip6.arpa.`;
+      }
+      if (options.omitSuffix) {
+        return "";
+      }
+      return "ip6.arpa.";
+    }
+    correctForm() {
+      let i;
+      let groups = [];
+      let zeroCounter = 0;
+      const zeroes = [];
+      for (i = 0;i < this.parsedAddress.length; i++) {
+        const value = parseInt(this.parsedAddress[i], 16);
+        if (value === 0) {
+          zeroCounter++;
+        }
+        if (value !== 0 && zeroCounter > 0) {
+          if (zeroCounter > 1) {
+            zeroes.push([i - zeroCounter, i - 1]);
+          }
+          zeroCounter = 0;
+        }
+      }
+      if (zeroCounter > 1) {
+        zeroes.push([this.parsedAddress.length - zeroCounter, this.parsedAddress.length - 1]);
+      }
+      const zeroLengths = zeroes.map((n) => n[1] - n[0] + 1);
+      if (zeroes.length > 0) {
+        const index = zeroLengths.indexOf(Math.max(...zeroLengths));
+        groups = compact(this.parsedAddress, zeroes[index]);
+      } else {
+        groups = this.parsedAddress;
+      }
+      for (i = 0;i < groups.length; i++) {
+        if (groups[i] !== "compact") {
+          groups[i] = parseInt(groups[i], 16).toString(16);
+        }
+      }
+      let correct = groups.join(":");
+      correct = correct.replace(/^compact$/, "::");
+      correct = correct.replace(/(^compact)|(compact$)/, ":");
+      correct = correct.replace(/compact/, "");
+      return correct;
+    }
+    binaryZeroPad() {
+      return this.bigInt().toString(2).padStart(constants6.BITS, "0");
+    }
+    parse4in6(address) {
+      const groups = address.split(":");
+      const lastGroup = groups.slice(-1)[0];
+      const address4 = lastGroup.match(constants4.RE_ADDRESS);
+      if (address4) {
+        this.parsedAddress4 = address4[0];
+        this.address4 = new ipv4_1.Address4(this.parsedAddress4);
+        for (let i = 0;i < this.address4.groups; i++) {
+          if (/^0[0-9]+/.test(this.address4.parsedAddress[i])) {
+            throw new address_error_1.AddressError("IPv4 addresses can't have leading zeroes.", address.replace(constants4.RE_ADDRESS, this.address4.parsedAddress.map(spanLeadingZeroes4).join(".")));
+          }
+        }
+        this.v4 = true;
+        groups[groups.length - 1] = this.address4.toGroup6();
+        address = groups.join(":");
+      }
+      return address;
+    }
+    parse(address) {
+      address = this.parse4in6(address);
+      const badCharacters = address.match(constants6.RE_BAD_CHARACTERS);
+      if (badCharacters) {
+        throw new address_error_1.AddressError(`Bad character${badCharacters.length > 1 ? "s" : ""} detected in address: ${badCharacters.join("")}`, address.replace(constants6.RE_BAD_CHARACTERS, '<span class="parse-error">$1</span>'));
+      }
+      const badAddress = address.match(constants6.RE_BAD_ADDRESS);
+      if (badAddress) {
+        throw new address_error_1.AddressError(`Address failed regex: ${badAddress.join("")}`, address.replace(constants6.RE_BAD_ADDRESS, '<span class="parse-error">$1</span>'));
+      }
+      let groups = [];
+      const halves = address.split("::");
+      if (halves.length === 2) {
+        let first = halves[0].split(":");
+        let last = halves[1].split(":");
+        if (first.length === 1 && first[0] === "") {
+          first = [];
+        }
+        if (last.length === 1 && last[0] === "") {
+          last = [];
+        }
+        const remaining = this.groups - (first.length + last.length);
+        if (!remaining) {
+          throw new address_error_1.AddressError("Error parsing groups");
+        }
+        this.elidedGroups = remaining;
+        this.elisionBegin = first.length;
+        this.elisionEnd = first.length + this.elidedGroups;
+        groups = groups.concat(first);
+        for (let i = 0;i < remaining; i++) {
+          groups.push("0");
+        }
+        groups = groups.concat(last);
+      } else if (halves.length === 1) {
+        groups = address.split(":");
+        this.elidedGroups = 0;
+      } else {
+        throw new address_error_1.AddressError("Too many :: groups found");
+      }
+      groups = groups.map((group) => parseInt(group, 16).toString(16));
+      if (groups.length !== this.groups) {
+        throw new address_error_1.AddressError("Incorrect number of groups found");
+      }
+      return groups;
+    }
+    canonicalForm() {
+      return this.parsedAddress.map(paddedHex).join(":");
+    }
+    decimal() {
+      return this.parsedAddress.map((n) => parseInt(n, 16).toString(10).padStart(5, "0")).join(":");
+    }
+    bigInt() {
+      return BigInt(`0x${this.parsedAddress.map(paddedHex).join("")}`);
+    }
+    to4() {
+      const binary = this.binaryZeroPad().split("");
+      return ipv4_1.Address4.fromHex(BigInt(`0b${binary.slice(96, 128).join("")}`).toString(16));
+    }
+    to4in6() {
+      const address4 = this.to4();
+      const address6 = new Address6(this.parsedAddress.slice(0, 6).join(":"), 6);
+      const correct = address6.correctForm();
+      let infix = "";
+      if (!/:$/.test(correct)) {
+        infix = ":";
+      }
+      return correct + infix + address4.address;
+    }
+    inspectTeredo() {
+      const prefix = this.getBitsBase16(0, 32);
+      const bitsForUdpPort = this.getBits(80, 96);
+      const udpPort = (bitsForUdpPort ^ BigInt("0xffff")).toString();
+      const server4 = ipv4_1.Address4.fromHex(this.getBitsBase16(32, 64));
+      const bitsForClient4 = this.getBits(96, 128);
+      const client4 = ipv4_1.Address4.fromHex((bitsForClient4 ^ BigInt("0xffffffff")).toString(16));
+      const flagsBase2 = this.getBitsBase2(64, 80);
+      const coneNat = (0, common_1.testBit)(flagsBase2, 15);
+      const reserved = (0, common_1.testBit)(flagsBase2, 14);
+      const groupIndividual = (0, common_1.testBit)(flagsBase2, 8);
+      const universalLocal = (0, common_1.testBit)(flagsBase2, 9);
+      const nonce = BigInt(`0b${flagsBase2.slice(2, 6) + flagsBase2.slice(8, 16)}`).toString(10);
+      return {
+        prefix: `${prefix.slice(0, 4)}:${prefix.slice(4, 8)}`,
+        server4: server4.address,
+        client4: client4.address,
+        flags: flagsBase2,
+        coneNat,
+        microsoft: {
+          reserved,
+          universalLocal,
+          groupIndividual,
+          nonce
+        },
+        udpPort
+      };
+    }
+    inspect6to4() {
+      const prefix = this.getBitsBase16(0, 16);
+      const gateway = ipv4_1.Address4.fromHex(this.getBitsBase16(16, 48));
+      return {
+        prefix: prefix.slice(0, 4),
+        gateway: gateway.address
+      };
+    }
+    to6to4() {
+      if (!this.is4()) {
+        return null;
+      }
+      const addr6to4 = [
+        "2002",
+        this.getBitsBase16(96, 112),
+        this.getBitsBase16(112, 128),
+        "",
+        "/16"
+      ].join(":");
+      return new Address6(addr6to4);
+    }
+    toByteArray() {
+      const valueWithoutPadding = this.bigInt().toString(16);
+      const leadingPad = "0".repeat(valueWithoutPadding.length % 2);
+      const value = `${leadingPad}${valueWithoutPadding}`;
+      const bytes = [];
+      for (let i = 0, length = value.length;i < length; i += 2) {
+        bytes.push(parseInt(value.substring(i, i + 2), 16));
+      }
+      return bytes;
+    }
+    toUnsignedByteArray() {
+      return this.toByteArray().map(unsignByte);
+    }
+    static fromByteArray(bytes) {
+      return this.fromUnsignedByteArray(bytes.map(unsignByte));
+    }
+    static fromUnsignedByteArray(bytes) {
+      const BYTE_MAX = BigInt("256");
+      let result = BigInt("0");
+      let multiplier = BigInt("1");
+      for (let i = bytes.length - 1;i >= 0; i--) {
+        result += multiplier * BigInt(bytes[i].toString(10));
+        multiplier *= BYTE_MAX;
+      }
+      return Address6.fromBigInt(result);
+    }
+    isCanonical() {
+      return this.addressMinusSuffix === this.canonicalForm();
+    }
+    isLinkLocal() {
+      if (this.getBitsBase2(0, 64) === "1111111010000000000000000000000000000000000000000000000000000000") {
+        return true;
+      }
+      return false;
+    }
+    isMulticast() {
+      return this.getType() === "Multicast";
+    }
+    is4() {
+      return this.v4;
+    }
+    isTeredo() {
+      return this.isInSubnet(new Address6("2001::/32"));
+    }
+    is6to4() {
+      return this.isInSubnet(new Address6("2002::/16"));
+    }
+    isLoopback() {
+      return this.getType() === "Loopback";
+    }
+    href(optionalPort) {
+      if (optionalPort === undefined) {
+        optionalPort = "";
+      } else {
+        optionalPort = `:${optionalPort}`;
+      }
+      return `http://[${this.correctForm()}]${optionalPort}/`;
+    }
+    link(options) {
+      if (!options) {
+        options = {};
+      }
+      if (options.className === undefined) {
+        options.className = "";
+      }
+      if (options.prefix === undefined) {
+        options.prefix = "/#address=";
+      }
+      if (options.v4 === undefined) {
+        options.v4 = false;
+      }
+      let formFunction = this.correctForm;
+      if (options.v4) {
+        formFunction = this.to4in6;
+      }
+      const form = formFunction.call(this);
+      if (options.className) {
+        return `<a href="${options.prefix}${form}" class="${options.className}">${form}</a>`;
+      }
+      return `<a href="${options.prefix}${form}">${form}</a>`;
+    }
+    group() {
+      if (this.elidedGroups === 0) {
+        return helpers.simpleGroup(this.address).join(":");
+      }
+      assert(typeof this.elidedGroups === "number");
+      assert(typeof this.elisionBegin === "number");
+      const output = [];
+      const [left, right] = this.address.split("::");
+      if (left.length) {
+        output.push(...helpers.simpleGroup(left));
+      } else {
+        output.push("");
+      }
+      const classes = ["hover-group"];
+      for (let i = this.elisionBegin;i < this.elisionBegin + this.elidedGroups; i++) {
+        classes.push(`group-${i}`);
+      }
+      output.push(`<span class="${classes.join(" ")}"></span>`);
+      if (right.length) {
+        output.push(...helpers.simpleGroup(right, this.elisionEnd));
+      } else {
+        output.push("");
+      }
+      if (this.is4()) {
+        assert(this.address4 instanceof ipv4_1.Address4);
+        output.pop();
+        output.push(this.address4.groupForV6());
+      }
+      return output.join(":");
+    }
+    regularExpressionString(substringSearch = false) {
+      let output = [];
+      const address6 = new Address6(this.correctForm());
+      if (address6.elidedGroups === 0) {
+        output.push((0, regular_expressions_1.simpleRegularExpression)(address6.parsedAddress));
+      } else if (address6.elidedGroups === constants6.GROUPS) {
+        output.push((0, regular_expressions_1.possibleElisions)(constants6.GROUPS));
+      } else {
+        const halves = address6.address.split("::");
+        if (halves[0].length) {
+          output.push((0, regular_expressions_1.simpleRegularExpression)(halves[0].split(":")));
+        }
+        assert(typeof address6.elidedGroups === "number");
+        output.push((0, regular_expressions_1.possibleElisions)(address6.elidedGroups, halves[0].length !== 0, halves[1].length !== 0));
+        if (halves[1].length) {
+          output.push((0, regular_expressions_1.simpleRegularExpression)(halves[1].split(":")));
+        }
+        output = [output.join(":")];
+      }
+      if (!substringSearch) {
+        output = [
+          "(?=^|",
+          regular_expressions_1.ADDRESS_BOUNDARY,
+          "|[^\\w\\:])(",
+          ...output,
+          ")(?=[^\\w\\:]|",
+          regular_expressions_1.ADDRESS_BOUNDARY,
+          "|$)"
+        ];
+      }
+      return output.join("");
+    }
+    regularExpression(substringSearch = false) {
+      return new RegExp(this.regularExpressionString(substringSearch), "i");
+    }
+  }
+  exports.Address6 = Address6;
+});
+
+// ../../node_modules/ip-address/dist/ip-address.js
+var require_ip_address = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.v6 = exports.AddressError = exports.Address6 = exports.Address4 = undefined;
+  var ipv4_1 = require_ipv4();
+  Object.defineProperty(exports, "Address4", { enumerable: true, get: function() {
+    return ipv4_1.Address4;
+  } });
+  var ipv6_1 = require_ipv6();
+  Object.defineProperty(exports, "Address6", { enumerable: true, get: function() {
+    return ipv6_1.Address6;
+  } });
+  var address_error_1 = require_address_error();
+  Object.defineProperty(exports, "AddressError", { enumerable: true, get: function() {
+    return address_error_1.AddressError;
+  } });
+  var helpers = __importStar(require_helpers());
+  exports.v6 = { helpers };
+});
+
 // ../../node_modules/dotenv/package.json
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "dotenv",
-    version: "16.6.1",
+    version: "17.2.3",
     description: "Loads environment variables from .env file",
     main: "lib/main.js",
     types: "lib/main.d.ts",
@@ -396,8 +1468,8 @@ var require_package = __commonJS((exports, module) => {
       "dts-check": "tsc --project tests/types/tsconfig.json",
       lint: "standard",
       pretest: "npm run lint && npm run dts-check",
-      test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
-      "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+      test: "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+      "test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
       prerelease: "npm test",
       release: "standard-version"
     },
@@ -444,6 +1516,39 @@ var require_main = __commonJS((exports, module) => {
   var crypto = __require("crypto");
   var packageJson = require_package();
   var version = packageJson.version;
+  var TIPS = [
+    "\uD83D\uDD10 encrypt with Dotenvx: https://dotenvx.com",
+    "\uD83D\uDD10 prevent committing .env to code: https://dotenvx.com/precommit",
+    "\uD83D\uDD10 prevent building .env in docker: https://dotenvx.com/prebuild",
+    "\uD83D\uDCE1 add observability to secrets: https://dotenvx.com/ops",
+    "\uD83D\uDC65 sync secrets across teammates & machines: https://dotenvx.com/ops",
+    "\uD83D\uDDC2️ backup and recover secrets: https://dotenvx.com/ops",
+    "✅ audit secrets and track compliance: https://dotenvx.com/ops",
+    "\uD83D\uDD04 add secrets lifecycle management: https://dotenvx.com/ops",
+    "\uD83D\uDD11 add access controls to secrets: https://dotenvx.com/ops",
+    "\uD83D\uDEE0️  run anywhere with `dotenvx run -- yourcommand`",
+    "⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+    "⚙️  enable debug logging with { debug: true }",
+    "⚙️  override existing env vars with { override: true }",
+    "⚙️  suppress all logs with { quiet: true }",
+    "⚙️  write to custom object with { processEnv: myObject }",
+    "⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+  ];
+  function _getRandomTip() {
+    return TIPS[Math.floor(Math.random() * TIPS.length)];
+  }
+  function parseBoolean(value) {
+    if (typeof value === "string") {
+      return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+    }
+    return Boolean(value);
+  }
+  function supportsAnsi() {
+    return process.stdout.isTTY;
+  }
+  function dim(text) {
+    return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+  }
   var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
   function parse(src) {
     const obj = {};
@@ -494,7 +1599,7 @@ var require_main = __commonJS((exports, module) => {
     return DotenvModule.parse(decrypted);
   }
   function _warn(message) {
-    console.log(`[dotenv@${version}][WARN] ${message}`);
+    console.error(`[dotenv@${version}][WARN] ${message}`);
   }
   function _debug(message) {
     console.log(`[dotenv@${version}][DEBUG] ${message}`);
@@ -568,8 +1673,8 @@ var require_main = __commonJS((exports, module) => {
     return envPath[0] === "~" ? path5.join(os.homedir(), envPath.slice(1)) : envPath;
   }
   function _configVault(options) {
-    const debug = Boolean(options && options.debug);
-    const quiet = options && "quiet" in options ? options.quiet : true;
+    const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+    const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
     if (debug || !quiet) {
       _log("Loading env from encrypted .env.vault");
     }
@@ -584,8 +1689,12 @@ var require_main = __commonJS((exports, module) => {
   function configDotenv(options) {
     const dotenvPath = path5.resolve(process.cwd(), ".env");
     let encoding = "utf8";
-    const debug = Boolean(options && options.debug);
-    const quiet = options && "quiet" in options ? options.quiet : true;
+    let processEnv = process.env;
+    if (options && options.processEnv != null) {
+      processEnv = options.processEnv;
+    }
+    let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+    let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
     if (options && options.encoding) {
       encoding = options.encoding;
     } else {
@@ -617,13 +1726,11 @@ var require_main = __commonJS((exports, module) => {
         lastError = e;
       }
     }
-    let processEnv = process.env;
-    if (options && options.processEnv != null) {
-      processEnv = options.processEnv;
-    }
-    DotenvModule.populate(processEnv, parsedAll, options);
+    const populated = DotenvModule.populate(processEnv, parsedAll, options);
+    debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+    quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
     if (debug || !quiet) {
-      const keysCount = Object.keys(parsedAll).length;
+      const keysCount = Object.keys(populated).length;
       const shortPaths = [];
       for (const filePath of optionPaths) {
         try {
@@ -636,7 +1743,7 @@ var require_main = __commonJS((exports, module) => {
           lastError = e;
         }
       }
-      _log(`injecting env (${keysCount}) from ${shortPaths.join(",")}`);
+      _log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
     }
     if (lastError) {
       return { parsed: parsedAll, error: lastError };
@@ -685,6 +1792,7 @@ var require_main = __commonJS((exports, module) => {
   function populate(processEnv, parsed, options = {}) {
     const debug = Boolean(options && options.debug);
     const override = Boolean(options && options.override);
+    const populated = {};
     if (typeof parsed !== "object") {
       const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
       err.code = "OBJECT_REQUIRED";
@@ -694,6 +1802,7 @@ var require_main = __commonJS((exports, module) => {
       if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
         if (override === true) {
           processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
         }
         if (debug) {
           if (override === true) {
@@ -704,8 +1813,10 @@ var require_main = __commonJS((exports, module) => {
         }
       } else {
         processEnv[key] = parsed[key];
+        populated[key] = parsed[key];
       }
     }
+    return populated;
   }
   var DotenvModule = {
     configDotenv,
@@ -2148,7 +3259,7 @@ var require_suppress_tracing = __commonJS((exports) => {
 });
 
 // ../../node_modules/@opentelemetry/core/build/src/baggage/constants.js
-var require_constants = __commonJS((exports) => {
+var require_constants3 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.BAGGAGE_MAX_TOTAL_LENGTH = exports.BAGGAGE_MAX_PER_NAME_VALUE_PAIRS = exports.BAGGAGE_MAX_NAME_VALUE_PAIRS = exports.BAGGAGE_HEADER = exports.BAGGAGE_ITEMS_SEPARATOR = exports.BAGGAGE_PROPERTIES_SEPARATOR = exports.BAGGAGE_KEY_PAIR_SEPARATOR = undefined;
   exports.BAGGAGE_KEY_PAIR_SEPARATOR = "=";
@@ -2165,7 +3276,7 @@ var require_utils3 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.parseKeyPairsIntoRecord = exports.parsePairKeyValue = exports.getKeyPairs = exports.serializeKeyPairs = undefined;
   var api_1 = require_src();
-  var constants_1 = require_constants();
+  var constants_1 = require_constants3();
   function serializeKeyPairs(keyPairs) {
     return keyPairs.reduce((hValue, current) => {
       const value = `${hValue}${hValue !== "" ? constants_1.BAGGAGE_ITEMS_SEPARATOR : ""}${current}`;
@@ -2223,7 +3334,7 @@ var require_W3CBaggagePropagator = __commonJS((exports) => {
   exports.W3CBaggagePropagator = undefined;
   var api_1 = require_src();
   var suppress_tracing_1 = require_suppress_tracing();
-  var constants_1 = require_constants();
+  var constants_1 = require_constants3();
   var utils_1 = require_utils3();
 
   class W3CBaggagePropagator {
@@ -5930,7 +7041,7 @@ var require_ms = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/debug/src/common.js
-var require_common = __commonJS((exports, module) => {
+var require_common2 = __commonJS((exports, module) => {
   function setup(env) {
     createDebug.debug = createDebug;
     createDebug.default = createDebug;
@@ -6253,7 +7364,7 @@ var require_browser = __commonJS((exports, module) => {
       return localStorage;
     } catch (error) {}
   }
-  module.exports = require_common()(exports);
+  module.exports = require_common2()(exports);
   var { formatters } = module.exports;
   formatters.j = function(v) {
     try {
@@ -6543,7 +7654,7 @@ var require_node4 = __commonJS((exports, module) => {
       debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
     }
   }
-  module.exports = require_common()(exports);
+  module.exports = require_common2()(exports);
   var { formatters } = module.exports;
   formatters.o = function(v) {
     this.inspectOpts.colors = this.useColors;
@@ -17823,7 +18934,7 @@ var require_autoLoader2 = __commonJS((exports) => {
 });
 
 // ../../node_modules/semver/internal/constants.js
-var require_constants2 = __commonJS((exports, module) => {
+var require_constants4 = __commonJS((exports, module) => {
   var SEMVER_SPEC_VERSION = "2.0.0";
   var MAX_LENGTH = 256;
   var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
@@ -17862,7 +18973,7 @@ var require_re = __commonJS((exports, module) => {
     MAX_SAFE_COMPONENT_LENGTH,
     MAX_SAFE_BUILD_LENGTH,
     MAX_LENGTH
-  } = require_constants2();
+  } = require_constants4();
   var debug2 = require_debug();
   exports = module.exports = {};
   var re = exports.re = [];
@@ -17979,7 +19090,7 @@ var require_identifiers = __commonJS((exports, module) => {
 // ../../node_modules/semver/classes/semver.js
 var require_semver3 = __commonJS((exports, module) => {
   var debug2 = require_debug();
-  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants2();
+  var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants4();
   var { safeRe: re, t } = require_re();
   var parseOptions2 = require_parse_options();
   var { compareIdentifiers } = require_identifiers();
@@ -18724,7 +19835,7 @@ var require_range = __commonJS((exports, module) => {
     tildeTrimReplace,
     caretTrimReplace
   } = require_re();
-  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants2();
+  var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants4();
   var isNullSet = (c) => c.value === "<0.0.0-0";
   var isAny = (c) => c.value === "";
   var isSatisfiable = (comparators, options) => {
@@ -19494,7 +20605,7 @@ var require_subset = __commonJS((exports, module) => {
 // ../../node_modules/semver/index.js
 var require_semver4 = __commonJS((exports, module) => {
   var internalRe = require_re();
-  var constants2 = require_constants2();
+  var constants2 = require_constants4();
   var SemVer = require_semver3();
   var identifiers = require_identifiers();
   var parse = require_parse();
@@ -24339,20 +25450,99 @@ var getRuntime = (elizaOS, agentId) => {
 };
 
 // ../../node_modules/express-rate-limit/dist/index.mjs
+var import_ip_address = __toESM(require_ip_address(), 1);
+import { isIPv6 } from "node:net";
+import { isIPv6 as isIPv62 } from "node:net";
 import { Buffer as Buffer2 } from "node:buffer";
 import { createHash } from "node:crypto";
 import { isIP } from "node:net";
+function ipKeyGenerator(ip, ipv6Subnet = 56) {
+  if (ipv6Subnet && isIPv6(ip)) {
+    return `${new import_ip_address.Address6(`${ip}/${ipv6Subnet}`).startAddress().correctForm()}/${ipv6Subnet}`;
+  }
+  return ip;
+}
+var MemoryStore = class {
+  constructor(validations2) {
+    this.validations = validations2;
+    this.previous = /* @__PURE__ */ new Map;
+    this.current = /* @__PURE__ */ new Map;
+    this.localKeys = true;
+  }
+  init(options) {
+    this.windowMs = options.windowMs;
+    this.validations?.windowMs(this.windowMs);
+    if (this.interval)
+      clearInterval(this.interval);
+    this.interval = setInterval(() => {
+      this.clearExpired();
+    }, this.windowMs);
+    this.interval.unref?.();
+  }
+  async get(key) {
+    return this.current.get(key) ?? this.previous.get(key);
+  }
+  async increment(key) {
+    const client = this.getClient(key);
+    const now = Date.now();
+    if (client.resetTime.getTime() <= now) {
+      this.resetClient(client, now);
+    }
+    client.totalHits++;
+    return client;
+  }
+  async decrement(key) {
+    const client = this.getClient(key);
+    if (client.totalHits > 0)
+      client.totalHits--;
+  }
+  async resetKey(key) {
+    this.current.delete(key);
+    this.previous.delete(key);
+  }
+  async resetAll() {
+    this.current.clear();
+    this.previous.clear();
+  }
+  shutdown() {
+    clearInterval(this.interval);
+    this.resetAll();
+  }
+  resetClient(client, now = Date.now()) {
+    client.totalHits = 0;
+    client.resetTime.setTime(now + this.windowMs);
+    return client;
+  }
+  getClient(key) {
+    if (this.current.has(key))
+      return this.current.get(key);
+    let client;
+    if (this.previous.has(key)) {
+      client = this.previous.get(key);
+      this.previous.delete(key);
+    } else {
+      client = { totalHits: 0, resetTime: /* @__PURE__ */ new Date };
+      this.resetClient(client);
+    }
+    this.current.set(key, client);
+    return client;
+  }
+  clearExpired() {
+    this.previous = this.current;
+    this.current = /* @__PURE__ */ new Map;
+  }
+};
 var SUPPORTED_DRAFT_VERSIONS = [
   "draft-6",
   "draft-7",
   "draft-8"
 ];
-var getResetSeconds = (resetTime, windowMs) => {
-  let resetSeconds = undefined;
+var getResetSeconds = (windowMs, resetTime) => {
+  let resetSeconds;
   if (resetTime) {
     const deltaSeconds = Math.ceil((resetTime.getTime() - Date.now()) / 1000);
     resetSeconds = Math.max(0, deltaSeconds);
-  } else if (windowMs) {
+  } else {
     resetSeconds = Math.ceil(windowMs / 1000);
   }
   return resetSeconds;
@@ -24377,18 +25567,18 @@ var setDraft6Headers = (response, info, windowMs) => {
   if (response.headersSent)
     return;
   const windowSeconds = Math.ceil(windowMs / 1000);
-  const resetSeconds = getResetSeconds(info.resetTime);
+  const resetSeconds = getResetSeconds(windowMs, info.resetTime);
   response.setHeader("RateLimit-Policy", `${info.limit};w=${windowSeconds}`);
   response.setHeader("RateLimit-Limit", info.limit.toString());
   response.setHeader("RateLimit-Remaining", info.remaining.toString());
-  if (resetSeconds)
+  if (typeof resetSeconds === "number")
     response.setHeader("RateLimit-Reset", resetSeconds.toString());
 };
 var setDraft7Headers = (response, info, windowMs) => {
   if (response.headersSent)
     return;
   const windowSeconds = Math.ceil(windowMs / 1000);
-  const resetSeconds = getResetSeconds(info.resetTime, windowMs);
+  const resetSeconds = getResetSeconds(windowMs, info.resetTime);
   response.setHeader("RateLimit-Policy", `${info.limit};w=${windowSeconds}`);
   response.setHeader("RateLimit", `limit=${info.limit}, remaining=${info.remaining}, reset=${resetSeconds}`);
 };
@@ -24396,19 +25586,29 @@ var setDraft8Headers = (response, info, windowMs, name, key) => {
   if (response.headersSent)
     return;
   const windowSeconds = Math.ceil(windowMs / 1000);
-  const resetSeconds = getResetSeconds(info.resetTime, windowMs);
+  const resetSeconds = getResetSeconds(windowMs, info.resetTime);
   const partitionKey = getPartitionKey(key);
-  const policy = `q=${info.limit}; w=${windowSeconds}; pk=:${partitionKey}:`;
   const header = `r=${info.remaining}; t=${resetSeconds}`;
-  response.append("RateLimit-Policy", `"${name}"; ${policy}`);
+  const policy = `q=${info.limit}; w=${windowSeconds}; pk=:${partitionKey}:`;
   response.append("RateLimit", `"${name}"; ${header}`);
+  response.append("RateLimit-Policy", `"${name}"; ${policy}`);
 };
 var setRetryAfterHeader = (response, info, windowMs) => {
   if (response.headersSent)
     return;
-  const resetSeconds = getResetSeconds(info.resetTime, windowMs);
+  const resetSeconds = getResetSeconds(windowMs, info.resetTime);
   response.setHeader("Retry-After", resetSeconds.toString());
 };
+var omitUndefinedProperties = (passedOptions) => {
+  const omittedOptions = {};
+  for (const k of Object.keys(passedOptions)) {
+    const key = k;
+    if (passedOptions[key] !== undefined) {
+      omittedOptions[key] = passedOptions[key];
+    }
+  }
+  return omittedOptions;
+};
 var ValidationError = class extends Error {
   constructor(code, message) {
     const url = `https://express-rate-limit.github.io/${code}/`;
@@ -24448,6 +25648,11 @@ var validations = {
       throw new ValidationError("ERR_ERL_UNEXPECTED_X_FORWARDED_FOR", `The 'X-Forwarded-For' header is set but the Express 'trust proxy' setting is false (default). This could indicate a misconfiguration which would prevent express-rate-limit from accurately identifying users.`);
     }
   },
+  forwardedHeader(request) {
+    if (request.headers.forwarded && request.ip === request.socket?.remoteAddress) {
+      throw new ValidationError("ERR_ERL_FORWARDED_HEADER", `The 'Forwarded' header (standardized X-Forwarded-For) is set but currently being ignored. Add a custom keyGenerator to use a value from this header.`);
+    }
+  },
   positiveHits(hits) {
     if (typeof hits !== "number" || hits < 1 || hits !== Math.round(hits)) {
       throw new ValidationError("ERR_ERL_INVALID_HITS", `The totalHits value returned from the store must be a positive integer, got ${hits}`);
@@ -24480,7 +25685,7 @@ var validations = {
   },
   limit(limit) {
     if (limit === 0) {
-      throw new ChangeWarning("WRN_ERL_MAX_ZERO", `Setting limit or max to 0 disables rate limiting in express-rate-limit v6 and older, but will cause all requests to be blocked in v7`);
+      throw new ChangeWarning("WRN_ERL_MAX_ZERO", "Setting limit or max to 0 disables rate limiting in express-rate-limit v6 and older, but will cause all requests to be blocked in v7");
     }
   },
   draftPolliHeaders(draft_polli_ratelimit_headers) {
@@ -24490,7 +25695,7 @@ var validations = {
   },
   onLimitReached(onLimitReached) {
     if (onLimitReached) {
-      throw new ChangeWarning("WRN_ERL_DEPRECATED_ON_LIMIT_REACHED", `The onLimitReached configuration option is deprecated and has been removed in express-rate-limit v7.`);
+      throw new ChangeWarning("WRN_ERL_DEPRECATED_ON_LIMIT_REACHED", "The onLimitReached configuration option is deprecated and has been removed in express-rate-limit v7.");
     }
   },
   headersDraftVersion(version) {
@@ -24515,11 +25720,39 @@ var validations = {
   },
   creationStack(store) {
     const { stack } = new Error("express-rate-limit validation check (set options.validate.creationStack=false to disable)");
-    if (stack?.includes("Layer.handle [as handle_request]")) {
+    if (stack?.includes("Layer.handle [as handle_request]") || stack?.includes("Layer.handleRequest")) {
       if (!store.localKeys) {
         throw new ValidationError("ERR_ERL_CREATED_IN_REQUEST_HANDLER", "express-rate-limit instance should *usually* be created at app initialization, not when responding to a request.");
       }
-      throw new ValidationError("ERR_ERL_CREATED_IN_REQUEST_HANDLER", `express-rate-limit instance should be created at app initialization, not when responding to a request.`);
+      throw new ValidationError("ERR_ERL_CREATED_IN_REQUEST_HANDLER", "express-rate-limit instance should be created at app initialization, not when responding to a request.");
+    }
+  },
+  ipv6Subnet(ipv6Subnet) {
+    if (ipv6Subnet === false) {
+      return;
+    }
+    if (!Number.isInteger(ipv6Subnet) || ipv6Subnet < 32 || ipv6Subnet > 64) {
+      throw new ValidationError("ERR_ERL_IPV6_SUBNET", `Unexpected ipv6Subnet value: ${ipv6Subnet}. Expected an integer between 32 and 64 (usually 48-64).`);
+    }
+  },
+  ipv6SubnetOrKeyGenerator(options) {
+    if (options.ipv6Subnet !== undefined && options.keyGenerator) {
+      throw new ValidationError("ERR_ERL_IPV6SUBNET_OR_KEYGENERATOR", `Incompatible options: the 'ipv6Subnet' option is ignored when a custom 'keyGenerator' function is also set.`);
+    }
+  },
+  keyGeneratorIpFallback(keyGenerator) {
+    if (!keyGenerator) {
+      return;
+    }
+    const src = keyGenerator.toString();
+    if ((src.includes("req.ip") || src.includes("request.ip")) && !src.includes("ipKeyGenerator")) {
+      throw new ValidationError("ERR_ERL_KEY_GEN_IPV6", "Custom keyGenerator appears to use request IP without calling the ipKeyGenerator helper function for IPv6 addresses. This could allow IPv6 users to bypass limits.");
+    }
+  },
+  windowMs(windowMs) {
+    const SET_TIMEOUT_MAX = 2 ** 31 - 1;
+    if (typeof windowMs !== "number" || Number.isNaN(windowMs) || windowMs < 1 || windowMs > SET_TIMEOUT_MAX) {
+      throw new ValidationError("ERR_ERL_WINDOW_MS", `Invalid windowMs value: ${windowMs}${typeof windowMs !== "number" ? ` (${typeof windowMs})` : ""}, must be a number between 1 and ${SET_TIMEOUT_MAX} when using the default MemoryStore`);
     }
   }
 };
@@ -24535,9 +25768,7 @@ var getValidations = (_enabled) => {
       ..._enabled
     };
   }
-  const wrappedValidations = {
-    enabled
-  };
+  const wrappedValidations = { enabled };
   for (const [name, validation] of Object.entries(validations)) {
     if (typeof validation === "function")
       wrappedValidations[name] = (...args) => {
@@ -24556,75 +25787,6 @@ var getValidations = (_enabled) => {
   }
   return wrappedValidations;
 };
-var MemoryStore = class {
-  constructor() {
-    this.previous = /* @__PURE__ */ new Map;
-    this.current = /* @__PURE__ */ new Map;
-    this.localKeys = true;
-  }
-  init(options) {
-    this.windowMs = options.windowMs;
-    if (this.interval)
-      clearInterval(this.interval);
-    this.interval = setInterval(() => {
-      this.clearExpired();
-    }, this.windowMs);
-    if (this.interval.unref)
-      this.interval.unref();
-  }
-  async get(key) {
-    return this.current.get(key) ?? this.previous.get(key);
-  }
-  async increment(key) {
-    const client = this.getClient(key);
-    const now = Date.now();
-    if (client.resetTime.getTime() <= now) {
-      this.resetClient(client, now);
-    }
-    client.totalHits++;
-    return client;
-  }
-  async decrement(key) {
-    const client = this.getClient(key);
-    if (client.totalHits > 0)
-      client.totalHits--;
-  }
-  async resetKey(key) {
-    this.current.delete(key);
-    this.previous.delete(key);
-  }
-  async resetAll() {
-    this.current.clear();
-    this.previous.clear();
-  }
-  shutdown() {
-    clearInterval(this.interval);
-    this.resetAll();
-  }
-  resetClient(client, now = Date.now()) {
-    client.totalHits = 0;
-    client.resetTime.setTime(now + this.windowMs);
-    return client;
-  }
-  getClient(key) {
-    if (this.current.has(key))
-      return this.current.get(key);
-    let client;
-    if (this.previous.has(key)) {
-      client = this.previous.get(key);
-      this.previous.delete(key);
-    } else {
-      client = { totalHits: 0, resetTime: /* @__PURE__ */ new Date };
-      this.resetClient(client);
-    }
-    this.current.set(key, client);
-    return client;
-  }
-  clearExpired() {
-    this.previous = this.current;
-    this.current = /* @__PURE__ */ new Map;
-  }
-};
 var isLegacyStore = (store) => typeof store.incr === "function" && typeof store.increment !== "function";
 var promisifyStore = (passedStore) => {
   if (!isLegacyStore(passedStore)) {
@@ -24662,22 +25824,17 @@ var getOptionsFromConfig = (config) => {
     validate: validations2.enabled
   };
 };
-var omitUndefinedOptions = (passedOptions) => {
-  const omittedOptions = {};
-  for (const k of Object.keys(passedOptions)) {
-    const key = k;
-    if (passedOptions[key] !== undefined) {
-      omittedOptions[key] = passedOptions[key];
-    }
-  }
-  return omittedOptions;
-};
 var parseOptions = (passedOptions) => {
-  const notUndefinedOptions = omitUndefinedOptions(passedOptions);
+  const notUndefinedOptions = omitUndefinedProperties(passedOptions);
   const validations2 = getValidations(notUndefinedOptions?.validate ?? true);
   validations2.validationsConfig();
   validations2.draftPolliHeaders(notUndefinedOptions.draft_polli_ratelimit_headers);
   validations2.onLimitReached(notUndefinedOptions.onLimitReached);
+  if (notUndefinedOptions.ipv6Subnet !== undefined && typeof notUndefinedOptions.ipv6Subnet !== "function") {
+    validations2.ipv6Subnet(notUndefinedOptions.ipv6Subnet);
+  }
+  validations2.keyGeneratorIpFallback(notUndefinedOptions.keyGenerator);
+  validations2.ipv6SubnetOrKeyGenerator(notUndefinedOptions);
   let standardHeaders = notUndefinedOptions.standardHeaders ?? false;
   if (standardHeaders === true)
     standardHeaders = "draft-6";
@@ -24710,23 +25867,31 @@ var parseOptions = (passedOptions) => {
     skipSuccessfulRequests: false,
     requestWasSuccessful: (_request, response) => response.statusCode < 400,
     skip: (_request, _response) => false,
-    keyGenerator(request, _response) {
+    async keyGenerator(request, response) {
       validations2.ip(request.ip);
       validations2.trustProxy(request);
       validations2.xForwardedForHeader(request);
-      return request.ip;
+      validations2.forwardedHeader(request);
+      const ip = request.ip;
+      let subnet = 56;
+      if (isIPv62(ip)) {
+        subnet = typeof config.ipv6Subnet === "function" ? await config.ipv6Subnet(request, response) : config.ipv6Subnet;
+        if (typeof config.ipv6Subnet === "function")
+          validations2.ipv6Subnet(subnet);
+      }
+      return ipKeyGenerator(ip, subnet);
     },
+    ipv6Subnet: 56,
     async handler(request, response, _next, _optionsUsed) {
       response.status(config.statusCode);
       const message = typeof config.message === "function" ? await config.message(request, response) : config.message;
-      if (!response.writableEnded) {
+      if (!response.writableEnded)
         response.send(message);
-      }
     },
     passOnStoreError: false,
     ...notUndefinedOptions,
     standardHeaders,
-    store: promisifyStore(notUndefinedOptions.store ?? new MemoryStore),
+    store: promisifyStore(notUndefinedOptions.store ?? new MemoryStore(validations2)),
     validations: validations2
   };
   if (typeof config.store.increment !== "function" || typeof config.store.decrement !== "function" || typeof config.store.resetKey !== "function" || config.store.resetAll !== undefined && typeof config.store.resetAll !== "function" || config.store.init !== undefined && typeof config.store.init !== "function") {
@@ -24779,7 +25944,8 @@ var rateLimit = (passedOptions) => {
       limit,
       used: totalHits,
       remaining: Math.max(limit - totalHits, 0),
-      resetTime
+      resetTime,
+      key
     };
     Object.defineProperty(info, "current", {
       configurable: false,
@@ -24859,7 +26025,7 @@ var rateLimit = (passedOptions) => {
   middleware.getKey = typeof config.store.get === "function" ? config.store.get.bind(config.store) : getThrowFn;
   return middleware;
 };
-var lib_default = rateLimit;
+var rate_limit_default = rateLimit;
 
 // src/api/shared/middleware.ts
 var securityMiddleware = () => {
@@ -24933,7 +26099,7 @@ var validateContentTypeMiddleware = () => {
   };
 };
 var createApiRateLimit = () => {
-  return lib_default({
+  return rate_limit_default({
     windowMs: 15 * 60 * 1000,
     max: 1000,
     message: {
@@ -24959,7 +26125,7 @@ var createApiRateLimit = () => {
   });
 };
 var createFileSystemRateLimit = () => {
-  return lib_default({
+  return rate_limit_default({
     windowMs: 5 * 60 * 1000,
     max: 100,
     message: {
@@ -24985,7 +26151,7 @@ var createFileSystemRateLimit = () => {
   });
 };
 var createUploadRateLimit = () => {
-  return lib_default({
+  return rate_limit_default({
     windowMs: 15 * 60 * 1000,
     max: 50,
     message: {
@@ -25740,7 +26906,7 @@ import {
 } from "@elizaos/core";
 import express13 from "express";
 
-// ../../node_modules/uuid/dist/esm/stringify.js
+// ../../node_modules/uuid/dist-node/stringify.js
 var byteToHex = [];
 for (let i = 0;i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).slice(1));
@@ -25749,8 +26915,8 @@ function unsafeStringify(arr, offset = 0) {
   return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
 }
 
-// ../../node_modules/uuid/dist/esm/rng.js
-import { randomFillSync } from "crypto";
+// ../../node_modules/uuid/dist-node/rng.js
+import { randomFillSync } from "node:crypto";
 var rnds8Pool = new Uint8Array(256);
 var poolPtr = rnds8Pool.length;
 function rng() {
@@ -25761,15 +26927,12 @@ function rng() {
   return rnds8Pool.slice(poolPtr, poolPtr += 16);
 }
 
-// ../../node_modules/uuid/dist/esm/native.js
-import { randomUUID } from "crypto";
+// ../../node_modules/uuid/dist-node/native.js
+import { randomUUID } from "node:crypto";
 var native_default = { randomUUID };
 
-// ../../node_modules/uuid/dist/esm/v4.js
-function v4(options, buf, offset) {
-  if (native_default.randomUUID && !buf && !options) {
-    return native_default.randomUUID();
-  }
+// ../../node_modules/uuid/dist-node/v4.js
+function _v4(options, buf, offset) {
   options = options || {};
   const rnds = options.random ?? options.rng?.() ?? rng();
   if (rnds.length < 16) {
@@ -25789,6 +26952,12 @@ function v4(options, buf, offset) {
   }
   return unsafeStringify(rnds);
 }
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
 var v4_default = v4;
 // src/api/messaging/errors/SessionErrors.ts
 class SessionError extends Error {
@@ -26747,7 +27916,7 @@ async function saveUploadedFile2(file, channelId) {
 }
 function createChannelMediaRouter() {
   const router = express16.Router();
-  const uploadMediaRateLimiter = lib_default({
+  const uploadMediaRateLimiter = rate_limit_default({
     windowMs: 15 * 60 * 1000,
     max: 100,
     message: { success: false, error: "Too many requests, please try again later." }
@@ -27627,7 +28796,7 @@ import express30 from "express";
 // package.json
 var package_default = {
   name: "@elizaos/server",
-  version: "1.6.1-alpha.5",
+  version: "1.6.1-alpha.6",
   description: "ElizaOS Server - Core server infrastructure for ElizaOS agents",
   publishConfig: {
     access: "public",
@@ -27673,23 +28842,23 @@ var package_default = {
   devDependencies: {
     "@elizaos/client": "workspace:*",
     "@types/node": "^24.0.1",
-    prettier: "3.5.3",
-    tsx: "4.19.4",
+    prettier: "3.6.2",
+    tsx: "4.20.6",
     typescript: "^5.5.4",
-    which: "^4.0.0",
+    which: "^5.0.0",
     ws: "^8.18.0"
   },
   gitHead: "255e37c0e4a76da0b776219db5ebb9dadf20e89f",
   dependencies: {
     "@elizaos/core": "workspace:*",
     "@elizaos/plugin-sql": "workspace:*",
-    "@sentry/node": "^10.11.0",
+    "@sentry/node": "^10.16.0",
     "@types/express": "^5.0.2",
     "@types/helmet": "^4.0.0",
-    "@types/multer": "^1.4.13",
-    dotenv: "^16.5.0",
+    "@types/multer": "^2.0.0",
+    dotenv: "^17.2.3",
     express: "^5.1.0",
-    "express-rate-limit": "^7.5.0",
+    "express-rate-limit": "^8.1.0",
     helmet: "^8.1.0",
     multer: "^2.0.1",
     "path-to-regexp": "^8.2.0",
@@ -29184,7 +30353,7 @@ var DEBUG_BUILD = typeof __SENTRY_DEBUG__ === "undefined" || __SENTRY_DEBUG__;
 var GLOBAL_OBJ = globalThis;
 
 // ../../node_modules/@sentry/core/build/esm/utils/version.js
-var SDK_VERSION = "10.15.0";
+var SDK_VERSION = "10.16.0";
 
 // ../../node_modules/@sentry/core/build/esm/carrier.js
 function getMainCarrier() {
@@ -33647,48 +34816,38 @@ function estimatePrimitiveSizeInBytes(value) {
 }
 // ../../node_modules/@sentry/core/build/esm/utils/promisebuffer.js
 var SENTRY_BUFFER_FULL_ERROR = Symbol.for("SentryBufferFullError");
-function makePromiseBuffer(limit) {
-  const buffer = [];
+function makePromiseBuffer(limit = 100) {
+  const buffer = new Set;
   function isReady() {
-    return limit === undefined || buffer.length < limit;
+    return buffer.size < limit;
   }
   function remove(task) {
-    return buffer.splice(buffer.indexOf(task), 1)[0] || Promise.resolve(undefined);
+    buffer.delete(task);
   }
   function add(taskProducer) {
     if (!isReady()) {
       return rejectedSyncPromise(SENTRY_BUFFER_FULL_ERROR);
     }
     const task = taskProducer();
-    if (buffer.indexOf(task) === -1) {
-      buffer.push(task);
-    }
-    task.then(() => remove(task)).then(null, () => remove(task).then(null, () => {}));
+    buffer.add(task);
+    task.then(() => remove(task), () => remove(task));
     return task;
   }
   function drain(timeout) {
-    return new SyncPromise((resolve, reject) => {
-      let counter = buffer.length;
-      if (!counter) {
-        return resolve(true);
-      }
-      const capturedSetTimeout = setTimeout(() => {
-        if (timeout && timeout > 0) {
-          resolve(false);
-        }
-      }, timeout);
-      buffer.forEach((item) => {
-        resolvedSyncPromise(item).then(() => {
-          if (!--counter) {
-            clearTimeout(capturedSetTimeout);
-            resolve(true);
-          }
-        }, reject);
-      });
-    });
+    if (!buffer.size) {
+      return resolvedSyncPromise(true);
+    }
+    const drainPromise = Promise.allSettled(Array.from(buffer)).then(() => true);
+    if (!timeout) {
+      return drainPromise;
+    }
+    const promises = [drainPromise, new Promise((resolve) => setTimeout(() => resolve(false), timeout))];
+    return Promise.race(promises);
   }
   return {
-    $: buffer,
+    get $() {
+      return Array.from(buffer);
+    },
     add,
     drain
   };
@@ -35382,7 +36541,42 @@ function processEvent(event, state, recordOutputs, span) {
   handleContentBlockDelta(event, state, recordOutputs);
   handleContentBlockStop(event, state);
 }
-async function* instrumentStream2(stream, span, recordOutputs) {
+function finalizeStreamSpan(state, span, recordOutputs) {
+  if (!span.isRecording()) {
+    return;
+  }
+  if (state.responseId) {
+    span.setAttributes({
+      [GEN_AI_RESPONSE_ID_ATTRIBUTE]: state.responseId
+    });
+  }
+  if (state.responseModel) {
+    span.setAttributes({
+      [GEN_AI_RESPONSE_MODEL_ATTRIBUTE]: state.responseModel
+    });
+  }
+  setTokenUsageAttributes2(span, state.promptTokens, state.completionTokens, state.cacheCreationInputTokens, state.cacheReadInputTokens);
+  span.setAttributes({
+    [GEN_AI_RESPONSE_STREAMING_ATTRIBUTE]: true
+  });
+  if (state.finishReasons.length > 0) {
+    span.setAttributes({
+      [GEN_AI_RESPONSE_FINISH_REASONS_ATTRIBUTE]: JSON.stringify(state.finishReasons)
+    });
+  }
+  if (recordOutputs && state.responseTexts.length > 0) {
+    span.setAttributes({
+      [GEN_AI_RESPONSE_TEXT_ATTRIBUTE]: state.responseTexts.join("")
+    });
+  }
+  if (recordOutputs && state.toolCalls.length > 0) {
+    span.setAttributes({
+      [GEN_AI_RESPONSE_TOOL_CALLS_ATTRIBUTE]: JSON.stringify(state.toolCalls)
+    });
+  }
+  span.end();
+}
+async function* instrumentAsyncIterableStream(stream, span, recordOutputs) {
   const state = {
     responseTexts: [],
     finishReasons: [],
@@ -35433,6 +36627,39 @@ async function* instrumentStream2(stream, span, recordOutputs) {
     span.end();
   }
 }
+function instrumentMessageStream(stream, span, recordOutputs) {
+  const state = {
+    responseTexts: [],
+    finishReasons: [],
+    responseId: "",
+    responseModel: "",
+    promptTokens: undefined,
+    completionTokens: undefined,
+    cacheCreationInputTokens: undefined,
+    cacheReadInputTokens: undefined,
+    toolCalls: [],
+    activeToolBlocks: {}
+  };
+  stream.on("streamEvent", (event) => {
+    processEvent(event, state, recordOutputs, span);
+  });
+  stream.on("message", () => {
+    finalizeStreamSpan(state, span, recordOutputs);
+  });
+  stream.on("error", (error2) => {
+    captureException(error2, {
+      mechanism: {
+        handled: false,
+        type: "auto.ai.anthropic.stream_error"
+      }
+    });
+    if (span.isRecording()) {
+      span.setStatus({ code: SPAN_STATUS_ERROR, message: "stream_error" });
+      span.end();
+    }
+  });
+  return stream;
+}
 
 // ../../node_modules/@sentry/core/build/esm/utils/anthropic-ai/constants.js
 var ANTHROPIC_AI_INTEGRATION_NAME = "Anthropic_AI";
@@ -35564,28 +36791,70 @@ function addResponseAttributes2(span, response, recordOutputs) {
   }
   addMetadataAttributes(span, response);
 }
+function handleStreamingError(error2, span, methodPath) {
+  captureException(error2, {
+    mechanism: { handled: false, type: "auto.ai.anthropic", data: { function: methodPath } }
+  });
+  if (span.isRecording()) {
+    span.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
+    span.end();
+  }
+  throw error2;
+}
+function handleStreamingRequest(originalMethod, target, context, args, requestAttributes, operationName, methodPath, params, options, isStreamRequested) {
+  const model = requestAttributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE] ?? "unknown";
+  const spanConfig = {
+    name: `${operationName} ${model} stream-response`,
+    op: getSpanOperation2(methodPath),
+    attributes: requestAttributes
+  };
+  if (isStreamRequested) {
+    return startSpanManual(spanConfig, async (span) => {
+      try {
+        if (options.recordInputs && params) {
+          addPrivateRequestAttributes(span, params);
+        }
+        const result = await originalMethod.apply(context, args);
+        return instrumentAsyncIterableStream(result, span, options.recordOutputs ?? false);
+      } catch (error2) {
+        return handleStreamingError(error2, span, methodPath);
+      }
+    });
+  } else {
+    return startSpanManual(spanConfig, (span) => {
+      try {
+        if (options.recordInputs && params) {
+          addPrivateRequestAttributes(span, params);
+        }
+        const messageStream = target.apply(context, args);
+        return instrumentMessageStream(messageStream, span, options.recordOutputs ?? false);
+      } catch (error2) {
+        return handleStreamingError(error2, span, methodPath);
+      }
+    });
+  }
+}
 function instrumentMethod2(originalMethod, methodPath, context, options) {
-  return async function instrumentedMethod(...args) {
-    const requestAttributes = extractRequestAttributes2(args, methodPath);
-    const model = requestAttributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE] ?? "unknown";
-    const operationName = getFinalOperationName(methodPath);
-    const params = typeof args[0] === "object" ? args[0] : undefined;
-    const isStreamRequested = Boolean(params?.stream);
-    const isStreamingMethod = methodPath === "messages.stream";
-    if (isStreamRequested || isStreamingMethod) {
-      return startSpanManual({
-        name: `${operationName} ${model} stream-response`,
+  return new Proxy(originalMethod, {
+    apply(target, thisArg, args) {
+      const requestAttributes = extractRequestAttributes2(args, methodPath);
+      const model = requestAttributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE] ?? "unknown";
+      const operationName = getFinalOperationName(methodPath);
+      const params = typeof args[0] === "object" ? args[0] : undefined;
+      const isStreamRequested = Boolean(params?.stream);
+      const isStreamingMethod = methodPath === "messages.stream";
+      if (isStreamRequested || isStreamingMethod) {
+        return handleStreamingRequest(originalMethod, target, context, args, requestAttributes, operationName, methodPath, params, options, isStreamRequested);
+      }
+      return startSpan({
+        name: `${operationName} ${model}`,
         op: getSpanOperation2(methodPath),
         attributes: requestAttributes
-      }, async (span) => {
-        try {
-          if (options.recordInputs && params) {
-            addPrivateRequestAttributes(span, params);
-          }
-          const result = await originalMethod.apply(context, args);
-          return instrumentStream2(result, span, options.recordOutputs ?? false);
-        } catch (error2) {
-          span.setStatus({ code: SPAN_STATUS_ERROR, message: "internal_error" });
+      }, (span) => {
+        if (options.recordInputs && params) {
+          addPrivateRequestAttributes(span, params);
+        }
+        return handleCallbackErrors(() => target.apply(context, args), (error2) => {
           captureException(error2, {
             mechanism: {
               handled: false,
@@ -35595,32 +36864,10 @@ function instrumentMethod2(originalMethod, methodPath, context, options) {
               }
             }
           });
-          span.end();
-          throw error2;
-        }
+        }, () => {}, (result) => addResponseAttributes2(span, result, options.recordOutputs));
       });
     }
-    return startSpan({
-      name: `${operationName} ${model}`,
-      op: getSpanOperation2(methodPath),
-      attributes: requestAttributes
-    }, (span) => {
-      if (options.recordInputs && params) {
-        addPrivateRequestAttributes(span, params);
-      }
-      return handleCallbackErrors(() => originalMethod.apply(context, args), (error2) => {
-        captureException(error2, {
-          mechanism: {
-            handled: false,
-            type: "auto.ai.anthropic",
-            data: {
-              function: methodPath
-            }
-          }
-        });
-      }, () => {}, (result) => addResponseAttributes2(span, result, options.recordOutputs));
-    });
-  };
+  });
 }
 function createDeepProxy2(target, currentPath = "", options) {
   return new Proxy(target, {
@@ -38715,7 +39962,7 @@ function functionNamesMatch(a, b) {
 }
 
 // ../../node_modules/@sentry/node-core/build/esm/integrations/local-variables/local-variables-async.js
-var base64WorkerScript = "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";
+var base64WorkerScript = "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";
 function log2(...args) {
   debug.log("[LocalVariables]", ...args);
 }