routstrd 0.4.10 → 0.4.11

package/dist/daemon/index.js

@@ -34170,7 +34170,7 @@ var init_hpke_noble = __esm(() => {
   priv2 = Symbol();
 });
 
-// node_modules/ehbp/dist/esm/protocol.js
+// node_modules/tinfoil/node_modules/ehbp/dist/esm/protocol.js
 var PROTOCOL, HPKE_CONFIG;
 var init_protocol = __esm(() => {
   PROTOCOL = {
@@ -34188,7 +34188,7 @@ var init_protocol = __esm(() => {
   };
 });
 
-// node_modules/ehbp/dist/esm/derive.js
+// node_modules/tinfoil/node_modules/ehbp/dist/esm/derive.js
 async function deriveResponseKeys(exportedSecret, requestEnc, responseNonce) {
   if (exportedSecret.length !== EXPORT_LENGTH) {
     throw new Error(`exported secret must be ${EXPORT_LENGTH} bytes, got ${exportedSecret.length}`);
@@ -34224,11 +34224,6 @@ function computeNonce(nonceBase, seq) {
   }
   return nonce;
 }
-async function encryptChunk(km, seq, plaintext) {
-  const nonce = computeNonce(km.nonceBase, seq);
-  const ciphertext = await aead.Seal(km.keyBytes, nonce, new Uint8Array(0), plaintext);
-  return ciphertext;
-}
 async function decryptChunk(km, seq, ciphertext) {
   const nonce = computeNonce(km.nonceBase, seq);
   const plaintext = await aead.Open(km.keyBytes, nonce, new Uint8Array(0), ciphertext);
@@ -34259,7 +34254,7 @@ var init_derive = __esm(() => {
   RESPONSE_NONCE_LABEL = new TextEncoder().encode("nonce");
 });
 
-// node_modules/ehbp/dist/esm/errors.js
+// node_modules/tinfoil/node_modules/ehbp/dist/esm/errors.js
 var EhbpError, KeyConfigMismatchError, ProtocolError, DecryptionError;
 var init_errors = __esm(() => {
   EhbpError = class EhbpError extends Error {
@@ -34292,7 +34287,7 @@ var init_errors = __esm(() => {
   };
 });
 
-// node_modules/ehbp/dist/esm/request-options.js
+// node_modules/tinfoil/node_modules/ehbp/dist/esm/request-options.js
 function forwardedRequestInit(source) {
   const forwarded = {};
   if (!source) {
@@ -34326,7 +34321,7 @@ var init_request_options = __esm(() => {
   ];
 });
 
-// node_modules/ehbp/dist/esm/identity.js
+// node_modules/tinfoil/node_modules/ehbp/dist/esm/identity.js
 function createSuite() {
   return new CipherSuite(KEM_DHKEM_X25519_HKDF_SHA256, KDF_HKDF_SHA256, AEAD_AES_256_GCM);
 }
@@ -34612,7 +34607,7 @@ var init_identity = __esm(() => {
   MAX_RESPONSE_CHUNK_BYTES = 64 * 1024 * 1024;
 });
 
-// node_modules/ehbp/dist/esm/client.js
+// node_modules/tinfoil/node_modules/ehbp/dist/esm/client.js
 class Transport {
   serverIdentity;
   serverHost;
@@ -34763,9 +34758,6 @@ class Transport {
     return this.request(url2, { ...init, method: "DELETE" });
   }
 }
-async function createTransport(serverURL, init) {
-  return Transport.create(serverURL, init);
-}
 var MAX_PROBLEM_DETAILS_BYTES;
 var init_client3 = __esm(() => {
   init_identity();
@@ -34776,35 +34768,7 @@ var init_client3 = __esm(() => {
   MAX_PROBLEM_DETAILS_BYTES = 64 * 1024;
 });
 
-// node_modules/ehbp/dist/esm/index.js
-var exports_esm = {};
-__export(exports_esm, {
-  serializeSessionRecoveryToken: () => serializeSessionRecoveryToken,
-  hexToBytes: () => hexToBytes8,
-  extractSessionRecoveryToken: () => extractSessionRecoveryToken,
-  encryptChunk: () => encryptChunk,
-  deserializeSessionRecoveryToken: () => deserializeSessionRecoveryToken,
-  deriveResponseKeys: () => deriveResponseKeys,
-  decryptResponseWithToken: () => decryptResponseWithToken,
-  decryptChunk: () => decryptChunk,
-  createTransport: () => createTransport,
-  computeNonce: () => computeNonce,
-  bytesToHex: () => bytesToHex8,
-  Transport: () => Transport,
-  RESPONSE_NONCE_LENGTH: () => RESPONSE_NONCE_LENGTH,
-  ProtocolError: () => ProtocolError,
-  PROTOCOL: () => PROTOCOL,
-  KeyConfigMismatchError: () => KeyConfigMismatchError,
-  Identity: () => Identity,
-  HPKE_REQUEST_INFO: () => HPKE_REQUEST_INFO,
-  HPKE_CONFIG: () => HPKE_CONFIG,
-  EhbpError: () => EhbpError,
-  EXPORT_LENGTH: () => EXPORT_LENGTH,
-  EXPORT_LABEL: () => EXPORT_LABEL,
-  DecryptionError: () => DecryptionError,
-  AES_GCM_NONCE_LENGTH: () => AES_GCM_NONCE_LENGTH,
-  AES256_KEY_LENGTH: () => AES256_KEY_LENGTH
-});
+// node_modules/tinfoil/node_modules/ehbp/dist/esm/index.js
 var init_esm3 = __esm(() => {
   init_identity();
   init_identity();
@@ -64619,6 +64583,650 @@ var init_dist10 = __esm(() => {
   init_openai();
 });
 
+// node_modules/ehbp/dist/esm/protocol.js
+var PROTOCOL2, HPKE_CONFIG2;
+var init_protocol2 = __esm(() => {
+  PROTOCOL2 = {
+    ENCAPSULATED_KEY_HEADER: "Ehbp-Encapsulated-Key",
+    RESPONSE_NONCE_HEADER: "Ehbp-Response-Nonce",
+    KEYS_MEDIA_TYPE: "application/ohttp-keys",
+    KEYS_PATH: "/.well-known/hpke-keys",
+    PROBLEM_JSON_MEDIA_TYPE: "application/problem+json",
+    KEY_CONFIG_PROBLEM_TYPE: "urn:ietf:params:ehbp:error:key-config"
+  };
+  HPKE_CONFIG2 = {
+    KEM: 32,
+    KDF: 1,
+    AEAD: 2
+  };
+});
+
+// node_modules/ehbp/dist/esm/derive.js
+async function deriveResponseKeys2(exportedSecret, requestEnc, responseNonce) {
+  if (exportedSecret.length !== EXPORT_LENGTH2) {
+    throw new Error(`exported secret must be ${EXPORT_LENGTH2} bytes, got ${exportedSecret.length}`);
+  }
+  if (requestEnc.length !== REQUEST_ENC_LENGTH2) {
+    throw new Error(`request enc must be ${REQUEST_ENC_LENGTH2} bytes, got ${requestEnc.length}`);
+  }
+  if (responseNonce.length !== RESPONSE_NONCE_LENGTH2) {
+    throw new Error(`response nonce must be ${RESPONSE_NONCE_LENGTH2} bytes, got ${responseNonce.length}`);
+  }
+  const salt = new Uint8Array(requestEnc.length + responseNonce.length);
+  salt.set(requestEnc, 0);
+  salt.set(responseNonce, requestEnc.length);
+  const prk = await kdf2.Extract(salt, exportedSecret);
+  const keyBytes = await kdf2.Expand(prk, RESPONSE_KEY_LABEL2, AES256_KEY_LENGTH2);
+  const nonceBase = await kdf2.Expand(prk, RESPONSE_NONCE_LABEL2, AES_GCM_NONCE_LENGTH2);
+  return { keyBytes, nonceBase };
+}
+function computeNonce2(nonceBase, seq) {
+  if (nonceBase.length !== AES_GCM_NONCE_LENGTH2) {
+    throw new Error(`nonce base must be ${AES_GCM_NONCE_LENGTH2} bytes`);
+  }
+  if (!Number.isInteger(seq) || seq < 0 || seq >= 4294967296) {
+    throw new Error(`sequence number must be an integer in range [0, 2^32): got ${seq}`);
+  }
+  const nonce = new Uint8Array(AES_GCM_NONCE_LENGTH2);
+  nonce.set(nonceBase);
+  for (let i4 = 0;i4 < 8; i4++) {
+    const shift = i4 * 8;
+    if (shift < 32) {
+      nonce[AES_GCM_NONCE_LENGTH2 - 1 - i4] ^= seq >>> shift & 255;
+    }
+  }
+  return nonce;
+}
+async function encryptChunk2(km, seq, plaintext) {
+  const nonce = computeNonce2(km.nonceBase, seq);
+  const ciphertext = await aead2.Seal(km.keyBytes, nonce, new Uint8Array(0), plaintext);
+  return ciphertext;
+}
+async function decryptChunk2(km, seq, ciphertext) {
+  const nonce = computeNonce2(km.nonceBase, seq);
+  const plaintext = await aead2.Open(km.keyBytes, nonce, new Uint8Array(0), ciphertext);
+  return plaintext;
+}
+function hexToBytes10(hex6) {
+  if (hex6.length % 2 !== 0) {
+    throw new Error("Hex string must have even length");
+  }
+  if (!/^[0-9a-fA-F]*$/.test(hex6)) {
+    throw new Error("Invalid hex character");
+  }
+  const bytes6 = new Uint8Array(hex6.length / 2);
+  for (let i4 = 0;i4 < bytes6.length; i4++) {
+    bytes6[i4] = parseInt(hex6.substring(i4 * 2, i4 * 2 + 2), 16);
+  }
+  return bytes6;
+}
+function bytesToHex12(bytes6) {
+  return Array.from(bytes6).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var kdf2, aead2, HPKE_REQUEST_INFO2 = "ehbp request", EXPORT_LABEL2 = "ehbp response", EXPORT_LENGTH2 = 32, RESPONSE_NONCE_LENGTH2 = 32, AES256_KEY_LENGTH2 = 32, AES_GCM_NONCE_LENGTH2 = 12, REQUEST_ENC_LENGTH2 = 32, RESPONSE_KEY_LABEL2, RESPONSE_NONCE_LABEL2;
+var init_derive2 = __esm(() => {
+  init_hpke_noble();
+  kdf2 = KDF_HKDF_SHA256();
+  aead2 = AEAD_AES_256_GCM();
+  RESPONSE_KEY_LABEL2 = new TextEncoder().encode("key");
+  RESPONSE_NONCE_LABEL2 = new TextEncoder().encode("nonce");
+});
+
+// node_modules/ehbp/dist/esm/errors.js
+var EhbpError2, KeyConfigMismatchError2, ProtocolError2, DecryptionError2;
+var init_errors6 = __esm(() => {
+  EhbpError2 = class EhbpError2 extends Error {
+    constructor(message, options) {
+      super(message);
+      this.name = "EhbpError";
+      if (options?.cause)
+        this.cause = options.cause;
+    }
+  };
+  KeyConfigMismatchError2 = class KeyConfigMismatchError2 extends EhbpError2 {
+    title;
+    constructor(title) {
+      super(title || "Server key configuration mismatch");
+      this.name = "KeyConfigMismatchError";
+      this.title = title || "";
+    }
+  };
+  ProtocolError2 = class ProtocolError2 extends EhbpError2 {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "ProtocolError";
+    }
+  };
+  DecryptionError2 = class DecryptionError2 extends EhbpError2 {
+    constructor(message, options) {
+      super(message, options);
+      this.name = "DecryptionError";
+    }
+  };
+});
+
+// node_modules/ehbp/dist/esm/request-options.js
+function forwardedRequestInit2(source) {
+  const forwarded = {};
+  if (!source) {
+    return forwarded;
+  }
+  const record2 = source;
+  const target = forwarded;
+  for (const key of FORWARDED_INIT_KEYS2) {
+    const value = record2[key];
+    if (value !== undefined) {
+      target[key] = value;
+    }
+  }
+  if (forwarded.mode === "navigate") {
+    delete forwarded.mode;
+  }
+  return forwarded;
+}
+var FORWARDED_INIT_KEYS2;
+var init_request_options2 = __esm(() => {
+  FORWARDED_INIT_KEYS2 = [
+    "cache",
+    "credentials",
+    "integrity",
+    "keepalive",
+    "mode",
+    "redirect",
+    "referrer",
+    "referrerPolicy",
+    "signal"
+  ];
+});
+
+// node_modules/ehbp/dist/esm/identity.js
+function createSuite2() {
+  return new CipherSuite(KEM_DHKEM_X25519_HKDF_SHA256, KDF_HKDF_SHA256, AEAD_AES_256_GCM);
+}
+
+class Identity3 {
+  suite;
+  publicKey;
+  privateKey;
+  constructor(suite, publicKey, privateKey) {
+    this.suite = suite;
+    this.publicKey = publicKey;
+    this.privateKey = privateKey;
+  }
+  static async generate() {
+    const suite = createSuite2();
+    const { publicKey, privateKey } = await suite.GenerateKeyPair(true);
+    return new Identity3(suite, publicKey, privateKey);
+  }
+  static async fromJSON(json3) {
+    const data = JSON.parse(json3);
+    const suite = createSuite2();
+    const publicKey = await suite.DeserializePublicKey(new Uint8Array(data.publicKey));
+    const privateKey = await suite.DeserializePrivateKey(new Uint8Array(data.privateKey), true);
+    return new Identity3(suite, publicKey, privateKey);
+  }
+  async toJSON() {
+    const publicKeyBytes = await this.suite.SerializePublicKey(this.publicKey);
+    const privateKeyBytes = await this.suite.SerializePrivateKey(this.privateKey);
+    return JSON.stringify({
+      publicKey: Array.from(publicKeyBytes),
+      privateKey: Array.from(privateKeyBytes)
+    });
+  }
+  getPublicKey() {
+    return this.publicKey;
+  }
+  async getPublicKeyHex() {
+    const exported = await this.suite.SerializePublicKey(this.publicKey);
+    return bytesToHex12(exported);
+  }
+  getPrivateKey() {
+    return this.privateKey;
+  }
+  async marshalConfig() {
+    const kemId = HPKE_CONFIG2.KEM;
+    const kdfId = HPKE_CONFIG2.KDF;
+    const aeadId = HPKE_CONFIG2.AEAD;
+    const publicKeyBytes = await this.suite.SerializePublicKey(this.publicKey);
+    const keyId = 0;
+    const publicKeySize = publicKeyBytes.length;
+    const cipherSuitesSize = 2 + 2;
+    const buffer = new Uint8Array(1 + 2 + publicKeySize + 2 + cipherSuitesSize);
+    let offset = 0;
+    buffer[offset++] = keyId;
+    buffer[offset++] = kemId >> 8 & 255;
+    buffer[offset++] = kemId & 255;
+    buffer.set(publicKeyBytes, offset);
+    offset += publicKeySize;
+    buffer[offset++] = cipherSuitesSize >> 8 & 255;
+    buffer[offset++] = cipherSuitesSize & 255;
+    buffer[offset++] = kdfId >> 8 & 255;
+    buffer[offset++] = kdfId & 255;
+    buffer[offset++] = aeadId >> 8 & 255;
+    buffer[offset++] = aeadId & 255;
+    return buffer;
+  }
+  static async unmarshalPublicConfig(data) {
+    let offset = 0;
+    const keyId = data[offset++];
+    const kemId = data[offset++] << 8 | data[offset++];
+    const publicKeySize = 32;
+    const publicKeyBytes = data.slice(offset, offset + publicKeySize);
+    offset += publicKeySize;
+    const cipherSuitesLength = data[offset++] << 8 | data[offset++];
+    const suites = [];
+    const cipherSuitesEnd = offset + cipherSuitesLength;
+    while (offset < cipherSuitesEnd) {
+      const kdfId = data[offset++] << 8 | data[offset++];
+      const aeadId = data[offset++] << 8 | data[offset++];
+      suites.push({ kdfId, aeadId });
+    }
+    if (suites.length === 0) {
+      throw new ProtocolError2("No cipher suites found in config");
+    }
+    const firstSuite = suites[0];
+    if (firstSuite.kdfId !== HPKE_CONFIG2.KDF || firstSuite.aeadId !== HPKE_CONFIG2.AEAD) {
+      throw new ProtocolError2(`Unsupported cipher suite: KDF=0x${firstSuite.kdfId.toString(16)}, AEAD=0x${firstSuite.aeadId.toString(16)}`);
+    }
+    return Identity3.fromPublicKeyBytes(publicKeyBytes);
+  }
+  static async fromPublicKeyHex(publicKeyHex) {
+    const publicKeyBytes = hexToBytes10(publicKeyHex);
+    if (publicKeyBytes.length !== 32) {
+      throw new ProtocolError2(`Invalid public key length: expected 32, got ${publicKeyBytes.length}`);
+    }
+    return Identity3.fromPublicKeyBytes(publicKeyBytes);
+  }
+  static async fromPublicKeyBytes(publicKeyBytes) {
+    const suite = createSuite2();
+    const publicKey = await suite.DeserializePublicKey(publicKeyBytes);
+    const placeholderPrivateKey = await suite.DeserializePrivateKey(new Uint8Array(32), false);
+    return new Identity3(suite, publicKey, placeholderPrivateKey);
+  }
+  async encryptRequestWithContext(request) {
+    const body = await request.arrayBuffer();
+    if (body.byteLength === 0) {
+      return {
+        request: new Request(request.url, {
+          ...forwardedRequestInit2(request),
+          method: request.method,
+          headers: request.headers,
+          body: null
+        }),
+        context: null
+      };
+    }
+    const infoBytes = new TextEncoder().encode(HPKE_REQUEST_INFO2);
+    const { encapsulatedSecret, ctx } = await this.suite.SetupSender(this.publicKey, {
+      info: infoBytes
+    });
+    const context = {
+      senderContext: ctx,
+      requestEnc: encapsulatedSecret
+    };
+    const headers = new Headers(request.headers);
+    headers.set(PROTOCOL2.ENCAPSULATED_KEY_HEADER, bytesToHex12(context.requestEnc));
+    const encrypted = await ctx.Seal(new Uint8Array(body));
+    const chunkLength = new Uint8Array(4);
+    new DataView(chunkLength.buffer).setUint32(0, encrypted.byteLength, false);
+    const chunkedData = new Uint8Array(4 + encrypted.byteLength);
+    chunkedData.set(chunkLength, 0);
+    chunkedData.set(encrypted, 4);
+    return {
+      request: new Request(request.url, {
+        ...forwardedRequestInit2(request),
+        method: request.method,
+        headers,
+        body: chunkedData,
+        duplex: "half"
+      }),
+      context
+    };
+  }
+  async decryptResponseWithContext(response, context) {
+    const token = await extractSessionRecoveryToken2(context);
+    return decryptResponseWithToken2(response, token);
+  }
+}
+async function extractSessionRecoveryToken2(context) {
+  const exportLabelBytes = new TextEncoder().encode(EXPORT_LABEL2);
+  const exportedSecret = new Uint8Array(await context.senderContext.Export(exportLabelBytes, EXPORT_LENGTH2));
+  return {
+    exportedSecret,
+    requestEnc: new Uint8Array(context.requestEnc)
+  };
+}
+function serializeSessionRecoveryToken2(token) {
+  return JSON.stringify({
+    exportedSecret: bytesToHex12(token.exportedSecret),
+    requestEnc: bytesToHex12(token.requestEnc)
+  });
+}
+function deserializeSessionRecoveryToken2(json3) {
+  const parsed = JSON.parse(json3);
+  return {
+    exportedSecret: hexToBytes10(parsed.exportedSecret),
+    requestEnc: hexToBytes10(parsed.requestEnc)
+  };
+}
+async function decryptResponseWithToken2(response, token, onStreamError, onStreamComplete) {
+  const responseNonceHex = response.headers.get(PROTOCOL2.RESPONSE_NONCE_HEADER);
+  if (!response.body && !responseNonceHex) {
+    return response;
+  }
+  if (!responseNonceHex) {
+    throw new ProtocolError2(`Missing ${PROTOCOL2.RESPONSE_NONCE_HEADER} header`);
+  }
+  const responseNonce = hexToBytes10(responseNonceHex);
+  if (responseNonce.length !== RESPONSE_NONCE_LENGTH2) {
+    throw new ProtocolError2(`Invalid response nonce length`);
+  }
+  if (!response.body) {
+    onStreamComplete?.();
+    return response;
+  }
+  const km = await deriveResponseKeys2(token.exportedSecret, token.requestEnc, responseNonce);
+  const decryptedStream = createDecryptStream2(response.body, km, onStreamError, onStreamComplete);
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  headers.delete("transfer-encoding");
+  return new Response(decryptedStream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function createDecryptStream2(body, km, onStreamError, onStreamComplete) {
+  let buffer = new Uint8Array(0);
+  let seq = 0;
+  const reader = body.getReader();
+  let consumerCancelled = false;
+  return new ReadableStream({
+    async pull(controller) {
+      const fail = (error53) => {
+        try {
+          onStreamError?.();
+        } catch {}
+        try {
+          controller.error(error53);
+        } finally {
+          reader.cancel(error53).catch(() => {});
+        }
+      };
+      while (true) {
+        if (buffer.length >= 4) {
+          const chunkLength = (buffer[0] << 24 | buffer[1] << 16 | buffer[2] << 8 | buffer[3]) >>> 0;
+          if (chunkLength === 0) {
+            buffer = buffer.slice(4);
+            continue;
+          }
+          if (chunkLength > MAX_RESPONSE_CHUNK_BYTES2) {
+            fail(new ProtocolError2("response chunk exceeds maximum allowed size"));
+            return;
+          }
+          if (buffer.length >= 4 + chunkLength) {
+            const ciphertext = buffer.slice(4, 4 + chunkLength);
+            buffer = buffer.slice(4 + chunkLength);
+            try {
+              const plaintext = await decryptChunk2(km, seq++, ciphertext);
+              controller.enqueue(plaintext);
+              return;
+            } catch (error53) {
+              fail(new DecryptionError2(`Decryption failed at chunk ${seq - 1}`, { cause: error53 }));
+              return;
+            }
+          }
+        }
+        let result;
+        try {
+          result = await reader.read();
+        } catch (error53) {
+          if (consumerCancelled) {
+            return;
+          }
+          fail(error53 instanceof Error ? error53 : new Error("Encrypted response read failed", {
+            cause: error53
+          }));
+          return;
+        }
+        const { done, value } = result;
+        if (done) {
+          if (consumerCancelled) {
+            return;
+          }
+          if (buffer.length !== 0) {
+            fail(new ProtocolError2("truncated encrypted response chunk"));
+          } else {
+            onStreamComplete?.();
+            controller.close();
+          }
+          return;
+        }
+        const newBuffer = new Uint8Array(buffer.length + value.length);
+        newBuffer.set(buffer);
+        newBuffer.set(value, buffer.length);
+        buffer = newBuffer;
+      }
+    },
+    cancel(reason) {
+      consumerCancelled = true;
+      return reader.cancel(reason);
+    }
+  });
+}
+var MAX_RESPONSE_CHUNK_BYTES2;
+var init_identity2 = __esm(() => {
+  init_hpke();
+  init_hpke_noble();
+  init_protocol2();
+  init_derive2();
+  init_errors6();
+  init_request_options2();
+  MAX_RESPONSE_CHUNK_BYTES2 = 64 * 1024 * 1024;
+});
+
+// node_modules/ehbp/dist/esm/client.js
+class Transport2 {
+  serverIdentity;
+  serverHost;
+  _lastSessionRecoveryToken;
+  requestGeneration = 0;
+  constructor(serverIdentity, serverHost) {
+    this.serverIdentity = serverIdentity;
+    this.serverHost = serverHost;
+  }
+  getSessionRecoveryToken() {
+    if (!this._lastSessionRecoveryToken) {
+      throw new Error("No session recovery token available \u2014 no request has been made yet");
+    }
+    return this._lastSessionRecoveryToken;
+  }
+  static async create(serverURL, init) {
+    const url3 = new URL(serverURL);
+    const serverHost = url3.host;
+    const keysURL = new URL(PROTOCOL2.KEYS_PATH, serverURL);
+    const response = await fetch(keysURL.toString(), init);
+    if (!response.ok) {
+      throw new Error(`Failed to get server public key: ${response.status}`);
+    }
+    const contentType = response.headers.get("content-type");
+    if (contentType !== PROTOCOL2.KEYS_MEDIA_TYPE) {
+      throw new Error(`Invalid content type: ${contentType}`);
+    }
+    const keysData = new Uint8Array(await response.arrayBuffer());
+    const serverIdentity = await Identity3.unmarshalPublicConfig(keysData);
+    return new Transport2(serverIdentity, serverHost);
+  }
+  static isProblemJSONContentType(contentType) {
+    if (!contentType) {
+      return false;
+    }
+    const mediaType = contentType.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+    return mediaType === PROTOCOL2.PROBLEM_JSON_MEDIA_TYPE;
+  }
+  static async checkKeyConfigMismatch(response) {
+    if (response.status !== 422)
+      return;
+    if (!Transport2.isProblemJSONContentType(response.headers.get("content-type")))
+      return;
+    let problem;
+    try {
+      const clone2 = response.clone();
+      if (!clone2.body)
+        return;
+      const reader = clone2.body.getReader();
+      const chunks = [];
+      let length2 = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        length2 += value.byteLength;
+        if (length2 > MAX_PROBLEM_DETAILS_BYTES2) {
+          reader.cancel().catch(() => {});
+          return;
+        }
+        chunks.push(value);
+      }
+      const body = new Uint8Array(length2);
+      let offset = 0;
+      for (const chunk of chunks) {
+        body.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      problem = JSON.parse(new TextDecoder().decode(body));
+    } catch {
+      return;
+    }
+    if (problem?.type === PROTOCOL2.KEY_CONFIG_PROBLEM_TYPE) {
+      throw new KeyConfigMismatchError2(typeof problem.title === "string" ? problem.title : undefined);
+    }
+  }
+  static async shouldDecryptResponse(response) {
+    if (response.headers.has(PROTOCOL2.RESPONSE_NONCE_HEADER)) {
+      return true;
+    }
+    await Transport2.checkKeyConfigMismatch(response);
+    if (!response.ok) {
+      return false;
+    }
+    throw new ProtocolError2(`Missing ${PROTOCOL2.RESPONSE_NONCE_HEADER} header`);
+  }
+  getServerIdentity() {
+    return this.serverIdentity;
+  }
+  getServerPublicKey() {
+    return this.serverIdentity.getPublicKey();
+  }
+  async getServerPublicKeyHex() {
+    return this.serverIdentity.getPublicKeyHex();
+  }
+  async request(input, init) {
+    const generation = ++this.requestGeneration;
+    this._lastSessionRecoveryToken = undefined;
+    const inputUrl = input instanceof Request ? input.url : String(input);
+    if (inputUrl.startsWith("data:") || inputUrl.startsWith("blob:")) {
+      return fetch(input, init);
+    }
+    const normalizedRequest = new Request(input, init);
+    const requestBodyBytes = await normalizedRequest.arrayBuffer();
+    const requestBody = requestBodyBytes.byteLength > 0 ? requestBodyBytes : null;
+    const url3 = new URL(normalizedRequest.url);
+    url3.host = this.serverHost;
+    const request = new Request(url3.toString(), {
+      ...forwardedRequestInit2(normalizedRequest),
+      method: normalizedRequest.method,
+      headers: normalizedRequest.headers,
+      body: requestBody,
+      duplex: "half"
+    });
+    const { request: encryptedRequest, context } = await this.serverIdentity.encryptRequestWithContext(request);
+    const token = context ? await extractSessionRecoveryToken2(context) : undefined;
+    const response = await fetch(encryptedRequest);
+    if (!token) {
+      return response;
+    }
+    const shouldDecrypt = await Transport2.shouldDecryptResponse(response);
+    if (!shouldDecrypt) {
+      return response;
+    }
+    let streamTerminated = false;
+    const clearToken = () => {
+      streamTerminated = true;
+      if (this.requestGeneration === generation) {
+        this._lastSessionRecoveryToken = undefined;
+      }
+    };
+    const decryptedResponse = await decryptResponseWithToken2(response, token, clearToken, clearToken);
+    if (this.requestGeneration === generation) {
+      this._lastSessionRecoveryToken = streamTerminated ? undefined : token;
+    }
+    return decryptedResponse;
+  }
+  async get(url3, init) {
+    return this.request(url3, { ...init, method: "GET" });
+  }
+  async post(url3, body, init) {
+    return this.request(url3, { ...init, method: "POST", body });
+  }
+  async put(url3, body, init) {
+    return this.request(url3, { ...init, method: "PUT", body });
+  }
+  async delete(url3, init) {
+    return this.request(url3, { ...init, method: "DELETE" });
+  }
+}
+async function createTransport2(serverURL, init) {
+  return Transport2.create(serverURL, init);
+}
+var MAX_PROBLEM_DETAILS_BYTES2;
+var init_client5 = __esm(() => {
+  init_identity2();
+  init_identity2();
+  init_protocol2();
+  init_request_options2();
+  init_errors6();
+  MAX_PROBLEM_DETAILS_BYTES2 = 64 * 1024;
+});
+
+// node_modules/ehbp/dist/esm/index.js
+var exports_esm = {};
+__export(exports_esm, {
+  serializeSessionRecoveryToken: () => serializeSessionRecoveryToken2,
+  hexToBytes: () => hexToBytes10,
+  extractSessionRecoveryToken: () => extractSessionRecoveryToken2,
+  encryptChunk: () => encryptChunk2,
+  deserializeSessionRecoveryToken: () => deserializeSessionRecoveryToken2,
+  deriveResponseKeys: () => deriveResponseKeys2,
+  decryptResponseWithToken: () => decryptResponseWithToken2,
+  decryptChunk: () => decryptChunk2,
+  createTransport: () => createTransport2,
+  computeNonce: () => computeNonce2,
+  bytesToHex: () => bytesToHex12,
+  Transport: () => Transport2,
+  RESPONSE_NONCE_LENGTH: () => RESPONSE_NONCE_LENGTH2,
+  ProtocolError: () => ProtocolError2,
+  PROTOCOL: () => PROTOCOL2,
+  KeyConfigMismatchError: () => KeyConfigMismatchError2,
+  Identity: () => Identity3,
+  HPKE_REQUEST_INFO: () => HPKE_REQUEST_INFO2,
+  HPKE_CONFIG: () => HPKE_CONFIG2,
+  EhbpError: () => EhbpError2,
+  EXPORT_LENGTH: () => EXPORT_LENGTH2,
+  EXPORT_LABEL: () => EXPORT_LABEL2,
+  DecryptionError: () => DecryptionError2,
+  AES_GCM_NONCE_LENGTH: () => AES_GCM_NONCE_LENGTH2,
+  AES256_KEY_LENGTH: () => AES256_KEY_LENGTH2
+});
+var init_esm4 = __esm(() => {
+  init_identity2();
+  init_identity2();
+  init_client5();
+  init_protocol2();
+  init_errors6();
+  init_derive2();
+});
+
 // node_modules/applesauce-sqlite/node_modules/applesauce-core/dist/factories/types.js
 var init_types4 = () => {};
 
@@ -64999,20 +65607,20 @@ __export(exports_utils3, {
   numberToBytesLE: () => numberToBytesLE5,
   numberToBytesBE: () => numberToBytesBE5,
   hexToNumber: () => hexToNumber5,
-  hexToBytes: () => hexToBytes10,
+  hexToBytes: () => hexToBytes11,
   equalBytes: () => equalBytes7,
   ensureBytes: () => ensureBytes4,
   createHmacDrbg: () => createHmacDrbg5,
   concatBytes: () => concatBytes12,
   bytesToNumberLE: () => bytesToNumberLE5,
   bytesToNumberBE: () => bytesToNumberBE5,
-  bytesToHex: () => bytesToHex12,
+  bytesToHex: () => bytesToHex13,
   bitSet: () => bitSet3,
   bitMask: () => bitMask5,
   bitLen: () => bitLen5,
   bitGet: () => bitGet3
 });
-function bytesToHex12(bytes7) {
+function bytesToHex13(bytes7) {
   if (!u8a8(bytes7))
     throw new Error("Uint8Array expected");
   let hex6 = "";
@@ -65030,7 +65638,7 @@ function hexToNumber5(hex6) {
     throw new Error("hex string expected, got " + typeof hex6);
   return BigInt(hex6 === "" ? "0" : `0x${hex6}`);
 }
-function hexToBytes10(hex6) {
+function hexToBytes11(hex6) {
   if (typeof hex6 !== "string")
     throw new Error("hex string expected, got " + typeof hex6);
   const len = hex6.length;
@@ -65048,27 +65656,27 @@ function hexToBytes10(hex6) {
   return array2;
 }
 function bytesToNumberBE5(bytes7) {
-  return hexToNumber5(bytesToHex12(bytes7));
+  return hexToNumber5(bytesToHex13(bytes7));
 }
 function bytesToNumberLE5(bytes7) {
   if (!u8a8(bytes7))
     throw new Error("Uint8Array expected");
-  return hexToNumber5(bytesToHex12(Uint8Array.from(bytes7).reverse()));
+  return hexToNumber5(bytesToHex13(Uint8Array.from(bytes7).reverse()));
 }
 function numberToBytesBE5(n, len) {
-  return hexToBytes10(n.toString(16).padStart(len * 2, "0"));
+  return hexToBytes11(n.toString(16).padStart(len * 2, "0"));
 }
 function numberToBytesLE5(n, len) {
   return numberToBytesBE5(n, len).reverse();
 }
 function numberToVarBytesBE3(n) {
-  return hexToBytes10(numberToHexUnpadded5(n));
+  return hexToBytes11(numberToHexUnpadded5(n));
 }
 function ensureBytes4(title, hex6, expectedLength) {
   let res;
   if (typeof hex6 === "string") {
     try {
-      res = hexToBytes10(hex6);
+      res = hexToBytes11(hex6);
     } catch (e13) {
       throw new Error(`${title} must be valid hex string, got "${hex6}". Cause: ${e13}`);
     }
@@ -65634,7 +66242,7 @@ function weierstrassPoints3(opts) {
     const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
     if (lengths && typeof key !== "bigint") {
       if (key instanceof Uint8Array)
-        key = bytesToHex12(key);
+        key = bytesToHex13(key);
       if (typeof key !== "string" || !lengths.includes(key.length))
         throw new Error("Invalid key");
       key = key.padStart(nByteLength * 2, "0");
@@ -65925,7 +66533,7 @@ function weierstrassPoints3(opts) {
       return toBytes9(Point4, this, isCompressed);
     }
     toHex(isCompressed = true) {
-      return bytesToHex12(this.toRawBytes(isCompressed));
+      return bytesToHex13(this.toRawBytes(isCompressed));
     }
   }
   Point4.BASE = new Point4(CURVE.Gx, CURVE.Gy, Fp5.ONE);
@@ -66003,7 +66611,7 @@ function weierstrass5(curveDef) {
       }
     }
   });
-  const numToNByteStr = (num2) => bytesToHex12(numberToBytesBE5(num2, CURVE.nByteLength));
+  const numToNByteStr = (num2) => bytesToHex13(numberToBytesBE5(num2, CURVE.nByteLength));
   function isBiggerThanHalfOrder(number10) {
     const HALF = CURVE_ORDER >> _1n27;
     return number10 > HALF;
@@ -66064,13 +66672,13 @@ function weierstrass5(curveDef) {
       return this.hasHighS() ? new Signature(this.r, modN3(-this.s), this.recovery) : this;
     }
     toDERRawBytes() {
-      return hexToBytes10(this.toDERHex());
+      return hexToBytes11(this.toDERHex());
     }
     toDERHex() {
       return DER5.hexFromSig({ r: this.r, s: this.s });
     }
     toCompactRawBytes() {
-      return hexToBytes10(this.toCompactHex());
+      return hexToBytes11(this.toCompactHex());
     }
     toCompactHex() {
       return numToNByteStr(this.r) + numToNByteStr(this.s);
@@ -66565,7 +67173,7 @@ var init_cryptoNode5 = __esm(() => {
 });
 
 // node_modules/applesauce-sqlite/node_modules/applesauce-core/node_modules/nostr-tools/node_modules/@noble/hashes/esm/utils.js
-function bytesToHex13(bytes7) {
+function bytesToHex14(bytes7) {
   if (!u8a9(bytes7))
     throw new Error("Uint8Array expected");
   let hex6 = "";
@@ -66574,7 +67182,7 @@ function bytesToHex13(bytes7) {
   }
   return hex6;
 }
-function hexToBytes11(hex6) {
+function hexToBytes12(hex6) {
   if (typeof hex6 !== "string")
     throw new Error("hex string expected, got " + typeof hex6);
   const len = hex6.length;
@@ -67256,7 +67864,7 @@ function genBech324(encoding2) {
   return { encode: encode5, decode: decode4, decodeToBytes, decodeUnsafe, fromWords, fromWordsUnsafe, toWords };
 }
 var gcd4 = (a, b) => !b ? a : gcd4(b, a % b), radix2carry4 = (from7, to) => from7 + (to - gcd4(from7, to)), base164, base324, base32hex4, base32crockford4, base647, base64url6, genBase584 = (abc) => chain4(radix6(58), alphabet4(abc), join5("")), base584, base58flickr4, base58xrp4, XMR_BLOCK_LEN3, base58xmr3, BECH_ALPHABET4, POLYMOD_GENERATORS4, bech324, bech32m4, utf83, hex6, CODERS3, coderTypeError3;
-var init_esm4 = __esm(() => {
+var init_esm5 = __esm(() => {
   /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   base164 = chain4(radix24(4), alphabet4("0123456789ABCDEF"), join5(""));
   base324 = chain4(radix24(5), alphabet4("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding4(5), join5(""));
@@ -67352,7 +67960,7 @@ function output8(out, instance) {
 var init__assert6 = () => {};
 
 // node_modules/applesauce-sqlite/node_modules/applesauce-core/node_modules/nostr-tools/node_modules/@noble/ciphers/esm/utils.js
-function bytesToHex14(bytes9) {
+function bytesToHex15(bytes9) {
   bytes8(bytes9);
   let hex7 = "";
   for (let i4 = 0;i4 < bytes9.length; i4++) {
@@ -67369,7 +67977,7 @@ function asciiToBase164(char) {
     return char - (asciis4._a - 10);
   return;
 }
-function hexToBytes12(hex7) {
+function hexToBytes13(hex7) {
   if (typeof hex7 !== "string")
     throw new Error("hex string expected, got " + typeof hex7);
   const hl = hex7.length;
@@ -68999,7 +69607,7 @@ function serializeEvent4(evt) {
 }
 function getEventHash4(event3) {
   let eventHash = sha2569(utf8Encoder5.encode(serializeEvent4(event3)));
-  return bytesToHex13(eventHash);
+  return bytesToHex14(eventHash);
 }
 function isRegularKind4(kind) {
   return kind < 1e4 && kind !== 0 && kind !== 3;
@@ -69164,7 +69772,7 @@ function decode4(code) {
       return {
         type: "nprofile",
         data: {
-          pubkey: bytesToHex13(tlv[0][0]),
+          pubkey: bytesToHex14(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder5.decode(d)) : []
         }
       };
@@ -69182,10 +69790,10 @@ function decode4(code) {
       return {
         type: "nevent",
         data: {
-          id: bytesToHex13(tlv[0][0]),
+          id: bytesToHex14(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder5.decode(d)) : [],
-          author: tlv[2]?.[0] ? bytesToHex13(tlv[2][0]) : undefined,
-          kind: tlv[3]?.[0] ? parseInt(bytesToHex13(tlv[3][0]), 16) : undefined
+          author: tlv[2]?.[0] ? bytesToHex14(tlv[2][0]) : undefined,
+          kind: tlv[3]?.[0] ? parseInt(bytesToHex14(tlv[3][0]), 16) : undefined
         }
       };
     }
@@ -69205,8 +69813,8 @@ function decode4(code) {
         type: "naddr",
         data: {
           identifier: utf8Decoder5.decode(tlv[0][0]),
-          pubkey: bytesToHex13(tlv[2][0]),
-          kind: parseInt(bytesToHex13(tlv[3][0]), 16),
+          pubkey: bytesToHex14(tlv[2][0]),
+          kind: parseInt(bytesToHex14(tlv[3][0]), 16),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder5.decode(d)) : []
         }
       };
@@ -69215,7 +69823,7 @@ function decode4(code) {
       return { type: prefix, data };
     case "npub":
     case "note":
-      return { type: prefix, data: bytesToHex13(data) };
+      return { type: prefix, data: bytesToHex14(data) };
     default:
       throw new Error(`unknown prefix ${prefix}`);
   }
@@ -69239,10 +69847,10 @@ function nsecEncode2(key) {
   return encodeBytes2("nsec", key);
 }
 function npubEncode3(hex7) {
-  return encodeBytes2("npub", hexToBytes11(hex7));
+  return encodeBytes2("npub", hexToBytes12(hex7));
 }
 function noteEncode2(hex7) {
-  return encodeBytes2("note", hexToBytes11(hex7));
+  return encodeBytes2("note", hexToBytes12(hex7));
 }
 function encodeBech322(prefix, data) {
   let words = bech324.toWords(data);
@@ -69253,7 +69861,7 @@ function encodeBytes2(prefix, bytes9) {
 }
 function nprofileEncode2(profile3) {
   let data = encodeTLV2({
-    0: [hexToBytes11(profile3.pubkey)],
+    0: [hexToBytes12(profile3.pubkey)],
     1: (profile3.relays || []).map((url3) => utf8Encoder5.encode(url3))
   });
   return encodeBech322("nprofile", data);
@@ -69264,9 +69872,9 @@ function neventEncode2(event3) {
     kindArray = integerToUint8Array2(event3.kind);
   }
   let data = encodeTLV2({
-    0: [hexToBytes11(event3.id)],
+    0: [hexToBytes12(event3.id)],
     1: (event3.relays || []).map((url3) => utf8Encoder5.encode(url3)),
-    2: event3.author ? [hexToBytes11(event3.author)] : [],
+    2: event3.author ? [hexToBytes12(event3.author)] : [],
     3: kindArray ? [new Uint8Array(kindArray)] : []
   });
   return encodeBech322("nevent", data);
@@ -69277,7 +69885,7 @@ function naddrEncode2(addr) {
   let data = encodeTLV2({
     0: [utf8Encoder5.encode(addr.identifier)],
     1: (addr.relays || []).map((url3) => utf8Encoder5.encode(url3)),
-    2: [hexToBytes11(addr.pubkey)],
+    2: [hexToBytes12(addr.pubkey)],
     3: [new Uint8Array(kind)]
   });
   return encodeBech322("naddr", data);
@@ -69296,7 +69904,7 @@ function encodeTLV2(tlv) {
   return concatBytes13(...entries);
 }
 function encrypt5(secretKey, pubkey, text) {
-  const privkey = secretKey instanceof Uint8Array ? bytesToHex13(secretKey) : secretKey;
+  const privkey = secretKey instanceof Uint8Array ? bytesToHex14(secretKey) : secretKey;
   const key = secp256k14.getSharedSecret(privkey, "02" + pubkey);
   const normalizedKey = getNormalizedX2(key);
   let iv = Uint8Array.from(randomBytes8(16));
@@ -69307,7 +69915,7 @@ function encrypt5(secretKey, pubkey, text) {
   return `${ctb64}?iv=${ivb64}`;
 }
 function decrypt4(secretKey, pubkey, data) {
-  const privkey = secretKey instanceof Uint8Array ? bytesToHex13(secretKey) : secretKey;
+  const privkey = secretKey instanceof Uint8Array ? bytesToHex14(secretKey) : secretKey;
   let [ctb64, ivb64] = data.split("?iv=");
   let key = secp256k14.getSharedSecret(privkey, "02" + pubkey);
   let normalizedKey = getNormalizedX2(key);
@@ -69496,7 +70104,7 @@ function minePow2(unsigned, difficulty) {
   return event3;
 }
 function fastEventHash2(evt) {
-  return bytesToHex13(sha2569(utf8Encoder5.encode(JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]))));
+  return bytesToHex14(sha2569(utf8Encoder5.encode(JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]))));
 }
 function getConversationKey2(privkeyA, pubkeyB) {
   const sharedX = secp256k14.getSharedSecret(privkeyA, "02" + pubkeyB).subarray(1, 33);
@@ -70244,7 +70852,7 @@ function validateEventMethodTag2(event3, method) {
 }
 function hashPayload3(payload) {
   const hash8 = sha2569(utf8Encoder5.encode(JSON.stringify(payload)));
-  return bytesToHex13(hash8);
+  return bytesToHex14(hash8);
 }
 function validateEventPayloadTag2(event3, payload) {
   const payloadTag = event3.tags.find((t) => t[0] === "payload");
@@ -70331,13 +70939,13 @@ var __defProp3, __export3 = (target, all) => {
     return schnorr4.utils.randomPrivateKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex13(schnorr4.getPublicKey(secretKey));
+    return bytesToHex14(schnorr4.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event3 = t;
-    event3.pubkey = bytesToHex13(schnorr4.getPublicKey(secretKey));
+    event3.pubkey = bytesToHex14(schnorr4.getPublicKey(secretKey));
     event3.id = getEventHash4(event3);
-    event3.sig = bytesToHex13(schnorr4.sign(getEventHash4(event3), secretKey));
+    event3.sig = bytesToHex14(schnorr4.sign(getEventHash4(event3), secretKey));
     event3[verifiedSymbol6] = true;
     return event3;
   }
@@ -70960,7 +71568,7 @@ var __defProp3, __export3 = (target, all) => {
   insert(timestamp, id) {
     if (this.sealed)
       throw Error("already sealed");
-    const idb = hexToBytes12(id);
+    const idb = hexToBytes13(id);
     if (idb.byteLength !== ID_SIZE3)
       throw Error("bad id size for added item");
     this.items.push({ timestamp, id: idb });
@@ -71053,10 +71661,10 @@ var __defProp3, __export3 = (target, all) => {
     let output9 = new WrappedBuffer3;
     output9.extend(new Uint8Array([PROTOCOL_VERSION3]));
     this.splitRange(0, this.storage.size(), this._bound(Number.MAX_VALUE), output9);
-    return bytesToHex14(output9.unwrap());
+    return bytesToHex15(output9.unwrap());
   }
   reconcile(queryMsg, onhave, onneed) {
-    const query2 = new WrappedBuffer3(hexToBytes12(queryMsg));
+    const query2 = new WrappedBuffer3(hexToBytes13(queryMsg));
     this.lastTimestampIn = this.lastTimestampOut = 0;
     let fullOutput = new WrappedBuffer3;
     fullOutput.extend(new Uint8Array([PROTOCOL_VERSION3]));
@@ -71099,22 +71707,22 @@ var __defProp3, __export3 = (target, all) => {
         let theirElems = {};
         for (let i22 = 0;i22 < numIds; i22++) {
           let e13 = getBytes4(query2, ID_SIZE3);
-          theirElems[bytesToHex14(e13)] = e13;
+          theirElems[bytesToHex15(e13)] = e13;
         }
         skip2 = true;
         this.storage.iterate(lower, upper, (item) => {
           let k2 = item.id;
-          const id = bytesToHex14(k2);
+          const id = bytesToHex15(k2);
           if (!theirElems[id]) {
             onhave?.(id);
           } else {
-            delete theirElems[bytesToHex14(k2)];
+            delete theirElems[bytesToHex15(k2)];
           }
           return true;
         });
         if (onneed) {
           for (let v3 of Object.values(theirElems)) {
-            onneed(bytesToHex14(v3));
+            onneed(bytesToHex15(v3));
           }
         }
       } else {
@@ -71132,7 +71740,7 @@ var __defProp3, __export3 = (target, all) => {
       prevIndex = upper;
       prevBound = currBound;
     }
-    return fullOutput.length === 1 ? null : bytesToHex14(fullOutput.unwrap());
+    return fullOutput.length === 1 ? null : bytesToHex15(fullOutput.unwrap());
   }
   splitRange(lower, upper, upperBound, o) {
     let numElems = upper - lower;
@@ -71285,17 +71893,17 @@ var __defProp3, __export3 = (target, all) => {
     this.subscription.close();
   }
 }, nip98_exports2, _authorizationScheme3 = "Nostr ";
-var init_esm5 = __esm(() => {
+var init_esm6 = __esm(() => {
   init_secp256k12();
   init_utils16();
   init_sha2564();
   init_utils16();
   init_utils16();
-  init_esm4();
+  init_esm5();
   init_utils16();
   init_secp256k12();
   init_aes3();
-  init_esm4();
+  init_esm5();
   init_utils16();
   init_sha2564();
   init_chacha2();
@@ -71305,13 +71913,13 @@ var init_esm5 = __esm(() => {
   init_hmac6();
   init_sha2564();
   init_utils16();
-  init_esm4();
-  init_esm4();
+  init_esm5();
+  init_esm5();
   init_utils17();
   init_sha2564();
   init_sha2564();
   init_utils16();
-  init_esm4();
+  init_esm5();
   __defProp3 = Object.defineProperty;
   verifiedSymbol6 = Symbol("verified");
   utils_exports2 = {};
@@ -71319,8 +71927,8 @@ var init_esm5 = __esm(() => {
     Queue: () => Queue2,
     QueueNode: () => QueueNode2,
     binarySearch: () => binarySearch3,
-    bytesToHex: () => bytesToHex13,
-    hexToBytes: () => hexToBytes11,
+    bytesToHex: () => bytesToHex14,
+    hexToBytes: () => hexToBytes12,
     insertEventIntoAscendingList: () => insertEventIntoAscendingList3,
     insertEventIntoDescendingList: () => insertEventIntoDescendingList3,
     normalizeURL: () => normalizeURL3,
@@ -71685,20 +72293,20 @@ function serializeEvent5(evt) {
 }
 function getEventHash5(event3) {
   let eventHash = sha2569(utf8Encoder6.encode(serializeEvent5(event3)));
-  return bytesToHex13(eventHash);
+  return bytesToHex14(eventHash);
 }
 var verifiedSymbol7, isRecord5 = (obj2) => obj2 instanceof Object, utf8Decoder6, utf8Encoder6, JS5 = class {
   generateSecretKey() {
     return schnorr4.utils.randomPrivateKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex13(schnorr4.getPublicKey(secretKey));
+    return bytesToHex14(schnorr4.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event3 = t;
-    event3.pubkey = bytesToHex13(schnorr4.getPublicKey(secretKey));
+    event3.pubkey = bytesToHex14(schnorr4.getPublicKey(secretKey));
     event3.id = getEventHash5(event3);
-    event3.sig = bytesToHex13(schnorr4.sign(getEventHash5(event3), secretKey));
+    event3.sig = bytesToHex14(schnorr4.sign(getEventHash5(event3), secretKey));
     event3[verifiedSymbol7] = true;
     return event3;
   }
@@ -71824,7 +72432,7 @@ function getReplaceableIdentifier2(event3) {
 }
 var EventStoreSymbol2, EventUIDSymbol2, ReplaceableAddressSymbol2, FromCacheSymbol2, ReplaceableIdentifierSymbol2;
 var init_event3 = __esm(() => {
-  init_esm5();
+  init_esm6();
   init_kinds2();
   init_utils18();
   EventStoreSymbol2 = Symbol.for("event-store");
@@ -71906,7 +72514,7 @@ var processTags2 = (tags3, ...fns) => {
 
 // node_modules/applesauce-sqlite/node_modules/applesauce-core/node_modules/nostr-tools/lib/esm/nip19.js
 function npubEncode4(hex7) {
-  return encodeBytes3("npub", hexToBytes11(hex7));
+  return encodeBytes3("npub", hexToBytes12(hex7));
 }
 function encodeBech323(prefix, data) {
   let words = bech324.toWords(data);
@@ -71917,7 +72525,7 @@ function encodeBytes3(prefix, bytes9) {
 }
 function nprofileEncode3(profile3) {
   let data = encodeTLV3({
-    0: [hexToBytes11(profile3.pubkey)],
+    0: [hexToBytes12(profile3.pubkey)],
     1: (profile3.relays || []).map((url3) => utf8Encoder8.encode(url3))
   });
   return encodeBech323("nprofile", data);
@@ -71938,7 +72546,7 @@ function encodeTLV3(tlv) {
 var utf8Decoder8, utf8Encoder8, Bech32MaxSize3 = 5000;
 var init_nip19 = __esm(() => {
   init_utils16();
-  init_esm4();
+  init_esm5();
   init_utils16();
   utf8Decoder8 = new TextDecoder("utf-8");
   utf8Encoder8 = new TextEncoder;
@@ -74614,7 +75222,7 @@ var init_models3 = __esm(() => {
 
 // node_modules/applesauce-sqlite/node_modules/applesauce-core/dist/operations/client.js
 var NEVER_ATTACH_CLIENT_TAG2;
-var init_client5 = __esm(() => {
+var init_client6 = __esm(() => {
   init_event3();
   init_pointers2();
   init_tags2();
@@ -74628,7 +75236,7 @@ var init_hidden_content4 = __esm(() => {
 
 // node_modules/applesauce-sqlite/node_modules/applesauce-core/dist/operations/index.js
 var init_operations2 = __esm(() => {
-  init_client5();
+  init_client6();
   init_content5();
   init_encrypted_content5();
   init_event4();
@@ -90915,49 +91523,6 @@ var ModelManager = class _ModelManager {
     }
   }
 };
-var AuditLogger = class _AuditLogger {
-  static instance = null;
-  static getInstance() {
-    if (!_AuditLogger.instance) {
-      _AuditLogger.instance = new _AuditLogger;
-    }
-    return _AuditLogger.instance;
-  }
-  async log(entry) {
-    const fullEntry = {
-      ...entry,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const logLine = JSON.stringify(fullEntry) + `
-`;
-    if (typeof window === "undefined") {
-      try {
-        const fs = await import("fs");
-        const path2 = await import("path");
-        const logPath = path2.join(process.cwd(), "audit.log");
-        fs.appendFileSync(logPath, logLine);
-      } catch (error53) {
-        console.error("[AuditLogger] Failed to write to file:", error53);
-      }
-    } else {
-      console.log("[AUDIT]", logLine.trim());
-    }
-  }
-  async logBalanceSnapshot(action, amounts, options) {
-    await this.log({
-      action,
-      totalBalance: amounts.totalBalance,
-      providerBalances: amounts.providerBalances,
-      mintBalances: amounts.mintBalances,
-      amount: options?.amount,
-      mintUrl: options?.mintUrl,
-      baseUrl: options?.baseUrl,
-      status: options?.status ?? "success",
-      details: options?.details
-    });
-  }
-};
-var auditLogger = AuditLogger.getInstance();
 function isNetworkErrorMessage(message) {
   return message.includes("NetworkError when attempting to fetch resource") || message.includes("Failed to fetch") || message.includes("Load failed") || message.includes("Unable to connect") || message.includes("Was there a typo in the url or port") || message.includes("ERR_TLS_CERT_ALTNAME_INVALID") || message.includes("ERR_TLS_CERT_NOT_YET_VALID") || message.includes("ERR_TLS_CERT_EXPIRED") || message.includes("UNABLE_TO_VERIFY_LEAF_SIGNATURE") || message.includes("SELF_SIGNED_CERT_IN_CHAIN");
 }
@@ -90992,7 +91557,7 @@ var CashuSpender = class _CashuSpender {
   debugLevel = "WARN";
   logger;
   static MAX_REFUND_RETRIES = 3;
-  static REFUND_RETRY_INTERVAL_MS = 120000;
+  static REFUND_RETRY_INTERVAL_MS = 2 * 60 * 1000;
   _refundRetryInterval = null;
   async receiveToken(token) {
     try {
@@ -91060,10 +91625,6 @@ var CashuSpender = class _CashuSpender {
       mintBalances: normalizedMintBalances
     };
   }
-  async _logTransaction(action, options) {
-    const balanceState = await this._getBalanceState();
-    await auditLogger.logBalanceSnapshot(action, balanceState, options);
-  }
   get isBusy() {
     return this._isBusy;
   }
@@ -91212,12 +91773,6 @@ var CashuSpender = class _CashuSpender {
     if (token) {
       this._log("DEBUG", `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`);
     }
-    this._logTransaction("spend", {
-      amount: spentAmount,
-      mintUrl: selectedMintUrl || mintUrl,
-      baseUrl,
-      status: "success"
-    });
     this._log("DEBUG", `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`);
     const units = this.walletAdapter.getMintUnits();
     return {
@@ -91258,12 +91813,6 @@ var CashuSpender = class _CashuSpender {
         const newBalance = balanceForBaseUrl + topUpResult.toppedUpAmount;
         const units = this.walletAdapter.getMintUnits();
         const unit = units[mintUrl] || "sat";
-        this._logTransaction("topup", {
-          amount: topUpResult.toppedUpAmount,
-          mintUrl,
-          baseUrl,
-          status: "success"
-        });
         return {
           token: apiKeyEntry.key,
           status: "success",
@@ -91620,7 +92169,7 @@ var BalanceManager = class _BalanceManager {
     if (!forceRefund) {
       const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
       if (apiKeyEntry?.lastUsed) {
-        const fiveMinutesAgo = Date.now() - 300000;
+        const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
         if (apiKeyEntry.lastUsed > fiveMinutesAgo) {
           this.logger.log(`refundApiKey: skipping ${baseUrl} - used ${Math.round((Date.now() - apiKeyEntry.lastUsed) / 1000)}s ago`);
           return {
@@ -92274,13 +92823,18 @@ var isOnionUrl = (url3) => {
     return trimmed.includes(TOR_ONION_SUFFIX);
   }
 };
-var USER_CACHE_SECRET_FIELD2 = "user_cache_secret";
-var USER_CACHE_SECRET_ENV2 = "TINFOIL_USER_CACHE_SECRET";
-var USER_CACHE_SECRET_PATHS2 = [
+var OPENAI_JSON_BODY_PATHS = [
   "/chat/completions",
   "/completions",
   "/responses"
 ];
+function isOpenAiJsonBodyPath(pathname) {
+  const path2 = (pathname.split("?")[0] ?? "").replace(/\/+$/, "");
+  return OPENAI_JSON_BODY_PATHS.some((suffix) => path2.endsWith(suffix));
+}
+var USER_CACHE_SECRET_FIELD2 = "user_cache_secret";
+var USER_CACHE_SECRET_ENV2 = "TINFOIL_USER_CACHE_SECRET";
+var USER_CACHE_SECRET_PATHS2 = OPENAI_JSON_BODY_PATHS;
 var USER_CACHE_SECRET_DIR_NAME2 = ".tinfoil";
 var USER_CACHE_SECRET_FILE_NAME2 = "user_cache_secret";
 function newUserCacheSecret2() {
@@ -92657,7 +93211,7 @@ async function isEhbpKeyConfigMismatchResponse(response, protocol) {
   }
 }
 async function fetchTinfoilEhbpOnce(context, options, normalized, ehbp, userCacheSecret) {
-  const { Identity: Identity3, PROTOCOL: PROTOCOL2, decryptResponseWithToken: decryptResponseWithToken2, extractSessionRecoveryToken: extractSessionRecoveryToken2 } = ehbp;
+  const { Identity: Identity4, PROTOCOL: PROTOCOL3, decryptResponseWithToken: decryptResponseWithToken3, extractSessionRecoveryToken: extractSessionRecoveryToken3 } = ehbp;
   const resolved = resolveOptions(options);
   const baseURL = context.client.getBaseURL() ?? resolved.baseUrl;
   const enclaveURL = context.client.getEnclaveURL();
@@ -92685,7 +93239,7 @@ async function fetchTinfoilEhbpOnce(context, options, normalized, ehbp, userCach
       }
     }
   }
-  const serverIdentity = await Identity3.fromPublicKeyHex(context.verification.hpkePublicKey);
+  const serverIdentity = await Identity4.fromPublicKeyHex(context.verification.hpkePublicKey);
   const request = new Request(targetUrl.toString(), {
     method,
     headers,
@@ -92700,18 +93254,18 @@ async function fetchTinfoilEhbpOnce(context, options, normalized, ehbp, userCach
   if (!requestContext) {
     return response;
   }
-  if (await isEhbpKeyConfigMismatchResponse(response, PROTOCOL2)) {
+  if (await isEhbpKeyConfigMismatchResponse(response, PROTOCOL3)) {
     throw new ehbp.KeyConfigMismatchError("EHBP key configuration mismatch");
   }
-  if (!response.headers.get(PROTOCOL2.RESPONSE_NONCE_HEADER)) {
+  if (!response.headers.get(PROTOCOL3.RESPONSE_NONCE_HEADER)) {
     return response;
   }
-  const token = await extractSessionRecoveryToken2(requestContext);
-  return await decryptResponseWithToken2(response, token);
+  const token = await extractSessionRecoveryToken3(requestContext);
+  return await decryptResponseWithToken3(response, token);
 }
 async function fetchTinfoilPreservingPlaintextErrors(options, input, init) {
   const context = await prepareTinfoilClient(options);
-  const ehbp = await Promise.resolve().then(() => (init_esm3(), exports_esm));
+  const ehbp = await Promise.resolve().then(() => (init_esm4(), exports_esm));
   const normalized = normalizeFetchArgs(input, init);
   const userCacheSecret = await resolveUserCacheSecret2({
     explicit: options.userCacheSecret,
@@ -92826,6 +93380,10 @@ function getImageResolutionFromDataUrl(dataUrl) {
 function calculateImageTokens(width, height, detail = "auto") {
   if (detail === "low")
     return 85;
+  if (detail === "original") {
+    const patches = Math.ceil(width / IMAGE_PATCH_PX) * Math.ceil(height / IMAGE_PATCH_PX);
+    return Math.ceil(Math.min(patches, MAX_IMAGE_PATCHES) * 1.2);
+  }
   let w2 = width;
   let h2 = height;
   if (w2 > 2048 || h2 > 2048) {
@@ -92853,6 +93411,238 @@ function calculateImageTokens(width, height, detail = "auto") {
   const numTiles = tilesWidth * tilesHeight;
   return 85 + 170 * numTiles;
 }
+var IMAGE_PATCH_PX = 32;
+var MAX_IMAGE_PATCHES = 30000;
+var MAX_TILED_IMAGE_TOKENS = 765;
+var MAX_ORIGINAL_IMAGE_TOKENS = Math.ceil(MAX_IMAGE_PATCHES * 1.2);
+function worstCaseImageTokensForDetail(detail) {
+  if (detail === "low")
+    return 85;
+  if (detail === "original")
+    return MAX_ORIGINAL_IMAGE_TOKENS;
+  return MAX_TILED_IMAGE_TOKENS;
+}
+function estimateImageTokensForUrl(url3, detail) {
+  if (!url3 || typeof url3 !== "string")
+    return 0;
+  if (url3.startsWith("data:")) {
+    const res = getImageResolutionFromDataUrl(url3);
+    if (res) {
+      return calculateImageTokens(res.width, res.height, detail);
+    }
+    return worstCaseImageTokensForDetail(detail);
+  }
+  return worstCaseImageTokensForDetail(detail);
+}
+function estimateInputImageTokens(item) {
+  const detail = typeof item?.detail === "string" && item?.detail ? item.detail : "auto";
+  const url3 = typeof item?.image_url === "string" ? item.image_url : item?.image_url?.url;
+  const fromUrl = estimateImageTokensForUrl(url3, detail);
+  if (fromUrl > 0 || !item?.file_id)
+    return fromUrl;
+  return worstCaseImageTokensForDetail(detail);
+}
+function countImageTokensInMessages(apiMessages) {
+  let total = 0;
+  for (const msg of apiMessages ?? []) {
+    const content2 = msg?.content;
+    if (!Array.isArray(content2))
+      continue;
+    for (const part of content2) {
+      if (!part || typeof part !== "object")
+        continue;
+      if (part.type === "image_url") {
+        const detail = typeof part.image_url?.detail === "string" && part.image_url?.detail ? part.image_url.detail : "auto";
+        const url3 = typeof part.image_url === "string" ? part.image_url : part.image_url?.url;
+        total += estimateImageTokensForUrl(url3, detail);
+      } else if (part.type === "input_image") {
+        total += estimateInputImageTokens(part);
+      }
+    }
+  }
+  return total;
+}
+function countImageTokensInResponsesInput(input) {
+  if (!Array.isArray(input))
+    return 0;
+  let total = 0;
+  for (const item of input) {
+    if (!item || typeof item !== "object")
+      continue;
+    if (item.type === "input_image") {
+      total += estimateInputImageTokens(item);
+      continue;
+    }
+    if (Array.isArray(item.content)) {
+      for (const part of item.content) {
+        if (part && typeof part === "object" && part.type === "input_image") {
+          total += estimateInputImageTokens(part);
+        }
+      }
+    }
+  }
+  return total;
+}
+function safeStringifyCompact(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}
+function textLength(value) {
+  if (typeof value === "string")
+    return value.length;
+  if (value !== null && typeof value === "object") {
+    return safeStringifyCompact(value)?.length ?? 0;
+  }
+  return 0;
+}
+function countMessageTextChars(apiMessages) {
+  let total = 0;
+  for (const msg of apiMessages ?? []) {
+    if (!msg || typeof msg !== "object")
+      continue;
+    const content2 = msg.content;
+    if (typeof content2 === "string") {
+      total += content2.length;
+    } else if (Array.isArray(content2)) {
+      for (const part of content2) {
+        if (part && typeof part === "object" && part.type === "text") {
+          total += textLength(part.text);
+        }
+      }
+    }
+    const toolCalls = msg.tool_calls;
+    if (Array.isArray(toolCalls)) {
+      for (const call of toolCalls) {
+        const fn = call?.function;
+        if (!fn || typeof fn !== "object")
+          continue;
+        total += textLength(fn.name);
+        total += textLength(fn.arguments);
+      }
+    }
+  }
+  return total;
+}
+function countResponsesInputTextChars(input) {
+  if (!Array.isArray(input))
+    return 0;
+  let total = 0;
+  for (const item of input) {
+    if (!item || typeof item !== "object")
+      continue;
+    const itemType = item.type;
+    if (itemType === "input_text") {
+      total += textLength(item.text);
+      continue;
+    }
+    if (itemType === "function_call") {
+      total += textLength(item.arguments);
+      continue;
+    }
+    if (itemType === "function_call_output") {
+      total += textLength(item.output);
+      continue;
+    }
+    if (itemType === "reasoning") {
+      const summary = item.summary;
+      if (Array.isArray(summary)) {
+        for (const part of summary) {
+          if (part && typeof part === "object") {
+            total += textLength(part.text);
+          }
+        }
+      }
+    }
+    const content2 = item.content;
+    if (typeof content2 === "string") {
+      total += content2.length;
+    } else if (Array.isArray(content2)) {
+      for (const part of content2) {
+        if (!part || typeof part !== "object")
+          continue;
+        total += textLength(part.text);
+        if (typeof part.refusal === "string") {
+          total += part.refusal.length;
+        }
+      }
+    }
+  }
+  return total;
+}
+var NODE_TOLERANCE_PERCENT = 1;
+function sumStringChars(node) {
+  if (typeof node === "string")
+    return node.length;
+  if (Array.isArray(node)) {
+    return node.reduce((total, item) => total + sumStringChars(item), 0);
+  }
+  if (node && typeof node === "object") {
+    let total = 0;
+    for (const [key, value] of Object.entries(node)) {
+      total += key.length + sumStringChars(value);
+    }
+    return total;
+  }
+  return 0;
+}
+function countPromptTokenIds(node) {
+  if (typeof node === "number" && Number.isInteger(node))
+    return 1;
+  if (Array.isArray(node)) {
+    return node.reduce((total, item) => total + countPromptTokenIds(item), 0);
+  }
+  return 0;
+}
+function estimateNodePromptTokens(body) {
+  return Math.floor(sumStringChars(body) / 3) + countPromptTokenIds(body?.prompt);
+}
+function nodeGateSats(model2, satsPricing, requestBody, imageTokens) {
+  const maxCost = satsPricing?.max_cost;
+  if (typeof maxCost !== "number" || !Number.isFinite(maxCost))
+    return 0;
+  const toleranceFactor = 1 - NODE_TOLERANCE_PERCENT / 100;
+  const promptPrice = typeof satsPricing.prompt === "number" ? satsPricing.prompt : 0;
+  const completionPrice = typeof satsPricing.completion === "number" ? satsPricing.completion : 0;
+  let gateMsats = Math.max(1, Math.floor(maxCost * 1000 * toleranceFactor));
+  let promptAllowanceSats = typeof satsPricing.max_prompt_cost === "number" ? satsPricing.max_prompt_cost * toleranceFactor : 0;
+  const topProvider = model2?.top_provider;
+  const providerContextLength = topProvider?.context_length;
+  const providerMaxCompletion = topProvider?.max_completion_tokens;
+  let promptTokenLimit;
+  if (topProvider && (providerContextLength || providerMaxCompletion)) {
+    if (providerContextLength && providerMaxCompletion) {
+      promptTokenLimit = Math.max(0, providerContextLength - providerMaxCompletion);
+    } else if (providerContextLength) {
+      promptTokenLimit = providerContextLength;
+    } else {
+      promptTokenLimit = 0;
+    }
+  } else if (model2?.context_length) {
+    promptTokenLimit = model2.context_length;
+  }
+  if (promptTokenLimit !== undefined) {
+    promptAllowanceSats = promptTokenLimit * promptPrice * toleranceFactor;
+  }
+  const promptTokens = estimateNodePromptTokens(requestBody) + (Array.isArray(requestBody?.messages) ? imageTokens : 0);
+  if (promptTokens > 0) {
+    const unusedPromptBudget = promptAllowanceSats - promptTokens * promptPrice;
+    if (unusedPromptBudget > 0) {
+      gateMsats -= Math.floor(unusedPromptBudget * 1000);
+    }
+  }
+  const rawMaxTokens = requestBody?.max_tokens;
+  const parsedMaxTokens = typeof rawMaxTokens === "number" ? rawMaxTokens : typeof rawMaxTokens === "string" && rawMaxTokens.trim() !== "" ? Number(rawMaxTokens) : NaN;
+  if (Number.isFinite(parsedMaxTokens) && parsedMaxTokens > 0 && typeof satsPricing?.max_completion_cost === "number" && completionPrice > 0 && !isTinfoilModel(model2.id)) {
+    const unusedCompletionBudget = satsPricing.max_completion_cost * toleranceFactor - parsedMaxTokens * completionPrice;
+    if (unusedCompletionBudget > 0) {
+      gateMsats -= Math.floor(unusedCompletionBudget * 1000);
+    }
+  }
+  return Math.max(gateMsats, 1) / 1000;
+}
 var ProviderManager = class _ProviderManager {
   constructor(discoveryAdapter, store, logger3) {
     this.discoveryAdapter = discoveryAdapter;
@@ -93095,35 +93885,45 @@ ${ranking}`);
     }
     return providerMints.includes(mintUrl);
   }
-  getRequiredSatsForModel(model2, apiMessages, maxTokens) {
+  getRequiredSatsForModel(model2, apiMessages, maxTokens, requestBody) {
     try {
+      const body = requestBody ?? {};
       let imageTokens = 0;
-      if (apiMessages) {
-        for (const msg of apiMessages) {
-          const content2 = msg?.content;
-          if (Array.isArray(content2)) {
-            for (const part of content2) {
-              const isImage = part && typeof part === "object" && part.type === "image_url";
-              const url3 = isImage ? typeof part.image_url === "string" ? part.image_url : part.image_url?.url : undefined;
-              if (url3 && typeof url3 === "string" && url3.startsWith("data:")) {
-                const res = getImageResolutionFromDataUrl(url3);
-                if (res) {
-                  const tokensFromImage = calculateImageTokens(res.width, res.height);
-                  imageTokens += tokensFromImage;
-                } else {}
-              }
-            }
-          }
+      let textChars = 0;
+      let sawPromptShape = false;
+      let textEstimateUnknown = false;
+      if (Array.isArray(apiMessages) && apiMessages.length > 0) {
+        sawPromptShape = true;
+        imageTokens += countImageTokensInMessages(apiMessages);
+        textChars += countMessageTextChars(apiMessages);
+      }
+      const responsesInput = body.input;
+      if (!sawPromptShape) {
+        if (Array.isArray(responsesInput)) {
+          sawPromptShape = true;
+          imageTokens += countImageTokensInResponsesInput(responsesInput);
+          textChars += countResponsesInputTextChars(responsesInput);
+        } else if (typeof responsesInput === "string") {
+          sawPromptShape = true;
+          textChars += responsesInput.length;
+        }
+      }
+      const instructions = body.instructions;
+      if (typeof instructions === "string" && instructions) {
+        sawPromptShape = true;
+        textChars += instructions.length;
+      }
+      const tools = body.tools;
+      if (Array.isArray(tools) && tools.length > 0) {
+        sawPromptShape = true;
+        const serialized = safeStringifyCompact(tools);
+        if (serialized === null) {
+          textEstimateUnknown = true;
+        } else {
+          textChars += serialized.length;
         }
       }
-      const apiMessagesNoImages = apiMessages ? apiMessages.map((m) => {
-        if (Array.isArray(m?.content)) {
-          const filtered = m.content.filter((p) => !(p && typeof p === "object" && p.type === "image_url"));
-          return { ...m, content: filtered };
-        }
-        return m;
-      }) : undefined;
-      const approximateTokens = apiMessagesNoImages ? Math.ceil(JSON.stringify(apiMessagesNoImages, null, 2).length / 2.84) : 1e4;
+      const approximateTokens = textEstimateUnknown ? 1e4 : sawPromptShape ? Math.ceil(textChars / 2.84) : 1e4;
       const totalInputTokens = approximateTokens + imageTokens;
       const sp = model2?.sats_pricing;
       if (!sp) {
@@ -93138,11 +93938,17 @@ ${ranking}`);
       if (maxTokens !== undefined && sp.completion && !isTinfoilModel(model2.id)) {
         completionCost = sp.completion * maxTokens;
       }
-      const totalEstimatedCosts = (promptCosts + completionCost + requestFee) * 1.05;
+      const componentEstimate = (promptCosts + completionCost + requestFee) * 1.05;
+      const gateEstimate = nodeGateSats(model2, sp, body, imageTokens) * 1.05;
+      let totalEstimatedCosts = Math.max(componentEstimate, gateEstimate);
+      if (typeof sp.max_cost === "number" && totalEstimatedCosts > sp.max_cost) {
+        return sp.max_cost;
+      }
       return totalEstimatedCosts;
     } catch (e13) {
       this.logger.error("getRequiredSatsForModel error:", e13);
-      return 0;
+      const sp = model2?.sats_pricing;
+      return sp?.max_cost ?? 50;
     }
   }
 };
@@ -94556,7 +95362,6 @@ var RoutstrClient = class {
       const satsSpent = await this._handlePostResponseBalanceUpdate({
         token: prepared.tokenUsed,
         baseUrl: prepared.baseUrlUsed,
-        mintUrl: params.mintUrl,
         initialTokenBalance: prepared.tokenBalanceInSats,
         initialTokenBalanceUnknown: prepared.tokenBalanceUnknown,
         fallbackSatsSpent: usage?.satsCost,
@@ -94612,17 +95417,22 @@ var RoutstrClient = class {
           messageCount: requestMessages.length,
           maxTokens: requestMaxTokens
         });
-        requiredSats = this.providerManager.getRequiredSatsForModel(selectedModel, requestMessages, requestMaxTokens);
+        requiredSats = this.providerManager.getRequiredSatsForModel(selectedModel, requestMessages, requestMaxTokens, requestBodyForPricing);
       }
     }
     let requestBody = body;
     if (body && typeof body === "object") {
       const bodyObj = body;
-      if (!bodyObj.stream) {
+      if (isOpenAiJsonBodyPath(requestPath) && !bodyObj.stream) {
         requestBody = { ...bodyObj, stream: false };
       }
     }
     const baseHeaders = this._buildBaseHeaders();
+    for (const [name16, value] of Object.entries(headers)) {
+      if (name16.toLowerCase() === "x-routstr-model-path") {
+        baseHeaders["x-routstr-model-path"] = value;
+      }
+    }
     const tinfoilEnabled = Boolean(modelId && isTinfoilModel(modelId));
     if (tinfoilEnabled) {
       this._log("DEBUG", `[RoutstrClient] Attesting Tinfoil model ${modelId} before spend`);
@@ -95128,7 +95938,7 @@ var RoutstrClient = class {
       this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: Failing over to next provider: ${nextProvider}, model: ${selectedModel.id}`);
       const newModel = await this.providerManager.getModelForProvider(nextProvider, selectedModel.id) ?? selectedModel;
       const messagesForPricing = Array.isArray(body?.messages) ? body.messages : [];
-      const newRequiredSats = this.providerManager.getRequiredSatsForModel(newModel, messagesForPricing, params.maxTokens);
+      const newRequiredSats = this.providerManager.getRequiredSatsForModel(newModel, messagesForPricing, params.maxTokens, body && typeof body === "object" ? body : undefined);
       if (params.tinfoilEnabled) {
         this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: Attesting Tinfoil failover provider ${nextProvider} before spend`);
         await prepareTinfoilClient({ baseUrl: nextProvider });
@@ -95253,7 +96063,6 @@ var RoutstrClient = class {
     const {
       token,
       baseUrl,
-      mintUrl,
       initialTokenBalance,
       initialTokenBalanceUnknown,
       fallbackSatsSpent,
@@ -95812,6 +96621,20 @@ function makeConsoleLogger2(prefix) {
   };
 }
 var consoleLogger2 = makeConsoleLogger2();
+var InsufficientBalanceError2 = class extends Error {
+  constructor(required2, available, maxMintBalance = 0, maxMintUrl = "", customMessage) {
+    super(customMessage ?? `Insufficient balance: need ${required2} sats, have ${available} sats available. ` + (maxMintBalance > 0 ? `Largest mint balance: ${maxMintBalance} sats from ${maxMintUrl}` : ""));
+    this.required = required2;
+    this.available = available;
+    this.maxMintBalance = maxMintBalance;
+    this.maxMintUrl = maxMintUrl;
+    this.name = "InsufficientBalanceError";
+  }
+  required;
+  available;
+  maxMintBalance;
+  maxMintUrl;
+};
 var ProviderBootstrapError2 = class extends Error {
   constructor(failedProviders, message) {
     super(message || `Failed to bootstrap providers. Tried: ${failedProviders.join(", ")}`);
@@ -95826,6 +96649,47 @@ var NoProvidersAvailableError2 = class extends Error {
     this.name = "NoProvidersAvailableError";
   }
 };
+var CoreErrorType2 = {
+  TOKEN_ALREADY_SPENT: "token_already_spent",
+  INVALID_TOKEN: "invalid_token",
+  MINT_ERROR: "mint_error",
+  MINT_UNREACHABLE: "mint_unreachable",
+  CASHU_ERROR: "cashu_error",
+  INSUFFICIENT_QUOTA: "insufficient_quota",
+  MINIMUM_BALANCE_REQUIRED: "minimum_balance_required",
+  TOKEN_CONSUMED: "token_consumed",
+  API_ERROR: "api_error",
+  PAYMENT_ERROR: "payment_error"
+};
+var CoreErrorCode2 = {
+  TOKEN_ALREADY_SPENT: "cashu_token_already_spent",
+  INVALID_CASHU_TOKEN: "invalid_cashu_token",
+  CASHU_TOKEN_SWAP_FEES_EXCEED_AMOUNT: "cashu_token_swap_fees_exceed_amount",
+  CASHU_FOREIGN_MINT_SWAP_FAILED: "cashu_foreign_mint_swap_failed",
+  CASHU_MINT_UNREACHABLE: "cashu_mint_unreachable",
+  CASHU_TOKEN_REDEMPTION_FAILED: "cashu_token_redemption_failed",
+  CASHU_TOKEN_ZERO_VALUE: "cashu_token_zero_value",
+  CASHU_TOKEN_CONSUMED: "cashu_token_consumed",
+  INTERNAL_ERROR: "internal_error",
+  INVALID_API_KEY: "invalid_api_key",
+  INSUFFICIENT_BALANCE: "insufficient_balance",
+  BALANCE_LIMIT_EXCEEDED: "balance_limit_exceeded"
+};
+function isInvalidTokenError2(parsed) {
+  return parsed.type === CoreErrorType2.INVALID_TOKEN && parsed.code === CoreErrorCode2.INVALID_CASHU_TOKEN;
+}
+function isCashuRedemptionError2(parsed) {
+  return parsed.type === CoreErrorType2.CASHU_ERROR && (parsed.code === CoreErrorCode2.CASHU_TOKEN_REDEMPTION_FAILED || parsed.code === CoreErrorCode2.CASHU_TOKEN_ZERO_VALUE);
+}
+function isTokenConsumedError2(parsed) {
+  return parsed.type === CoreErrorType2.TOKEN_CONSUMED && parsed.code === CoreErrorCode2.CASHU_TOKEN_CONSUMED;
+}
+function isCoreInternalError2(parsed) {
+  return parsed.type === CoreErrorType2.API_ERROR && parsed.code === CoreErrorCode2.INTERNAL_ERROR;
+}
+function isHandledRedemptionError2(parsed) {
+  return isInvalidTokenError2(parsed) || isCashuRedemptionError2(parsed) || isTokenConsumedError2(parsed) || isCoreInternalError2(parsed);
+}
 var DEFAULT_NOSTR_RELAYS2 = [
   "wss://relay.damus.io",
   "wss://nos.lol",
@@ -96549,49 +97413,535 @@ var ModelManager2 = class _ModelManager2 {
     }
   }
 };
-var AuditLogger2 = class _AuditLogger2 {
-  static instance = null;
-  static getInstance() {
-    if (!_AuditLogger2.instance) {
-      _AuditLogger2.instance = new _AuditLogger2;
+function isNetworkErrorMessage2(message) {
+  return message.includes("NetworkError when attempting to fetch resource") || message.includes("Failed to fetch") || message.includes("Load failed") || message.includes("Unable to connect") || message.includes("Was there a typo in the url or port") || message.includes("ERR_TLS_CERT_ALTNAME_INVALID") || message.includes("ERR_TLS_CERT_NOT_YET_VALID") || message.includes("ERR_TLS_CERT_EXPIRED") || message.includes("UNABLE_TO_VERIFY_LEAF_SIGNATURE") || message.includes("SELF_SIGNED_CERT_IN_CHAIN");
+}
+function getBalanceInSats2(balance, unit) {
+  return unit === "msat" ? balance / 1000 : balance;
+}
+var CashuSpender2 = class _CashuSpender2 {
+  constructor(walletAdapter, storageAdapter, _discoveryAdapter, balanceManager, logger5) {
+    this.walletAdapter = walletAdapter;
+    this.storageAdapter = storageAdapter;
+    this._discoveryAdapter = _discoveryAdapter;
+    this.balanceManager = balanceManager;
+    this.logger = (logger5 ?? consoleLogger2).child("CashuSpender");
+  }
+  walletAdapter;
+  storageAdapter;
+  _discoveryAdapter;
+  balanceManager;
+  _isBusy = false;
+  debugLevel = "WARN";
+  logger;
+  static MAX_REFUND_RETRIES = 3;
+  static REFUND_RETRY_INTERVAL_MS = 2 * 60 * 1000;
+  _refundRetryInterval = null;
+  async receiveToken(token) {
+    try {
+      const result = await this.walletAdapter.receiveToken(token);
+      return result;
+    } catch (error53) {
+      const errorMessage = error53 instanceof Error ? error53.message : String(error53);
+      if (errorMessage.includes("Failed to fetch mint")) {
+        const cachedTokens = this.storageAdapter.getCachedReceiveTokens();
+        const existingIndex = cachedTokens.findIndex((t) => t.token === token);
+        if (existingIndex === -1) {
+          const { amount: amount2, unit: unit2 } = this._decodeTokenAmount(token);
+          this.storageAdapter.setCachedReceiveTokens([
+            ...cachedTokens,
+            {
+              token,
+              amount: amount2,
+              unit: unit2,
+              createdAt: Date.now()
+            }
+          ]);
+        }
+      }
+      const { amount, unit } = this._decodeTokenAmount(token);
+      return { success: false, amount, unit, message: errorMessage };
     }
-    return _AuditLogger2.instance;
   }
-  async log(entry) {
-    const fullEntry = {
-      ...entry,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  _decodeTokenAmount(token) {
+    try {
+      const metadata = ur(token);
+      const unit = metadata.unit || "sat";
+      return { amount: metadata.amount, unit };
+    } catch {
+      return { amount: 0, unit: "sat" };
+    }
+  }
+  async _getBalanceState() {
+    if (this.balanceManager) {
+      return this.balanceManager.getBalanceState();
+    }
+    const mintBalances = await this.walletAdapter.getBalances();
+    const units = this.walletAdapter.getMintUnits();
+    let totalMintBalance = 0;
+    const normalizedMintBalances = {};
+    for (const url4 in mintBalances) {
+      const balance = mintBalances[url4];
+      const unit = units[url4];
+      const balanceInSats = getBalanceInSats2(balance, unit);
+      normalizedMintBalances[url4] = balanceInSats;
+      totalMintBalance += balanceInSats;
+    }
+    const providerBalances = {};
+    let totalProviderBalance = 0;
+    const apiKeys = this.storageAdapter.getAllApiKeys();
+    for (const apiKey of apiKeys) {
+      if (!providerBalances[apiKey.baseUrl]) {
+        providerBalances[apiKey.baseUrl] = 0;
+      }
+      providerBalances[apiKey.baseUrl] += apiKey.balance;
+      totalProviderBalance += apiKey.balance;
+    }
+    return {
+      totalBalance: totalMintBalance + totalProviderBalance,
+      providerBalances,
+      mintBalances: normalizedMintBalances
     };
-    const logLine = JSON.stringify(fullEntry) + `
-`;
-    if (typeof window === "undefined") {
+  }
+  get isBusy() {
+    return this._isBusy;
+  }
+  getDebugLevel() {
+    return this.debugLevel;
+  }
+  setDebugLevel(level) {
+    this.debugLevel = level;
+  }
+  _log(level, ...args) {
+    const levelPriority = {
+      DEBUG: 0,
+      WARN: 1,
+      ERROR: 2
+    };
+    if (levelPriority[level] >= levelPriority[this.debugLevel]) {
+      switch (level) {
+        case "DEBUG":
+          this.logger.log(...args);
+          break;
+        case "WARN":
+          this.logger.warn(...args);
+          break;
+        case "ERROR":
+          this.logger.error(...args);
+          break;
+      }
+    }
+  }
+  async spend(options) {
+    const {
+      mintUrl,
+      amount,
+      baseUrl,
+      reuseToken = false,
+      p2pkPubkey,
+      excludeMints = [],
+      retryCount = 0
+    } = options;
+    this._isBusy = true;
+    try {
+      const result = await this._spendInternal({
+        mintUrl,
+        amount,
+        baseUrl,
+        reuseToken,
+        p2pkPubkey,
+        excludeMints,
+        retryCount
+      });
+      if (result.status === "failed" || !result.token) {
+        const errorMsg = result.error || `Insufficient balance. Need ${amount} sats.`;
+        if (this._isNetworkError(errorMsg)) {
+          throw new Error(`Your mint ${mintUrl} is unreachable or is blocking your IP. Please try again later or switch mints.`);
+        }
+        if (result.errorDetails) {
+          throw new InsufficientBalanceError2(result.errorDetails.required, result.errorDetails.available, result.errorDetails.maxMintBalance, result.errorDetails.maxMintUrl);
+        }
+        throw new Error(errorMsg);
+      }
+      return result;
+    } finally {
+      this._isBusy = false;
+    }
+  }
+  _isNetworkError(message) {
+    return isNetworkErrorMessage2(message) || message.includes("Your mint") && message.includes("unreachable");
+  }
+  async _spendInternal(options) {
+    let {
+      mintUrl,
+      amount,
+      baseUrl,
+      reuseToken,
+      p2pkPubkey,
+      excludeMints,
+      retryCount
+    } = options;
+    this._log("DEBUG", `[CashuSpender] _spendInternal: amount=${amount}, mintUrl=${mintUrl}, baseUrl=${baseUrl}, reuseToken=${reuseToken}`);
+    let adjustedAmount = Math.ceil(amount);
+    if (!adjustedAmount || isNaN(adjustedAmount)) {
+      this._log("ERROR", `[CashuSpender] _spendInternal: Invalid amount: ${amount}`);
+      return {
+        token: null,
+        status: "failed",
+        balance: 0,
+        error: "Please enter a valid amount"
+      };
+    }
+    if (reuseToken && baseUrl) {
+      this._log("DEBUG", `[CashuSpender] _spendInternal: Attempting to reuse token for ${baseUrl}`);
+      const existingResult = await this._tryReuseToken(baseUrl, adjustedAmount, mintUrl);
+      if (existingResult) {
+        this._log("DEBUG", `[CashuSpender] _spendInternal: Successfully reused token, balance: ${existingResult.balance}`);
+        return existingResult;
+      }
+      this._log("DEBUG", `[CashuSpender] _spendInternal: Could not reuse token, will create new token`);
+    }
+    const balanceState = await this._getBalanceState();
+    const totalAvailableBalance = balanceState.totalBalance;
+    this._log("DEBUG", `[CashuSpender] _spendInternal: totalAvailableBalance=${totalAvailableBalance}, adjustedAmount=${adjustedAmount}`);
+    if (totalAvailableBalance < adjustedAmount) {
+      this._log("ERROR", `[CashuSpender] _spendInternal: Insufficient balance, have=${totalAvailableBalance}, need=${adjustedAmount}`);
+      return this._createInsufficientBalanceError(adjustedAmount, balanceState.mintBalances, totalAvailableBalance);
+    }
+    let token = null;
+    let selectedMintUrl;
+    let spentAmount = adjustedAmount;
+    if (this.balanceManager) {
+      const tokenResult = await this.balanceManager.createProviderToken({
+        mintUrl,
+        baseUrl,
+        amount: adjustedAmount,
+        p2pkPubkey,
+        excludeMints,
+        retryCount
+      });
+      if (!tokenResult.success || !tokenResult.token) {
+        if ((tokenResult.error || "").includes("Insufficient balance")) {
+          return this._createInsufficientBalanceError(adjustedAmount, balanceState.mintBalances, totalAvailableBalance);
+        }
+        return {
+          token: null,
+          status: "failed",
+          balance: 0,
+          error: tokenResult.error || "Failed to create token"
+        };
+      }
+      token = tokenResult.token;
+      selectedMintUrl = tokenResult.selectedMintUrl;
+      spentAmount = tokenResult.amountSpent || adjustedAmount;
+    } else {
       try {
-        const fs = await import("fs");
-        const path2 = await import("path");
-        const logPath = path2.join(process.cwd(), "audit.log");
-        fs.appendFileSync(logPath, logLine);
+        token = await this.walletAdapter.sendToken(mintUrl, adjustedAmount, p2pkPubkey);
+        selectedMintUrl = mintUrl;
       } catch (error53) {
-        console.error("[AuditLogger] Failed to write to file:", error53);
+        const errorMsg = error53 instanceof Error ? error53.message : String(error53);
+        return {
+          token: null,
+          status: "failed",
+          balance: 0,
+          error: `Error generating token: ${errorMsg}`
+        };
       }
-    } else {
-      console.log("[AUDIT]", logLine.trim());
     }
+    if (token) {
+      this._log("DEBUG", `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`);
+    }
+    this._log("DEBUG", `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`);
+    const units = this.walletAdapter.getMintUnits();
+    return {
+      token,
+      status: "success",
+      balance: spentAmount,
+      unit: (selectedMintUrl ? units[selectedMintUrl] : units[mintUrl]) || "sat",
+      selectedMintUrl: selectedMintUrl || mintUrl
+    };
   }
-  async logBalanceSnapshot(action, amounts, options) {
-    await this.log({
-      action,
-      totalBalance: amounts.totalBalance,
-      providerBalances: amounts.providerBalances,
-      mintBalances: amounts.mintBalances,
-      amount: options?.amount,
-      mintUrl: options?.mintUrl,
-      baseUrl: options?.baseUrl,
-      status: options?.status ?? "success",
-      details: options?.details
-    });
+  async _tryReuseToken(baseUrl, amount, mintUrl) {
+    const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+    if (!apiKeyEntry)
+      return null;
+    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+    const balanceForBaseUrl = apiKeyDistribution.find((b) => b.baseUrl === baseUrl)?.amount || 0;
+    this._log("DEBUG", "Reusing API key", balanceForBaseUrl, amount);
+    if (balanceForBaseUrl > amount) {
+      const units = this.walletAdapter.getMintUnits();
+      const unit = units[mintUrl] || "sat";
+      return {
+        token: apiKeyEntry.key,
+        status: "success",
+        balance: balanceForBaseUrl,
+        unit
+      };
+    }
+    if (this.balanceManager) {
+      const topUpAmount = Math.ceil(amount * 1.2 - balanceForBaseUrl);
+      const topUpResult = await this.balanceManager.topUp({
+        mintUrl,
+        baseUrl,
+        amount: topUpAmount,
+        token: apiKeyEntry.key
+      });
+      this._log("DEBUG", "TOPUP ", topUpResult);
+      if (topUpResult.success && topUpResult.toppedUpAmount) {
+        const newBalance = balanceForBaseUrl + topUpResult.toppedUpAmount;
+        const units = this.walletAdapter.getMintUnits();
+        const unit = units[mintUrl] || "sat";
+        return {
+          token: apiKeyEntry.key,
+          status: "success",
+          balance: newBalance,
+          unit
+        };
+      }
+      const providerBalance = await this._getProviderTokenBalance(baseUrl, apiKeyEntry.key);
+      this._log("DEBUG", providerBalance);
+      if (providerBalance <= 0) {
+        this.storageAdapter.removeApiKey(baseUrl);
+      }
+    }
+    return null;
+  }
+  async refundXcashuTokens(mintUrl, excludeBaseUrls) {
+    const results = [];
+    const xcashuTokens = this.storageAdapter.getXcashuTokens();
+    const excludedUrls = new Set(excludeBaseUrls || []);
+    for (const [baseUrl, tokens] of Object.entries(xcashuTokens)) {
+      if (excludedUrls.has(baseUrl))
+        continue;
+      for (const xcashuToken of tokens) {
+        try {
+          if (!this.balanceManager) {
+            throw new Error("BalanceManager not available for xcashu refund");
+          }
+          const fetchResult = await this.balanceManager.fetchRefundToken(baseUrl, xcashuToken.token, true);
+          if (!fetchResult.success && fetchResult.status === 425) {
+            results.push({
+              baseUrl,
+              token: xcashuToken.token,
+              success: false,
+              error: fetchResult.error
+            });
+            this._log("WARN", `[CashuSpender] refundXcashuTokens: 425 "Refund is pending" for ${baseUrl}; leaving token in store, tryCount untouched`);
+            continue;
+          }
+          if (!fetchResult.success && fetchResult.parsedError?.type === CoreErrorType2.TOKEN_ALREADY_SPENT) {
+            this.storageAdapter.removeXcashuToken(baseUrl, xcashuToken.token);
+            results.push({
+              baseUrl,
+              token: xcashuToken.token,
+              success: false,
+              error: fetchResult.error
+            });
+            this._log("WARN", `[CashuSpender] refundXcashuTokens: token_already_spent for ${baseUrl}; removing permanently-spent xcashu token from store`);
+            continue;
+          }
+          if (!fetchResult.success && fetchResult.parsedError && isHandledRedemptionError2(fetchResult.parsedError)) {
+            const directReceive = await this.receiveToken(xcashuToken.token);
+            if (directReceive.success) {
+              this.storageAdapter.removeXcashuToken(baseUrl, xcashuToken.token);
+              results.push({
+                baseUrl,
+                token: xcashuToken.token,
+                success: true
+              });
+              this._log("DEBUG", `[CashuSpender] refundXcashuTokens: provider returned ${fetchResult.parsedError.type}/${fetchResult.parsedError.code}; recovered original token directly, amount=${directReceive.amount}`);
+              continue;
+            }
+            this._log("WARN", `[CashuSpender] refundXcashuTokens: provider returned ${fetchResult.parsedError.type}/${fetchResult.parsedError.code}; direct original-token recovery also failed: ${directReceive.message ?? "unknown error"}`);
+          }
+          if (!fetchResult.success && fetchResult.status === 404 && (fetchResult.error || "").includes("Refund not found")) {
+            const currentTryCount = xcashuToken.tryCount ?? 0;
+            const newTryCount = currentTryCount + 1;
+            if (newTryCount >= _CashuSpender2.MAX_REFUND_RETRIES) {
+              this.storageAdapter.removeXcashuToken(baseUrl, xcashuToken.token);
+              this._log("WARN", `[CashuSpender] refundXcashuTokens: 404 "Refund not found" for ${baseUrl} after ${newTryCount} retries; removing unrefundable xcashu token from store`);
+            } else {
+              this.storageAdapter.updateXcashuTokenTryCount(xcashuToken.token, newTryCount);
+              this._log("WARN", `[CashuSpender] refundXcashuTokens: 404 "Refund not found" for ${baseUrl}; tryCount=${newTryCount}/${_CashuSpender2.MAX_REFUND_RETRIES}, will retry in ${_CashuSpender2.REFUND_RETRY_INTERVAL_MS / 1000}s`);
+              this._startRefundRetryInterval(mintUrl);
+            }
+            results.push({
+              baseUrl,
+              token: xcashuToken.token,
+              success: false,
+              error: fetchResult.error
+            });
+            continue;
+          }
+          if (!fetchResult.success || !fetchResult.token) {
+            throw new Error(fetchResult.error || "Failed to fetch refund token from provider");
+          }
+          const receiveResult = await this.receiveToken(fetchResult.token);
+          if (receiveResult.success) {
+            this.storageAdapter.removeXcashuToken(baseUrl, xcashuToken.token);
+            results.push({
+              baseUrl,
+              token: xcashuToken.token,
+              success: true
+            });
+            this._log("DEBUG", `[CashuSpender] refundXcashuTokens: Successfully refunded xcashu token for ${baseUrl}, amount=${receiveResult.amount}`);
+          } else {
+            const currentTryCount = xcashuToken.tryCount ?? 0;
+            const newTryCount = currentTryCount + 1;
+            this.storageAdapter.updateXcashuTokenTryCount(xcashuToken.token, newTryCount);
+            results.push({
+              baseUrl,
+              token: xcashuToken.token,
+              success: false,
+              error: receiveResult.message ?? "Refund failed"
+            });
+            this._log("DEBUG", `[CashuSpender] refundXcashuTokens: Failed to receive refund token for ${baseUrl}, incremented tryCount to ${newTryCount}: ${receiveResult.message}`);
+          }
+        } catch (error53) {
+          const currentTryCount = xcashuToken.tryCount ?? 0;
+          const newTryCount = currentTryCount + 1;
+          this.storageAdapter.updateXcashuTokenTryCount(xcashuToken.token, newTryCount);
+          const errorMessage = error53 instanceof Error ? error53.message : String(error53);
+          results.push({
+            baseUrl,
+            token: xcashuToken.token,
+            success: false,
+            error: errorMessage
+          });
+          this._log("ERROR", `[CashuSpender] refundXcashuTokens: Exception during refund for ${baseUrl}: ${errorMessage}, incremented tryCount to ${newTryCount}`);
+        }
+      }
+    }
+    return results;
+  }
+  _startRefundRetryInterval(mintUrl) {
+    if (this._refundRetryInterval)
+      return;
+    this._log("DEBUG", `[CashuSpender] Starting refund retry interval (every ${_CashuSpender2.REFUND_RETRY_INTERVAL_MS / 1000}s)`);
+    this._refundRetryInterval = setInterval(async () => {
+      const remainingTokens = this.storageAdapter.getXcashuTokens();
+      const hasTokens = Object.values(remainingTokens).some((tokens) => tokens.length > 0);
+      if (!hasTokens) {
+        this._stopRefundRetryInterval();
+        return;
+      }
+      try {
+        await this.refundXcashuTokens(mintUrl);
+      } catch (error53) {
+        this._log("ERROR", `[CashuSpender] Refund retry interval error: ${error53 instanceof Error ? error53.message : String(error53)}`);
+      }
+    }, _CashuSpender2.REFUND_RETRY_INTERVAL_MS);
+  }
+  _stopRefundRetryInterval() {
+    if (this._refundRetryInterval) {
+      clearInterval(this._refundRetryInterval);
+      this._refundRetryInterval = null;
+      this._log("DEBUG", `[CashuSpender] Stopped refund retry interval`);
+    }
+  }
+  async refundProviders(mintUrl, forceRefund) {
+    const results = [];
+    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+    for (const apiKeyEntry of apiKeyDistribution) {
+      const apiKeyEntryFull = this.storageAdapter.getApiKey(apiKeyEntry.baseUrl);
+      if (apiKeyEntryFull && this.balanceManager) {
+        try {
+          const balanceResult = await this.balanceManager.getTokenBalance(apiKeyEntryFull.key, apiKeyEntry.baseUrl);
+          if (balanceResult.isInvalidApiKey) {
+            this.logger.warn(`refundProviders: ${apiKeyEntry.baseUrl} returned invalid API key; removing local key and treating as success`);
+            this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
+            results.push({
+              baseUrl: apiKeyEntry.baseUrl,
+              success: true
+            });
+            continue;
+          }
+          if (balanceResult.amount >= 0 && !balanceResult.balanceUnknown) {
+            const balanceSat = balanceResult.unit === "msat" ? Math.floor(balanceResult.amount / 1000) : balanceResult.amount;
+            const reservedSat = balanceResult.unit === "msat" ? Math.floor(balanceResult.reserved / 1000) : balanceResult.reserved;
+            this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, balanceSat, reservedSat);
+          } else {
+            this.logger.warn(`refundProviders: balance refresh for ${apiKeyEntry.baseUrl} returned negative amount; keeping stale local balance=${apiKeyEntryFull.balance}`);
+          }
+        } catch (error53) {
+          this.logger.warn(`refundProviders: balance refresh threw for ${apiKeyEntry.baseUrl}; proceeding with stale local balance`, error53);
+        }
+        const refreshedEntry = this.storageAdapter.getApiKey(apiKeyEntry.baseUrl);
+        if (!refreshedEntry) {
+          continue;
+        }
+        const refundResult = await this.balanceManager.refundApiKey({
+          mintUrl,
+          baseUrl: apiKeyEntry.baseUrl,
+          apiKey: refreshedEntry.key,
+          forceRefund
+        });
+        if (refundResult.success) {
+          this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
+        } else {
+          const currentEntry = this.storageAdapter.getApiKey(apiKeyEntry.baseUrl);
+          this.logger.warn(`refundProviders: refund failed for ${apiKeyEntry.baseUrl}; currentEntry=${Boolean(currentEntry)} balance=${currentEntry?.balance ?? "none"}. Touching lastUsed to rate-limit retries.`);
+          if (currentEntry) {
+            this.storageAdapter.touchApiKeyLastUsed(apiKeyEntry.baseUrl);
+          }
+        }
+        results.push({
+          baseUrl: apiKeyEntry.baseUrl,
+          success: refundResult.success
+        });
+      } else {
+        this.logger.warn(`refundProviders: cannot refund ${apiKeyEntry.baseUrl}; apiKeyEntryFull=${Boolean(apiKeyEntryFull)} balanceManager=${Boolean(this.balanceManager)}`);
+        results.push({
+          baseUrl: apiKeyEntry.baseUrl,
+          success: false
+        });
+      }
+    }
+    return results;
+  }
+  _createInsufficientBalanceError(required2, normalizedBalances, availableBalance) {
+    let maxBalance = 0;
+    let maxMintUrl = "";
+    for (const mintUrl in normalizedBalances) {
+      const balanceInSats = normalizedBalances[mintUrl];
+      if (balanceInSats > maxBalance) {
+        maxBalance = balanceInSats;
+        maxMintUrl = mintUrl;
+      }
+    }
+    const error53 = new InsufficientBalanceError2(required2, availableBalance ?? maxBalance, maxBalance, maxMintUrl);
+    return {
+      token: null,
+      status: "failed",
+      balance: 0,
+      error: error53.message,
+      errorDetails: {
+        required: required2,
+        available: availableBalance ?? maxBalance,
+        maxMintBalance: maxBalance,
+        maxMintUrl
+      }
+    };
+  }
+  async _getProviderTokenBalance(baseUrl, token) {
+    try {
+      const response = await fetch(`${baseUrl}v1/wallet/info`, {
+        headers: {
+          Authorization: `Bearer ${token}`
+        }
+      });
+      if (response.ok) {
+        const data = await response.json();
+        return data.balance / 1000;
+      }
+    } catch {
+      return 0;
+    }
+    return 0;
   }
 };
-var auditLogger2 = AuditLogger2.getInstance();
+var MAX_IMAGE_PATCHES2 = 30000;
+var MAX_ORIGINAL_IMAGE_TOKENS2 = Math.ceil(MAX_IMAGE_PATCHES2 * 1.2);
 var createBunPersistentEventDatabase = async (dbPath) => {
   const { BunSqliteEventDatabase: BunSqliteEventDatabase2 } = await Promise.resolve().then(() => (init_bun(), exports_bun));
   return new BunSqliteEventDatabase2(dbPath);
@@ -100997,14 +102347,14 @@ __export(exports_utils4, {
   numberToBytesLE: () => numberToBytesLE6,
   numberToBytesBE: () => numberToBytesBE6,
   hexToNumber: () => hexToNumber6,
-  hexToBytes: () => hexToBytes13,
+  hexToBytes: () => hexToBytes14,
   equalBytes: () => equalBytes9,
   ensureBytes: () => ensureBytes5,
   createHmacDrbg: () => createHmacDrbg6,
   concatBytes: () => concatBytes15,
   bytesToNumberLE: () => bytesToNumberLE6,
   bytesToNumberBE: () => bytesToNumberBE6,
-  bytesToHex: () => bytesToHex15,
+  bytesToHex: () => bytesToHex16,
   bitSet: () => bitSet4,
   bitMask: () => bitMask6,
   bitLen: () => bitLen6,
@@ -101016,7 +102366,7 @@ var _1n29 = BigInt(1);
 var _2n23 = BigInt(2);
 var u8a11 = (a) => a instanceof Uint8Array;
 var hexes11 = /* @__PURE__ */ Array.from({ length: 256 }, (_3, i6) => i6.toString(16).padStart(2, "0"));
-function bytesToHex15(bytes10) {
+function bytesToHex16(bytes10) {
   if (!u8a11(bytes10))
     throw new Error("Uint8Array expected");
   let hex7 = "";
@@ -101034,7 +102384,7 @@ function hexToNumber6(hex7) {
     throw new Error("hex string expected, got " + typeof hex7);
   return BigInt(hex7 === "" ? "0" : `0x${hex7}`);
 }
-function hexToBytes13(hex7) {
+function hexToBytes14(hex7) {
   if (typeof hex7 !== "string")
     throw new Error("hex string expected, got " + typeof hex7);
   const len = hex7.length;
@@ -101052,27 +102402,27 @@ function hexToBytes13(hex7) {
   return array2;
 }
 function bytesToNumberBE6(bytes10) {
-  return hexToNumber6(bytesToHex15(bytes10));
+  return hexToNumber6(bytesToHex16(bytes10));
 }
 function bytesToNumberLE6(bytes10) {
   if (!u8a11(bytes10))
     throw new Error("Uint8Array expected");
-  return hexToNumber6(bytesToHex15(Uint8Array.from(bytes10).reverse()));
+  return hexToNumber6(bytesToHex16(Uint8Array.from(bytes10).reverse()));
 }
 function numberToBytesBE6(n, len) {
-  return hexToBytes13(n.toString(16).padStart(len * 2, "0"));
+  return hexToBytes14(n.toString(16).padStart(len * 2, "0"));
 }
 function numberToBytesLE6(n, len) {
   return numberToBytesBE6(n, len).reverse();
 }
 function numberToVarBytesBE4(n) {
-  return hexToBytes13(numberToHexUnpadded6(n));
+  return hexToBytes14(numberToHexUnpadded6(n));
 }
 function ensureBytes5(title, hex7, expectedLength) {
   let res;
   if (typeof hex7 === "string") {
     try {
-      res = hexToBytes13(hex7);
+      res = hexToBytes14(hex7);
     } catch (e29) {
       throw new Error(`${title} must be valid hex string, got "${hex7}". Cause: ${e29}`);
     }
@@ -101683,7 +103033,7 @@ function weierstrassPoints4(opts) {
     const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
     if (lengths && typeof key !== "bigint") {
       if (key instanceof Uint8Array)
-        key = bytesToHex15(key);
+        key = bytesToHex16(key);
       if (typeof key !== "string" || !lengths.includes(key.length))
         throw new Error("Invalid key");
       key = key.padStart(nByteLength * 2, "0");
@@ -101974,7 +103324,7 @@ function weierstrassPoints4(opts) {
       return toBytes12(Point5, this, isCompressed);
     }
     toHex(isCompressed = true) {
-      return bytesToHex15(this.toRawBytes(isCompressed));
+      return bytesToHex16(this.toRawBytes(isCompressed));
     }
   }
   Point5.BASE = new Point5(CURVE.Gx, CURVE.Gy, Fp6.ONE);
@@ -102052,7 +103402,7 @@ function weierstrass6(curveDef) {
       }
     }
   });
-  const numToNByteStr = (num2) => bytesToHex15(numberToBytesBE6(num2, CURVE.nByteLength));
+  const numToNByteStr = (num2) => bytesToHex16(numberToBytesBE6(num2, CURVE.nByteLength));
   function isBiggerThanHalfOrder(number13) {
     const HALF = CURVE_ORDER >> _1n32;
     return number13 > HALF;
@@ -102113,13 +103463,13 @@ function weierstrass6(curveDef) {
       return this.hasHighS() ? new Signature(this.r, modN4(-this.s), this.recovery) : this;
     }
     toDERRawBytes() {
-      return hexToBytes13(this.toDERHex());
+      return hexToBytes14(this.toDERHex());
     }
     toDERHex() {
       return DER6.hexFromSig({ r: this.r, s: this.s });
     }
     toCompactRawBytes() {
-      return hexToBytes13(this.toCompactHex());
+      return hexToBytes14(this.toCompactHex());
     }
     toCompactHex() {
       return numToNByteStr(this.r) + numToNByteStr(this.s);
@@ -102545,7 +103895,7 @@ var isLE11 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
 if (!isLE11)
   throw new Error("Non little-endian hardware is not supported");
 var hexes12 = Array.from({ length: 256 }, (v4, i6) => i6.toString(16).padStart(2, "0"));
-function bytesToHex16(bytes10) {
+function bytesToHex17(bytes10) {
   if (!u8a12(bytes10))
     throw new Error("Uint8Array expected");
   let hex7 = "";
@@ -102554,7 +103904,7 @@ function bytesToHex16(bytes10) {
   }
   return hex7;
 }
-function hexToBytes14(hex7) {
+function hexToBytes15(hex7) {
   if (typeof hex7 !== "string")
     throw new Error("hex string expected, got " + typeof hex7);
   const len = hex7.length;
@@ -103322,7 +104672,7 @@ var isLE12 = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
 if (!isLE12)
   throw new Error("Non little-endian hardware is not supported");
 var hexes13 = /* @__PURE__ */ Array.from({ length: 256 }, (_3, i6) => i6.toString(16).padStart(2, "0"));
-function bytesToHex17(bytes12) {
+function bytesToHex18(bytes12) {
   bytes11(bytes12);
   let hex8 = "";
   for (let i6 = 0;i6 < bytes12.length; i6++) {
@@ -103340,7 +104690,7 @@ function asciiToBase165(char) {
     return char - (asciis5._a - 10);
   return;
 }
-function hexToBytes15(hex8) {
+function hexToBytes16(hex8) {
   if (typeof hex8 !== "string")
     throw new Error("hex string expected, got " + typeof hex8);
   const hl = hex8.length;
@@ -104883,8 +106233,8 @@ __export4(utils_exports3, {
   Queue: () => Queue3,
   QueueNode: () => QueueNode3,
   binarySearch: () => binarySearch5,
-  bytesToHex: () => bytesToHex16,
-  hexToBytes: () => hexToBytes14,
+  bytesToHex: () => bytesToHex17,
+  hexToBytes: () => hexToBytes15,
   insertEventIntoAscendingList: () => insertEventIntoAscendingList5,
   insertEventIntoDescendingList: () => insertEventIntoDescendingList5,
   normalizeURL: () => normalizeURL5,
@@ -105010,13 +106360,13 @@ var JS6 = class {
     return schnorr5.utils.randomPrivateKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex16(schnorr5.getPublicKey(secretKey));
+    return bytesToHex17(schnorr5.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event7 = t;
-    event7.pubkey = bytesToHex16(schnorr5.getPublicKey(secretKey));
+    event7.pubkey = bytesToHex17(schnorr5.getPublicKey(secretKey));
     event7.id = getEventHash6(event7);
-    event7.sig = bytesToHex16(schnorr5.sign(getEventHash6(event7), secretKey));
+    event7.sig = bytesToHex17(schnorr5.sign(getEventHash6(event7), secretKey));
     event7[verifiedSymbol9] = true;
     return event7;
   }
@@ -105045,7 +106395,7 @@ function serializeEvent6(evt) {
 }
 function getEventHash6(event7) {
   let eventHash = sha25611(utf8Encoder9.encode(serializeEvent6(event7)));
-  return bytesToHex16(eventHash);
+  return bytesToHex17(eventHash);
 }
 var i6 = new JS6;
 var generateSecretKey6 = i6.generateSecretKey;
@@ -105893,7 +107243,7 @@ function decode6(code) {
       return {
         type: "nprofile",
         data: {
-          pubkey: bytesToHex16(tlv[0][0]),
+          pubkey: bytesToHex17(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder9.decode(d)) : []
         }
       };
@@ -105911,10 +107261,10 @@ function decode6(code) {
       return {
         type: "nevent",
         data: {
-          id: bytesToHex16(tlv[0][0]),
+          id: bytesToHex17(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder9.decode(d)) : [],
-          author: tlv[2]?.[0] ? bytesToHex16(tlv[2][0]) : undefined,
-          kind: tlv[3]?.[0] ? parseInt(bytesToHex16(tlv[3][0]), 16) : undefined
+          author: tlv[2]?.[0] ? bytesToHex17(tlv[2][0]) : undefined,
+          kind: tlv[3]?.[0] ? parseInt(bytesToHex17(tlv[3][0]), 16) : undefined
         }
       };
     }
@@ -105934,8 +107284,8 @@ function decode6(code) {
         type: "naddr",
         data: {
           identifier: utf8Decoder9.decode(tlv[0][0]),
-          pubkey: bytesToHex16(tlv[2][0]),
-          kind: parseInt(bytesToHex16(tlv[3][0]), 16),
+          pubkey: bytesToHex17(tlv[2][0]),
+          kind: parseInt(bytesToHex17(tlv[3][0]), 16),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder9.decode(d)) : []
         }
       };
@@ -105944,7 +107294,7 @@ function decode6(code) {
       return { type: prefix, data };
     case "npub":
     case "note":
-      return { type: prefix, data: bytesToHex16(data) };
+      return { type: prefix, data: bytesToHex17(data) };
     default:
       throw new Error(`unknown prefix ${prefix}`);
   }
@@ -105968,10 +107318,10 @@ function nsecEncode4(key) {
   return encodeBytes4("nsec", key);
 }
 function npubEncode5(hex8) {
-  return encodeBytes4("npub", hexToBytes14(hex8));
+  return encodeBytes4("npub", hexToBytes15(hex8));
 }
 function noteEncode4(hex8) {
-  return encodeBytes4("note", hexToBytes14(hex8));
+  return encodeBytes4("note", hexToBytes15(hex8));
 }
 function encodeBech324(prefix, data) {
   let words = bech325.toWords(data);
@@ -105982,7 +107332,7 @@ function encodeBytes4(prefix, bytes12) {
 }
 function nprofileEncode4(profile6) {
   let data = encodeTLV4({
-    0: [hexToBytes14(profile6.pubkey)],
+    0: [hexToBytes15(profile6.pubkey)],
     1: (profile6.relays || []).map((url4) => utf8Encoder9.encode(url4))
   });
   return encodeBech324("nprofile", data);
@@ -105993,9 +107343,9 @@ function neventEncode4(event7) {
     kindArray = integerToUint8Array3(event7.kind);
   }
   let data = encodeTLV4({
-    0: [hexToBytes14(event7.id)],
+    0: [hexToBytes15(event7.id)],
     1: (event7.relays || []).map((url4) => utf8Encoder9.encode(url4)),
-    2: event7.author ? [hexToBytes14(event7.author)] : [],
+    2: event7.author ? [hexToBytes15(event7.author)] : [],
     3: kindArray ? [new Uint8Array(kindArray)] : []
   });
   return encodeBech324("nevent", data);
@@ -106006,7 +107356,7 @@ function naddrEncode4(addr) {
   let data = encodeTLV4({
     0: [utf8Encoder9.encode(addr.identifier)],
     1: (addr.relays || []).map((url4) => utf8Encoder9.encode(url4)),
-    2: [hexToBytes14(addr.pubkey)],
+    2: [hexToBytes15(addr.pubkey)],
     3: [new Uint8Array(kind)]
   });
   return encodeBech324("naddr", data);
@@ -106030,7 +107380,7 @@ __export4(nip04_exports3, {
   encrypt: () => encrypt7
 });
 function encrypt7(secretKey, pubkey2, text) {
-  const privkey = secretKey instanceof Uint8Array ? bytesToHex16(secretKey) : secretKey;
+  const privkey = secretKey instanceof Uint8Array ? bytesToHex17(secretKey) : secretKey;
   const key = secp256k15.getSharedSecret(privkey, "02" + pubkey2);
   const normalizedKey = getNormalizedX3(key);
   let iv = Uint8Array.from(randomBytes10(16));
@@ -106041,7 +107391,7 @@ function encrypt7(secretKey, pubkey2, text) {
   return `${ctb64}?iv=${ivb64}`;
 }
 function decrypt6(secretKey, pubkey2, data) {
-  const privkey = secretKey instanceof Uint8Array ? bytesToHex16(secretKey) : secretKey;
+  const privkey = secretKey instanceof Uint8Array ? bytesToHex17(secretKey) : secretKey;
   let [ctb64, ivb64] = data.split("?iv=");
   let key = secp256k15.getSharedSecret(privkey, "02" + pubkey2);
   let normalizedKey = getNormalizedX3(key);
@@ -106264,7 +107614,7 @@ function minePow3(unsigned, difficulty) {
   return event7;
 }
 function fastEventHash3(evt) {
-  return bytesToHex16(sha25611(utf8Encoder9.encode(JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]))));
+  return bytesToHex17(sha25611(utf8Encoder9.encode(JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]))));
 }
 var nip17_exports3 = {};
 __export4(nip17_exports3, {
@@ -107238,7 +108588,7 @@ var NegentropyStorageVector4 = class {
   insert(timestamp, id) {
     if (this.sealed)
       throw Error("already sealed");
-    const idb = hexToBytes15(id);
+    const idb = hexToBytes16(id);
     if (idb.byteLength !== ID_SIZE4)
       throw Error("bad id size for added item");
     this.items.push({ timestamp, id: idb });
@@ -107332,10 +108682,10 @@ var Negentropy4 = class {
     let output12 = new WrappedBuffer4;
     output12.extend(new Uint8Array([PROTOCOL_VERSION4]));
     this.splitRange(0, this.storage.size(), this._bound(Number.MAX_VALUE), output12);
-    return bytesToHex17(output12.unwrap());
+    return bytesToHex18(output12.unwrap());
   }
   reconcile(queryMsg, onhave, onneed) {
-    const query2 = new WrappedBuffer4(hexToBytes15(queryMsg));
+    const query2 = new WrappedBuffer4(hexToBytes16(queryMsg));
     this.lastTimestampIn = this.lastTimestampOut = 0;
     let fullOutput = new WrappedBuffer4;
     fullOutput.extend(new Uint8Array([PROTOCOL_VERSION4]));
@@ -107378,22 +108728,22 @@ var Negentropy4 = class {
         let theirElems = {};
         for (let i22 = 0;i22 < numIds; i22++) {
           let e29 = getBytes5(query2, ID_SIZE4);
-          theirElems[bytesToHex17(e29)] = e29;
+          theirElems[bytesToHex18(e29)] = e29;
         }
         skip3 = true;
         this.storage.iterate(lower, upper, (item) => {
           let k3 = item.id;
-          const id = bytesToHex17(k3);
+          const id = bytesToHex18(k3);
           if (!theirElems[id]) {
             onhave?.(id);
           } else {
-            delete theirElems[bytesToHex17(k3)];
+            delete theirElems[bytesToHex18(k3)];
           }
           return true;
         });
         if (onneed) {
           for (let v4 of Object.values(theirElems)) {
-            onneed(bytesToHex17(v4));
+            onneed(bytesToHex18(v4));
           }
         }
       } else {
@@ -107411,7 +108761,7 @@ var Negentropy4 = class {
       prevIndex = upper;
       prevBound = currBound;
     }
-    return fullOutput.length === 1 ? null : bytesToHex17(fullOutput.unwrap());
+    return fullOutput.length === 1 ? null : bytesToHex18(fullOutput.unwrap());
   }
   splitRange(lower, upper, upperBound, o) {
     let numElems = upper - lower;
@@ -107661,7 +109011,7 @@ function validateEventMethodTag3(event7, method) {
 }
 function hashPayload4(payload) {
   const hash10 = sha25611(utf8Encoder9.encode(JSON.stringify(payload)));
-  return bytesToHex16(hash10);
+  return bytesToHex17(hash10);
 }
 function validateEventPayloadTag3(event7, payload) {
   const payloadTag = event7.tags.find((t) => t[0] === "payload");
@@ -107731,13 +109081,13 @@ var JS7 = class {
     return schnorr5.utils.randomPrivateKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex16(schnorr5.getPublicKey(secretKey));
+    return bytesToHex17(schnorr5.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event7 = t;
-    event7.pubkey = bytesToHex16(schnorr5.getPublicKey(secretKey));
+    event7.pubkey = bytesToHex17(schnorr5.getPublicKey(secretKey));
     event7.id = getEventHash7(event7);
-    event7.sig = bytesToHex16(schnorr5.sign(getEventHash7(event7), secretKey));
+    event7.sig = bytesToHex17(schnorr5.sign(getEventHash7(event7), secretKey));
     event7[verifiedSymbol10] = true;
     return event7;
   }
@@ -107766,7 +109116,7 @@ function serializeEvent7(evt) {
 }
 function getEventHash7(event7) {
   let eventHash = sha25611(utf8Encoder10.encode(serializeEvent7(event7)));
-  return bytesToHex16(eventHash);
+  return bytesToHex17(eventHash);
 }
 var i7 = new JS7;
 var generateSecretKey7 = i7.generateSecretKey;
@@ -108003,7 +109353,7 @@ var utf8Decoder12 = new TextDecoder("utf-8");
 var utf8Encoder12 = new TextEncoder;
 var Bech32MaxSize5 = 5000;
 function npubEncode6(hex8) {
-  return encodeBytes5("npub", hexToBytes14(hex8));
+  return encodeBytes5("npub", hexToBytes15(hex8));
 }
 function encodeBech325(prefix, data) {
   let words = bech325.toWords(data);
@@ -108014,7 +109364,7 @@ function encodeBytes5(prefix, bytes12) {
 }
 function nprofileEncode5(profile6) {
   let data = encodeTLV5({
-    0: [hexToBytes14(profile6.pubkey)],
+    0: [hexToBytes15(profile6.pubkey)],
     1: (profile6.relays || []).map((url4) => utf8Encoder12.encode(url4))
   });
   return encodeBech325("nprofile", data);
@@ -111009,7 +112359,7 @@ class NotImplementedError extends WalletBaseError {
   code = "NOT_IMPLEMENTED";
 }
 
-class InsufficientBalanceError2 extends WalletBaseError {
+class InsufficientBalanceError3 extends WalletBaseError {
   code = "INSUFFICIENT_BALANCE";
 }
 
@@ -111051,7 +112401,7 @@ function createWalletError(code, message) {
     case "NOT_IMPLEMENTED":
       return new NotImplementedError(message);
     case "INSUFFICIENT_BALANCE":
-      return new InsufficientBalanceError2(message);
+      return new InsufficientBalanceError3(message);
     case "QUOTA_EXCEEDED":
       return new QuotaExceededError(message);
     case "RESTRICTED":
@@ -126995,7 +128345,7 @@ function rotl5(word, shift) {
 }
 var hasHexBuiltin4 = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
 var hexes14 = /* @__PURE__ */ Array.from({ length: 256 }, (_4, i8) => i8.toString(16).padStart(2, "0"));
-function bytesToHex18(bytes12) {
+function bytesToHex19(bytes12) {
   abytes7(bytes12);
   if (hasHexBuiltin4)
     return bytes12.toHex();
@@ -127015,7 +128365,7 @@ function asciiToBase166(ch) {
     return ch - (asciis6.a - 10);
   return;
 }
-function hexToBytes16(hex8) {
+function hexToBytes17(hex8) {
   if (typeof hex8 !== "string")
     throw new Error("hex string expected, got " + typeof hex8);
   if (hasHexBuiltin4)
@@ -127774,15 +129124,15 @@ function hexToNumber7(hex8) {
   return hex8 === "" ? _0n35 : BigInt("0x" + hex8);
 }
 function bytesToNumberBE7(bytes12) {
-  return hexToNumber7(bytesToHex18(bytes12));
+  return hexToNumber7(bytesToHex19(bytes12));
 }
 function bytesToNumberLE7(bytes12) {
-  return hexToNumber7(bytesToHex18(copyBytes4(abytes7(bytes12)).reverse()));
+  return hexToNumber7(bytesToHex19(copyBytes4(abytes7(bytes12)).reverse()));
 }
 function numberToBytesBE7(n, len) {
   anumber6(len);
   n = abignumber2(n);
-  const res = hexToBytes16(n.toString(16).padStart(len * 2, "0"));
+  const res = hexToBytes17(n.toString(16).padStart(len * 2, "0"));
   if (res.length !== len)
     throw new Error("number too large");
   return res;
@@ -128870,7 +130220,7 @@ function weierstrass7(params, extraOpts = {}) {
       return P3;
     }
     static fromHex(hex8) {
-      return Point6.fromBytes(hexToBytes16(hex8));
+      return Point6.fromBytes(hexToBytes17(hex8));
     }
     get x() {
       return this.toAffine().x;
@@ -129063,7 +130413,7 @@ function weierstrass7(params, extraOpts = {}) {
       return encodePoint(Point6, this, isCompressed);
     }
     toHex(isCompressed = true) {
-      return bytesToHex18(this.toBytes(isCompressed));
+      return bytesToHex19(this.toBytes(isCompressed));
     }
     toString() {
       return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
@@ -129218,7 +130568,7 @@ function ecdsa3(Point6, hash10, ecdsaOpts = {}) {
       return new Signature(Fn5.fromBytes(r), Fn5.fromBytes(s), recid);
     }
     static fromHex(hex8, format) {
-      return this.fromBytes(hexToBytes16(hex8), format);
+      return this.fromBytes(hexToBytes17(hex8), format);
     }
     assertRecovery() {
       const { recovery } = this;
@@ -129253,7 +130603,7 @@ function ecdsa3(Point6, hash10, ecdsaOpts = {}) {
     toBytes(format = defaultSigOpts.format) {
       validateSigFormat3(format);
       if (format === "der")
-        return hexToBytes16(DER7.hexFromSig(this));
+        return hexToBytes17(DER7.hexFromSig(this));
       const { r, s } = this;
       const rb = Fn5.toBytes(r);
       const sb = Fn5.toBytes(s);
@@ -129264,7 +130614,7 @@ function ecdsa3(Point6, hash10, ecdsaOpts = {}) {
       return concatBytes17(rb, sb);
     }
     toHex(format) {
-      return bytesToHex18(this.toBytes(format));
+      return bytesToHex19(this.toBytes(format));
     }
   }
   const bits2int = ecdsaOpts.bits2int || function bits2int_def(bytes12) {
@@ -131124,8 +132474,8 @@ function validateEvent9(event11) {
 var utils_exports4 = {};
 __export5(utils_exports4, {
   binarySearch: () => binarySearch7,
-  bytesToHex: () => bytesToHex18,
-  hexToBytes: () => hexToBytes16,
+  bytesToHex: () => bytesToHex19,
+  hexToBytes: () => hexToBytes17,
   insertEventIntoAscendingList: () => insertEventIntoAscendingList7,
   insertEventIntoDescendingList: () => insertEventIntoDescendingList7,
   mergeReverseSortedLists: () => mergeReverseSortedLists,
@@ -131254,13 +132604,13 @@ var JS8 = class {
     return schnorr6.utils.randomSecretKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex18(schnorr6.getPublicKey(secretKey));
+    return bytesToHex19(schnorr6.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event11 = t;
-    event11.pubkey = bytesToHex18(schnorr6.getPublicKey(secretKey));
+    event11.pubkey = bytesToHex19(schnorr6.getPublicKey(secretKey));
     event11.id = getEventHash8(event11);
-    event11.sig = bytesToHex18(schnorr6.sign(hexToBytes16(getEventHash8(event11)), secretKey));
+    event11.sig = bytesToHex19(schnorr6.sign(hexToBytes17(getEventHash8(event11)), secretKey));
     event11[verifiedSymbol11] = true;
     return event11;
   }
@@ -131273,7 +132623,7 @@ var JS8 = class {
         event11[verifiedSymbol11] = false;
         return false;
       }
-      const valid = schnorr6.verify(hexToBytes16(event11.sig), hexToBytes16(hash10), hexToBytes16(event11.pubkey));
+      const valid = schnorr6.verify(hexToBytes17(event11.sig), hexToBytes17(hash10), hexToBytes17(event11.pubkey));
       event11[verifiedSymbol11] = valid;
       return valid;
     } catch (err) {
@@ -131289,7 +132639,7 @@ function serializeEvent8(evt) {
 }
 function getEventHash8(event11) {
   let eventHash = sha25612(utf8Encoder13.encode(serializeEvent8(event11)));
-  return bytesToHex18(eventHash);
+  return bytesToHex19(eventHash);
 }
 var i8 = new JS8;
 var generateSecretKey8 = i8.generateSecretKey;
@@ -132356,7 +133706,7 @@ function decode8(code) {
       return {
         type: "nprofile",
         data: {
-          pubkey: bytesToHex18(tlv[0][0]),
+          pubkey: bytesToHex19(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder13.decode(d)) : []
         }
       };
@@ -132374,10 +133724,10 @@ function decode8(code) {
       return {
         type: "nevent",
         data: {
-          id: bytesToHex18(tlv[0][0]),
+          id: bytesToHex19(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder13.decode(d)) : [],
-          author: tlv[2]?.[0] ? bytesToHex18(tlv[2][0]) : undefined,
-          kind: tlv[3]?.[0] ? parseInt(bytesToHex18(tlv[3][0]), 16) : undefined
+          author: tlv[2]?.[0] ? bytesToHex19(tlv[2][0]) : undefined,
+          kind: tlv[3]?.[0] ? parseInt(bytesToHex19(tlv[3][0]), 16) : undefined
         }
       };
     }
@@ -132397,8 +133747,8 @@ function decode8(code) {
         type: "naddr",
         data: {
           identifier: utf8Decoder13.decode(tlv[0][0]),
-          pubkey: bytesToHex18(tlv[2][0]),
-          kind: parseInt(bytesToHex18(tlv[3][0]), 16),
+          pubkey: bytesToHex19(tlv[2][0]),
+          kind: parseInt(bytesToHex19(tlv[3][0]), 16),
           relays: tlv[1] ? tlv[1].map((d) => utf8Decoder13.decode(d)) : []
         }
       };
@@ -132407,7 +133757,7 @@ function decode8(code) {
       return { type: prefix, data };
     case "npub":
     case "note":
-      return { type: prefix, data: bytesToHex18(data) };
+      return { type: prefix, data: bytesToHex19(data) };
     default:
       throw new Error(`unknown prefix ${prefix}`);
   }
@@ -132433,10 +133783,10 @@ function nsecEncode6(key) {
   return encodeBytes6("nsec", key);
 }
 function npubEncode7(hex9) {
-  return encodeBytes6("npub", hexToBytes16(hex9));
+  return encodeBytes6("npub", hexToBytes17(hex9));
 }
 function noteEncode6(hex9) {
-  return encodeBytes6("note", hexToBytes16(hex9));
+  return encodeBytes6("note", hexToBytes17(hex9));
 }
 function encodeBech326(prefix, data) {
   let words = bech326.toWords(data);
@@ -132447,7 +133797,7 @@ function encodeBytes6(prefix, bytes12) {
 }
 function nprofileEncode6(profile9) {
   let data = encodeTLV6({
-    0: [hexToBytes16(profile9.pubkey)],
+    0: [hexToBytes17(profile9.pubkey)],
     1: (profile9.relays || []).map((url5) => utf8Encoder13.encode(url5))
   });
   return encodeBech326("nprofile", data);
@@ -132458,9 +133808,9 @@ function neventEncode6(event11) {
     kindArray = integerToUint8Array4(event11.kind);
   }
   let data = encodeTLV6({
-    0: [hexToBytes16(event11.id)],
+    0: [hexToBytes17(event11.id)],
     1: (event11.relays || []).map((url5) => utf8Encoder13.encode(url5)),
-    2: event11.author ? [hexToBytes16(event11.author)] : [],
+    2: event11.author ? [hexToBytes17(event11.author)] : [],
     3: kindArray ? [new Uint8Array(kindArray)] : []
   });
   return encodeBech326("nevent", data);
@@ -132471,7 +133821,7 @@ function naddrEncode6(addr) {
   let data = encodeTLV6({
     0: [utf8Encoder13.encode(addr.identifier)],
     1: (addr.relays || []).map((url5) => utf8Encoder13.encode(url5)),
-    2: [hexToBytes16(addr.pubkey)],
+    2: [hexToBytes17(addr.pubkey)],
     3: [new Uint8Array(kind)]
   });
   return encodeBech326("naddr", data);
@@ -132495,8 +133845,8 @@ __export5(nip04_exports4, {
   encrypt: () => encrypt9
 });
 function encrypt9(secretKey, pubkey3, text) {
-  const privkey = secretKey instanceof Uint8Array ? secretKey : hexToBytes16(secretKey);
-  const key = secp256k16.getSharedSecret(privkey, hexToBytes16("02" + pubkey3));
+  const privkey = secretKey instanceof Uint8Array ? secretKey : hexToBytes17(secretKey);
+  const key = secp256k16.getSharedSecret(privkey, hexToBytes17("02" + pubkey3));
   const normalizedKey = getNormalizedX4(key);
   let iv = Uint8Array.from(randomBytes11(16));
   let plaintext = utf8Encoder13.encode(text);
@@ -132506,9 +133856,9 @@ function encrypt9(secretKey, pubkey3, text) {
   return `${ctb64}?iv=${ivb64}`;
 }
 function decrypt8(secretKey, pubkey3, data) {
-  const privkey = secretKey instanceof Uint8Array ? secretKey : hexToBytes16(secretKey);
+  const privkey = secretKey instanceof Uint8Array ? secretKey : hexToBytes17(secretKey);
   let [ctb64, ivb64] = data.split("?iv=");
-  let key = secp256k16.getSharedSecret(privkey, hexToBytes16("02" + pubkey3));
+  let key = secp256k16.getSharedSecret(privkey, hexToBytes17("02" + pubkey3));
   let normalizedKey = getNormalizedX4(key);
   let iv = base649.decode(ivb64);
   let ciphertext = base649.decode(ctb64);
@@ -132736,7 +134086,7 @@ function minePow4(unsigned, difficulty) {
     tag2[1] = (++count).toString();
     const hash10 = sha25612(utf8Encoder13.encode(JSON.stringify([0, event11.pubkey, event11.created_at, event11.kind, event11.tags, event11.content])));
     if (getPowFromBytes(hash10) >= difficulty) {
-      event11.id = bytesToHex18(hash10);
+      event11.id = bytesToHex19(hash10);
       break;
     }
   }
@@ -132770,7 +134120,7 @@ var minPlaintextSize4 = 1;
 var maxPlaintextSize4 = 4294967295;
 var extendedPrefixThreshold = 65536;
 function getConversationKey4(privkeyA, pubkeyB) {
-  const sharedX = secp256k16.getSharedSecret(privkeyA, hexToBytes16("02" + pubkeyB)).subarray(1, 33);
+  const sharedX = secp256k16.getSharedSecret(privkeyA, hexToBytes17("02" + pubkeyB)).subarray(1, 33);
   return extract5(sha25612, sharedX, utf8Encoder13.encode("nip44-v2"));
 }
 function getMessageKeys4(conversationKey, nonce) {
@@ -133877,7 +135227,7 @@ var NegentropyStorageVector5 = class {
   insert(timestamp, id) {
     if (this.sealed)
       throw Error("already sealed");
-    const idb = hexToBytes16(id);
+    const idb = hexToBytes17(id);
     if (idb.byteLength !== ID_SIZE5)
       throw Error("bad id size for added item");
     this.items.push({ timestamp, id: idb });
@@ -133971,10 +135321,10 @@ var Negentropy5 = class {
     let output12 = new WrappedBuffer5;
     output12.extend(new Uint8Array([PROTOCOL_VERSION5]));
     this.splitRange(0, this.storage.size(), this._bound(Number.MAX_VALUE), output12);
-    return bytesToHex18(output12.unwrap());
+    return bytesToHex19(output12.unwrap());
   }
   reconcile(queryMsg, onhave, onneed) {
-    const query2 = new WrappedBuffer5(hexToBytes16(queryMsg));
+    const query2 = new WrappedBuffer5(hexToBytes17(queryMsg));
     this.lastTimestampIn = this.lastTimestampOut = 0;
     let fullOutput = new WrappedBuffer5;
     fullOutput.extend(new Uint8Array([PROTOCOL_VERSION5]));
@@ -134017,22 +135367,22 @@ var Negentropy5 = class {
         let theirElems = {};
         for (let i22 = 0;i22 < numIds; i22++) {
           let e43 = getBytes6(query2, ID_SIZE5);
-          theirElems[bytesToHex18(e43)] = e43;
+          theirElems[bytesToHex19(e43)] = e43;
         }
         skip4 = true;
         this.storage.iterate(lower, upper, (item) => {
           let k4 = item.id;
-          const id = bytesToHex18(k4);
+          const id = bytesToHex19(k4);
           if (!theirElems[id]) {
             onhave?.(id);
           } else {
-            delete theirElems[bytesToHex18(k4)];
+            delete theirElems[bytesToHex19(k4)];
           }
           return true;
         });
         if (onneed) {
           for (let v4 of Object.values(theirElems)) {
-            onneed(bytesToHex18(v4));
+            onneed(bytesToHex19(v4));
           }
         }
       } else {
@@ -134050,7 +135400,7 @@ var Negentropy5 = class {
       prevIndex = upper;
       prevBound = currBound;
     }
-    return fullOutput.length === 1 ? null : bytesToHex18(fullOutput.unwrap());
+    return fullOutput.length === 1 ? null : bytesToHex19(fullOutput.unwrap());
   }
   splitRange(lower, upper, upperBound, o) {
     let numElems = upper - lower;
@@ -134300,7 +135650,7 @@ function validateEventMethodTag4(event11, method) {
 }
 function hashPayload5(payload) {
   const hash10 = sha25612(utf8Encoder13.encode(JSON.stringify(payload)));
-  return bytesToHex18(hash10);
+  return bytesToHex19(hash10);
 }
 function validateEventPayloadTag4(event11, payload) {
   const payloadTag = event11.tags.find((t) => t[0] === "payload");
@@ -134336,7 +135686,7 @@ async function validateEvent25(event11, url5, method, body) {
 
 // src/utils/nip98.ts
 var NIP98_KIND = 27235;
-function hexToBytes17(hex9) {
+function hexToBytes18(hex9) {
   const normalized = hex9.trim().toLowerCase();
   if (!/^[a-f0-9]{64}$/.test(normalized)) {
     throw new Error("Expected a 64-char hex private key or an nsec private key.");
@@ -134359,7 +135709,7 @@ function parseSecretKey(value) {
     }
     return decoded.data;
   }
-  return hexToBytes17(trimmed);
+  return hexToBytes18(trimmed);
 }
 async function sha256Hex(data) {
   const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(data));
@@ -134543,6 +135893,75 @@ Installing routstr models in opencode.json...`);
 import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname3 } from "path";
+var PI_THINKING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var THINKING_LEVEL_VALUES = {
+  off: "none",
+  minimal: "minimal",
+  low: "low",
+  medium: "medium",
+  high: "high",
+  xhigh: "xhigh",
+  max: "max"
+};
+function deriveThinkingFields(model4) {
+  const reasoning = model4.reasoning;
+  if (!reasoning)
+    return null;
+  const supported = (reasoning.supported_efforts ?? []).filter((effort) => typeof effort === "string").map((effort) => effort.trim().toLowerCase()).filter(Boolean);
+  if (supported.length === 0)
+    return null;
+  const allowed = new Set(supported);
+  if (reasoning.mandatory === true)
+    allowed.delete("none");
+  const thinkingLevelMap = {};
+  for (const level of PI_THINKING_LEVELS) {
+    const value = THINKING_LEVEL_VALUES[level];
+    thinkingLevelMap[level] = allowed.has(value) ? value : null;
+  }
+  return { reasoning: true, thinkingLevelMap };
+}
+var isDeepSeekModel = (id) => id.startsWith("deepseek");
+function buildPiModelEntry(model4, previous) {
+  const entry = { id: model4.id };
+  if (model4.context_length !== undefined && model4.context_length > 0) {
+    entry.contextWindow = model4.context_length;
+  }
+  if (model4.name) {
+    entry.name = model4.name;
+  }
+  const mods = model4.architecture?.input_modalities ?? [];
+  const input = [];
+  if (mods.includes("text"))
+    input.push("text");
+  if (mods.includes("image"))
+    input.push("image");
+  entry.input = input;
+  const derived = deriveThinkingFields(model4);
+  if (derived) {
+    entry.reasoning = derived.reasoning;
+    entry.thinkingLevelMap = derived.thinkingLevelMap;
+  } else {
+    if (previous?.reasoning !== undefined)
+      entry.reasoning = previous.reasoning;
+    if (previous?.thinkingLevelMap !== undefined) {
+      entry.thinkingLevelMap = previous.thinkingLevelMap;
+    }
+  }
+  if (isDeepSeekModel(model4.id)) {
+    entry.compat = { ...previous?.compat ?? {}, supportsDeveloperRole: false };
+  } else if (previous?.compat !== undefined) {
+    entry.compat = previous.compat;
+  }
+  return entry;
+}
 async function installPiIntegration(config2, apiKey, integrationConfig) {
   const { name: name16, configPath } = integrationConfig;
   console.log(`
@@ -134571,30 +135990,7 @@ Installing routstr models in pi models.json...`);
       return;
     }
     const existingModels = new Map((piConfig.providers["routstr"]?.models ?? []).map((m) => [m.id, m]));
-    const providerModels = models.map((model4) => {
-      const previous = existingModels.get(model4.id);
-      const entry = { id: model4.id };
-      if (model4.context_length !== undefined && model4.context_length > 0) {
-        entry.contextWindow = model4.context_length;
-      }
-      if (model4.name) {
-        entry.name = model4.name;
-      }
-      const mods = model4.architecture?.input_modalities ?? [];
-      const input = [];
-      if (mods.includes("text"))
-        input.push("text");
-      if (mods.includes("image"))
-        input.push("image");
-      entry.input = input;
-      if (previous?.reasoning !== undefined)
-        entry.reasoning = previous.reasoning;
-      if (previous?.thinkingLevelMap !== undefined)
-        entry.thinkingLevelMap = previous.thinkingLevelMap;
-      if (previous?.compat !== undefined)
-        entry.compat = previous.compat;
-      return entry;
-    });
+    const providerModels = models.map((model4) => buildPiModelEntry(model4, existingModels.get(model4.id)));
     piConfig.providers["routstr"] = {
       baseUrl,
       api: "openai-completions",
@@ -135188,6 +136584,32 @@ async function getUsageSummary(driver, clients, tzOffsetMinutes, clientFilter) {
   return summary;
 }
 
+// src/daemon/http/request-body.ts
+var OPENAI_JSON_BODY_PATH_SUFFIXES = [
+  "/chat/completions",
+  "/completions",
+  "/responses"
+];
+function isOpenAiJsonBodyPath2(pathname) {
+  const path2 = (pathname.split("?")[0] ?? "").replace(/\/+$/, "");
+  return OPENAI_JSON_BODY_PATH_SUFFIXES.some((suffix) => path2.endsWith(suffix));
+}
+function applyDefaultOutputTokenLimit(pathname, body, maxTokens) {
+  if (!(maxTokens > 0) || !isOpenAiJsonBodyPath2(pathname)) {
+    return false;
+  }
+  if (pathname.split("?")[0].replace(/\/+$/, "").endsWith("/responses")) {
+    if (typeof body.max_output_tokens === "number")
+      return false;
+    body.max_output_tokens = maxTokens;
+    return true;
+  }
+  if (typeof body.max_tokens === "number")
+    return false;
+  body.max_tokens = maxTokens;
+  return true;
+}
+
 // src/daemon/http/index.ts
 var HOP_BY_HOP_HEADERS = new Set([
   "connection",
@@ -136425,16 +137847,7 @@ function createDaemonRequestHandler(deps) {
       sendJson(res, 400, { error: "Missing required 'model' field." });
       return;
     }
-    if (deps.maxTokens > 0) {
-      const isResponsesPath = url5.pathname.includes("/responses");
-      if (isResponsesPath) {
-        if (typeof bodyObj.max_output_tokens !== "number") {
-          bodyObj.max_output_tokens = deps.maxTokens;
-        }
-      } else if (typeof bodyObj.max_tokens !== "number") {
-        bodyObj.max_tokens = deps.maxTokens;
-      }
-    }
+    applyDefaultOutputTokenLimit(url5.pathname, bodyObj, deps.maxTokens);
     const forcedProvider = url5.searchParams.get("provider") || req.headers["x-routstr-provider"] || deps.provider || undefined;
     const incomingHeaders = {};
     for (const [key, value] of Object.entries(req.headers)) {
@@ -137649,7 +139062,7 @@ var SqliteKeysetRepository = class {
     await this.db.run("DELETE FROM coco_cashu_keysets WHERE mintUrl = ? AND id = ?", [mintUrl, keysetId]);
   }
 };
-function hexToBytes18(hexString) {
+function hexToBytes19(hexString) {
   if (!/^[0-9a-fA-F]+$/.test(hexString))
     throw new Error(`Invalid hex string: contains non-hex characters`);
   if (hexString.length % 2 !== 0)
@@ -137659,7 +139072,7 @@ function hexToBytes18(hexString) {
     throw new Error(`Failed to parse hex string`);
   return new Uint8Array(matches.map((byte) => parseInt(byte, 16)));
 }
-function bytesToHex20(bytes12) {
+function bytesToHex21(bytes12) {
   return Array.from(bytes12).map((b2) => b2.toString(16).padStart(2, "0")).join("");
 }
 var SqliteKeyRingRepository = class {
@@ -137672,7 +139085,7 @@ var SqliteKeyRingRepository = class {
     if (!row)
       return null;
     try {
-      const secretKeyBytes = hexToBytes18(row.secretKey);
+      const secretKeyBytes = hexToBytes19(row.secretKey);
       return {
         publicKeyHex: row.publicKey,
         secretKey: secretKeyBytes,
@@ -137683,7 +139096,7 @@ var SqliteKeyRingRepository = class {
     }
   }
   async setPersistedKeyPair(keyPair) {
-    const secretKeyHex = bytesToHex20(keyPair.secretKey);
+    const secretKeyHex = bytesToHex21(keyPair.secretKey);
     await this.db.run(`INSERT INTO coco_cashu_keypairs (publicKey, secretKey, createdAt, derivationIndex)
        VALUES (?, ?, ?, ?)
        ON CONFLICT(publicKey) DO UPDATE SET
@@ -137701,7 +139114,7 @@ var SqliteKeyRingRepository = class {
   async getAllPersistedKeyPairs() {
     return (await this.db.all("SELECT publicKey, secretKey, derivationIndex FROM coco_cashu_keypairs")).map((row) => {
       try {
-        const secretKeyBytes = hexToBytes18(row.secretKey);
+        const secretKeyBytes = hexToBytes19(row.secretKey);
         return {
           publicKeyHex: row.publicKey,
           secretKey: secretKeyBytes,
@@ -137717,7 +139130,7 @@ var SqliteKeyRingRepository = class {
     if (!row)
       return null;
     try {
-      const secretKeyBytes = hexToBytes18(row.secretKey);
+      const secretKeyBytes = hexToBytes19(row.secretKey);
       return {
         publicKeyHex: row.publicKey,
         secretKey: secretKeyBytes,
@@ -139146,13 +140559,13 @@ var JS9 = class {
     return schnorr6.utils.randomSecretKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex18(schnorr6.getPublicKey(secretKey));
+    return bytesToHex19(schnorr6.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event11 = t;
-    event11.pubkey = bytesToHex18(schnorr6.getPublicKey(secretKey));
+    event11.pubkey = bytesToHex19(schnorr6.getPublicKey(secretKey));
     event11.id = getEventHash9(event11);
-    event11.sig = bytesToHex18(schnorr6.sign(hexToBytes16(getEventHash9(event11)), secretKey));
+    event11.sig = bytesToHex19(schnorr6.sign(hexToBytes17(getEventHash9(event11)), secretKey));
     event11[verifiedSymbol12] = true;
     return event11;
   }
@@ -139165,7 +140578,7 @@ var JS9 = class {
         event11[verifiedSymbol12] = false;
         return false;
       }
-      const valid = schnorr6.verify(hexToBytes16(event11.sig), hexToBytes16(hash10), hexToBytes16(event11.pubkey));
+      const valid = schnorr6.verify(hexToBytes17(event11.sig), hexToBytes17(hash10), hexToBytes17(event11.pubkey));
       event11[verifiedSymbol12] = valid;
       return valid;
     } catch (err) {
@@ -139181,7 +140594,7 @@ function serializeEvent9(evt) {
 }
 function getEventHash9(event11) {
   let eventHash = sha25612(utf8Encoder14.encode(serializeEvent9(event11)));
-  return bytesToHex18(eventHash);
+  return bytesToHex19(eventHash);
 }
 var i9 = new JS9;
 var generateSecretKey9 = i9.generateSecretKey;
@@ -139209,7 +140622,7 @@ async function getToken6(loginUrl, httpMethod, sign4, includeAuthorizationScheme
 }
 function hashPayload6(payload) {
   const hash10 = sha25612(utf8Encoder14.encode(JSON.stringify(payload)));
-  return bytesToHex18(hash10);
+  return bytesToHex19(hash10);
 }
 
 // node_modules/npubcash-sdk/dist/npc-sdk.mjs
@@ -155929,6 +157342,44 @@ function legacyCocodPidPath() {
   return process.env.COCOD_PID || join11(legacyCocodDir(), "cocod.pid");
 }
 
+// src/daemon/wallet/trusted-mints.ts
+var DEFAULT_MINT_URL = "https://mint.cubabitcoin.org";
+var DEFAULT_TRUSTED_MINT_URLS = [
+  DEFAULT_MINT_URL,
+  "https://mint.minibits.cash/Bitcoin"
+];
+function safeNormalizeMintUrl(mintUrl) {
+  try {
+    return normalizeMintUrl(mintUrl);
+  } catch {
+    return mintUrl;
+  }
+}
+async function seedTrustedMints(wallet, defaultMintUrl, options = {}) {
+  const seeds = options.seeds ?? DEFAULT_TRUSTED_MINT_URLS;
+  const target = safeNormalizeMintUrl(defaultMintUrl);
+  const trusted = new Set(wallet.trustedMints.map(safeNormalizeMintUrl));
+  const attempted = new Set;
+  for (const seed of [defaultMintUrl, ...seeds]) {
+    const mintUrl = safeNormalizeMintUrl(seed);
+    if (attempted.has(mintUrl))
+      continue;
+    attempted.add(mintUrl);
+    if (trusted.has(mintUrl))
+      continue;
+    const isDefault = mintUrl === target;
+    try {
+      options.onProgress?.(`Adding ${isDefault ? "default" : "trusted"} mint: ${mintUrl}`);
+      await wallet.addMint(mintUrl);
+      trusted.add(mintUrl);
+    } catch (error53) {
+      if (isDefault)
+        throw error53;
+      options.onError?.(`Could not add trusted mint ${mintUrl}`, error53);
+    }
+  }
+}
+
 // src/daemon/wallet/coco-client.ts
 var NPC_DEFAULT_BASE_URL = "https://npubx.cash";
 var STALE_SOCKET_ERROR_CODES = new Set([
@@ -155937,7 +157388,6 @@ var STALE_SOCKET_ERROR_CODES = new Set([
   "FailedToOpenSocket"
 ]);
 var STARTUP_LOG_PREFIX = "[routstrd:start]";
-var DEFAULT_MINT_URL = "https://mint.cubabitcoin.org";
 function startupProgress(message) {
   logger5.info(message);
   console.log(`${STARTUP_LOG_PREFIX} ${message}`);
@@ -156596,10 +158046,15 @@ async function createCocoClient(options = {}) {
     const trustedMints = await coco.mint.getAllTrustedMints();
     const configuredDefault = walletConfig.defaultMintUrl;
     const defaultMintUrl = normalizeMintUrl(configuredDefault || trustedMints[0]?.mintUrl || DEFAULT_MINT_URL);
-    if (!trustedMints.some((mint) => mint.mintUrl === defaultMintUrl)) {
-      startupProgress(`Adding default mint: ${defaultMintUrl}`);
-      await coco.mint.addMint(defaultMintUrl, { trusted: true });
-    }
+    await seedTrustedMints({
+      trustedMints: trustedMints.map((mint) => mint.mintUrl),
+      addMint: (mintUrl) => coco.mint.addMint(mintUrl, { trusted: true })
+    }, defaultMintUrl, {
+      onProgress: startupProgress,
+      onError: (message, error53) => logger5.warn(message, {
+        error: error53 instanceof Error ? error53.message : String(error53)
+      })
+    });
     walletConfig.defaultMintUrl = defaultMintUrl;
     if (configuredDefault !== defaultMintUrl) {
       saveConfig(walletConfig, configFile);