@routstr/sdk 0.1.0 → 0.1.1

package/dist/client/index.js

@@ -0,0 +1,2534 @@
+'use strict';
+
+// core/errors.ts
+var InsufficientBalanceError = class extends Error {
+  constructor(required, available, maxMintBalance = 0, maxMintUrl = "") {
+    super(
+      `Insufficient balance: need ${required} sats, have ${available} sats available. ` + (maxMintBalance > 0 ? `Largest mint balance: ${maxMintBalance} sats from ${maxMintUrl}` : "")
+    );
+    this.required = required;
+    this.available = available;
+    this.maxMintBalance = maxMintBalance;
+    this.maxMintUrl = maxMintUrl;
+    this.name = "InsufficientBalanceError";
+  }
+};
+var ProviderError = class extends Error {
+  constructor(baseUrl, statusCode, message, requestId) {
+    super(
+      `Provider ${baseUrl} returned ${statusCode}: ${message}` + (requestId ? ` (Request ID: ${requestId})` : "")
+    );
+    this.baseUrl = baseUrl;
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    this.name = "ProviderError";
+  }
+};
+var FailoverError = class extends Error {
+  constructor(originalProvider, failedProviders, message) {
+    super(
+      message || `All providers failed. Original: ${originalProvider}, Failed: ${failedProviders.join(", ")}`
+    );
+    this.originalProvider = originalProvider;
+    this.failedProviders = failedProviders;
+    this.name = "FailoverError";
+  }
+};
+
+// wallet/AuditLogger.ts
+var AuditLogger = class _AuditLogger {
+  static instance = null;
+  static getInstance() {
+    if (!_AuditLogger.instance) {
+      _AuditLogger.instance = new _AuditLogger();
+    }
+    return _AuditLogger.instance;
+  }
+  async log(entry) {
+    const fullEntry = {
+      ...entry,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const logLine = JSON.stringify(fullEntry) + "\n";
+    if (typeof window === "undefined") {
+      try {
+        const fs = await import('fs');
+        const path = await import('path');
+        const logPath = path.join(process.cwd(), "audit.log");
+        fs.appendFileSync(logPath, logLine);
+      } catch (error) {
+        console.error("[AuditLogger] Failed to write to file:", error);
+      }
+    } else {
+      console.log("[AUDIT]", logLine.trim());
+    }
+  }
+  async logBalanceSnapshot(action, amounts, options) {
+    await this.log({
+      action,
+      totalBalance: amounts.totalBalance,
+      providerBalances: amounts.providerBalances,
+      mintBalances: amounts.mintBalances,
+      amount: options?.amount,
+      mintUrl: options?.mintUrl,
+      baseUrl: options?.baseUrl,
+      status: options?.status ?? "success",
+      details: options?.details
+    });
+  }
+};
+var auditLogger = AuditLogger.getInstance();
+
+// wallet/tokenUtils.ts
+function isNetworkErrorMessage(message) {
+  return message.includes("NetworkError when attempting to fetch resource") || message.includes("Failed to fetch") || message.includes("Load failed");
+}
+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 };
+}
+
+// wallet/CashuSpender.ts
+var CashuSpender = class {
+  constructor(walletAdapter, storageAdapter, _providerRegistry, balanceManager) {
+    this.walletAdapter = walletAdapter;
+    this.storageAdapter = storageAdapter;
+    this._providerRegistry = _providerRegistry;
+    this.balanceManager = balanceManager;
+  }
+  _isBusy = false;
+  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 pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const providerBalances = {};
+    let totalProviderBalance = 0;
+    for (const pending of pendingDistribution) {
+      providerBalances[pending.baseUrl] = pending.amount;
+      totalProviderBalance += pending.amount;
+    }
+    const apiKeys = this.storageAdapter.getAllApiKeys();
+    for (const apiKey of apiKeys) {
+      if (!providerBalances[apiKey.baseUrl]) {
+        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;
+  }
+  /**
+   * 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;
+    console.log(
+      `[CashuSpender] _spendInternal: amount=${amount}, mintUrl=${mintUrl}, baseUrl=${baseUrl}, reuseToken=${reuseToken}`
+    );
+    let adjustedAmount = Math.ceil(amount);
+    if (!adjustedAmount || isNaN(adjustedAmount)) {
+      console.error(`[CashuSpender] _spendInternal: Invalid amount: ${amount}`);
+      return {
+        token: null,
+        status: "failed",
+        balance: 0,
+        error: "Please enter a valid amount"
+      };
+    }
+    if (reuseToken && baseUrl) {
+      console.log(
+        `[CashuSpender] _spendInternal: Attempting to reuse token for ${baseUrl}`
+      );
+      const existingResult = await this._tryReuseToken(
+        baseUrl,
+        adjustedAmount,
+        mintUrl
+      );
+      if (existingResult) {
+        console.log(
+          `[CashuSpender] _spendInternal: Successfully reused token, balance: ${existingResult.balance}`
+        );
+        return existingResult;
+      }
+      console.log(
+        `[CashuSpender] _spendInternal: Could not reuse token, will create new token`
+      );
+    }
+    const balances = await this.walletAdapter.getBalances();
+    const units = this.walletAdapter.getMintUnits();
+    let totalBalance = 0;
+    for (const url in balances) {
+      const balance = balances[url];
+      const unit = units[url];
+      const balanceInSats = getBalanceInSats(balance, unit);
+      totalBalance += balanceInSats;
+    }
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const totalPending = pendingDistribution.reduce(
+      (sum, item) => sum + item.amount,
+      0
+    );
+    console.log(
+      `[CashuSpender] _spendInternal: totalBalance=${totalBalance}, totalPending=${totalPending}, adjustedAmount=${adjustedAmount}`
+    );
+    const totalAvailableBalance = totalBalance + totalPending;
+    if (totalAvailableBalance < adjustedAmount) {
+      console.error(
+        `[CashuSpender] _spendInternal: Insufficient balance, have=${totalAvailableBalance}, need=${adjustedAmount}`
+      );
+      return this._createInsufficientBalanceError(
+        adjustedAmount,
+        balances,
+        units,
+        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,
+            balances,
+            units,
+            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 && baseUrl) {
+      this.storageAdapter.setToken(baseUrl, token);
+    }
+    this._logTransaction("spend", {
+      amount: spentAmount,
+      mintUrl: selectedMintUrl || mintUrl,
+      baseUrl,
+      status: "success"
+    });
+    console.log(
+      `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`
+    );
+    return {
+      token,
+      status: "success",
+      balance: spentAmount,
+      unit: (selectedMintUrl ? units[selectedMintUrl] : units[mintUrl]) || "sat"
+    };
+  }
+  /**
+   * Try to reuse an existing token
+   */
+  async _tryReuseToken(baseUrl, amount, mintUrl) {
+    const storedToken = this.storageAdapter.getToken(baseUrl);
+    if (!storedToken) return null;
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const balanceForBaseUrl = pendingDistribution.find((b) => b.baseUrl === baseUrl)?.amount || 0;
+    console.log("RESUINGDSR GSODGNSD", balanceForBaseUrl, amount);
+    if (balanceForBaseUrl > amount) {
+      const units = this.walletAdapter.getMintUnits();
+      const unit = units[mintUrl] || "sat";
+      return {
+        token: storedToken,
+        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
+      });
+      console.log("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: storedToken,
+          status: "success",
+          balance: newBalance,
+          unit
+        };
+      }
+      const providerBalance = await this._getProviderTokenBalance(
+        baseUrl,
+        storedToken
+      );
+      console.log(providerBalance);
+      if (providerBalance <= 0) {
+        this.storageAdapter.removeToken(baseUrl);
+      }
+    }
+    return null;
+  }
+  /**
+   * Refund specific providers without retrying spend
+   */
+  async refundProviders(baseUrls, mintUrl, refundApiKeys = false) {
+    const results = [];
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const toRefund = pendingDistribution.filter(
+      (p) => baseUrls.includes(p.baseUrl)
+    );
+    const refundResults = await Promise.allSettled(
+      toRefund.map(async (pending) => {
+        const token = this.storageAdapter.getToken(pending.baseUrl);
+        console.log(token, this.balanceManager);
+        if (!token || !this.balanceManager) {
+          return { baseUrl: pending.baseUrl, success: false };
+        }
+        const tokenBalance = await this.balanceManager.getTokenBalance(
+          token,
+          pending.baseUrl
+        );
+        if (tokenBalance.reserved > 0) {
+          return { baseUrl: pending.baseUrl, success: false };
+        }
+        const result = await this.balanceManager.refund({
+          mintUrl,
+          baseUrl: pending.baseUrl,
+          token
+        });
+        console.log(result);
+        if (result.success) {
+          this.storageAdapter.removeToken(pending.baseUrl);
+        }
+        return { baseUrl: pending.baseUrl, success: result.success };
+      })
+    );
+    results.push(
+      ...refundResults.map(
+        (r) => r.status === "fulfilled" ? r.value : { baseUrl: "", success: false }
+      )
+    );
+    if (refundApiKeys) {
+      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+      const apiKeysToRefund = apiKeyDistribution.filter(
+        (p) => baseUrls.includes(p.baseUrl)
+      );
+      for (const apiKeyEntry of apiKeysToRefund) {
+        const apiKeyEntryFull = this.storageAdapter.getApiKey(
+          apiKeyEntry.baseUrl
+        );
+        if (apiKeyEntryFull && this.balanceManager) {
+          const refundResult = await this.balanceManager.refundApiKey({
+            mintUrl,
+            baseUrl: apiKeyEntry.baseUrl,
+            apiKey: apiKeyEntryFull.key
+          });
+          if (refundResult.success) {
+            this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, 0);
+          }
+          results.push({
+            baseUrl: apiKeyEntry.baseUrl,
+            success: refundResult.success
+          });
+        } else {
+          results.push({
+            baseUrl: apiKeyEntry.baseUrl,
+            success: false
+          });
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Create an insufficient balance error result
+   */
+  _createInsufficientBalanceError(required, balances, units, availableBalance) {
+    let maxBalance = 0;
+    let maxMintUrl = "";
+    for (const mintUrl in balances) {
+      const balance = balances[mintUrl];
+      const unit = units[mintUrl];
+      const balanceInSats = getBalanceInSats(balance, unit);
+      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 {
+  constructor(walletAdapter, storageAdapter, providerRegistry) {
+    this.walletAdapter = walletAdapter;
+    this.storageAdapter = storageAdapter;
+    this.providerRegistry = providerRegistry;
+  }
+  /**
+   * Unified refund - handles both NIP-60 and legacy wallet refunds
+   */
+  async refund(options) {
+    const { mintUrl, baseUrl, token: providedToken } = options;
+    const storedToken = providedToken || this.storageAdapter.getToken(baseUrl);
+    if (!storedToken) {
+      console.log("[BalanceManager] No token to refund, returning early");
+      return { success: true, message: "No API key to refund" };
+    }
+    let fetchResult;
+    try {
+      fetchResult = await this._fetchRefundToken(baseUrl, storedToken);
+      if (!fetchResult.success) {
+        return {
+          success: false,
+          message: fetchResult.error || "Refund failed",
+          requestId: fetchResult.requestId
+        };
+      }
+      if (!fetchResult.token) {
+        return {
+          success: false,
+          message: "No token received from refund",
+          requestId: fetchResult.requestId
+        };
+      }
+      if (fetchResult.error === "No balance to refund") {
+        console.log(
+          "[BalanceManager] No balance to refund, removing stored token"
+        );
+        this.storageAdapter.removeToken(baseUrl);
+        return { success: true, message: "No balance to refund" };
+      }
+      const receiveResult = await this.walletAdapter.receiveToken(
+        fetchResult.token
+      );
+      const totalAmountMsat = receiveResult.unit === "msat" ? receiveResult.amount : receiveResult.amount * 1e3;
+      if (!providedToken) {
+        this.storageAdapter.removeToken(baseUrl);
+      }
+      return {
+        success: receiveResult.success,
+        refundedAmount: totalAmountMsat,
+        requestId: fetchResult.requestId
+      };
+    } catch (error) {
+      console.error("[BalanceManager] Refund error", error);
+      return this._handleRefundError(error, mintUrl, fetchResult?.requestId);
+    }
+  }
+  /**
+   * Refund API key balance - convert remaining API key balance to cashu token
+   */
+  async refundApiKey(options) {
+    const { mintUrl, baseUrl, apiKey } = options;
+    if (!apiKey) {
+      return { success: false, message: "No API key to refund" };
+    }
+    let fetchResult;
+    try {
+      fetchResult = await this._fetchRefundTokenWithApiKey(baseUrl, apiKey);
+      if (!fetchResult.success) {
+        return {
+          success: false,
+          message: fetchResult.error || "API key refund failed",
+          requestId: fetchResult.requestId
+        };
+      }
+      if (!fetchResult.token) {
+        return {
+          success: false,
+          message: "No token received from API key refund",
+          requestId: fetchResult.requestId
+        };
+      }
+      if (fetchResult.error === "No balance to refund") {
+        return { success: false, message: "No balance to refund" };
+      }
+      const receiveResult = await this.walletAdapter.receiveToken(
+        fetchResult.token
+      );
+      const totalAmountMsat = receiveResult.unit === "msat" ? receiveResult.amount : receiveResult.amount * 1e3;
+      return {
+        success: receiveResult.success,
+        refundedAmount: totalAmountMsat,
+        requestId: fetchResult.requestId
+      };
+    } catch (error) {
+      console.error("[BalanceManager] API key refund error", error);
+      return this._handleRefundError(error, mintUrl, fetchResult?.requestId);
+    }
+  }
+  /**
+   * Fetch refund token from provider API using API key authentication
+   */
+  async _fetchRefundTokenWithApiKey(baseUrl, apiKey) {
+    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 response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "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: `API key refund failed: ${errorData?.detail || response.statusText}`
+        };
+      }
+      const data = await response.json();
+      return {
+        success: true,
+        token: data.token,
+        requestId
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      console.error(
+        "[BalanceManager._fetchRefundTokenWithApiKey] 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;
+    if (!amount || amount <= 0) {
+      return { success: false, message: "Invalid top up amount" };
+    }
+    const storedToken = providedToken || this.storageAdapter.getToken(baseUrl);
+    if (!storedToken) {
+      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,
+        storedToken,
+        cashuToken
+      );
+      requestId = topUpResult.requestId;
+      console.log(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) {
+      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);
+    if (!adjustedAmount || isNaN(adjustedAmount)) {
+      return { success: false, error: "Invalid top up amount" };
+    }
+    const balances = await this.walletAdapter.getBalances();
+    const units = this.walletAdapter.getMintUnits();
+    let totalMintBalance = 0;
+    for (const url in balances) {
+      const unit = units[url];
+      const balanceInSats = getBalanceInSats(balances[url], unit);
+      totalMintBalance += balanceInSats;
+    }
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const refundablePending = pendingDistribution.filter((entry) => entry.baseUrl !== baseUrl).reduce((sum, entry) => sum + entry.amount, 0);
+    if (totalMintBalance < adjustedAmount && totalMintBalance + refundablePending >= adjustedAmount && retryCount < 1) {
+      await this._refundOtherProvidersForTopUp(baseUrl, mintUrl);
+      return this.createProviderToken({
+        ...options,
+        retryCount: retryCount + 1
+      });
+    }
+    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;
+        }
+      }
+      const error = new InsufficientBalanceError(
+        adjustedAmount,
+        totalMintBalance,
+        maxBalance,
+        maxMintUrl
+      );
+      return { success: false, error: error.message };
+    }
+    let lastError;
+    for (const candidateMint of candidates) {
+      try {
+        const token = await this.walletAdapter.sendToken(
+          candidateMint,
+          requiredAmount,
+          p2pkPubkey
+        );
+        return {
+          success: true,
+          token,
+          selectedMintUrl: candidateMint,
+          amountSpent: requiredAmount
+        };
+      } catch (error) {
+        if (error instanceof Error) {
+          lastError = error.message;
+          if (isNetworkErrorMessage(error.message)) {
+            continue;
+          }
+        }
+        return {
+          success: false,
+          error: lastError || "Failed to create top up token"
+        };
+      }
+    }
+    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) {
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const toRefund = pendingDistribution.filter(
+      (pending) => pending.baseUrl !== baseUrl
+    );
+    const refundResults = await Promise.allSettled(
+      toRefund.map(async (pending) => {
+        const token = this.storageAdapter.getToken(pending.baseUrl);
+        if (!token) {
+          return { baseUrl: pending.baseUrl, success: false };
+        }
+        const tokenBalance = await this.getTokenBalance(token, pending.baseUrl);
+        if (tokenBalance.reserved > 0) {
+          return { baseUrl: pending.baseUrl, success: false };
+        }
+        const result = await this.refund({
+          mintUrl,
+          baseUrl: pending.baseUrl,
+          token
+        });
+        return { baseUrl: pending.baseUrl, success: result.success };
+      })
+    );
+    for (const result of refundResults) {
+      if (result.status === "fulfilled" && result.value.success) {
+        this.storageAdapter.removeToken(result.value.baseUrl);
+      }
+    }
+  }
+  /**
+   * Fetch refund token from provider API
+   */
+  async _fetchRefundToken(baseUrl, storedToken) {
+    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 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(() => ({}));
+        if (response.status === 400 && errorData?.detail === "No balance to refund") {
+          this.storageAdapter.removeToken(baseUrl);
+          return {
+            success: false,
+            requestId,
+            error: "No balance to refund"
+          };
+        }
+        return {
+          success: false,
+          requestId,
+          error: `Refund request failed with status ${response.status}: ${errorData?.detail || response.statusText}`
+        };
+      }
+      const data = await response.json();
+      console.log("refund rsule", data);
+      return {
+        success: true,
+        token: data.token,
+        requestId
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      console.error("[BalanceManager._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 refund request"
+      };
+    }
+  }
+  /**
+   * 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);
+      console.error("[BalanceManager._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.walletAdapter.receiveToken(cashuToken);
+    } catch (error) {
+      console.error(
+        "[BalanceManager._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();
+        console.log("TOKENA FASJDFAS", data);
+        return {
+          amount: data.balance,
+          reserved: data.reserved ?? 0,
+          unit: "msat",
+          apiKey: data.api_key
+        };
+      } else {
+        console.log(response.status);
+        const data = await response.json();
+        console.log("FAILED ", data);
+      }
+    } catch (error) {
+      console.error("ERRORR IN RESTPONSE", 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/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;
+    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.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,
+      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;
+      }
+      if (parsed.usage) {
+        result.usage = {
+          total_tokens: parsed.usage.total_tokens,
+          prompt_tokens: parsed.usage.prompt_tokens,
+          completion_tokens: parsed.usage.completion_tokens
+        };
+      }
+      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 {
+  constructor(providerRegistry) {
+    this.providerRegistry = providerRegistry;
+  }
+  failedProviders = /* @__PURE__ */ new Set();
+  /**
+   * Reset the failed providers list
+   */
+  resetFailedProviders() {
+    this.failedProviders.clear();
+  }
+  /**
+   * Mark a provider as failed
+   */
+  markFailed(baseUrl) {
+    this.failedProviders.add(baseUrl);
+  }
+  /**
+   * Check if a provider has failed
+   */
+  hasFailed(baseUrl) {
+    return this.failedProviders.has(baseUrl);
+  }
+  /**
+   * 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()
+      );
+      const allProviders = this.providerRegistry.getAllProvidersModels();
+      const candidates = [];
+      for (const [baseUrl, models] of Object.entries(allProviders)) {
+        if (baseUrl === currentBaseUrl || this.failedProviders.has(baseUrl) || disabledProviders.has(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);
+      return candidates.length > 0 ? candidates[0].baseUrl : null;
+    } catch (error) {
+      console.error("Error finding next best provider:", 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 (!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 normalizedId = this.normalizeModelId(modelId);
+    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 (torMode && !baseUrl.includes(".onion")) continue;
+      if (!torMode && (baseUrl.includes(".onion") || isInsecureHttpUrl(baseUrl)))
+        continue;
+      const match = models.find(
+        (model) => this.normalizeModelId(model.id) === normalizedId
+      );
+      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;
+                  console.log("IMAGE INPUT RESOLUTION", {
+                    width: res.width,
+                    height: res.height,
+                    tokensFromImage
+                  });
+                } else {
+                  console.log(
+                    "IMAGE INPUT RESOLUTION",
+                    "unknown (unsupported format or parse failure)"
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+      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) {
+      console.error(e);
+      return 0;
+    }
+  }
+};
+
+// client/RoutstrClient.ts
+var TOPUP_MARGIN = 0.7;
+var RoutstrClient = class {
+  constructor(walletAdapter, storageAdapter, providerRegistry, alertLevel, mode = "xcashu") {
+    this.walletAdapter = walletAdapter;
+    this.storageAdapter = storageAdapter;
+    this.providerRegistry = providerRegistry;
+    this.balanceManager = new BalanceManager(
+      walletAdapter,
+      storageAdapter,
+      providerRegistry
+    );
+    this.cashuSpender = new CashuSpender(
+      walletAdapter,
+      storageAdapter,
+      providerRegistry,
+      this.balanceManager
+    );
+    this.streamProcessor = new StreamProcessor();
+    this.providerManager = new ProviderManager(providerRegistry);
+    this.alertLevel = alertLevel;
+    this.mode = mode;
+  }
+  cashuSpender;
+  balanceManager;
+  streamProcessor;
+  providerManager;
+  alertLevel;
+  mode;
+  /**
+   * Get the current client mode
+   */
+  getMode() {
+    return this.mode;
+  }
+  /**
+   * 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 {
+      path,
+      method,
+      body,
+      headers = {},
+      baseUrl,
+      mintUrl,
+      modelId
+    } = params;
+    await this._checkBalance();
+    let requiredSats = 1;
+    let selectedModel;
+    if (modelId) {
+      const providerModel = await this.providerManager.getModelForProvider(
+        baseUrl,
+        modelId
+      );
+      selectedModel = providerModel ?? void 0;
+      if (selectedModel) {
+        requiredSats = this.providerManager.getRequiredSatsForModel(
+          selectedModel,
+          []
+        );
+      }
+    }
+    const { token, tokenBalance, tokenBalanceUnit } = await this._spendToken({
+      mintUrl,
+      amount: requiredSats,
+      baseUrl
+    });
+    console.log(token, baseUrl);
+    let requestBody = body;
+    if (body && typeof body === "object") {
+      const bodyObj = body;
+      if (!bodyObj.stream) {
+        requestBody = { ...bodyObj, stream: false };
+      }
+    }
+    const baseHeaders = this._buildBaseHeaders(headers);
+    const requestHeaders = this._withAuthHeader(baseHeaders, token);
+    const response = await this._makeRequest({
+      path,
+      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;
+    await this._handlePostResponseBalanceUpdate({
+      token,
+      baseUrl: baseUrlUsed,
+      initialTokenBalance: tokenBalanceInSats,
+      response
+    });
+    return response;
+  }
+  /**
+   * 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);
+      this.providerManager.resetFailedProviders();
+      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,
+          initialTokenBalance: tokenBalanceInSats,
+          fallbackSatsSpent: isApikeysEstimate ? this._getEstimatedCosts(selectedModel, streamingResult) : void 0,
+          response
+        });
+        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") console.log("HEADERS,", headers);
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body === void 0 || method === "GET" ? void 0 : JSON.stringify(body)
+      });
+      if (this.mode === "xcashu") console.log("response,", response);
+      response.baseUrl = baseUrl;
+      if (!response.ok) {
+        const requestId = response.headers.get("x-routstr-request-id") || void 0;
+        return await this._handleErrorResponse(
+          params,
+          token,
+          response.status,
+          requestId,
+          this.mode === "xcashu" ? response.headers.get("x-cashu") ?? void 0 : void 0
+        );
+      }
+      return response;
+    } catch (error) {
+      if (this._isNetworkError(error?.message || "")) {
+        return await this._handleErrorResponse(
+          params,
+          token,
+          -1
+          // just for Network Error to skip all statuses
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Handle error responses with failover
+   */
+  async _handleErrorResponse(params, token, status, requestId, xCashuRefundToken) {
+    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
+    let tryNextProvider = false;
+    console.log(
+      `[RoutstrClient] _handleErrorResponse: status=${status}, baseUrl=${baseUrl}, mode=${this.mode}, token preview=${token}, requestId=${requestId}`
+    );
+    console.log(
+      `[RoutstrClient] _handleErrorResponse: Attempting to receive/restore token for ${baseUrl}`
+    );
+    if (params.token.startsWith("cashu")) {
+      const tryReceiveTokenResult = await this.walletAdapter.receiveToken(
+        params.token
+      );
+      if (tryReceiveTokenResult.success) {
+        console.log(
+          `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
+        );
+        tryNextProvider = true;
+        if (this.mode === "lazyrefund")
+          this.storageAdapter.removeToken(baseUrl);
+      } else {
+        console.log(
+          `[RoutstrClient] _handleErrorResponse: Token restore failed or not needed`
+        );
+      }
+    }
+    if (this.mode === "xcashu") {
+      if (xCashuRefundToken) {
+        console.log(
+          `[RoutstrClient] _handleErrorResponse: Attempting to receive xcashu refund token, preview=${xCashuRefundToken.substring(0, 20)}...`
+        );
+        try {
+          const receiveResult = await this.walletAdapter.receiveToken(xCashuRefundToken);
+          if (receiveResult.success) {
+            console.log(
+              `[RoutstrClient] _handleErrorResponse: xcashu refund received, amount=${receiveResult.amount}`
+            );
+            tryNextProvider = true;
+          } else
+            throw new ProviderError(
+              baseUrl,
+              status,
+              "xcashu refund failed",
+              requestId
+            );
+        } catch (error) {
+          console.error("[xcashu] Failed to receive refund token:", error);
+          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.mode === "lazyrefund")) {
+      const topupResult = await this.balanceManager.topUp({
+        mintUrl,
+        baseUrl,
+        amount: params.requiredSats * TOPUP_MARGIN,
+        token: params.token
+      });
+      console.log(
+        `[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;
+          console.log(
+            `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
+          );
+          throw new InsufficientBalanceError(required, available);
+        } else {
+          console.log(
+            `[RoutstrClient] _handleErrorResponse: Topup failed with non-insufficient-balance error, will try next provider`
+          );
+          tryNextProvider = true;
+        }
+      } else {
+        console.log(
+          `[RoutstrClient] _handleErrorResponse: Topup successful, will retry with new token`
+        );
+      }
+      if (!tryNextProvider)
+        return this._makeRequest({
+          ...params,
+          token: params.token,
+          headers: this._withAuthHeader(params.baseHeaders, params.token)
+        });
+    }
+    if ((status === 401 || status === 403 || status === 413 || status === 400 || status === 500 || status === 502 || status === 503 || status === 521) && !tryNextProvider) {
+      console.log(
+        `[RoutstrClient] _handleErrorResponse: Status ${status} (auth/server error), attempting refund for ${baseUrl}, mode=${this.mode}`
+      );
+      if (this.mode === "lazyrefund") {
+        try {
+          const refundResult = await this.balanceManager.refund({
+            mintUrl,
+            baseUrl,
+            token: params.token
+          });
+          console.log(
+            `[RoutstrClient] _handleErrorResponse: Lazyrefund result: success=${refundResult.success}`
+          );
+          if (refundResult.success) this.storageAdapter.removeToken(baseUrl);
+          else
+            throw new ProviderError(
+              baseUrl,
+              status,
+              "refund failed",
+              requestId
+            );
+        } catch (error) {
+          throw new ProviderError(
+            baseUrl,
+            status,
+            "Failed to refund token",
+            requestId
+          );
+        }
+      } else if (this.mode === "apikeys") {
+        console.log(
+          `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`
+        );
+        const initialBalance = await this.balanceManager.getTokenBalance(
+          token,
+          baseUrl
+        );
+        console.log(
+          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${initialBalance.amount}`
+        );
+        const refundResult = await this.balanceManager.refundApiKey({
+          mintUrl,
+          baseUrl,
+          apiKey: token
+        });
+        console.log(
+          `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
+        );
+        if (!refundResult.success && initialBalance.amount > 0) {
+          throw new ProviderError(
+            baseUrl,
+            status,
+            refundResult.message ?? "Unknown error"
+          );
+        } else {
+          this.storageAdapter.removeApiKey(baseUrl);
+        }
+      }
+    }
+    this.providerManager.markFailed(baseUrl);
+    console.log(
+      `[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) {
+      console.log(
+        `[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
+      );
+      console.log(
+        `[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)
+      });
+    }
+    throw new FailoverError(baseUrl, Array.from(this.providerManager));
+  }
+  /**
+   * Handle post-response balance update for all modes
+   */
+  async _handlePostResponseBalanceUpdate(params) {
+    const { token, baseUrl, initialTokenBalance, fallbackSatsSpent, response } = params;
+    let satsSpent = initialTokenBalance;
+    if (this.mode === "xcashu" && response) {
+      const refundToken = response.headers.get("x-cashu") ?? void 0;
+      if (refundToken) {
+        try {
+          const receiveResult = await this.walletAdapter.receiveToken(refundToken);
+          satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
+        } catch (error) {
+          console.error("[xcashu] Failed to receive refund token:", error);
+        }
+      }
+    } else if (this.mode === "lazyrefund") {
+      const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+        token,
+        baseUrl
+      );
+      const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+      this.storageAdapter.updateTokenBalance(baseUrl, latestTokenBalance);
+      satsSpent = initialTokenBalance - latestTokenBalance;
+    } else if (this.mode === "apikeys") {
+      try {
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+          token,
+          baseUrl
+        );
+        console.log(
+          "LATEST Balance",
+          latestBalanceInfo.amount,
+          latestBalanceInfo.reserved,
+          latestBalanceInfo.apiKey,
+          baseUrl
+        );
+        const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+        this.storageAdapter.updateChildKeyBalance(baseUrl, latestTokenBalance);
+        this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
+        satsSpent = initialTokenBalance - latestTokenBalance;
+      } catch (e) {
+        console.warn("Could not get updated API key balance:", e);
+        satsSpent = fallbackSatsSpent ?? initialTokenBalance;
+      }
+    }
+    return satsSpent;
+  }
+  /**
+   * 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 || ""
+    };
+  }
+  /**
+   * Create a child key for a parent API key via the provider's API
+   * POST /v1/balance/child-key
+   */
+  async _createChildKey(baseUrl, parentApiKey, options) {
+    const response = await fetch(`${baseUrl}v1/balance/child-key`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${parentApiKey}`
+      },
+      body: JSON.stringify({
+        count: options?.count ?? 1,
+        balance_limit: options?.balanceLimit,
+        balance_limit_reset: options?.balanceLimitReset,
+        validity_date: options?.validityDate
+      })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to create child key: ${response.status} ${await response.text()}`
+      );
+    }
+    const data = await response.json();
+    return {
+      childKey: data.api_keys?.[0],
+      balance: data.balance ?? 0,
+      balanceLimit: data.balance_limit,
+      validityDate: data.validity_date
+    };
+  }
+  /**
+   * 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 cashu token amount
+   */
+  _getPendingCashuTokenAmount() {
+    const distribution = this.storageAdapter.getCachedTokenDistribution();
+    return distribution.reduce((total, item) => total + item.amount, 0);
+  }
+  /**
+   * Check if error message indicates a network error
+   */
+  _isNetworkError(message) {
+    return message.includes("NetworkError when attempting to fetch resource") || message.includes("Failed to fetch") || message.includes("Load failed");
+  }
+  /**
+   * Handle errors and notify callbacks
+   */
+  _handleError(error, callbacks) {
+    console.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;
+      console.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;
+    console.log(
+      `[RoutstrClient] _spendToken: mode=${this.mode}, amount=${amount}, baseUrl=${baseUrl}, mintUrl=${mintUrl}`
+    );
+    if (this.mode === "apikeys") {
+      let parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+      if (!parentApiKey) {
+        console.log(
+          `[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) {
+          console.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 {
+          console.log(
+            `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult2.token}`
+          );
+        }
+        console.log(
+          `[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 tryReceiveTokenResult = await this.walletAdapter.receiveToken(
+              spendResult2.token
+            );
+            if (tryReceiveTokenResult.success) {
+              console.log(
+                `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
+              );
+            } else {
+              console.log(
+                `[RoutstrClient] _handleErrorResponse: Token restore failed or not needed`
+              );
+            }
+            console.log(
+              `[RoutstrClient] _spendToken: API key already exists for ${baseUrl}, using existing key`
+            );
+          } else {
+            throw error;
+          }
+        }
+        parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+      } else {
+        console.log(
+          `[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) {
+          console.warn("Could not get initial API key balance:", e);
+        }
+      }
+      console.log(
+        `[RoutstrClient] _spendToken: Returning token with balance=${tokenBalance} ${tokenBalanceUnit}`
+      );
+      return {
+        token: parentApiKey?.key ?? "",
+        tokenBalance,
+        tokenBalanceUnit
+      };
+    }
+    console.log(
+      `[RoutstrClient] _spendToken: Calling CashuSpender.spend for amount=${amount}, mintUrl=${mintUrl}, mode=${this.mode}`
+    );
+    const spendResult = await this.cashuSpender.spend({
+      mintUrl,
+      amount,
+      baseUrl: this.mode === "lazyrefund" ? baseUrl : "",
+      reuseToken: this.mode === "lazyrefund"
+    });
+    if (!spendResult.token) {
+      console.error(
+        `[RoutstrClient] _spendToken: CashuSpender.spend failed, error:`,
+        spendResult.error
+      );
+    } else {
+      console.log(
+        `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult.token}, balance: ${spendResult.balance} ${spendResult.unit ?? "sat"}`
+      );
+    }
+    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;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map