@routstr/sdk 0.3.6 → 0.3.7

package/dist/client/index.js

@@ -1,4824 +0,0 @@
-'use strict';
-
-var cashuTs = require('@cashu/cashu-ts');
-var vanilla = require('zustand/vanilla');
-var stream = require('stream');
-var string_decoder = require('string_decoder');
-
-// core/types.ts
-function makeConsoleLogger(prefix) {
-  const fmt = (args) => prefix ? [prefix, ...args] : args;
-  return {
-    log: (...args) => console.log(...fmt(args)),
-    warn: (...args) => console.warn(...fmt(args)),
-    error: (...args) => console.error(...fmt(args)),
-    debug: (...args) => console.log(...fmt(args)),
-    child: (p) => makeConsoleLogger(prefix ? `${prefix}:${p}` : p)
-  };
-}
-var consoleLogger = makeConsoleLogger();
-
-// core/errors.ts
-var InsufficientBalanceError = class extends Error {
-  constructor(required, available, maxMintBalance = 0, maxMintUrl = "", customMessage) {
-    super(
-      customMessage ?? `Insufficient balance: need ${required} sats, have ${available} sats available. ` + (maxMintBalance > 0 ? `Largest mint balance: ${maxMintBalance} sats from ${maxMintUrl}` : "")
-    );
-    this.required = required;
-    this.available = available;
-    this.maxMintBalance = maxMintBalance;
-    this.maxMintUrl = maxMintUrl;
-    this.name = "InsufficientBalanceError";
-  }
-};
-var ProviderError = class extends Error {
-  constructor(baseUrl, statusCode, message, requestId) {
-    super(
-      `Provider ${baseUrl} returned ${statusCode}: ${message}` + (requestId ? ` (Request ID: ${requestId})` : "")
-    );
-    this.baseUrl = baseUrl;
-    this.statusCode = statusCode;
-    this.requestId = requestId;
-    this.name = "ProviderError";
-  }
-};
-var FailoverError = class extends Error {
-  constructor(originalProvider, failedProviders, message) {
-    super(
-      message || `All providers failed. Original: ${originalProvider}, Failed: ${failedProviders.join(", ")}`
-    );
-    this.originalProvider = originalProvider;
-    this.failedProviders = failedProviders;
-    this.name = "FailoverError";
-  }
-};
-
-// wallet/AuditLogger.ts
-var AuditLogger = class _AuditLogger {
-  static instance = null;
-  static getInstance() {
-    if (!_AuditLogger.instance) {
-      _AuditLogger.instance = new _AuditLogger();
-    }
-    return _AuditLogger.instance;
-  }
-  async log(entry) {
-    const fullEntry = {
-      ...entry,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const logLine = JSON.stringify(fullEntry) + "\n";
-    if (typeof window === "undefined") {
-      try {
-        const fs = await import('fs');
-        const path = await import('path');
-        const logPath = path.join(process.cwd(), "audit.log");
-        fs.appendFileSync(logPath, logLine);
-      } catch (error) {
-        console.error("[AuditLogger] Failed to write to file:", error);
-      }
-    } else {
-      console.log("[AUDIT]", logLine.trim());
-    }
-  }
-  async logBalanceSnapshot(action, amounts, options) {
-    await this.log({
-      action,
-      totalBalance: amounts.totalBalance,
-      providerBalances: amounts.providerBalances,
-      mintBalances: amounts.mintBalances,
-      amount: options?.amount,
-      mintUrl: options?.mintUrl,
-      baseUrl: options?.baseUrl,
-      status: options?.status ?? "success",
-      details: options?.details
-    });
-  }
-};
-var auditLogger = AuditLogger.getInstance();
-
-// wallet/tokenUtils.ts
-function isNetworkErrorMessage(message) {
-  return message.includes("NetworkError when attempting to fetch resource") || message.includes("Failed to fetch") || message.includes("Load failed") || 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 getBalanceInSats(balance, unit) {
-  return unit === "msat" ? balance / 1e3 : balance;
-}
-function selectMintWithBalance(balances, units, amount, excludeMints = []) {
-  for (const mintUrl in balances) {
-    if (excludeMints.includes(mintUrl)) {
-      continue;
-    }
-    const balanceInSats = getBalanceInSats(balances[mintUrl], units[mintUrl]);
-    if (balanceInSats >= amount) {
-      return { selectedMintUrl: mintUrl, selectedMintBalance: balanceInSats };
-    }
-  }
-  return { selectedMintUrl: null, selectedMintBalance: 0 };
-}
-var CashuSpender = class {
-  constructor(walletAdapter, storageAdapter, _providerRegistry, balanceManager, logger) {
-    this.walletAdapter = walletAdapter;
-    this.storageAdapter = storageAdapter;
-    this._providerRegistry = _providerRegistry;
-    this.balanceManager = balanceManager;
-    this.logger = (logger ?? consoleLogger).child("CashuSpender");
-  }
-  _isBusy = false;
-  debugLevel = "WARN";
-  logger;
-  async receiveToken(token) {
-    try {
-      const result = await this.walletAdapter.receiveToken(token);
-      return result;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      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 decoded = cashuTs.getDecodedToken(token);
-      const amount = decoded.proofs.reduce(
-        (acc, proof) => acc + proof.amount,
-        0
-      );
-      const unit = decoded.unit || "sat";
-      return { 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 url in mintBalances) {
-      const balance = mintBalances[url];
-      const unit = units[url];
-      const balanceInSats = getBalanceInSats(balance, unit);
-      normalizedMintBalances[url] = 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);
-  }
-  /**
-   * Check if the spender is currently in a critical operation
-   */
-  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;
-      }
-    }
-  }
-  /**
-   * Spend Cashu tokens with automatic mint selection and retry logic
-   * Throws errors on failure instead of returning failed SpendResult
-   */
-  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;
-    }
-  }
-  /**
-   * Check if error message indicates a network error
-   */
-  _isNetworkError(message) {
-    return isNetworkErrorMessage(message) || message.includes("Your mint") && message.includes("unreachable");
-  }
-  /**
-   * Internal spending logic
-   */
-  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 (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        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"
-    };
-  }
-  /**
-   * Try to reuse an existing API key
-   */
-  async _tryReuseToken(baseUrl, amount, mintUrl) {
-    const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
-    if (!apiKeyEntry) return null;
-    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-    const balanceForBaseUrl = apiKeyDistribution.find((b) => b.baseUrl === baseUrl)?.amount || 0;
-    this._log("DEBUG", "Reusing API key", balanceForBaseUrl, amount);
-    if (balanceForBaseUrl > amount) {
-      const units = this.walletAdapter.getMintUnits();
-      const unit = units[mintUrl] || "sat";
-      return {
-        token: apiKeyEntry.key,
-        status: "success",
-        balance: balanceForBaseUrl,
-        unit
-      };
-    }
-    if (this.balanceManager) {
-      const topUpAmount = Math.ceil(amount * 1.2 - balanceForBaseUrl);
-      const topUpResult = await this.balanceManager.topUp({
-        mintUrl,
-        baseUrl,
-        amount: topUpAmount,
-        token: apiKeyEntry.key
-      });
-      this._log("DEBUG", "TOPUP ", topUpResult);
-      if (topUpResult.success && topUpResult.toppedUpAmount) {
-        const newBalance = balanceForBaseUrl + topUpResult.toppedUpAmount;
-        const units = this.walletAdapter.getMintUnits();
-        const unit = units[mintUrl] || "sat";
-        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;
-  }
-  /**
-   * Refund all xcashu tokens from storage by calling the provider's refund endpoint.
-   * The xcashu token acts as an API key to claim the refund, and the response contains
-   * the actual refunded Cashu token which is then received into the wallet.
-   * @param mintUrl - The mint URL for receiving tokens
-   * @param excludeBaseUrls - Base URLs to exclude from refund (optional)
-   * @returns Results for each xcashu token refund attempt
-   */
-  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.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 (error) {
-          const currentTryCount = xcashuToken.tryCount ?? 0;
-          const newTryCount = currentTryCount + 1;
-          this.storageAdapter.updateXcashuTokenTryCount(
-            xcashuToken.token,
-            newTryCount
-          );
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          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;
-  }
-  /**
-   * Refund specific providers without retrying spend
-   */
-  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.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
-            results.push({
-              baseUrl: apiKeyEntry.baseUrl,
-              success: true
-            });
-            continue;
-          }
-          if (balanceResult.amount >= 0) {
-            const balanceSat = balanceResult.unit === "msat" ? Math.floor(balanceResult.amount / 1e3) : balanceResult.amount;
-            this.storageAdapter.updateApiKeyBalance(
-              apiKeyEntry.baseUrl,
-              balanceSat
-            );
-          }
-        } catch {
-        }
-        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
-          );
-          if (currentEntry) {
-            this.storageAdapter.updateApiKeyBalance(
-              apiKeyEntry.baseUrl,
-              currentEntry.balance
-            );
-          }
-        }
-        results.push({
-          baseUrl: apiKeyEntry.baseUrl,
-          success: refundResult.success
-        });
-      } else {
-        results.push({
-          baseUrl: apiKeyEntry.baseUrl,
-          success: false
-        });
-      }
-    }
-    return results;
-  }
-  /**
-   * Create an insufficient balance error result
-   */
-  _createInsufficientBalanceError(required, normalizedBalances, availableBalance) {
-    let maxBalance = 0;
-    let maxMintUrl = "";
-    for (const mintUrl in normalizedBalances) {
-      const balanceInSats = normalizedBalances[mintUrl];
-      if (balanceInSats > maxBalance) {
-        maxBalance = balanceInSats;
-        maxMintUrl = mintUrl;
-      }
-    }
-    const error = new InsufficientBalanceError(
-      required,
-      availableBalance ?? maxBalance,
-      maxBalance,
-      maxMintUrl
-    );
-    return {
-      token: null,
-      status: "failed",
-      balance: 0,
-      error: error.message,
-      errorDetails: {
-        required,
-        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 / 1e3;
-      }
-    } catch {
-      return 0;
-    }
-    return 0;
-  }
-};
-
-// wallet/BalanceManager.ts
-var BalanceManager = class _BalanceManager {
-  constructor(walletAdapter, storageAdapter, providerRegistry, cashuSpender, logger) {
-    this.walletAdapter = walletAdapter;
-    this.storageAdapter = storageAdapter;
-    this.providerRegistry = providerRegistry;
-    this.logger = (logger ?? consoleLogger).child("BalanceManager");
-    if (cashuSpender) {
-      this.cashuSpender = cashuSpender;
-    } else {
-      this.cashuSpender = new CashuSpender(
-        walletAdapter,
-        storageAdapter,
-        providerRegistry,
-        this
-      );
-    }
-  }
-  cashuSpender;
-  /** In-memory guard for per-provider wallet mutations (topup / refund) */
-  providerWalletOps = /* @__PURE__ */ new Map();
-  /** Cooldown (ms) between opposite operations on the same provider */
-  static PROVIDER_WALLET_COOLDOWN_MS = 1e4;
-  logger;
-  /**
-   * Check whether a wallet operation (topup/refund) may run for a provider.
-   * Returns the reason when blocked.
-   */
-  _canRunProviderWalletOperation(baseUrl, type) {
-    const existing = this.providerWalletOps.get(baseUrl);
-    if (!existing) {
-      return { allowed: true };
-    }
-    if (existing.type === type) {
-      return { allowed: true };
-    }
-    if (!existing.endTime) {
-      return {
-        allowed: false,
-        reason: `Provider wallet operation locked; ${existing.type} in progress`
-      };
-    }
-    const elapsed = Date.now() - existing.endTime;
-    if (elapsed < _BalanceManager.PROVIDER_WALLET_COOLDOWN_MS) {
-      return {
-        allowed: false,
-        reason: `Provider wallet operation locked; recent ${existing.type} completed ${Math.round(elapsed / 1e3)}s ago`
-      };
-    }
-    this.providerWalletOps.delete(baseUrl);
-    return { allowed: true };
-  }
-  _beginProviderWalletOperation(baseUrl, type) {
-    this.providerWalletOps.set(baseUrl, { type, startTime: Date.now() });
-  }
-  _endProviderWalletOperation(baseUrl, type) {
-    const existing = this.providerWalletOps.get(baseUrl);
-    if (existing && existing.type === type) {
-      existing.endTime = Date.now();
-    }
-  }
-  async getBalanceState() {
-    const mintBalances = await this.walletAdapter.getBalances();
-    const units = this.walletAdapter.getMintUnits();
-    let totalMintBalance = 0;
-    const normalizedMintBalances = {};
-    for (const url in mintBalances) {
-      const balance = mintBalances[url];
-      const unit = units[url];
-      const balanceInSats = getBalanceInSats(balance, unit);
-      normalizedMintBalances[url] = 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
-    };
-  }
-  /**
-   * Refund API key balance - convert remaining API key balance to cashu token
-   * @param options - Refund options including forceRefund flag
-   * @returns Refund result
-   */
-  async refundApiKey(options) {
-    const { mintUrl, baseUrl, apiKey, forceRefund } = options;
-    const guard = this._canRunProviderWalletOperation(baseUrl, "refund");
-    if (!guard.allowed) {
-      this.logger.log(`Skipping refund for ${baseUrl} - ${guard.reason}`);
-      return { success: false, message: guard.reason };
-    }
-    this._beginProviderWalletOperation(baseUrl, "refund");
-    try {
-      return await this._refundApiKeyImpl({ mintUrl, baseUrl, apiKey, forceRefund });
-    } finally {
-      this._endProviderWalletOperation(baseUrl, "refund");
-    }
-  }
-  async _refundApiKeyImpl(options) {
-    const { mintUrl, baseUrl, apiKey, forceRefund } = options;
-    if (!apiKey) {
-      return { success: false, message: "No API key to refund" };
-    }
-    if (!forceRefund) {
-      const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
-      if (apiKeyEntry?.lastUsed) {
-        const fiveMinutesAgo = Date.now() - 5 * 60 * 1e3;
-        if (apiKeyEntry.lastUsed > fiveMinutesAgo) {
-          this.logger.log(`Skipping refund for ${baseUrl} - used ${Math.round((Date.now() - apiKeyEntry.lastUsed) / 1e3)}s ago`);
-          return {
-            success: false,
-            message: "API key was used recently, skipping refund"
-          };
-        }
-      }
-    }
-    let fetchResult;
-    try {
-      fetchResult = await this.fetchRefundToken(baseUrl, apiKey);
-      if (!fetchResult.success) {
-        return {
-          success: false,
-          message: fetchResult.error || "API key refund failed",
-          requestId: fetchResult.requestId
-        };
-      }
-      if (!fetchResult.token) {
-        return {
-          success: false,
-          message: "No token received from API key refund",
-          requestId: fetchResult.requestId
-        };
-      }
-      if (fetchResult.error === "No balance to refund") {
-        this.storageAdapter.removeApiKey(baseUrl);
-        return { success: true, message: "No balance to refund, key cleaned up" };
-      }
-      const receiveResult = await this.cashuSpender.receiveToken(
-        fetchResult.token
-      );
-      const totalAmountMsat = receiveResult.unit === "msat" ? receiveResult.amount : receiveResult.amount * 1e3;
-      if (receiveResult.success) {
-        this.storageAdapter.removeApiKey(baseUrl);
-      }
-      return {
-        success: receiveResult.success,
-        refundedAmount: totalAmountMsat,
-        message: receiveResult.message,
-        requestId: fetchResult.requestId
-      };
-    } catch (error) {
-      this.logger.error("API key refund error", error);
-      return this._handleRefundError(error, mintUrl, fetchResult?.requestId);
-    }
-  }
-  /**
-   * Fetch refund token from provider API using API key (or xcashu token) authentication
-   */
-  async fetchRefundToken(baseUrl, apiKeyOrToken, xCashu = false) {
-    if (!baseUrl) {
-      return {
-        success: false,
-        error: "No base URL configured"
-      };
-    }
-    const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-    const url = `${normalizedBaseUrl}v1/wallet/refund`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => {
-      controller.abort();
-    }, 6e4);
-    try {
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (xCashu) {
-        headers["X-Cashu"] = apiKeyOrToken;
-      } else {
-        headers["Authorization"] = `Bearer ${apiKeyOrToken}`;
-      }
-      const response = await fetch(url, {
-        method: "POST",
-        headers,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      const requestId = response.headers.get("x-routstr-request-id") || void 0;
-      if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
-        return {
-          success: false,
-          requestId,
-          error: `API key refund failed: ${errorData?.detail || response.statusText}`
-        };
-      }
-      const data = await response.json();
-      return {
-        success: true,
-        token: data.token,
-        requestId
-      };
-    } catch (error) {
-      clearTimeout(timeoutId);
-      this.logger.error("fetchRefundToken fetch error", error);
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          return {
-            success: false,
-            error: "Request timed out after 1 minute"
-          };
-        }
-        return {
-          success: false,
-          error: error.message
-        };
-      }
-      return {
-        success: false,
-        error: "Unknown error occurred during API key refund request"
-      };
-    }
-  }
-  /**
-   * Top up API key balance with a cashu token
-   */
-  async topUp(options) {
-    const { mintUrl, baseUrl, amount, token: providedToken } = options;
-    const guard = this._canRunProviderWalletOperation(baseUrl, "topup");
-    if (!guard.allowed) {
-      this.logger.log(`Skipping topup for ${baseUrl} - ${guard.reason}`);
-      return { success: false, message: guard.reason };
-    }
-    this._beginProviderWalletOperation(baseUrl, "topup");
-    try {
-      return await this._topUpImpl({ mintUrl, baseUrl, amount, token: providedToken });
-    } finally {
-      this._endProviderWalletOperation(baseUrl, "topup");
-    }
-  }
-  async _topUpImpl(options) {
-    const { mintUrl, baseUrl, amount, token: providedToken } = options;
-    if (!amount || amount <= 0) {
-      return { success: false, message: "Invalid top up amount" };
-    }
-    const apiKeyEntry = providedToken ? null : this.storageAdapter.getApiKey(baseUrl);
-    const apiKey = providedToken || apiKeyEntry?.key;
-    if (!apiKey) {
-      return { success: false, message: "No API key available for top up" };
-    }
-    let cashuToken = null;
-    let requestId;
-    try {
-      const tokenResult = await this.createProviderToken({
-        mintUrl,
-        baseUrl,
-        amount
-      });
-      if (!tokenResult.success || !tokenResult.token) {
-        return {
-          success: false,
-          message: tokenResult.error || "Unable to create top up token"
-        };
-      }
-      cashuToken = tokenResult.token;
-      const topUpResult = await this._postTopUp(baseUrl, apiKey, cashuToken);
-      requestId = topUpResult.requestId;
-      this.logger.log("topUpResult:", topUpResult);
-      if (!topUpResult.success) {
-        await this._recoverFailedTopUp(cashuToken);
-        return {
-          success: false,
-          message: topUpResult.error || "Top up failed",
-          requestId,
-          recoveredToken: true
-        };
-      }
-      return {
-        success: true,
-        toppedUpAmount: amount,
-        requestId
-      };
-    } catch (error) {
-      this.logger.log(`topup error for ${baseUrl}: ${error}`);
-      if (cashuToken) {
-        await this._recoverFailedTopUp(cashuToken);
-      }
-      return this._handleTopUpError(error, mintUrl, requestId);
-    }
-  }
-  async createProviderToken(options) {
-    const {
-      mintUrl,
-      baseUrl,
-      amount,
-      retryCount = 0,
-      excludeMints = [],
-      p2pkPubkey
-    } = options;
-    const adjustedAmount = Math.ceil(amount);
-    this.logger.log(`createProviderToken: baseUrl=${baseUrl} mintUrl=${mintUrl} amount=${amount} adjustedAmount=${adjustedAmount} retryCount=${retryCount}`);
-    if (!adjustedAmount || isNaN(adjustedAmount)) {
-      this.logger.error(`createProviderToken: invalid amount=${amount}`);
-      return { success: false, error: "Invalid top up amount" };
-    }
-    const balanceState = await this.getBalanceState();
-    const balances = await this.walletAdapter.getBalances();
-    const units = this.walletAdapter.getMintUnits();
-    const totalMintBalance = Object.values(balanceState.mintBalances).reduce(
-      (sum, value) => sum + value,
-      0
-    );
-    const targetProviderBalance = balanceState.providerBalances[baseUrl] || 0;
-    const refundableProviderBalance = Object.entries(
-      balanceState.providerBalances
-    ).filter(([providerBaseUrl]) => providerBaseUrl !== baseUrl).reduce((sum, [, value]) => sum + value, 0);
-    if (totalMintBalance + targetProviderBalance < adjustedAmount && totalMintBalance + targetProviderBalance + refundableProviderBalance >= adjustedAmount && retryCount < 2) {
-      await this._refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount);
-      return this.createProviderToken({
-        ...options,
-        retryCount: retryCount + 1
-      });
-    }
-    if (totalMintBalance + targetProviderBalance < adjustedAmount) {
-      const error = new InsufficientBalanceError(
-        adjustedAmount,
-        totalMintBalance + targetProviderBalance,
-        totalMintBalance,
-        Object.entries(balanceState.mintBalances).reduce(
-          (max, [url, balance]) => balance > max.balance ? { url, balance } : max,
-          { url: "", balance: 0 }
-        ).url
-      );
-      this.logger.error(`createProviderToken: insufficient balance required=${adjustedAmount} available=${totalMintBalance + targetProviderBalance} totalMint=${totalMintBalance} targetProvider=${targetProviderBalance}`);
-      return { success: false, error: error.message };
-    }
-    const providerMints = baseUrl && this.providerRegistry ? this.providerRegistry.getProviderMints(baseUrl) : [];
-    let requiredAmount = adjustedAmount;
-    const supportedMintsOnly = providerMints.length > 0;
-    let candidates = this._selectCandidateMints({
-      balances,
-      units,
-      amount: requiredAmount,
-      preferredMintUrl: mintUrl,
-      excludeMints,
-      allowedMints: supportedMintsOnly ? providerMints : void 0
-    });
-    if (candidates.length === 0 && supportedMintsOnly) {
-      requiredAmount += 2;
-      candidates = this._selectCandidateMints({
-        balances,
-        units,
-        amount: requiredAmount,
-        preferredMintUrl: mintUrl,
-        excludeMints
-      });
-    }
-    if (candidates.length === 0) {
-      let maxBalance = 0;
-      let maxMintUrl = "";
-      for (const mintUrl2 in balances) {
-        const balance = balances[mintUrl2];
-        const unit = units[mintUrl2];
-        const balanceInSats = getBalanceInSats(balance, unit);
-        if (balanceInSats > maxBalance) {
-          maxBalance = balanceInSats;
-          maxMintUrl = mintUrl2;
-        }
-      }
-      this.logger.error(`createProviderToken: no candidate mints required=${requiredAmount} totalMint=${totalMintBalance} maxBalance=${maxBalance} maxMint=${maxMintUrl}`);
-      const error = new InsufficientBalanceError(
-        adjustedAmount,
-        totalMintBalance,
-        maxBalance,
-        maxMintUrl
-      );
-      return { success: false, error: error.message };
-    }
-    let lastError;
-    for (const candidateMint of candidates) {
-      try {
-        this.logger.log(`createProviderToken: attempting mint=${candidateMint} amount=${requiredAmount}`);
-        const token = await this.walletAdapter.sendToken(
-          candidateMint,
-          requiredAmount,
-          p2pkPubkey
-        );
-        this.logger.log(`createProviderToken: success from mint=${candidateMint}`);
-        return {
-          success: true,
-          token,
-          selectedMintUrl: candidateMint,
-          amountSpent: requiredAmount
-        };
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        this.logger.error(`createProviderToken: mint=${candidateMint} failed: ${errorMsg}`);
-        if (error instanceof Error) {
-          lastError = errorMsg;
-          if (isNetworkErrorMessage(error.message)) {
-            this.logger.warn(`createProviderToken: network error from ${candidateMint}, trying next mint...`);
-            continue;
-          }
-        }
-        return {
-          success: false,
-          error: lastError || "Failed to create top up token"
-        };
-      }
-    }
-    this.logger.error(`createProviderToken: all candidate mints exhausted lastError=${lastError}`);
-    return {
-      success: false,
-      error: lastError || "All candidate mints failed while creating top up token"
-    };
-  }
-  _selectCandidateMints(options) {
-    const {
-      balances,
-      units,
-      amount,
-      preferredMintUrl,
-      excludeMints,
-      allowedMints
-    } = options;
-    const candidates = [];
-    const { selectedMintUrl: firstMint } = selectMintWithBalance(
-      balances,
-      units,
-      amount,
-      excludeMints
-    );
-    if (firstMint && (!allowedMints || allowedMints.length === 0 || allowedMints.includes(firstMint))) {
-      candidates.push(firstMint);
-    }
-    const canUseMint = (mint) => {
-      if (excludeMints.includes(mint)) return false;
-      if (allowedMints && allowedMints.length > 0 && !allowedMints.includes(mint)) {
-        return false;
-      }
-      const rawBalance = balances[mint] || 0;
-      const unit = units[mint];
-      const balanceInSats = getBalanceInSats(rawBalance, unit);
-      return balanceInSats >= amount;
-    };
-    if (preferredMintUrl && canUseMint(preferredMintUrl) && !candidates.includes(preferredMintUrl)) {
-      candidates.push(preferredMintUrl);
-    }
-    for (const mint in balances) {
-      if (mint === preferredMintUrl || candidates.includes(mint)) continue;
-      if (canUseMint(mint)) {
-        candidates.push(mint);
-      }
-    }
-    return candidates;
-  }
-  async _refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount) {
-    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-    const forceRefund = retryCount >= 2;
-    const apiKeysToRefund = apiKeyDistribution.filter(
-      (apiKey) => apiKey.baseUrl !== baseUrl && apiKey.amount > 0
-    );
-    const apiKeyRefundResults = await Promise.allSettled(
-      apiKeysToRefund.map(async (apiKeyEntry) => {
-        const fullApiKeyEntry = this.storageAdapter.getApiKey(
-          apiKeyEntry.baseUrl
-        );
-        if (!fullApiKeyEntry) {
-          return { baseUrl: apiKeyEntry.baseUrl, success: false };
-        }
-        const result = await this.refundApiKey({
-          mintUrl,
-          baseUrl: apiKeyEntry.baseUrl,
-          apiKey: fullApiKeyEntry.key,
-          forceRefund
-        });
-        return { baseUrl: apiKeyEntry.baseUrl, success: result.success };
-      })
-    );
-    for (const result of apiKeyRefundResults) {
-      if (result.status === "fulfilled" && result.value.success) {
-        this.storageAdapter.updateApiKeyBalance(result.value.baseUrl, 0);
-      }
-    }
-  }
-  /**
-   * Post topup request to provider API
-   */
-  async _postTopUp(baseUrl, storedToken, cashuToken) {
-    if (!baseUrl) {
-      return {
-        success: false,
-        error: "No base URL configured"
-      };
-    }
-    const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-    const url = `${normalizedBaseUrl}v1/wallet/topup?cashu_token=${encodeURIComponent(
-      cashuToken
-    )}`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => {
-      controller.abort();
-    }, 6e4);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${storedToken}`,
-          "Content-Type": "application/json"
-        },
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      const requestId = response.headers.get("x-routstr-request-id") || void 0;
-      if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
-        return {
-          success: false,
-          requestId,
-          error: errorData?.detail || `Top up failed with status ${response.status}`
-        };
-      }
-      return { success: true, requestId };
-    } catch (error) {
-      clearTimeout(timeoutId);
-      this.logger.error("_postTopUp fetch error", error);
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          return {
-            success: false,
-            error: "Request timed out after 1 minute"
-          };
-        }
-        return {
-          success: false,
-          error: error.message
-        };
-      }
-      return {
-        success: false,
-        error: "Unknown error occurred during top up request"
-      };
-    }
-  }
-  /**
-   * Attempt to receive token back after failed top up
-   */
-  async _recoverFailedTopUp(cashuToken) {
-    try {
-      await this.cashuSpender.receiveToken(cashuToken);
-    } catch (error) {
-      this.logger.error("_recoverFailedTopUp: failed to recover token", error);
-    }
-  }
-  /**
-   * Handle refund errors with specific error types
-   */
-  _handleRefundError(error, mintUrl, requestId) {
-    if (error instanceof Error) {
-      if (isNetworkErrorMessage(error.message)) {
-        return {
-          success: false,
-          message: `Failed to connect to the mint: ${mintUrl}`,
-          requestId
-        };
-      }
-      if (error.message.includes("Wallet not found")) {
-        return {
-          success: false,
-          message: `Wallet couldn't be loaded. Please save this refunded cashu token manually.`,
-          requestId
-        };
-      }
-      return {
-        success: false,
-        message: error.message,
-        requestId
-      };
-    }
-    return {
-      success: false,
-      message: "Refund failed",
-      requestId
-    };
-  }
-  /**
-   * Get token balance from provider
-   */
-  async getTokenBalance(token, baseUrl) {
-    try {
-      const response = await fetch(`${baseUrl}v1/wallet/info`, {
-        headers: {
-          Authorization: `Bearer ${token}`
-        }
-      });
-      if (response.ok) {
-        const data = await response.json();
-        return {
-          amount: data.balance,
-          reserved: data.reserved ?? 0,
-          unit: "msat",
-          apiKey: data.api_key
-        };
-      } else {
-        this.logger.warn(`getTokenBalance: status=${response.status}`);
-        const data = await response.json();
-        this.logger.warn("getTokenBalance: FAILED", data);
-        const isInvalidApiKey = response.status === 401 && data?.detail?.error?.code === "invalid_api_key" && data?.detail?.error?.message?.includes("proofs already spent");
-        return {
-          amount: -1,
-          reserved: data.reserved ?? 0,
-          unit: "msat",
-          apiKey: data.api_key,
-          isInvalidApiKey
-        };
-      }
-    } catch (error) {
-      this.logger.error("getTokenBalance error", error);
-    }
-    return { amount: -1, reserved: 0, unit: "sat", apiKey: "" };
-  }
-  /**
-   * Handle topup errors with specific error types
-   */
-  _handleTopUpError(error, mintUrl, requestId) {
-    if (error instanceof Error) {
-      if (isNetworkErrorMessage(error.message)) {
-        return {
-          success: false,
-          message: `Failed to connect to the mint: ${mintUrl}`,
-          requestId
-        };
-      }
-      if (error.message.includes("Wallet not found")) {
-        return {
-          success: false,
-          message: "Wallet couldn't be loaded. The cashu token was recovered locally.",
-          requestId
-        };
-      }
-      return {
-        success: false,
-        message: error.message,
-        requestId
-      };
-    }
-    return {
-      success: false,
-      message: "Top up failed",
-      requestId
-    };
-  }
-};
-
-// client/usage.ts
-function extractUsageFromResponseBody(body, fallbackSatsCost = 0) {
-  if (!body || typeof body !== "object") return null;
-  const usage = body.usage;
-  if (!usage || typeof usage !== "object") return null;
-  const promptTokens = Number(usage.prompt_tokens ?? 0);
-  const completionTokens = Number(usage.completion_tokens ?? 0);
-  const totalTokens = Number(usage.total_tokens ?? 0);
-  const costValue = usage.cost;
-  let cost = 0;
-  let satsCost = fallbackSatsCost;
-  if (typeof costValue === "number") {
-    cost = costValue;
-  } else if (costValue && typeof costValue === "object") {
-    const costObj = costValue;
-    const totalUsd = costObj.total_usd;
-    const totalMsats = costObj.total_msats;
-    cost = typeof totalUsd === "number" ? totalUsd : 0;
-    if (typeof totalMsats === "number") {
-      satsCost = totalMsats / 1e3;
-    }
-  }
-  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0 && cost === 0 && satsCost === 0) {
-    return null;
-  }
-  return {
-    promptTokens,
-    completionTokens,
-    totalTokens,
-    cost,
-    satsCost
-  };
-}
-function extractResponseId(body) {
-  if (!body || typeof body !== "object") return void 0;
-  const id = body.id;
-  if (typeof id !== "string") return void 0;
-  const trimmed = id.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function extractUsageFromSSEJson(parsed, fallbackSatsCost = 0) {
-  if (!parsed || typeof parsed !== "object") {
-    return null;
-  }
-  if (!parsed.usage && parsed.cost && typeof parsed.cost === "object") {
-    const costObj = parsed.cost;
-    const msats2 = costObj.total_msats ?? 0;
-    const cost2 = costObj.total_usd ?? 0;
-    if (msats2 === 0 && cost2 === 0) return null;
-    return {
-      promptTokens: Number(costObj.input_tokens ?? 0),
-      completionTokens: Number(costObj.output_tokens ?? 0),
-      totalTokens: Number((costObj.input_tokens ?? 0) + (costObj.output_tokens ?? 0)),
-      cost: Number(cost2),
-      satsCost: msats2 > 0 ? msats2 / 1e3 : fallbackSatsCost
-    };
-  }
-  if (!parsed.usage) {
-    return null;
-  }
-  const usage = parsed.usage;
-  const usageCost = usage.cost;
-  let cost = 0;
-  let msats = 0;
-  if (typeof usageCost === "number") {
-    cost = usageCost;
-  } else if (usageCost && typeof usageCost === "object") {
-    cost = usageCost.total_usd ?? 0;
-    msats = usageCost.total_msats ?? 0;
-  }
-  if (cost === 0) {
-    cost = parsed.metadata?.routstr?.cost?.total_usd ?? 0;
-  }
-  if (msats === 0) {
-    msats = parsed.metadata?.routstr?.cost?.total_msats ?? (typeof usage.cost_sats === "number" ? usage.cost_sats * 1e3 : 0);
-  }
-  const promptTokens = Number(usage.prompt_tokens ?? usage.input_tokens ?? 0);
-  const completionTokens = Number(usage.completion_tokens ?? usage.output_tokens ?? 0);
-  const totalTokens = Number(usage.total_tokens ?? promptTokens + completionTokens);
-  const result = {
-    promptTokens,
-    completionTokens,
-    totalTokens,
-    cost: Number(cost ?? 0),
-    satsCost: msats > 0 ? msats / 1e3 : fallbackSatsCost
-  };
-  if (result.promptTokens === 0 && result.completionTokens === 0 && result.totalTokens === 0 && result.cost === 0 && result.satsCost === 0) {
-    return null;
-  }
-  return result;
-}
-function toUsageStats(usage) {
-  if (!usage) return void 0;
-  return {
-    total_tokens: usage.totalTokens,
-    prompt_tokens: usage.promptTokens,
-    completion_tokens: usage.completionTokens,
-    cost: usage.cost,
-    sats_cost: usage.satsCost
-  };
-}
-
-// client/StreamProcessor.ts
-var StreamProcessor = class {
-  accumulatedContent = "";
-  accumulatedThinking = "";
-  accumulatedImages = [];
-  isInThinking = false;
-  isInContent = false;
-  /**
-   * Process a streaming response
-   */
-  async process(response, callbacks, modelId) {
-    if (!response.body) {
-      throw new Error("Response body is not available");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder("utf-8");
-    let buffer = "";
-    this.accumulatedContent = "";
-    this.accumulatedThinking = "";
-    this.accumulatedImages = [];
-    this.isInThinking = false;
-    this.isInContent = false;
-    let usage;
-    let model;
-    let finish_reason;
-    let citations;
-    let annotations;
-    let responseId;
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        const chunk = decoder.decode(value, { stream: true });
-        buffer += chunk;
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          const parsed = this._parseLine(line);
-          if (!parsed) continue;
-          if (parsed.content) {
-            this._handleContent(parsed.content, callbacks, modelId);
-          }
-          if (parsed.reasoning) {
-            this._handleThinking(parsed.reasoning, callbacks);
-          }
-          if (parsed.usage) {
-            usage = parsed.usage;
-          }
-          if (parsed.model) {
-            model = parsed.model;
-          }
-          if (parsed.finish_reason) {
-            finish_reason = parsed.finish_reason;
-          }
-          if (parsed.responseId) {
-            responseId = parsed.responseId;
-          }
-          if (parsed.citations) {
-            citations = parsed.citations;
-          }
-          if (parsed.annotations) {
-            annotations = parsed.annotations;
-          }
-          if (parsed.images) {
-            this._mergeImages(parsed.images);
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-    return {
-      content: this.accumulatedContent,
-      thinking: this.accumulatedThinking || void 0,
-      images: this.accumulatedImages.length > 0 ? this.accumulatedImages : void 0,
-      usage,
-      model,
-      responseId,
-      finish_reason,
-      citations,
-      annotations
-    };
-  }
-  /**
-   * Parse a single SSE line
-   */
-  _parseLine(line) {
-    if (!line.trim()) return null;
-    if (!line.startsWith("data: ")) {
-      return null;
-    }
-    const jsonData = line.slice(6);
-    if (jsonData === "[DONE]") {
-      return null;
-    }
-    try {
-      const parsed = JSON.parse(jsonData);
-      const result = {};
-      if (parsed.choices?.[0]?.delta?.content) {
-        result.content = parsed.choices[0].delta.content;
-      }
-      if (parsed.choices?.[0]?.delta?.reasoning) {
-        result.reasoning = parsed.choices[0].delta.reasoning;
-      }
-      const extractedUsage = extractUsageFromSSEJson(parsed);
-      if (extractedUsage) {
-        result.usage = toUsageStats(extractedUsage);
-      } else if (parsed.usage) {
-        result.usage = {
-          total_tokens: parsed.usage.total_tokens ?? parsed.usage.input_tokens + parsed.usage.output_tokens,
-          prompt_tokens: parsed.usage.prompt_tokens ?? parsed.usage.input_tokens,
-          completion_tokens: parsed.usage.completion_tokens ?? parsed.usage.output_tokens
-        };
-      }
-      if (parsed.id) {
-        result.responseId = parsed.id;
-      }
-      if (parsed.model) {
-        result.model = parsed.model;
-      }
-      if (parsed.citations) {
-        result.citations = parsed.citations;
-      }
-      if (parsed.annotations) {
-        result.annotations = parsed.annotations;
-      }
-      if (parsed.choices?.[0]?.finish_reason) {
-        result.finish_reason = parsed.choices[0].finish_reason;
-      }
-      const images = parsed.choices?.[0]?.message?.images || parsed.choices?.[0]?.delta?.images;
-      if (images && Array.isArray(images)) {
-        result.images = images;
-      }
-      return result;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Handle content delta with thinking support
-   */
-  _handleContent(content, callbacks, modelId) {
-    if (this.isInThinking && !this.isInContent) {
-      this.accumulatedThinking += "</thinking>";
-      callbacks.onThinking(this.accumulatedThinking);
-      this.isInThinking = false;
-      this.isInContent = true;
-    }
-    if (modelId) {
-      this._extractThinkingFromContent(content, callbacks);
-    } else {
-      this.accumulatedContent += content;
-    }
-    callbacks.onContent(this.accumulatedContent);
-  }
-  /**
-   * Handle thinking/reasoning content
-   */
-  _handleThinking(reasoning, callbacks) {
-    if (!this.isInThinking) {
-      this.accumulatedThinking += "<thinking> ";
-      this.isInThinking = true;
-    }
-    this.accumulatedThinking += reasoning;
-    callbacks.onThinking(this.accumulatedThinking);
-  }
-  /**
-   * Extract thinking blocks from content (for models with inline thinking)
-   */
-  _extractThinkingFromContent(content, callbacks) {
-    const parts = content.split(/(<thinking>|<\/thinking>)/);
-    for (const part of parts) {
-      if (part === "<thinking>") {
-        this.isInThinking = true;
-        if (!this.accumulatedThinking.includes("<thinking>")) {
-          this.accumulatedThinking += "<thinking> ";
-        }
-      } else if (part === "</thinking>") {
-        this.isInThinking = false;
-        this.accumulatedThinking += "</thinking>";
-      } else if (this.isInThinking) {
-        this.accumulatedThinking += part;
-      } else {
-        this.accumulatedContent += part;
-      }
-    }
-  }
-  /**
-   * Merge images into accumulated array, avoiding duplicates
-   */
-  _mergeImages(newImages) {
-    for (const img of newImages) {
-      const newUrl = img.image_url?.url;
-      const existingIndex = this.accumulatedImages.findIndex((existing) => {
-        const existingUrl = existing.image_url?.url;
-        if (newUrl && existingUrl) {
-          return existingUrl === newUrl;
-        }
-        if (img.index !== void 0 && existing.index !== void 0) {
-          return existing.index === img.index;
-        }
-        return false;
-      });
-      if (existingIndex === -1) {
-        this.accumulatedImages.push(img);
-      } else {
-        this.accumulatedImages[existingIndex] = img;
-      }
-    }
-  }
-};
-
-// utils/torUtils.ts
-var TOR_ONION_SUFFIX = ".onion";
-var isTorContext = () => {
-  if (typeof window === "undefined") return false;
-  const hostname = window.location.hostname.toLowerCase();
-  return hostname.endsWith(TOR_ONION_SUFFIX);
-};
-var isOnionUrl = (url) => {
-  if (!url) return false;
-  const trimmed = url.trim().toLowerCase();
-  if (!trimmed) return false;
-  try {
-    const candidate = trimmed.startsWith("http") ? trimmed : `http://${trimmed}`;
-    return new URL(candidate).hostname.endsWith(TOR_ONION_SUFFIX);
-  } catch {
-    return trimmed.includes(TOR_ONION_SUFFIX);
-  }
-};
-
-// client/ProviderManager.ts
-function getImageResolutionFromDataUrl(dataUrl) {
-  try {
-    if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:"))
-      return null;
-    const commaIdx = dataUrl.indexOf(",");
-    if (commaIdx === -1) return null;
-    const meta = dataUrl.slice(5, commaIdx);
-    const base64 = dataUrl.slice(commaIdx + 1);
-    const binary = typeof atob === "function" ? atob(base64) : Buffer.from(base64, "base64").toString("binary");
-    const len = binary.length;
-    const bytes = new Uint8Array(len);
-    for (let i = 0; i < len; i++) bytes[i] = binary.charCodeAt(i);
-    const isPNG = meta.includes("image/png");
-    const isJPEG = meta.includes("image/jpeg") || meta.includes("image/jpg");
-    if (isPNG) {
-      const sig = [137, 80, 78, 71, 13, 10, 26, 10];
-      for (let i = 0; i < sig.length; i++) {
-        if (bytes[i] !== sig[i]) return null;
-      }
-      const view = new DataView(
-        bytes.buffer,
-        bytes.byteOffset,
-        bytes.byteLength
-      );
-      const width = view.getUint32(16, false);
-      const height = view.getUint32(20, false);
-      if (width > 0 && height > 0) return { width, height };
-      return null;
-    }
-    if (isJPEG) {
-      let offset = 0;
-      if (bytes[offset++] !== 255 || bytes[offset++] !== 216) return null;
-      while (offset < bytes.length) {
-        while (offset < bytes.length && bytes[offset] !== 255) offset++;
-        if (offset + 1 >= bytes.length) break;
-        while (bytes[offset] === 255) offset++;
-        const marker = bytes[offset++];
-        if (marker === 216 || marker === 217) continue;
-        if (offset + 1 >= bytes.length) break;
-        const length = bytes[offset] << 8 | bytes[offset + 1];
-        offset += 2;
-        if (marker === 192 || marker === 194) {
-          if (length < 7 || offset + length - 2 > bytes.length) return null;
-          const precision = bytes[offset];
-          const height = bytes[offset + 1] << 8 | bytes[offset + 2];
-          const width = bytes[offset + 3] << 8 | bytes[offset + 4];
-          if (precision > 0 && width > 0 && height > 0)
-            return { width, height };
-          return null;
-        } else {
-          offset += length - 2;
-        }
-      }
-      return null;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function calculateImageTokens(width, height, detail = "auto") {
-  if (detail === "low") return 85;
-  let w = width;
-  let h = height;
-  if (w > 2048 || h > 2048) {
-    const aspectRatio = w / h;
-    if (w > h) {
-      w = 2048;
-      h = Math.floor(w / aspectRatio);
-    } else {
-      h = 2048;
-      w = Math.floor(h * aspectRatio);
-    }
-  }
-  if (w > 768 || h > 768) {
-    const aspectRatio = w / h;
-    if (w > h) {
-      w = 768;
-      h = Math.floor(w / aspectRatio);
-    } else {
-      h = 768;
-      w = Math.floor(h * aspectRatio);
-    }
-  }
-  const tilesWidth = Math.floor((w + 511) / 512);
-  const tilesHeight = Math.floor((h + 511) / 512);
-  const numTiles = tilesWidth * tilesHeight;
-  return 85 + 170 * numTiles;
-}
-function isInsecureHttpUrl(url) {
-  return url.startsWith("http://");
-}
-var ProviderManager = class _ProviderManager {
-  constructor(providerRegistry, store, logger) {
-    this.providerRegistry = providerRegistry;
-    this.instanceId = `pm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-    this.logger = (logger ?? consoleLogger).child(`ProviderManager:${this.instanceId}`);
-    if (store) {
-      this.store = store;
-      this.hydrateFromStore();
-    }
-  }
-  failedProviders = /* @__PURE__ */ new Set();
-  /** Track when each provider last failed (provider URL -> timestamp) */
-  lastFailed = /* @__PURE__ */ new Map();
-  /** Providers on cooldown: [provider_url, cooldown_started_timestamp][] */
-  providersOnCoolDown = [];
-  /** Cooldown duration in milliseconds (42 seconds) */
-  static COOLDOWN_DURATION_MS = 42 * 1e3;
-  /** Optional persistent store for failure tracking */
-  store = null;
-  /** Instance ID for debugging */
-  instanceId;
-  logger;
-  /**
-   * Hydrate in-memory state from persistent store
-   */
-  hydrateFromStore() {
-    if (!this.store) return;
-    const state = this.store.getState();
-    this.failedProviders = new Set(state.failedProviders);
-    this.lastFailed = new Map(Object.entries(state.lastFailed));
-    const now = Date.now();
-    this.providersOnCoolDown = state.providersOnCooldown.filter(
-      (entry) => now - entry.timestamp < _ProviderManager.COOLDOWN_DURATION_MS
-    ).map((entry) => [entry.baseUrl, entry.timestamp]);
-    this.logger.log(`Hydrated from store: failedProviders=${this.failedProviders.size} lastFailed=${this.lastFailed.size} providersOnCooldown=${this.providersOnCoolDown.length}`);
-  }
-  /**
-   * Get instance ID for debugging
-   */
-  getInstanceId() {
-    return this.instanceId;
-  }
-  /**
-   * Clean up expired cooldown entries
-   * Also removes the provider from failedProviders so it can be retried
-   */
-  cleanupExpiredCooldowns() {
-    const now = Date.now();
-    const before = this.providersOnCoolDown.length;
-    this.providersOnCoolDown = this.providersOnCoolDown.filter(
-      ([url, timestamp]) => {
-        const age = now - timestamp;
-        const isExpired = age >= _ProviderManager.COOLDOWN_DURATION_MS;
-        if (isExpired) {
-          this.logger.log(`Removing expired cooldown for ${url} (age: ${age}ms)`);
-          this.failedProviders.delete(url);
-          if (this.store) {
-            this.store.getState().removeFailedProvider(url);
-          }
-        }
-        return !isExpired;
-      }
-    );
-    const after = this.providersOnCoolDown.length;
-    if (before !== after) {
-      this.logger.log(`Cleaned up ${before - after} expired cooldown(s), ${after} remaining`);
-    }
-  }
-  /**
-   * Get the cooldown duration in milliseconds
-   */
-  getCooldownDurationMs() {
-    return _ProviderManager.COOLDOWN_DURATION_MS;
-  }
-  /**
-   * Check if a provider is currently on cooldown
-   */
-  isOnCooldown(baseUrl) {
-    this.cleanupExpiredCooldowns();
-    const result = this.providersOnCoolDown.some(([url]) => url === baseUrl);
-    return result;
-  }
-  /**
-   * Get all providers currently on cooldown
-   */
-  getProvidersOnCooldown() {
-    this.cleanupExpiredCooldowns();
-    return [...this.providersOnCoolDown];
-  }
-  /**
-   * Reset the failed providers list
-   */
-  resetFailedProviders() {
-    this.failedProviders.clear();
-    if (this.store) {
-      this.store.getState().setFailedProviders([]);
-    }
-  }
-  /**
-   * Get the last failed timestamp for a provider
-   */
-  getLastFailed(baseUrl) {
-    return this.lastFailed.get(baseUrl);
-  }
-  /**
-   * Get all providers with their last failed timestamps
-   */
-  getAllLastFailed() {
-    return new Map(this.lastFailed);
-  }
-  /**
-   * Mark a provider as failed
-   * If a provider fails twice within 5 minutes, it's added to cooldown
-   */
-  markFailed(baseUrl) {
-    const now = Date.now();
-    const lastFailure = this.lastFailed.get(baseUrl);
-    this.logger.log(`markFailed: ${baseUrl} lastFailure=${lastFailure} now=${now}`);
-    if (lastFailure !== void 0) {
-      const timeSinceLastFailure = now - lastFailure;
-      this.logger.log(`markFailed: timeSinceLastFailure=${timeSinceLastFailure}ms withinCooldown=${timeSinceLastFailure < _ProviderManager.COOLDOWN_DURATION_MS}`);
-    }
-    this.lastFailed.set(baseUrl, now);
-    this.failedProviders.add(baseUrl);
-    if (this.store) {
-      this.store.getState().setLastFailedTimestamp(baseUrl, now);
-      this.store.getState().addFailedProvider(baseUrl);
-    }
-    this.logger.log(`markFailed: updated ${baseUrl} to ${now}, failedProviders=${this.failedProviders.size}`);
-    if (lastFailure !== void 0 && now - lastFailure < _ProviderManager.COOLDOWN_DURATION_MS) {
-      this.logger.log(`markFailed: second failure within cooldown window for ${baseUrl}`);
-      if (!this.isOnCooldown(baseUrl)) {
-        this.providersOnCoolDown.push([baseUrl, now]);
-        if (this.store) {
-          this.store.getState().addProviderOnCooldown(baseUrl, now);
-        }
-        this.logger.log(`markFailed: ${baseUrl} added to cooldown`);
-      } else {
-        this.logger.log(`markFailed: ${baseUrl} already on cooldown`);
-      }
-    } else {
-      if (lastFailure === void 0) {
-        this.logger.log(`markFailed: first failure for ${baseUrl}`);
-      } else {
-        this.logger.log(`markFailed: failure outside cooldown window for ${baseUrl} (${now - lastFailure}ms ago)`);
-      }
-    }
-  }
-  /**
-   * Remove a provider from cooldown (e.g., after successful request)
-   */
-  removeFromCooldown(baseUrl) {
-    this.providersOnCoolDown = this.providersOnCoolDown.filter(
-      ([url]) => url !== baseUrl
-    );
-    if (this.store) {
-      this.store.getState().removeProviderFromCooldown(baseUrl);
-    }
-  }
-  /**
-   * Clear all cooldown tracking
-   */
-  clearCooldowns() {
-    this.providersOnCoolDown = [];
-    if (this.store) {
-      this.store.getState().clearProvidersOnCooldown();
-    }
-  }
-  /**
-   * Clear all failure tracking (lastFailed timestamps)
-   */
-  clearFailureHistory() {
-    this.lastFailed.clear();
-    if (this.store) {
-      this.store.getState().setLastFailed({});
-    }
-  }
-  /**
-   * Check if a provider has failed
-   */
-  hasFailed(baseUrl) {
-    return this.failedProviders.has(baseUrl);
-  }
-  /**
-   * Get a copy of the failed providers set
-   */
-  getFailedProviders() {
-    return new Set(this.failedProviders);
-  }
-  /**
-   * Find the next best provider for a model
-   * @param modelId The model ID to find a provider for
-   * @param currentBaseUrl The current provider to exclude
-   * @returns The best provider URL or null if none available
-   */
-  findNextBestProvider(modelId, currentBaseUrl) {
-    try {
-      const torMode = isTorContext();
-      const disabledProviders = new Set(
-        this.providerRegistry.getDisabledProviders()
-      );
-      this.logger.log(`findNextBestProvider: model=${modelId} disabled=${[...disabledProviders].length} onCooldown=${this.providersOnCoolDown.length}`);
-      const allProviders = this.providerRegistry.getAllProvidersModels();
-      this.logger.log(`findNextBestProvider: total providers=${Object.keys(allProviders).length}`);
-      const candidates = [];
-      for (const [baseUrl, models] of Object.entries(allProviders)) {
-        if (baseUrl === currentBaseUrl) {
-          continue;
-        }
-        if (disabledProviders.has(baseUrl)) {
-          continue;
-        }
-        if (this.isOnCooldown(baseUrl)) {
-          continue;
-        }
-        if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl))) {
-          continue;
-        }
-        const model = models.find((m) => m.id === modelId);
-        if (!model) {
-          continue;
-        }
-        const cost = model.sats_pricing?.completion ?? 0;
-        candidates.push({ baseUrl, model, cost });
-      }
-      candidates.sort((a, b) => a.cost - b.cost);
-      if (candidates.length > 0) {
-        return candidates[0].baseUrl;
-      } else {
-        return null;
-      }
-    } catch (error) {
-      this.logger.error("findNextBestProvider error:", error);
-      return null;
-    }
-  }
-  /**
-   * Find the best model for a provider
-   * Useful when switching providers and need to find equivalent model
-   */
-  async getModelForProvider(baseUrl, modelId) {
-    const models = this.providerRegistry.getModelsForProvider(baseUrl);
-    const exactMatch = models.find((m) => m.id === modelId);
-    if (exactMatch) return exactMatch;
-    const providerInfo = await this.providerRegistry.getProviderInfo(baseUrl);
-    if (providerInfo?.version && /^0\.1\./.test(providerInfo.version)) {
-      const suffix = modelId.split("/").pop();
-      const suffixMatch = models.find((m) => m.id === suffix);
-      if (suffixMatch) return suffixMatch;
-    }
-    return null;
-  }
-  /**
-   * Get all available providers for a model
-   * Returns sorted list by price
-   */
-  getAllProvidersForModel(modelId) {
-    const candidates = [];
-    const allProviders = this.providerRegistry.getAllProvidersModels();
-    const disabledProviders = new Set(
-      this.providerRegistry.getDisabledProviders()
-    );
-    const torMode = isTorContext();
-    for (const [baseUrl, models] of Object.entries(allProviders)) {
-      if (disabledProviders.has(baseUrl)) continue;
-      if (this.isOnCooldown(baseUrl)) continue;
-      if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl)))
-        continue;
-      const model = models.find((m) => m.id === modelId);
-      if (!model) continue;
-      const cost = model.sats_pricing?.completion ?? 0;
-      candidates.push({ baseUrl, model, cost });
-    }
-    return candidates.sort((a, b) => a.cost - b.cost);
-  }
-  /**
-   * Get providers for a model sorted by prompt+completion pricing
-   */
-  getProviderPriceRankingForModel(modelId, options = {}) {
-    const includeDisabled = options.includeDisabled ?? false;
-    const torMode = options.torMode ?? false;
-    const disabledProviders = new Set(
-      this.providerRegistry.getDisabledProviders()
-    );
-    const allModels = this.providerRegistry.getAllProvidersModels();
-    const results = [];
-    for (const [baseUrl, models] of Object.entries(allModels)) {
-      if (!includeDisabled && disabledProviders.has(baseUrl)) continue;
-      if (this.isOnCooldown(baseUrl)) continue;
-      if (torMode && !baseUrl.includes(".onion")) continue;
-      if (!torMode && (baseUrl.includes(".onion") || isInsecureHttpUrl(baseUrl)))
-        continue;
-      const match = models.find((model) => model.id === modelId);
-      if (!match?.sats_pricing) continue;
-      const prompt = match.sats_pricing.prompt;
-      const completion = match.sats_pricing.completion;
-      if (typeof prompt !== "number" || typeof completion !== "number") {
-        continue;
-      }
-      const promptPerMillion = prompt * 1e6;
-      const completionPerMillion = completion * 1e6;
-      const totalPerMillion = promptPerMillion + completionPerMillion;
-      results.push({
-        baseUrl,
-        model: match,
-        promptPerMillion,
-        completionPerMillion,
-        totalPerMillion
-      });
-    }
-    return results.sort((a, b) => {
-      if (a.totalPerMillion !== b.totalPerMillion) {
-        return a.totalPerMillion - b.totalPerMillion;
-      }
-      return a.baseUrl.localeCompare(b.baseUrl);
-    });
-  }
-  /**
-   * Get best-priced provider for a specific model
-   */
-  getBestProviderForModel(modelId, options = {}) {
-    const ranking = this.getProviderPriceRankingForModel(modelId, options);
-    return ranking[0]?.baseUrl ?? null;
-  }
-  normalizeModelId(modelId) {
-    return modelId.includes("/") ? modelId.split("/").pop() || modelId : modelId;
-  }
-  /**
-   * Check if a provider accepts a specific mint
-   */
-  providerAcceptsMint(baseUrl, mintUrl) {
-    const providerMints = this.providerRegistry.getProviderMints(baseUrl);
-    if (providerMints.length === 0) {
-      return true;
-    }
-    return providerMints.includes(mintUrl);
-  }
-  /**
-   * Get required sats for a model based on message history
-   * Simple estimation based on typical usage
-   */
-  getRequiredSatsForModel(model, apiMessages, maxTokens) {
-    try {
-      let imageTokens = 0;
-      if (apiMessages) {
-        for (const msg of apiMessages) {
-          const content = msg?.content;
-          if (Array.isArray(content)) {
-            for (const part of content) {
-              const isImage = part && typeof part === "object" && part.type === "image_url";
-              const url = isImage ? typeof part.image_url === "string" ? part.image_url : part.image_url?.url : void 0;
-              if (url && typeof url === "string" && url.startsWith("data:")) {
-                const res = getImageResolutionFromDataUrl(url);
-                if (res) {
-                  const tokensFromImage = calculateImageTokens(
-                    res.width,
-                    res.height
-                  );
-                  imageTokens += tokensFromImage;
-                  this.logger.log(`IMAGE INPUT RESOLUTION width=${res.width} height=${res.height} tokens=${tokensFromImage}`);
-                } else {
-                  this.logger.log("IMAGE INPUT RESOLUTION: unknown format");
-                }
-              }
-            }
-          }
-        }
-      }
-      const apiMessagesNoImages = apiMessages ? apiMessages.map((m) => {
-        if (Array.isArray(m?.content)) {
-          const filtered = m.content.filter(
-            (p) => !(p && typeof p === "object" && p.type === "image_url")
-          );
-          return { ...m, content: filtered };
-        }
-        return m;
-      }) : void 0;
-      const approximateTokens = apiMessagesNoImages ? Math.ceil(JSON.stringify(apiMessagesNoImages, null, 2).length / 2.84) : 1e4;
-      const totalInputTokens = approximateTokens + imageTokens;
-      const sp = model?.sats_pricing;
-      if (!sp) {
-        return 0;
-      }
-      if (!sp.max_completion_cost) {
-        return sp.max_cost ?? 50;
-      }
-      const promptCosts = (sp.prompt || 0) * totalInputTokens;
-      let completionCost = sp.max_completion_cost;
-      if (maxTokens !== void 0 && sp.completion) {
-        completionCost = sp.completion * maxTokens;
-      }
-      const totalEstimatedCosts = (promptCosts + completionCost) * 1.05;
-      return totalEstimatedCosts;
-    } catch (e) {
-      this.logger.error("getRequiredSatsForModel error:", e);
-      return 0;
-    }
-  }
-};
-
-// storage/drivers/localStorage.ts
-var canUseLocalStorage = () => {
-  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
-};
-var isQuotaExceeded = (error) => {
-  const e = error;
-  return !!e && (e?.name === "QuotaExceededError" || e?.code === 22 || e?.code === 1014);
-};
-var NON_CRITICAL_KEYS = /* @__PURE__ */ new Set(["modelsFromAllProviders"]);
-var localStorageDriver = {
-  async getItem(key, defaultValue) {
-    if (!canUseLocalStorage()) return defaultValue;
-    try {
-      const item = window.localStorage.getItem(key);
-      if (item === null) return defaultValue;
-      try {
-        return JSON.parse(item);
-      } catch (parseError) {
-        if (typeof defaultValue === "string") {
-          return item;
-        }
-        throw parseError;
-      }
-    } catch (error) {
-      console.error(`Error retrieving item with key "${key}":`, error);
-      if (canUseLocalStorage()) {
-        try {
-          window.localStorage.removeItem(key);
-        } catch (removeError) {
-          console.error(
-            `Error removing corrupted item with key "${key}":`,
-            removeError
-          );
-        }
-      }
-      return defaultValue;
-    }
-  },
-  async setItem(key, value) {
-    if (!canUseLocalStorage()) return;
-    try {
-      window.localStorage.setItem(key, JSON.stringify(value));
-    } catch (error) {
-      if (isQuotaExceeded(error)) {
-        if (NON_CRITICAL_KEYS.has(key)) {
-          console.warn(
-            `Storage quota exceeded; skipping non-critical key "${key}".`
-          );
-          return;
-        }
-        try {
-          window.localStorage.removeItem("modelsFromAllProviders");
-        } catch {
-        }
-        try {
-          window.localStorage.setItem(key, JSON.stringify(value));
-          return;
-        } catch (retryError) {
-          console.warn(
-            `Storage quota exceeded; unable to persist key "${key}" after cleanup attempt.`,
-            retryError
-          );
-          return;
-        }
-      }
-      console.error(`Error storing item with key "${key}":`, error);
-    }
-  },
-  async removeItem(key) {
-    if (!canUseLocalStorage()) return;
-    try {
-      window.localStorage.removeItem(key);
-    } catch (error) {
-      console.error(`Error removing item with key "${key}":`, error);
-    }
-  }
-};
-
-// storage/drivers/memory.ts
-var createMemoryDriver = (seed) => {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    async getItem(key, defaultValue) {
-      const item = store.get(key);
-      if (item === void 0) return defaultValue;
-      try {
-        return JSON.parse(item);
-      } catch (parseError) {
-        if (typeof defaultValue === "string") {
-          return item;
-        }
-        throw parseError;
-      }
-    },
-    async setItem(key, value) {
-      store.set(key, JSON.stringify(value));
-    },
-    async removeItem(key) {
-      store.delete(key);
-    }
-  };
-};
-
-// storage/drivers/sqlite.ts
-var isBun = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var cachedDbModule = null;
-var loadDatabase = async (dbPath) => {
-  if (isBun()) {
-    throw new Error(
-      "SQLite driver not supported in Bun. Use createBunSqliteDriver() instead."
-    );
-  }
-  try {
-    if (!cachedDbModule) {
-      cachedDbModule = (await import('better-sqlite3')).default;
-    }
-    return new cachedDbModule(dbPath);
-  } catch (error) {
-    throw new Error(
-      `better-sqlite3 is required for sqlite storage. Install it to use sqlite storage. (${error})`
-    );
-  }
-};
-var createSqliteDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "sdk_storage";
-  let db;
-  let selectStmt;
-  let upsertStmt;
-  let deleteStmt;
-  const initDb = async () => {
-    if (!db) {
-      db = await loadDatabase(dbPath);
-      db.exec(
-        `CREATE TABLE IF NOT EXISTS ${tableName} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
-      );
-      selectStmt = db.prepare(`SELECT value FROM ${tableName} WHERE key = ?`);
-      upsertStmt = db.prepare(
-        `INSERT INTO ${tableName} (key, value) VALUES (?, ?)
-     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
-      );
-      deleteStmt = db.prepare(`DELETE FROM ${tableName} WHERE key = ?`);
-    }
-  };
-  const ensureInit = async () => {
-    if (!db) {
-      await initDb();
-    }
-  };
-  return {
-    async getItem(key, defaultValue) {
-      try {
-        await ensureInit();
-        const row = selectStmt.get(key);
-        if (!row || typeof row.value !== "string") return defaultValue;
-        try {
-          return JSON.parse(row.value);
-        } catch (parseError) {
-          if (typeof defaultValue === "string") {
-            return row.value;
-          }
-          throw parseError;
-        }
-      } catch (error) {
-        console.error(`SQLite getItem failed for key "${key}":`, error);
-        return defaultValue;
-      }
-    },
-    async setItem(key, value) {
-      try {
-        await ensureInit();
-        upsertStmt.run(key, JSON.stringify(value));
-      } catch (error) {
-        console.error(`SQLite setItem failed for key "${key}":`, error);
-      }
-    },
-    async removeItem(key) {
-      try {
-        await ensureInit();
-        deleteStmt.run(key);
-      } catch (error) {
-        console.error(`SQLite removeItem failed for key "${key}":`, error);
-      }
-    }
-  };
-};
-
-// storage/keys.ts
-var SDK_STORAGE_KEYS = {
-  MODELS_FROM_ALL_PROVIDERS: "modelsFromAllProviders",
-  LAST_USED_MODEL: "lastUsedModel",
-  BASE_URLS_LIST: "base_urls_list",
-  DISABLED_PROVIDERS: "disabled_providers",
-  MINTS_FROM_ALL_PROVIDERS: "mints_from_all_providers",
-  INFO_FROM_ALL_PROVIDERS: "info_from_all_providers",
-  LAST_MODELS_UPDATE: "lastModelsUpdate",
-  LAST_BASE_URLS_UPDATE: "lastBaseUrlsUpdate",
-  API_KEYS: "api_keys",
-  CHILD_KEYS: "child_keys",
-  XCASHU_TOKENS: "xcashu_tokens",
-  ROUTSTR21_MODELS: "routstr21Models",
-  LAST_ROUTSTR21_MODELS_UPDATE: "lastRoutstr21ModelsUpdate",
-  CACHED_RECEIVE_TOKENS: "cached_receive_tokens",
-  USAGE_TRACKING: "usage_tracking",
-  CLIENT_IDS: "client_ids",
-  FAILED_PROVIDERS: "failed_providers",
-  LAST_FAILED: "last_failed",
-  PROVIDERS_ON_COOLDOWN: "providers_on_cooldown"
-};
-
-// storage/usageTracking/indexedDB.ts
-var DEFAULT_DB_NAME = "routstr-sdk";
-var DEFAULT_STORE_NAME = "usage_tracking";
-var MIGRATION_MARKER_KEY = "usage_tracking_migration_v1";
-var isBrowser = typeof indexedDB !== "undefined";
-var normalizeBaseUrl = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var openDatabase = (dbName, storeName) => {
-  if (!isBrowser) {
-    return Promise.reject(new Error("IndexedDB is not available"));
-  }
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(dbName, 1);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(storeName)) {
-        const store = db.createObjectStore(storeName, { keyPath: "id" });
-        store.createIndex("timestamp", "timestamp", { unique: false });
-        store.createIndex("modelId", "modelId", { unique: false });
-        store.createIndex("baseUrl", "baseUrl", { unique: false });
-        store.createIndex("sessionId", "sessionId", { unique: false });
-        store.createIndex("client", "client", { unique: false });
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-};
-var matchesFilters = (entry, options = {}) => {
-  if (typeof options.before === "number" && entry.timestamp >= options.before) {
-    return false;
-  }
-  if (typeof options.after === "number" && entry.timestamp <= options.after) {
-    return false;
-  }
-  if (options.modelId && entry.modelId !== options.modelId) {
-    return false;
-  }
-  if (options.baseUrl && normalizeBaseUrl(entry.baseUrl) !== normalizeBaseUrl(options.baseUrl)) {
-    return false;
-  }
-  if (options.sessionId && entry.sessionId !== options.sessionId) {
-    return false;
-  }
-  if (options.client && entry.client !== options.client) {
-    return false;
-  }
-  return true;
-};
-var createIndexedDBUsageTrackingDriver = (options = {}) => {
-  const dbName = options.dbName || DEFAULT_DB_NAME;
-  const storeName = options.storeName || DEFAULT_STORE_NAME;
-  const legacyStorageDriver = options.legacyStorageDriver;
-  let dbPromise = null;
-  let migrationPromise = null;
-  const getDb = () => {
-    if (!dbPromise) {
-      dbPromise = openDatabase(dbName, storeName);
-    }
-    return dbPromise;
-  };
-  const putMany = async (entries) => {
-    if (entries.length === 0) return;
-    const db = await getDb();
-    await new Promise((resolve, reject) => {
-      const tx = db.transaction(storeName, "readwrite");
-      const store = tx.objectStore(storeName);
-      for (const entry of entries) {
-        store.put({ ...entry, baseUrl: normalizeBaseUrl(entry.baseUrl) });
-      }
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
-  };
-  const ensureMigrated = async () => {
-    if (!legacyStorageDriver) return;
-    if (!migrationPromise) {
-      migrationPromise = (async () => {
-        const migrated = await legacyStorageDriver.getItem(
-          MIGRATION_MARKER_KEY,
-          false
-        );
-        if (migrated) return;
-        const legacyEntries = await legacyStorageDriver.getItem(
-          SDK_STORAGE_KEYS.USAGE_TRACKING,
-          []
-        );
-        if (legacyEntries.length > 0) {
-          await putMany(legacyEntries);
-          await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
-        }
-        await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY, true);
-      })();
-    }
-    await migrationPromise;
-  };
-  return {
-    async migrate() {
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureMigrated();
-      await putMany([entry]);
-    },
-    async appendMany(entries) {
-      await ensureMigrated();
-      await putMany(entries);
-    },
-    async list(options2 = {}) {
-      await ensureMigrated();
-      const db = await getDb();
-      return new Promise((resolve, reject) => {
-        const tx = db.transaction(storeName, "readonly");
-        const store = tx.objectStore(storeName);
-        const index = store.index("timestamp");
-        const direction = "prev";
-        const request = index.openCursor(null, direction);
-        const results = [];
-        const limit = options2.limit;
-        request.onsuccess = () => {
-          const cursor = request.result;
-          if (!cursor) {
-            resolve(results);
-            return;
-          }
-          const value = cursor.value;
-          if (matchesFilters(value, options2)) {
-            results.push(value);
-            if (typeof limit === "number" && results.length >= limit) {
-              resolve(results);
-              return;
-            }
-          }
-          cursor.continue();
-        };
-        request.onerror = () => reject(request.error);
-      });
-    },
-    async count(options2 = {}) {
-      const results = await this.list(options2);
-      return results.length;
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureMigrated();
-      const db = await getDb();
-      return new Promise((resolve, reject) => {
-        const tx = db.transaction(storeName, "readwrite");
-        const store = tx.objectStore(storeName);
-        const index = store.index("timestamp");
-        const range = IDBKeyRange.upperBound(timestamp, true);
-        const request = index.openCursor(range);
-        let deleted = 0;
-        request.onsuccess = () => {
-          const cursor = request.result;
-          if (!cursor) {
-            resolve(deleted);
-            return;
-          }
-          deleted += 1;
-          cursor.delete();
-          cursor.continue();
-        };
-        request.onerror = () => reject(request.error);
-      });
-    },
-    async clear() {
-      await ensureMigrated();
-      const db = await getDb();
-      await new Promise((resolve, reject) => {
-        const tx = db.transaction(storeName, "readwrite");
-        tx.objectStore(storeName).clear();
-        tx.oncomplete = () => resolve();
-        tx.onerror = () => reject(tx.error);
-      });
-    }
-  };
-};
-
-// storage/usageTracking/sqlite.ts
-var MIGRATION_MARKER_KEY2 = "usage_tracking_migration_v1";
-var normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var isBun2 = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var cachedDbModule2 = null;
-var loadDatabase2 = async (dbPath) => {
-  if (isBun2()) {
-    throw new Error(
-      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
-    );
-  }
-  try {
-    if (!cachedDbModule2) {
-      cachedDbModule2 = (await import('better-sqlite3')).default;
-    }
-    return new cachedDbModule2(dbPath);
-  } catch (error) {
-    throw new Error(
-      `better-sqlite3 is required for sqlite usage tracking. Install it to use sqlite storage. (${error})`
-    );
-  }
-};
-var buildWhereClause = (options = {}) => {
-  const clauses = [];
-  const params = [];
-  if (typeof options.before === "number") {
-    clauses.push("timestamp < ?");
-    params.push(options.before);
-  }
-  if (typeof options.after === "number") {
-    clauses.push("timestamp > ?");
-    params.push(options.after);
-  }
-  if (options.modelId) {
-    clauses.push("model_id = ?");
-    params.push(options.modelId);
-  }
-  if (options.baseUrl) {
-    clauses.push("base_url = ?");
-    params.push(normalizeBaseUrl2(options.baseUrl));
-  }
-  if (options.sessionId) {
-    clauses.push("session_id = ?");
-    params.push(options.sessionId);
-  }
-  if (options.client) {
-    clauses.push("client = ?");
-    params.push(options.client);
-  }
-  return {
-    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    params
-  };
-};
-var createSqliteUsageTrackingDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "usage_tracking";
-  const legacyStorageDriver = options.legacyStorageDriver;
-  let db;
-  let insertStmt;
-  let migrationComplete = false;
-  const initDb = async () => {
-    if (!db) {
-      db = await loadDatabase2(dbPath);
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS ${tableName} (
-          id TEXT PRIMARY KEY,
-          timestamp INTEGER NOT NULL,
-          model_id TEXT NOT NULL,
-          base_url TEXT NOT NULL,
-          request_id TEXT NOT NULL,
-          cost REAL NOT NULL,
-          sats_cost REAL NOT NULL,
-          prompt_tokens INTEGER NOT NULL,
-          completion_tokens INTEGER NOT NULL,
-          total_tokens INTEGER NOT NULL,
-          client TEXT,
-          session_id TEXT,
-          tags TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_session_id ON ${tableName}(session_id);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_client ON ${tableName}(client);
-      `);
-      insertStmt = db.prepare(`
-        INSERT OR REPLACE INTO ${tableName} (
-          id, timestamp, model_id, base_url, request_id,
-          cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
-          client, session_id, tags
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-    }
-  };
-  const ensureInit = async () => {
-    if (!db) {
-      await initDb();
-    }
-  };
-  const appendOne = (entry) => {
-    insertStmt.run(
-      entry.id,
-      entry.timestamp,
-      entry.modelId,
-      normalizeBaseUrl2(entry.baseUrl),
-      entry.requestId,
-      entry.cost,
-      entry.satsCost,
-      entry.promptTokens,
-      entry.completionTokens,
-      entry.totalTokens,
-      entry.client ?? null,
-      entry.sessionId ?? null,
-      JSON.stringify(entry.tags ?? [])
-    );
-  };
-  const ensureMigrated = async () => {
-    if (!legacyStorageDriver || migrationComplete) return;
-    const migrated = await legacyStorageDriver.getItem(
-      MIGRATION_MARKER_KEY2,
-      false
-    );
-    if (migrated) {
-      migrationComplete = true;
-      return;
-    }
-    const legacyEntries = await legacyStorageDriver.getItem(
-      SDK_STORAGE_KEYS.USAGE_TRACKING,
-      []
-    );
-    for (const entry of legacyEntries) {
-      appendOne(entry);
-    }
-    if (legacyEntries.length > 0) {
-      await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
-    }
-    await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY2, true);
-    migrationComplete = true;
-  };
-  const mapRow = (row) => ({
-    id: row.id,
-    timestamp: row.timestamp,
-    modelId: row.model_id,
-    baseUrl: row.base_url,
-    requestId: row.request_id,
-    cost: row.cost,
-    satsCost: row.sats_cost,
-    promptTokens: row.prompt_tokens,
-    completionTokens: row.completion_tokens,
-    totalTokens: row.total_tokens,
-    client: row.client ?? void 0,
-    sessionId: row.session_id ?? void 0,
-    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
-  });
-  return {
-    async migrate() {
-      await ensureInit();
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureInit();
-      await ensureMigrated();
-      appendOne(entry);
-    },
-    async appendMany(entries) {
-      await ensureInit();
-      await ensureMigrated();
-      for (const entry of entries) {
-        appendOne(entry);
-      }
-    },
-    async list(options2 = {}) {
-      await ensureInit();
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause(options2);
-      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
-      const stmt = db.prepare(
-        `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`
-      );
-      const rows = stmt.all(
-        ...typeof options2.limit === "number" ? [...params, options2.limit] : params
-      );
-      return rows.map(mapRow);
-    },
-    async count(options2 = {}) {
-      await ensureInit();
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause(options2);
-      const stmt = db.prepare(`SELECT COUNT(*) as count FROM ${tableName} ${sql}`);
-      const row = stmt.get(...params);
-      return Number(row?.count ?? 0);
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureInit();
-      await ensureMigrated();
-      const stmt = db.prepare(`DELETE FROM ${tableName} WHERE timestamp < ?`);
-      const result = stmt.run(timestamp);
-      return result.changes;
-    },
-    async clear() {
-      await ensureInit();
-      await ensureMigrated();
-      db.prepare(`DELETE FROM ${tableName}`).run();
-    }
-  };
-};
-
-// storage/usageTracking/bunSqlite.ts
-var MIGRATION_MARKER_KEY3 = "usage_tracking_migration_v1";
-var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var buildWhereClause2 = (options = {}) => {
-  const clauses = [];
-  const params = [];
-  if (typeof options.before === "number") {
-    clauses.push("timestamp < ?");
-    params.push(options.before);
-  }
-  if (typeof options.after === "number") {
-    clauses.push("timestamp > ?");
-    params.push(options.after);
-  }
-  if (options.modelId) {
-    clauses.push("model_id = ?");
-    params.push(options.modelId);
-  }
-  if (options.baseUrl) {
-    clauses.push("base_url = ?");
-    params.push(normalizeBaseUrl3(options.baseUrl));
-  }
-  if (options.sessionId) {
-    clauses.push("session_id = ?");
-    params.push(options.sessionId);
-  }
-  if (options.client) {
-    clauses.push("client = ?");
-    params.push(options.client);
-  }
-  return {
-    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    params
-  };
-};
-var createBunSqliteUsageTrackingDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "usage_tracking";
-  const legacyStorageDriver = options.legacyStorageDriver;
-  const SQLiteDatabase = options.sqlite?.Database;
-  let migrationPromise = null;
-  if (!SQLiteDatabase) {
-    throw new Error(
-      "Bun SQLite Database constructor is required. Pass { sqlite: { Database } } when creating the driver."
-    );
-  }
-  const db = new SQLiteDatabase(dbPath);
-  db.run(`
-    CREATE TABLE IF NOT EXISTS ${tableName} (
-      id TEXT PRIMARY KEY,
-      timestamp INTEGER NOT NULL,
-      model_id TEXT NOT NULL,
-      base_url TEXT NOT NULL,
-      request_id TEXT NOT NULL,
-      cost REAL NOT NULL,
-      sats_cost REAL NOT NULL,
-      prompt_tokens INTEGER NOT NULL,
-      completion_tokens INTEGER NOT NULL,
-      total_tokens INTEGER NOT NULL,
-      client TEXT,
-      session_id TEXT,
-      tags TEXT
-    )
-  `);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url)`);
-  const appendOne = (entry) => {
-    db.query(`
-      INSERT OR REPLACE INTO ${tableName} (
-        id, timestamp, model_id, base_url, request_id,
-        cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
-        client, session_id, tags
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      entry.id,
-      entry.timestamp,
-      entry.modelId,
-      normalizeBaseUrl3(entry.baseUrl),
-      entry.requestId,
-      entry.cost,
-      entry.satsCost,
-      entry.promptTokens,
-      entry.completionTokens,
-      entry.totalTokens,
-      entry.client ?? null,
-      entry.sessionId ?? null,
-      JSON.stringify(entry.tags ?? [])
-    );
-  };
-  const mapRow = (row) => ({
-    id: row.id,
-    timestamp: row.timestamp,
-    modelId: row.model_id,
-    baseUrl: row.base_url,
-    requestId: row.request_id,
-    cost: row.cost,
-    satsCost: row.sats_cost,
-    promptTokens: row.prompt_tokens,
-    completionTokens: row.completion_tokens,
-    totalTokens: row.total_tokens,
-    client: row.client ?? void 0,
-    sessionId: row.session_id ?? void 0,
-    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
-  });
-  const ensureMigrated = async () => {
-    if (!legacyStorageDriver) return;
-    if (!migrationPromise) {
-      migrationPromise = (async () => {
-        const migrated = await legacyStorageDriver.getItem(
-          MIGRATION_MARKER_KEY3,
-          false
-        );
-        if (migrated) return;
-        const legacyEntries = await legacyStorageDriver.getItem(
-          SDK_STORAGE_KEYS.USAGE_TRACKING,
-          []
-        );
-        if (legacyEntries.length > 0) {
-          for (const entry of legacyEntries) {
-            appendOne(entry);
-          }
-          await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
-        }
-        await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY3, true);
-      })();
-    }
-    await migrationPromise;
-  };
-  return {
-    async migrate() {
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureMigrated();
-      appendOne(entry);
-    },
-    async appendMany(entries) {
-      await ensureMigrated();
-      for (const entry of entries) {
-        appendOne(entry);
-      }
-    },
-    async list(options2 = {}) {
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause2(options2);
-      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
-      const query = `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`;
-      let rows;
-      if (typeof options2.limit === "number") {
-        rows = db.query(query).all(...params, options2.limit);
-      } else {
-        rows = db.query(query).all(...params);
-      }
-      return rows.map(mapRow);
-    },
-    async count(options2 = {}) {
-      const { sql, params } = buildWhereClause2(options2);
-      const query = `SELECT COUNT(*) as count FROM ${tableName} ${sql}`;
-      const row = db.query(query).get(...params);
-      return Number(row?.count ?? 0);
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureMigrated();
-      const before = timestamp;
-      const result = db.query(`DELETE FROM ${tableName} WHERE timestamp < ?`).run(before);
-      return result.changes ?? 0;
-    },
-    async clear() {
-      await ensureMigrated();
-      db.query(`DELETE FROM ${tableName}`).run();
-    }
-  };
-};
-
-// storage/usageTracking/memory.ts
-var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var matchesFilters2 = (entry, options = {}) => {
-  if (typeof options.before === "number" && entry.timestamp >= options.before) {
-    return false;
-  }
-  if (typeof options.after === "number" && entry.timestamp <= options.after) {
-    return false;
-  }
-  if (options.modelId && entry.modelId !== options.modelId) {
-    return false;
-  }
-  if (options.baseUrl && normalizeBaseUrl4(entry.baseUrl) !== normalizeBaseUrl4(options.baseUrl)) {
-    return false;
-  }
-  if (options.sessionId && entry.sessionId !== options.sessionId) {
-    return false;
-  }
-  if (options.client && entry.client !== options.client) {
-    return false;
-  }
-  return true;
-};
-var createMemoryUsageTrackingDriver = (seed = []) => {
-  const store = /* @__PURE__ */ new Map();
-  for (const entry of seed) {
-    store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
-  }
-  return {
-    async migrate() {
-      return;
-    },
-    async append(entry) {
-      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
-    },
-    async appendMany(entries) {
-      for (const entry of entries) {
-        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
-      }
-    },
-    async list(options = {}) {
-      const entries = [...store.values()].filter((entry) => matchesFilters2(entry, options)).sort((a, b) => b.timestamp - a.timestamp);
-      if (typeof options.limit === "number") {
-        return entries.slice(0, options.limit);
-      }
-      return entries;
-    },
-    async count(options = {}) {
-      return (await this.list(options)).length;
-    },
-    async deleteOlderThan(timestamp) {
-      let deleted = 0;
-      for (const [id, entry] of store.entries()) {
-        if (entry.timestamp < timestamp) {
-          store.delete(id);
-          deleted += 1;
-        }
-      }
-      return deleted;
-    },
-    async clear() {
-      store.clear();
-    }
-  };
-};
-var normalizeBaseUrl5 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
-  modelsFromAllProviders: {},
-  lastUsedModel: null,
-  baseUrlsList: [],
-  lastBaseUrlsUpdate: null,
-  disabledProviders: [],
-  mintsFromAllProviders: {},
-  infoFromAllProviders: {},
-  lastModelsUpdate: {},
-  apiKeys: [],
-  childKeys: [],
-  xcashuTokens: {},
-  routstr21Models: [],
-  lastRoutstr21ModelsUpdate: null,
-  cachedReceiveTokens: [],
-  clientIds: [],
-  failedProviders: [],
-  lastFailed: {},
-  providersOnCooldown: [],
-  setModelsFromAllProviders: (value) => {
-    const normalized = {};
-    for (const [baseUrl, models] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = models;
-    }
-    void driver.setItem(
-      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
-      normalized
-    );
-    set({ modelsFromAllProviders: normalized });
-  },
-  setLastUsedModel: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
-    set({ lastUsedModel: value });
-  },
-  setBaseUrlsList: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl5(url));
-    void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
-    set({ baseUrlsList: normalized });
-  },
-  setBaseUrlsLastUpdate: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
-    set({ lastBaseUrlsUpdate: value });
-  },
-  setDisabledProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl5(url));
-    void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
-    set({ disabledProviders: normalized });
-  },
-  setMintsFromAllProviders: (value) => {
-    const normalized = {};
-    for (const [baseUrl, mints] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = mints.map(
-        (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
-      );
-    }
-    void driver.setItem(
-      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
-      normalized
-    );
-    set({ mintsFromAllProviders: normalized });
-  },
-  setInfoFromAllProviders: (value) => {
-    const normalized = {};
-    for (const [baseUrl, info] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = info;
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
-    set({ infoFromAllProviders: normalized });
-  },
-  setLastModelsUpdate: (value) => {
-    const normalized = {};
-    for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = timestamp;
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
-    set({ lastModelsUpdate: normalized });
-  },
-  setApiKeys: (value) => {
-    set((state) => {
-      const updates = typeof value === "function" ? value(state.apiKeys) : value;
-      const normalized = updates.map((entry) => ({
-        ...entry,
-        baseUrl: normalizeBaseUrl5(entry.baseUrl),
-        balance: entry.balance ?? 0,
-        lastUsed: entry.lastUsed ?? null
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.API_KEYS, normalized);
-      return { apiKeys: normalized };
-    });
-  },
-  setChildKeys: (value) => {
-    set((state) => {
-      const updates = typeof value === "function" ? value(state.childKeys) : value;
-      const normalized = updates.map((entry) => ({
-        parentBaseUrl: normalizeBaseUrl5(entry.parentBaseUrl),
-        childKey: entry.childKey,
-        balance: entry.balance ?? 0,
-        balanceLimit: entry.balanceLimit,
-        validityDate: entry.validityDate,
-        createdAt: entry.createdAt ?? Date.now()
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
-      return { childKeys: normalized };
-    });
-  },
-  setXcashuTokens: (value) => {
-    const normalized = {};
-    for (const [baseUrl, tokens] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = tokens.map((entry) => ({
-        ...entry,
-        baseUrl: normalizeBaseUrl5(entry.baseUrl),
-        createdAt: entry.createdAt ?? Date.now(),
-        tryCount: entry.tryCount ?? 0
-      }));
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, normalized);
-    set({ xcashuTokens: normalized });
-  },
-  updateXcashuTokenTryCount: (token, tryCount) => {
-    const currentTokens = get().xcashuTokens;
-    const updatedTokens = {};
-    for (const [baseUrl, tokens] of Object.entries(currentTokens)) {
-      updatedTokens[baseUrl] = tokens.map(
-        (entry) => entry.token === token ? { ...entry, tryCount } : entry
-      );
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, updatedTokens);
-    set({ xcashuTokens: updatedTokens });
-  },
-  setRoutstr21Models: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
-    set({ routstr21Models: value });
-  },
-  setRoutstr21ModelsLastUpdate: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE, value);
-    set({ lastRoutstr21ModelsUpdate: value });
-  },
-  setCachedReceiveTokens: (value) => {
-    const normalized = value.map((entry) => ({
-      token: entry.token,
-      amount: entry.amount,
-      unit: entry.unit || "sat",
-      createdAt: entry.createdAt ?? Date.now()
-    }));
-    void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
-    set({ cachedReceiveTokens: normalized });
-  },
-  setClientIds: (value) => {
-    set((state) => {
-      const updates = typeof value === "function" ? value(state.clientIds) : value;
-      const normalized = updates.map((entry) => ({
-        ...entry,
-        createdAt: entry.createdAt ?? Date.now(),
-        lastUsed: entry.lastUsed ?? null
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.CLIENT_IDS, normalized);
-      return { clientIds: normalized };
-    });
-  },
-  // ========== Failure Tracking ==========
-  setFailedProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl5(url));
-    void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, normalized);
-    set({ failedProviders: normalized });
-  },
-  addFailedProvider: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().failedProviders;
-    if (!current.includes(normalized)) {
-      const updated = [...current, normalized];
-      void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
-      set({ failedProviders: updated });
-    }
-  },
-  removeFailedProvider: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().failedProviders;
-    const updated = current.filter((url) => url !== normalized);
-    void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
-    set({ failedProviders: updated });
-  },
-  setLastFailed: (value) => {
-    const normalized = {};
-    for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = timestamp;
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, normalized);
-    set({ lastFailed: normalized });
-  },
-  setLastFailedTimestamp: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().lastFailed;
-    const updated = { ...current, [normalized]: timestamp };
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, updated);
-    set({ lastFailed: updated });
-  },
-  setProvidersOnCooldown: (value) => {
-    const normalized = value.map((entry) => ({
-      baseUrl: normalizeBaseUrl5(entry.baseUrl),
-      timestamp: entry.timestamp
-    }));
-    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, normalized);
-    set({ providersOnCooldown: normalized });
-  },
-  addProviderOnCooldown: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().providersOnCooldown;
-    if (!current.some((entry) => entry.baseUrl === normalized)) {
-      const updated = [...current, { baseUrl: normalized, timestamp }];
-      void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
-      set({ providersOnCooldown: updated });
-    }
-  },
-  removeProviderFromCooldown: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().providersOnCooldown;
-    const updated = current.filter((entry) => entry.baseUrl !== normalized);
-    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
-    set({ providersOnCooldown: updated });
-  },
-  clearProvidersOnCooldown: () => {
-    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, []);
-    set({ providersOnCooldown: [] });
-  }
-}));
-var hydrateStoreFromDriver = async (store, driver) => {
-  const [
-    rawModels,
-    lastUsedModel,
-    rawBaseUrls,
-    lastBaseUrlsUpdate,
-    rawDisabledProviders,
-    rawMints,
-    rawInfo,
-    rawLastModelsUpdate,
-    rawApiKeys,
-    rawChildKeys,
-    rawXcashuTokens,
-    rawRoutstr21Models,
-    rawLastRoutstr21ModelsUpdate,
-    rawCachedReceiveTokens,
-    rawClientIds,
-    rawFailedProviders,
-    rawLastFailed,
-    rawProvidersOnCooldown
-  ] = await Promise.all([
-    driver.getItem(
-      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
-      {}
-    ),
-    driver.getItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, null),
-    driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []),
-    driver.getItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, null),
-    driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []),
-    driver.getItem(
-      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
-      {}
-    ),
-    driver.getItem(
-      SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
-      {}
-    ),
-    driver.getItem(
-      SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
-      {}
-    ),
-    driver.getItem(SDK_STORAGE_KEYS.API_KEYS, []),
-    driver.getItem(SDK_STORAGE_KEYS.CHILD_KEYS, []),
-    driver.getItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, {}),
-    driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
-    driver.getItem(
-      SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
-      null
-    ),
-    driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
-    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, []),
-    driver.getItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, []),
-    driver.getItem(SDK_STORAGE_KEYS.LAST_FAILED, {}),
-    driver.getItem(
-      SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN,
-      []
-    )
-  ]);
-  const modelsFromAllProviders = Object.fromEntries(
-    Object.entries(rawModels).map(([baseUrl, models]) => [
-      normalizeBaseUrl5(baseUrl),
-      models
-    ])
-  );
-  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl5(url));
-  const disabledProviders = rawDisabledProviders.map(
-    (url) => normalizeBaseUrl5(url)
-  );
-  const mintsFromAllProviders = Object.fromEntries(
-    Object.entries(rawMints).map(([baseUrl, mints]) => [
-      normalizeBaseUrl5(baseUrl),
-      mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
-    ])
-  );
-  const infoFromAllProviders = Object.fromEntries(
-    Object.entries(rawInfo).map(([baseUrl, info]) => [
-      normalizeBaseUrl5(baseUrl),
-      info
-    ])
-  );
-  const lastModelsUpdate = Object.fromEntries(
-    Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl5(baseUrl),
-      timestamp
-    ])
-  );
-  const apiKeys = rawApiKeys.map((entry) => ({
-    ...entry,
-    baseUrl: normalizeBaseUrl5(entry.baseUrl),
-    balance: entry.balance ?? 0,
-    lastUsed: entry.lastUsed ?? null
-  }));
-  const childKeys = rawChildKeys.map((entry) => ({
-    parentBaseUrl: normalizeBaseUrl5(entry.parentBaseUrl),
-    childKey: entry.childKey,
-    balance: entry.balance ?? 0,
-    balanceLimit: entry.balanceLimit,
-    validityDate: entry.validityDate,
-    createdAt: entry.createdAt ?? Date.now()
-  }));
-  const xcashuTokens = Object.fromEntries(
-    Object.entries(rawXcashuTokens).map(([baseUrl, tokens]) => [
-      normalizeBaseUrl5(baseUrl),
-      tokens.map((entry) => ({
-        baseUrl: normalizeBaseUrl5(entry.baseUrl),
-        token: entry.token,
-        createdAt: entry.createdAt ?? Date.now(),
-        tryCount: entry.tryCount ?? 0
-      }))
-    ])
-  );
-  const routstr21Models = rawRoutstr21Models;
-  const lastRoutstr21ModelsUpdate = rawLastRoutstr21ModelsUpdate;
-  const cachedReceiveTokens = rawCachedReceiveTokens?.map((entry) => ({
-    token: entry.token,
-    amount: entry.amount,
-    unit: entry.unit || "sat",
-    createdAt: entry.createdAt ?? Date.now()
-  }));
-  const clientIds = rawClientIds.map((entry) => ({
-    ...entry,
-    createdAt: entry.createdAt ?? Date.now(),
-    lastUsed: entry.lastUsed ?? null
-  }));
-  const failedProviders = rawFailedProviders.map(
-    (url) => normalizeBaseUrl5(url)
-  );
-  const lastFailed = Object.fromEntries(
-    Object.entries(rawLastFailed).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl5(baseUrl),
-      timestamp
-    ])
-  );
-  const providersOnCooldown = rawProvidersOnCooldown.map((entry) => ({
-    baseUrl: normalizeBaseUrl5(entry.baseUrl),
-    timestamp: entry.timestamp
-  }));
-  store.setState({
-    modelsFromAllProviders,
-    lastUsedModel,
-    baseUrlsList,
-    lastBaseUrlsUpdate,
-    disabledProviders,
-    mintsFromAllProviders,
-    infoFromAllProviders,
-    lastModelsUpdate,
-    apiKeys,
-    childKeys,
-    xcashuTokens,
-    routstr21Models,
-    lastRoutstr21ModelsUpdate,
-    cachedReceiveTokens,
-    clientIds,
-    failedProviders,
-    lastFailed,
-    providersOnCooldown
-  });
-};
-var createSdkStore = ({
-  driver
-}) => {
-  const store = createEmptyStore(driver);
-  return {
-    store,
-    hydrate: hydrateStoreFromDriver(store, driver)
-  };
-};
-
-// storage/index.ts
-var isBrowser2 = () => {
-  try {
-    return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
-  } catch {
-    return false;
-  }
-};
-var isNode = () => {
-  try {
-    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-  } catch {
-    return false;
-  }
-};
-var defaultDriver = null;
-var isBun3 = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var getDefaultSdkDriver = () => {
-  if (defaultDriver) return defaultDriver;
-  if (isBrowser2()) {
-    defaultDriver = localStorageDriver;
-    return defaultDriver;
-  }
-  if (isBun3()) {
-    defaultDriver = createMemoryDriver();
-    return defaultDriver;
-  }
-  if (isNode()) {
-    defaultDriver = createSqliteDriver();
-    return defaultDriver;
-  }
-  defaultDriver = createMemoryDriver();
-  return defaultDriver;
-};
-var defaultStore = null;
-var defaultUsageTrackingDriver = null;
-var getDefaultSdkStore = () => {
-  if (!defaultStore) {
-    defaultStore = createSdkStore({ driver: getDefaultSdkDriver() });
-  }
-  return defaultStore.hydrate.then(() => defaultStore.store);
-};
-var getDefaultUsageTrackingDriver = () => {
-  if (defaultUsageTrackingDriver) return defaultUsageTrackingDriver;
-  const storageDriver = getDefaultSdkDriver();
-  if (isBrowser2()) {
-    defaultUsageTrackingDriver = createIndexedDBUsageTrackingDriver({
-      legacyStorageDriver: storageDriver
-    });
-    return defaultUsageTrackingDriver;
-  }
-  if (isBun3()) {
-    defaultUsageTrackingDriver = createBunSqliteUsageTrackingDriver();
-    return defaultUsageTrackingDriver;
-  }
-  if (isNode()) {
-    defaultUsageTrackingDriver = createSqliteUsageTrackingDriver({
-      legacyStorageDriver: storageDriver
-    });
-    return defaultUsageTrackingDriver;
-  }
-  defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
-  return defaultUsageTrackingDriver;
-};
-function mergeUsage(previous, next) {
-  if (!previous) return next;
-  return {
-    promptTokens: next.promptTokens > 0 ? next.promptTokens : previous.promptTokens,
-    completionTokens: next.completionTokens > 0 ? next.completionTokens : previous.completionTokens,
-    totalTokens: next.totalTokens > 0 ? next.totalTokens : previous.totalTokens,
-    cost: next.cost > 0 ? next.cost : previous.cost,
-    satsCost: next.satsCost > 0 ? next.satsCost : previous.satsCost
-  };
-}
-function hasUsageChanged(previous, next) {
-  if (!previous) return true;
-  return previous.promptTokens !== next.promptTokens || previous.completionTokens !== next.completionTokens || previous.totalTokens !== next.totalTokens || previous.cost !== next.cost || previous.satsCost !== next.satsCost;
-}
-async function inspectSSEWebStream(stream, onUsage, onResponseId) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder("utf-8");
-  let buffer = "";
-  let capturedUsage = null;
-  let capturedResponseId;
-  let responseIdCaptured = false;
-  const inspectDataPayload = (jsonText) => {
-    if (responseIdCaptured && capturedUsage && capturedUsage.totalTokens > 0) {
-      return;
-    }
-    const trimmed = jsonText.trim();
-    if (!trimmed || trimmed === "[DONE]") return;
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return;
-    try {
-      const data = JSON.parse(trimmed);
-      if (!responseIdCaptured) {
-        const responseId = data?.id;
-        if (typeof responseId === "string" && responseId.trim().length > 0) {
-          capturedResponseId = responseId.trim();
-          onResponseId?.(capturedResponseId);
-          responseIdCaptured = true;
-        }
-      }
-      const usage = extractUsageFromSSEJson(data);
-      if (usage) {
-        const merged = mergeUsage(capturedUsage, usage);
-        if (hasUsageChanged(capturedUsage, merged)) {
-          capturedUsage = merged;
-          onUsage(merged);
-        }
-      }
-    } catch {
-    }
-  };
-  const inspectEventBlock = (eventBlock) => {
-    if (responseIdCaptured && capturedUsage && capturedUsage.totalTokens > 0) {
-      return;
-    }
-    const lines = eventBlock.split(/\r?\n/);
-    const dataParts = [];
-    for (const line of lines) {
-      if (!line || line.startsWith(":")) continue;
-      if (line.startsWith("data:")) {
-        const value = line.startsWith("data: ") ? line.slice(6) : line.slice(5);
-        dataParts.push(value);
-      }
-    }
-    if (dataParts.length === 0) return;
-    inspectDataPayload(dataParts.join("\n"));
-  };
-  const drainBufferedEvents = () => {
-    const terminator = /\r?\n\r?\n/g;
-    let lastIndex = 0;
-    let match;
-    while ((match = terminator.exec(buffer)) !== null) {
-      const block = buffer.slice(lastIndex, match.index);
-      lastIndex = match.index + match[0].length;
-      if (block.length > 0) inspectEventBlock(block);
-    }
-    if (lastIndex > 0) buffer = buffer.slice(lastIndex);
-  };
-  try {
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      if (value && value.byteLength > 0) {
-        buffer += decoder.decode(value, { stream: true });
-        drainBufferedEvents();
-      }
-    }
-    buffer += decoder.decode();
-    drainBufferedEvents();
-    if (buffer.length > 0) {
-      const tail = buffer.replace(/\r?\n+$/, "");
-      if (tail.length > 0) inspectEventBlock(tail);
-      buffer = "";
-    }
-  } catch {
-  } finally {
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-  return {
-    capturedUsage: capturedUsage ?? void 0,
-    capturedResponseId
-  };
-}
-function createSSEParserTransform(onUsage, onResponseId) {
-  let buffer = "";
-  const decoder = new string_decoder.StringDecoder("utf8");
-  let capturedUsage = null;
-  let responseIdCaptured = false;
-  const inspectDataPayload = (jsonText) => {
-    if (responseIdCaptured && capturedUsage && capturedUsage.totalTokens > 0) {
-      return;
-    }
-    const trimmed = jsonText.trim();
-    if (!trimmed || trimmed === "[DONE]") return;
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return;
-    try {
-      const data = JSON.parse(trimmed);
-      if (!responseIdCaptured) {
-        const responseId = data?.id;
-        if (typeof responseId === "string" && responseId.trim().length > 0) {
-          onResponseId?.(responseId.trim());
-          responseIdCaptured = true;
-        }
-      }
-      const usage = extractUsageFromSSEJson(data);
-      if (usage) {
-        const mergedUsage = mergeUsage(capturedUsage, usage);
-        if (hasUsageChanged(capturedUsage, mergedUsage)) {
-          capturedUsage = mergedUsage;
-          onUsage(mergedUsage);
-        }
-      }
-    } catch {
-    }
-  };
-  const inspectEventBlock = (eventBlock) => {
-    if (responseIdCaptured && capturedUsage && capturedUsage.totalTokens > 0) {
-      return;
-    }
-    const lines = eventBlock.split(/\r?\n/);
-    const dataParts = [];
-    for (const line of lines) {
-      if (!line || line.startsWith(":")) continue;
-      if (line.startsWith("data:")) {
-        const value = line.startsWith("data: ") ? line.slice(6) : line.slice(5);
-        dataParts.push(value);
-      }
-    }
-    if (dataParts.length === 0) return;
-    const payload = dataParts.join("\n");
-    inspectDataPayload(payload);
-  };
-  const processBufferedEvents = () => {
-    const terminator = /\r?\n\r?\n/g;
-    let lastIndex = 0;
-    let match;
-    while ((match = terminator.exec(buffer)) !== null) {
-      const block = buffer.slice(lastIndex, match.index);
-      lastIndex = match.index + match[0].length;
-      if (block.length > 0) {
-        inspectEventBlock(block);
-      }
-    }
-    if (lastIndex > 0) {
-      buffer = buffer.slice(lastIndex);
-    }
-  };
-  return new stream.Transform({
-    transform(chunk, _encoding, callback) {
-      this.push(chunk);
-      buffer += decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-      processBufferedEvents();
-      callback();
-    },
-    flush(callback) {
-      buffer += decoder.end();
-      processBufferedEvents();
-      if (buffer.length > 0) {
-        const tail = buffer.replace(/\r?\n+$/, "");
-        if (tail.length > 0) {
-          inspectEventBlock(tail);
-        }
-        buffer = "";
-      }
-      callback();
-    }
-  });
-}
-
-// client/RoutstrClient.ts
-var TOPUP_MARGIN = 1.2;
-var RoutstrClient = class {
-  constructor(walletAdapter, storageAdapter, providerRegistry, alertLevel, mode = "xcashu", options = {}) {
-    this.walletAdapter = walletAdapter;
-    this.storageAdapter = storageAdapter;
-    this.providerRegistry = providerRegistry;
-    this.logger = (options.logger ?? consoleLogger).child("RoutstrClient");
-    this.balanceManager = new BalanceManager(
-      walletAdapter,
-      storageAdapter,
-      providerRegistry
-    );
-    this.cashuSpender = new CashuSpender(
-      walletAdapter,
-      storageAdapter,
-      providerRegistry,
-      this.balanceManager
-    );
-    this.streamProcessor = new StreamProcessor();
-    this.alertLevel = alertLevel;
-    this.mode = mode;
-    this.usageTrackingDriver = options.usageTrackingDriver;
-    this.sdkStore = options.sdkStore;
-    this.providerManager = options.providerManager ?? new ProviderManager(providerRegistry, this.sdkStore, this.logger);
-  }
-  cashuSpender;
-  balanceManager;
-  streamProcessor;
-  providerManager;
-  alertLevel;
-  mode;
-  debugLevel = "WARN";
-  usageTrackingDriver;
-  sdkStore;
-  logger;
-  /**
-   * Get the current client mode
-   */
-  getMode() {
-    return this.mode;
-  }
-  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;
-      }
-    }
-  }
-  /**
-   * Get the CashuSpender instance
-   */
-  getCashuSpender() {
-    return this.cashuSpender;
-  }
-  /**
-   * Get the BalanceManager instance
-   */
-  getBalanceManager() {
-    return this.balanceManager;
-  }
-  /**
-   * Get the ProviderManager instance
-   */
-  getProviderManager() {
-    return this.providerManager;
-  }
-  /**
-   * Check if the client is currently busy (in critical section)
-   */
-  get isBusy() {
-    return this.cashuSpender.isBusy;
-  }
-  /**
-   * Route an API request to the upstream provider
-   *
-   * This is a simpler alternative to fetchAIResponse that just proxies
-   * the request upstream without the streaming callback machinery.
-   * Useful for daemon-style routing where you just need to forward
-   * requests and get responses back.
-   */
-  async routeRequest(params) {
-    const prepared = await this._prepareRoutedRequest(params);
-    const contentType = prepared.response.headers.get("content-type") || "";
-    const isSSE = contentType.includes("text/event-stream");
-    const runFinalize = async () => {
-      const { capturedUsage, capturedResponseId } = await prepared.usagePromise;
-      const usage = capturedUsage ?? prepared.capturedUsage;
-      const requestId = capturedResponseId ?? prepared.capturedResponseId;
-      const satsSpent = await this._handlePostResponseBalanceUpdate({
-        token: prepared.tokenUsed,
-        baseUrl: prepared.baseUrlUsed,
-        mintUrl: params.mintUrl,
-        initialTokenBalance: prepared.tokenBalanceInSats,
-        response: prepared.response,
-        modelId: prepared.modelId,
-        usage,
-        requestId,
-        clientApiKey: prepared.clientApiKey
-      });
-      prepared.response.satsSpent = satsSpent;
-      prepared.response.usage = usage;
-      prepared.response.requestId = requestId;
-      return satsSpent;
-    };
-    if (isSSE) {
-      const finalizePromise = runFinalize().catch((error) => {
-        this._log("ERROR", "[RoutstrClient] SSE finalize failed:", error);
-        return 0;
-      });
-      prepared.response.finalize = () => finalizePromise;
-      return prepared.response;
-    }
-    await runFinalize();
-    return prepared.response;
-  }
-  async _prepareRoutedRequest(params) {
-    const {
-      path: requestPath,
-      method,
-      body,
-      headers = {},
-      baseUrl,
-      mintUrl,
-      modelId,
-      clientApiKey: providedClientApiKey
-    } = params;
-    const clientApiKey = providedClientApiKey ?? this._extractClientApiKey(headers);
-    await this._checkBalance();
-    let requiredSats = 1;
-    let selectedModel;
-    if (modelId) {
-      const providerModel = await this.providerManager.getModelForProvider(
-        baseUrl,
-        modelId
-      );
-      selectedModel = providerModel ?? void 0;
-      if (selectedModel) {
-        const requestMessages = Array.isArray(
-          body?.messages
-        ) ? body.messages : [];
-        const requestMaxTokens = typeof body?.max_tokens === "number" ? body.max_tokens : void 0;
-        this._log(
-          "DEBUG",
-          "[RoutstrClient] generic request pricing input",
-          {
-            modelId: selectedModel.id,
-            messageCount: requestMessages.length,
-            maxTokens: requestMaxTokens
-          }
-        );
-        requiredSats = this.providerManager.getRequiredSatsForModel(
-          selectedModel,
-          requestMessages,
-          requestMaxTokens
-        );
-      }
-    }
-    const { token, tokenBalance, tokenBalanceUnit } = await this._spendToken({
-      mintUrl,
-      amount: requiredSats,
-      baseUrl
-    });
-    let requestBody = body;
-    if (body && typeof body === "object") {
-      const bodyObj = body;
-      if (!bodyObj.stream) {
-        requestBody = { ...bodyObj, stream: false };
-      }
-    }
-    const baseHeaders = this._buildBaseHeaders();
-    const requestHeaders = this._withAuthHeader(baseHeaders, token);
-    const response = await this._makeRequest({
-      path: requestPath,
-      method,
-      body: method === "GET" ? void 0 : requestBody,
-      baseUrl,
-      mintUrl,
-      token,
-      requiredSats,
-      headers: requestHeaders,
-      baseHeaders,
-      selectedModel
-    });
-    const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
-    const baseUrlUsed = response.baseUrl || baseUrl;
-    const tokenUsed = response.token || token;
-    const contentType = response.headers.get("content-type") || "";
-    let processedResponse = response;
-    let capturedUsage;
-    let capturedResponseId;
-    let usagePromise = Promise.resolve({});
-    if (contentType.includes("text/event-stream") && response.body) {
-      const [clientStream, inspectStream] = response.body.tee();
-      processedResponse = new Response(clientStream, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers
-      });
-      processedResponse.baseUrl = response.baseUrl;
-      processedResponse.token = response.token;
-      usagePromise = inspectSSEWebStream(
-        inspectStream,
-        (usage) => {
-          capturedUsage = usage;
-          processedResponse.usage = usage;
-        },
-        (responseId) => {
-          capturedResponseId = responseId;
-          processedResponse.requestId = responseId;
-        }
-      );
-      processedResponse.usagePromise = usagePromise;
-    }
-    return {
-      response: processedResponse,
-      tokenUsed,
-      baseUrlUsed,
-      tokenBalanceInSats,
-      modelId,
-      capturedUsage,
-      capturedResponseId,
-      clientApiKey,
-      usagePromise
-    };
-  }
-  /**
-   * Extract clientApiKey from Authorization Bearer token if present
-   */
-  _extractClientApiKey(headers) {
-    const authHeader = headers["Authorization"] || headers["authorization"];
-    if (authHeader?.startsWith("Bearer ")) {
-      const extractedKey = authHeader.slice(7);
-      return extractedKey;
-    }
-    return void 0;
-  }
-  /**
-   * Fetch AI response with streaming
-   */
-  async fetchAIResponse(options, callbacks) {
-    const {
-      messageHistory,
-      selectedModel,
-      baseUrl,
-      mintUrl,
-      balance,
-      transactionHistory,
-      maxTokens,
-      headers
-    } = options;
-    const apiMessages = await this._convertMessages(messageHistory);
-    const requiredSats = this.providerManager.getRequiredSatsForModel(
-      selectedModel,
-      apiMessages,
-      maxTokens
-    );
-    try {
-      await this._checkBalance();
-      callbacks.onPaymentProcessing?.(true);
-      const spendResult = await this._spendToken({
-        mintUrl,
-        amount: requiredSats,
-        baseUrl
-      });
-      let token = spendResult.token;
-      let tokenBalance = spendResult.tokenBalance;
-      let tokenBalanceUnit = spendResult.tokenBalanceUnit;
-      const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
-      callbacks.onTokenCreated?.(this._getPendingCashuTokenAmount());
-      const baseHeaders = this._buildBaseHeaders(headers);
-      const requestHeaders = this._withAuthHeader(baseHeaders, token);
-      const providerInfo = await this.providerRegistry.getProviderInfo(baseUrl);
-      const providerVersion = providerInfo?.version ?? "";
-      let modelIdForRequest = selectedModel.id;
-      if (/^0\.1\./.test(providerVersion)) {
-        const newModel = await this.providerManager.getModelForProvider(
-          baseUrl,
-          selectedModel.id
-        );
-        modelIdForRequest = newModel?.id ?? selectedModel.id;
-      }
-      const body = {
-        model: modelIdForRequest,
-        messages: apiMessages,
-        stream: true
-      };
-      if (maxTokens !== void 0) {
-        body.max_tokens = maxTokens;
-      }
-      if (selectedModel?.name?.startsWith("OpenAI:")) {
-        body.tools = [{ type: "web_search" }];
-      }
-      const response = await this._makeRequest({
-        path: "/v1/chat/completions",
-        method: "POST",
-        body,
-        selectedModel,
-        baseUrl,
-        mintUrl,
-        token,
-        requiredSats,
-        maxTokens,
-        headers: requestHeaders,
-        baseHeaders
-      });
-      if (!response.body) {
-        throw new Error("Response body is not available");
-      }
-      if (response.status === 200) {
-        const baseUrlUsed = response.baseUrl || baseUrl;
-        const streamingResult = await this.streamProcessor.process(
-          response,
-          {
-            onContent: callbacks.onStreamingUpdate,
-            onThinking: callbacks.onThinkingUpdate
-          },
-          selectedModel.id
-        );
-        if (streamingResult.finish_reason === "content_filter") {
-          callbacks.onMessageAppend({
-            role: "assistant",
-            content: "Your request was denied due to content filtering."
-          });
-        } else if (streamingResult.content || streamingResult.images && streamingResult.images.length > 0) {
-          const message = await this._createAssistantMessage(streamingResult);
-          callbacks.onMessageAppend(message);
-        } else {
-          callbacks.onMessageAppend({
-            role: "system",
-            content: "The provider did not respond to this request."
-          });
-        }
-        callbacks.onStreamingUpdate("");
-        callbacks.onThinkingUpdate("");
-        const isApikeysEstimate = this.mode === "apikeys";
-        let satsSpent = await this._handlePostResponseBalanceUpdate({
-          token,
-          baseUrl: baseUrlUsed,
-          mintUrl,
-          initialTokenBalance: tokenBalanceInSats,
-          fallbackSatsSpent: isApikeysEstimate ? this._getEstimatedCosts(selectedModel, streamingResult) : void 0,
-          response,
-          modelId: selectedModel.id,
-          usage: streamingResult.usage ? {
-            promptTokens: Number(streamingResult.usage.prompt_tokens ?? 0),
-            completionTokens: Number(
-              streamingResult.usage.completion_tokens ?? 0
-            ),
-            totalTokens: Number(streamingResult.usage.total_tokens ?? 0),
-            cost: Number(streamingResult.usage.cost ?? 0),
-            satsCost: Number(streamingResult.usage.sats_cost ?? 0)
-          } : void 0,
-          requestId: streamingResult.responseId
-        });
-        const estimatedCosts = this._getEstimatedCosts(
-          selectedModel,
-          streamingResult
-        );
-        const onLastMessageSatsUpdate = callbacks.onLastMessageSatsUpdate;
-        onLastMessageSatsUpdate?.(satsSpent, estimatedCosts);
-      } else {
-        throw new Error(`${response.status} ${response.statusText}`);
-      }
-    } catch (error) {
-      this._handleError(error, callbacks);
-    } finally {
-      callbacks.onPaymentProcessing?.(false);
-    }
-  }
-  /**
-   * Make the API request with failover support
-   */
-  async _makeRequest(params) {
-    const { path, method, body, baseUrl, token, headers } = params;
-    try {
-      const url = `${baseUrl.replace(/\/$/, "")}${path}`;
-      if (this.mode === "xcashu") this._log("DEBUG", "HEADERS,", headers);
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: body === void 0 || method === "GET" ? void 0 : JSON.stringify(body)
-      });
-      if (this.mode === "xcashu") this._log("DEBUG", "response,", response);
-      response.baseUrl = baseUrl;
-      response.token = token;
-      if (!response.ok) {
-        const requestId = response.headers.get("x-routstr-request-id") || void 0;
-        let bodyText;
-        try {
-          bodyText = await response.text();
-        } catch (e) {
-          bodyText = void 0;
-        }
-        return await this._handleErrorResponse(
-          params,
-          token,
-          response.status,
-          requestId,
-          this.mode === "xcashu" ? response.headers.get("x-cashu") ?? void 0 : void 0,
-          bodyText,
-          params.retryCount ?? 0
-        );
-      }
-      return response;
-    } catch (error) {
-      if (isNetworkErrorMessage(error?.message || "")) {
-        return await this._handleErrorResponse(
-          params,
-          token,
-          -1,
-          // just for Network Error to skip all statuses
-          void 0,
-          void 0,
-          void 0,
-          params.retryCount ?? 0
-        );
-      }
-      throw error;
-    }
-  }
-  /**
-   * Handle error responses with failover
-   */
-  async _handleErrorResponse(params, token, status, requestId, xCashuRefundToken, responseBody, retryCount = 0) {
-    const MAX_RETRIES_PER_PROVIDER = 2;
-    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
-    let tryNextProvider = false;
-    const errorMessage = responseBody;
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: status=${status}, baseUrl=${baseUrl}, mode=${this.mode}, token preview=${token}, requestId=${requestId}, errorMessage=${errorMessage}`
-    );
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: Attempting to receive/restore token for ${baseUrl}`
-    );
-    if (params.token.startsWith("cashu")) {
-      const receiveResult = await this.cashuSpender.receiveToken(
-        params.token
-      );
-      if (receiveResult.success) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${receiveResult.amount}`
-        );
-        tryNextProvider = true;
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Failed to receive token: ${receiveResult.message}`
-        );
-      }
-    }
-    if (this.mode === "xcashu") {
-      if (xCashuRefundToken) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Attempting to receive xcashu refund token, preview=${xCashuRefundToken.substring(0, 20)}...`
-        );
-        const receiveResult = await this.cashuSpender.receiveToken(xCashuRefundToken);
-        if (receiveResult.success) {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: xcashu refund received, amount=${receiveResult.amount}`
-          );
-          tryNextProvider = true;
-        } else {
-          this._log(
-            "ERROR",
-            `[xcashu] Failed to receive refund token: ${receiveResult.message}`
-          );
-          throw new ProviderError(
-            baseUrl,
-            status,
-            "[xcashu] Failed to receive refund token",
-            requestId
-          );
-        }
-      } else {
-        if (!tryNextProvider)
-          throw new ProviderError(
-            baseUrl,
-            status,
-            "[xcashu] Failed to receive refund token",
-            requestId
-          );
-      }
-    }
-    if (status === 402 && !tryNextProvider && this.mode === "apikeys") {
-      this.storageAdapter.getApiKey(baseUrl);
-      let topupAmount = params.requiredSats;
-      try {
-        const currentBalanceInfo = await this.balanceManager.getTokenBalance(
-          params.token,
-          baseUrl
-        );
-        const currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
-        const reservedBalance = currentBalanceInfo.unit === "msat" ? (currentBalanceInfo.reserved ?? 0) / 1e3 : currentBalanceInfo.reserved ?? 0;
-        const shortfall = Math.max(0, params.requiredSats - currentBalance + reservedBalance);
-        topupAmount = shortfall > 0.21 * params.requiredSats ? shortfall : 0.21 * params.requiredSats;
-        this._log(
-          "DEBUG",
-          `The shortfall is: ${shortfall}. requiredSats: ${params.requiredSats}. Current Balance: ${currentBalance}. Reserved Balance: ${reservedBalance}. Available Balance: ${currentBalance - reservedBalance}`
-        );
-      } catch (e) {
-        this._log(
-          "WARN",
-          "Could not get current token balance for topup calculation:",
-          e
-        );
-      }
-      const topupResult = await this.balanceManager.topUp({
-        mintUrl,
-        baseUrl,
-        amount: topupAmount * TOPUP_MARGIN,
-        token: params.token
-      });
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Topup result for ${baseUrl}: success=${topupResult.success}, message=${topupResult.message}`
-      );
-      if (!topupResult.success) {
-        const message = topupResult.message || "";
-        if (message.includes("Insufficient balance")) {
-          const needMatch = message.match(/need (\d+)/);
-          const haveMatch = message.match(/have (\d+)/);
-          const required = needMatch ? parseInt(needMatch[1], 10) : params.requiredSats;
-          const available = haveMatch ? parseInt(haveMatch[1], 10) : 0;
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
-          );
-          throw new InsufficientBalanceError(
-            required,
-            available,
-            0,
-            "",
-            message
-          );
-        } else {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Topup failed with non-insufficient-balance error, will try next provider`
-          );
-          tryNextProvider = true;
-        }
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Topup successful, will retry with new token`
-        );
-      }
-      if (!tryNextProvider) {
-        if (retryCount < MAX_RETRIES_PER_PROVIDER) {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Retrying 402 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
-          );
-          return this._makeRequest({
-            ...params,
-            token: params.token,
-            headers: this._withAuthHeader(params.baseHeaders, params.token),
-            retryCount: retryCount + 1
-          });
-        } else {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: 402 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
-          );
-          tryNextProvider = true;
-        }
-      }
-    }
-    const isInsufficientBalance413 = status === 413 && responseBody?.includes("Insufficient balance");
-    if (isInsufficientBalance413 && !tryNextProvider && this.mode === "apikeys") {
-      let retryToken = params.token;
-      try {
-        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-          params.token,
-          baseUrl
-        );
-        if (latestBalanceInfo.isInvalidApiKey) {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Invalid API key (proofs already spent), removing for ${baseUrl}`
-          );
-          this.storageAdapter.removeApiKey(baseUrl);
-          tryNextProvider = true;
-        } else {
-          const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
-          if (latestBalanceInfo.apiKey) {
-            const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
-            if (storedApiKeyEntry?.key !== latestBalanceInfo.apiKey) {
-              if (storedApiKeyEntry) {
-                this.storageAdapter.removeApiKey(baseUrl);
-              }
-              this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
-            }
-            retryToken = latestBalanceInfo.apiKey;
-          }
-          if (latestTokenBalance >= 0) {
-            this.storageAdapter.updateApiKeyBalance(
-              baseUrl,
-              latestTokenBalance
-            );
-          }
-        }
-      } catch (error) {
-        this._log(
-          "WARN",
-          `[RoutstrClient] _handleErrorResponse: Failed to refresh API key after 413 insufficient balance for ${baseUrl}`,
-          error
-        );
-      }
-      if (retryCount < MAX_RETRIES_PER_PROVIDER) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Retrying 413 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
-        );
-        return this._makeRequest({
-          ...params,
-          token: retryToken,
-          headers: this._withAuthHeader(params.baseHeaders, retryToken),
-          retryCount: retryCount + 1
-        });
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: 413 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
-        );
-        tryNextProvider = true;
-      }
-    }
-    if (status === 401 && this.mode === "apikeys") {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Checking balance for ${baseUrl}, key preview=${token}`
-      );
-      const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-        token,
-        baseUrl
-      );
-      if (latestBalanceInfo.isInvalidApiKey) {
-        this.storageAdapter.removeApiKey(baseUrl);
-        tryNextProvider = true;
-      }
-    }
-    if ((status === 401 || status === 403 || status === 404 || status === 413 || status === 400 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Status ${status} (${status === 429 ? "rate limited" : "auth/server error"}), attempting refund for ${baseUrl}, mode=${this.mode}`
-      );
-      if (this.mode === "apikeys") {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`
-        );
-        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-          token,
-          baseUrl
-        );
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${latestBalanceInfo.amount}`
-        );
-        const refundResult = await this.balanceManager.refundApiKey({
-          mintUrl,
-          baseUrl,
-          apiKey: token,
-          forceRefund: true
-        });
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
-        );
-        if (!refundResult.success && latestBalanceInfo.amount > 0) {
-          throw new ProviderError(
-            baseUrl,
-            status,
-            refundResult.message ?? "Unknown error"
-          );
-        }
-      }
-    }
-    this.providerManager.markFailed(baseUrl);
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: Marked provider ${baseUrl} as failed`
-    );
-    if (!selectedModel) {
-      throw new ProviderError(
-        baseUrl,
-        status,
-        "Funny, no selected model. HMM. "
-      );
-    }
-    const nextProvider = this.providerManager.findNextBestProvider(
-      selectedModel.id,
-      baseUrl
-    );
-    if (nextProvider) {
-      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
-      );
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Creating new token for failover provider ${nextProvider}, required sats: ${newRequiredSats}`
-      );
-      const spendResult = await this._spendToken({
-        mintUrl,
-        amount: newRequiredSats,
-        baseUrl: nextProvider
-      });
-      return this._makeRequest({
-        ...params,
-        path,
-        method,
-        body,
-        baseUrl: nextProvider,
-        selectedModel: newModel,
-        token: spendResult.token,
-        requiredSats: newRequiredSats,
-        headers: this._withAuthHeader(params.baseHeaders, spendResult.token),
-        retryCount: 0
-      });
-    }
-    throw new FailoverError(
-      baseUrl,
-      Array.from(this.providerManager.getFailedProviders())
-    );
-  }
-  /**
-   * Handle post-response balance update for all modes
-   */
-  async _handlePostResponseBalanceUpdate(params) {
-    const {
-      token,
-      baseUrl,
-      mintUrl,
-      initialTokenBalance,
-      fallbackSatsSpent,
-      response,
-      modelId,
-      usage,
-      requestId,
-      clientApiKey
-    } = params;
-    let satsSpent = initialTokenBalance;
-    if (this.mode === "xcashu" && response) {
-      const refundToken = response.headers.get("x-cashu") ?? void 0;
-      if (refundToken) {
-        const receiveResult = await this.cashuSpender.receiveToken(refundToken);
-        if (receiveResult.success) {
-          this.storageAdapter.removeXcashuToken(baseUrl, token);
-          satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
-        } else {
-          this._log(
-            "ERROR",
-            `[xcashu] Failed to receive refund token: ${receiveResult.message}`
-          );
-        }
-      }
-    } else if (this.mode === "apikeys") {
-      try {
-        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-          token,
-          baseUrl
-        );
-        this._log(
-          "DEBUG",
-          "LATEST Balance",
-          latestBalanceInfo.amount,
-          latestBalanceInfo.reserved,
-          latestBalanceInfo.apiKey,
-          baseUrl
-        );
-        const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
-        const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
-        if (storedApiKeyEntry?.key.startsWith("cashu") && latestBalanceInfo.apiKey) {
-          this.storageAdapter.removeApiKey(baseUrl);
-          this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
-        }
-        this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
-        satsSpent = initialTokenBalance - latestTokenBalance;
-      } catch (e) {
-        this._log("WARN", "Could not get updated API key balance:", e);
-        satsSpent = fallbackSatsSpent ?? initialTokenBalance;
-      }
-    }
-    await this._trackResponseUsage({
-      token,
-      baseUrl,
-      response,
-      modelId,
-      satsSpent,
-      usage,
-      requestId,
-      clientApiKey
-    });
-    (async () => {
-    })();
-    return satsSpent;
-  }
-  async _trackResponseUsage(params) {
-    const {
-      token,
-      baseUrl,
-      response,
-      modelId,
-      satsSpent,
-      usage: providedUsage,
-      requestId: providedRequestId,
-      clientApiKey
-    } = params;
-    if (!response || !modelId) {
-      return;
-    }
-    try {
-      let usage = providedUsage;
-      let requestId = providedRequestId;
-      if (!usage || !requestId) {
-        const contentType = response.headers.get("content-type") || "";
-        if (contentType.includes("text/event-stream")) {
-          usage = usage ?? response.usage;
-          requestId = requestId ?? response.requestId ?? response.headers.get("x-routstr-request-id") ?? void 0;
-          if (!usage) {
-            return;
-          }
-        } else {
-          const cloned = response.clone();
-          const responseBody = await cloned.json();
-          usage = usage ?? extractUsageFromResponseBody(responseBody, satsSpent) ?? void 0;
-          requestId = requestId ?? extractResponseId(responseBody) ?? response.headers.get("x-routstr-request-id") ?? void 0;
-        }
-      }
-      if (!usage) {
-        return;
-      }
-      const finalRequestId = requestId || "unknown";
-      const store = this.sdkStore ?? await getDefaultSdkStore();
-      const state = store.getState();
-      const matchKey = clientApiKey ?? token;
-      const matchingClient = state.clientIds.find(
-        (client) => client.apiKey === matchKey
-      );
-      const entryId = finalRequestId === "unknown" ? `req-${Date.now()}-${modelId}` : finalRequestId;
-      const usageTracking = this.usageTrackingDriver ?? getDefaultUsageTrackingDriver();
-      const entry = {
-        id: entryId,
-        timestamp: Date.now(),
-        modelId,
-        baseUrl,
-        requestId: finalRequestId,
-        client: matchingClient?.clientId,
-        ...usage
-      };
-      if (this.mode === "xcashu") {
-        entry.satsCost = satsSpent;
-      }
-      await usageTracking.append(entry);
-    } catch (error) {
-    }
-  }
-  /**
-   * Convert messages for API format
-   */
-  async _convertMessages(messages) {
-    return Promise.all(
-      messages.filter((m) => m.role !== "system").map(async (m) => ({
-        role: m.role,
-        content: typeof m.content === "string" ? m.content : m.content
-      }))
-    );
-  }
-  /**
-   * Create assistant message from streaming result
-   */
-  async _createAssistantMessage(result) {
-    if (result.images && result.images.length > 0) {
-      const content = [];
-      if (result.content) {
-        content.push({
-          type: "text",
-          text: result.content,
-          thinking: result.thinking,
-          citations: result.citations,
-          annotations: result.annotations
-        });
-      }
-      for (const img of result.images) {
-        content.push({
-          type: "image_url",
-          image_url: {
-            url: img.image_url.url
-          }
-        });
-      }
-      return {
-        role: "assistant",
-        content
-      };
-    }
-    return {
-      role: "assistant",
-      content: result.content || ""
-    };
-  }
-  /**
-   * Calculate estimated costs from usage
-   */
-  _getEstimatedCosts(selectedModel, streamingResult) {
-    let estimatedCosts = 0;
-    if (streamingResult.usage) {
-      const { completion_tokens, prompt_tokens } = streamingResult.usage;
-      if (completion_tokens !== void 0 && prompt_tokens !== void 0) {
-        estimatedCosts = (selectedModel.sats_pricing?.completion ?? 0) * completion_tokens + (selectedModel.sats_pricing?.prompt ?? 0) * prompt_tokens;
-      }
-    }
-    return estimatedCosts;
-  }
-  /**
-   * Get pending API key amount
-   */
-  _getPendingCashuTokenAmount() {
-    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-    return apiKeyDistribution.reduce((total, item) => total + item.amount, 0);
-  }
-  /**
-   * Handle errors and notify callbacks
-   */
-  _handleError(error, callbacks) {
-    this._log("ERROR", "[RoutstrClient] _handleError: Error occurred", error);
-    if (error instanceof Error) {
-      const isStreamError = error.message.includes("Error in input stream") || error.message.includes("Load failed");
-      const modifiedErrorMsg = isStreamError ? "AI stream was cut off, turn on Keep Active or please try again" : error.message;
-      this._log(
-        "ERROR",
-        `[RoutstrClient] _handleError: Error type=${error.constructor.name}, message=${modifiedErrorMsg}, isStreamError=${isStreamError}`
-      );
-      callbacks.onMessageAppend({
-        role: "system",
-        content: "Uncaught Error: " + modifiedErrorMsg + (this.alertLevel === "max" ? " | " + error.stack : "")
-      });
-    } else {
-      callbacks.onMessageAppend({
-        role: "system",
-        content: "Unknown Error: Please tag Routstr on Nostr and/or retry."
-      });
-    }
-  }
-  /**
-   * Check wallet balance and throw if insufficient
-   */
-  async _checkBalance() {
-    const balances = await this.walletAdapter.getBalances();
-    const totalBalance = Object.values(balances).reduce((sum, v) => sum + v, 0);
-    if (totalBalance <= 0) {
-      throw new InsufficientBalanceError(1, 0);
-    }
-  }
-  /**
-   * Spend a token using CashuSpender with standardized error handling
-   */
-  async _spendToken(params) {
-    const { mintUrl, amount, baseUrl } = params;
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _spendToken: mode=${this.mode}, amount=${amount}, baseUrl=${baseUrl}, mintUrl=${mintUrl}`
-    );
-    if (this.mode === "apikeys") {
-      let parentApiKey = this.storageAdapter.getApiKey(baseUrl);
-      if (!parentApiKey) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: No existing API key for ${baseUrl}, creating new one via Cashu`
-        );
-        const spendResult2 = await this.cashuSpender.spend({
-          mintUrl,
-          amount: amount * TOPUP_MARGIN,
-          baseUrl: "",
-          reuseToken: false
-        });
-        if (!spendResult2.token) {
-          this._log(
-            "ERROR",
-            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error:`,
-            spendResult2.error
-          );
-          throw new Error(
-            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error: ${spendResult2.error}`
-          );
-        } else {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult2.token}`
-          );
-        }
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: Created API key for ${baseUrl}, key preview: ${spendResult2.token}, balance: ${spendResult2.balance}`
-        );
-        try {
-          this.storageAdapter.setApiKey(baseUrl, spendResult2.token);
-        } catch (error) {
-          if (error instanceof Error && error.message.includes("ApiKey already exists")) {
-            const receiveResult = await this.cashuSpender.receiveToken(
-              spendResult2.token
-            );
-            if (receiveResult.success) {
-              this._log(
-                "DEBUG",
-                `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${receiveResult.amount}`
-              );
-            } else {
-              this._log(
-                "DEBUG",
-                `[RoutstrClient] _handleErrorResponse: Token restore failed: ${receiveResult.message}`
-              );
-            }
-            this._log(
-              "DEBUG",
-              `[RoutstrClient] _spendToken: API key already exists for ${baseUrl}, using existing key`
-            );
-          } else {
-            throw error;
-          }
-        }
-        parentApiKey = this.storageAdapter.getApiKey(baseUrl);
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: Using existing API key for ${baseUrl}, key preview: ${parentApiKey.key}`
-        );
-      }
-      let tokenBalance = 0;
-      let tokenBalanceUnit = "sat";
-      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-      const distributionForBaseUrl = apiKeyDistribution.find(
-        (d) => d.baseUrl === baseUrl
-      );
-      if (distributionForBaseUrl) {
-        tokenBalance = distributionForBaseUrl.amount;
-      }
-      if (tokenBalance === 0 && parentApiKey) {
-        try {
-          const balanceInfo = await this.balanceManager.getTokenBalance(
-            parentApiKey.key,
-            baseUrl
-          );
-          tokenBalance = balanceInfo.amount;
-          tokenBalanceUnit = balanceInfo.unit;
-        } catch (e) {
-          this._log("WARN", "Could not get initial API key balance:", e);
-        }
-      }
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _spendToken: Returning token with balance=${tokenBalance} ${tokenBalanceUnit}`
-      );
-      return {
-        token: parentApiKey?.key ?? "",
-        tokenBalance,
-        tokenBalanceUnit
-      };
-    }
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _spendToken: Calling CashuSpender.spend for amount=${amount}, mintUrl=${mintUrl}, mode=${this.mode}`
-    );
-    const spendResult = await this.cashuSpender.spend({
-      mintUrl,
-      amount,
-      baseUrl: "",
-      reuseToken: false
-    });
-    if (!spendResult.token) {
-      this._log(
-        "ERROR",
-        `[RoutstrClient] _spendToken: CashuSpender.spend failed, error:`,
-        spendResult.error
-      );
-    } else {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult.token}, balance: ${spendResult.balance} ${spendResult.unit ?? "sat"}`
-      );
-      this.storageAdapter.addXcashuToken(baseUrl, spendResult.token);
-    }
-    return {
-      token: spendResult.token,
-      tokenBalance: spendResult.balance,
-      tokenBalanceUnit: spendResult.unit ?? "sat"
-    };
-  }
-  /**
-   * Build request headers with common defaults and dev mock controls
-   */
-  _buildBaseHeaders(additionalHeaders = {}, token) {
-    const headers = {
-      ...additionalHeaders,
-      "Content-Type": "application/json"
-    };
-    return headers;
-  }
-  /**
-   * Attach auth headers using the active client mode
-   */
-  _withAuthHeader(headers, token) {
-    const nextHeaders = { ...headers };
-    if (this.mode === "xcashu") {
-      nextHeaders["X-Cashu"] = token;
-    } else {
-      nextHeaders["Authorization"] = `Bearer ${token}`;
-    }
-    return nextHeaders;
-  }
-};
-
-exports.ProviderManager = ProviderManager;
-exports.RoutstrClient = RoutstrClient;
-exports.StreamProcessor = StreamProcessor;
-exports.createSSEParserTransform = createSSEParserTransform;
-exports.inspectSSEWebStream = inspectSSEWebStream;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map