routstrd 0.4.10 → 0.4.11

package/dist/index.js

@@ -47459,6 +47459,47 @@ function legacyCocodPidPath() {
 }
 var init_paths = () => {};
 
+// src/daemon/wallet/trusted-mints.ts
+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 (error) {
+      if (isDefault)
+        throw error;
+      options.onError?.(`Could not add trusted mint ${mintUrl}`, error);
+    }
+  }
+}
+var DEFAULT_MINT_URL = "https://mint.cubabitcoin.org", DEFAULT_TRUSTED_MINT_URLS;
+var init_trusted_mints = __esm(() => {
+  init_dist();
+  DEFAULT_TRUSTED_MINT_URLS = [
+    DEFAULT_MINT_URL,
+    "https://mint.minibits.cash/Bitcoin"
+  ];
+});
+
 // src/daemon/wallet/coco-client.ts
 import { Database } from "bun:sqlite";
 import {
@@ -48100,10 +48141,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, error) => logger.warn(message, {
+        error: error instanceof Error ? error.message : String(error)
+      })
+    });
     walletConfig.defaultMintUrl = defaultMintUrl;
     if (configuredDefault !== defaultMintUrl) {
       saveConfig(walletConfig, configFile);
@@ -48518,7 +48564,7 @@ async function createCocoClient(options = {}) {
     }
   };
 }
-var NPC_DEFAULT_BASE_URL = "https://npubx.cash", STALE_SOCKET_ERROR_CODES, STARTUP_LOG_PREFIX2 = "[routstrd:start]", DEFAULT_MINT_URL = "https://mint.cubabitcoin.org", surfacingRecoveryProgress = false, RECOVERY_STALL_MARKERS, SAFE_COCO_LOG_FIELDS, EXPIRED_MINT_OBSERVATION_DEADLINE_MS = 15000, PENDING_MINT_SWEEP_INTERVAL_MS = 15000, PENDING_MINT_CHECK_TIMEOUT_MS = 1e4, PENDING_MINT_SWEEP_DEADLINE_MS = 30000, PENDING_MINT_STOP_DRAIN_MS = 1e4;
+var NPC_DEFAULT_BASE_URL = "https://npubx.cash", STALE_SOCKET_ERROR_CODES, STARTUP_LOG_PREFIX2 = "[routstrd:start]", surfacingRecoveryProgress = false, RECOVERY_STALL_MARKERS, SAFE_COCO_LOG_FIELDS, EXPIRED_MINT_OBSERVATION_DEADLINE_MS = 15000, PENDING_MINT_SWEEP_INTERVAL_MS = 15000, PENDING_MINT_CHECK_TIMEOUT_MS = 1e4, PENDING_MINT_SWEEP_DEADLINE_MS = 30000, PENDING_MINT_STOP_DRAIN_MS = 1e4;
 var init_coco_client = __esm(() => {
   init_dist();
   init_dist2();
@@ -48529,6 +48575,8 @@ var init_coco_client = __esm(() => {
   init_receive_dedup();
   init_logger();
   init_paths();
+  init_trusted_mints();
+  init_trusted_mints();
   STALE_SOCKET_ERROR_CODES = new Set([
     "ECONNREFUSED",
     "ENOENT",
@@ -48623,6 +48671,56 @@ var init_opencode = __esm(() => {
 import { existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname4 } from "path";
+function deriveThinkingFields(model) {
+  const reasoning = model.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 };
+}
+function buildPiModelEntry(model, previous) {
+  const entry = { id: model.id };
+  if (model.context_length !== undefined && model.context_length > 0) {
+    entry.contextWindow = model.context_length;
+  }
+  if (model.name) {
+    entry.name = model.name;
+  }
+  const mods = model.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(model);
+  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(model.id)) {
+    entry.compat = { ...previous?.compat ?? {}, supportsDeveloperRole: false };
+  } else if (previous?.compat !== undefined) {
+    entry.compat = previous.compat;
+  }
+  return entry;
+}
 async function installPiIntegration(config, apiKey, integrationConfig) {
   const { name, configPath } = integrationConfig;
   console.log(`
@@ -48651,30 +48749,7 @@ Installing routstr models in pi models.json...`);
       return;
     }
     const existingModels = new Map((piConfig.providers["routstr"]?.models ?? []).map((m2) => [m2.id, m2]));
-    const providerModels = models.map((model) => {
-      const previous = existingModels.get(model.id);
-      const entry = { id: model.id };
-      if (model.context_length !== undefined && model.context_length > 0) {
-        entry.contextWindow = model.context_length;
-      }
-      if (model.name) {
-        entry.name = model.name;
-      }
-      const mods = model.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((model) => buildPiModelEntry(model, existingModels.get(model.id)));
     piConfig.providers["routstr"] = {
       baseUrl,
       api: "openai-completions",
@@ -48687,8 +48762,27 @@ Installing routstr models in pi models.json...`);
     console.error("Failed to install models in pi models.json:", error);
   }
 }
+var PI_THINKING_LEVELS, THINKING_LEVEL_VALUES, isDeepSeekModel = (id) => id.startsWith("deepseek");
 var init_pi = __esm(() => {
   init_daemon_client();
+  PI_THINKING_LEVELS = [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+  ];
+  THINKING_LEVEL_VALUES = {
+    off: "none",
+    minimal: "minimal",
+    low: "low",
+    medium: "medium",
+    high: "high",
+    xhigh: "xhigh",
+    max: "max"
+  };
 });
 
 // src/integrations/openclaw.ts
@@ -61014,7 +61108,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "routstrd",
-    version: "0.4.10",
+    version: "0.4.11",
     module: "src/index.ts",
     type: "module",
     private: false,
@@ -61037,6 +61131,7 @@ var init_package = __esm(() => {
       monitor: "bun src/index.ts monitor",
       lint: "tsc --noEmit",
       test: "bun test",
+      smoke: "scripts/smoke/chat-completions.sh",
       build: "bun build src/index.ts --target=bun --outfile=dist/index.js --external better-sqlite3 && bun build src/daemon/index.ts --target=bun --outfile=dist/daemon/index.js --external better-sqlite3",
       "build:binary": "bun build --compile --no-compile-autoload-dotenv --no-compile-autoload-bunfig src/index.ts --outfile=dist/routstrd",
       prepublishOnly: "bun run build"
@@ -61052,7 +61147,7 @@ var init_package = __esm(() => {
       "@cashu/cashu-ts": "^4.3.0",
       "@cashu/coco-core": "^1.0.1",
       "@cashu/coco-sqlite-bun": "^1.0.1",
-      "@routstr/sdk": "^0.4.5",
+      "@routstr/sdk": "^0.4.6",
       "@scure/bip39": "^2.2.0",
       "applesauce-core": "^5.1.0",
       "applesauce-relay": "^5.1.0",
@@ -99690,7 +99785,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 = {
@@ -99708,7 +99803,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}`);
@@ -99744,11 +99839,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);
@@ -99779,7 +99869,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 {
@@ -99812,7 +99902,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) {
@@ -99846,7 +99936,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);
 }
@@ -100132,7 +100222,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;
@@ -100283,9 +100373,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();
@@ -100296,35 +100383,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: () => hexToBytes11,
-  extractSessionRecoveryToken: () => extractSessionRecoveryToken,
-  encryptChunk: () => encryptChunk,
-  deserializeSessionRecoveryToken: () => deserializeSessionRecoveryToken,
-  deriveResponseKeys: () => deriveResponseKeys,
-  decryptResponseWithToken: () => decryptResponseWithToken,
-  decryptChunk: () => decryptChunk,
-  createTransport: () => createTransport,
-  computeNonce: () => computeNonce,
-  bytesToHex: () => bytesToHex11,
-  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_esm5 = __esm(() => {
   init_identity();
   init_identity();
@@ -130139,6 +130198,650 @@ var init_dist16 = __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 i6 = 0;i6 < 8; i6++) {
+    const shift = i6 * 8;
+    if (shift < 32) {
+      nonce[AES_GCM_NONCE_LENGTH2 - 1 - i6] ^= 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 hexToBytes13(hex7) {
+  if (hex7.length % 2 !== 0) {
+    throw new Error("Hex string must have even length");
+  }
+  if (!/^[0-9a-fA-F]*$/.test(hex7)) {
+    throw new Error("Invalid hex character");
+  }
+  const bytes6 = new Uint8Array(hex7.length / 2);
+  for (let i6 = 0;i6 < bytes6.length; i6++) {
+    bytes6[i6] = parseInt(hex7.substring(i6 * 2, i6 * 2 + 2), 16);
+  }
+  return bytes6;
+}
+function bytesToHex15(bytes6) {
+  return Array.from(bytes6).map((b2) => b2.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 bytesToHex15(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 = hexToBytes13(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, bytesToHex15(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: bytesToHex15(token.exportedSecret),
+    requestEnc: bytesToHex15(token.requestEnc)
+  });
+}
+function deserializeSessionRecoveryToken2(json3) {
+  const parsed = JSON.parse(json3);
+  return {
+    exportedSecret: hexToBytes13(parsed.exportedSecret),
+    requestEnc: hexToBytes13(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 = hexToBytes13(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: () => hexToBytes13,
+  extractSessionRecoveryToken: () => extractSessionRecoveryToken2,
+  encryptChunk: () => encryptChunk2,
+  deserializeSessionRecoveryToken: () => deserializeSessionRecoveryToken2,
+  deriveResponseKeys: () => deriveResponseKeys2,
+  decryptResponseWithToken: () => decryptResponseWithToken2,
+  decryptChunk: () => decryptChunk2,
+  createTransport: () => createTransport2,
+  computeNonce: () => computeNonce2,
+  bytesToHex: () => bytesToHex15,
+  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_esm6 = __esm(() => {
+  init_identity2();
+  init_identity2();
+  init_client5();
+  init_protocol2();
+  init_errors6();
+  init_derive2();
+});
+
 // node_modules/@routstr/sdk/dist/index.mjs
 function makeConsoleLogger(prefix) {
   const fmt = (args) => prefix ? [prefix, ...args] : args;
@@ -130256,6 +130959,10 @@ function selectMintWithBalance(balances, units, amount, excludeMints = []) {
 function isKeyNotFoundResponse(status, body) {
   return status === 401 && typeof body === "string" && body.includes("Key not found");
 }
+function isOpenAiJsonBodyPath(pathname) {
+  const path2 = (pathname.split("?")[0] ?? "").replace(/\/+$/, "");
+  return OPENAI_JSON_BODY_PATHS.some((suffix) => path2.endsWith(suffix));
+}
 function newUserCacheSecret2() {
   try {
     const bytes6 = new Uint8Array(32);
@@ -130624,7 +131331,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();
@@ -130652,7 +131359,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,
@@ -130667,18 +131374,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_esm5(), exports_esm));
+  const ehbp = await Promise.resolve().then(() => (init_esm6(), exports_esm));
   const normalized = normalizeFetchArgs(input, init);
   const userCacheSecret = await resolveUserCacheSecret2({
     explicit: options.userCacheSecret,
@@ -130771,6 +131478,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 w5 = width;
   let h5 = height;
   if (w5 > 2048 || h5 > 2048) {
@@ -130798,6 +131509,233 @@ function calculateImageTokens(width, height, detail = "auto") {
   const numTiles = tilesWidth * tilesHeight;
   return 85 + 170 * numTiles;
 }
+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 fn3 = call?.function;
+        if (!fn3 || typeof fn3 !== "object")
+          continue;
+        total += textLength(fn3.name);
+        total += textLength(fn3.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;
+}
+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;
+}
 function extractCostBreakdown(costObj) {
   if (!costObj || typeof costObj !== "object")
     return {};
@@ -131936,584 +132874,7 @@ var consoleLogger, InsufficientBalanceError, ProviderError, FailoverError, Provi
       return cachedModels.length > 0 ? cachedModels : [];
     }
   }
-}, 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
-    });
-  }
-}, auditLogger, CashuSpender = class _CashuSpender {
-  constructor(walletAdapter, storageAdapter, _discoveryAdapter, balanceManager, logger4) {
-    this.walletAdapter = walletAdapter;
-    this.storageAdapter = storageAdapter;
-    this._discoveryAdapter = _discoveryAdapter;
-    this.balanceManager = balanceManager;
-    this.logger = (logger4 ?? consoleLogger).child("CashuSpender");
-  }
-  walletAdapter;
-  storageAdapter;
-  _discoveryAdapter;
-  balanceManager;
-  _isBusy = false;
-  debugLevel = "WARN";
-  logger;
-  static MAX_REFUND_RETRIES = 3;
-  static REFUND_RETRY_INTERVAL_MS = 120000;
-  _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 };
-    }
-  }
-  _decodeTokenAmount(token) {
-    try {
-      const metadata = ur3(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 url3 in mintBalances) {
-      const balance = mintBalances[url3];
-      const unit = units[url3];
-      const balanceInSats = getBalanceInSats(balance, unit);
-      normalizedMintBalances[url3] = 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
-    };
-  }
-  async _logTransaction(action, options) {
-    const balanceState = await this._getBalanceState();
-    await auditLogger.logBalanceSnapshot(action, balanceState, options);
-  }
-  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 InsufficientBalanceError(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 isNetworkErrorMessage(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 {
-        token = await this.walletAdapter.sendToken(mintUrl, adjustedAmount, p2pkPubkey);
-        selectedMintUrl = mintUrl;
-      } catch (error53) {
-        const errorMsg = error53 instanceof Error ? error53.message : String(error53);
-        return {
-          token: null,
-          status: "failed",
-          balance: 0,
-          error: `Error generating token: ${errorMsg}`
-        };
-      }
-    }
-    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 {
-      token,
-      status: "success",
-      balance: spentAmount,
-      unit: (selectedMintUrl ? units[selectedMintUrl] : units[mintUrl]) || "sat",
-      selectedMintUrl: selectedMintUrl || mintUrl
-    };
-  }
-  async _tryReuseToken(baseUrl, amount, mintUrl) {
-    const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
-    if (!apiKeyEntry)
-      return null;
-    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-    const balanceForBaseUrl = apiKeyDistribution.find((b2) => b2.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";
-        this._logTransaction("topup", {
-          amount: topUpResult.toppedUpAmount,
-          mintUrl,
-          baseUrl,
-          status: "success"
-        });
-        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 === CoreErrorType.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 && isHandledRedemptionError(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 >= _CashuSpender.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}/${_CashuSpender.MAX_REFUND_RETRIES}, will retry in ${_CashuSpender.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 ${_CashuSpender.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)}`);
-      }
-    }, _CashuSpender.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 InsufficientBalanceError(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;
-  }
-}, BalanceManager = class _BalanceManager {
+}, CashuSpender, BalanceManager = class _BalanceManager {
   constructor(walletAdapter, storageAdapter, discoveryAdapter, cashuSpender, logger4) {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
@@ -132617,7 +132978,7 @@ var consoleLogger, InsufficientBalanceError, ProviderError, FailoverError, Provi
     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 {
@@ -133267,7 +133628,7 @@ var consoleLogger, InsufficientBalanceError, ProviderError, FailoverError, Provi
   } catch {
     return trimmed.includes(TOR_ONION_SUFFIX);
   }
-}, USER_CACHE_SECRET_FIELD2 = "user_cache_secret", USER_CACHE_SECRET_ENV2 = "TINFOIL_USER_CACHE_SECRET", USER_CACHE_SECRET_PATHS2, USER_CACHE_SECRET_DIR_NAME2 = ".tinfoil", USER_CACHE_SECRET_FILE_NAME2 = "user_cache_secret", ephemeralUserCacheSecret2, warnedEphemeral = false, defaultUserCacheSecretPromise, customPathSecretPromises, TINFOIL_MODEL_PREFIX = "tinfoil-", clientCache, normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`, fetchProviderInfo = async (adapter, baseUrl, logger4) => {
+}, OPENAI_JSON_BODY_PATHS, USER_CACHE_SECRET_FIELD2 = "user_cache_secret", USER_CACHE_SECRET_ENV2 = "TINFOIL_USER_CACHE_SECRET", USER_CACHE_SECRET_PATHS2, USER_CACHE_SECRET_DIR_NAME2 = ".tinfoil", USER_CACHE_SECRET_FILE_NAME2 = "user_cache_secret", ephemeralUserCacheSecret2, warnedEphemeral = false, defaultUserCacheSecretPromise, customPathSecretPromises, TINFOIL_MODEL_PREFIX = "tinfoil-", clientCache, normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`, fetchProviderInfo = async (adapter, baseUrl, logger4) => {
   const normalized = normalizeBaseUrl2(baseUrl);
   const cached2 = adapter.getCachedProviderInfo()[normalized];
   if (cached2)
@@ -133287,7 +133648,7 @@ var consoleLogger, InsufficientBalanceError, ProviderError, FailoverError, Provi
     logger4.warn(`Failed to fetch provider info from ${normalized}:`, error53);
     return null;
   }
-}, ProviderManager = class _ProviderManager {
+}, IMAGE_PATCH_PX = 32, MAX_IMAGE_PATCHES = 30000, MAX_TILED_IMAGE_TOKENS = 765, MAX_ORIGINAL_IMAGE_TOKENS, NODE_TOLERANCE_PERCENT = 1, ProviderManager = class _ProviderManager {
   constructor(discoveryAdapter, store, logger4) {
     this.discoveryAdapter = discoveryAdapter;
     this.instanceId = `pm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
@@ -133529,35 +133890,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((m2) => {
-        if (Array.isArray(m2?.content)) {
-          const filtered = m2.content.filter((p2) => !(p2 && typeof p2 === "object" && p2.type === "image_url"));
-          return { ...m2, content: filtered };
-        }
-        return m2;
-      }) : 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) {
@@ -133572,11 +133943,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 (e41) {
       this.logger.error("getRequiredSatsForModel error:", e41);
-      return 0;
+      const sp = model2?.sats_pricing;
+      return sp?.max_cost ?? 50;
     }
   }
 }, canUseLocalStorage = () => {
@@ -134629,7 +135006,6 @@ ${ranking}`);
       const satsSpent = await this._handlePostResponseBalanceUpdate({
         token: prepared.tokenUsed,
         baseUrl: prepared.baseUrlUsed,
-        mintUrl: params.mintUrl,
         initialTokenBalance: prepared.tokenBalanceInSats,
         initialTokenBalanceUnknown: prepared.tokenBalanceUnknown,
         fallbackSatsSpent: usage?.satsCost,
@@ -134685,17 +135061,22 @@ ${ranking}`);
           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`);
@@ -135201,7 +135582,7 @@ ${ranking}`);
       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 });
@@ -135326,7 +135707,6 @@ ${ranking}`);
     const {
       token,
       baseUrl,
-      mintUrl,
       initialTokenBalance,
       initialTokenBalanceUnknown,
       fallbackSatsSpent,
@@ -135860,14 +136240,536 @@ var init_dist17 = __esm(() => {
   ]);
   MAX_EVENT_FUTURE_DRIFT_SECONDS = 15 * 60;
   DISCOVERY_KINDS = [38421, 38423, 38425];
-  auditLogger = AuditLogger.getInstance();
-  USER_CACHE_SECRET_PATHS2 = [
+  CashuSpender = class _CashuSpender {
+    constructor(walletAdapter, storageAdapter, _discoveryAdapter, balanceManager, logger4) {
+      this.walletAdapter = walletAdapter;
+      this.storageAdapter = storageAdapter;
+      this._discoveryAdapter = _discoveryAdapter;
+      this.balanceManager = balanceManager;
+      this.logger = (logger4 ?? consoleLogger).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 };
+      }
+    }
+    _decodeTokenAmount(token) {
+      try {
+        const metadata = ur3(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 url3 in mintBalances) {
+        const balance = mintBalances[url3];
+        const unit = units[url3];
+        const balanceInSats = getBalanceInSats(balance, unit);
+        normalizedMintBalances[url3] = 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
+      };
+    }
+    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 InsufficientBalanceError(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 isNetworkErrorMessage(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 {
+          token = await this.walletAdapter.sendToken(mintUrl, adjustedAmount, p2pkPubkey);
+          selectedMintUrl = mintUrl;
+        } catch (error53) {
+          const errorMsg = error53 instanceof Error ? error53.message : String(error53);
+          return {
+            token: null,
+            status: "failed",
+            balance: 0,
+            error: `Error generating token: ${errorMsg}`
+          };
+        }
+      }
+      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 _tryReuseToken(baseUrl, amount, mintUrl) {
+      const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+      if (!apiKeyEntry)
+        return null;
+      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+      const balanceForBaseUrl = apiKeyDistribution.find((b2) => b2.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 === CoreErrorType.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 && isHandledRedemptionError(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 >= _CashuSpender.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}/${_CashuSpender.MAX_REFUND_RETRIES}, will retry in ${_CashuSpender.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 ${_CashuSpender.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)}`);
+        }
+      }, _CashuSpender.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 InsufficientBalanceError(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;
+    }
+  };
+  OPENAI_JSON_BODY_PATHS = [
     "/chat/completions",
     "/completions",
     "/responses"
   ];
+  USER_CACHE_SECRET_PATHS2 = OPENAI_JSON_BODY_PATHS;
   customPathSecretPromises = /* @__PURE__ */ new Map;
   clientCache = /* @__PURE__ */ new Map;
+  MAX_ORIGINAL_IMAGE_TOKENS = Math.ceil(MAX_IMAGE_PATCHES * 1.2);
   NON_CRITICAL_KEYS = /* @__PURE__ */ new Set(["modelsFromAllProviders"]);
   localStorageDriver = {
     async getItem(key, defaultValue) {
@@ -136340,20 +137242,20 @@ __export(exports_utils3, {
   numberToBytesLE: () => numberToBytesLE6,
   numberToBytesBE: () => numberToBytesBE7,
   hexToNumber: () => hexToNumber7,
-  hexToBytes: () => hexToBytes13,
+  hexToBytes: () => hexToBytes14,
   equalBytes: () => equalBytes8,
   ensureBytes: () => ensureBytes4,
   createHmacDrbg: () => createHmacDrbg6,
   concatBytes: () => concatBytes14,
   bytesToNumberLE: () => bytesToNumberLE6,
   bytesToNumberBE: () => bytesToNumberBE6,
-  bytesToHex: () => bytesToHex15,
+  bytesToHex: () => bytesToHex16,
   bitSet: () => bitSet3,
   bitMask: () => bitMask6,
   bitLen: () => bitLen6,
   bitGet: () => bitGet3
 });
-function bytesToHex15(bytes7) {
+function bytesToHex16(bytes7) {
   if (!u8a8(bytes7))
     throw new Error("Uint8Array expected");
   let hex7 = "";
@@ -136371,7 +137273,7 @@ function hexToNumber7(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;
@@ -136389,27 +137291,27 @@ function hexToBytes13(hex7) {
   return array2;
 }
 function bytesToNumberBE6(bytes7) {
-  return hexToNumber7(bytesToHex15(bytes7));
+  return hexToNumber7(bytesToHex16(bytes7));
 }
 function bytesToNumberLE6(bytes7) {
   if (!u8a8(bytes7))
     throw new Error("Uint8Array expected");
-  return hexToNumber7(bytesToHex15(Uint8Array.from(bytes7).reverse()));
+  return hexToNumber7(bytesToHex16(Uint8Array.from(bytes7).reverse()));
 }
 function numberToBytesBE7(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 numberToBytesBE7(n, len).reverse();
 }
 function numberToVarBytesBE3(n) {
-  return hexToBytes13(numberToHexUnpadded6(n));
+  return hexToBytes14(numberToHexUnpadded6(n));
 }
 function ensureBytes4(title, hex7, expectedLength) {
   let res;
   if (typeof hex7 === "string") {
     try {
-      res = hexToBytes13(hex7);
+      res = hexToBytes14(hex7);
     } catch (e41) {
       throw new Error(`${title} must be valid hex string, got "${hex7}". Cause: ${e41}`);
     }
@@ -136975,7 +137877,7 @@ function weierstrassPoints3(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");
@@ -137266,7 +138168,7 @@ function weierstrassPoints3(opts) {
       return toBytes9(Point5, this, isCompressed);
     }
     toHex(isCompressed = true) {
-      return bytesToHex15(this.toRawBytes(isCompressed));
+      return bytesToHex16(this.toRawBytes(isCompressed));
     }
   }
   Point5.BASE = new Point5(CURVE.Gx, CURVE.Gy, Fp5.ONE);
@@ -137344,7 +138246,7 @@ function weierstrass6(curveDef) {
       }
     }
   });
-  const numToNByteStr = (num3) => bytesToHex15(numberToBytesBE7(num3, CURVE.nByteLength));
+  const numToNByteStr = (num3) => bytesToHex16(numberToBytesBE7(num3, CURVE.nByteLength));
   function isBiggerThanHalfOrder(number10) {
     const HALF = CURVE_ORDER >> _1n31;
     return number10 > HALF;
@@ -137405,13 +138307,13 @@ function weierstrass6(curveDef) {
       return this.hasHighS() ? new Signature(this.r, modN3(-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);
@@ -137906,7 +138808,7 @@ var init_cryptoNode7 = __esm(() => {
 });
 
 // node_modules/applesauce-sqlite/node_modules/applesauce-core/node_modules/nostr-tools/node_modules/@noble/hashes/esm/utils.js
-function bytesToHex16(bytes7) {
+function bytesToHex17(bytes7) {
   if (!u8a9(bytes7))
     throw new Error("Uint8Array expected");
   let hex7 = "";
@@ -137915,7 +138817,7 @@ function bytesToHex16(bytes7) {
   }
   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;
@@ -138597,7 +139499,7 @@ function genBech325(encoding2) {
   return { encode: encode5, decode: decode5, decodeToBytes, decodeUnsafe, fromWords, fromWordsUnsafe, toWords };
 }
 var gcd5 = (a, b2) => !b2 ? a : gcd5(b2, a % b2), radix2carry5 = (from7, to) => from7 + (to - gcd5(from7, to)), base165, base325, base32hex5, base32crockford5, base648, base64url7, genBase585 = (abc) => chain5(radix7(58), alphabet5(abc), join14("")), base585, base58flickr5, base58xrp5, XMR_BLOCK_LEN3, base58xmr3, BECH_ALPHABET5, POLYMOD_GENERATORS5, bech325, bech32m5, utf83, hex7, CODERS3, coderTypeError3;
-var init_esm6 = __esm(() => {
+var init_esm7 = __esm(() => {
   /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   base165 = chain5(radix25(4), alphabet5("0123456789ABCDEF"), join14(""));
   base325 = chain5(radix25(5), alphabet5("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding5(5), join14(""));
@@ -138693,7 +139595,7 @@ function output8(out, instance) {
 var init__assert8 = () => {};
 
 // node_modules/applesauce-sqlite/node_modules/applesauce-core/node_modules/nostr-tools/node_modules/@noble/ciphers/esm/utils.js
-function bytesToHex17(bytes9) {
+function bytesToHex18(bytes9) {
   bytes8(bytes9);
   let hex8 = "";
   for (let i6 = 0;i6 < bytes9.length; i6++) {
@@ -138710,7 +139612,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;
@@ -140340,7 +141242,7 @@ function serializeEvent6(evt) {
 }
 function getEventHash6(event3) {
   let eventHash = sha25611(utf8Encoder9.encode(serializeEvent6(event3)));
-  return bytesToHex16(eventHash);
+  return bytesToHex17(eventHash);
 }
 function isRegularKind5(kind) {
   return kind < 1e4 && kind !== 0 && kind !== 3;
@@ -140505,7 +141407,7 @@ function decode5(code) {
       return {
         type: "nprofile",
         data: {
-          pubkey: bytesToHex16(tlv[0][0]),
+          pubkey: bytesToHex17(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d2) => utf8Decoder7.decode(d2)) : []
         }
       };
@@ -140523,10 +141425,10 @@ function decode5(code) {
       return {
         type: "nevent",
         data: {
-          id: bytesToHex16(tlv[0][0]),
+          id: bytesToHex17(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d2) => utf8Decoder7.decode(d2)) : [],
-          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
         }
       };
     }
@@ -140546,8 +141448,8 @@ function decode5(code) {
         type: "naddr",
         data: {
           identifier: utf8Decoder7.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((d2) => utf8Decoder7.decode(d2)) : []
         }
       };
@@ -140556,7 +141458,7 @@ function decode5(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}`);
   }
@@ -140580,10 +141482,10 @@ function nsecEncode3(key) {
   return encodeBytes3("nsec", key);
 }
 function npubEncode4(hex8) {
-  return encodeBytes3("npub", hexToBytes14(hex8));
+  return encodeBytes3("npub", hexToBytes15(hex8));
 }
 function noteEncode3(hex8) {
-  return encodeBytes3("note", hexToBytes14(hex8));
+  return encodeBytes3("note", hexToBytes15(hex8));
 }
 function encodeBech323(prefix, data) {
   let words = bech325.toWords(data);
@@ -140594,7 +141496,7 @@ function encodeBytes3(prefix, bytes9) {
 }
 function nprofileEncode3(profile3) {
   let data = encodeTLV3({
-    0: [hexToBytes14(profile3.pubkey)],
+    0: [hexToBytes15(profile3.pubkey)],
     1: (profile3.relays || []).map((url3) => utf8Encoder9.encode(url3))
   });
   return encodeBech323("nprofile", data);
@@ -140605,9 +141507,9 @@ function neventEncode3(event3) {
     kindArray = integerToUint8Array3(event3.kind);
   }
   let data = encodeTLV3({
-    0: [hexToBytes14(event3.id)],
+    0: [hexToBytes15(event3.id)],
     1: (event3.relays || []).map((url3) => utf8Encoder9.encode(url3)),
-    2: event3.author ? [hexToBytes14(event3.author)] : [],
+    2: event3.author ? [hexToBytes15(event3.author)] : [],
     3: kindArray ? [new Uint8Array(kindArray)] : []
   });
   return encodeBech323("nevent", data);
@@ -140618,7 +141520,7 @@ function naddrEncode3(addr) {
   let data = encodeTLV3({
     0: [utf8Encoder9.encode(addr.identifier)],
     1: (addr.relays || []).map((url3) => utf8Encoder9.encode(url3)),
-    2: [hexToBytes14(addr.pubkey)],
+    2: [hexToBytes15(addr.pubkey)],
     3: [new Uint8Array(kind)]
   });
   return encodeBech323("naddr", data);
@@ -140637,7 +141539,7 @@ function encodeTLV3(tlv) {
   return concatBytes15(...entries);
 }
 function encrypt7(secretKey, pubkey, text) {
-  const privkey = secretKey instanceof Uint8Array ? bytesToHex16(secretKey) : secretKey;
+  const privkey = secretKey instanceof Uint8Array ? bytesToHex17(secretKey) : secretKey;
   const key = secp256k15.getSharedSecret(privkey, "02" + pubkey);
   const normalizedKey = getNormalizedX3(key);
   let iv = Uint8Array.from(randomBytes11(16));
@@ -140648,7 +141550,7 @@ function encrypt7(secretKey, pubkey, text) {
   return `${ctb64}?iv=${ivb64}`;
 }
 function decrypt6(secretKey, pubkey, 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" + pubkey);
   let normalizedKey = getNormalizedX3(key);
@@ -140837,7 +141739,7 @@ function minePow3(unsigned, difficulty) {
   return event3;
 }
 function fastEventHash2(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]))));
 }
 function getConversationKey3(privkeyA, pubkeyB) {
   const sharedX = secp256k15.getSharedSecret(privkeyA, "02" + pubkeyB).subarray(1, 33);
@@ -141585,7 +142487,7 @@ function validateEventMethodTag3(event3, method) {
 }
 function hashPayload5(payload) {
   const hash8 = sha25611(utf8Encoder9.encode(JSON.stringify(payload)));
-  return bytesToHex16(hash8);
+  return bytesToHex17(hash8);
 }
 function validateEventPayloadTag3(event3, payload) {
   const payloadTag = event3.tags.find((t) => t[0] === "payload");
@@ -141672,13 +142574,13 @@ var __defProp4, __export4 = (target, all) => {
     return schnorr5.utils.randomPrivateKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex16(schnorr5.getPublicKey(secretKey));
+    return bytesToHex17(schnorr5.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event3 = t;
-    event3.pubkey = bytesToHex16(schnorr5.getPublicKey(secretKey));
+    event3.pubkey = bytesToHex17(schnorr5.getPublicKey(secretKey));
     event3.id = getEventHash6(event3);
-    event3.sig = bytesToHex16(schnorr5.sign(getEventHash6(event3), secretKey));
+    event3.sig = bytesToHex17(schnorr5.sign(getEventHash6(event3), secretKey));
     event3[verifiedSymbol8] = true;
     return event3;
   }
@@ -142301,7 +143203,7 @@ var __defProp4, __export4 = (target, all) => {
   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 });
@@ -142394,10 +143296,10 @@ var __defProp4, __export4 = (target, all) => {
     let output9 = new WrappedBuffer4;
     output9.extend(new Uint8Array([PROTOCOL_VERSION4]));
     this.splitRange(0, this.storage.size(), this._bound(Number.MAX_VALUE), output9);
-    return bytesToHex17(output9.unwrap());
+    return bytesToHex18(output9.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]));
@@ -142440,22 +143342,22 @@ var __defProp4, __export4 = (target, all) => {
         let theirElems = {};
         for (let i22 = 0;i22 < numIds; i22++) {
           let e41 = getBytes5(query2, ID_SIZE4);
-          theirElems[bytesToHex17(e41)] = e41;
+          theirElems[bytesToHex18(e41)] = e41;
         }
         skip2 = true;
         this.storage.iterate(lower, upper, (item) => {
           let k5 = item.id;
-          const id = bytesToHex17(k5);
+          const id = bytesToHex18(k5);
           if (!theirElems[id]) {
             onhave?.(id);
           } else {
-            delete theirElems[bytesToHex17(k5)];
+            delete theirElems[bytesToHex18(k5)];
           }
           return true;
         });
         if (onneed) {
           for (let v4 of Object.values(theirElems)) {
-            onneed(bytesToHex17(v4));
+            onneed(bytesToHex18(v4));
           }
         }
       } else {
@@ -142473,7 +143375,7 @@ var __defProp4, __export4 = (target, all) => {
       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;
@@ -142626,17 +143528,17 @@ var __defProp4, __export4 = (target, all) => {
     this.subscription.close();
   }
 }, nip98_exports3, _authorizationScheme5 = "Nostr ";
-var init_esm7 = __esm(() => {
+var init_esm8 = __esm(() => {
   init_secp256k15();
   init_utils22();
   init_sha2566();
   init_utils22();
   init_utils22();
-  init_esm6();
+  init_esm7();
   init_utils22();
   init_secp256k15();
   init_aes4();
-  init_esm6();
+  init_esm7();
   init_utils22();
   init_sha2566();
   init_chacha3();
@@ -142646,13 +143548,13 @@ var init_esm7 = __esm(() => {
   init_hmac8();
   init_sha2566();
   init_utils22();
-  init_esm6();
-  init_esm6();
+  init_esm7();
+  init_esm7();
   init_utils23();
   init_sha2566();
   init_sha2566();
   init_utils22();
-  init_esm6();
+  init_esm7();
   __defProp4 = Object.defineProperty;
   verifiedSymbol8 = Symbol("verified");
   utils_exports3 = {};
@@ -142660,8 +143562,8 @@ var init_esm7 = __esm(() => {
     Queue: () => Queue2,
     QueueNode: () => QueueNode2,
     binarySearch: () => binarySearch4,
-    bytesToHex: () => bytesToHex16,
-    hexToBytes: () => hexToBytes14,
+    bytesToHex: () => bytesToHex17,
+    hexToBytes: () => hexToBytes15,
     insertEventIntoAscendingList: () => insertEventIntoAscendingList4,
     insertEventIntoDescendingList: () => insertEventIntoDescendingList4,
     normalizeURL: () => normalizeURL4,
@@ -143026,20 +143928,20 @@ function serializeEvent7(evt) {
 }
 function getEventHash7(event3) {
   let eventHash = sha25611(utf8Encoder10.encode(serializeEvent7(event3)));
-  return bytesToHex16(eventHash);
+  return bytesToHex17(eventHash);
 }
 var verifiedSymbol9, isRecord7 = (obj2) => obj2 instanceof Object, utf8Decoder8, utf8Encoder10, JS7 = class {
   generateSecretKey() {
     return schnorr5.utils.randomPrivateKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex16(schnorr5.getPublicKey(secretKey));
+    return bytesToHex17(schnorr5.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event3 = t;
-    event3.pubkey = bytesToHex16(schnorr5.getPublicKey(secretKey));
+    event3.pubkey = bytesToHex17(schnorr5.getPublicKey(secretKey));
     event3.id = getEventHash7(event3);
-    event3.sig = bytesToHex16(schnorr5.sign(getEventHash7(event3), secretKey));
+    event3.sig = bytesToHex17(schnorr5.sign(getEventHash7(event3), secretKey));
     event3[verifiedSymbol9] = true;
     return event3;
   }
@@ -143165,7 +144067,7 @@ function getReplaceableIdentifier2(event3) {
 }
 var EventStoreSymbol2, EventUIDSymbol2, ReplaceableAddressSymbol2, FromCacheSymbol2, ReplaceableIdentifierSymbol2;
 var init_event3 = __esm(() => {
-  init_esm7();
+  init_esm8();
   init_kinds2();
   init_utils24();
   EventStoreSymbol2 = Symbol.for("event-store");
@@ -143247,7 +144149,7 @@ var processTags2 = (tags3, ...fns) => {
 
 // node_modules/applesauce-sqlite/node_modules/applesauce-core/node_modules/nostr-tools/lib/esm/nip19.js
 function npubEncode5(hex8) {
-  return encodeBytes4("npub", hexToBytes14(hex8));
+  return encodeBytes4("npub", hexToBytes15(hex8));
 }
 function encodeBech324(prefix, data) {
   let words = bech325.toWords(data);
@@ -143258,7 +144160,7 @@ function encodeBytes4(prefix, bytes9) {
 }
 function nprofileEncode4(profile3) {
   let data = encodeTLV4({
-    0: [hexToBytes14(profile3.pubkey)],
+    0: [hexToBytes15(profile3.pubkey)],
     1: (profile3.relays || []).map((url3) => utf8Encoder12.encode(url3))
   });
   return encodeBech324("nprofile", data);
@@ -143279,7 +144181,7 @@ function encodeTLV4(tlv) {
 var utf8Decoder10, utf8Encoder12, Bech32MaxSize4 = 5000;
 var init_nip19 = __esm(() => {
   init_utils22();
-  init_esm6();
+  init_esm7();
   init_utils22();
   utf8Decoder10 = new TextDecoder("utf-8");
   utf8Encoder12 = new TextEncoder;
@@ -145955,7 +146857,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();
@@ -145969,7 +146871,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();
@@ -146492,7 +147394,28 @@ function makeConsoleLogger2(prefix) {
     child: (p2) => makeConsoleLogger2(prefix ? `${prefix}:${p2}` : p2)
   };
 }
-var consoleLogger2, ProviderBootstrapError2, NoProvidersAvailableError2, DEFAULT_NOSTR_RELAYS2, POSITIVE_REVIEW_LABELS2, NEGATIVE_REVIEW_LABELS2, PROVIDER_FETCH_TIMEOUT_MS2 = 1e4, NOSTR_QUERY_TIMEOUT_MS2 = 5000, MAX_EVENT_FUTURE_DRIFT_SECONDS2, DISCOVERY_KINDS2, PRUNE_CHUNK_SIZE2 = 500, ModelManager2 = class _ModelManager2 {
+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);
+}
+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 consoleLogger2, InsufficientBalanceError2, ProviderBootstrapError2, NoProvidersAvailableError2, CoreErrorType2, CoreErrorCode2, DEFAULT_NOSTR_RELAYS2, POSITIVE_REVIEW_LABELS2, NEGATIVE_REVIEW_LABELS2, PROVIDER_FETCH_TIMEOUT_MS2 = 1e4, NOSTR_QUERY_TIMEOUT_MS2 = 5000, MAX_EVENT_FUTURE_DRIFT_SECONDS2, DISCOVERY_KINDS2, PRUNE_CHUNK_SIZE2 = 500, ModelManager2 = class _ModelManager2 {
   constructor(adapter, config2 = {}) {
     this.adapter = adapter;
     this.providerDirectoryUrl = config2.providerDirectoryUrl || "https://api.routstr.com/v1/providers/";
@@ -147197,48 +148120,7 @@ var consoleLogger2, ProviderBootstrapError2, NoProvidersAvailableError2, DEFAULT
       return cachedModels.length > 0 ? cachedModels : [];
     }
   }
-}, AuditLogger2 = class _AuditLogger2 {
-  static instance = null;
-  static getInstance() {
-    if (!_AuditLogger2.instance) {
-      _AuditLogger2.instance = new _AuditLogger2;
-    }
-    return _AuditLogger2.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
-    });
-  }
-}, auditLogger2, createBunPersistentEventDatabase = async (dbPath) => {
+}, CashuSpender2, MAX_IMAGE_PATCHES2 = 30000, MAX_ORIGINAL_IMAGE_TOKENS2, createBunPersistentEventDatabase = async (dbPath) => {
   const { BunSqliteEventDatabase: BunSqliteEventDatabase2 } = await Promise.resolve().then(() => (init_bun(), exports_bun));
   return new BunSqliteEventDatabase2(dbPath);
 }, BunModelManager;
@@ -147248,6 +148130,20 @@ var init_bun2 = __esm(() => {
   init_helpers();
   init_cashu_ts_es3();
   consoleLogger2 = makeConsoleLogger2();
+  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;
+  };
   ProviderBootstrapError2 = class extends Error {
     constructor(failedProviders, message) {
       super(message || `Failed to bootstrap providers. Tried: ${failedProviders.join(", ")}`);
@@ -147262,6 +148158,32 @@ var init_bun2 = __esm(() => {
       this.name = "NoProvidersAvailableError";
     }
   };
+  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"
+  };
+  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"
+  };
   DEFAULT_NOSTR_RELAYS2 = [
     "wss://relay.damus.io",
     "wss://nos.lol",
@@ -147276,7 +148198,528 @@ var init_bun2 = __esm(() => {
   ]);
   MAX_EVENT_FUTURE_DRIFT_SECONDS2 = 15 * 60;
   DISCOVERY_KINDS2 = [38421, 38423, 38425];
-  auditLogger2 = AuditLogger2.getInstance();
+  CashuSpender2 = class _CashuSpender2 {
+    constructor(walletAdapter, storageAdapter, _discoveryAdapter, balanceManager, logger6) {
+      this.walletAdapter = walletAdapter;
+      this.storageAdapter = storageAdapter;
+      this._discoveryAdapter = _discoveryAdapter;
+      this.balanceManager = balanceManager;
+      this.logger = (logger6 ?? 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 };
+      }
+    }
+    _decodeTokenAmount(token) {
+      try {
+        const metadata = ur3(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
+      };
+    }
+    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 {
+          token = await this.walletAdapter.sendToken(mintUrl, adjustedAmount, p2pkPubkey);
+          selectedMintUrl = mintUrl;
+        } catch (error53) {
+          const errorMsg = error53 instanceof Error ? error53.message : String(error53);
+          return {
+            token: null,
+            status: "failed",
+            balance: 0,
+            error: `Error generating token: ${errorMsg}`
+          };
+        }
+      }
+      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 _tryReuseToken(baseUrl, amount, mintUrl) {
+      const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+      if (!apiKeyEntry)
+        return null;
+      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+      const balanceForBaseUrl = apiKeyDistribution.find((b2) => b2.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;
+    }
+  };
+  MAX_ORIGINAL_IMAGE_TOKENS2 = Math.ceil(MAX_IMAGE_PATCHES2 * 1.2);
   BunModelManager = class extends ModelManager2 {
     constructor(adapter, config2 = {}) {
       super(adapter, {
@@ -151495,20 +152938,20 @@ __export(exports_utils4, {
   numberToBytesLE: () => numberToBytesLE7,
   numberToBytesBE: () => numberToBytesBE8,
   hexToNumber: () => hexToNumber8,
-  hexToBytes: () => hexToBytes16,
+  hexToBytes: () => hexToBytes17,
   equalBytes: () => equalBytes10,
   ensureBytes: () => ensureBytes5,
   createHmacDrbg: () => createHmacDrbg7,
   concatBytes: () => concatBytes17,
   bytesToNumberLE: () => bytesToNumberLE7,
   bytesToNumberBE: () => bytesToNumberBE7,
-  bytesToHex: () => bytesToHex18,
+  bytesToHex: () => bytesToHex19,
   bitSet: () => bitSet4,
   bitMask: () => bitMask7,
   bitLen: () => bitLen7,
   bitGet: () => bitGet4
 });
-function bytesToHex18(bytes10) {
+function bytesToHex19(bytes10) {
   if (!u8a11(bytes10))
     throw new Error("Uint8Array expected");
   let hex8 = "";
@@ -151526,7 +152969,7 @@ function hexToNumber8(hex8) {
     throw new Error("hex string expected, got " + typeof hex8);
   return BigInt(hex8 === "" ? "0" : `0x${hex8}`);
 }
-function hexToBytes16(hex8) {
+function hexToBytes17(hex8) {
   if (typeof hex8 !== "string")
     throw new Error("hex string expected, got " + typeof hex8);
   const len = hex8.length;
@@ -151544,27 +152987,27 @@ function hexToBytes16(hex8) {
   return array2;
 }
 function bytesToNumberBE7(bytes10) {
-  return hexToNumber8(bytesToHex18(bytes10));
+  return hexToNumber8(bytesToHex19(bytes10));
 }
 function bytesToNumberLE7(bytes10) {
   if (!u8a11(bytes10))
     throw new Error("Uint8Array expected");
-  return hexToNumber8(bytesToHex18(Uint8Array.from(bytes10).reverse()));
+  return hexToNumber8(bytesToHex19(Uint8Array.from(bytes10).reverse()));
 }
 function numberToBytesBE8(n, len) {
-  return hexToBytes16(n.toString(16).padStart(len * 2, "0"));
+  return hexToBytes17(n.toString(16).padStart(len * 2, "0"));
 }
 function numberToBytesLE7(n, len) {
   return numberToBytesBE8(n, len).reverse();
 }
 function numberToVarBytesBE4(n) {
-  return hexToBytes16(numberToHexUnpadded7(n));
+  return hexToBytes17(numberToHexUnpadded7(n));
 }
 function ensureBytes5(title, hex8, expectedLength) {
   let res;
   if (typeof hex8 === "string") {
     try {
-      res = hexToBytes16(hex8);
+      res = hexToBytes17(hex8);
     } catch (e57) {
       throw new Error(`${title} must be valid hex string, got "${hex8}". Cause: ${e57}`);
     }
@@ -152130,7 +153573,7 @@ function weierstrassPoints4(opts) {
     const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
     if (lengths && typeof key !== "bigint") {
       if (key instanceof Uint8Array)
-        key = bytesToHex18(key);
+        key = bytesToHex19(key);
       if (typeof key !== "string" || !lengths.includes(key.length))
         throw new Error("Invalid key");
       key = key.padStart(nByteLength * 2, "0");
@@ -152421,7 +153864,7 @@ function weierstrassPoints4(opts) {
       return toBytes12(Point6, this, isCompressed);
     }
     toHex(isCompressed = true) {
-      return bytesToHex18(this.toRawBytes(isCompressed));
+      return bytesToHex19(this.toRawBytes(isCompressed));
     }
   }
   Point6.BASE = new Point6(CURVE.Gx, CURVE.Gy, Fp6.ONE);
@@ -152499,7 +153942,7 @@ function weierstrass7(curveDef) {
       }
     }
   });
-  const numToNByteStr = (num3) => bytesToHex18(numberToBytesBE8(num3, CURVE.nByteLength));
+  const numToNByteStr = (num3) => bytesToHex19(numberToBytesBE8(num3, CURVE.nByteLength));
   function isBiggerThanHalfOrder(number13) {
     const HALF = CURVE_ORDER >> _1n36;
     return number13 > HALF;
@@ -152560,13 +154003,13 @@ function weierstrass7(curveDef) {
       return this.hasHighS() ? new Signature(this.r, modN4(-this.s), this.recovery) : this;
     }
     toDERRawBytes() {
-      return hexToBytes16(this.toDERHex());
+      return hexToBytes17(this.toDERHex());
     }
     toDERHex() {
       return DER7.hexFromSig({ r: this.r, s: this.s });
     }
     toCompactRawBytes() {
-      return hexToBytes16(this.toCompactHex());
+      return hexToBytes17(this.toCompactHex());
     }
     toCompactHex() {
       return numToNByteStr(this.r) + numToNByteStr(this.s);
@@ -153061,7 +154504,7 @@ var init_cryptoNode9 = __esm(() => {
 });
 
 // node_modules/applesauce-wallet-connect/node_modules/applesauce-core/node_modules/nostr-tools/node_modules/@noble/hashes/esm/utils.js
-function bytesToHex19(bytes10) {
+function bytesToHex20(bytes10) {
   if (!u8a12(bytes10))
     throw new Error("Uint8Array expected");
   let hex8 = "";
@@ -153070,7 +154513,7 @@ function bytesToHex19(bytes10) {
   }
   return hex8;
 }
-function hexToBytes17(hex8) {
+function hexToBytes18(hex8) {
   if (typeof hex8 !== "string")
     throw new Error("hex string expected, got " + typeof hex8);
   const len = hex8.length;
@@ -153752,7 +155195,7 @@ function genBech326(encoding2) {
   return { encode: encode5, decode: decode7, decodeToBytes, decodeUnsafe, fromWords, fromWordsUnsafe, toWords };
 }
 var gcd6 = (a, b3) => !b3 ? a : gcd6(b3, a % b3), radix2carry6 = (from8, to) => from8 + (to - gcd6(from8, to)), base166, base326, base32hex6, base32crockford6, base649, base64url8, genBase586 = (abc) => chain6(radix8(58), alphabet6(abc), join15("")), base586, base58flickr6, base58xrp6, XMR_BLOCK_LEN4, base58xmr4, BECH_ALPHABET6, POLYMOD_GENERATORS6, bech326, bech32m6, utf84, hex8, CODERS4, coderTypeError4;
-var init_esm8 = __esm(() => {
+var init_esm9 = __esm(() => {
   /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   base166 = chain6(radix26(4), alphabet6("0123456789ABCDEF"), join15(""));
   base326 = chain6(radix26(5), alphabet6("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding6(5), join15(""));
@@ -153848,7 +155291,7 @@ function output11(out, instance) {
 var init__assert11 = () => {};
 
 // node_modules/applesauce-wallet-connect/node_modules/applesauce-core/node_modules/nostr-tools/node_modules/@noble/ciphers/esm/utils.js
-function bytesToHex20(bytes12) {
+function bytesToHex21(bytes12) {
   bytes11(bytes12);
   let hex9 = "";
   for (let i8 = 0;i8 < bytes12.length; i8++) {
@@ -153865,7 +155308,7 @@ function asciiToBase166(char) {
     return char - (asciis6._a - 10);
   return;
 }
-function hexToBytes18(hex9) {
+function hexToBytes19(hex9) {
   if (typeof hex9 !== "string")
     throw new Error("hex string expected, got " + typeof hex9);
   const hl = hex9.length;
@@ -155495,7 +156938,7 @@ function serializeEvent8(evt) {
 }
 function getEventHash8(event7) {
   let eventHash = sha25613(utf8Encoder13.encode(serializeEvent8(event7)));
-  return bytesToHex19(eventHash);
+  return bytesToHex20(eventHash);
 }
 function isRegularKind7(kind) {
   return kind < 1e4 && kind !== 0 && kind !== 3;
@@ -155660,7 +157103,7 @@ function decode7(code) {
       return {
         type: "nprofile",
         data: {
-          pubkey: bytesToHex19(tlv[0][0]),
+          pubkey: bytesToHex20(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d2) => utf8Decoder11.decode(d2)) : []
         }
       };
@@ -155678,10 +157121,10 @@ function decode7(code) {
       return {
         type: "nevent",
         data: {
-          id: bytesToHex19(tlv[0][0]),
+          id: bytesToHex20(tlv[0][0]),
           relays: tlv[1] ? tlv[1].map((d2) => utf8Decoder11.decode(d2)) : [],
-          author: tlv[2]?.[0] ? bytesToHex19(tlv[2][0]) : undefined,
-          kind: tlv[3]?.[0] ? parseInt(bytesToHex19(tlv[3][0]), 16) : undefined
+          author: tlv[2]?.[0] ? bytesToHex20(tlv[2][0]) : undefined,
+          kind: tlv[3]?.[0] ? parseInt(bytesToHex20(tlv[3][0]), 16) : undefined
         }
       };
     }
@@ -155701,8 +157144,8 @@ function decode7(code) {
         type: "naddr",
         data: {
           identifier: utf8Decoder11.decode(tlv[0][0]),
-          pubkey: bytesToHex19(tlv[2][0]),
-          kind: parseInt(bytesToHex19(tlv[3][0]), 16),
+          pubkey: bytesToHex20(tlv[2][0]),
+          kind: parseInt(bytesToHex20(tlv[3][0]), 16),
           relays: tlv[1] ? tlv[1].map((d2) => utf8Decoder11.decode(d2)) : []
         }
       };
@@ -155711,7 +157154,7 @@ function decode7(code) {
       return { type: prefix, data };
     case "npub":
     case "note":
-      return { type: prefix, data: bytesToHex19(data) };
+      return { type: prefix, data: bytesToHex20(data) };
     default:
       throw new Error(`unknown prefix ${prefix}`);
   }
@@ -155735,10 +157178,10 @@ function nsecEncode5(key) {
   return encodeBytes5("nsec", key);
 }
 function npubEncode6(hex9) {
-  return encodeBytes5("npub", hexToBytes17(hex9));
+  return encodeBytes5("npub", hexToBytes18(hex9));
 }
 function noteEncode5(hex9) {
-  return encodeBytes5("note", hexToBytes17(hex9));
+  return encodeBytes5("note", hexToBytes18(hex9));
 }
 function encodeBech325(prefix, data) {
   let words = bech326.toWords(data);
@@ -155749,7 +157192,7 @@ function encodeBytes5(prefix, bytes12) {
 }
 function nprofileEncode5(profile6) {
   let data = encodeTLV5({
-    0: [hexToBytes17(profile6.pubkey)],
+    0: [hexToBytes18(profile6.pubkey)],
     1: (profile6.relays || []).map((url4) => utf8Encoder13.encode(url4))
   });
   return encodeBech325("nprofile", data);
@@ -155760,9 +157203,9 @@ function neventEncode5(event7) {
     kindArray = integerToUint8Array4(event7.kind);
   }
   let data = encodeTLV5({
-    0: [hexToBytes17(event7.id)],
+    0: [hexToBytes18(event7.id)],
     1: (event7.relays || []).map((url4) => utf8Encoder13.encode(url4)),
-    2: event7.author ? [hexToBytes17(event7.author)] : [],
+    2: event7.author ? [hexToBytes18(event7.author)] : [],
     3: kindArray ? [new Uint8Array(kindArray)] : []
   });
   return encodeBech325("nevent", data);
@@ -155773,7 +157216,7 @@ function naddrEncode5(addr) {
   let data = encodeTLV5({
     0: [utf8Encoder13.encode(addr.identifier)],
     1: (addr.relays || []).map((url4) => utf8Encoder13.encode(url4)),
-    2: [hexToBytes17(addr.pubkey)],
+    2: [hexToBytes18(addr.pubkey)],
     3: [new Uint8Array(kind)]
   });
   return encodeBech325("naddr", data);
@@ -155792,7 +157235,7 @@ function encodeTLV5(tlv) {
   return concatBytes18(...entries);
 }
 function encrypt9(secretKey, pubkey2, text) {
-  const privkey = secretKey instanceof Uint8Array ? bytesToHex19(secretKey) : secretKey;
+  const privkey = secretKey instanceof Uint8Array ? bytesToHex20(secretKey) : secretKey;
   const key = secp256k16.getSharedSecret(privkey, "02" + pubkey2);
   const normalizedKey = getNormalizedX4(key);
   let iv = Uint8Array.from(randomBytes13(16));
@@ -155803,7 +157246,7 @@ function encrypt9(secretKey, pubkey2, text) {
   return `${ctb64}?iv=${ivb64}`;
 }
 function decrypt8(secretKey, pubkey2, data) {
-  const privkey = secretKey instanceof Uint8Array ? bytesToHex19(secretKey) : secretKey;
+  const privkey = secretKey instanceof Uint8Array ? bytesToHex20(secretKey) : secretKey;
   let [ctb64, ivb64] = data.split("?iv=");
   let key = secp256k16.getSharedSecret(privkey, "02" + pubkey2);
   let normalizedKey = getNormalizedX4(key);
@@ -155992,7 +157435,7 @@ function minePow4(unsigned, difficulty) {
   return event7;
 }
 function fastEventHash3(evt) {
-  return bytesToHex19(sha25613(utf8Encoder13.encode(JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]))));
+  return bytesToHex20(sha25613(utf8Encoder13.encode(JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content]))));
 }
 function getConversationKey4(privkeyA, pubkeyB) {
   const sharedX = secp256k16.getSharedSecret(privkeyA, "02" + pubkeyB).subarray(1, 33);
@@ -156740,7 +158183,7 @@ function validateEventMethodTag4(event7, method) {
 }
 function hashPayload6(payload) {
   const hash10 = sha25613(utf8Encoder13.encode(JSON.stringify(payload)));
-  return bytesToHex19(hash10);
+  return bytesToHex20(hash10);
 }
 function validateEventPayloadTag4(event7, payload) {
   const payloadTag = event7.tags.find((t) => t[0] === "payload");
@@ -156827,13 +158270,13 @@ var __defProp5, __export5 = (target, all) => {
     return schnorr6.utils.randomPrivateKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex19(schnorr6.getPublicKey(secretKey));
+    return bytesToHex20(schnorr6.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event7 = t;
-    event7.pubkey = bytesToHex19(schnorr6.getPublicKey(secretKey));
+    event7.pubkey = bytesToHex20(schnorr6.getPublicKey(secretKey));
     event7.id = getEventHash8(event7);
-    event7.sig = bytesToHex19(schnorr6.sign(getEventHash8(event7), secretKey));
+    event7.sig = bytesToHex20(schnorr6.sign(getEventHash8(event7), secretKey));
     event7[verifiedSymbol11] = true;
     return event7;
   }
@@ -157456,7 +158899,7 @@ var __defProp5, __export5 = (target, all) => {
   insert(timestamp, id) {
     if (this.sealed)
       throw Error("already sealed");
-    const idb = hexToBytes18(id);
+    const idb = hexToBytes19(id);
     if (idb.byteLength !== ID_SIZE5)
       throw Error("bad id size for added item");
     this.items.push({ timestamp, id: idb });
@@ -157549,10 +158992,10 @@ var __defProp5, __export5 = (target, all) => {
     let output12 = new WrappedBuffer5;
     output12.extend(new Uint8Array([PROTOCOL_VERSION5]));
     this.splitRange(0, this.storage.size(), this._bound(Number.MAX_VALUE), output12);
-    return bytesToHex20(output12.unwrap());
+    return bytesToHex21(output12.unwrap());
   }
   reconcile(queryMsg, onhave, onneed) {
-    const query2 = new WrappedBuffer5(hexToBytes18(queryMsg));
+    const query2 = new WrappedBuffer5(hexToBytes19(queryMsg));
     this.lastTimestampIn = this.lastTimestampOut = 0;
     let fullOutput = new WrappedBuffer5;
     fullOutput.extend(new Uint8Array([PROTOCOL_VERSION5]));
@@ -157595,22 +159038,22 @@ var __defProp5, __export5 = (target, all) => {
         let theirElems = {};
         for (let i22 = 0;i22 < numIds; i22++) {
           let e57 = getBytes6(query2, ID_SIZE5);
-          theirElems[bytesToHex20(e57)] = e57;
+          theirElems[bytesToHex21(e57)] = e57;
         }
         skip3 = true;
         this.storage.iterate(lower, upper, (item) => {
           let k6 = item.id;
-          const id = bytesToHex20(k6);
+          const id = bytesToHex21(k6);
           if (!theirElems[id]) {
             onhave?.(id);
           } else {
-            delete theirElems[bytesToHex20(k6)];
+            delete theirElems[bytesToHex21(k6)];
           }
           return true;
         });
         if (onneed) {
           for (let v4 of Object.values(theirElems)) {
-            onneed(bytesToHex20(v4));
+            onneed(bytesToHex21(v4));
           }
         }
       } else {
@@ -157628,7 +159071,7 @@ var __defProp5, __export5 = (target, all) => {
       prevIndex = upper;
       prevBound = currBound;
     }
-    return fullOutput.length === 1 ? null : bytesToHex20(fullOutput.unwrap());
+    return fullOutput.length === 1 ? null : bytesToHex21(fullOutput.unwrap());
   }
   splitRange(lower, upper, upperBound, o) {
     let numElems = upper - lower;
@@ -157781,17 +159224,17 @@ var __defProp5, __export5 = (target, all) => {
     this.subscription.close();
   }
 }, nip98_exports4, _authorizationScheme6 = "Nostr ";
-var init_esm9 = __esm(() => {
+var init_esm10 = __esm(() => {
   init_secp256k16();
   init_utils27();
   init_sha2568();
   init_utils27();
   init_utils27();
-  init_esm8();
+  init_esm9();
   init_utils27();
   init_secp256k16();
   init_aes5();
-  init_esm8();
+  init_esm9();
   init_utils27();
   init_sha2568();
   init_chacha4();
@@ -157801,13 +159244,13 @@ var init_esm9 = __esm(() => {
   init_hmac10();
   init_sha2568();
   init_utils27();
-  init_esm8();
-  init_esm8();
+  init_esm9();
+  init_esm9();
   init_utils28();
   init_sha2568();
   init_sha2568();
   init_utils27();
-  init_esm8();
+  init_esm9();
   __defProp5 = Object.defineProperty;
   verifiedSymbol11 = Symbol("verified");
   utils_exports4 = {};
@@ -157815,8 +159258,8 @@ var init_esm9 = __esm(() => {
     Queue: () => Queue3,
     QueueNode: () => QueueNode3,
     binarySearch: () => binarySearch6,
-    bytesToHex: () => bytesToHex19,
-    hexToBytes: () => hexToBytes17,
+    bytesToHex: () => bytesToHex20,
+    hexToBytes: () => hexToBytes18,
     insertEventIntoAscendingList: () => insertEventIntoAscendingList6,
     insertEventIntoDescendingList: () => insertEventIntoDescendingList6,
     normalizeURL: () => normalizeURL6,
@@ -158181,20 +159624,20 @@ function serializeEvent9(evt) {
 }
 function getEventHash9(event7) {
   let eventHash = sha25613(utf8Encoder14.encode(serializeEvent9(event7)));
-  return bytesToHex19(eventHash);
+  return bytesToHex20(eventHash);
 }
 var verifiedSymbol12, isRecord10 = (obj2) => obj2 instanceof Object, utf8Decoder12, utf8Encoder14, JS9 = class {
   generateSecretKey() {
     return schnorr6.utils.randomPrivateKey();
   }
   getPublicKey(secretKey) {
-    return bytesToHex19(schnorr6.getPublicKey(secretKey));
+    return bytesToHex20(schnorr6.getPublicKey(secretKey));
   }
   finalizeEvent(t, secretKey) {
     const event7 = t;
-    event7.pubkey = bytesToHex19(schnorr6.getPublicKey(secretKey));
+    event7.pubkey = bytesToHex20(schnorr6.getPublicKey(secretKey));
     event7.id = getEventHash9(event7);
-    event7.sig = bytesToHex19(schnorr6.sign(getEventHash9(event7), secretKey));
+    event7.sig = bytesToHex20(schnorr6.sign(getEventHash9(event7), secretKey));
     event7[verifiedSymbol12] = true;
     return event7;
   }
@@ -158330,7 +159773,7 @@ function getTagValue3(event7, name16) {
 }
 var EventStoreSymbol3, EventUIDSymbol3, ReplaceableAddressSymbol3, FromCacheSymbol3, ReplaceableIdentifierSymbol3;
 var init_event7 = __esm(() => {
-  init_esm9();
+  init_esm10();
   init_kinds3();
   init_pure3();
   init_utils29();
@@ -158481,7 +159924,7 @@ var processTags3 = (tags5, ...fns) => {
 
 // node_modules/applesauce-wallet-connect/node_modules/applesauce-core/node_modules/nostr-tools/lib/esm/nip19.js
 function npubEncode7(hex9) {
-  return encodeBytes6("npub", hexToBytes17(hex9));
+  return encodeBytes6("npub", hexToBytes18(hex9));
 }
 function encodeBech326(prefix, data) {
   let words = bech326.toWords(data);
@@ -158492,7 +159935,7 @@ function encodeBytes6(prefix, bytes12) {
 }
 function nprofileEncode6(profile6) {
   let data = encodeTLV6({
-    0: [hexToBytes17(profile6.pubkey)],
+    0: [hexToBytes18(profile6.pubkey)],
     1: (profile6.relays || []).map((url4) => utf8Encoder16.encode(url4))
   });
   return encodeBech326("nprofile", data);
@@ -158513,7 +159956,7 @@ function encodeTLV6(tlv) {
 var utf8Decoder14, utf8Encoder16, Bech32MaxSize6 = 5000;
 var init_nip192 = __esm(() => {
   init_utils27();
-  init_esm8();
+  init_esm9();
   init_utils27();
   utf8Decoder14 = new TextDecoder("utf-8");
   utf8Encoder16 = new TextEncoder;
@@ -159657,7 +161100,7 @@ function isNIP04Encrypted(ciphertext) {
   return ciphertext[l2 - 28] == "?" && ciphertext[l2 - 27] == "i" && ciphertext[l2 - 26] == "v" && ciphertext[l2 - 25] == "=";
 }
 var init_encryption = __esm(() => {
-  init_esm9();
+  init_esm10();
 });
 
 // node_modules/applesauce-wallet-connect/dist/helpers/encryption.js
@@ -161972,7 +163415,7 @@ var init_models4 = __esm(() => {
 
 // node_modules/applesauce-wallet-connect/node_modules/applesauce-core/dist/operations/client.js
 var NEVER_ATTACH_CLIENT_TAG3;
-var init_client6 = __esm(() => {
+var init_client7 = __esm(() => {
   init_event7();
   init_pointers3();
   init_tags3();
@@ -161986,7 +163429,7 @@ var init_hidden_content6 = __esm(() => {
 
 // node_modules/applesauce-wallet-connect/node_modules/applesauce-core/dist/operations/index.js
 var init_operations3 = __esm(() => {
-  init_client6();
+  init_client7();
   init_content6();
   init_encrypted_content8();
   init_event8();
@@ -162016,7 +163459,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":
@@ -162037,7 +163480,7 @@ function createWalletError(code, message) {
       return new OtherError(message);
   }
 }
-var WalletBaseError, RateLimitedError, NotImplementedError, InsufficientBalanceError2, QuotaExceededError, RestrictedError, UnauthorizedError, InternalError, UnsupportedEncryptionError, PaymentFailedError, NotFoundError2, OtherError;
+var WalletBaseError, RateLimitedError, NotImplementedError, InsufficientBalanceError3, QuotaExceededError, RestrictedError, UnauthorizedError, InternalError, UnsupportedEncryptionError, PaymentFailedError, NotFoundError2, OtherError;
 var init_error5 = __esm(() => {
   WalletBaseError = class WalletBaseError extends Error {
     constructor(message) {
@@ -162051,7 +163494,7 @@ var init_error5 = __esm(() => {
   NotImplementedError = class NotImplementedError extends WalletBaseError {
     code = "NOT_IMPLEMENTED";
   };
-  InsufficientBalanceError2 = class InsufficientBalanceError2 extends WalletBaseError {
+  InsufficientBalanceError3 = class InsufficientBalanceError3 extends WalletBaseError {
     code = "INSUFFICIENT_BALANCE";
   };
   QuotaExceededError = class QuotaExceededError extends WalletBaseError {
@@ -163523,6 +164966,35 @@ var init_usage_summary = __esm(() => {
   };
 });
 
+// src/daemon/http/request-body.ts
+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;
+}
+var OPENAI_JSON_BODY_PATH_SUFFIXES;
+var init_request_body = __esm(() => {
+  OPENAI_JSON_BODY_PATH_SUFFIXES = [
+    "/chat/completions",
+    "/completions",
+    "/responses"
+  ];
+});
+
 // src/daemon/http/index.ts
 import { randomBytes as randomBytes14 } from "crypto";
 import { Readable } from "stream";
@@ -164752,16 +166224,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)) {
@@ -164874,6 +166337,7 @@ var init_http = __esm(() => {
   init_wallet();
   init_clients();
   init_usage_summary();
+  init_request_body();
   HOP_BY_HOP_HEADERS = new Set([
     "connection",
     "keep-alive",
@@ -166193,46 +167657,111 @@ function truncateNpub(npub) {
     return npub;
   return npub.slice(0, 10) + "\u2026" + npub.slice(-6);
 }
+function tokenSegments(entry) {
+  const cacheRead = Math.max(0, entry.cacheReadInputTokens || 0);
+  const cacheWrite = Math.max(0, entry.cacheCreationInputTokens || 0);
+  const prompt = Math.max(0, entry.promptTokens || 0);
+  const output12 = Math.max(0, entry.completionTokens || 0);
+  const cached2 = cacheRead + cacheWrite;
+  const uncachedInput = prompt >= cached2 ? prompt - cached2 : prompt;
+  const notCached = cacheWrite + uncachedInput;
+  const input = cacheRead + notCached;
+  return { cacheRead, notCached, input, output: output12, total: input + output12 };
+}
+function renderStackedBar(segments, trackWidth) {
+  const track = Math.max(0, Math.floor(trackWidth));
+  if (track === 0)
+    return "";
+  const values2 = segments.map((segment) => Math.max(0, segment.value));
+  const total = values2.reduce((sum, value) => sum + value, 0);
+  if (total <= 0)
+    return " ".repeat(track);
+  const exact = values2.map((value) => value / total * track);
+  const cells = exact.map((value) => Math.floor(value));
+  let remaining = track - cells.reduce((sum, value) => sum + value, 0);
+  const remainders = exact.map((value, index) => ({ index, frac: value - Math.floor(value) })).sort((a, b3) => b3.frac - a.frac);
+  for (let i10 = 0;i10 < remainders.length && remaining > 0; i10++, remaining--) {
+    cells[remainders[i10].index] += 1;
+  }
+  const bar = segments.map((segment, i10) => cells[i10] > 0 ? `${segment.color}${"\u2588".repeat(cells[i10])}` : "").join("");
+  return bar.length > 0 ? bar + COLORS.reset : " ".repeat(track);
+}
 function renderRecent(stats, width, naming) {
   const recentEntries = stats.entries.slice(0, 50);
   if (recentEntries.length === 0)
     return renderBox(["No recent entries"], width, "Recent Requests");
-  const timeCol = 10;
-  const modelCol = 18;
-  const tokensCol = 18;
-  const costCol = 18;
+  const timeCol = 8;
+  const costCol = 12;
+  const minBarWidth = "CACHE HIT".length;
+  const maxBarWidth = 20;
+  const minProviderCol = 12;
+  const minModelCol = 10;
+  const minClientCol = 6;
   const hasOwnerInfo = naming.npubs.length > 0 || naming.ownersByClientId.size > 0;
   const clientLabels = recentEntries.map((entry) => hasOwnerInfo ? resolveClientLabel(entry.client, naming) : entry.client || "unknown");
   const maxLabelLen = clientLabels.reduce((max, label) => Math.max(max, label.length), 6);
-  const clientCol = hasOwnerInfo ? Math.min(32, Math.max(14, maxLabelLen)) : 14;
+  const tokenRows = recentEntries.map((entry) => tokenSegments(entry));
+  const inputTexts = tokenRows.map((row) => formatNumber2(row.input));
+  const outputTexts = tokenRows.map((row) => formatNumber2(row.output));
+  const inputCol = Math.max(...inputTexts.map((text) => text.length));
+  const outputCol = Math.max(...outputTexts.map((text) => text.length));
+  const inOutCol = inputCol + outputCol + " - ".length;
   const innerWidth = Math.max(0, width - 4);
-  const providerCol = Math.max(12, innerWidth - timeCol - modelCol - tokensCol - costCol - 5 - clientCol);
-  const msatsToSats = (msats) => typeof msats === "number" ? msats / 1000 : 0;
+  let modelCol = 18;
+  let clientCol = hasOwnerInfo ? Math.min(32, Math.max(14, maxLabelLen)) : 14;
+  let barWidth = maxBarWidth;
+  let showProvider = false;
+  let providerCol = 0;
+  const usedWidth = () => timeCol + modelCol + (barWidth + 1 + inOutCol) + costCol + clientCol + (showProvider ? providerCol + 1 : 0) + 4;
+  if (innerWidth - usedWidth() > minProviderCol + 1) {
+    showProvider = true;
+    providerCol = innerWidth - usedWidth();
+  }
+  while (usedWidth() > innerWidth && barWidth > minBarWidth)
+    barWidth -= 1;
+  while (usedWidth() > innerWidth && providerCol > minProviderCol)
+    providerCol -= 1;
+  while (usedWidth() > innerWidth && modelCol > minModelCol)
+    modelCol -= 1;
+  while (usedWidth() > innerWidth && clientCol > minClientCol)
+    clientCol -= 1;
+  const tokensCol = barWidth + 1 + inOutCol;
   const lines = [];
-  lines.push(`${COLORS.bold}${["TIME".padEnd(timeCol), "MODEL".padEnd(modelCol), "I/CR/CW/O".padEnd(tokensCol), "I/O/T in sats".padEnd(costCol), "BASE:PROVIDER".padEnd(providerCol), "CLIENT".padEnd(clientCol)].join(" ")}${COLORS.reset}`);
-  lines.push(COLORS.dim + "\u2500".repeat(width - 4) + COLORS.reset);
+  const header = [
+    "TIME".padEnd(timeCol),
+    "MODEL".padEnd(modelCol),
+    "CACHE HIT".padEnd(tokensCol - inOutCol) + "IN".padEnd(inputCol) + " - " + "OUT".padStart(outputCol),
+    "COST".padStart(costCol),
+    ...showProvider ? ["BASE:PROVIDER".padEnd(providerCol)] : [],
+    "CLIENT".padEnd(clientCol)
+  ];
+  lines.push(`${COLORS.bold}${header.join(" ")}${COLORS.reset}`);
+  lines.push(COLORS.dim + "\u2500".repeat(innerWidth) + COLORS.reset);
   for (let i10 = 0;i10 < recentEntries.length; i10++) {
     const entry = recentEntries[i10];
     const time6 = formatTime(entry.timestamp).slice(0, 8);
     const model4 = entry.modelId.slice(0, modelCol).padEnd(modelCol);
-    const tokens = [
-      entry.promptTokens,
-      entry.cacheReadInputTokens || 0,
-      entry.cacheCreationInputTokens || 0,
-      entry.completionTokens
-    ].map(formatNumber2).join("/");
+    const segments = tokenRows[i10];
+    const bar = renderStackedBar([
+      { value: segments.cacheRead, color: TOKEN_BAR_COLORS.cacheRead },
+      { value: segments.notCached, color: TOKEN_BAR_COLORS.notCached }
+    ], barWidth);
+    const tokens = `${bar} ${inputTexts[i10].padEnd(inputCol)} - ${outputTexts[i10].padStart(outputCol)}`;
     const totalSats = typeof entry.totalMsats === "number" ? entry.totalMsats / 1000 : entry.satsCost;
-    const cost = [
-      formatCost(msatsToSats(entry.inputMsats)),
-      formatCost(msatsToSats(entry.outputMsats)),
-      formatCost(totalSats)
-    ].join("/");
+    const cost = `${formatCost(totalSats)} sats`.padStart(costCol);
     const baseUrl = (entry.baseUrl || "unknown").replace("https://", "").replace("http://", "");
     const provider = `${baseUrl}:${entry.provider || "unknown"}`.slice(0, providerCol).padEnd(providerCol);
     const clientLabel = clientLabels[i10].slice(0, clientCol).padEnd(clientCol);
     const clientColor = CLIENT_COLORS[entry.client || "unknown"] || CLIENT_COLORS.default || COLORS.white;
     const modelColor = MODEL_COLORS[entry.modelId] || MODEL_COLORS.default;
-    lines.push(`${COLORS.dim}${time6}${COLORS.reset} ${modelColor}${model4}${COLORS.reset} ${tokens.padEnd(tokensCol)} ${COLORS.green}${cost.padEnd(costCol)}${COLORS.reset} ${COLORS.dim}${provider}${COLORS.reset} ${clientColor}${clientLabel}${COLORS.reset}`);
+    lines.push([
+      `${COLORS.dim}${time6}${COLORS.reset}`,
+      `${modelColor}${model4}${COLORS.reset}`,
+      tokens,
+      `${COLORS.green}${cost.padEnd(costCol)}${COLORS.reset}`,
+      ...showProvider ? [`${COLORS.dim}${provider}${COLORS.reset}`] : [],
+      `${clientColor}${clientLabel}${COLORS.reset}`
+    ].join(" "));
   }
   return renderBox(lines, width, `Recent Requests (${stats.entries.length} shown)`);
 }
@@ -166258,12 +167787,16 @@ function renderTabContent(activeTab, stats, balance, status, width, naming) {
       return "Unknown tab";
   }
 }
-var _sectionMaxLabelLen;
+var _sectionMaxLabelLen, TOKEN_BAR_COLORS;
 var init_render = __esm(() => {
   init_constants2();
   init_data();
   init_state();
   _sectionMaxLabelLen = new Map;
+  TOKEN_BAR_COLORS = {
+    cacheRead: COLORS.green,
+    notCached: COLORS.red
+  };
 });
 
 // src/tui/usage/app.ts