@routstr/sdk 0.2.4 → 0.2.5

package/dist/index.js

@@ -5,6 +5,7 @@ var applesauceCore = require('applesauce-core');
 var rxjs = require('rxjs');
 var vanilla = require('zustand/vanilla');
 var cashuTs = require('@cashu/cashu-ts');
+var stream = require('stream');
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -385,10 +386,7 @@ var ModelManager = class _ModelManager {
       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
-    })) : [];
+    const list = Array.isArray(json?.data) ? json.data : [];
     return list;
   }
   isProviderDownError(error) {
@@ -1115,7 +1113,7 @@ var CashuSpender = class {
   /**
    * Refund specific providers without retrying spend
    */
-  async refundProviders(baseUrls, mintUrl, refundApiKeys = false) {
+  async refundProviders(baseUrls, mintUrl, refundApiKeys = false, forceRefund) {
     const results = [];
     const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
     const toRefund = pendingDistribution.filter(
@@ -1165,7 +1163,8 @@ var CashuSpender = class {
           const refundResult = await this.balanceManager.refundApiKey({
             mintUrl,
             baseUrl: apiKeyEntry.baseUrl,
-            apiKey: apiKeyEntryFull.key
+            apiKey: apiKeyEntryFull.key,
+            forceRefund
           });
           if (refundResult.success) {
             this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, 0);
@@ -1338,12 +1337,29 @@ var BalanceManager = class {
   }
   /**
    * Refund API key balance - convert remaining API key balance to cashu token
+   * @param options - Refund options including forceRefund flag
+   * @returns Refund result
    */
   async refundApiKey(options) {
-    const { mintUrl, baseUrl, apiKey } = options;
+    const { mintUrl, baseUrl, apiKey, forceRefund } = options;
     if (!apiKey) {
       return { success: false, message: "No API key to refund" };
     }
+    if (!forceRefund) {
+      const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+      if (apiKeyEntry?.lastUsed) {
+        const fiveMinutesAgo = Date.now() - 5 * 60 * 1e3;
+        if (apiKeyEntry.lastUsed > fiveMinutesAgo) {
+          console.log(
+            `[BalanceManager] Skipping refund for ${baseUrl} - used ${Math.round((Date.now() - apiKeyEntry.lastUsed) / 1e3)}s ago`
+          );
+          return {
+            success: false,
+            message: "API key was used recently, skipping refund"
+          };
+        }
+      }
+    }
     let fetchResult;
     try {
       fetchResult = await this._fetchRefundTokenWithApiKey(baseUrl, apiKey);
@@ -1535,8 +1551,8 @@ var BalanceManager = class {
     const refundableProviderBalance = Object.entries(
       balanceState.providerBalances
     ).filter(([providerBaseUrl]) => providerBaseUrl !== baseUrl).reduce((sum, [, value]) => sum + value, 0);
-    if (totalMintBalance + targetProviderBalance < adjustedAmount && totalMintBalance + targetProviderBalance + refundableProviderBalance >= adjustedAmount && retryCount < 1) {
-      await this._refundOtherProvidersForTopUp(baseUrl, mintUrl);
+    if (totalMintBalance + targetProviderBalance < adjustedAmount && totalMintBalance + targetProviderBalance + refundableProviderBalance >= adjustedAmount && retryCount < 2) {
+      await this._refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount);
       return this.createProviderToken({
         ...options,
         retryCount: retryCount + 1
@@ -1689,9 +1705,10 @@ var BalanceManager = class {
     }
     return candidates;
   }
-  async _refundOtherProvidersForTopUp(baseUrl, mintUrl) {
+  async _refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount) {
     const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
     const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+    const forceRefund = retryCount >= 2;
     const toRefund = pendingDistribution.filter(
       (pending) => pending.baseUrl !== baseUrl
     );
@@ -1732,7 +1749,8 @@ var BalanceManager = class {
         const result = await this.refundApiKey({
           mintUrl,
           baseUrl: apiKeyEntry.baseUrl,
-          apiKey: fullApiKeyEntry.key
+          apiKey: fullApiKeyEntry.key,
+          forceRefund
         });
         return { baseUrl: apiKeyEntry.baseUrl, success: result.success };
       })
@@ -1986,6 +2004,77 @@ var BalanceManager = class {
   }
 };
 
+// client/usage.ts
+function extractUsageFromResponseBody(body, fallbackSatsCost = 0) {
+  if (!body || typeof body !== "object") return null;
+  const usage = body.usage;
+  if (!usage || typeof usage !== "object") return null;
+  const promptTokens = Number(usage.prompt_tokens ?? 0);
+  const completionTokens = Number(usage.completion_tokens ?? 0);
+  const totalTokens = Number(usage.total_tokens ?? 0);
+  const costValue = usage.cost;
+  let cost = 0;
+  let satsCost = fallbackSatsCost;
+  if (typeof costValue === "number") {
+    cost = costValue;
+  } else if (costValue && typeof costValue === "object") {
+    const costObj = costValue;
+    const totalUsd = costObj.total_usd;
+    const totalMsats = costObj.total_msats;
+    cost = typeof totalUsd === "number" ? totalUsd : 0;
+    if (typeof totalMsats === "number") {
+      satsCost = totalMsats / 1e3;
+    }
+  }
+  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0 && cost === 0 && satsCost === 0) {
+    return null;
+  }
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    cost,
+    satsCost
+  };
+}
+function extractResponseId(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const id = body.id;
+  if (typeof id !== "string") return void 0;
+  const trimmed = id.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function extractUsageFromSSEJson(parsed, fallbackSatsCost = 0) {
+  if (!parsed || typeof parsed !== "object" || !parsed.usage) {
+    return null;
+  }
+  const usage = parsed.usage;
+  const usageCost = usage.cost;
+  const cost = typeof usageCost === "number" ? usageCost : usageCost?.total_usd ?? parsed.metadata?.routstr?.cost?.total_usd ?? 0;
+  const msats = parsed.metadata?.routstr?.cost?.total_msats ?? (typeof usage.cost_sats === "number" ? usage.cost_sats * 1e3 : 0);
+  const result = {
+    promptTokens: Number(usage.prompt_tokens ?? 0),
+    completionTokens: Number(usage.completion_tokens ?? 0),
+    totalTokens: Number(usage.total_tokens ?? 0),
+    cost: Number(cost ?? 0),
+    satsCost: msats > 0 ? msats / 1e3 : fallbackSatsCost
+  };
+  if (result.promptTokens === 0 && result.completionTokens === 0 && result.totalTokens === 0 && result.cost === 0 && result.satsCost === 0) {
+    return null;
+  }
+  return result;
+}
+function toUsageStats(usage) {
+  if (!usage) return void 0;
+  return {
+    total_tokens: usage.totalTokens,
+    prompt_tokens: usage.promptTokens,
+    completion_tokens: usage.completionTokens,
+    cost: usage.cost,
+    sats_cost: usage.satsCost
+  };
+}
+
 // client/StreamProcessor.ts
 var StreamProcessor = class {
   accumulatedContent = "";
@@ -2013,6 +2102,7 @@ var StreamProcessor = class {
     let finish_reason;
     let citations;
     let annotations;
+    let responseId;
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -2041,6 +2131,9 @@ var StreamProcessor = class {
           if (parsed.finish_reason) {
             finish_reason = parsed.finish_reason;
           }
+          if (parsed.responseId) {
+            responseId = parsed.responseId;
+          }
           if (parsed.citations) {
             citations = parsed.citations;
           }
@@ -2061,6 +2154,7 @@ var StreamProcessor = class {
       images: this.accumulatedImages.length > 0 ? this.accumulatedImages : void 0,
       usage,
       model,
+      responseId,
       finish_reason,
       citations,
       annotations
@@ -2088,12 +2182,15 @@ var StreamProcessor = class {
         result.reasoning = parsed.choices[0].delta.reasoning;
       }
       if (parsed.usage) {
-        result.usage = {
+        result.usage = toUsageStats(extractUsageFromSSEJson(parsed)) ?? {
           total_tokens: parsed.usage.total_tokens,
           prompt_tokens: parsed.usage.prompt_tokens,
           completion_tokens: parsed.usage.completion_tokens
         };
       }
+      if (parsed.id) {
+        result.responseId = parsed.id;
+      }
       if (parsed.model) {
         result.model = parsed.model;
       }
@@ -2541,7 +2638,6 @@ var ProviderManager = class _ProviderManager {
    * 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(
@@ -2555,9 +2651,7 @@ var ProviderManager = class _ProviderManager {
       if (torMode && !baseUrl.includes(".onion")) continue;
       if (!torMode && (baseUrl.includes(".onion") || isInsecureHttpUrl(baseUrl)))
         continue;
-      const match = models.find(
-        (model) => this.normalizeModelId(model.id) === normalizedId
-      );
+      const match = models.find((model) => model.id === modelId);
       if (!match?.sats_pricing) continue;
       const prompt = match.sats_pricing.prompt;
       const completion = match.sats_pricing.completion;
@@ -2670,1928 +2764,2602 @@ var ProviderManager = class _ProviderManager {
   }
 };
 
-// client/RoutstrClient.ts
-var TOPUP_MARGIN = 1.2;
-var RoutstrClient = class {
-  constructor(walletAdapter, storageAdapter, providerRegistry, alertLevel, mode = "xcashu") {
-    this.walletAdapter = walletAdapter;
-    this.storageAdapter = storageAdapter;
-    this.providerRegistry = providerRegistry;
-    this.balanceManager = new BalanceManager(
-      walletAdapter,
-      storageAdapter,
-      providerRegistry
-    );
-    this.cashuSpender = new CashuSpender(
-      walletAdapter,
-      storageAdapter,
-      providerRegistry,
-      this.balanceManager
-    );
-    this.streamProcessor = new StreamProcessor();
-    this.providerManager = new ProviderManager(providerRegistry);
-    this.alertLevel = alertLevel;
-    this.mode = mode;
+// storage/drivers/localStorage.ts
+var canUseLocalStorage = () => {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+};
+var isQuotaExceeded = (error) => {
+  const e = error;
+  return !!e && (e?.name === "QuotaExceededError" || e?.code === 22 || e?.code === 1014);
+};
+var NON_CRITICAL_KEYS = /* @__PURE__ */ new Set(["modelsFromAllProviders"]);
+var localStorageDriver = {
+  async getItem(key, defaultValue) {
+    if (!canUseLocalStorage()) return defaultValue;
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item === null) return defaultValue;
+      try {
+        return JSON.parse(item);
+      } catch (parseError) {
+        if (typeof defaultValue === "string") {
+          return item;
+        }
+        throw parseError;
+      }
+    } catch (error) {
+      console.error(`Error retrieving item with key "${key}":`, error);
+      if (canUseLocalStorage()) {
+        try {
+          window.localStorage.removeItem(key);
+        } catch (removeError) {
+          console.error(
+            `Error removing corrupted item with key "${key}":`,
+            removeError
+          );
+        }
+      }
+      return defaultValue;
+    }
+  },
+  async setItem(key, value) {
+    if (!canUseLocalStorage()) return;
+    try {
+      window.localStorage.setItem(key, JSON.stringify(value));
+    } catch (error) {
+      if (isQuotaExceeded(error)) {
+        if (NON_CRITICAL_KEYS.has(key)) {
+          console.warn(
+            `Storage quota exceeded; skipping non-critical key "${key}".`
+          );
+          return;
+        }
+        try {
+          window.localStorage.removeItem("modelsFromAllProviders");
+        } catch {
+        }
+        try {
+          window.localStorage.setItem(key, JSON.stringify(value));
+          return;
+        } catch (retryError) {
+          console.warn(
+            `Storage quota exceeded; unable to persist key "${key}" after cleanup attempt.`,
+            retryError
+          );
+          return;
+        }
+      }
+      console.error(`Error storing item with key "${key}":`, error);
+    }
+  },
+  async removeItem(key) {
+    if (!canUseLocalStorage()) return;
+    try {
+      window.localStorage.removeItem(key);
+    } catch (error) {
+      console.error(`Error removing item with key "${key}":`, error);
+    }
   }
-  cashuSpender;
-  balanceManager;
-  streamProcessor;
-  providerManager;
-  alertLevel;
-  mode;
-  debugLevel = "WARN";
-  /**
-   * Get the current client mode
-   */
-  getMode() {
-    return this.mode;
+};
+
+// 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);
+    }
   }
-  getDebugLevel() {
-    return this.debugLevel;
+  return {
+    async getItem(key, defaultValue) {
+      const item = store.get(key);
+      if (item === void 0) return defaultValue;
+      try {
+        return JSON.parse(item);
+      } catch (parseError) {
+        if (typeof defaultValue === "string") {
+          return item;
+        }
+        throw parseError;
+      }
+    },
+    async setItem(key, value) {
+      store.set(key, JSON.stringify(value));
+    },
+    async removeItem(key) {
+      store.delete(key);
+    }
+  };
+};
+
+// storage/drivers/sqlite.ts
+var isBun = () => {
+  return typeof process.versions.bun !== "undefined";
+};
+var createDatabase = (dbPath) => {
+  if (isBun()) {
+    throw new Error(
+      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
+    );
   }
-  setDebugLevel(level) {
-    this.debugLevel = level;
+  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})`
+    );
   }
-  _log(level, ...args) {
-    const levelPriority = {
-      DEBUG: 0,
-      WARN: 1,
-      ERROR: 2
-    };
-    if (levelPriority[level] >= levelPriority[this.debugLevel]) {
-      switch (level) {
-        case "DEBUG":
-          console.log(...args);
-          break;
-        case "WARN":
-          console.warn(...args);
-          break;
-        case "ERROR":
-          console.error(...args);
-          break;
+  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 {
+    async 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;
+      }
+    },
+    async setItem(key, value) {
+      try {
+        upsertStmt.run(key, JSON.stringify(value));
+      } catch (error) {
+        console.error(`SQLite setItem failed for key "${key}":`, error);
+      }
+    },
+    async removeItem(key) {
+      try {
+        deleteStmt.run(key);
+      } catch (error) {
+        console.error(`SQLite removeItem failed for key "${key}":`, error);
       }
     }
+  };
+};
+
+// storage/drivers/indexedDB.ts
+var isBrowser = typeof indexedDB !== "undefined";
+var openDatabase = (dbName, storeName) => {
+  if (!isBrowser) {
+    return Promise.reject(new Error("IndexedDB is not available"));
   }
-  /**
-   * Get the CashuSpender instance
-   */
-  getCashuSpender() {
-    return this.cashuSpender;
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+};
+var createIndexedDBDriver = (options = {}) => {
+  const dbName = options.dbName || "routstr-sdk";
+  const storeName = options.storeName || "sdk_storage";
+  let dbPromise = null;
+  const getDb = () => {
+    if (!dbPromise) {
+      dbPromise = openDatabase(dbName, storeName);
+    }
+    return dbPromise;
+  };
+  return {
+    async getItem(key, defaultValue) {
+      try {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+          const tx = db.transaction(storeName, "readonly");
+          const store = tx.objectStore(storeName);
+          const request = store.get(key);
+          request.onsuccess = () => {
+            const raw = request.result;
+            if (raw === void 0) {
+              resolve(defaultValue);
+              return;
+            }
+            if (typeof raw === "string") {
+              try {
+                resolve(JSON.parse(raw));
+              } catch {
+                if (typeof defaultValue === "string") {
+                  resolve(raw);
+                } else {
+                  resolve(defaultValue);
+                }
+              }
+            } else {
+              resolve(raw);
+            }
+          };
+          request.onerror = () => reject(request.error);
+        });
+      } catch (error) {
+        console.error(`IndexedDB getItem failed for key "${key}":`, error);
+        return defaultValue;
+      }
+    },
+    async setItem(key, value) {
+      try {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+          const tx = db.transaction(storeName, "readwrite");
+          const store = tx.objectStore(storeName);
+          store.put(JSON.stringify(value), key);
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => reject(tx.error);
+        });
+      } catch (error) {
+        console.error(`IndexedDB setItem failed for key "${key}":`, error);
+      }
+    },
+    async removeItem(key) {
+      try {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+          const tx = db.transaction(storeName, "readwrite");
+          const store = tx.objectStore(storeName);
+          store.delete(key);
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => reject(tx.error);
+        });
+      } catch (error) {
+        console.error(`IndexedDB 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",
+  ROUTSTR21_MODELS: "routstr21Models",
+  LAST_ROUTSTR21_MODELS_UPDATE: "lastRoutstr21ModelsUpdate",
+  CACHED_RECEIVE_TOKENS: "cached_receive_tokens",
+  USAGE_TRACKING: "usage_tracking",
+  CLIENT_IDS: "client_ids"
+};
+
+// storage/usageTracking/indexedDB.ts
+var DEFAULT_DB_NAME = "routstr-sdk";
+var DEFAULT_STORE_NAME = "usage_tracking";
+var MIGRATION_MARKER_KEY = "usage_tracking_migration_v1";
+var isBrowser2 = typeof indexedDB !== "undefined";
+var normalizeBaseUrl = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var openDatabase2 = (dbName, storeName) => {
+  if (!isBrowser2) {
+    return Promise.reject(new Error("IndexedDB is not available"));
   }
-  /**
-   * Get the BalanceManager instance
-   */
-  getBalanceManager() {
-    return this.balanceManager;
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        const store = db.createObjectStore(storeName, { keyPath: "id" });
+        store.createIndex("timestamp", "timestamp", { unique: false });
+        store.createIndex("modelId", "modelId", { unique: false });
+        store.createIndex("baseUrl", "baseUrl", { unique: false });
+        store.createIndex("sessionId", "sessionId", { unique: false });
+        store.createIndex("client", "client", { unique: false });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+};
+var matchesFilters = (entry, options = {}) => {
+  if (typeof options.before === "number" && entry.timestamp >= options.before) {
+    return false;
   }
-  /**
-   * Get the ProviderManager instance
-   */
-  getProviderManager() {
-    return this.providerManager;
+  if (typeof options.after === "number" && entry.timestamp <= options.after) {
+    return false;
   }
-  /**
-   * Check if the client is currently busy (in critical section)
-   */
-  get isBusy() {
-    return this.cashuSpender.isBusy;
+  if (options.modelId && entry.modelId !== options.modelId) {
+    return false;
   }
-  /**
-   * 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,
+  if (options.baseUrl && normalizeBaseUrl(entry.baseUrl) !== normalizeBaseUrl(options.baseUrl)) {
+    return false;
+  }
+  if (options.sessionId && entry.sessionId !== options.sessionId) {
+    return false;
+  }
+  if (options.client && entry.client !== options.client) {
+    return false;
+  }
+  return true;
+};
+var createIndexedDBUsageTrackingDriver = (options = {}) => {
+  const dbName = options.dbName || DEFAULT_DB_NAME;
+  const storeName = options.storeName || DEFAULT_STORE_NAME;
+  const legacyStorageDriver = options.legacyStorageDriver;
+  let dbPromise = null;
+  let migrationPromise = null;
+  const getDb = () => {
+    if (!dbPromise) {
+      dbPromise = openDatabase2(dbName, storeName);
+    }
+    return dbPromise;
+  };
+  const putMany = async (entries) => {
+    if (entries.length === 0) return;
+    const db = await getDb();
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(storeName, "readwrite");
+      const store = tx.objectStore(storeName);
+      for (const entry of entries) {
+        store.put({ ...entry, baseUrl: normalizeBaseUrl(entry.baseUrl) });
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  };
+  const ensureMigrated = async () => {
+    if (!legacyStorageDriver) return;
+    if (!migrationPromise) {
+      migrationPromise = (async () => {
+        const migrated = await legacyStorageDriver.getItem(
+          MIGRATION_MARKER_KEY,
+          false
+        );
+        if (migrated) return;
+        const legacyEntries = await legacyStorageDriver.getItem(
+          SDK_STORAGE_KEYS.USAGE_TRACKING,
           []
         );
-      }
+        if (legacyEntries.length > 0) {
+          await putMany(legacyEntries);
+          await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
+        }
+        await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY, true);
+      })();
     }
-    const { token, tokenBalance, tokenBalanceUnit } = await this._spendToken({
-      mintUrl,
-      amount: requiredSats,
-      baseUrl
-    });
-    this._log("DEBUG", token, baseUrl);
-    let requestBody = body;
-    if (body && typeof body === "object") {
-      const bodyObj = body;
-      if (!bodyObj.stream) {
-        requestBody = { ...bodyObj, stream: false };
-      }
+    await migrationPromise;
+  };
+  return {
+    async migrate() {
+      await ensureMigrated();
+    },
+    async append(entry) {
+      await ensureMigrated();
+      await putMany([entry]);
+    },
+    async appendMany(entries) {
+      await ensureMigrated();
+      await putMany(entries);
+    },
+    async list(options2 = {}) {
+      await ensureMigrated();
+      const db = await getDb();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readonly");
+        const store = tx.objectStore(storeName);
+        const index = store.index("timestamp");
+        const direction = "prev";
+        const request = index.openCursor(null, direction);
+        const results = [];
+        const limit = options2.limit;
+        request.onsuccess = () => {
+          const cursor = request.result;
+          if (!cursor) {
+            resolve(results);
+            return;
+          }
+          const value = cursor.value;
+          if (matchesFilters(value, options2)) {
+            results.push(value);
+            if (typeof limit === "number" && results.length >= limit) {
+              resolve(results);
+              return;
+            }
+          }
+          cursor.continue();
+        };
+        request.onerror = () => reject(request.error);
+      });
+    },
+    async count(options2 = {}) {
+      const results = await this.list(options2);
+      return results.length;
+    },
+    async deleteOlderThan(timestamp) {
+      await ensureMigrated();
+      const db = await getDb();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readwrite");
+        const store = tx.objectStore(storeName);
+        const index = store.index("timestamp");
+        const range = IDBKeyRange.upperBound(timestamp, true);
+        const request = index.openCursor(range);
+        let deleted = 0;
+        request.onsuccess = () => {
+          const cursor = request.result;
+          if (!cursor) {
+            resolve(deleted);
+            return;
+          }
+          deleted += 1;
+          cursor.delete();
+          cursor.continue();
+        };
+        request.onerror = () => reject(request.error);
+      });
+    },
+    async clear() {
+      await ensureMigrated();
+      const db = await getDb();
+      await new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readwrite");
+        tx.objectStore(storeName).clear();
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+      });
     }
-    const baseHeaders = this._buildBaseHeaders(headers);
-    const requestHeaders = this._withAuthHeader(baseHeaders, token);
-    const response = await this._makeRequest({
-      path,
-      method,
-      body: method === "GET" ? void 0 : requestBody,
-      baseUrl,
-      mintUrl,
-      token,
-      requiredSats,
-      headers: requestHeaders,
-      baseHeaders,
-      selectedModel
-    });
-    const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
-    const baseUrlUsed = response.baseUrl || baseUrl;
-    const tokenUsed = response.token || token;
-    await this._handlePostResponseBalanceUpdate({
-      token: tokenUsed,
-      baseUrl: baseUrlUsed,
-      initialTokenBalance: tokenBalanceInSats,
-      response
-    });
-    return response;
+  };
+};
+
+// storage/usageTracking/sqlite.ts
+var MIGRATION_MARKER_KEY2 = "usage_tracking_migration_v1";
+var normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var isBun2 = () => {
+  return typeof process.versions.bun !== "undefined";
+};
+var createDatabase2 = (dbPath) => {
+  if (isBun2()) {
+    throw new Error(
+      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
+    );
   }
-  /**
-   * 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
+  let Database = null;
+  try {
+    Database = __require("better-sqlite3");
+  } catch (error) {
+    throw new Error(
+      `better-sqlite3 is required for sqlite usage tracking. Install it to use sqlite storage. (${error})`
     );
-    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;
+  }
+  return new Database(dbPath);
+};
+var buildWhereClause = (options = {}) => {
+  const clauses = [];
+  const params = [];
+  if (typeof options.before === "number") {
+    clauses.push("timestamp < ?");
+    params.push(options.before);
+  }
+  if (typeof options.after === "number") {
+    clauses.push("timestamp > ?");
+    params.push(options.after);
+  }
+  if (options.modelId) {
+    clauses.push("model_id = ?");
+    params.push(options.modelId);
+  }
+  if (options.baseUrl) {
+    clauses.push("base_url = ?");
+    params.push(normalizeBaseUrl2(options.baseUrl));
+  }
+  if (options.sessionId) {
+    clauses.push("session_id = ?");
+    params.push(options.sessionId);
+  }
+  if (options.client) {
+    clauses.push("client = ?");
+    params.push(options.client);
+  }
+  return {
+    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
+    params
+  };
+};
+var createSqliteUsageTrackingDriver = (options = {}) => {
+  const dbPath = options.dbPath || "routstr.sqlite";
+  const tableName = options.tableName || "usage_tracking";
+  const db = createDatabase2(dbPath);
+  const legacyStorageDriver = options.legacyStorageDriver;
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ${tableName} (
+      id TEXT PRIMARY KEY,
+      timestamp INTEGER NOT NULL,
+      model_id TEXT NOT NULL,
+      base_url TEXT NOT NULL,
+      request_id TEXT NOT NULL,
+      cost REAL NOT NULL,
+      sats_cost REAL NOT NULL,
+      prompt_tokens INTEGER NOT NULL,
+      completion_tokens INTEGER NOT NULL,
+      total_tokens INTEGER NOT NULL,
+      client TEXT,
+      session_id TEXT,
+      tags TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id);
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url);
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_session_id ON ${tableName}(session_id);
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_client ON ${tableName}(client);
+  `);
+  const insertStmt = db.prepare(`
+    INSERT OR REPLACE INTO ${tableName} (
+      id, timestamp, model_id, base_url, request_id,
+      cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
+      client, session_id, tags
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  let migrationComplete = false;
+  const appendOne = (entry) => {
+    insertStmt.run(
+      entry.id,
+      entry.timestamp,
+      entry.modelId,
+      normalizeBaseUrl2(entry.baseUrl),
+      entry.requestId,
+      entry.cost,
+      entry.satsCost,
+      entry.promptTokens,
+      entry.completionTokens,
+      entry.totalTokens,
+      entry.client ?? null,
+      entry.sessionId ?? null,
+      JSON.stringify(entry.tags ?? [])
+    );
+  };
+  const ensureMigrated = async () => {
+    if (!legacyStorageDriver || migrationComplete) return;
+    const migrated = await legacyStorageDriver.getItem(
+      MIGRATION_MARKER_KEY2,
+      false
+    );
+    if (migrated) {
+      migrationComplete = true;
+      return;
+    }
+    const legacyEntries = await legacyStorageDriver.getItem(
+      SDK_STORAGE_KEYS.USAGE_TRACKING,
+      []
+    );
+    for (const entry of legacyEntries) {
+      appendOne(entry);
+    }
+    if (legacyEntries.length > 0) {
+      await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
+    }
+    await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY2, true);
+    migrationComplete = true;
+  };
+  const mapRow = (row) => ({
+    id: row.id,
+    timestamp: row.timestamp,
+    modelId: row.model_id,
+    baseUrl: row.base_url,
+    requestId: row.request_id,
+    cost: row.cost,
+    satsCost: row.sats_cost,
+    promptTokens: row.prompt_tokens,
+    completionTokens: row.completion_tokens,
+    totalTokens: row.total_tokens,
+    client: row.client ?? void 0,
+    sessionId: row.session_id ?? void 0,
+    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
+  });
+  return {
+    async migrate() {
+      await ensureMigrated();
+    },
+    async append(entry) {
+      await ensureMigrated();
+      appendOne(entry);
+    },
+    async appendMany(entries) {
+      await ensureMigrated();
+      for (const entry of entries) {
+        appendOne(entry);
       }
-      if (selectedModel?.name?.startsWith("OpenAI:")) {
-        body.tools = [{ type: "web_search" }];
+    },
+    async list(options2 = {}) {
+      await ensureMigrated();
+      const { sql, params } = buildWhereClause(options2);
+      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
+      const stmt = db.prepare(
+        `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`
+      );
+      const rows = stmt.all(
+        ...typeof options2.limit === "number" ? [...params, options2.limit] : params
+      );
+      return rows.map(mapRow);
+    },
+    async count(options2 = {}) {
+      await ensureMigrated();
+      const { sql, params } = buildWhereClause(options2);
+      const stmt = db.prepare(`SELECT COUNT(*) as count FROM ${tableName} ${sql}`);
+      const row = stmt.get(...params);
+      return Number(row?.count ?? 0);
+    },
+    async deleteOlderThan(timestamp) {
+      await ensureMigrated();
+      const stmt = db.prepare(`DELETE FROM ${tableName} WHERE timestamp < ?`);
+      const result = stmt.run(timestamp);
+      return result.changes;
+    },
+    async clear() {
+      await ensureMigrated();
+      db.prepare(`DELETE FROM ${tableName}`).run();
+    }
+  };
+};
+
+// storage/usageTracking/memory.ts
+var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var matchesFilters2 = (entry, options = {}) => {
+  if (typeof options.before === "number" && entry.timestamp >= options.before) {
+    return false;
+  }
+  if (typeof options.after === "number" && entry.timestamp <= options.after) {
+    return false;
+  }
+  if (options.modelId && entry.modelId !== options.modelId) {
+    return false;
+  }
+  if (options.baseUrl && normalizeBaseUrl3(entry.baseUrl) !== normalizeBaseUrl3(options.baseUrl)) {
+    return false;
+  }
+  if (options.sessionId && entry.sessionId !== options.sessionId) {
+    return false;
+  }
+  if (options.client && entry.client !== options.client) {
+    return false;
+  }
+  return true;
+};
+var createMemoryUsageTrackingDriver = (seed = []) => {
+  const store = /* @__PURE__ */ new Map();
+  for (const entry of seed) {
+    store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl3(entry.baseUrl) });
+  }
+  return {
+    async migrate() {
+      return;
+    },
+    async append(entry) {
+      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl3(entry.baseUrl) });
+    },
+    async appendMany(entries) {
+      for (const entry of entries) {
+        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl3(entry.baseUrl) });
       }
-      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");
+    },
+    async list(options = {}) {
+      const entries = [...store.values()].filter((entry) => matchesFilters2(entry, options)).sort((a, b) => b.timestamp - a.timestamp);
+      if (typeof options.limit === "number") {
+        return entries.slice(0, options.limit);
       }
-      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."
-          });
+      return entries;
+    },
+    async count(options = {}) {
+      return (await this.list(options)).length;
+    },
+    async deleteOlderThan(timestamp) {
+      let deleted = 0;
+      for (const [id, entry] of store.entries()) {
+        if (entry.timestamp < timestamp) {
+          store.delete(id);
+          deleted += 1;
         }
-        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);
+      return deleted;
+    },
+    async clear() {
+      store.clear();
     }
-  }
-  /**
-   * Make the API request with failover support
-   */
-  async _makeRequest(params) {
-    const { path, method, body, baseUrl, token, headers } = params;
-    try {
-      const url = `${baseUrl.replace(/\/$/, "")}${path}`;
-      if (this.mode === "xcashu") this._log("DEBUG", "HEADERS,", headers);
-      this._log("DEBUG", "HEADERS,", headers);
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: body === void 0 || method === "GET" ? void 0 : JSON.stringify(body)
-      });
-      if (this.mode === "xcashu") this._log("DEBUG", "response,", response);
-      response.baseUrl = baseUrl;
-      response.token = token;
-      if (!response.ok) {
-        const requestId = response.headers.get("x-routstr-request-id") || void 0;
-        let bodyText;
-        try {
-          bodyText = await response.text();
-        } catch (e) {
-          bodyText = void 0;
-        }
-        return await this._handleErrorResponse(
-          params,
-          token,
-          response.status,
-          requestId,
-          this.mode === "xcashu" ? response.headers.get("x-cashu") ?? void 0 : void 0,
-          bodyText,
-          params.retryCount ?? 0
-        );
-      }
-      return response;
-    } catch (error) {
-      if (isNetworkErrorMessage(error?.message || "")) {
-        return await this._handleErrorResponse(
-          params,
-          token,
-          -1,
-          // just for Network Error to skip all statuses
-          void 0,
-          void 0,
-          void 0,
-          params.retryCount ?? 0
-        );
-      }
-      throw error;
+  };
+};
+var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var getCashuTokenBalance = (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;
   }
-  /**
-   * Handle error responses with failover
-   */
-  async _handleErrorResponse(params, token, status, requestId, xCashuRefundToken, responseBody, retryCount = 0) {
-    const MAX_RETRIES_PER_PROVIDER = 2;
-    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
-    let tryNextProvider = false;
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: status=${status}, baseUrl=${baseUrl}, mode=${this.mode}, token preview=${token}, requestId=${requestId}`
-    );
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: Attempting to receive/restore token for ${baseUrl}`
-    );
-    if (params.token.startsWith("cashu")) {
-      const tryReceiveTokenResult = await this.cashuSpender.receiveToken(
-        params.token
-      );
-      if (tryReceiveTokenResult.success) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
-        );
-        tryNextProvider = true;
-        if (this.mode === "lazyrefund")
-          this.storageAdapter.removeToken(baseUrl);
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Failed to receive token. `
-        );
-      }
-    }
-    if (this.mode === "xcashu") {
-      if (xCashuRefundToken) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Attempting to receive xcashu refund token, preview=${xCashuRefundToken.substring(0, 20)}...`
-        );
-        try {
-          const receiveResult = await this.cashuSpender.receiveToken(xCashuRefundToken);
-          if (receiveResult.success) {
-            this._log(
-              "DEBUG",
-              `[RoutstrClient] _handleErrorResponse: xcashu refund received, amount=${receiveResult.amount}`
-            );
-            tryNextProvider = true;
-          } else
-            throw new ProviderError(
-              baseUrl,
-              status,
-              "xcashu refund failed",
-              requestId
-            );
-        } catch (error) {
-          this._log("ERROR", "[xcashu] Failed to receive refund token:", error);
-          throw new ProviderError(
-            baseUrl,
-            status,
-            "[xcashu] Failed to receive refund token",
-            requestId
-          );
-        }
-      } else {
-        if (!tryNextProvider)
-          throw new ProviderError(
-            baseUrl,
-            status,
-            "[xcashu] Failed to receive refund token",
-            requestId
-          );
-      }
+};
+var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
+  modelsFromAllProviders: {},
+  lastUsedModel: null,
+  baseUrlsList: [],
+  lastBaseUrlsUpdate: null,
+  disabledProviders: [],
+  mintsFromAllProviders: {},
+  infoFromAllProviders: {},
+  lastModelsUpdate: {},
+  cachedTokens: [],
+  apiKeys: [],
+  childKeys: [],
+  routstr21Models: [],
+  lastRoutstr21ModelsUpdate: null,
+  cachedReceiveTokens: [],
+  clientIds: [],
+  setModelsFromAllProviders: (value) => {
+    const normalized = {};
+    for (const [baseUrl, models] of Object.entries(value)) {
+      normalized[normalizeBaseUrl4(baseUrl)] = models;
     }
-    if (status === 402 && !tryNextProvider && (this.mode === "apikeys" || this.mode === "lazyrefund")) {
-      this.storageAdapter.getApiKey(baseUrl);
-      let topupAmount = params.requiredSats;
-      try {
-        let currentBalance = 0;
-        if (this.mode === "apikeys") {
-          const currentBalanceInfo = await this.balanceManager.getTokenBalance(
-            params.token,
-            baseUrl
-          );
-          currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
-        } else if (this.mode === "lazyrefund") {
-          const distribution = this.storageAdapter.getCachedTokenDistribution();
-          const tokenEntry = distribution.find((t) => t.baseUrl === baseUrl);
-          currentBalance = tokenEntry?.amount ?? 0;
-        }
-        const shortfall = Math.max(0, params.requiredSats - currentBalance);
-        topupAmount = shortfall > 0 ? shortfall : params.requiredSats;
-      } catch (e) {
-        this._log(
-          "WARN",
-          "Could not get current token balance for topup calculation:",
-          e
-        );
-      }
-      const topupResult = await this.balanceManager.topUp({
-        mintUrl,
-        baseUrl,
-        amount: topupAmount * TOPUP_MARGIN,
-        token: params.token
-      });
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Topup result for ${baseUrl}: success=${topupResult.success}, message=${topupResult.message}`
+    void driver.setItem(
+      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
+      normalized
+    );
+    set({ modelsFromAllProviders: normalized });
+  },
+  setLastUsedModel: (value) => {
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
+    set({ lastUsedModel: value });
+  },
+  setBaseUrlsList: (value) => {
+    const normalized = value.map((url) => normalizeBaseUrl4(url));
+    void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
+    set({ baseUrlsList: normalized });
+  },
+  setBaseUrlsLastUpdate: (value) => {
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
+    set({ lastBaseUrlsUpdate: value });
+  },
+  setDisabledProviders: (value) => {
+    const normalized = value.map((url) => normalizeBaseUrl4(url));
+    void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
+    set({ disabledProviders: normalized });
+  },
+  setMintsFromAllProviders: (value) => {
+    const normalized = {};
+    for (const [baseUrl, mints] of Object.entries(value)) {
+      normalized[normalizeBaseUrl4(baseUrl)] = mints.map(
+        (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
       );
-      if (!topupResult.success) {
-        const message = topupResult.message || "";
-        if (message.includes("Insufficient balance")) {
-          const needMatch = message.match(/need (\d+)/);
-          const haveMatch = message.match(/have (\d+)/);
-          const required = needMatch ? parseInt(needMatch[1], 10) : params.requiredSats;
-          const available = haveMatch ? parseInt(haveMatch[1], 10) : 0;
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
-          );
-          throw new InsufficientBalanceError(
-            required,
-            available,
-            0,
-            "",
-            message
-          );
-        } else {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Topup failed with non-insufficient-balance error, will try next provider`
-          );
-          tryNextProvider = true;
-        }
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Topup successful, will retry with new token`
-        );
-      }
-      if (!tryNextProvider) {
-        if (retryCount < MAX_RETRIES_PER_PROVIDER) {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Retrying 402 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
-          );
-          return this._makeRequest({
-            ...params,
-            token: params.token,
-            headers: this._withAuthHeader(params.baseHeaders, params.token),
-            retryCount: retryCount + 1
-          });
-        } else {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: 402 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
-          );
-          tryNextProvider = true;
-        }
-      }
     }
-    const isInsufficientBalance413 = status === 413 && responseBody?.includes("Insufficient balance");
-    if (isInsufficientBalance413 && !tryNextProvider && this.mode === "apikeys") {
-      let retryToken = params.token;
-      try {
-        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-          params.token,
-          baseUrl
-        );
-        if (latestBalanceInfo.isInvalidApiKey) {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Invalid API key (proofs already spent), removing for ${baseUrl}`
-          );
-          this.storageAdapter.removeApiKey(baseUrl);
-          tryNextProvider = true;
-        } else {
-          const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
-          if (latestBalanceInfo.apiKey) {
-            const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
-            if (storedApiKeyEntry?.key !== latestBalanceInfo.apiKey) {
-              if (storedApiKeyEntry) {
-                this.storageAdapter.removeApiKey(baseUrl);
-              }
-              this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
-            }
-            retryToken = latestBalanceInfo.apiKey;
-          }
-          if (latestTokenBalance >= 0) {
-            this.storageAdapter.updateApiKeyBalance(
-              baseUrl,
-              latestTokenBalance
-            );
-          }
-        }
-      } catch (error) {
-        this._log(
-          "WARN",
-          `[RoutstrClient] _handleErrorResponse: Failed to refresh API key after 413 insufficient balance for ${baseUrl}`,
-          error
-        );
-      }
-      if (retryCount < MAX_RETRIES_PER_PROVIDER) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Retrying 413 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
-        );
-        return this._makeRequest({
-          ...params,
-          token: retryToken,
-          headers: this._withAuthHeader(params.baseHeaders, retryToken),
-          retryCount: retryCount + 1
-        });
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: 413 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
-        );
-        tryNextProvider = true;
-      }
+    void driver.setItem(
+      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+      normalized
+    );
+    set({ mintsFromAllProviders: normalized });
+  },
+  setInfoFromAllProviders: (value) => {
+    const normalized = {};
+    for (const [baseUrl, info] of Object.entries(value)) {
+      normalized[normalizeBaseUrl4(baseUrl)] = info;
     }
-    if ((status === 401 || status === 403 || status === 413 || status === 400 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Status ${status} (auth/server error), attempting refund for ${baseUrl}, mode=${this.mode}`
-      );
-      if (this.mode === "lazyrefund") {
-        try {
-          const refundResult = await this.balanceManager.refund({
-            mintUrl,
-            baseUrl,
-            token: params.token
-          });
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Lazyrefund result: success=${refundResult.success}`
-          );
-          if (refundResult.success) this.storageAdapter.removeToken(baseUrl);
-          else
-            throw new ProviderError(
-              baseUrl,
-              status,
-              "refund failed",
-              requestId
-            );
-        } catch (error) {
-          throw new ProviderError(
-            baseUrl,
-            status,
-            "Failed to refund token",
-            requestId
-          );
-        }
-      } else if (this.mode === "apikeys") {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`
-        );
-        const initialBalance = await this.balanceManager.getTokenBalance(
-          token,
-          baseUrl
-        );
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${initialBalance.amount}`
-        );
-        const refundResult = await this.balanceManager.refundApiKey({
-          mintUrl,
-          baseUrl,
-          apiKey: token
-        });
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
-        );
-        if (!refundResult.success && initialBalance.amount > 0) {
-          throw new ProviderError(
-            baseUrl,
-            status,
-            refundResult.message ?? "Unknown error"
-          );
-        }
-      }
-    }
-    this.providerManager.markFailed(baseUrl);
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: Marked provider ${baseUrl} as failed`
-    );
-    if (!selectedModel) {
-      throw new ProviderError(
-        baseUrl,
-        status,
-        "Funny, no selected model. HMM. "
-      );
-    }
-    const nextProvider = this.providerManager.findNextBestProvider(
-      selectedModel.id,
-      baseUrl
-    );
-    if (nextProvider) {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Failing over to next provider: ${nextProvider}, model: ${selectedModel.id}`
-      );
-      const newModel = await this.providerManager.getModelForProvider(
-        nextProvider,
-        selectedModel.id
-      ) ?? selectedModel;
-      const messagesForPricing = Array.isArray(
-        body?.messages
-      ) ? body.messages : [];
-      const newRequiredSats = this.providerManager.getRequiredSatsForModel(
-        newModel,
-        messagesForPricing,
-        params.maxTokens
-      );
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Creating new token for failover provider ${nextProvider}, required sats: ${newRequiredSats}`
-      );
-      const spendResult = await this._spendToken({
-        mintUrl,
-        amount: newRequiredSats,
-        baseUrl: nextProvider
-      });
-      return this._makeRequest({
-        ...params,
-        path,
-        method,
-        body,
-        baseUrl: nextProvider,
-        selectedModel: newModel,
-        token: spendResult.token,
-        requiredSats: newRequiredSats,
-        headers: this._withAuthHeader(params.baseHeaders, spendResult.token),
-        retryCount: 0
-      });
-    }
-    throw new FailoverError(
-      baseUrl,
-      Array.from(this.providerManager.getFailedProviders())
-    );
-  }
-  /**
-   * Handle post-response balance update for all modes
-   */
-  async _handlePostResponseBalanceUpdate(params) {
-    const { token, baseUrl, 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.cashuSpender.receiveToken(refundToken);
-          satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
-        } catch (error) {
-          this._log("ERROR", "[xcashu] Failed to receive refund token:", error);
-        }
-      }
-    } else if (this.mode === "lazyrefund") {
-      const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-        token,
-        baseUrl
-      );
-      const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
-      this.storageAdapter.updateTokenBalance(baseUrl, latestTokenBalance);
-      satsSpent = initialTokenBalance - latestTokenBalance;
-    } else if (this.mode === "apikeys") {
-      try {
-        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-          token,
-          baseUrl
-        );
-        this._log(
-          "DEBUG",
-          "LATEST Balance",
-          latestBalanceInfo.amount,
-          latestBalanceInfo.reserved,
-          latestBalanceInfo.apiKey,
-          baseUrl
-        );
-        const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
-        const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
-        if (storedApiKeyEntry?.key.startsWith("cashu") && latestBalanceInfo.apiKey) {
-          this.storageAdapter.removeApiKey(baseUrl);
-          this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
-        }
-        this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
-        satsSpent = initialTokenBalance - latestTokenBalance;
-      } catch (e) {
-        this._log("WARN", "Could not get updated API key balance:", e);
-        satsSpent = fallbackSatsSpent ?? initialTokenBalance;
-      }
-    }
-    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
-      };
+    void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
+    set({ infoFromAllProviders: normalized });
+  },
+  setLastModelsUpdate: (value) => {
+    const normalized = {};
+    for (const [baseUrl, timestamp] of Object.entries(value)) {
+      normalized[normalizeBaseUrl4(baseUrl)] = timestamp;
     }
-    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
-      })
+    void 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: normalizeBaseUrl4(entry.baseUrl),
+        balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
+        lastUsed: entry.lastUsed ?? null
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, normalized);
+      return { cachedTokens: normalized };
     });
-    if (!response.ok) {
-      throw new Error(
-        `Failed to create child key: ${response.status} ${await response.text()}`
-      );
-    }
-    const data = await response.json();
-    return {
-      childKey: data.api_keys?.[0],
-      balance: data.balance ?? 0,
-      balanceLimit: data.balance_limit,
-      validityDate: data.validity_date
-    };
-  }
-  /**
-   * Calculate estimated costs from usage
-   */
-  _getEstimatedCosts(selectedModel, streamingResult) {
-    let estimatedCosts = 0;
-    if (streamingResult.usage) {
-      const { completion_tokens, prompt_tokens } = streamingResult.usage;
-      if (completion_tokens !== void 0 && prompt_tokens !== void 0) {
-        estimatedCosts = (selectedModel.sats_pricing?.completion ?? 0) * completion_tokens + (selectedModel.sats_pricing?.prompt ?? 0) * prompt_tokens;
-      }
-    }
-    return estimatedCosts;
-  }
-  /**
-   * Get pending cashu token amount
-   */
-  _getPendingCashuTokenAmount() {
-    const distribution = this.storageAdapter.getCachedTokenDistribution();
-    return distribution.reduce((total, item) => total + item.amount, 0);
-  }
-  /**
-   * Handle errors and notify callbacks
-   */
-  _handleError(error, callbacks) {
-    this._log("ERROR", "[RoutstrClient] _handleError: Error occurred", error);
-    if (error instanceof Error) {
-      const isStreamError = error.message.includes("Error in input stream") || error.message.includes("Load failed");
-      const modifiedErrorMsg = isStreamError ? "AI stream was cut off, turn on Keep Active or please try again" : error.message;
-      this._log(
-        "ERROR",
-        `[RoutstrClient] _handleError: Error type=${error.constructor.name}, message=${modifiedErrorMsg}, isStreamError=${isStreamError}`
-      );
-      callbacks.onMessageAppend({
-        role: "system",
-        content: "Uncaught Error: " + modifiedErrorMsg + (this.alertLevel === "max" ? " | " + error.stack : "")
-      });
-    } else {
-      callbacks.onMessageAppend({
-        role: "system",
-        content: "Unknown Error: Please tag Routstr on Nostr and/or retry."
-      });
-    }
-  }
-  /**
-   * Check wallet balance and throw if insufficient
-   */
-  async _checkBalance() {
-    const balances = await this.walletAdapter.getBalances();
-    const totalBalance = Object.values(balances).reduce((sum, v) => sum + v, 0);
-    if (totalBalance <= 0) {
-      throw new InsufficientBalanceError(1, 0);
-    }
-  }
-  /**
-   * Spend a token using CashuSpender with standardized error handling
-   */
-  async _spendToken(params) {
-    const { mintUrl, amount, baseUrl } = params;
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _spendToken: mode=${this.mode}, amount=${amount}, baseUrl=${baseUrl}, mintUrl=${mintUrl}`
-    );
-    if (this.mode === "apikeys") {
-      let parentApiKey = this.storageAdapter.getApiKey(baseUrl);
-      if (!parentApiKey) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: No existing API key for ${baseUrl}, creating new one via Cashu`
-        );
-        const spendResult2 = await this.cashuSpender.spend({
-          mintUrl,
-          amount: amount * TOPUP_MARGIN,
-          baseUrl: "",
-          reuseToken: false
-        });
-        if (!spendResult2.token) {
-          this._log(
-            "ERROR",
-            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error:`,
-            spendResult2.error
-          );
-          throw new Error(
-            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error: ${spendResult2.error}`
-          );
-        } else {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult2.token}`
-          );
-        }
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: Created API key for ${baseUrl}, key preview: ${spendResult2.token}, balance: ${spendResult2.balance}`
-        );
-        try {
-          this.storageAdapter.setApiKey(baseUrl, spendResult2.token);
-        } catch (error) {
-          if (error instanceof Error && error.message.includes("ApiKey already exists")) {
-            const tryReceiveTokenResult = await this.cashuSpender.receiveToken(
-              spendResult2.token
-            );
-            if (tryReceiveTokenResult.success) {
-              this._log(
-                "DEBUG",
-                `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
-              );
-            } else {
-              this._log(
-                "DEBUG",
-                `[RoutstrClient] _handleErrorResponse: Token restore failed or not needed`
-              );
-            }
-            this._log(
-              "DEBUG",
-              `[RoutstrClient] _spendToken: API key already exists for ${baseUrl}, using existing key`
-            );
-          } else {
-            throw error;
-          }
-        }
-        parentApiKey = this.storageAdapter.getApiKey(baseUrl);
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: Using existing API key for ${baseUrl}, key preview: ${parentApiKey.key}`
-        );
-      }
-      let tokenBalance = 0;
-      let tokenBalanceUnit = "sat";
-      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-      const distributionForBaseUrl = apiKeyDistribution.find(
-        (d) => d.baseUrl === baseUrl
-      );
-      if (distributionForBaseUrl) {
-        tokenBalance = distributionForBaseUrl.amount;
-      }
-      if (tokenBalance === 0 && parentApiKey) {
-        try {
-          const balanceInfo = await this.balanceManager.getTokenBalance(
-            parentApiKey.key,
-            baseUrl
-          );
-          tokenBalance = balanceInfo.amount;
-          tokenBalanceUnit = balanceInfo.unit;
-        } catch (e) {
-          this._log("WARN", "Could not get initial API key balance:", e);
-        }
-      }
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _spendToken: Returning token with balance=${tokenBalance} ${tokenBalanceUnit}`
-      );
-      return {
-        token: parentApiKey?.key ?? "",
-        tokenBalance,
-        tokenBalanceUnit
-      };
-    }
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _spendToken: Calling CashuSpender.spend for amount=${amount}, mintUrl=${mintUrl}, mode=${this.mode}`
-    );
-    const spendResult = await this.cashuSpender.spend({
-      mintUrl,
-      amount,
-      baseUrl: this.mode === "lazyrefund" ? baseUrl : "",
-      reuseToken: this.mode === "lazyrefund"
+  },
+  setApiKeys: (value) => {
+    set((state) => {
+      const updates = typeof value === "function" ? value(state.apiKeys) : value;
+      const normalized = updates.map((entry) => ({
+        ...entry,
+        baseUrl: normalizeBaseUrl4(entry.baseUrl),
+        balance: entry.balance ?? 0,
+        lastUsed: entry.lastUsed ?? null
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.API_KEYS, normalized);
+      return { apiKeys: normalized };
     });
-    if (!spendResult.token) {
-      this._log(
-        "ERROR",
-        `[RoutstrClient] _spendToken: CashuSpender.spend failed, error:`,
-        spendResult.error
-      );
-    } else {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult.token}, balance: ${spendResult.balance} ${spendResult.unit ?? "sat"}`
-      );
-    }
-    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 = {
-  async getItem(key, defaultValue) {
-    if (!canUseLocalStorage()) return defaultValue;
-    try {
-      const item = window.localStorage.getItem(key);
-      if (item === null) return defaultValue;
-      try {
-        return JSON.parse(item);
-      } catch (parseError) {
-        if (typeof defaultValue === "string") {
-          return item;
-        }
-        throw parseError;
-      }
-    } catch (error) {
-      console.error(`Error retrieving item with key "${key}":`, error);
-      if (canUseLocalStorage()) {
-        try {
-          window.localStorage.removeItem(key);
-        } catch (removeError) {
-          console.error(
-            `Error removing corrupted item with key "${key}":`,
-            removeError
-          );
-        }
-      }
-      return defaultValue;
-    }
   },
-  async setItem(key, value) {
-    if (!canUseLocalStorage()) return;
-    try {
-      window.localStorage.setItem(key, JSON.stringify(value));
-    } catch (error) {
-      if (isQuotaExceeded(error)) {
-        if (NON_CRITICAL_KEYS.has(key)) {
-          console.warn(
-            `Storage quota exceeded; skipping non-critical key "${key}".`
-          );
-          return;
-        }
-        try {
-          window.localStorage.removeItem("modelsFromAllProviders");
-        } catch {
-        }
-        try {
-          window.localStorage.setItem(key, JSON.stringify(value));
-          return;
-        } catch (retryError) {
-          console.warn(
-            `Storage quota exceeded; unable to persist key "${key}" after cleanup attempt.`,
-            retryError
-          );
-          return;
-        }
-      }
-      console.error(`Error storing item with key "${key}":`, error);
-    }
+  setChildKeys: (value) => {
+    set((state) => {
+      const updates = typeof value === "function" ? value(state.childKeys) : value;
+      const normalized = updates.map((entry) => ({
+        parentBaseUrl: normalizeBaseUrl4(entry.parentBaseUrl),
+        childKey: entry.childKey,
+        balance: entry.balance ?? 0,
+        balanceLimit: entry.balanceLimit,
+        validityDate: entry.validityDate,
+        createdAt: entry.createdAt ?? Date.now()
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
+      return { childKeys: normalized };
+    });
   },
-  async removeItem(key) {
-    if (!canUseLocalStorage()) return;
-    try {
-      window.localStorage.removeItem(key);
-    } catch (error) {
-      console.error(`Error removing item with key "${key}":`, error);
-    }
+  setRoutstr21Models: (value) => {
+    void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
+    set({ routstr21Models: value });
+  },
+  setRoutstr21ModelsLastUpdate: (value) => {
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE, value);
+    set({ lastRoutstr21ModelsUpdate: value });
+  },
+  setCachedReceiveTokens: (value) => {
+    const normalized = value.map((entry) => ({
+      token: entry.token,
+      amount: entry.amount,
+      unit: entry.unit || "sat",
+      createdAt: entry.createdAt ?? Date.now()
+    }));
+    void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
+    set({ cachedReceiveTokens: normalized });
+  },
+  setClientIds: (value) => {
+    set((state) => {
+      const updates = typeof value === "function" ? value(state.clientIds) : value;
+      const normalized = updates.map((entry) => ({
+        ...entry,
+        createdAt: entry.createdAt ?? Date.now(),
+        lastUsed: entry.lastUsed ?? null
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.CLIENT_IDS, normalized);
+      return { clientIds: normalized };
+    });
   }
+}));
+var hydrateStoreFromDriver = async (store, driver) => {
+  const [
+    rawModels,
+    lastUsedModel,
+    rawBaseUrls,
+    lastBaseUrlsUpdate,
+    rawDisabledProviders,
+    rawMints,
+    rawInfo,
+    rawLastModelsUpdate,
+    rawCachedTokens,
+    rawApiKeys,
+    rawChildKeys,
+    rawRoutstr21Models,
+    rawLastRoutstr21ModelsUpdate,
+    rawCachedReceiveTokens,
+    rawClientIds
+  ] = await Promise.all([
+    driver.getItem(
+      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, null),
+    driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, null),
+    driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []),
+    driver.getItem(
+      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(
+      SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(
+      SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
+      {}
+    ),
+    driver.getItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, []),
+    driver.getItem(SDK_STORAGE_KEYS.API_KEYS, []),
+    driver.getItem(SDK_STORAGE_KEYS.CHILD_KEYS, []),
+    driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
+    driver.getItem(
+      SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
+      null
+    ),
+    driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
+    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, [])
+  ]);
+  const modelsFromAllProviders = Object.fromEntries(
+    Object.entries(rawModels).map(([baseUrl, models]) => [
+      normalizeBaseUrl4(baseUrl),
+      models
+    ])
+  );
+  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl4(url));
+  const disabledProviders = rawDisabledProviders.map(
+    (url) => normalizeBaseUrl4(url)
+  );
+  const mintsFromAllProviders = Object.fromEntries(
+    Object.entries(rawMints).map(([baseUrl, mints]) => [
+      normalizeBaseUrl4(baseUrl),
+      mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
+    ])
+  );
+  const infoFromAllProviders = Object.fromEntries(
+    Object.entries(rawInfo).map(([baseUrl, info]) => [
+      normalizeBaseUrl4(baseUrl),
+      info
+    ])
+  );
+  const lastModelsUpdate = Object.fromEntries(
+    Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
+      normalizeBaseUrl4(baseUrl),
+      timestamp
+    ])
+  );
+  const cachedTokens = rawCachedTokens.map((entry) => ({
+    ...entry,
+    baseUrl: normalizeBaseUrl4(entry.baseUrl),
+    balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
+    lastUsed: entry.lastUsed ?? null
+  }));
+  const apiKeys = rawApiKeys.map((entry) => ({
+    ...entry,
+    baseUrl: normalizeBaseUrl4(entry.baseUrl),
+    balance: entry.balance ?? 0,
+    lastUsed: entry.lastUsed ?? null
+  }));
+  const childKeys = rawChildKeys.map((entry) => ({
+    parentBaseUrl: normalizeBaseUrl4(entry.parentBaseUrl),
+    childKey: entry.childKey,
+    balance: entry.balance ?? 0,
+    balanceLimit: entry.balanceLimit,
+    validityDate: entry.validityDate,
+    createdAt: entry.createdAt ?? Date.now()
+  }));
+  const routstr21Models = rawRoutstr21Models;
+  const lastRoutstr21ModelsUpdate = rawLastRoutstr21ModelsUpdate;
+  const cachedReceiveTokens = rawCachedReceiveTokens?.map((entry) => ({
+    token: entry.token,
+    amount: entry.amount,
+    unit: entry.unit || "sat",
+    createdAt: entry.createdAt ?? Date.now()
+  }));
+  const clientIds = rawClientIds.map((entry) => ({
+    ...entry,
+    createdAt: entry.createdAt ?? Date.now(),
+    lastUsed: entry.lastUsed ?? null
+  }));
+  store.setState({
+    modelsFromAllProviders,
+    lastUsedModel,
+    baseUrlsList,
+    lastBaseUrlsUpdate,
+    disabledProviders,
+    mintsFromAllProviders,
+    infoFromAllProviders,
+    lastModelsUpdate,
+    cachedTokens,
+    apiKeys,
+    childKeys,
+    routstr21Models,
+    lastRoutstr21ModelsUpdate,
+    cachedReceiveTokens,
+    clientIds
+  });
 };
-
-// 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);
-    }
-  }
+var createSdkStore = ({
+  driver
+}) => {
+  const store = createEmptyStore(driver);
   return {
-    async getItem(key, defaultValue) {
-      const item = store.get(key);
-      if (item === void 0) return defaultValue;
-      try {
-        return JSON.parse(item);
-      } catch (parseError) {
-        if (typeof defaultValue === "string") {
-          return item;
-        }
-        throw parseError;
-      }
-    },
-    async setItem(key, value) {
-      store.set(key, JSON.stringify(value));
-    },
-    async removeItem(key) {
-      store.delete(key);
-    }
+    store,
+    hydrate: hydrateStoreFromDriver(store, driver)
   };
 };
-
-// storage/drivers/sqlite.ts
-var isBun = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var createDatabase = (dbPath) => {
-  if (isBun()) {
-    throw new Error(
-      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
-    );
-  }
-  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 {
-    async 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;
-      }
-    },
-    async setItem(key, value) {
-      try {
-        upsertStmt.run(key, JSON.stringify(value));
-      } catch (error) {
-        console.error(`SQLite setItem failed for key "${key}":`, error);
-      }
-    },
-    async removeItem(key) {
-      try {
-        deleteStmt.run(key);
-      } catch (error) {
-        console.error(`SQLite removeItem failed for key "${key}":`, error);
-      }
+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 = normalizeBaseUrl4(baseUrl);
+    const timestamps = store.getState().lastModelsUpdate;
+    return timestamps[normalized] || null;
+  },
+  setProviderLastUpdate: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl4(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),
+  getRoutstr21Models: () => store.getState().routstr21Models,
+  setRoutstr21Models: (models) => store.getState().setRoutstr21Models(models),
+  getRoutstr21ModelsLastUpdate: () => store.getState().lastRoutstr21ModelsUpdate,
+  setRoutstr21ModelsLastUpdate: (timestamp) => store.getState().setRoutstr21ModelsLastUpdate(timestamp)
+});
+var createStorageAdapterFromStore = (store) => ({
+  getToken: (baseUrl) => {
+    const normalized = normalizeBaseUrl4(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 = normalizeBaseUrl4(baseUrl);
+    const tokens = store.getState().cachedTokens;
+    const balance = getCashuTokenBalance(token);
+    const existingIndex = tokens.findIndex(
+      (entry) => entry.baseUrl === normalized
+    );
+    if (existingIndex !== -1) {
+      throw new Error(`Token already exists for baseUrl: ${normalized}`);
     }
-  };
-};
-
-// storage/drivers/indexedDB.ts
-var isBrowser = typeof indexedDB !== "undefined";
-var openDatabase = (dbName, storeName) => {
-  if (!isBrowser) {
-    return Promise.reject(new Error("IndexedDB is not available"));
-  }
-  return new Promise((resolve, reject) => {
-    const request = indexedDB.open(dbName, 1);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(storeName)) {
-        db.createObjectStore(storeName);
+    const next = [...tokens];
+    next.push({
+      baseUrl: normalized,
+      token,
+      balance,
+      lastUsed: Date.now()
+    });
+    store.getState().setCachedTokens(next);
+  },
+  removeToken: (baseUrl) => {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    const next = store.getState().cachedTokens.filter((entry) => entry.baseUrl !== normalized);
+    store.getState().setCachedTokens(next);
+  },
+  updateTokenBalance: (baseUrl, balance) => {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    const tokens = store.getState().cachedTokens;
+    const next = tokens.map(
+      (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
+    );
+    store.getState().setCachedTokens(next);
+  },
+  getCachedTokenDistribution: () => {
+    const cachedTokens = store.getState().cachedTokens;
+    const distributionMap = {};
+    for (const entry of cachedTokens) {
+      const sum = entry.balance || 0;
+      if (sum > 0) {
+        distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
       }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-};
-var createIndexedDBDriver = (options = {}) => {
-  const dbName = options.dbName || "routstr-sdk";
-  const storeName = options.storeName || "sdk_storage";
-  let dbPromise = null;
-  const getDb = () => {
-    if (!dbPromise) {
-      dbPromise = openDatabase(dbName, storeName);
     }
-    return dbPromise;
-  };
-  return {
-    async getItem(key, defaultValue) {
-      try {
-        const db = await getDb();
-        return new Promise((resolve, reject) => {
-          const tx = db.transaction(storeName, "readonly");
-          const store = tx.objectStore(storeName);
-          const request = store.get(key);
-          request.onsuccess = () => {
-            const raw = request.result;
-            if (raw === void 0) {
-              resolve(defaultValue);
-              return;
-            }
-            if (typeof raw === "string") {
-              try {
-                resolve(JSON.parse(raw));
-              } catch {
-                if (typeof defaultValue === "string") {
-                  resolve(raw);
-                } else {
-                  resolve(defaultValue);
-                }
-              }
-            } else {
-              resolve(raw);
-            }
-          };
-          request.onerror = () => reject(request.error);
-        });
-      } catch (error) {
-        console.error(`IndexedDB getItem failed for key "${key}":`, error);
-        return defaultValue;
-      }
-    },
-    async setItem(key, value) {
-      try {
-        const db = await getDb();
-        return new Promise((resolve, reject) => {
-          const tx = db.transaction(storeName, "readwrite");
-          const store = tx.objectStore(storeName);
-          store.put(JSON.stringify(value), key);
-          tx.oncomplete = () => resolve();
-          tx.onerror = () => reject(tx.error);
-        });
-      } catch (error) {
-        console.error(`IndexedDB setItem failed for key "${key}":`, error);
-      }
-    },
-    async removeItem(key) {
-      try {
-        const db = await getDb();
-        return new Promise((resolve, reject) => {
-          const tx = db.transaction(storeName, "readwrite");
-          const store = tx.objectStore(storeName);
-          store.delete(key);
-          tx.oncomplete = () => resolve();
-          tx.onerror = () => reject(tx.error);
-        });
-      } catch (error) {
-        console.error(`IndexedDB removeItem failed for key "${key}":`, error);
+    return Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
+  },
+  getApiKeyDistribution: () => {
+    const apiKeys = store.getState().apiKeys;
+    const distributionMap = {};
+    for (const entry of apiKeys) {
+      const sum = entry.balance || 0;
+      if (sum > 0) {
+        distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
       }
     }
-  };
-};
-
-// 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",
-  ROUTSTR21_MODELS: "routstr21Models",
-  LAST_ROUTSTR21_MODELS_UPDATE: "lastRoutstr21ModelsUpdate",
-  CACHED_RECEIVE_TOKENS: "cached_receive_tokens",
-  USAGE_TRACKING: "usage_tracking",
-  CLIENT_IDS: "client_ids"
-};
-
-// storage/store.ts
-var normalizeBaseUrl = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var getCashuTokenBalance = (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 Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
+  },
+  saveProviderInfo: (baseUrl, info) => {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    const next = { ...store.getState().infoFromAllProviders };
+    next[normalized] = info;
+    store.getState().setInfoFromAllProviders(next);
+  },
+  getProviderInfo: (baseUrl) => {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    return store.getState().infoFromAllProviders[normalized] || null;
+  },
+  // ========== API Keys (for apikeys mode) ==========
+  getApiKey: (baseUrl) => {
+    const normalized = normalizeBaseUrl4(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;
+  },
+  setApiKey: (baseUrl, key) => {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    const keys = store.getState().apiKeys;
+    const existingIndex = keys.findIndex(
+      (entry) => entry.baseUrl === normalized
+    );
+    if (existingIndex !== -1) {
+      throw new Error(`ApiKey already exists for baseUrl: ${normalized}`);
     }
-    return sum;
-  } catch {
-    return 0;
-  }
-};
-var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
-  modelsFromAllProviders: {},
-  lastUsedModel: null,
-  baseUrlsList: [],
-  lastBaseUrlsUpdate: null,
-  disabledProviders: [],
-  mintsFromAllProviders: {},
-  infoFromAllProviders: {},
-  lastModelsUpdate: {},
-  cachedTokens: [],
-  apiKeys: [],
-  childKeys: [],
-  routstr21Models: [],
-  lastRoutstr21ModelsUpdate: null,
-  cachedReceiveTokens: [],
-  usageTracking: [],
-  clientIds: [],
-  setModelsFromAllProviders: (value) => {
-    const normalized = {};
-    for (const [baseUrl, models] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(baseUrl)] = models;
-    }
-    void driver.setItem(
-      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
-      normalized
-    );
-    set({ modelsFromAllProviders: normalized });
+    const next = [...keys];
+    next.push({
+      baseUrl: normalized,
+      key,
+      balance: 0,
+      lastUsed: Date.now()
+    });
+    store.getState().setApiKeys(next);
   },
-  setLastUsedModel: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
-    set({ lastUsedModel: value });
+  updateApiKeyBalance: (baseUrl, balance) => {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    const keys = store.getState().apiKeys;
+    const next = keys.map(
+      (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
+    );
+    store.getState().setApiKeys(next);
   },
-  setBaseUrlsList: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl(url));
-    void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
-    set({ baseUrlsList: normalized });
+  removeApiKey: (baseUrl) => {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    const next = store.getState().apiKeys.filter((entry) => entry.baseUrl !== normalized);
+    store.getState().setApiKeys(next);
   },
-  setBaseUrlsLastUpdate: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
-    set({ lastBaseUrlsUpdate: value });
+  getAllApiKeys: () => {
+    return store.getState().apiKeys.map((entry) => ({
+      baseUrl: entry.baseUrl,
+      key: entry.key,
+      balance: entry.balance,
+      lastUsed: entry.lastUsed
+    }));
   },
-  setDisabledProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl(url));
-    void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
-    set({ disabledProviders: normalized });
+  // ========== Child Keys ==========
+  getChildKey: (parentBaseUrl) => {
+    const normalized = normalizeBaseUrl4(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
+    };
   },
-  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
-      );
-    }
-    void driver.setItem(
-      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
-      normalized
+  setChildKey: (parentBaseUrl, childKey, balance, validityDate, balanceLimit) => {
+    const normalized = normalizeBaseUrl4(parentBaseUrl);
+    const keys = store.getState().childKeys;
+    const existingIndex = keys.findIndex(
+      (entry) => entry.parentBaseUrl === normalized
     );
-    set({ mintsFromAllProviders: normalized });
-  },
-  setInfoFromAllProviders: (value) => {
-    const normalized = {};
-    for (const [baseUrl, info] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(baseUrl)] = info;
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
-    set({ infoFromAllProviders: normalized });
-  },
-  setLastModelsUpdate: (value) => {
-    const normalized = {};
-    for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(baseUrl)] = timestamp;
+    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);
     }
-    void 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 : getCashuTokenBalance(entry.token),
-        lastUsed: entry.lastUsed ?? null
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, normalized);
-      return { cachedTokens: normalized };
-    });
+  updateChildKeyBalance: (parentBaseUrl, balance) => {
+    const normalized = normalizeBaseUrl4(parentBaseUrl);
+    const keys = store.getState().childKeys;
+    const next = keys.map(
+      (entry) => entry.parentBaseUrl === normalized ? { ...entry, balance } : entry
+    );
+    store.getState().setChildKeys(next);
   },
-  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
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.API_KEYS, normalized);
-      return { apiKeys: normalized };
-    });
+  removeChildKey: (parentBaseUrl) => {
+    const normalized = normalizeBaseUrl4(parentBaseUrl);
+    const next = store.getState().childKeys.filter((entry) => entry.parentBaseUrl !== normalized);
+    store.getState().setChildKeys(next);
   },
-  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()
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
-      return { childKeys: normalized };
-    });
+  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
+    }));
   },
-  setRoutstr21Models: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
-    set({ routstr21Models: value });
+  getCachedReceiveTokens: () => {
+    return store.getState().cachedReceiveTokens;
   },
-  setRoutstr21ModelsLastUpdate: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE, value);
-    set({ lastRoutstr21ModelsUpdate: value });
+  setCachedReceiveTokens: (tokens) => {
+    store.getState().setCachedReceiveTokens(tokens);
+  }
+});
+var createProviderRegistryFromStore = (store) => ({
+  getModelsForProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    return store.getState().modelsFromAllProviders[normalized] || [];
   },
-  setCachedReceiveTokens: (value) => {
-    const normalized = value.map((entry) => ({
-      token: entry.token,
-      amount: entry.amount,
-      unit: entry.unit || "sat",
-      createdAt: entry.createdAt ?? Date.now()
-    }));
-    void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
-    set({ cachedReceiveTokens: normalized });
+  getDisabledProviders: () => store.getState().disabledProviders,
+  getProviderMints: (baseUrl) => {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    return store.getState().mintsFromAllProviders[normalized] || [];
   },
-  setUsageTracking: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.USAGE_TRACKING, value);
-    set({ usageTracking: value });
+  getProviderInfo: async (baseUrl) => {
+    const normalized = normalizeBaseUrl4(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;
+    }
   },
-  setClientIds: (value) => {
-    set((state) => {
-      const updates = typeof value === "function" ? value(state.clientIds) : value;
-      const normalized = updates.map((entry) => ({
-        ...entry,
-        createdAt: entry.createdAt ?? Date.now(),
-        lastUsed: entry.lastUsed ?? null
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.CLIENT_IDS, normalized);
-      return { clientIds: normalized };
-    });
+  getAllProvidersModels: () => store.getState().modelsFromAllProviders
+});
+
+// storage/index.ts
+var isBrowser3 = () => {
+  try {
+    return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+  } catch {
+    return false;
   }
-}));
-var hydrateStoreFromDriver = async (store, driver) => {
-  const [
-    rawModels,
-    lastUsedModel,
-    rawBaseUrls,
-    lastBaseUrlsUpdate,
-    rawDisabledProviders,
-    rawMints,
-    rawInfo,
-    rawLastModelsUpdate,
-    rawCachedTokens,
-    rawApiKeys,
-    rawChildKeys,
-    rawRoutstr21Models,
-    rawLastRoutstr21ModelsUpdate,
-    rawCachedReceiveTokens,
-    rawUsageTracking,
-    rawClientIds
-  ] = await Promise.all([
-    driver.getItem(
-      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
-      {}
-    ),
-    driver.getItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, null),
-    driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []),
-    driver.getItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, null),
-    driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []),
-    driver.getItem(
-      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
-      {}
-    ),
-    driver.getItem(
-      SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
-      {}
-    ),
-    driver.getItem(
-      SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
-      {}
-    ),
-    driver.getItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, []),
-    driver.getItem(SDK_STORAGE_KEYS.API_KEYS, []),
-    driver.getItem(SDK_STORAGE_KEYS.CHILD_KEYS, []),
-    driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
-    driver.getItem(
-      SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
-      null
-    ),
-    driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
-    driver.getItem(SDK_STORAGE_KEYS.USAGE_TRACKING, []),
-    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, [])
-  ]);
-  const modelsFromAllProviders = Object.fromEntries(
-    Object.entries(rawModels).map(([baseUrl, models]) => [
-      normalizeBaseUrl(baseUrl),
-      models
-    ])
-  );
-  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl(url));
-  const disabledProviders = rawDisabledProviders.map(
-    (url) => normalizeBaseUrl(url)
-  );
-  const mintsFromAllProviders = Object.fromEntries(
-    Object.entries(rawMints).map(([baseUrl, mints]) => [
-      normalizeBaseUrl(baseUrl),
-      mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
-    ])
-  );
-  const infoFromAllProviders = Object.fromEntries(
-    Object.entries(rawInfo).map(([baseUrl, info]) => [
-      normalizeBaseUrl(baseUrl),
-      info
-    ])
-  );
-  const lastModelsUpdate = Object.fromEntries(
-    Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl(baseUrl),
-      timestamp
-    ])
-  );
-  const cachedTokens = rawCachedTokens.map((entry) => ({
-    ...entry,
-    baseUrl: normalizeBaseUrl(entry.baseUrl),
-    balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
-    lastUsed: entry.lastUsed ?? null
-  }));
-  const apiKeys = rawApiKeys.map((entry) => ({
-    ...entry,
-    baseUrl: normalizeBaseUrl(entry.baseUrl),
-    balance: entry.balance ?? 0,
-    lastUsed: entry.lastUsed ?? null
-  }));
-  const childKeys = rawChildKeys.map((entry) => ({
-    parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
-    childKey: entry.childKey,
-    balance: entry.balance ?? 0,
-    balanceLimit: entry.balanceLimit,
-    validityDate: entry.validityDate,
-    createdAt: entry.createdAt ?? Date.now()
-  }));
-  const routstr21Models = rawRoutstr21Models;
-  const lastRoutstr21ModelsUpdate = rawLastRoutstr21ModelsUpdate;
-  const cachedReceiveTokens = rawCachedReceiveTokens?.map((entry) => ({
-    token: entry.token,
-    amount: entry.amount,
-    unit: entry.unit || "sat",
-    createdAt: entry.createdAt ?? Date.now()
-  }));
-  const usageTracking = rawUsageTracking;
-  const clientIds = rawClientIds.map((entry) => ({
-    ...entry,
-    createdAt: entry.createdAt ?? Date.now(),
-    lastUsed: entry.lastUsed ?? null
-  }));
-  store.setState({
-    modelsFromAllProviders,
-    lastUsedModel,
-    baseUrlsList,
-    lastBaseUrlsUpdate,
-    disabledProviders,
-    mintsFromAllProviders,
-    infoFromAllProviders,
-    lastModelsUpdate,
-    cachedTokens,
-    apiKeys,
-    childKeys,
-    routstr21Models,
-    lastRoutstr21ModelsUpdate,
-    cachedReceiveTokens,
-    usageTracking,
-    clientIds
-  });
 };
-var createSdkStore = ({
-  driver
-}) => {
-  const store = createEmptyStore(driver);
-  return {
-    store,
-    hydrate: hydrateStoreFromDriver(store, driver)
-  };
+var isNode = () => {
+  try {
+    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+  } catch {
+    return false;
+  }
 };
-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),
-  getRoutstr21Models: () => store.getState().routstr21Models,
-  setRoutstr21Models: (models) => store.getState().setRoutstr21Models(models),
-  getRoutstr21ModelsLastUpdate: () => store.getState().lastRoutstr21ModelsUpdate,
-  setRoutstr21ModelsLastUpdate: (timestamp) => store.getState().setRoutstr21ModelsLastUpdate(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
+var defaultDriver = null;
+var isBun3 = () => {
+  return typeof process.versions.bun !== "undefined";
+};
+var getDefaultSdkDriver = () => {
+  if (defaultDriver) return defaultDriver;
+  if (isBrowser3()) {
+    defaultDriver = localStorageDriver;
+    return defaultDriver;
+  }
+  if (isBun3()) {
+    defaultDriver = createMemoryDriver();
+    return defaultDriver;
+  }
+  if (isNode()) {
+    defaultDriver = createSqliteDriver();
+    return defaultDriver;
+  }
+  defaultDriver = createMemoryDriver();
+  return defaultDriver;
+};
+var defaultStore = null;
+var defaultUsageTrackingDriver = null;
+var getDefaultSdkStore = () => {
+  if (!defaultStore) {
+    defaultStore = createSdkStore({ driver: getDefaultSdkDriver() });
+  }
+  return defaultStore.hydrate.then(() => defaultStore.store);
+};
+var getDefaultUsageTrackingDriver = () => {
+  if (defaultUsageTrackingDriver) return defaultUsageTrackingDriver;
+  const storageDriver = getDefaultSdkDriver();
+  if (isBrowser3()) {
+    defaultUsageTrackingDriver = createIndexedDBUsageTrackingDriver({
+      legacyStorageDriver: storageDriver
+    });
+    return defaultUsageTrackingDriver;
+  }
+  if (isBun3()) {
+    defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+    return defaultUsageTrackingDriver;
+  }
+  if (isNode()) {
+    defaultUsageTrackingDriver = createSqliteUsageTrackingDriver({
+      legacyStorageDriver: storageDriver
+    });
+    return defaultUsageTrackingDriver;
+  }
+  defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+  return defaultUsageTrackingDriver;
+};
+var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
+var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
+var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(await getDefaultSdkStore());
+function createSSEParserTransform(onUsage, onResponseId) {
+  let buffer = "";
+  const maybeCaptureUsageFromJson = (jsonText) => {
+    try {
+      const data = JSON.parse(jsonText);
+      const responseId = data.id;
+      if (typeof responseId === "string" && responseId.trim().length > 0) {
+        onResponseId?.(responseId.trim());
+      }
+      const usage = extractUsageFromSSEJson(data);
+      if (usage) {
+        onUsage(usage);
+      }
+    } catch {
+    }
+  };
+  const processLine = (self, line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return;
+    }
+    if (trimmed === "data: [DONE]" || trimmed === "[DONE]") {
+      self.push("data: [DONE]\n\n");
+      return;
+    }
+    if (trimmed.startsWith("data:")) {
+      const dataStr = trimmed.startsWith("data: ") ? trimmed.slice(6) : trimmed.slice(5).trimStart();
+      if (dataStr === "[DONE]") {
+        self.push("data: [DONE]\n\n");
+        return;
+      }
+      maybeCaptureUsageFromJson(dataStr);
+      self.push(`data: ${dataStr}
+
+`);
+      return;
+    }
+    if (trimmed.startsWith("{")) {
+      maybeCaptureUsageFromJson(trimmed);
+      self.push(`data: ${trimmed}
+
+`);
+      return;
+    }
+    self.push(line + "\n");
+  };
+  return new stream.Transform({
+    transform(chunk, encoding, callback) {
+      buffer += chunk.toString();
+      const lines = buffer.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        processLine(this, line);
+      }
+      callback();
+    },
+    flush(callback) {
+      if (buffer.trim()) {
+        processLine(this, buffer);
+      }
+      buffer = "";
+      callback();
+    }
+  });
+}
+var TOPUP_MARGIN = 1.2;
+var RoutstrClient = class {
+  constructor(walletAdapter, storageAdapter, providerRegistry, alertLevel, mode = "xcashu") {
+    this.walletAdapter = walletAdapter;
+    this.storageAdapter = storageAdapter;
+    this.providerRegistry = providerRegistry;
+    this.balanceManager = new BalanceManager(
+      walletAdapter,
+      storageAdapter,
+      providerRegistry
+    );
+    this.cashuSpender = new CashuSpender(
+      walletAdapter,
+      storageAdapter,
+      providerRegistry,
+      this.balanceManager
+    );
+    this.streamProcessor = new StreamProcessor();
+    this.providerManager = new ProviderManager(providerRegistry);
+    this.alertLevel = alertLevel;
+    if (mode === "lazyrefund") {
+      this.mode = "apikeys";
+    } else if (mode === "apikeys") {
+      this.mode = "lazyrefund";
+    } else {
+      this.mode = mode;
+    }
+  }
+  cashuSpender;
+  balanceManager;
+  streamProcessor;
+  providerManager;
+  alertLevel;
+  mode;
+  debugLevel = "WARN";
+  /**
+   * Get the current client mode
+   */
+  getMode() {
+    return this.mode;
+  }
+  getDebugLevel() {
+    return this.debugLevel;
+  }
+  setDebugLevel(level) {
+    this.debugLevel = level;
+  }
+  _log(level, ...args) {
+    const levelPriority = {
+      DEBUG: 0,
+      WARN: 1,
+      ERROR: 2
+    };
+    if (levelPriority[level] >= levelPriority[this.debugLevel]) {
+      switch (level) {
+        case "DEBUG":
+          console.log(...args);
+          break;
+        case "WARN":
+          console.warn(...args);
+          break;
+        case "ERROR":
+          console.error(...args);
+          break;
+      }
+    }
+  }
+  /**
+   * Get the CashuSpender instance
+   */
+  getCashuSpender() {
+    return this.cashuSpender;
+  }
+  /**
+   * Get the BalanceManager instance
+   */
+  getBalanceManager() {
+    return this.balanceManager;
+  }
+  /**
+   * Get the ProviderManager instance
+   */
+  getProviderManager() {
+    return this.providerManager;
+  }
+  /**
+   * Check if the client is currently busy (in critical section)
+   */
+  get isBusy() {
+    return this.cashuSpender.isBusy;
+  }
+  /**
+   * Route an API request to the upstream provider
+   *
+   * This is a simpler alternative to fetchAIResponse that just proxies
+   * the request upstream without the streaming callback machinery.
+   * Useful for daemon-style routing where you just need to forward
+   * requests and get responses back.
+   */
+  async routeRequest(params) {
+    const prepared = await this._prepareRoutedRequest(params);
+    const satsSpent = await this._handlePostResponseBalanceUpdate({
+      token: prepared.tokenUsed,
+      baseUrl: prepared.baseUrlUsed,
+      initialTokenBalance: prepared.tokenBalanceInSats,
+      response: prepared.response,
+      modelId: prepared.modelId,
+      usage: prepared.capturedUsage,
+      requestId: prepared.capturedResponseId
+    });
+    prepared.response.satsSpent = satsSpent;
+    prepared.response.usage = prepared.capturedUsage;
+    prepared.response.requestId = prepared.capturedResponseId;
+    return prepared.response;
+  }
+  async routeRequestToNodeResponse(params) {
+    const { res } = params;
+    const prepared = await this._prepareRoutedRequest(params);
+    res.statusCode = prepared.response.status;
+    prepared.response.headers.forEach((value, key) => {
+      res.setHeader(key, value);
+    });
+    const body = prepared.response.body;
+    if (!body) {
+      const satsSpent = await this._handlePostResponseBalanceUpdate({
+        token: prepared.tokenUsed,
+        baseUrl: prepared.baseUrlUsed,
+        initialTokenBalance: prepared.tokenBalanceInSats,
+        response: prepared.response,
+        modelId: prepared.modelId,
+        usage: prepared.capturedUsage,
+        requestId: prepared.capturedResponseId
+      });
+      prepared.response.satsSpent = satsSpent;
+      res.end();
+      return;
+    }
+    const nodeReadable = stream.Readable.fromWeb(body);
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = async () => {
+        if (settled) return;
+        settled = true;
+        try {
+          const satsSpent = await this._handlePostResponseBalanceUpdate({
+            token: prepared.tokenUsed,
+            baseUrl: prepared.baseUrlUsed,
+            initialTokenBalance: prepared.tokenBalanceInSats,
+            response: prepared.response,
+            modelId: prepared.modelId,
+            usage: prepared.capturedUsage,
+            requestId: prepared.capturedResponseId
+          });
+          prepared.response.satsSpent = satsSpent;
+          prepared.response.usage = prepared.capturedUsage;
+          prepared.response.requestId = prepared.capturedResponseId;
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      };
+      const fail = (error) => {
+        if (settled) return;
+        settled = true;
+        reject(error);
+      };
+      res.once("finish", finish);
+      res.once("close", finish);
+      res.once("error", fail);
+      nodeReadable.once("error", fail);
+      nodeReadable.pipe(res);
+    });
+  }
+  async _prepareRoutedRequest(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
+    });
+    this._log("DEBUG", token, baseUrl);
+    let requestBody = body;
+    if (body && typeof body === "object") {
+      const bodyObj = body;
+      if (!bodyObj.stream) {
+        requestBody = { ...bodyObj, stream: false };
+      }
+    }
+    const baseHeaders = this._buildBaseHeaders(headers);
+    const requestHeaders = this._withAuthHeader(baseHeaders, token);
+    const response = await this._makeRequest({
+      path,
+      method,
+      body: method === "GET" ? void 0 : requestBody,
+      baseUrl,
+      mintUrl,
+      token,
+      requiredSats,
+      headers: requestHeaders,
+      baseHeaders,
+      selectedModel
+    });
+    const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
+    const baseUrlUsed = response.baseUrl || baseUrl;
+    const tokenUsed = response.token || token;
+    const contentType = response.headers.get("content-type") || "";
+    let processedResponse = response;
+    let capturedUsage;
+    let capturedResponseId;
+    if (contentType.includes("text/event-stream") && response.body) {
+      const nodeReadable = stream.Readable.fromWeb(response.body);
+      const sseParser = createSSEParserTransform(
+        (usage) => {
+          capturedUsage = usage;
+          processedResponse.usage = usage;
+        },
+        (responseId) => {
+          capturedResponseId = responseId;
+          processedResponse.requestId = responseId;
+        }
+      );
+      const transformed = nodeReadable.pipe(sseParser, { end: true });
+      const webStream = stream.Readable.toWeb(
+        transformed
+      );
+      processedResponse = new Response(webStream, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+      processedResponse.baseUrl = response.baseUrl;
+      processedResponse.token = response.token;
+    }
+    return {
+      response: processedResponse,
+      tokenUsed,
+      baseUrlUsed,
+      tokenBalanceInSats,
+      modelId,
+      capturedUsage,
+      capturedResponseId
+    };
+  }
+  /**
+   * 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,
+          modelId: selectedModel.id,
+          usage: streamingResult.usage ? {
+            promptTokens: Number(streamingResult.usage.prompt_tokens ?? 0),
+            completionTokens: Number(
+              streamingResult.usage.completion_tokens ?? 0
+            ),
+            totalTokens: Number(streamingResult.usage.total_tokens ?? 0),
+            cost: Number(streamingResult.usage.cost ?? 0),
+            satsCost: Number(streamingResult.usage.sats_cost ?? 0)
+          } : void 0,
+          requestId: streamingResult.responseId
+        });
+        const estimatedCosts = this._getEstimatedCosts(
+          selectedModel,
+          streamingResult
+        );
+        const onLastMessageSatsUpdate = callbacks.onLastMessageSatsUpdate;
+        onLastMessageSatsUpdate?.(satsSpent, estimatedCosts);
+      } else {
+        throw new Error(`${response.status} ${response.statusText}`);
+      }
+    } catch (error) {
+      this._handleError(error, callbacks);
+    } finally {
+      callbacks.onPaymentProcessing?.(false);
+    }
+  }
+  /**
+   * Make the API request with failover support
+   */
+  async _makeRequest(params) {
+    const { path, method, body, baseUrl, token, headers } = params;
+    try {
+      const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+      if (this.mode === "xcashu") this._log("DEBUG", "HEADERS,", headers);
+      this._log("DEBUG", "HEADERS,", headers);
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body === void 0 || method === "GET" ? void 0 : JSON.stringify(body)
+      });
+      if (this.mode === "xcashu") this._log("DEBUG", "response,", response);
+      response.baseUrl = baseUrl;
+      response.token = token;
+      if (!response.ok) {
+        const requestId = response.headers.get("x-routstr-request-id") || void 0;
+        let bodyText;
+        try {
+          bodyText = await response.text();
+        } catch (e) {
+          bodyText = void 0;
+        }
+        return await this._handleErrorResponse(
+          params,
+          token,
+          response.status,
+          requestId,
+          this.mode === "xcashu" ? response.headers.get("x-cashu") ?? void 0 : void 0,
+          bodyText,
+          params.retryCount ?? 0
+        );
+      }
+      return response;
+    } catch (error) {
+      if (isNetworkErrorMessage(error?.message || "")) {
+        return await this._handleErrorResponse(
+          params,
+          token,
+          -1,
+          // just for Network Error to skip all statuses
+          void 0,
+          void 0,
+          void 0,
+          params.retryCount ?? 0
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Handle error responses with failover
+   */
+  async _handleErrorResponse(params, token, status, requestId, xCashuRefundToken, responseBody, retryCount = 0) {
+    const MAX_RETRIES_PER_PROVIDER = 2;
+    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
+    let tryNextProvider = false;
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _handleErrorResponse: status=${status}, baseUrl=${baseUrl}, mode=${this.mode}, token preview=${token}, requestId=${requestId}`
+    );
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _handleErrorResponse: Attempting to receive/restore token for ${baseUrl}`
+    );
+    if (params.token.startsWith("cashu")) {
+      const tryReceiveTokenResult = await this.cashuSpender.receiveToken(
+        params.token
+      );
+      if (tryReceiveTokenResult.success) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
+        );
+        tryNextProvider = true;
+        if (this.mode === "lazyrefund")
+          this.storageAdapter.removeToken(baseUrl);
+      } else {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Failed to receive token. `
+        );
+      }
+    }
+    if (this.mode === "xcashu") {
+      if (xCashuRefundToken) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Attempting to receive xcashu refund token, preview=${xCashuRefundToken.substring(0, 20)}...`
+        );
+        try {
+          const receiveResult = await this.cashuSpender.receiveToken(xCashuRefundToken);
+          if (receiveResult.success) {
+            this._log(
+              "DEBUG",
+              `[RoutstrClient] _handleErrorResponse: xcashu refund received, amount=${receiveResult.amount}`
+            );
+            tryNextProvider = true;
+          } else
+            throw new ProviderError(
+              baseUrl,
+              status,
+              "xcashu refund failed",
+              requestId
+            );
+        } catch (error) {
+          this._log("ERROR", "[xcashu] Failed to receive refund token:", error);
+          throw new ProviderError(
+            baseUrl,
+            status,
+            "[xcashu] Failed to receive refund token",
+            requestId
+          );
+        }
+      } else {
+        if (!tryNextProvider)
+          throw new ProviderError(
+            baseUrl,
+            status,
+            "[xcashu] Failed to receive refund token",
+            requestId
+          );
+      }
+    }
+    if (status === 402 && !tryNextProvider && (this.mode === "apikeys" || this.mode === "lazyrefund")) {
+      this.storageAdapter.getApiKey(baseUrl);
+      let topupAmount = params.requiredSats;
+      try {
+        let currentBalance = 0;
+        if (this.mode === "apikeys") {
+          const currentBalanceInfo = await this.balanceManager.getTokenBalance(
+            params.token,
+            baseUrl
+          );
+          currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
+        } else if (this.mode === "lazyrefund") {
+          const distribution = this.storageAdapter.getCachedTokenDistribution();
+          const tokenEntry = distribution.find((t) => t.baseUrl === baseUrl);
+          currentBalance = tokenEntry?.amount ?? 0;
+        }
+        const shortfall = Math.max(0, params.requiredSats - currentBalance);
+        topupAmount = shortfall > 0 ? shortfall : params.requiredSats;
+      } catch (e) {
+        this._log(
+          "WARN",
+          "Could not get current token balance for topup calculation:",
+          e
+        );
+      }
+      const topupResult = await this.balanceManager.topUp({
+        mintUrl,
+        baseUrl,
+        amount: topupAmount * TOPUP_MARGIN,
+        token: params.token
+      });
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Topup result for ${baseUrl}: success=${topupResult.success}, message=${topupResult.message}`
+      );
+      if (!topupResult.success) {
+        const message = topupResult.message || "";
+        if (message.includes("Insufficient balance")) {
+          const needMatch = message.match(/need (\d+)/);
+          const haveMatch = message.match(/have (\d+)/);
+          const required = needMatch ? parseInt(needMatch[1], 10) : params.requiredSats;
+          const available = haveMatch ? parseInt(haveMatch[1], 10) : 0;
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
+          );
+          throw new InsufficientBalanceError(
+            required,
+            available,
+            0,
+            "",
+            message
+          );
+        } else {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Topup failed with non-insufficient-balance error, will try next provider`
+          );
+          tryNextProvider = true;
+        }
+      } else {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Topup successful, will retry with new token`
+        );
+      }
+      if (!tryNextProvider) {
+        if (retryCount < MAX_RETRIES_PER_PROVIDER) {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Retrying 402 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
+          );
+          return this._makeRequest({
+            ...params,
+            token: params.token,
+            headers: this._withAuthHeader(params.baseHeaders, params.token),
+            retryCount: retryCount + 1
+          });
+        } else {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: 402 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
+          );
+          tryNextProvider = true;
+        }
+      }
+    }
+    const isInsufficientBalance413 = status === 413 && responseBody?.includes("Insufficient balance");
+    if (isInsufficientBalance413 && !tryNextProvider && this.mode === "apikeys") {
+      let retryToken = params.token;
+      try {
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+          params.token,
+          baseUrl
+        );
+        if (latestBalanceInfo.isInvalidApiKey) {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Invalid API key (proofs already spent), removing for ${baseUrl}`
+          );
+          this.storageAdapter.removeApiKey(baseUrl);
+          tryNextProvider = true;
+        } else {
+          const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+          if (latestBalanceInfo.apiKey) {
+            const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+            if (storedApiKeyEntry?.key !== latestBalanceInfo.apiKey) {
+              if (storedApiKeyEntry) {
+                this.storageAdapter.removeApiKey(baseUrl);
+              }
+              this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
+            }
+            retryToken = latestBalanceInfo.apiKey;
+          }
+          if (latestTokenBalance >= 0) {
+            this.storageAdapter.updateApiKeyBalance(
+              baseUrl,
+              latestTokenBalance
+            );
+          }
+        }
+      } catch (error) {
+        this._log(
+          "WARN",
+          `[RoutstrClient] _handleErrorResponse: Failed to refresh API key after 413 insufficient balance for ${baseUrl}`,
+          error
+        );
+      }
+      if (retryCount < MAX_RETRIES_PER_PROVIDER) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Retrying 413 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
+        );
+        return this._makeRequest({
+          ...params,
+          token: retryToken,
+          headers: this._withAuthHeader(params.baseHeaders, retryToken),
+          retryCount: retryCount + 1
+        });
+      } else {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: 413 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
+        );
+        tryNextProvider = true;
+      }
+    }
+    if ((status === 401 || status === 403 || status === 413 || status === 400 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Status ${status} (auth/server error), attempting refund for ${baseUrl}, mode=${this.mode}`
+      );
+      if (this.mode === "lazyrefund") {
+        try {
+          const refundResult = await this.balanceManager.refund({
+            mintUrl,
+            baseUrl,
+            token: params.token
+          });
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Lazyrefund result: success=${refundResult.success}`
+          );
+          if (refundResult.success) this.storageAdapter.removeToken(baseUrl);
+          else
+            throw new ProviderError(
+              baseUrl,
+              status,
+              "refund failed",
+              requestId
+            );
+        } catch (error) {
+          throw new ProviderError(
+            baseUrl,
+            status,
+            "Failed to refund token",
+            requestId
+          );
+        }
+      } else if (this.mode === "apikeys") {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`
+        );
+        const initialBalance = await this.balanceManager.getTokenBalance(
+          token,
+          baseUrl
+        );
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${initialBalance.amount}`
+        );
+        const refundResult = await this.balanceManager.refundApiKey({
+          mintUrl,
+          baseUrl,
+          apiKey: token
+        });
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
+        );
+        if (!refundResult.success && initialBalance.amount > 0) {
+          throw new ProviderError(
+            baseUrl,
+            status,
+            refundResult.message ?? "Unknown error"
+          );
+        }
+      }
+    }
+    this.providerManager.markFailed(baseUrl);
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _handleErrorResponse: Marked provider ${baseUrl} as failed`
     );
-    store.getState().setCachedTokens(next);
-    return entry.token;
-  },
-  setToken: (baseUrl, token) => {
-    const normalized = normalizeBaseUrl(baseUrl);
-    const tokens = store.getState().cachedTokens;
-    const balance = getCashuTokenBalance(token);
-    const existingIndex = tokens.findIndex(
-      (entry) => entry.baseUrl === normalized
+    if (!selectedModel) {
+      throw new ProviderError(
+        baseUrl,
+        status,
+        "Funny, no selected model. HMM. "
+      );
+    }
+    const nextProvider = this.providerManager.findNextBestProvider(
+      selectedModel.id,
+      baseUrl
     );
-    if (existingIndex !== -1) {
-      throw new Error(`Token already exists for baseUrl: ${normalized}`);
+    if (nextProvider) {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Failing over to next provider: ${nextProvider}, model: ${selectedModel.id}`
+      );
+      const newModel = await this.providerManager.getModelForProvider(
+        nextProvider,
+        selectedModel.id
+      ) ?? selectedModel;
+      const messagesForPricing = Array.isArray(
+        body?.messages
+      ) ? body.messages : [];
+      const newRequiredSats = this.providerManager.getRequiredSatsForModel(
+        newModel,
+        messagesForPricing,
+        params.maxTokens
+      );
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Creating new token for failover provider ${nextProvider}, required sats: ${newRequiredSats}`
+      );
+      const spendResult = await this._spendToken({
+        mintUrl,
+        amount: newRequiredSats,
+        baseUrl: nextProvider
+      });
+      return this._makeRequest({
+        ...params,
+        path,
+        method,
+        body,
+        baseUrl: nextProvider,
+        selectedModel: newModel,
+        token: spendResult.token,
+        requiredSats: newRequiredSats,
+        headers: this._withAuthHeader(params.baseHeaders, spendResult.token),
+        retryCount: 0
+      });
+    }
+    throw new FailoverError(
+      baseUrl,
+      Array.from(this.providerManager.getFailedProviders())
+    );
+  }
+  /**
+   * Handle post-response balance update for all modes
+   */
+  async _handlePostResponseBalanceUpdate(params) {
+    const {
+      token,
+      baseUrl,
+      initialTokenBalance,
+      fallbackSatsSpent,
+      response,
+      modelId,
+      usage,
+      requestId
+    } = 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.cashuSpender.receiveToken(refundToken);
+          satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
+        } catch (error) {
+          this._log("ERROR", "[xcashu] Failed to receive refund token:", error);
+        }
+      }
+    } else if (this.mode === "lazyrefund") {
+      const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+        token,
+        baseUrl
+      );
+      const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+      this.storageAdapter.updateTokenBalance(baseUrl, latestTokenBalance);
+      satsSpent = initialTokenBalance - latestTokenBalance;
+    } else if (this.mode === "apikeys") {
+      try {
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+          token,
+          baseUrl
+        );
+        this._log(
+          "DEBUG",
+          "LATEST Balance",
+          latestBalanceInfo.amount,
+          latestBalanceInfo.reserved,
+          latestBalanceInfo.apiKey,
+          baseUrl
+        );
+        const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+        const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+        if (storedApiKeyEntry?.key.startsWith("cashu") && latestBalanceInfo.apiKey) {
+          this.storageAdapter.removeApiKey(baseUrl);
+          this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
+        }
+        this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
+        satsSpent = initialTokenBalance - latestTokenBalance;
+      } catch (e) {
+        this._log("WARN", "Could not get updated API key balance:", e);
+        satsSpent = fallbackSatsSpent ?? initialTokenBalance;
+      }
     }
-    const next = [...tokens];
-    next.push({
-      baseUrl: normalized,
+    await this._trackResponseUsage({
       token,
-      balance,
-      lastUsed: Date.now()
+      baseUrl,
+      response,
+      modelId,
+      satsSpent,
+      usage,
+      requestId
     });
-    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
+    return satsSpent;
+  }
+  async _trackResponseUsage(params) {
+    const {
+      token,
+      baseUrl,
+      response,
+      modelId,
+      satsSpent,
+      usage: providedUsage,
+      requestId: providedRequestId
+    } = params;
+    if (!response || !modelId) {
+      return;
+    }
+    try {
+      let usage = providedUsage;
+      let requestId = providedRequestId;
+      if (!usage || !requestId) {
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("text/event-stream")) {
+          usage = usage ?? response.usage;
+          requestId = requestId ?? response.requestId ?? response.headers.get("x-routstr-request-id") ?? void 0;
+          if (!usage) {
+            return;
+          }
+        } else {
+          const cloned = response.clone();
+          const responseBody = await cloned.json();
+          usage = usage ?? extractUsageFromResponseBody(responseBody, satsSpent) ?? void 0;
+          requestId = requestId ?? extractResponseId(responseBody) ?? response.headers.get("x-routstr-request-id") ?? void 0;
+        }
+      }
+      if (!usage) {
+        return;
+      }
+      const finalRequestId = requestId || "unknown";
+      const store = await getDefaultSdkStore();
+      const state = store.getState();
+      const matchingClient = state.clientIds.find(
+        (client) => client.apiKey === token
+      );
+      const entryId = finalRequestId === "unknown" ? `req-${Date.now()}-${modelId}` : finalRequestId;
+      const usageTracking = getDefaultUsageTrackingDriver();
+      const entry = {
+        id: entryId,
+        timestamp: Date.now(),
+        modelId,
+        baseUrl,
+        requestId: finalRequestId,
+        client: matchingClient?.clientId,
+        ...usage
+      };
+      if (this.mode === "xcashu") {
+        entry.satsCost = satsSpent;
+      }
+      await usageTracking.append(entry);
+    } catch (error) {
+    }
+  }
+  /**
+   * Convert messages for API format
+   */
+  async _convertMessages(messages) {
+    return Promise.all(
+      messages.filter((m) => m.role !== "system").map(async (m) => ({
+        role: m.role,
+        content: typeof m.content === "string" ? m.content : m.content
+      }))
     );
-    store.getState().setCachedTokens(next);
-  },
-  getCachedTokenDistribution: () => {
-    const cachedTokens = store.getState().cachedTokens;
-    const distributionMap = {};
-    for (const entry of cachedTokens) {
-      const sum = entry.balance || 0;
-      if (sum > 0) {
-        distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
+  }
+  /**
+   * 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 Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
-  },
-  getApiKeyDistribution: () => {
-    const apiKeys = store.getState().apiKeys;
-    const distributionMap = {};
-    for (const entry of apiKeys) {
-      const sum = entry.balance || 0;
-      if (sum > 0) {
-        distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
+    return {
+      role: "assistant",
+      content: result.content || ""
+    };
+  }
+  /**
+   * Calculate estimated costs from usage
+   */
+  _getEstimatedCosts(selectedModel, streamingResult) {
+    let estimatedCosts = 0;
+    if (streamingResult.usage) {
+      const { completion_tokens, prompt_tokens } = streamingResult.usage;
+      if (completion_tokens !== void 0 && prompt_tokens !== void 0) {
+        estimatedCosts = (selectedModel.sats_pricing?.completion ?? 0) * completion_tokens + (selectedModel.sats_pricing?.prompt ?? 0) * prompt_tokens;
       }
     }
-    return 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;
-  },
-  setApiKey: (baseUrl, key) => {
-    const normalized = normalizeBaseUrl(baseUrl);
-    const keys = store.getState().apiKeys;
-    const existingIndex = keys.findIndex(
-      (entry) => entry.baseUrl === normalized
+    return estimatedCosts;
+  }
+  /**
+   * Get pending cashu token amount
+   */
+  _getPendingCashuTokenAmount() {
+    const distribution = this.storageAdapter.getCachedTokenDistribution();
+    return distribution.reduce((total, item) => total + item.amount, 0);
+  }
+  /**
+   * Handle errors and notify callbacks
+   */
+  _handleError(error, callbacks) {
+    this._log("ERROR", "[RoutstrClient] _handleError: Error occurred", error);
+    if (error instanceof Error) {
+      const isStreamError = error.message.includes("Error in input stream") || error.message.includes("Load failed");
+      const modifiedErrorMsg = isStreamError ? "AI stream was cut off, turn on Keep Active or please try again" : error.message;
+      this._log(
+        "ERROR",
+        `[RoutstrClient] _handleError: Error type=${error.constructor.name}, message=${modifiedErrorMsg}, isStreamError=${isStreamError}`
+      );
+      callbacks.onMessageAppend({
+        role: "system",
+        content: "Uncaught Error: " + modifiedErrorMsg + (this.alertLevel === "max" ? " | " + error.stack : "")
+      });
+    } else {
+      callbacks.onMessageAppend({
+        role: "system",
+        content: "Unknown Error: Please tag Routstr on Nostr and/or retry."
+      });
+    }
+  }
+  /**
+   * Check wallet balance and throw if insufficient
+   */
+  async _checkBalance() {
+    const balances = await this.walletAdapter.getBalances();
+    const totalBalance = Object.values(balances).reduce((sum, v) => sum + v, 0);
+    if (totalBalance <= 0) {
+      throw new InsufficientBalanceError(1, 0);
+    }
+  }
+  /**
+   * Spend a token using CashuSpender with standardized error handling
+   */
+  async _spendToken(params) {
+    const { mintUrl, amount, baseUrl } = params;
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _spendToken: mode=${this.mode}, amount=${amount}, baseUrl=${baseUrl}, mintUrl=${mintUrl}`
     );
-    if (existingIndex !== -1) {
-      throw new Error(`ApiKey already exists for baseUrl: ${normalized}`);
+    if (this.mode === "apikeys") {
+      let parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+      if (!parentApiKey) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _spendToken: No existing API key for ${baseUrl}, creating new one via Cashu`
+        );
+        const spendResult2 = await this.cashuSpender.spend({
+          mintUrl,
+          amount: amount * TOPUP_MARGIN,
+          baseUrl: "",
+          reuseToken: false
+        });
+        if (!spendResult2.token) {
+          this._log(
+            "ERROR",
+            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error:`,
+            spendResult2.error
+          );
+          throw new Error(
+            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error: ${spendResult2.error}`
+          );
+        } else {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult2.token}`
+          );
+        }
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _spendToken: Created API key for ${baseUrl}, key preview: ${spendResult2.token}, balance: ${spendResult2.balance}`
+        );
+        try {
+          this.storageAdapter.setApiKey(baseUrl, spendResult2.token);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("ApiKey already exists")) {
+            const tryReceiveTokenResult = await this.cashuSpender.receiveToken(
+              spendResult2.token
+            );
+            if (tryReceiveTokenResult.success) {
+              this._log(
+                "DEBUG",
+                `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
+              );
+            } else {
+              this._log(
+                "DEBUG",
+                `[RoutstrClient] _handleErrorResponse: Token restore failed or not needed`
+              );
+            }
+            this._log(
+              "DEBUG",
+              `[RoutstrClient] _spendToken: API key already exists for ${baseUrl}, using existing key`
+            );
+          } else {
+            throw error;
+          }
+        }
+        parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+      } else {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _spendToken: Using existing API key for ${baseUrl}, key preview: ${parentApiKey.key}`
+        );
+      }
+      let tokenBalance = 0;
+      let tokenBalanceUnit = "sat";
+      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+      const distributionForBaseUrl = apiKeyDistribution.find(
+        (d) => d.baseUrl === baseUrl
+      );
+      if (distributionForBaseUrl) {
+        tokenBalance = distributionForBaseUrl.amount;
+      }
+      if (tokenBalance === 0 && parentApiKey) {
+        try {
+          const balanceInfo = await this.balanceManager.getTokenBalance(
+            parentApiKey.key,
+            baseUrl
+          );
+          tokenBalance = balanceInfo.amount;
+          tokenBalanceUnit = balanceInfo.unit;
+        } catch (e) {
+          this._log("WARN", "Could not get initial API key balance:", e);
+        }
+      }
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _spendToken: Returning token with balance=${tokenBalance} ${tokenBalanceUnit}`
+      );
+      return {
+        token: parentApiKey?.key ?? "",
+        tokenBalance,
+        tokenBalanceUnit
+      };
     }
-    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);
-  },
-  removeApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
-    const next = store.getState().apiKeys.filter((entry) => entry.baseUrl !== normalized);
-    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
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _spendToken: Calling CashuSpender.spend for amount=${amount}, mintUrl=${mintUrl}, mode=${this.mode}`
     );
-    if (existingIndex !== -1) {
-      const next = keys.map(
-        (entry) => entry.parentBaseUrl === normalized ? {
-          ...entry,
-          childKey,
-          balance: balance ?? 0,
-          validityDate,
-          balanceLimit,
-          createdAt: Date.now()
-        } : entry
+    const spendResult = await this.cashuSpender.spend({
+      mintUrl,
+      amount,
+      baseUrl: this.mode === "lazyrefund" ? baseUrl : "",
+      reuseToken: this.mode === "lazyrefund"
+    });
+    if (!spendResult.token) {
+      this._log(
+        "ERROR",
+        `[RoutstrClient] _spendToken: CashuSpender.spend failed, error:`,
+        spendResult.error
       );
-      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
-    }));
-  },
-  getCachedReceiveTokens: () => {
-    return store.getState().cachedReceiveTokens;
-  },
-  setCachedReceiveTokens: (tokens) => {
-    store.getState().setCachedReceiveTokens(tokens);
-  }
-});
-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;
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult.token}, balance: ${spendResult.balance} ${spendResult.unit ?? "sat"}`
+      );
     }
-  },
-  getAllProvidersModels: () => store.getState().modelsFromAllProviders
-});
-
-// storage/index.ts
-var isBrowser2 = () => {
-  try {
-    return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
-  } catch {
-    return false;
-  }
-};
-var isNode = () => {
-  try {
-    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-  } catch {
-    return false;
-  }
-};
-var defaultDriver = null;
-var isBun2 = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var getDefaultSdkDriver = () => {
-  if (defaultDriver) return defaultDriver;
-  if (isBrowser2()) {
-    defaultDriver = localStorageDriver;
-    return defaultDriver;
-  }
-  if (isBun2()) {
-    defaultDriver = createMemoryDriver();
-    return defaultDriver;
+    return {
+      token: spendResult.token,
+      tokenBalance: spendResult.balance,
+      tokenBalanceUnit: spendResult.unit ?? "sat"
+    };
   }
-  if (isNode()) {
-    defaultDriver = createSqliteDriver();
-    return defaultDriver;
+  /**
+   * Build request headers with common defaults and dev mock controls
+   */
+  _buildBaseHeaders(additionalHeaders = {}, token) {
+    const headers = {
+      ...additionalHeaders,
+      "Content-Type": "application/json"
+    };
+    return headers;
   }
-  defaultDriver = createMemoryDriver();
-  return defaultDriver;
-};
-var defaultStore = null;
-var getDefaultSdkStore = () => {
-  if (!defaultStore) {
-    defaultStore = createSdkStore({ driver: getDefaultSdkDriver() });
+  /**
+   * 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;
   }
-  return defaultStore.hydrate.then(() => defaultStore.store);
 };
-var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
-var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
-var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(await getDefaultSdkStore());
 
 // routeRequests.ts
-async function routeRequests(options) {
+async function resolveRouteRequestContext(options) {
   const {
     modelId,
     requestBody,
@@ -4665,12 +5433,11 @@ async function routeRequests(options) {
   if (!mintUrl) {
     throw new Error("No mint configured in wallet");
   }
-  const alertLevel = "min";
   const client = new RoutstrClient(
     walletAdapter,
     storageAdapter,
     providerRegistry,
-    alertLevel,
+    "min",
     mode
   );
   if (debugLevel) {
@@ -4678,18 +5445,27 @@ async function routeRequests(options) {
   }
   const maxTokens = extractMaxTokens(requestBody);
   const stream = extractStream(requestBody);
-  let response = null;
+  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;
+  }
+  return {
+    client,
+    baseUrl,
+    mintUrl,
+    path,
+    modelId,
+    proxiedBody
+  };
+}
+async function routeRequests(options) {
+  const { client, baseUrl, mintUrl, path, modelId, proxiedBody } = await resolveRouteRequestContext(options);
   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;
-    }
-    console.log(modelId);
-    response = await client.routeRequest({
+    const response = await client.routeRequest({
       path,
       method: "POST",
       body: proxiedBody,
@@ -4708,24 +5484,41 @@ async function routeRequests(options) {
     throw error;
   }
 }
+async function routeRequestsToNodeResponse(options) {
+  const { res } = options;
+  const { client, baseUrl, mintUrl, path, modelId, proxiedBody } = await resolveRouteRequestContext(options);
+  try {
+    await client.routeRequestToNodeResponse({
+      path,
+      method: "POST",
+      body: proxiedBody,
+      baseUrl,
+      mintUrl,
+      modelId,
+      res
+    });
+  } 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;
+  return typeof maxTokens === "number" ? maxTokens : void 0;
 }
 function extractStream(requestBody) {
   if (!requestBody || typeof requestBody !== "object") {
-    return false;
+    return void 0;
   }
   const body = requestBody;
   const stream = body.stream;
-  return stream === true;
+  return typeof stream === "boolean" ? stream : void 0;
 }
 
 exports.BalanceManager = BalanceManager;
@@ -4748,10 +5541,14 @@ exports.StreamingError = StreamingError;
 exports.TokenOperationError = TokenOperationError;
 exports.createDiscoveryAdapterFromStore = createDiscoveryAdapterFromStore;
 exports.createIndexedDBDriver = createIndexedDBDriver;
+exports.createIndexedDBUsageTrackingDriver = createIndexedDBUsageTrackingDriver;
 exports.createMemoryDriver = createMemoryDriver;
+exports.createMemoryUsageTrackingDriver = createMemoryUsageTrackingDriver;
 exports.createProviderRegistryFromStore = createProviderRegistryFromStore;
+exports.createSSEParserTransform = createSSEParserTransform;
 exports.createSdkStore = createSdkStore;
 exports.createSqliteDriver = createSqliteDriver;
+exports.createSqliteUsageTrackingDriver = createSqliteUsageTrackingDriver;
 exports.createStorageAdapterFromStore = createStorageAdapterFromStore;
 exports.filterBaseUrlsForTor = filterBaseUrlsForTor;
 exports.getDefaultDiscoveryAdapter = getDefaultDiscoveryAdapter;
@@ -4759,11 +5556,13 @@ exports.getDefaultProviderRegistry = getDefaultProviderRegistry;
 exports.getDefaultSdkDriver = getDefaultSdkDriver;
 exports.getDefaultSdkStore = getDefaultSdkStore;
 exports.getDefaultStorageAdapter = getDefaultStorageAdapter;
+exports.getDefaultUsageTrackingDriver = getDefaultUsageTrackingDriver;
 exports.getProviderEndpoints = getProviderEndpoints;
 exports.isOnionUrl = isOnionUrl;
 exports.isTorContext = isTorContext;
 exports.localStorageDriver = localStorageDriver;
 exports.normalizeProviderUrl = normalizeProviderUrl;
 exports.routeRequests = routeRequests;
+exports.routeRequestsToNodeResponse = routeRequestsToNodeResponse;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map