@vapi-network/core 0.2.3 → 0.5.0

package/dist/agent-link.js

@@ -0,0 +1,1715 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
+var init_u64 = __esm({
+  "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_u64.js"() {
+    U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+    _32n = /* @__PURE__ */ BigInt(32);
+    rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+    rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+    rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+    rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+var isLE, swap32IfBE, Hash;
+var init_utils = __esm({
+  "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js"() {
+    isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+    swap32IfBE = isLE ? (u) => u : byteSwap32;
+    Hash = class {
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  clean(B);
+}
+var _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_PI, SHA3_ROTL, _SHA3_IOTA, IOTAS, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, keccak_256;
+var init_sha3 = __esm({
+  "../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js"() {
+    init_u64();
+    init_utils();
+    _0n = BigInt(0);
+    _1n = BigInt(1);
+    _2n = BigInt(2);
+    _7n = BigInt(7);
+    _256n = BigInt(256);
+    _0x71n = BigInt(113);
+    SHA3_PI = [];
+    SHA3_ROTL = [];
+    _SHA3_IOTA = [];
+    for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+      [x, y] = [y, (2 * x + 3 * y) % 5];
+      SHA3_PI.push(2 * (5 * y + x));
+      SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+      let t = _0n;
+      for (let j = 0; j < 7; j++) {
+        R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+        if (R & _2n)
+          t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+      }
+      _SHA3_IOTA.push(t);
+    }
+    IOTAS = split(_SHA3_IOTA, true);
+    SHA3_IOTA_H = IOTAS[0];
+    SHA3_IOTA_L = IOTAS[1];
+    rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+    rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+    Keccak = class _Keccak extends Hash {
+      // NOTE: we accept arguments in bytes instead of bits here.
+      constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        super();
+        this.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
+        this.enableXOF = false;
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        anumber(outputLen);
+        if (!(0 < blockLen && blockLen < 200))
+          throw new Error("only keccak-f1600 function is supported");
+        this.state = new Uint8Array(200);
+        this.state32 = u32(this.state);
+      }
+      clone() {
+        return this._cloneInto();
+      }
+      keccak() {
+        swap32IfBE(this.state32);
+        keccakP(this.state32, this.rounds);
+        swap32IfBE(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+      }
+      update(data) {
+        aexists(this);
+        data = toBytes(data);
+        abytes(data);
+        const { blockLen, state } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len; ) {
+          const take = Math.min(blockLen - this.pos, len - pos);
+          for (let i = 0; i < take; i++)
+            state[this.pos++] ^= data[pos++];
+          if (this.pos === blockLen)
+            this.keccak();
+        }
+        return this;
+      }
+      finish() {
+        if (this.finished)
+          return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        state[pos] ^= suffix;
+        if ((suffix & 128) !== 0 && pos === blockLen - 1)
+          this.keccak();
+        state[blockLen - 1] ^= 128;
+        this.keccak();
+      }
+      writeInto(out) {
+        aexists(this, false);
+        abytes(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len; ) {
+          if (this.posOut >= blockLen)
+            this.keccak();
+          const take = Math.min(blockLen - this.posOut, len - pos);
+          out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+          this.posOut += take;
+          pos += take;
+        }
+        return out;
+      }
+      xofInto(out) {
+        if (!this.enableXOF)
+          throw new Error("XOF is not possible for this instance");
+        return this.writeInto(out);
+      }
+      xof(bytes) {
+        anumber(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+      }
+      digestInto(out) {
+        aoutput(out, this);
+        if (this.finished)
+          throw new Error("digest() was already called");
+        this.writeInto(out);
+        this.destroy();
+        return out;
+      }
+      digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+      }
+      destroy() {
+        this.destroyed = true;
+        clean(this.state);
+      }
+      _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.destroyed = this.destroyed;
+        return to;
+      }
+    };
+    gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
+    keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/data/isHex.js
+function isHex(value, { strict = true } = {}) {
+  if (!value)
+    return false;
+  if (typeof value !== "string")
+    return false;
+  return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
+}
+var init_isHex = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/data/isHex.js"() {
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/version.js
+var version;
+var init_version = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/version.js"() {
+    version = "2.56.1";
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/base.js
+function walk(err, fn) {
+  if (fn?.(err))
+    return err;
+  if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
+    return walk(err.cause, fn);
+  return fn ? null : err;
+}
+var errorConfig, BaseError;
+var init_base = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/base.js"() {
+    init_version();
+    errorConfig = {
+      getDocsUrl: ({ docsBaseUrl, docsPath = "", docsSlug }) => docsPath ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
+      version: `viem@${version}`
+    };
+    BaseError = class _BaseError extends Error {
+      constructor(shortMessage, args = {}) {
+        const details = (() => {
+          if (args.cause instanceof _BaseError)
+            return args.cause.details;
+          if (args.cause?.message)
+            return args.cause.message;
+          return args.details;
+        })();
+        const docsPath = (() => {
+          if (args.cause instanceof _BaseError)
+            return args.cause.docsPath || args.docsPath;
+          return args.docsPath;
+        })();
+        const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath });
+        const message = [
+          shortMessage || "An error occurred.",
+          "",
+          ...args.metaMessages ? [...args.metaMessages, ""] : [],
+          ...docsUrl ? [`Docs: ${docsUrl}`] : [],
+          ...details ? [`Details: ${details}`] : [],
+          ...errorConfig.version ? [`Version: ${errorConfig.version}`] : []
+        ].join("\n");
+        super(message, args.cause ? { cause: args.cause } : void 0);
+        Object.defineProperty(this, "details", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "docsPath", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "metaMessages", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "shortMessage", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "version", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        Object.defineProperty(this, "name", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: "BaseError"
+        });
+        this.details = details;
+        this.docsPath = docsPath;
+        this.metaMessages = args.metaMessages;
+        this.name = args.name ?? this.name;
+        this.shortMessage = shortMessage;
+        this.version = version;
+      }
+      walk(fn) {
+        return walk(this, fn);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/data.js
+var SizeExceedsPaddingSizeError;
+var init_data = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/data.js"() {
+    init_base();
+    SizeExceedsPaddingSizeError = class extends BaseError {
+      constructor({ size: size2, targetSize, type }) {
+        super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/data/pad.js
+function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
+  if (typeof hexOrBytes === "string")
+    return padHex(hexOrBytes, { dir, size: size2 });
+  return padBytes(hexOrBytes, { dir, size: size2 });
+}
+function padHex(hex_, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return hex_;
+  const hex = hex_.replace("0x", "");
+  if (hex.length > size2 * 2)
+    throw new SizeExceedsPaddingSizeError({
+      size: Math.ceil(hex.length / 2),
+      targetSize: size2,
+      type: "hex"
+    });
+  return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size2 * 2, "0")}`;
+}
+function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
+  if (size2 === null)
+    return bytes;
+  if (bytes.length > size2)
+    throw new SizeExceedsPaddingSizeError({
+      size: bytes.length,
+      targetSize: size2,
+      type: "bytes"
+    });
+  const paddedBytes = new Uint8Array(size2);
+  for (let i = 0; i < size2; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size2 - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+  }
+  return paddedBytes;
+}
+var init_pad = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/data/pad.js"() {
+    init_data();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/encoding.js
+var IntegerOutOfRangeError, SizeOverflowError;
+var init_encoding = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/encoding.js"() {
+    init_base();
+    IntegerOutOfRangeError = class extends BaseError {
+      constructor({ max, min, signed, size: size2, value }) {
+        super(`Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
+      }
+    };
+    SizeOverflowError = class extends BaseError {
+      constructor({ givenSize, maxSize }) {
+        super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/data/size.js
+function size(value) {
+  if (isHex(value, { strict: false }))
+    return Math.ceil((value.length - 2) / 2);
+  return value.length;
+}
+var init_size = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/data/size.js"() {
+    init_isHex();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/encoding/fromHex.js
+function assertSize(hexOrBytes, { size: size2 }) {
+  if (size(hexOrBytes) > size2)
+    throw new SizeOverflowError({
+      givenSize: size(hexOrBytes),
+      maxSize: size2
+    });
+}
+var init_fromHex = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/encoding/fromHex.js"() {
+    init_encoding();
+    init_size();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/encoding/toHex.js
+function toHex(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToHex(value, opts);
+  if (typeof value === "string") {
+    return stringToHex(value, opts);
+  }
+  if (typeof value === "boolean")
+    return boolToHex(value, opts);
+  return bytesToHex(value, opts);
+}
+function boolToHex(value, opts = {}) {
+  const hex = `0x${Number(value)}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { size: opts.size });
+  }
+  return hex;
+}
+function bytesToHex(value, opts = {}) {
+  let string = "";
+  for (let i = 0; i < value.length; i++) {
+    string += hexes[value[i]];
+  }
+  const hex = `0x${string}`;
+  if (typeof opts.size === "number") {
+    assertSize(hex, { size: opts.size });
+    return pad(hex, { dir: "right", size: opts.size });
+  }
+  return hex;
+}
+function numberToHex(value_, opts = {}) {
+  const { signed, size: size2 } = opts;
+  const value = BigInt(value_);
+  let maxValue;
+  if (size2) {
+    if (signed)
+      maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
+    else
+      maxValue = 2n ** (BigInt(size2) * 8n) - 1n;
+  } else if (typeof value_ === "number") {
+    maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+  }
+  const minValue = typeof maxValue === "bigint" && signed ? -maxValue - 1n : 0;
+  if (maxValue && value > maxValue || value < minValue) {
+    const suffix = typeof value_ === "bigint" ? "n" : "";
+    throw new IntegerOutOfRangeError({
+      max: maxValue ? `${maxValue}${suffix}` : void 0,
+      min: `${minValue}${suffix}`,
+      signed,
+      size: size2,
+      value: `${value_}${suffix}`
+    });
+  }
+  const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
+  if (size2)
+    return pad(hex, { size: size2 });
+  return hex;
+}
+function stringToHex(value_, opts = {}) {
+  const value = encoder.encode(value_);
+  return bytesToHex(value, opts);
+}
+var hexes, encoder;
+var init_toHex = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/encoding/toHex.js"() {
+    init_encoding();
+    init_pad();
+    init_fromHex();
+    hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+    encoder = /* @__PURE__ */ new TextEncoder();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/encoding/toBytes.js
+function toBytes2(value, opts = {}) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return numberToBytes(value, opts);
+  if (typeof value === "boolean")
+    return boolToBytes(value, opts);
+  if (isHex(value))
+    return hexToBytes(value, opts);
+  return stringToBytes(value, opts);
+}
+function boolToBytes(value, opts = {}) {
+  const bytes = new Uint8Array(1);
+  bytes[0] = Number(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { size: opts.size });
+  }
+  return bytes;
+}
+function charCodeToBase16(char) {
+  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+    return char - charCodeMap.zero;
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
+    return char - (charCodeMap.A - 10);
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
+    return char - (charCodeMap.a - 10);
+  return void 0;
+}
+function hexToBytes(hex_, opts = {}) {
+  let hex = hex_;
+  if (opts.size) {
+    assertSize(hex, { size: opts.size });
+    hex = pad(hex, { dir: "right", size: opts.size });
+  }
+  let hexString = hex.slice(2);
+  if (hexString.length % 2)
+    hexString = `0${hexString}`;
+  const length = hexString.length / 2;
+  const bytes = new Uint8Array(length);
+  for (let index = 0, j = 0; index < length; index++) {
+    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    if (nibbleLeft === void 0 || nibbleRight === void 0) {
+      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+    }
+    bytes[index] = nibbleLeft * 16 + nibbleRight;
+  }
+  return bytes;
+}
+function numberToBytes(value, opts) {
+  const hex = numberToHex(value, opts);
+  return hexToBytes(hex);
+}
+function stringToBytes(value, opts = {}) {
+  const bytes = encoder2.encode(value);
+  if (typeof opts.size === "number") {
+    assertSize(bytes, { size: opts.size });
+    return pad(bytes, { dir: "right", size: opts.size });
+  }
+  return bytes;
+}
+var encoder2, charCodeMap;
+var init_toBytes = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/encoding/toBytes.js"() {
+    init_base();
+    init_isHex();
+    init_pad();
+    init_fromHex();
+    init_toHex();
+    encoder2 = /* @__PURE__ */ new TextEncoder();
+    charCodeMap = {
+      zero: 48,
+      nine: 57,
+      A: 65,
+      F: 70,
+      a: 97,
+      f: 102
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/hash/keccak256.js
+function keccak256(value, to_) {
+  const to = to_ || "hex";
+  const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes2(value) : value);
+  if (to === "bytes")
+    return bytes;
+  return toHex(bytes);
+}
+var init_keccak256 = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/hash/keccak256.js"() {
+    init_sha3();
+    init_isHex();
+    init_toBytes();
+    init_toHex();
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/lru.js
+var LruMap;
+var init_lru = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/lru.js"() {
+    LruMap = class extends Map {
+      constructor(size2) {
+        super();
+        Object.defineProperty(this, "maxSize", {
+          enumerable: true,
+          configurable: true,
+          writable: true,
+          value: void 0
+        });
+        this.maxSize = size2;
+      }
+      get(key) {
+        const value = super.get(key);
+        if (super.has(key)) {
+          super.delete(key);
+          super.set(key, value);
+        }
+        return value;
+      }
+      set(key, value) {
+        if (super.has(key))
+          super.delete(key);
+        super.set(key, value);
+        if (this.maxSize && this.size > this.maxSize) {
+          const firstKey = super.keys().next().value;
+          if (firstKey !== void 0)
+            super.delete(firstKey);
+        }
+        return this;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/address.js
+var InvalidAddressError;
+var init_address = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/address.js"() {
+    init_base();
+    InvalidAddressError = class extends BaseError {
+      constructor({ address }) {
+        super(`Address "${address}" is invalid.`, {
+          metaMessages: [
+            "- Address must be a hex value of 20 bytes (40 hex characters).",
+            "- Address must match its checksum counterpart."
+          ],
+          name: "InvalidAddressError"
+        });
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/address/getAddress.js
+function checksumAddress(address_, chainId) {
+  if (checksumAddressCache.has(`${address_}.${chainId}`))
+    return checksumAddressCache.get(`${address_}.${chainId}`);
+  const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
+  const hash = keccak256(stringToBytes(hexAddress), "bytes");
+  const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
+  for (let i = 0; i < 40; i += 2) {
+    if (hash[i >> 1] >> 4 >= 8 && address[i]) {
+      address[i] = address[i].toUpperCase();
+    }
+    if ((hash[i >> 1] & 15) >= 8 && address[i + 1]) {
+      address[i + 1] = address[i + 1].toUpperCase();
+    }
+  }
+  const result = `0x${address.join("")}`;
+  checksumAddressCache.set(`${address_}.${chainId}`, result);
+  return result;
+}
+function getAddress(address, chainId) {
+  if (!isAddress(address, { strict: false }))
+    throw new InvalidAddressError({ address });
+  return checksumAddress(address, chainId);
+}
+var checksumAddressCache;
+var init_getAddress = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/address/getAddress.js"() {
+    init_address();
+    init_toBytes();
+    init_keccak256();
+    init_lru();
+    init_isAddress();
+    checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
+  }
+});
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/address/isAddress.js
+function isAddress(address, options) {
+  const { strict = true } = options ?? {};
+  const cacheKey = `${address}.${strict}`;
+  if (isAddressCache.has(cacheKey))
+    return isAddressCache.get(cacheKey);
+  const result = (() => {
+    if (!addressRegex.test(address))
+      return false;
+    if (address.toLowerCase() === address)
+      return true;
+    if (strict)
+      return checksumAddress(address) === address;
+    return true;
+  })();
+  isAddressCache.set(cacheKey, result);
+  return result;
+}
+var addressRegex, isAddressCache;
+var init_isAddress = __esm({
+  "../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/address/isAddress.js"() {
+    init_lru();
+    init_getAddress();
+    addressRegex = /^0x[a-fA-F0-9]{40}$/;
+    isAddressCache = /* @__PURE__ */ new LruMap(8192);
+  }
+});
+
+// src/agent-link.ts
+import { createHash } from "node:crypto";
+import { mkdir as mkdir2, open, stat, unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/errors/siwe.js
+init_base();
+var SiweInvalidMessageFieldError = class extends BaseError {
+  constructor(parameters) {
+    const { docsPath, field, metaMessages } = parameters;
+    super(`Invalid Sign-In with Ethereum message field "${field}".`, {
+      docsPath,
+      metaMessages,
+      name: "SiweInvalidMessageFieldError"
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/siwe/createSiweMessage.js
+init_getAddress();
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/siwe/utils.js
+function isUri(value) {
+  if (/[^a-z0-9:/?#[\]@!$&'()*+,;=.\-_~%]/i.test(value))
+    return false;
+  if (/%[^0-9a-f]/i.test(value))
+    return false;
+  if (/%[0-9a-f](:?[^0-9a-f]|$)/i.test(value))
+    return false;
+  const splitted = splitUri(value);
+  const scheme = splitted[1];
+  const authority = splitted[2];
+  const path = splitted[3];
+  const query = splitted[4];
+  const fragment = splitted[5];
+  if (!(scheme?.length && path.length >= 0))
+    return false;
+  if (authority?.length) {
+    if (!(path.length === 0 || /^\//.test(path)))
+      return false;
+  } else {
+    if (/^\/\//.test(path))
+      return false;
+  }
+  if (!/^[a-z][a-z0-9+\-.]*$/.test(scheme.toLowerCase()))
+    return false;
+  let out = "";
+  out += `${scheme}:`;
+  if (authority?.length)
+    out += `//${authority}`;
+  out += path;
+  if (query?.length)
+    out += `?${query}`;
+  if (fragment?.length)
+    out += `#${fragment}`;
+  return out;
+}
+function splitUri(value) {
+  return value.match(/(?:([^:/?#]+):)?(?:\/\/([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?/);
+}
+
+// ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/utils/siwe/createSiweMessage.js
+function createSiweMessage(parameters) {
+  const { chainId, domain, expirationTime, issuedAt = /* @__PURE__ */ new Date(), nonce, notBefore, requestId, resources, scheme, uri, version: version2 } = parameters;
+  {
+    if (chainId !== Math.floor(chainId))
+      throw new SiweInvalidMessageFieldError({
+        field: "chainId",
+        metaMessages: [
+          "- Chain ID must be a EIP-155 chain ID.",
+          "- See https://eips.ethereum.org/EIPS/eip-155",
+          "",
+          `Provided value: ${chainId}`
+        ]
+      });
+    if (!(domainRegex.test(domain) || ipRegex.test(domain) || localhostRegex.test(domain)))
+      throw new SiweInvalidMessageFieldError({
+        field: "domain",
+        metaMessages: [
+          "- Domain must be an RFC 3986 authority.",
+          "- See https://www.rfc-editor.org/rfc/rfc3986",
+          "",
+          `Provided value: ${domain}`
+        ]
+      });
+    if (!nonceRegex.test(nonce))
+      throw new SiweInvalidMessageFieldError({
+        field: "nonce",
+        metaMessages: [
+          "- Nonce must be at least 8 characters.",
+          "- Nonce must be alphanumeric.",
+          "",
+          `Provided value: ${nonce}`
+        ]
+      });
+    if (!isUri(uri))
+      throw new SiweInvalidMessageFieldError({
+        field: "uri",
+        metaMessages: [
+          "- URI must be a RFC 3986 URI referring to the resource that is the subject of the signing.",
+          "- See https://www.rfc-editor.org/rfc/rfc3986",
+          "",
+          `Provided value: ${uri}`
+        ]
+      });
+    if (version2 !== "1")
+      throw new SiweInvalidMessageFieldError({
+        field: "version",
+        metaMessages: [
+          "- Version must be '1'.",
+          "",
+          `Provided value: ${version2}`
+        ]
+      });
+    if (scheme && !schemeRegex.test(scheme))
+      throw new SiweInvalidMessageFieldError({
+        field: "scheme",
+        metaMessages: [
+          "- Scheme must be an RFC 3986 URI scheme.",
+          "- See https://www.rfc-editor.org/rfc/rfc3986#section-3.1",
+          "",
+          `Provided value: ${scheme}`
+        ]
+      });
+    const statement2 = parameters.statement;
+    if (statement2?.includes("\n"))
+      throw new SiweInvalidMessageFieldError({
+        field: "statement",
+        metaMessages: [
+          "- Statement must not include '\\n'.",
+          "",
+          `Provided value: ${statement2}`
+        ]
+      });
+  }
+  const address = getAddress(parameters.address);
+  const origin = (() => {
+    if (scheme)
+      return `${scheme}://${domain}`;
+    return domain;
+  })();
+  const statement = (() => {
+    if (!parameters.statement)
+      return "";
+    return `${parameters.statement}
+`;
+  })();
+  const prefix = `${origin} wants you to sign in with your Ethereum account:
+${address}
+
+${statement}`;
+  let suffix = `URI: ${uri}
+Version: ${version2}
+Chain ID: ${chainId}
+Nonce: ${nonce}
+Issued At: ${issuedAt.toISOString()}`;
+  if (expirationTime)
+    suffix += `
+Expiration Time: ${expirationTime.toISOString()}`;
+  if (notBefore)
+    suffix += `
+Not Before: ${notBefore.toISOString()}`;
+  if (requestId)
+    suffix += `
+Request ID: ${requestId}`;
+  if (resources) {
+    let content = "\nResources:";
+    for (const resource of resources) {
+      if (!isUri(resource))
+        throw new SiweInvalidMessageFieldError({
+          field: "resources",
+          metaMessages: [
+            "- Every resource must be a RFC 3986 URI.",
+            "- See https://www.rfc-editor.org/rfc/rfc3986",
+            "",
+            `Provided value: ${resource}`
+          ]
+        });
+      content += `
+- ${resource}`;
+    }
+    suffix += content;
+  }
+  return `${prefix}
+${suffix}`;
+}
+var domainRegex = /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}(:[0-9]{1,5})?$/;
+var ipRegex = /^(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]?)(:[0-9]{1,5})?$/;
+var localhostRegex = /^localhost(:[0-9]{1,5})?$/;
+var nonceRegex = /^[a-zA-Z0-9]{8,}$/;
+var schemeRegex = /^([a-zA-Z][a-zA-Z0-9+-.]*)$/;
+
+// src/audit.ts
+import { appendFile, chmod, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/net-guard.ts
+import { lookup as dnsLookup } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+import { Readable } from "node:stream";
+var defaultLookup = async (hostname) => {
+  const addresses = await dnsLookup(hostname, { all: true });
+  return addresses.map(({ address }) => address);
+};
+async function assertPublicUrl(url, options) {
+  if (url.username || url.password) {
+    throw guardError(url);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw guardError(url);
+  }
+  if (options.allowPrivateNetwork) {
+    return;
+  }
+  const hostname = normalizeHostname(url.hostname);
+  const lowercaseHostname = hostname.toLowerCase();
+  if (!lowercaseHostname || lowercaseHostname === "localhost" || lowercaseHostname.endsWith(".localhost") || lowercaseHostname.endsWith(".local") || lowercaseHostname.endsWith(".internal")) {
+    throw guardError(url);
+  }
+  if (isIP(hostname)) {
+    if (isNonPublicAddress(hostname)) {
+      throw guardError(url);
+    }
+    return;
+  }
+  let addresses;
+  try {
+    addresses = await withTimeout(
+      (options.lookup ?? defaultLookup)(hostname),
+      options.timeoutMs ?? 5e3
+    );
+  } catch {
+    throw guardError(url);
+  }
+  if (addresses.length === 0 || addresses.some(isNonPublicAddress)) {
+    throw guardError(url);
+  }
+}
+function createPublicFetch(options) {
+  const lookupFn = options.lookup ?? defaultLookup;
+  return (async (input, init) => {
+    const url = new URL(input instanceof Request ? input.url : input);
+    await assertPublicUrl(url, {
+      allowPrivateNetwork: options.allowPrivateNetwork,
+      lookup: lookupFn,
+      timeoutMs: 5e3
+    });
+    const normalized = new Request(input, init);
+    const bytes = normalized.body ? Buffer.from(await normalized.arrayBuffer()) : null;
+    return await new Promise((resolve, reject) => {
+      const requestOptions = {
+        method: normalized.method,
+        headers: Object.fromEntries(normalized.headers),
+        signal: normalized.signal,
+        ...options.allowPrivateNetwork ? {} : { lookup: pinnedLookup(lookupFn) }
+      };
+      const onResponse = (incoming) => {
+        try {
+          const headers = new Headers();
+          for (const [name, value] of Object.entries(incoming.headers)) {
+            if (Array.isArray(value)) {
+              for (const item of value) headers.append(name, item);
+            } else if (value !== void 0) {
+              headers.set(name, value);
+            }
+          }
+          const status = incoming.statusCode ?? 500;
+          const bodyForbidden = normalized.method === "HEAD" || [204, 205, 304].includes(status);
+          if (bodyForbidden) incoming.resume();
+          const response = new Response(
+            bodyForbidden ? null : Readable.toWeb(incoming),
+            { status, statusText: incoming.statusMessage, headers }
+          );
+          Object.defineProperty(response, "url", { value: url.toString() });
+          resolve(response);
+        } catch (error) {
+          incoming.destroy();
+          reject(error);
+        }
+      };
+      const request = url.protocol === "https:" ? httpsRequest(url, requestOptions, onResponse) : httpRequest(url, requestOptions, onResponse);
+      request.on("error", reject);
+      if (bytes) request.write(bytes);
+      request.end();
+    });
+  });
+}
+function pinnedLookup(lookup) {
+  return (hostname, dnsOptions, callback) => {
+    void lookup(normalizeHostname(hostname)).then((addresses) => {
+      if (addresses.length === 0 || addresses.some(isNonPublicAddress)) {
+        callback(guardError(new URL(`https://${hostname}`)), "");
+        return;
+      }
+      const address = addresses[0];
+      const family = isIP(address);
+      callback(
+        null,
+        dnsOptions.all ? [{ address, family }] : address,
+        dnsOptions.all ? void 0 : family
+      );
+    }).catch(
+      (error) => callback(error instanceof Error ? error : new Error("DNS lookup failed."), "")
+    );
+  };
+}
+async function withTimeout(operation, timeoutMs) {
+  let timeout;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => reject(new Error("DNS lookup timed out.")), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+function normalizeHostname(hostname) {
+  const unbracketed = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  return unbracketed.endsWith(".") ? unbracketed.slice(0, -1) : unbracketed;
+}
+function isNonPublicAddress(address) {
+  const normalized = normalizeHostname(address);
+  const version2 = isIP(normalized);
+  if (version2 === 4) {
+    return isNonPublicIpv4(parseIpv4(normalized));
+  }
+  if (version2 === 6) {
+    return isNonPublicIpv6(parseIpv6(normalized));
+  }
+  return true;
+}
+function parseIpv4(address) {
+  const octets = address.split(".").map(Number);
+  return [octets[0], octets[1], octets[2], octets[3]];
+}
+function isNonPublicIpv4([first, second, third]) {
+  return first === 0 || first === 10 || first === 100 && second >= 64 && second <= 127 || first === 127 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 0 && (third === 0 || third === 2) || first === 192 && second === 168 || first === 198 && second >= 18 && second <= 19 || first === 198 && second === 51 && third === 100 || first === 203 && second === 0 && third === 113 || first >= 224;
+}
+function parseIpv6(address) {
+  let normalized = address.toLowerCase();
+  const lastColon = normalized.lastIndexOf(":");
+  const dottedTail = normalized.slice(lastColon + 1);
+  if (dottedTail.includes(".")) {
+    const [first, second, third, fourth] = parseIpv4(dottedTail);
+    normalized = `${normalized.slice(0, lastColon + 1)}${(first << 8 | second).toString(16)}:${(third << 8 | fourth).toString(16)}`;
+  }
+  const halves = normalized.split("::");
+  const left = halves[0] ? halves[0].split(":").map(parseHex) : [];
+  const right = halves[1] ? halves[1].split(":").map(parseHex) : [];
+  const omittedCount = 8 - left.length - right.length;
+  return halves.length === 2 ? [...left, ...Array.from({ length: omittedCount }, () => 0), ...right] : left;
+}
+function parseHex(value) {
+  return Number.parseInt(value, 16);
+}
+function isNonPublicIpv6(hextets) {
+  if (hextets.slice(0, 5).every((hextet) => hextet === 0) && hextets[5] === 65535) {
+    const embeddedIpv4 = [
+      hextets[6] >> 8,
+      hextets[6] & 255,
+      hextets[7] >> 8,
+      hextets[7] & 255
+    ];
+    return isNonPublicIpv4(embeddedIpv4);
+  }
+  if (hextets.slice(0, 6).every((hextet) => hextet === 0)) {
+    const compatibleIpv4 = [
+      hextets[6] >> 8,
+      hextets[6] & 255,
+      hextets[7] >> 8,
+      hextets[7] & 255
+    ];
+    if (isNonPublicIpv4(compatibleIpv4)) return true;
+  }
+  const isUnspecified = hextets.every((hextet) => hextet === 0);
+  const isLoopback = hextets.slice(0, 7).every((hextet) => hextet === 0) && hextets[7] === 1;
+  const first = hextets[0];
+  const isUniqueLocal = first >= 64512 && first <= 65023;
+  const isLinkLocal = first >= 65152 && first <= 65215;
+  const isSiteLocal = first >= 65216 && first <= 65279;
+  const isMulticast = first >= 65280;
+  const isDocumentation = first === 8193 && hextets[1] === 3512;
+  return isUnspecified || isLoopback || isUniqueLocal || isLinkLocal || isSiteLocal || isMulticast || isDocumentation;
+}
+function guardError(url) {
+  return new Error(
+    `URL hostname ${JSON.stringify(url.hostname)} is not allowed; private or internal destinations require allowPrivateNetwork true in the vAPI config.`
+  );
+}
+
+// src/audit.ts
+var AUDIT_FILE = "audit.log";
+function auditLogPath(home) {
+  return join(home, AUDIT_FILE);
+}
+async function appendAudit(home, record, options = {}) {
+  const entry = {
+    time: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+    event: record.event,
+    ...record.wallet === void 0 ? {} : { wallet: record.wallet },
+    ...record.owner === void 0 ? {} : { owner: record.owner },
+    tty: record.tty,
+    ...record.agentMarker === void 0 ? {} : { agentMarker: record.agentMarker },
+    ...record.detail === void 0 ? {} : { detail: record.detail }
+  };
+  const path = auditLogPath(home);
+  await mkdir(home, { recursive: true, mode: 448 });
+  await appendFile(path, `${JSON.stringify(entry)}
+`, { encoding: "utf8", mode: 384 });
+  await chmod(path, 384);
+  return entry;
+}
+
+// src/agent-link.ts
+var AGENT_LINK_STATEMENT = "Link this wallet to a vAPI account as an agent.";
+var AGENT_LINK_REVOKED_MESSAGE = "This agent's link was revoked or has expired. Run vapi login to link it again.";
+var AgentLinkError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AgentLinkError";
+  }
+  code;
+};
+var DEFAULT_AGENT_SCOPES = ["mcp:call", "router.use"];
+var ALLOWED_AGENT_SCOPES = /* @__PURE__ */ new Set([...DEFAULT_AGENT_SCOPES, "call.publish"]);
+var publicFetch = createPublicFetch({ allowPrivateNetwork: false });
+async function startDeviceLink(args) {
+  const scopes = args.scopes ?? [...DEFAULT_AGENT_SCOPES];
+  if (scopes.some((scope) => !ALLOWED_AGENT_SCOPES.has(scope))) {
+    throw new AgentLinkError("invalid_scope", "The requested agent scope is not allowed.");
+  }
+  const fetchImpl = args.fetchImpl ?? publicFetch;
+  const api = new URL(args.apiBase);
+  const nonceResponse = await safeFetch(
+    fetchImpl,
+    apiEndpoint(args.apiBase, "/api/auth/siwe-nonce?purpose=link")
+  );
+  if (!nonceResponse.ok) throw httpError("The vAPI sign-in nonce request failed.");
+  const noncePayload = await responseRecord(nonceResponse);
+  const nonce = stringField(noncePayload, "nonce");
+  if (nonce === void 0) throw httpError("The vAPI sign-in nonce response was invalid.");
+  const message = createSiweMessage({
+    domain: api.host,
+    address: args.account.address,
+    statement: AGENT_LINK_STATEMENT,
+    uri: api.origin,
+    version: "1",
+    chainId: 8453,
+    nonce,
+    issuedAt: args.now?.() ?? /* @__PURE__ */ new Date()
+  });
+  const signature = await args.account.signMessage({ message });
+  const response = await safeFetch(
+    fetchImpl,
+    apiEndpoint(args.apiBase, "/oauth/device_authorization"),
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        agent_message: message,
+        agent_signature: signature,
+        label: args.label,
+        scope: scopes.join(" "),
+        ...args.routerAllowanceUsd === void 0 ? {} : { router_allowance_usd: args.routerAllowanceUsd }
+      })
+    }
+  );
+  const payload = await responseRecord(response);
+  if (!response.ok) throw deviceAuthorizationError(response.status, payload);
+  return {
+    clientId: requiredString(payload, "client_id"),
+    deviceCode: requiredString(payload, "device_code"),
+    userCode: requiredString(payload, "user_code"),
+    verificationUri: requiredString(payload, "verification_uri"),
+    verificationUriComplete: requiredString(payload, "verification_uri_complete"),
+    expiresIn: requiredNumber(payload, "expires_in"),
+    interval: requiredNumber(payload, "interval")
+  };
+}
+async function pollDeviceLink(args) {
+  const fetchImpl = args.fetchImpl ?? publicFetch;
+  const sleep = args.sleep ?? sleepFor;
+  const now = args.now ?? Date.now;
+  const deadline = now() + args.start.expiresIn * 1e3;
+  let interval = args.start.interval;
+  while (now() < deadline) {
+    await sleep(interval * 1e3);
+    if (now() >= deadline) break;
+    const body = new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: args.start.deviceCode,
+      client_id: args.start.clientId
+    });
+    const response = await safeFetch(fetchImpl, apiEndpoint(args.apiBase, "/oauth/token"), {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body
+    });
+    const payload = await responseRecord(response);
+    if (response.ok) {
+      const scope = requiredString(payload, "scope");
+      const owner = requiredOwner(payload, "owner_wallet");
+      return {
+        tokens: {
+          accessToken: requiredString(payload, "access_token"),
+          refreshToken: requiredString(payload, "refresh_token"),
+          expiresAt: now() + requiredNumber(payload, "expires_in") * 1e3,
+          scopes: splitScopes(scope)
+        },
+        owner,
+        ...optionalStringProperty(payload, "router_key", "routerKey"),
+        ...optionalStringProperty(payload, "router_base_url", "routerBaseUrl"),
+        ...optionalStringProperty(payload, "router_key_error", "routerKeyError")
+      };
+    }
+    const error = stringField(payload, "error");
+    if (response.status === 400 && error === "authorization_pending") continue;
+    if (response.status === 400 && error === "slow_down") {
+      interval += 5;
+      continue;
+    }
+    if (response.status === 400 && error === "access_denied") {
+      throw new AgentLinkError("access_denied", "The owner denied the agent link.");
+    }
+    if (response.status === 400 && error === "expired_token") throw expiredLinkError();
+    throw httpError("The vAPI agent link request failed.");
+  }
+  throw expiredLinkError();
+}
+var agentSecretAccounts = (wallet) => ({
+  tokens: `vapi.agent.${wallet}.tokens`,
+  routerStake: `vapi.agent.${wallet}.router.stake`,
+  routerBalance: `vapi.agent.${wallet}.router.balance`
+});
+async function renameAgentLinkWallet(args) {
+  await args.wallets.reload();
+  const current = args.wallets.resolve({ name: args.from });
+  if (current.entry.link === void 0) return await args.wallets.rename(args.from, args.to);
+  return await withAgentCredentialLock(
+    args.wallets,
+    current.entry.link.clientId,
+    async () => await args.wallets.rename(args.from, args.to, { secrets: args.secrets })
+  );
+}
+async function saveAgentLink(args) {
+  if (!args.secrets.available) {
+    throw new Error(
+      "No OS secret store is available on this machine, so the agent link cannot be stored safely. Nothing was saved."
+    );
+  }
+  const link = {
+    apiBase: args.apiBase,
+    clientId: args.start.clientId,
+    owner: args.result.owner,
+    label: args.label,
+    scopes: [...args.result.tokens.scopes],
+    linkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...args.result.routerKey === void 0 || args.result.routerBaseUrl === void 0 ? {} : { routerBaseUrl: args.result.routerBaseUrl }
+  };
+  await withAgentCredentialLock(args.wallets, `wallet:${args.wallet}`, async () => {
+    await args.wallets.reload();
+    const previousLink = args.wallets.entry(args.wallet)?.link;
+    const accounts = agentSecretAccounts(args.wallet);
+    const previousSecrets = await readSecretSnapshot(args.secrets, accounts);
+    try {
+      await safeSetSecret(args.secrets, accounts.tokens, JSON.stringify(args.result.tokens));
+      await writeOptionalSecret(args.secrets, accounts.routerStake, args.result.routerKey);
+      await writeOptionalSecret(args.secrets, accounts.routerBalance, void 0);
+      await args.wallets.setLink(args.wallet, link);
+    } catch (error) {
+      const secretsRestored = await restoreSecretSnapshot(args.secrets, accounts, previousSecrets);
+      const metadataRestored = await restoreLinkMetadata(args.wallets, args.wallet, previousLink);
+      if (!secretsRestored || !metadataRestored) {
+        await args.wallets.clearLink(args.wallet).catch(() => void 0);
+        throw httpError(
+          "The agent link could not be stored consistently. Local link metadata was cleared; run vapi login again."
+        );
+      }
+      throw error;
+    }
+  });
+  await appendAudit(args.home ?? args.wallets.home, {
+    event: "agent.linked",
+    wallet: args.wallet,
+    owner: args.result.owner,
+    tty: Boolean(process.stderr.isTTY)
+  });
+  return link;
+}
+async function agentAccessToken(args) {
+  return await resolveAgentAccessToken(args, {});
+}
+async function agentFetch(args, url, init) {
+  const fetchImpl = args.fetchImpl ?? publicFetch;
+  const accessToken = await resolveAgentAccessToken(args, {});
+  const response = await safeAgentFetch(fetchImpl, url, withBearer(init, accessToken));
+  if (response.status !== 401) return response;
+  const refreshedToken = await resolveAgentAccessToken(args, { rejectedAccessToken: accessToken });
+  const refreshedResponse = await safeAgentFetch(fetchImpl, url, withBearer(init, refreshedToken));
+  if (refreshedResponse.status === 401) {
+    throw new AgentLinkError("not_linked", AGENT_LINK_REVOKED_MESSAGE);
+  }
+  return refreshedResponse;
+}
+async function forgetAgentLink(args) {
+  const link = args.wallets.entry(args.wallet)?.link;
+  let revokedError;
+  if (link !== void 0) {
+    try {
+      await agentFetch(args, apiEndpoint(link.apiBase, "/api/agents/self"), {
+        method: "DELETE"
+      });
+    } catch (error) {
+      if (error instanceof AgentLinkError && error.code === "not_linked" && error.message === AGENT_LINK_REVOKED_MESSAGE) {
+        revokedError = error;
+      }
+    }
+  }
+  if (args.secrets.available) {
+    if (link !== void 0) {
+      await removeSecretAccounts(args.secrets, agentSecretAccounts(args.wallet));
+    }
+  }
+  if (args.wallets.entry(args.wallet) !== void 0) await args.wallets.clearLink(args.wallet);
+  if (link !== void 0) {
+    await appendAudit(args.home ?? args.wallets.home, {
+      event: "agent.unlinked",
+      wallet: args.wallet,
+      owner: link.owner,
+      tty: Boolean(process.stderr.isTTY)
+    });
+  }
+  if (revokedError !== void 0) throw revokedError;
+}
+async function resolveAgentAccessToken(args, options) {
+  await args.wallets.reload();
+  const link = args.wallets.entry(args.wallet)?.link;
+  if (link === void 0 || !args.secrets.available) throw notLinkedError();
+  const accounts = agentSecretAccounts(args.wallet);
+  const tokens = parseTokens(await safeGetSecret(args.secrets, accounts.tokens));
+  if (tokens === void 0) throw notLinkedError();
+  const now = args.now ?? Date.now;
+  if (options.rejectedAccessToken === void 0 && tokens.expiresAt - 6e4 > now()) {
+    return tokens.accessToken;
+  }
+  return await withAgentCredentialLock(args.wallets, link.clientId, async () => {
+    await args.wallets.reload();
+    const currentLink = args.wallets.entry(args.wallet)?.link;
+    if (currentLink === void 0) throw notLinkedError();
+    const currentAccounts = agentSecretAccounts(args.wallet);
+    const current = parseTokens(await safeGetSecret(args.secrets, currentAccounts.tokens));
+    if (current === void 0) throw notLinkedError();
+    if (options.rejectedAccessToken !== void 0 && current.accessToken !== options.rejectedAccessToken) {
+      return current.accessToken;
+    }
+    if (options.rejectedAccessToken === void 0 && current.expiresAt - 6e4 > now()) {
+      return current.accessToken;
+    }
+    const response = await safeFetch(
+      args.fetchImpl ?? publicFetch,
+      apiEndpoint(currentLink.apiBase, "/oauth/token"),
+      {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: current.refreshToken,
+          client_id: currentLink.clientId
+        })
+      }
+    );
+    const payload = await responseRecord(response);
+    if (!response.ok) {
+      if (response.status === 400 && stringField(payload, "error") === "invalid_grant") {
+        throw new AgentLinkError("not_linked", AGENT_LINK_REVOKED_MESSAGE);
+      }
+      throw httpError("The vAPI agent token refresh failed.");
+    }
+    const refreshed = {
+      accessToken: requiredString(payload, "access_token"),
+      refreshToken: stringField(payload, "refresh_token") ?? current.refreshToken,
+      expiresAt: now() + requiredNumber(payload, "expires_in") * 1e3,
+      scopes: stringField(payload, "scope") === void 0 ? [...current.scopes] : splitScopes(requiredString(payload, "scope"))
+    };
+    await safeSetSecret(args.secrets, currentAccounts.tokens, JSON.stringify(refreshed));
+    return refreshed.accessToken;
+  });
+}
+async function readSecretSnapshot(secrets, accounts) {
+  const [tokens, routerStake, routerBalance] = await Promise.all([
+    safeGetSecret(secrets, accounts.tokens),
+    safeGetSecret(secrets, accounts.routerStake),
+    safeGetSecret(secrets, accounts.routerBalance)
+  ]);
+  return {
+    ...tokens === void 0 ? {} : { tokens },
+    ...routerStake === void 0 ? {} : { routerStake },
+    ...routerBalance === void 0 ? {} : { routerBalance }
+  };
+}
+async function restoreSecretSnapshot(secrets, accounts, snapshot) {
+  try {
+    await writeOptionalSecret(secrets, accounts.tokens, snapshot.tokens);
+    await writeOptionalSecret(secrets, accounts.routerStake, snapshot.routerStake);
+    await writeOptionalSecret(secrets, accounts.routerBalance, snapshot.routerBalance);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function restoreLinkMetadata(wallets, wallet, link) {
+  try {
+    if (link === void 0) await wallets.clearLink(wallet);
+    else await wallets.setLink(wallet, link);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeOptionalSecret(secrets, account, value) {
+  if (value === void 0) await safeRemoveSecret(secrets, account);
+  else await safeSetSecret(secrets, account, value);
+}
+async function removeSecretAccounts(secrets, accounts) {
+  await safeRemoveSecret(secrets, accounts.tokens);
+  await safeRemoveSecret(secrets, accounts.routerStake);
+  await safeRemoveSecret(secrets, accounts.routerBalance);
+}
+async function withAgentCredentialLock(wallets, clientId, operation) {
+  const digest = createHash("sha256").update(clientId).digest("hex").slice(0, 24);
+  const lockPath = `${wallets.registryPath}.${digest}.agent-link.lock`;
+  await mkdir2(dirname(lockPath), { recursive: true, mode: 448 });
+  const deadline = Date.now() + 3e4;
+  let handle;
+  while (!handle) {
+    try {
+      handle = await open(lockPath, "wx", 384);
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+      await removeStaleCredentialLock(lockPath);
+      if (Date.now() >= deadline) {
+        throw httpError("Timed out waiting to update the agent credentials.");
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+  try {
+    return await operation();
+  } finally {
+    await handle.close();
+    await unlink(lockPath).catch(() => void 0);
+  }
+}
+async function removeStaleCredentialLock(path) {
+  try {
+    const metadata = await stat(path);
+    if (Date.now() - metadata.mtimeMs > 5 * 6e4) await unlink(path);
+  } catch {
+  }
+}
+async function safeGetSecret(secrets, account) {
+  try {
+    return await secrets.get(account);
+  } catch {
+    throw httpError("The agent tokens could not be read from the OS secret store.");
+  }
+}
+async function safeSetSecret(secrets, account, value) {
+  try {
+    await secrets.set(account, value);
+  } catch {
+    throw httpError("The agent credentials could not be stored in the OS secret store.");
+  }
+}
+async function safeRemoveSecret(secrets, account) {
+  try {
+    await secrets.remove(account);
+  } catch {
+    throw httpError("The agent credentials could not be removed from the OS secret store.");
+  }
+}
+function parseTokens(value) {
+  if (value === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  const accessToken = stringField(parsed, "accessToken");
+  const refreshToken = stringField(parsed, "refreshToken");
+  const expiresAt = numberField(parsed, "expiresAt");
+  const scopes = parsed.scopes;
+  if (accessToken === void 0 || refreshToken === void 0 || expiresAt === void 0 || !Array.isArray(scopes) || scopes.some((scope) => typeof scope !== "string")) {
+    return void 0;
+  }
+  return { accessToken, refreshToken, expiresAt, scopes };
+}
+function withBearer(init, accessToken) {
+  const headers = new Headers(init?.headers);
+  headers.set("authorization", `Bearer ${accessToken}`);
+  return { ...init, headers };
+}
+async function safeFetch(fetchImpl, input, init) {
+  try {
+    return await fetchImpl(input, init);
+  } catch {
+    throw httpError("The vAPI agent link request failed.");
+  }
+}
+async function safeAgentFetch(fetchImpl, input, init) {
+  try {
+    return await fetchImpl(input, init);
+  } catch {
+    throw httpError("The vAPI agent request failed.");
+  }
+}
+function deviceAuthorizationError(status, payload) {
+  const error = stringField(payload, "error");
+  if (status === 401 && error === "invalid_agent_signature") {
+    return new AgentLinkError(
+      "invalid_agent_signature",
+      "The agent wallet signature was rejected."
+    );
+  }
+  if (status === 400 && error === "invalid_scope") {
+    return new AgentLinkError("invalid_scope", "The requested agent scope is not allowed.");
+  }
+  return httpError("The vAPI agent link request failed.");
+}
+function notLinkedError() {
+  return new AgentLinkError("not_linked", "Run vapi login first.");
+}
+function expiredLinkError() {
+  return new AgentLinkError(
+    "expired_token",
+    "The agent link request expired. Run vapi login again."
+  );
+}
+function httpError(message) {
+  return new AgentLinkError("http", message);
+}
+function apiEndpoint(apiBase, path) {
+  return new URL(path, new URL(apiBase).origin).toString();
+}
+async function responseRecord(response) {
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw httpError("The vAPI agent link response was invalid.");
+  }
+  if (!isRecord(payload)) throw httpError("The vAPI agent link response was invalid.");
+  return payload;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+}
+function numberField(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function requiredString(record, key) {
+  const value = stringField(record, key);
+  if (value === void 0) throw httpError("The vAPI agent link response was invalid.");
+  return value;
+}
+function requiredNumber(record, key) {
+  const value = numberField(record, key);
+  if (value === void 0) throw httpError("The vAPI agent link response was invalid.");
+  return value;
+}
+function requiredOwner(record, key) {
+  const value = requiredString(record, key);
+  if (!value.startsWith("0x")) throw httpError("The vAPI agent link response was invalid.");
+  return value;
+}
+function optionalStringProperty(record, source, target) {
+  const value = stringField(record, source);
+  return value === void 0 ? {} : { [target]: value };
+}
+function splitScopes(scope) {
+  return scope.split(/\s+/u).filter(Boolean);
+}
+async function sleepFor(milliseconds) {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+export {
+  AGENT_LINK_REVOKED_MESSAGE,
+  AGENT_LINK_STATEMENT,
+  AgentLinkError,
+  DEFAULT_AGENT_SCOPES,
+  agentAccessToken,
+  agentFetch,
+  agentSecretAccounts,
+  forgetAgentLink,
+  pollDeviceLink,
+  renameAgentLinkWallet,
+  saveAgentLink,
+  startDeviceLink,
+  withAgentCredentialLock
+};
+//# sourceMappingURL=agent-link.js.map