@routstr/sdk 0.3.7 → 0.3.8

package/dist/client/index.js

@@ -0,0 +1,4883 @@
+'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";
+  }
+  required;
+  available;
+  maxMintBalance;
+  maxMintUrl;
+};
+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";
+  }
+  baseUrl;
+  statusCode;
+  requestId;
+};
+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";
+  }
+  originalProvider;
+  failedProviders;
+};
+
+// 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");
+  }
+  walletAdapter;
+  storageAdapter;
+  _providerRegistry;
+  balanceManager;
+  _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.logger.warn(
+              `refundProviders: ${apiKeyEntry.baseUrl} returned invalid API key; removing local key and treating as success`
+            );
+            this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
+            results.push({
+              baseUrl: apiKeyEntry.baseUrl,
+              success: true
+            });
+            continue;
+          }
+          if (balanceResult.amount >= 0) {
+            const balanceSat = balanceResult.unit === "msat" ? Math.floor(balanceResult.amount / 1e3) : balanceResult.amount;
+            this.storageAdapter.updateApiKeyBalance(
+              apiKeyEntry.baseUrl,
+              balanceSat
+            );
+          } else {
+            this.logger.warn(
+              `refundProviders: balance refresh for ${apiKeyEntry.baseUrl} returned negative amount; keeping stale local balance=${apiKeyEntryFull.balance}`
+            );
+          }
+        } catch (error) {
+          this.logger.warn(
+            `refundProviders: balance refresh threw for ${apiKeyEntry.baseUrl}; proceeding with stale local balance`,
+            error
+          );
+        }
+        const refreshedEntry = this.storageAdapter.getApiKey(
+          apiKeyEntry.baseUrl
+        );
+        if (!refreshedEntry) {
+          continue;
+        }
+        const refundResult = await this.balanceManager.refundApiKey({
+          mintUrl,
+          baseUrl: apiKeyEntry.baseUrl,
+          apiKey: refreshedEntry.key,
+          forceRefund
+        });
+        if (refundResult.success) {
+          this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
+        } else {
+          const currentEntry = this.storageAdapter.getApiKey(
+            apiKeyEntry.baseUrl
+          );
+          this.logger.warn(
+            `refundProviders: refund failed for ${apiKeyEntry.baseUrl}; currentEntry=${Boolean(currentEntry)} balance=${currentEntry?.balance ?? "none"}. Touching lastUsed to rate-limit retries.`
+          );
+          if (currentEntry) {
+            this.storageAdapter.updateApiKeyBalance(
+              apiKeyEntry.baseUrl,
+              currentEntry.balance
+            );
+          }
+        }
+        results.push({
+          baseUrl: apiKeyEntry.baseUrl,
+          success: refundResult.success
+        });
+      } else {
+        this.logger.warn(
+          `refundProviders: cannot refund ${apiKeyEntry.baseUrl}; apiKeyEntryFull=${Boolean(apiKeyEntryFull)} balanceManager=${Boolean(this.balanceManager)}`
+        );
+        results.push({
+          baseUrl: apiKeyEntry.baseUrl,
+          success: false
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * 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,
+        this.logger
+      );
+    }
+  }
+  walletAdapter;
+  storageAdapter;
+  providerRegistry;
+  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) {
+      this.logger.warn(`refundApiKey: aborting for ${baseUrl} - no API key`);
+      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(
+            `refundApiKey: skipping ${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.error === "No balance to refund") {
+        this.logger.log(`refundApiKey: provider says no balance for ${baseUrl}; removing API key`);
+        this.storageAdapter.removeApiKey(baseUrl);
+        return { success: true, message: "No balance to refund, key cleaned up" };
+      }
+      if (!fetchResult.success) {
+        this.logger.warn(
+          `refundApiKey: fetch failed for ${baseUrl}: ${fetchResult.error || "API key refund failed"}`
+        );
+        return {
+          success: false,
+          message: fetchResult.error || "API key refund failed",
+          requestId: fetchResult.requestId
+        };
+      }
+      if (!fetchResult.token) {
+        this.logger.warn(`refundApiKey: no token received for ${baseUrl}`);
+        return {
+          success: false,
+          message: "No token received from API key refund",
+          requestId: fetchResult.requestId
+        };
+      }
+      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);
+      } else {
+        this.logger.warn(
+          `refundApiKey: receive failed for ${baseUrl}; keeping API key. message=${receiveResult.message ?? "none"}`
+        );
+      }
+      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(() => ({}));
+        this.logger.warn(
+          `fetchRefundToken: non-ok response for ${url} status=${response.status} statusText=${response.statusText}`,
+          errorData
+        );
+        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();
+    }
+  }
+  providerRegistry;
+  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,
+      void 0,
+      this.logger
+    );
+    this.cashuSpender = new CashuSpender(
+      walletAdapter,
+      storageAdapter,
+      providerRegistry,
+      this.balanceManager,
+      this.logger
+    );
+    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);
+  }
+  walletAdapter;
+  storageAdapter;
+  providerRegistry;
+  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