@routstr/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3572 @@
+'use strict';
+
+var vanilla = require('zustand/vanilla');
+var cashuTs = require('@cashu/cashu-ts');
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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 MintUnreachableError = class extends Error {
+  constructor(mintUrl) {
+    super(
+      `Your mint ${mintUrl} is unreachable or is blocking your IP. Please try again later or switch mints.`
+    );
+    this.mintUrl = mintUrl;
+    this.name = "MintUnreachableError";
+  }
+};
+var TokenOperationError = class extends Error {
+  constructor(message, operation, mintUrl) {
+    super(message);
+    this.operation = operation;
+    this.mintUrl = mintUrl;
+    this.name = "TokenOperationError";
+  }
+};
+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";
+  }
+};
+var StreamingError = class extends Error {
+  constructor(message, finishReason, accumulatedContent) {
+    super(message);
+    this.finishReason = finishReason;
+    this.accumulatedContent = accumulatedContent;
+    this.name = "StreamingError";
+  }
+};
+var ModelNotFoundError = class extends Error {
+  constructor(modelId, baseUrl) {
+    super(`Model '${modelId}' not found on provider ${baseUrl}`);
+    this.modelId = modelId;
+    this.baseUrl = baseUrl;
+    this.name = "ModelNotFoundError";
+  }
+};
+var ProviderBootstrapError = class extends Error {
+  constructor(failedProviders, message) {
+    super(
+      message || `Failed to bootstrap providers. Tried: ${failedProviders.join(", ")}`
+    );
+    this.failedProviders = failedProviders;
+    this.name = "ProviderBootstrapError";
+  }
+};
+var NoProvidersAvailableError = class extends Error {
+  constructor() {
+    super("No providers are available for model discovery");
+    this.name = "NoProvidersAvailableError";
+  }
+};
+var MintDiscoveryError = class extends Error {
+  constructor(baseUrl, message) {
+    super(message || `Failed to discover mints from provider ${baseUrl}`);
+    this.baseUrl = baseUrl;
+    this.name = "MintDiscoveryError";
+  }
+};
+
+// discovery/ModelManager.ts
+var ModelManager = class _ModelManager {
+  constructor(adapter, config = {}) {
+    this.adapter = adapter;
+    this.providerDirectoryUrl = config.providerDirectoryUrl || "https://api.routstr.com/v1/providers/";
+    this.cacheTTL = config.cacheTTL || 21 * 60 * 1e3;
+    this.includeProviderUrls = config.includeProviderUrls || [];
+    this.excludeProviderUrls = config.excludeProviderUrls || [];
+  }
+  cacheTTL;
+  providerDirectoryUrl;
+  includeProviderUrls;
+  excludeProviderUrls;
+  /**
+   * Get the list of bootstrapped provider base URLs
+   * @returns Array of provider base URLs
+   */
+  getBaseUrls() {
+    return this.adapter.getBaseUrlsList();
+  }
+  static async init(adapter, config = {}, options = {}) {
+    const manager = new _ModelManager(adapter, config);
+    const torMode = options.torMode ?? false;
+    const forceRefresh = options.forceRefresh ?? false;
+    const providers = await manager.bootstrapProviders(torMode);
+    await manager.fetchModels(providers, forceRefresh);
+    return manager;
+  }
+  /**
+   * Bootstrap provider list from the provider directory
+   * Fetches available providers and caches their base URLs
+   * @param torMode Whether running in Tor context
+   * @returns Array of provider base URLs
+   * @throws ProviderBootstrapError if all providers fail to fetch
+   */
+  async bootstrapProviders(torMode = false) {
+    try {
+      const cachedUrls = this.adapter.getBaseUrlsList();
+      if (cachedUrls.length > 0) {
+        const lastUpdate = this.adapter.getBaseUrlsLastUpdate();
+        const cacheValid = lastUpdate && Date.now() - lastUpdate <= this.cacheTTL;
+        if (cacheValid) {
+          return this.filterBaseUrlsForTor(cachedUrls, torMode);
+        }
+      }
+      const res = await fetch(this.providerDirectoryUrl);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch providers: ${res.status}`);
+      }
+      const data = await res.json();
+      const providers = Array.isArray(data?.providers) ? data.providers : [];
+      const bases = /* @__PURE__ */ new Set();
+      for (const p of providers) {
+        const endpoints = this.getProviderEndpoints(p, torMode);
+        for (const endpoint of endpoints) {
+          bases.add(endpoint);
+        }
+      }
+      for (const url of this.includeProviderUrls) {
+        const normalized = this.normalizeUrl(url);
+        if (!torMode || normalized.includes(".onion")) {
+          bases.add(normalized);
+        }
+      }
+      const excluded = new Set(
+        this.excludeProviderUrls.map((url) => this.normalizeUrl(url))
+      );
+      const list = Array.from(bases).filter((base) => {
+        if (excluded.has(base)) return false;
+        return true;
+      });
+      if (list.length > 0) {
+        this.adapter.setBaseUrlsList(list);
+        this.adapter.setBaseUrlsLastUpdate(Date.now());
+      }
+      return list;
+    } catch (e) {
+      console.error("Failed to bootstrap providers", e);
+      throw new ProviderBootstrapError([], `Provider bootstrap failed: ${e}`);
+    }
+  }
+  /**
+   * Fetch models from all providers and select best-priced options
+   * Uses cache if available and not expired
+   * @param baseUrls List of provider base URLs to fetch from
+   * @param forceRefresh Ignore cache and fetch fresh data
+   * @returns Array of unique models with best prices selected
+   */
+  async fetchModels(baseUrls, forceRefresh = false) {
+    if (baseUrls.length === 0) {
+      throw new NoProvidersAvailableError();
+    }
+    const bestById = /* @__PURE__ */ new Map();
+    const modelsFromAllProviders = {};
+    const disabledProviders = this.adapter.getDisabledProviders();
+    const estimateMinCost = (m) => {
+      return m?.sats_pricing?.completion ?? 0;
+    };
+    const fetchPromises = baseUrls.map(async (url) => {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      try {
+        let list;
+        if (!forceRefresh) {
+          const lastUpdate = this.adapter.getProviderLastUpdate(base);
+          const cacheValid = lastUpdate && Date.now() - lastUpdate <= this.cacheTTL;
+          if (cacheValid) {
+            const cachedModels = this.adapter.getCachedModels();
+            const cachedList = cachedModels[base] || [];
+            list = cachedList;
+          } else {
+            list = await this.fetchModelsFromProvider(base);
+          }
+        } else {
+          list = await this.fetchModelsFromProvider(base);
+        }
+        modelsFromAllProviders[base] = list;
+        this.adapter.setProviderLastUpdate(base, Date.now());
+        if (!disabledProviders.includes(base)) {
+          for (const m of list) {
+            const existing = bestById.get(m.id);
+            if (!m.sats_pricing) continue;
+            if (!existing) {
+              bestById.set(m.id, { model: m, base });
+              continue;
+            }
+            const currentCost = estimateMinCost(m);
+            const existingCost = estimateMinCost(existing.model);
+            if (currentCost < existingCost && m.sats_pricing) {
+              bestById.set(m.id, { model: m, base });
+            }
+          }
+        }
+        return { success: true, base, list };
+      } catch (error) {
+        if (this.isProviderDownError(error)) {
+          console.warn(`Provider ${base} is down right now.`);
+        } else {
+          console.warn(`Failed to fetch models from ${base}:`, error);
+        }
+        this.adapter.setProviderLastUpdate(base, Date.now());
+        return { success: false, base };
+      }
+    });
+    await Promise.allSettled(fetchPromises);
+    const existingCache = this.adapter.getCachedModels();
+    this.adapter.setCachedModels({
+      ...existingCache,
+      ...modelsFromAllProviders
+    });
+    return Array.from(bestById.values()).map((v) => v.model);
+  }
+  /**
+   * Fetch models from a single provider
+   * @param baseUrl Provider base URL
+   * @returns Array of models from provider
+   */
+  async fetchModelsFromProvider(baseUrl) {
+    const res = await fetch(`${baseUrl}v1/models`);
+    if (!res.ok) {
+      throw new Error(`Failed to fetch models: ${res.status}`);
+    }
+    const json = await res.json();
+    const list = Array.isArray(json?.data) ? json.data.map((m) => ({
+      ...m,
+      id: m.id.split("/").pop() || m.id
+    })) : [];
+    return list;
+  }
+  isProviderDownError(error) {
+    if (!(error instanceof Error)) return false;
+    const msg = error.message.toLowerCase();
+    if (msg.includes("fetch failed")) return true;
+    if (msg.includes("502")) return true;
+    if (msg.includes("503")) return true;
+    if (msg.includes("504")) return true;
+    const cause = error.cause;
+    return cause?.code === "ENOTFOUND";
+  }
+  /**
+   * Get all cached models from all providers
+   * @returns Record mapping baseUrl -> models
+   */
+  getAllCachedModels() {
+    return this.adapter.getCachedModels();
+  }
+  /**
+   * Clear cache for a specific provider
+   * @param baseUrl Provider base URL
+   */
+  clearProviderCache(baseUrl) {
+    const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const cached = this.adapter.getCachedModels();
+    delete cached[base];
+    this.adapter.setCachedModels(cached);
+    this.adapter.setProviderLastUpdate(base, 0);
+  }
+  /**
+   * Clear all model caches
+   */
+  clearAllCache() {
+    this.adapter.setCachedModels({});
+  }
+  /**
+   * Filter base URLs based on Tor context
+   * @param baseUrls Provider URLs to filter
+   * @param torMode Whether in Tor context
+   * @returns Filtered URLs appropriate for Tor mode
+   */
+  filterBaseUrlsForTor(baseUrls, torMode) {
+    if (!torMode) {
+      return baseUrls.filter((url) => !url.includes(".onion"));
+    }
+    return baseUrls.filter((url) => url.includes(".onion"));
+  }
+  /**
+   * Get provider endpoints from provider info
+   * @param provider Provider object from directory
+   * @param torMode Whether in Tor context
+   * @returns Array of endpoint URLs
+   */
+  getProviderEndpoints(provider, torMode) {
+    const endpoints = [];
+    if (torMode && provider.onion_url) {
+      endpoints.push(this.normalizeUrl(provider.onion_url));
+    } else if (provider.endpoint_url) {
+      endpoints.push(this.normalizeUrl(provider.endpoint_url));
+    }
+    return endpoints;
+  }
+  /**
+   * Normalize provider URL with trailing slash
+   * @param url URL to normalize
+   * @returns Normalized URL
+   */
+  normalizeUrl(url) {
+    if (!url.startsWith("http")) {
+      url = `https://${url}`;
+    }
+    return url.endsWith("/") ? url : `${url}/`;
+  }
+};
+
+// discovery/MintDiscovery.ts
+var MintDiscovery = class {
+  constructor(adapter, config = {}) {
+    this.adapter = adapter;
+    this.cacheTTL = config.cacheTTL || 21 * 60 * 1e3;
+  }
+  cacheTTL;
+  /**
+   * Fetch mints from all providers via their /v1/info endpoints
+   * Caches mints and full provider info for later access
+   * @param baseUrls List of provider base URLs to fetch from
+   * @returns Object with mints and provider info from all providers
+   */
+  async discoverMints(baseUrls, options = {}) {
+    if (baseUrls.length === 0) {
+      return { mintsFromProviders: {}, infoFromProviders: {} };
+    }
+    const mintsFromAllProviders = {};
+    const infoFromAllProviders = {};
+    const forceRefresh = options.forceRefresh ?? false;
+    const fetchPromises = baseUrls.map(async (url) => {
+      const base = url.endsWith("/") ? url : `${url}/`;
+      try {
+        if (!forceRefresh) {
+          const lastUpdate = this.adapter.getProviderLastUpdate(base);
+          const cacheValid = lastUpdate && Date.now() - lastUpdate <= this.cacheTTL;
+          if (cacheValid) {
+            const cachedMints = this.adapter.getCachedMints()[base] || [];
+            const cachedInfo = this.adapter.getCachedProviderInfo()[base];
+            mintsFromAllProviders[base] = cachedMints;
+            if (cachedInfo) {
+              infoFromAllProviders[base] = cachedInfo;
+            }
+            return {
+              success: true,
+              base,
+              mints: cachedMints,
+              info: cachedInfo
+            };
+          }
+        }
+        const res = await fetch(`${base}v1/info`);
+        if (!res.ok) {
+          throw new Error(`Failed to fetch info: ${res.status}`);
+        }
+        const json = await res.json();
+        const mints = Array.isArray(json?.mints) ? json.mints : [];
+        const normalizedMints = mints.map(
+          (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
+        );
+        mintsFromAllProviders[base] = normalizedMints;
+        infoFromAllProviders[base] = json;
+        this.adapter.setProviderLastUpdate(base, Date.now());
+        return { success: true, base, mints: normalizedMints, info: json };
+      } catch (error) {
+        this.adapter.setProviderLastUpdate(base, Date.now());
+        if (this.isProviderDownError(error)) {
+          console.warn(`Provider ${base} is down right now.`);
+        } else {
+          console.warn(`Failed to fetch mints from ${base}:`, error);
+        }
+        return { success: false, base, mints: [], info: null };
+      }
+    });
+    const results = await Promise.allSettled(fetchPromises);
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        const { base, mints, info } = result.value;
+        mintsFromAllProviders[base] = mints;
+        if (info) {
+          infoFromAllProviders[base] = info;
+        }
+      } else {
+        console.error("Mint discovery error:", result.reason);
+      }
+    }
+    try {
+      this.adapter.setCachedMints(mintsFromAllProviders);
+      this.adapter.setCachedProviderInfo(infoFromAllProviders);
+    } catch (error) {
+      console.error("Error caching mint discovery results:", error);
+    }
+    return {
+      mintsFromProviders: mintsFromAllProviders,
+      infoFromProviders: infoFromAllProviders
+    };
+  }
+  /**
+   * Get cached mints from all providers
+   * @returns Record mapping baseUrl -> mint URLs
+   */
+  getCachedMints() {
+    return this.adapter.getCachedMints();
+  }
+  /**
+   * Get cached provider info from all providers
+   * @returns Record mapping baseUrl -> provider info
+   */
+  getCachedProviderInfo() {
+    return this.adapter.getCachedProviderInfo();
+  }
+  /**
+   * Get mints for a specific provider
+   * @param baseUrl Provider base URL
+   * @returns Array of mint URLs for the provider
+   */
+  getProviderMints(baseUrl) {
+    const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const allMints = this.getCachedMints();
+    return allMints[normalized] || [];
+  }
+  /**
+   * Get info for a specific provider
+   * @param baseUrl Provider base URL
+   * @returns Provider info object or null if not found
+   */
+  getProviderInfo(baseUrl) {
+    const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const allInfo = this.getCachedProviderInfo();
+    return allInfo[normalized] || null;
+  }
+  /**
+   * Clear mint cache for a specific provider
+   * @param baseUrl Provider base URL
+   */
+  clearProviderMintCache(baseUrl) {
+    const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const mints = this.getCachedMints();
+    delete mints[normalized];
+    this.adapter.setCachedMints(mints);
+    const info = this.getCachedProviderInfo();
+    delete info[normalized];
+    this.adapter.setCachedProviderInfo(info);
+  }
+  /**
+   * Clear all mint caches
+   */
+  clearAllCache() {
+    this.adapter.setCachedMints({});
+    this.adapter.setCachedProviderInfo({});
+  }
+  isProviderDownError(error) {
+    if (!(error instanceof Error)) return false;
+    const msg = error.message.toLowerCase();
+    if (msg.includes("fetch failed")) return true;
+    if (msg.includes("502")) return true;
+    if (msg.includes("503")) return true;
+    if (msg.includes("504")) return true;
+    const cause = error.cause;
+    if (cause?.code === "ENOTFOUND") return true;
+    return false;
+  }
+};
+
+// 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/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 = unit === "msat" ? balance / 1e3 : balance;
+      normalizedMintBalances[url] = balanceInSats;
+      totalMintBalance += balanceInSats;
+    }
+    const pendingDistribution = this.storageAdapter.getPendingTokenDistribution();
+    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
+   */
+  async spend(options) {
+    const {
+      mintUrl,
+      amount,
+      baseUrl,
+      reuseToken = false,
+      p2pkPubkey,
+      excludeMints = [],
+      retryCount = 0
+    } = options;
+    this._isBusy = true;
+    try {
+      return await this._spendInternal({
+        mintUrl,
+        amount,
+        baseUrl,
+        reuseToken,
+        p2pkPubkey,
+        excludeMints,
+        retryCount
+      });
+    } finally {
+      this._isBusy = false;
+    }
+  }
+  /**
+   * Internal spending logic
+   */
+  async _spendInternal(options) {
+    let {
+      mintUrl,
+      amount,
+      baseUrl,
+      reuseToken,
+      p2pkPubkey,
+      excludeMints,
+      retryCount
+    } = options;
+    let adjustedAmount = Math.ceil(amount);
+    if (!adjustedAmount || isNaN(adjustedAmount)) {
+      return {
+        token: null,
+        status: "failed",
+        balance: 0,
+        error: "Please enter a valid amount"
+      };
+    }
+    if (reuseToken && baseUrl) {
+      const existingResult = await this._tryReuseToken(
+        baseUrl,
+        adjustedAmount,
+        mintUrl
+      );
+      if (existingResult) {
+        return existingResult;
+      }
+    }
+    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 = unit === "msat" ? balance / 1e3 : balance;
+      totalBalance += balanceInSats;
+    }
+    const pendingDistribution = this.storageAdapter.getPendingTokenDistribution();
+    const totalPending = pendingDistribution.reduce(
+      (sum, item) => sum + item.amount,
+      0
+    );
+    if (totalBalance < adjustedAmount && totalPending + totalBalance > adjustedAmount && (retryCount ?? 0) < 1) {
+      return await this._refundAndRetry(options);
+    }
+    const totalAvailableBalance = totalBalance + totalPending;
+    if (totalAvailableBalance < adjustedAmount) {
+      return this._createInsufficientBalanceError(
+        adjustedAmount,
+        balances,
+        units,
+        totalAvailableBalance
+      );
+    }
+    let { selectedMintUrl, selectedMintBalance } = this._selectMintWithBalance(
+      balances,
+      units,
+      adjustedAmount,
+      excludeMints
+    );
+    if (selectedMintUrl && baseUrl && this.providerRegistry) {
+      const providerMints = this.providerRegistry.getProviderMints(baseUrl);
+      if (providerMints.length > 0 && !providerMints.includes(selectedMintUrl)) {
+        const alternateResult = await this._findAlternateMint(
+          options,
+          balances,
+          units,
+          providerMints
+        );
+        if (alternateResult) {
+          return alternateResult;
+        }
+        adjustedAmount += 2;
+      }
+    }
+    const activeMintBalance = balances[mintUrl] || 0;
+    const activeMintUnit = units[mintUrl];
+    const activeMintBalanceInSats = activeMintUnit === "msat" ? activeMintBalance / 1e3 : activeMintBalance;
+    let token = null;
+    if (activeMintBalanceInSats >= adjustedAmount && (baseUrl === "" || !this.providerRegistry)) {
+      try {
+        token = await this.walletAdapter.sendToken(
+          mintUrl,
+          adjustedAmount,
+          p2pkPubkey
+        );
+      } catch (error) {
+        return this._handleSendError(error, options, balances, units);
+      }
+    } else if (selectedMintUrl && selectedMintBalance >= adjustedAmount) {
+      try {
+        token = await this.walletAdapter.sendToken(
+          selectedMintUrl,
+          adjustedAmount,
+          p2pkPubkey
+        );
+      } catch (error) {
+        return this._handleSendError(error, options, balances, units);
+      }
+    } else {
+      return this._createInsufficientBalanceError(
+        adjustedAmount,
+        balances,
+        units
+      );
+    }
+    if (token && baseUrl) {
+      this.storageAdapter.setToken(baseUrl, token);
+    }
+    this._logTransaction("spend", {
+      amount: adjustedAmount,
+      mintUrl: selectedMintUrl || mintUrl,
+      baseUrl,
+      status: "success"
+    });
+    return {
+      token,
+      status: "success",
+      balance: adjustedAmount,
+      unit: activeMintUnit
+    };
+  }
+  /**
+   * 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.getPendingTokenDistribution();
+    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 pending tokens and retry
+   */
+  async _refundAndRetry(options) {
+    const { mintUrl, baseUrl, retryCount } = options;
+    const pendingDistribution = this.storageAdapter.getPendingTokenDistribution();
+    const refundResults = await Promise.allSettled(
+      pendingDistribution.map(async (pending) => {
+        const token = this.storageAdapter.getToken(pending.baseUrl);
+        if (!token || !this.balanceManager || pending.baseUrl === baseUrl) {
+          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
+        });
+        return { baseUrl: pending.baseUrl, success: result.success };
+      })
+    );
+    for (const result of refundResults) {
+      const refundResult = result.status === "fulfilled" ? result.value : { baseUrl: "", success: false };
+      if (refundResult.success) {
+        this.storageAdapter.removeToken(refundResult.baseUrl);
+      }
+    }
+    const successfulRefunds = refundResults.filter(
+      (r) => r.status === "fulfilled" && r.value.success
+    ).length;
+    if (successfulRefunds > 0) {
+      this._logTransaction("refund", {
+        amount: pendingDistribution.length,
+        mintUrl,
+        status: "success",
+        details: `Refunded ${successfulRefunds} of ${pendingDistribution.length} tokens`
+      });
+    }
+    return this._spendInternal({
+      ...options,
+      retryCount: (retryCount || 0) + 1
+    });
+  }
+  /**
+   * Find an alternate mint that the provider accepts
+   */
+  async _findAlternateMint(options, balances, units, providerMints) {
+    const { amount, excludeMints } = options;
+    const adjustedAmount = Math.ceil(amount) + 2;
+    const extendedExcludes = [...excludeMints || []];
+    while (true) {
+      const { selectedMintUrl } = this._selectMintWithBalance(
+        balances,
+        units,
+        adjustedAmount,
+        extendedExcludes
+      );
+      if (!selectedMintUrl) break;
+      if (providerMints.includes(selectedMintUrl)) {
+        try {
+          const token = await this.walletAdapter.sendToken(
+            selectedMintUrl,
+            adjustedAmount
+          );
+          if (options.baseUrl) {
+            this.storageAdapter.setToken(options.baseUrl, token);
+          }
+          return {
+            token,
+            status: "success",
+            balance: adjustedAmount,
+            unit: units[selectedMintUrl] || "sat"
+          };
+        } catch (error) {
+          extendedExcludes.push(selectedMintUrl);
+        }
+      } else {
+        extendedExcludes.push(selectedMintUrl);
+      }
+    }
+    return null;
+  }
+  /**
+   * Handle send errors with retry logic for network errors
+   */
+  async _handleSendError(error, options, balances, units) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    const isNetworkError = error instanceof Error && (error.message.includes(
+      "NetworkError when attempting to fetch resource"
+    ) || error.message.includes("Failed to fetch") || error.message.includes("Load failed"));
+    if (isNetworkError) {
+      const { mintUrl, amount, baseUrl, p2pkPubkey, excludeMints, retryCount } = options;
+      const extendedExcludes = [...excludeMints || [], mintUrl];
+      const { selectedMintUrl } = this._selectMintWithBalance(
+        balances,
+        units,
+        Math.ceil(amount),
+        extendedExcludes
+      );
+      if (selectedMintUrl && (retryCount || 0) < Object.keys(balances).length) {
+        return this._spendInternal({
+          ...options,
+          mintUrl: selectedMintUrl,
+          excludeMints: extendedExcludes,
+          retryCount: (retryCount || 0) + 1
+        });
+      }
+      throw new MintUnreachableError(mintUrl);
+    }
+    return {
+      token: null,
+      status: "failed",
+      balance: 0,
+      error: `Error generating token: ${errorMsg}`
+    };
+  }
+  /**
+   * Select a mint with sufficient balance
+   */
+  _selectMintWithBalance(balances, units, amount, excludeMints = []) {
+    for (const mintUrl in balances) {
+      if (excludeMints.includes(mintUrl)) {
+        continue;
+      }
+      const balance = balances[mintUrl];
+      const unit = units[mintUrl];
+      const balanceInSats = unit === "msat" ? balance / 1e3 : balance;
+      if (balanceInSats >= amount) {
+        return { selectedMintUrl: mintUrl, selectedMintBalance: balanceInSats };
+      }
+    }
+    return { selectedMintUrl: null, selectedMintBalance: 0 };
+  }
+  /**
+   * 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 = unit === "msat" ? balance / 1e3 : balance;
+      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) {
+    this.walletAdapter = walletAdapter;
+    this.storageAdapter = storageAdapter;
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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 {
+      cashuToken = await this.walletAdapter.sendToken(mintUrl, amount);
+      const topUpResult = await this._postTopUp(
+        baseUrl,
+        storedToken,
+        cashuToken
+      );
+      requestId = topUpResult.requestId;
+      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);
+    }
+  }
+  /**
+   * 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 (error.message.includes(
+        "NetworkError when attempting to fetch resource"
+      ) || error.message.includes("Failed to fetch") || error.message.includes("Load failed")) {
+        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
+        };
+      }
+    } catch {
+    }
+    return { amount: 0, reserved: 0, unit: "sat", apiKey: "" };
+  }
+  /**
+   * Handle topup errors with specific error types
+   */
+  _handleTopUpError(error, mintUrl, requestId) {
+    if (error instanceof Error) {
+      if (error.message.includes(
+        "NetworkError when attempting to fetch resource"
+      ) || error.message.includes("Failed to fetch") || error.message.includes("Load failed")) {
+        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);
+  }
+};
+var shouldAllowHttp = (url, torMode) => {
+  if (!url.startsWith("http://")) return true;
+  if (url.includes("localhost") || url.includes("127.0.0.1")) return true;
+  return torMode && isOnionUrl(url);
+};
+var normalizeProviderUrl = (url, torMode = false) => {
+  if (!url || typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+  }
+  const useHttpForOnion = torMode && isOnionUrl(trimmed);
+  const withProto = `${useHttpForOnion ? "http" : "https"}://${trimmed}`;
+  return withProto.endsWith("/") ? withProto : `${withProto}/`;
+};
+var dedupePreserveOrder = (urls) => {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const url of urls) {
+    if (!seen.has(url)) {
+      seen.add(url);
+      out.push(url);
+    }
+  }
+  return out;
+};
+var getProviderEndpoints = (provider, torMode) => {
+  const rawUrls = [
+    provider.endpoint_url,
+    ...Array.isArray(provider.endpoint_urls) ? provider.endpoint_urls : [],
+    provider.onion_url,
+    ...Array.isArray(provider.onion_urls) ? provider.onion_urls : []
+  ];
+  const normalized = rawUrls.map((value) => normalizeProviderUrl(value, torMode)).filter((value) => Boolean(value));
+  const unique = dedupePreserveOrder(normalized).filter(
+    (value) => shouldAllowHttp(value, torMode)
+  );
+  if (unique.length === 0) return [];
+  const onion = unique.filter((value) => isOnionUrl(value));
+  const clearnet = unique.filter((value) => !isOnionUrl(value));
+  if (torMode) {
+    return onion.length > 0 ? onion : clearnet;
+  }
+  return clearnet;
+};
+var filterBaseUrlsForTor = (baseUrls, torMode) => {
+  if (!Array.isArray(baseUrls)) return [];
+  const normalized = baseUrls.map((value) => normalizeProviderUrl(value, torMode)).filter((value) => Boolean(value));
+  const filtered = normalized.filter(
+    (value) => torMode ? true : !isOnionUrl(value)
+  );
+  return dedupePreserveOrder(
+    filtered.filter((value) => shouldAllowHttp(value, torMode))
+  );
+};
+
+// 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;
+}
+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)) {
+          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)) 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")) 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 RoutstrClient = class {
+  constructor(walletAdapter, storageAdapter, providerRegistry, alertLevel, mode = "xcashu") {
+    this.walletAdapter = walletAdapter;
+    this.storageAdapter = storageAdapter;
+    this.providerRegistry = providerRegistry;
+    this.balanceManager = new BalanceManager(walletAdapter, storageAdapter);
+    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
+    });
+    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;
+    await this._handlePostResponseBalanceUpdate({
+      token,
+      baseUrl,
+      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}`;
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body === void 0 || method === "GET" ? void 0 : JSON.stringify(body)
+      });
+      response.baseUrl = baseUrl;
+      if (!response.ok) {
+        return await this._handleErrorResponse(response, params, token);
+      }
+      return response;
+    } catch (error) {
+      if (this._isNetworkError(error?.message || "")) {
+        return await this._handleNetworkError(error, params);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Handle error responses with failover
+   */
+  async _handleErrorResponse(response, params, token) {
+    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
+    const status = response.status;
+    if (this.mode === "apikeys") {
+      console.log("error ;", status);
+      if (status === 401 || status === 403) {
+        const parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+        if (parentApiKey) {
+          try {
+            const childKeyResult = await this._createChildKey(
+              baseUrl,
+              parentApiKey
+            );
+            this.storageAdapter.setChildKey(
+              baseUrl,
+              childKeyResult.childKey,
+              childKeyResult.balance,
+              childKeyResult.validityDate,
+              childKeyResult.balanceLimit
+            );
+            return this._makeRequest({
+              ...params,
+              token: childKeyResult.childKey,
+              headers: this._withAuthHeader(
+                params.baseHeaders,
+                childKeyResult.childKey
+              )
+            });
+          } catch (e) {
+          }
+        }
+      } else if (status === 402) {
+        const parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+        if (parentApiKey) {
+          const topupResult = await this.balanceManager.topUp({
+            mintUrl,
+            baseUrl,
+            amount: params.requiredSats * 3,
+            token: parentApiKey
+          });
+          console.log(topupResult);
+          return this._makeRequest({
+            ...params,
+            token: params.token,
+            headers: this._withAuthHeader(params.baseHeaders, params.token)
+          });
+        }
+      }
+      throw new ProviderError(baseUrl, status, await response.text());
+    }
+    await this.balanceManager.refund({
+      mintUrl,
+      baseUrl,
+      token
+    });
+    this.providerManager.markFailed(baseUrl);
+    this.storageAdapter.removeToken(baseUrl);
+    if (status === 401 || status === 403 || status === 402 || status === 413 || status === 400 || status === 500 || status === 502) {
+      if (!selectedModel) {
+        throw new ProviderError(baseUrl, status, await response.text());
+      }
+      const nextProvider = this.providerManager.findNextBestProvider(
+        selectedModel.id,
+        baseUrl
+      );
+      if (nextProvider) {
+        const newModel = await this.providerManager.getModelForProvider(
+          nextProvider,
+          selectedModel.id
+        ) ?? selectedModel;
+        const messagesForPricing = Array.isArray(
+          body?.messages
+        ) ? body.messages : [];
+        const newRequiredSats = this.providerManager.getRequiredSatsForModel(
+          newModel,
+          messagesForPricing,
+          params.maxTokens
+        );
+        const spendResult = await this.cashuSpender.spend({
+          mintUrl,
+          amount: newRequiredSats,
+          baseUrl: nextProvider,
+          reuseToken: true
+        });
+        if (spendResult.status === "failed" || !spendResult.token) {
+          if (spendResult.errorDetails) {
+            throw new InsufficientBalanceError(
+              spendResult.errorDetails.required,
+              spendResult.errorDetails.available,
+              spendResult.errorDetails.maxMintBalance,
+              spendResult.errorDetails.maxMintUrl
+            );
+          }
+          throw new Error(
+            spendResult.error || `Insufficient balance for ${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 ProviderError(baseUrl, status, await response.text());
+  }
+  /**
+   * Handle network errors with failover
+   */
+  async _handleNetworkError(error, params) {
+    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
+    await this.balanceManager.refund({
+      mintUrl,
+      baseUrl,
+      token: params.token
+    });
+    this.providerManager.markFailed(baseUrl);
+    if (!selectedModel) {
+      throw error;
+    }
+    const nextProvider = this.providerManager.findNextBestProvider(
+      selectedModel.id,
+      baseUrl
+    );
+    if (!nextProvider) {
+      throw new FailoverError(baseUrl, Array.from(this.providerManager));
+    }
+    const newModel = await this.providerManager.getModelForProvider(
+      nextProvider,
+      selectedModel.id
+    ) ?? selectedModel;
+    const messagesForPricing = Array.isArray(
+      body?.messages
+    ) ? body.messages : [];
+    const newRequiredSats = this.providerManager.getRequiredSatsForModel(
+      newModel,
+      messagesForPricing,
+      params.maxTokens
+    );
+    const spendResult = await this.cashuSpender.spend({
+      mintUrl,
+      amount: newRequiredSats,
+      baseUrl: nextProvider,
+      reuseToken: true
+    });
+    if (spendResult.status === "failed" || !spendResult.token) {
+      if (spendResult.errorDetails) {
+        throw new InsufficientBalanceError(
+          spendResult.errorDetails.required,
+          spendResult.errorDetails.available,
+          spendResult.errorDetails.maxMintBalance,
+          spendResult.errorDetails.maxMintUrl
+        );
+      }
+      throw new Error(
+        spendResult.error || `Insufficient balance for ${nextProvider}`
+      );
+    }
+    return this._makeRequest({
+      ...params,
+      path,
+      method,
+      body,
+      baseUrl: nextProvider,
+      selectedModel: newModel,
+      token: spendResult.token,
+      requiredSats: newRequiredSats,
+      headers: this._withAuthHeader(params.baseHeaders, spendResult.token)
+    });
+  }
+  /**
+   * Handle post-response refund and balance updates
+   */
+  async _handlePostResponseRefund(params) {
+    const {
+      mintUrl,
+      baseUrl,
+      tokenBalance,
+      tokenBalanceUnit,
+      initialBalance,
+      selectedModel,
+      streamingResult,
+      callbacks
+    } = params;
+    const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
+    const estimatedCosts = this._getEstimatedCosts(
+      selectedModel,
+      streamingResult
+    );
+    const refundResult = await this.balanceManager.refund({
+      mintUrl,
+      baseUrl
+    });
+    if (refundResult.success) {
+      refundResult.refundedAmount !== void 0 ? refundResult.refundedAmount / 1e3 : 0;
+    }
+    let satsSpent;
+    if (refundResult.success) {
+      if (refundResult.refundedAmount !== void 0) {
+        satsSpent = tokenBalanceInSats - refundResult.refundedAmount / 1e3;
+      } else if (refundResult.message?.includes("No API key to refund")) {
+        satsSpent = 0;
+      } else {
+        satsSpent = tokenBalanceInSats;
+      }
+      const newBalance = initialBalance - satsSpent;
+      callbacks.onBalanceUpdate(newBalance);
+    } else {
+      if (refundResult.message?.includes("Refund request failed with status 401")) {
+        this.storageAdapter.removeToken(baseUrl);
+      }
+      satsSpent = tokenBalanceInSats;
+    }
+    const netCosts = satsSpent - estimatedCosts;
+    const overchargeThreshold = tokenBalanceUnit === "msat" ? 0.05 : 1;
+    if (netCosts > overchargeThreshold) {
+      if (this.alertLevel === "max") {
+        callbacks.onMessageAppend({
+          role: "system",
+          content: `ATTENTION: Provider may be overcharging. Estimated: ${estimatedCosts.toFixed(
+            tokenBalanceUnit === "msat" ? 3 : 0
+          )}, Actual: ${satsSpent.toFixed(
+            tokenBalanceUnit === "msat" ? 3 : 0
+          )}`
+        });
+      }
+    }
+    const newTransaction = {
+      type: "spent",
+      amount: satsSpent,
+      timestamp: Date.now(),
+      status: "success",
+      model: selectedModel.id,
+      message: "Tokens spent",
+      balance: initialBalance - satsSpent
+    };
+    callbacks.onTransactionUpdate(newTransaction);
+    return satsSpent;
+  }
+  /**
+   * 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._getApiKeyBalance(baseUrl, token);
+        console.log("LATEST BANAL", latestBalanceInfo);
+        const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+        this.storageAdapter.updateChildKeyBalance(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
+    };
+  }
+  /**
+   * Get balance for an API key from the provider
+   */
+  async _getApiKeyBalance(baseUrl, apiKey) {
+    try {
+      const response = await fetch(`${baseUrl}v1/wallet/info`, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`
+        }
+      });
+      if (response.ok) {
+        const data = await response.json();
+        console.log(data);
+        return {
+          amount: data.balance,
+          unit: "msat"
+        };
+      }
+    } catch {
+    }
+    return { amount: 0, unit: "sat" };
+  }
+  /**
+   * 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.getPendingTokenDistribution();
+    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 error:", error);
+    if (error instanceof Error) {
+      const modifiedErrorMsg = error.message.includes("Error in input stream") || error.message.includes("Load failed") ? "AI stream was cut off, turn on Keep Active or please try again" : error.message;
+      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;
+    if (this.mode === "apikeys") {
+      let parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+      if (!parentApiKey) {
+        const spendResult2 = await this.cashuSpender.spend({
+          mintUrl,
+          amount: amount * 3,
+          baseUrl: "",
+          reuseToken: false
+        });
+        if (spendResult2.status === "failed" || !spendResult2.token) {
+          const errorMsg = spendResult2.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 (spendResult2.errorDetails) {
+            throw new InsufficientBalanceError(
+              spendResult2.errorDetails.required,
+              spendResult2.errorDetails.available,
+              spendResult2.errorDetails.maxMintBalance,
+              spendResult2.errorDetails.maxMintUrl
+            );
+          }
+          throw new Error(errorMsg);
+        }
+        const apiKeyCreated = await this.balanceManager.getTokenBalance(
+          spendResult2.token,
+          baseUrl
+        );
+        parentApiKey = apiKeyCreated.apiKey;
+        this.storageAdapter.setApiKey(baseUrl, parentApiKey);
+      }
+      let childKeyEntry = this.storageAdapter.getChildKey(baseUrl);
+      if (!childKeyEntry) {
+        try {
+          const childKeyResult = await this._createChildKey(
+            baseUrl,
+            parentApiKey
+          );
+          this.storageAdapter.setChildKey(
+            baseUrl,
+            childKeyResult.childKey,
+            childKeyResult.balance,
+            childKeyResult.validityDate,
+            childKeyResult.balanceLimit
+          );
+          childKeyEntry = {
+            parentBaseUrl: baseUrl,
+            childKey: childKeyResult.childKey,
+            balance: childKeyResult.balance,
+            balanceLimit: childKeyResult.balanceLimit,
+            validityDate: childKeyResult.validityDate,
+            createdAt: Date.now()
+          };
+        } catch (e) {
+          console.warn("Could not create child key, using parent key:", e);
+          childKeyEntry = {
+            parentBaseUrl: baseUrl,
+            childKey: parentApiKey,
+            balance: 0,
+            createdAt: Date.now()
+          };
+        }
+      }
+      let tokenBalance = childKeyEntry.balance;
+      let tokenBalanceUnit = "sat";
+      if (tokenBalance === 0) {
+        try {
+          const balanceInfo = await this._getApiKeyBalance(
+            baseUrl,
+            childKeyEntry.childKey
+          );
+          tokenBalance = balanceInfo.amount;
+          tokenBalanceUnit = balanceInfo.unit;
+        } catch (e) {
+          console.warn("Could not get initial API key balance:", e);
+        }
+      }
+      return {
+        token: childKeyEntry.childKey,
+        tokenBalance,
+        tokenBalanceUnit
+      };
+    }
+    const spendResult = await this.cashuSpender.spend({
+      mintUrl,
+      amount,
+      baseUrl,
+      reuseToken: true
+    });
+    if (spendResult.status === "failed" || !spendResult.token) {
+      const errorMsg = spendResult.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 (spendResult.errorDetails) {
+        throw new InsufficientBalanceError(
+          spendResult.errorDetails.required,
+          spendResult.errorDetails.available,
+          spendResult.errorDetails.maxMintBalance,
+          spendResult.errorDetails.maxMintUrl
+        );
+      }
+      throw new Error(errorMsg);
+    }
+    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;
+  }
+};
+
+// 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 = {
+  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;
+    }
+  },
+  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);
+    }
+  },
+  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();
+  if (seed) {
+    for (const [key, value] of Object.entries(seed)) {
+      store.set(key, value);
+    }
+  }
+  return {
+    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;
+      }
+    },
+    setItem(key, value) {
+      store.set(key, JSON.stringify(value));
+    },
+    removeItem(key) {
+      store.delete(key);
+    }
+  };
+};
+
+// storage/drivers/sqlite.ts
+var createDatabase = (dbPath) => {
+  let Database = null;
+  try {
+    Database = __require("better-sqlite3");
+  } catch (error) {
+    throw new Error(
+      `better-sqlite3 is required for sqlite storage. Install it to use sqlite storage. (${error})`
+    );
+  }
+  return new Database(dbPath);
+};
+var createSqliteDriver = (options = {}) => {
+  const dbPath = options.dbPath || "routstr.sqlite";
+  const tableName = options.tableName || "sdk_storage";
+  const db = createDatabase(dbPath);
+  db.exec(
+    `CREATE TABLE IF NOT EXISTS ${tableName} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
+  );
+  const selectStmt = db.prepare(`SELECT value FROM ${tableName} WHERE key = ?`);
+  const upsertStmt = db.prepare(
+    `INSERT INTO ${tableName} (key, value) VALUES (?, ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  );
+  const deleteStmt = db.prepare(`DELETE FROM ${tableName} WHERE key = ?`);
+  return {
+    getItem(key, defaultValue) {
+      try {
+        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;
+      }
+    },
+    setItem(key, value) {
+      try {
+        upsertStmt.run(key, JSON.stringify(value));
+      } catch (error) {
+        console.error(`SQLite setItem failed for key "${key}":`, error);
+      }
+    },
+    removeItem(key) {
+      try {
+        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",
+  LOCAL_CASHU_TOKENS: "local_cashu_tokens",
+  API_KEYS: "api_keys",
+  CHILD_KEYS: "child_keys"
+};
+
+// storage/store.ts
+var normalizeBaseUrl = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var getTokenBalance = (token) => {
+  try {
+    const decoded = cashuTs.getDecodedToken(token);
+    const unitDivisor = decoded.unit === "msat" ? 1e3 : 1;
+    let sum = 0;
+    for (const proof of decoded.proofs) {
+      sum += proof.amount / unitDivisor;
+    }
+    return sum;
+  } catch {
+    return 0;
+  }
+};
+var createSdkStore = ({ driver }) => {
+  return vanilla.createStore((set, get) => ({
+    modelsFromAllProviders: Object.fromEntries(
+      Object.entries(
+        driver.getItem(
+          SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
+          {}
+        )
+      ).map(([baseUrl, models]) => [normalizeBaseUrl(baseUrl), models])
+    ),
+    lastUsedModel: driver.getItem(
+      SDK_STORAGE_KEYS.LAST_USED_MODEL,
+      null
+    ),
+    baseUrlsList: driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []).map((url) => normalizeBaseUrl(url)),
+    lastBaseUrlsUpdate: driver.getItem(
+      SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE,
+      null
+    ),
+    disabledProviders: driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []).map((url) => normalizeBaseUrl(url)),
+    mintsFromAllProviders: Object.fromEntries(
+      Object.entries(
+        driver.getItem(
+          SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+          {}
+        )
+      ).map(([baseUrl, mints]) => [
+        normalizeBaseUrl(baseUrl),
+        mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
+      ])
+    ),
+    infoFromAllProviders: Object.fromEntries(
+      Object.entries(
+        driver.getItem(
+          SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
+          {}
+        )
+      ).map(([baseUrl, info]) => [normalizeBaseUrl(baseUrl), info])
+    ),
+    lastModelsUpdate: Object.fromEntries(
+      Object.entries(
+        driver.getItem(
+          SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
+          {}
+        )
+      ).map(([baseUrl, timestamp]) => [normalizeBaseUrl(baseUrl), timestamp])
+    ),
+    cachedTokens: driver.getItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, []).map((entry) => ({
+      ...entry,
+      baseUrl: normalizeBaseUrl(entry.baseUrl),
+      balance: typeof entry.balance === "number" ? entry.balance : getTokenBalance(entry.token),
+      lastUsed: entry.lastUsed ?? null
+    })),
+    apiKeys: driver.getItem(SDK_STORAGE_KEYS.API_KEYS, []).map((entry) => ({
+      ...entry,
+      baseUrl: normalizeBaseUrl(entry.baseUrl),
+      balance: entry.balance ?? 0,
+      lastUsed: entry.lastUsed ?? null
+    })),
+    childKeys: driver.getItem(SDK_STORAGE_KEYS.CHILD_KEYS, []).map((entry) => ({
+      parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
+      childKey: entry.childKey,
+      balance: entry.balance ?? 0,
+      balanceLimit: entry.balanceLimit,
+      validityDate: entry.validityDate,
+      createdAt: entry.createdAt ?? Date.now()
+    })),
+    setModelsFromAllProviders: (value) => {
+      const normalized = {};
+      for (const [baseUrl, models] of Object.entries(value)) {
+        normalized[normalizeBaseUrl(baseUrl)] = models;
+      }
+      driver.setItem(SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS, normalized);
+      set({ modelsFromAllProviders: normalized });
+    },
+    setLastUsedModel: (value) => {
+      driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
+      set({ lastUsedModel: value });
+    },
+    setBaseUrlsList: (value) => {
+      const normalized = value.map((url) => normalizeBaseUrl(url));
+      driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
+      set({ baseUrlsList: normalized });
+    },
+    setBaseUrlsLastUpdate: (value) => {
+      driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
+      set({ lastBaseUrlsUpdate: value });
+    },
+    setDisabledProviders: (value) => {
+      const normalized = value.map((url) => normalizeBaseUrl(url));
+      driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
+      set({ disabledProviders: normalized });
+    },
+    setMintsFromAllProviders: (value) => {
+      const normalized = {};
+      for (const [baseUrl, mints] of Object.entries(value)) {
+        normalized[normalizeBaseUrl(baseUrl)] = mints.map(
+          (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
+        );
+      }
+      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[normalizeBaseUrl(baseUrl)] = info;
+      }
+      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[normalizeBaseUrl(baseUrl)] = timestamp;
+      }
+      driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
+      set({ lastModelsUpdate: normalized });
+    },
+    setCachedTokens: (value) => {
+      set((state) => {
+        const updates = typeof value === "function" ? value(state.cachedTokens) : value;
+        const normalized = updates.map((entry) => ({
+          ...entry,
+          baseUrl: normalizeBaseUrl(entry.baseUrl),
+          balance: typeof entry.balance === "number" ? entry.balance : getTokenBalance(entry.token),
+          lastUsed: entry.lastUsed ?? null
+        }));
+        driver.setItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, normalized);
+        return { cachedTokens: normalized };
+      });
+    },
+    setApiKeys: (value) => {
+      set((state) => {
+        const updates = typeof value === "function" ? value(state.apiKeys) : value;
+        const normalized = updates.map((entry) => ({
+          ...entry,
+          baseUrl: normalizeBaseUrl(entry.baseUrl),
+          balance: entry.balance ?? 0,
+          lastUsed: entry.lastUsed ?? null
+        }));
+        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: normalizeBaseUrl(entry.parentBaseUrl),
+          childKey: entry.childKey,
+          balance: entry.balance ?? 0,
+          balanceLimit: entry.balanceLimit,
+          validityDate: entry.validityDate,
+          createdAt: entry.createdAt ?? Date.now()
+        }));
+        driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
+        return { childKeys: normalized };
+      });
+    }
+  }));
+};
+var createDiscoveryAdapterFromStore = (store) => ({
+  getCachedModels: () => store.getState().modelsFromAllProviders,
+  setCachedModels: (models) => store.getState().setModelsFromAllProviders(models),
+  getCachedMints: () => store.getState().mintsFromAllProviders,
+  setCachedMints: (mints) => store.getState().setMintsFromAllProviders(mints),
+  getCachedProviderInfo: () => store.getState().infoFromAllProviders,
+  setCachedProviderInfo: (info) => store.getState().setInfoFromAllProviders(info),
+  getProviderLastUpdate: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const timestamps = store.getState().lastModelsUpdate;
+    return timestamps[normalized] || null;
+  },
+  setProviderLastUpdate: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const timestamps = { ...store.getState().lastModelsUpdate };
+    timestamps[normalized] = timestamp;
+    store.getState().setLastModelsUpdate(timestamps);
+  },
+  getLastUsedModel: () => store.getState().lastUsedModel,
+  setLastUsedModel: (modelId) => store.getState().setLastUsedModel(modelId),
+  getDisabledProviders: () => store.getState().disabledProviders,
+  getBaseUrlsList: () => store.getState().baseUrlsList,
+  setBaseUrlsList: (urls) => store.getState().setBaseUrlsList(urls),
+  getBaseUrlsLastUpdate: () => store.getState().lastBaseUrlsUpdate,
+  setBaseUrlsLastUpdate: (timestamp) => store.getState().setBaseUrlsLastUpdate(timestamp)
+});
+var createStorageAdapterFromStore = (store) => ({
+  getToken: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const entry = store.getState().cachedTokens.find((token) => token.baseUrl === normalized);
+    if (!entry) return null;
+    const next = store.getState().cachedTokens.map(
+      (token) => token.baseUrl === normalized ? { ...token, lastUsed: Date.now() } : token
+    );
+    store.getState().setCachedTokens(next);
+    return entry.token;
+  },
+  setToken: (baseUrl, token) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const tokens = store.getState().cachedTokens;
+    const balance = getTokenBalance(token);
+    const existingIndex = tokens.findIndex(
+      (entry) => entry.baseUrl === normalized
+    );
+    if (existingIndex !== -1) {
+      throw new Error(`Token already exists for baseUrl: ${normalized}`);
+    }
+    const next = [...tokens];
+    next.push({
+      baseUrl: normalized,
+      token,
+      balance,
+      lastUsed: Date.now()
+    });
+    store.getState().setCachedTokens(next);
+  },
+  removeToken: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const next = store.getState().cachedTokens.filter((entry) => entry.baseUrl !== normalized);
+    store.getState().setCachedTokens(next);
+  },
+  updateTokenBalance: (baseUrl, balance) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const tokens = store.getState().cachedTokens;
+    const next = tokens.map(
+      (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
+    );
+    store.getState().setCachedTokens(next);
+  },
+  getPendingTokenDistribution: () => {
+    const tokens = store.getState().cachedTokens;
+    const distributionMap = {};
+    for (const entry of tokens) {
+      const sum = entry.balance || 0;
+      if (sum > 0) {
+        distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
+      }
+    }
+    return Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
+  },
+  saveProviderInfo: (baseUrl, info) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const next = { ...store.getState().infoFromAllProviders };
+    next[normalized] = info;
+    store.getState().setInfoFromAllProviders(next);
+  },
+  getProviderInfo: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    return store.getState().infoFromAllProviders[normalized] || null;
+  },
+  // ========== API Keys (for apikeys mode) ==========
+  getApiKey: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const entry = store.getState().apiKeys.find((key) => key.baseUrl === normalized);
+    if (!entry) return null;
+    const next = store.getState().apiKeys.map(
+      (key) => key.baseUrl === normalized ? { ...key, lastUsed: Date.now() } : key
+    );
+    store.getState().setApiKeys(next);
+    return entry.key;
+  },
+  setApiKey: (baseUrl, key) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const keys = store.getState().apiKeys;
+    const existingIndex = keys.findIndex(
+      (entry) => entry.baseUrl === normalized
+    );
+    if (existingIndex !== -1) {
+      const next = keys.map(
+        (entry) => entry.baseUrl === normalized ? { ...entry, key, lastUsed: Date.now() } : entry
+      );
+      store.getState().setApiKeys(next);
+    } else {
+      const next = [...keys];
+      next.push({
+        baseUrl: normalized,
+        key,
+        balance: 0,
+        lastUsed: Date.now()
+      });
+      store.getState().setApiKeys(next);
+    }
+  },
+  updateApiKeyBalance: (baseUrl, balance) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const keys = store.getState().apiKeys;
+    const next = keys.map(
+      (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
+    );
+    store.getState().setApiKeys(next);
+  },
+  getAllApiKeys: () => {
+    return store.getState().apiKeys.map((entry) => ({
+      baseUrl: entry.baseUrl,
+      key: entry.key,
+      balance: entry.balance,
+      lastUsed: entry.lastUsed
+    }));
+  },
+  // ========== Child Keys ==========
+  getChildKey: (parentBaseUrl) => {
+    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const entry = store.getState().childKeys.find((key) => key.parentBaseUrl === normalized);
+    if (!entry) return null;
+    return {
+      parentBaseUrl: entry.parentBaseUrl,
+      childKey: entry.childKey,
+      balance: entry.balance,
+      balanceLimit: entry.balanceLimit,
+      validityDate: entry.validityDate,
+      createdAt: entry.createdAt
+    };
+  },
+  setChildKey: (parentBaseUrl, childKey, balance, validityDate, balanceLimit) => {
+    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const keys = store.getState().childKeys;
+    const existingIndex = keys.findIndex(
+      (entry) => entry.parentBaseUrl === normalized
+    );
+    if (existingIndex !== -1) {
+      const next = keys.map(
+        (entry) => entry.parentBaseUrl === normalized ? {
+          ...entry,
+          childKey,
+          balance: balance ?? 0,
+          validityDate,
+          balanceLimit,
+          createdAt: Date.now()
+        } : entry
+      );
+      store.getState().setChildKeys(next);
+    } else {
+      const next = [...keys];
+      next.push({
+        parentBaseUrl: normalized,
+        childKey,
+        balance: balance ?? 0,
+        validityDate,
+        balanceLimit,
+        createdAt: Date.now()
+      });
+      store.getState().setChildKeys(next);
+    }
+  },
+  updateChildKeyBalance: (parentBaseUrl, balance) => {
+    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const keys = store.getState().childKeys;
+    const next = keys.map(
+      (entry) => entry.parentBaseUrl === normalized ? { ...entry, balance } : entry
+    );
+    store.getState().setChildKeys(next);
+  },
+  removeChildKey: (parentBaseUrl) => {
+    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const next = store.getState().childKeys.filter((entry) => entry.parentBaseUrl !== normalized);
+    store.getState().setChildKeys(next);
+  },
+  getAllChildKeys: () => {
+    return store.getState().childKeys.map((entry) => ({
+      parentBaseUrl: entry.parentBaseUrl,
+      childKey: entry.childKey,
+      balance: entry.balance,
+      balanceLimit: entry.balanceLimit,
+      validityDate: entry.validityDate,
+      createdAt: entry.createdAt
+    }));
+  }
+});
+var createProviderRegistryFromStore = (store) => ({
+  getModelsForProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    return store.getState().modelsFromAllProviders[normalized] || [];
+  },
+  getDisabledProviders: () => store.getState().disabledProviders,
+  getProviderMints: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    return store.getState().mintsFromAllProviders[normalized] || [];
+  },
+  getProviderInfo: async (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const cached = store.getState().infoFromAllProviders[normalized];
+    if (cached) return cached;
+    try {
+      const response = await fetch(`${normalized}v1/info`);
+      if (!response.ok) {
+        throw new Error(`Failed ${response.status}`);
+      }
+      const info = await response.json();
+      const next = { ...store.getState().infoFromAllProviders };
+      next[normalized] = info;
+      store.getState().setInfoFromAllProviders(next);
+      return info;
+    } catch (error) {
+      console.warn(`Failed to fetch provider info from ${normalized}:`, error);
+      return null;
+    }
+  },
+  getAllProvidersModels: () => store.getState().modelsFromAllProviders
+});
+
+// storage/index.ts
+var isBrowser = () => {
+  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 getDefaultSdkDriver = () => {
+  if (defaultDriver) return defaultDriver;
+  if (isBrowser()) {
+    defaultDriver = localStorageDriver;
+    return defaultDriver;
+  }
+  if (isNode()) {
+    defaultDriver = createSqliteDriver();
+    return defaultDriver;
+  }
+  defaultDriver = createMemoryDriver();
+  return defaultDriver;
+};
+var defaultStore = null;
+var getDefaultSdkStore = () => {
+  if (!defaultStore) {
+    defaultStore = createSdkStore({ driver: getDefaultSdkDriver() });
+  }
+  return defaultStore;
+};
+var getDefaultDiscoveryAdapter = () => createDiscoveryAdapterFromStore(getDefaultSdkStore());
+var getDefaultStorageAdapter = () => createStorageAdapterFromStore(getDefaultSdkStore());
+var getDefaultProviderRegistry = () => createProviderRegistryFromStore(getDefaultSdkStore());
+
+// routeRequests.ts
+async function routeRequests(options) {
+  const {
+    modelId,
+    requestBody,
+    path = "/v1/chat/completions",
+    forcedProvider,
+    walletAdapter,
+    storageAdapter,
+    providerRegistry,
+    discoveryAdapter,
+    includeProviderUrls = [],
+    torMode = false,
+    forceRefresh = false,
+    modelManager: providedModelManager
+  } = options;
+  let modelManager;
+  let providers;
+  if (providedModelManager) {
+    modelManager = providedModelManager;
+    providers = modelManager.getBaseUrls();
+    if (providers.length === 0) {
+      throw new Error("No providers available - run bootstrap first");
+    }
+  } else {
+    modelManager = new ModelManager(discoveryAdapter, {
+      includeProviderUrls: forcedProvider ? [forcedProvider, ...includeProviderUrls] : includeProviderUrls
+    });
+    providers = await modelManager.bootstrapProviders(torMode);
+    if (providers.length === 0) {
+      throw new Error("No providers available");
+    }
+    await modelManager.fetchModels(providers, forceRefresh);
+  }
+  const providerManager = new ProviderManager(providerRegistry);
+  let baseUrl;
+  let selectedModel;
+  if (forcedProvider) {
+    const normalizedProvider = forcedProvider.endsWith("/") ? forcedProvider : `${forcedProvider}/`;
+    const cachedModels = modelManager.getAllCachedModels();
+    const models = cachedModels[normalizedProvider] || [];
+    const match = models.find((m) => m.id === modelId);
+    if (!match) {
+      throw new Error(
+        `Provider ${normalizedProvider} does not offer model: ${modelId}`
+      );
+    }
+    baseUrl = normalizedProvider;
+    selectedModel = match;
+  } else {
+    const ranking = providerManager.getProviderPriceRankingForModel(modelId, {
+      torMode,
+      includeDisabled: false
+    });
+    if (ranking.length === 0) {
+      throw new Error(`No providers found for model: ${modelId}`);
+    }
+    const cheapest = ranking[0];
+    baseUrl = cheapest.baseUrl;
+    selectedModel = cheapest.model;
+  }
+  const balances = await walletAdapter.getBalances();
+  const totalBalance = Object.values(balances).reduce((sum, v) => sum + v, 0);
+  if (totalBalance <= 0) {
+    throw new Error(
+      "Wallet balance is empty. Add a mint and fund it before making requests."
+    );
+  }
+  const providerMints = providerRegistry.getProviderMints(baseUrl);
+  const mintUrl = walletAdapter.getActiveMintUrl() || providerMints[0] || Object.keys(balances)[0];
+  if (!mintUrl) {
+    throw new Error("No mint configured in wallet");
+  }
+  const alertLevel = "min";
+  const client = new RoutstrClient(
+    walletAdapter,
+    storageAdapter,
+    providerRegistry,
+    alertLevel,
+    "apikeys"
+  );
+  const maxTokens = extractMaxTokens(requestBody);
+  const stream = extractStream(requestBody);
+  let response = null;
+  try {
+    const proxiedBody = requestBody && typeof requestBody === "object" ? { ...requestBody } : {};
+    proxiedBody.model = selectedModel.id;
+    if (stream !== void 0) {
+      proxiedBody.stream = stream;
+    }
+    if (maxTokens !== void 0) {
+      proxiedBody.max_tokens = maxTokens;
+    }
+    response = await client.routeRequest({
+      path,
+      method: "POST",
+      body: proxiedBody,
+      baseUrl,
+      mintUrl,
+      modelId
+    });
+    if (!response.ok) {
+      throw new Error(`${response.status} ${response.statusText}`);
+    }
+    return response;
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("401") || error.message.includes("402") || error.message.includes("403"))) {
+      throw new Error(`Authentication failed: ${error.message}`);
+    }
+    throw error;
+  }
+}
+function extractMaxTokens(requestBody) {
+  if (!requestBody || typeof requestBody !== "object") {
+    return void 0;
+  }
+  const body = requestBody;
+  const maxTokens = body.max_tokens;
+  if (typeof maxTokens === "number") {
+    return maxTokens;
+  }
+  return void 0;
+}
+function extractStream(requestBody) {
+  if (!requestBody || typeof requestBody !== "object") {
+    return false;
+  }
+  const body = requestBody;
+  const stream = body.stream;
+  return stream === true;
+}
+
+exports.BalanceManager = BalanceManager;
+exports.CashuSpender = CashuSpender;
+exports.FailoverError = FailoverError;
+exports.InsufficientBalanceError = InsufficientBalanceError;
+exports.MintDiscovery = MintDiscovery;
+exports.MintDiscoveryError = MintDiscoveryError;
+exports.MintUnreachableError = MintUnreachableError;
+exports.ModelManager = ModelManager;
+exports.ModelNotFoundError = ModelNotFoundError;
+exports.NoProvidersAvailableError = NoProvidersAvailableError;
+exports.ProviderBootstrapError = ProviderBootstrapError;
+exports.ProviderError = ProviderError;
+exports.ProviderManager = ProviderManager;
+exports.RoutstrClient = RoutstrClient;
+exports.SDK_STORAGE_KEYS = SDK_STORAGE_KEYS;
+exports.StreamProcessor = StreamProcessor;
+exports.StreamingError = StreamingError;
+exports.TokenOperationError = TokenOperationError;
+exports.createMemoryDriver = createMemoryDriver;
+exports.createSdkStore = createSdkStore;
+exports.createSqliteDriver = createSqliteDriver;
+exports.filterBaseUrlsForTor = filterBaseUrlsForTor;
+exports.getDefaultDiscoveryAdapter = getDefaultDiscoveryAdapter;
+exports.getDefaultProviderRegistry = getDefaultProviderRegistry;
+exports.getDefaultSdkDriver = getDefaultSdkDriver;
+exports.getDefaultSdkStore = getDefaultSdkStore;
+exports.getDefaultStorageAdapter = getDefaultStorageAdapter;
+exports.getProviderEndpoints = getProviderEndpoints;
+exports.isOnionUrl = isOnionUrl;
+exports.isTorContext = isTorContext;
+exports.localStorageDriver = localStorageDriver;
+exports.normalizeProviderUrl = normalizeProviderUrl;
+exports.routeRequests = routeRequests;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map