@routstr/sdk 0.2.4 → 0.2.5

package/dist/client/index.mjs

@@ -1,3 +1,14 @@
+import { createStore } from 'zustand/vanilla';
+import { getDecodedToken } from '@cashu/cashu-ts';
+import { Transform, Readable } from 'stream';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // core/errors.ts
 var InsufficientBalanceError = class extends Error {
   constructor(required, available, maxMintBalance = 0, maxMintUrl = "", customMessage) {
@@ -466,7 +477,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(
@@ -516,7 +527,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);
@@ -689,12 +701,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);
@@ -886,8 +915,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
@@ -1040,9 +1069,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
     );
@@ -1083,7 +1113,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 };
       })
@@ -1337,6 +1368,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 = "";
@@ -1364,6 +1466,7 @@ var StreamProcessor = class {
     let finish_reason;
     let citations;
     let annotations;
+    let responseId;
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -1392,6 +1495,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;
           }
@@ -1412,6 +1518,7 @@ var StreamProcessor = class {
       images: this.accumulatedImages.length > 0 ? this.accumulatedImages : void 0,
       usage,
       model,
+      responseId,
       finish_reason,
       citations,
       annotations
@@ -1439,12 +1546,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;
       }
@@ -1836,7 +1946,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(
@@ -1850,9 +1959,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;
@@ -1965,7 +2072,1058 @@ var ProviderManager = class _ProviderManager {
   }
 };
 
-// client/RoutstrClient.ts
+// storage/drivers/localStorage.ts
+var canUseLocalStorage = () => {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+};
+var isQuotaExceeded = (error) => {
+  const e = error;
+  return !!e && (e?.name === "QuotaExceededError" || e?.code === 22 || e?.code === 1014);
+};
+var NON_CRITICAL_KEYS = /* @__PURE__ */ new Set(["modelsFromAllProviders"]);
+var localStorageDriver = {
+  async getItem(key, defaultValue) {
+    if (!canUseLocalStorage()) return defaultValue;
+    try {
+      const item = window.localStorage.getItem(key);
+      if (item === null) return defaultValue;
+      try {
+        return JSON.parse(item);
+      } catch (parseError) {
+        if (typeof defaultValue === "string") {
+          return item;
+        }
+        throw parseError;
+      }
+    } catch (error) {
+      console.error(`Error retrieving item with key "${key}":`, error);
+      if (canUseLocalStorage()) {
+        try {
+          window.localStorage.removeItem(key);
+        } catch (removeError) {
+          console.error(
+            `Error removing corrupted item with key "${key}":`,
+            removeError
+          );
+        }
+      }
+      return defaultValue;
+    }
+  },
+  async setItem(key, value) {
+    if (!canUseLocalStorage()) return;
+    try {
+      window.localStorage.setItem(key, JSON.stringify(value));
+    } catch (error) {
+      if (isQuotaExceeded(error)) {
+        if (NON_CRITICAL_KEYS.has(key)) {
+          console.warn(
+            `Storage quota exceeded; skipping non-critical key "${key}".`
+          );
+          return;
+        }
+        try {
+          window.localStorage.removeItem("modelsFromAllProviders");
+        } catch {
+        }
+        try {
+          window.localStorage.setItem(key, JSON.stringify(value));
+          return;
+        } catch (retryError) {
+          console.warn(
+            `Storage quota exceeded; unable to persist key "${key}" after cleanup attempt.`,
+            retryError
+          );
+          return;
+        }
+      }
+      console.error(`Error storing item with key "${key}":`, error);
+    }
+  },
+  async removeItem(key) {
+    if (!canUseLocalStorage()) return;
+    try {
+      window.localStorage.removeItem(key);
+    } catch (error) {
+      console.error(`Error removing item with key "${key}":`, error);
+    }
+  }
+};
+
+// storage/drivers/memory.ts
+var createMemoryDriver = (seed) => {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    async getItem(key, defaultValue) {
+      const item = store.get(key);
+      if (item === void 0) return defaultValue;
+      try {
+        return JSON.parse(item);
+      } catch (parseError) {
+        if (typeof defaultValue === "string") {
+          return item;
+        }
+        throw parseError;
+      }
+    },
+    async setItem(key, value) {
+      store.set(key, JSON.stringify(value));
+    },
+    async removeItem(key) {
+      store.delete(key);
+    }
+  };
+};
+
+// storage/drivers/sqlite.ts
+var isBun = () => {
+  return typeof process.versions.bun !== "undefined";
+};
+var 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);
+      }
+    }
+  };
+};
+
+// 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 isBrowser = typeof indexedDB !== "undefined";
+var normalizeBaseUrl = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var openDatabase = (dbName, storeName) => {
+  if (!isBrowser) {
+    return Promise.reject(new Error("IndexedDB is not available"));
+  }
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        const store = db.createObjectStore(storeName, { keyPath: "id" });
+        store.createIndex("timestamp", "timestamp", { unique: false });
+        store.createIndex("modelId", "modelId", { unique: false });
+        store.createIndex("baseUrl", "baseUrl", { unique: false });
+        store.createIndex("sessionId", "sessionId", { unique: false });
+        store.createIndex("client", "client", { unique: false });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+};
+var matchesFilters = (entry, options = {}) => {
+  if (typeof options.before === "number" && entry.timestamp >= options.before) {
+    return false;
+  }
+  if (typeof options.after === "number" && entry.timestamp <= options.after) {
+    return false;
+  }
+  if (options.modelId && entry.modelId !== options.modelId) {
+    return false;
+  }
+  if (options.baseUrl && normalizeBaseUrl(entry.baseUrl) !== normalizeBaseUrl(options.baseUrl)) {
+    return false;
+  }
+  if (options.sessionId && entry.sessionId !== options.sessionId) {
+    return false;
+  }
+  if (options.client && entry.client !== options.client) {
+    return false;
+  }
+  return true;
+};
+var createIndexedDBUsageTrackingDriver = (options = {}) => {
+  const dbName = options.dbName || DEFAULT_DB_NAME;
+  const storeName = options.storeName || DEFAULT_STORE_NAME;
+  const legacyStorageDriver = options.legacyStorageDriver;
+  let dbPromise = null;
+  let migrationPromise = null;
+  const getDb = () => {
+    if (!dbPromise) {
+      dbPromise = openDatabase(dbName, storeName);
+    }
+    return dbPromise;
+  };
+  const putMany = async (entries) => {
+    if (entries.length === 0) return;
+    const db = await getDb();
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(storeName, "readwrite");
+      const store = tx.objectStore(storeName);
+      for (const entry of entries) {
+        store.put({ ...entry, baseUrl: normalizeBaseUrl(entry.baseUrl) });
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  };
+  const ensureMigrated = async () => {
+    if (!legacyStorageDriver) return;
+    if (!migrationPromise) {
+      migrationPromise = (async () => {
+        const migrated = await legacyStorageDriver.getItem(
+          MIGRATION_MARKER_KEY,
+          false
+        );
+        if (migrated) return;
+        const legacyEntries = await legacyStorageDriver.getItem(
+          SDK_STORAGE_KEYS.USAGE_TRACKING,
+          []
+        );
+        if (legacyEntries.length > 0) {
+          await putMany(legacyEntries);
+          await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
+        }
+        await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY, true);
+      })();
+    }
+    await migrationPromise;
+  };
+  return {
+    async migrate() {
+      await ensureMigrated();
+    },
+    async append(entry) {
+      await ensureMigrated();
+      await putMany([entry]);
+    },
+    async appendMany(entries) {
+      await ensureMigrated();
+      await putMany(entries);
+    },
+    async list(options2 = {}) {
+      await ensureMigrated();
+      const db = await getDb();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readonly");
+        const store = tx.objectStore(storeName);
+        const index = store.index("timestamp");
+        const direction = "prev";
+        const request = index.openCursor(null, direction);
+        const results = [];
+        const limit = options2.limit;
+        request.onsuccess = () => {
+          const cursor = request.result;
+          if (!cursor) {
+            resolve(results);
+            return;
+          }
+          const value = cursor.value;
+          if (matchesFilters(value, options2)) {
+            results.push(value);
+            if (typeof limit === "number" && results.length >= limit) {
+              resolve(results);
+              return;
+            }
+          }
+          cursor.continue();
+        };
+        request.onerror = () => reject(request.error);
+      });
+    },
+    async count(options2 = {}) {
+      const results = await this.list(options2);
+      return results.length;
+    },
+    async deleteOlderThan(timestamp) {
+      await ensureMigrated();
+      const db = await getDb();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readwrite");
+        const store = tx.objectStore(storeName);
+        const index = store.index("timestamp");
+        const range = IDBKeyRange.upperBound(timestamp, true);
+        const request = index.openCursor(range);
+        let deleted = 0;
+        request.onsuccess = () => {
+          const cursor = request.result;
+          if (!cursor) {
+            resolve(deleted);
+            return;
+          }
+          deleted += 1;
+          cursor.delete();
+          cursor.continue();
+        };
+        request.onerror = () => reject(request.error);
+      });
+    },
+    async clear() {
+      await ensureMigrated();
+      const db = await getDb();
+      await new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readwrite");
+        tx.objectStore(storeName).clear();
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+      });
+    }
+  };
+};
+
+// storage/usageTracking/sqlite.ts
+var MIGRATION_MARKER_KEY2 = "usage_tracking_migration_v1";
+var normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var isBun2 = () => {
+  return typeof process.versions.bun !== "undefined";
+};
+var createDatabase2 = (dbPath) => {
+  if (isBun2()) {
+    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 usage tracking. Install it to use sqlite storage. (${error})`
+    );
+  }
+  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);
+      }
+    },
+    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) });
+      }
+    },
+    async list(options = {}) {
+      const entries = [...store.values()].filter((entry) => matchesFilters2(entry, options)).sort((a, b) => b.timestamp - a.timestamp);
+      if (typeof options.limit === "number") {
+        return entries.slice(0, options.limit);
+      }
+      return entries;
+    },
+    async count(options = {}) {
+      return (await this.list(options)).length;
+    },
+    async deleteOlderThan(timestamp) {
+      let deleted = 0;
+      for (const [id, entry] of store.entries()) {
+        if (entry.timestamp < timestamp) {
+          store.delete(id);
+          deleted += 1;
+        }
+      }
+      return deleted;
+    },
+    async clear() {
+      store.clear();
+    }
+  };
+};
+var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var getCashuTokenBalance = (token) => {
+  try {
+    const decoded = getDecodedToken(token);
+    const unitDivisor = decoded.unit === "msat" ? 1e3 : 1;
+    let sum = 0;
+    for (const proof of decoded.proofs) {
+      sum += proof.amount / unitDivisor;
+    }
+    return sum;
+  } catch {
+    return 0;
+  }
+};
+var createEmptyStore = (driver) => 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;
+    }
+    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
+      );
+    }
+    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;
+    }
+    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;
+    }
+    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 };
+    });
+  },
+  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 };
+    });
+  },
+  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 };
+    });
+  },
+  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
+  });
+};
+var createSdkStore = ({
+  driver
+}) => {
+  const store = createEmptyStore(driver);
+  return {
+    store,
+    hydrate: hydrateStoreFromDriver(store, driver)
+  };
+};
+
+// storage/index.ts
+var isBrowser2 = () => {
+  try {
+    return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+  } catch {
+    return false;
+  }
+};
+var isNode = () => {
+  try {
+    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+  } catch {
+    return false;
+  }
+};
+var defaultDriver = null;
+var isBun3 = () => {
+  return typeof process.versions.bun !== "undefined";
+};
+var getDefaultSdkDriver = () => {
+  if (defaultDriver) return defaultDriver;
+  if (isBrowser2()) {
+    defaultDriver = localStorageDriver;
+    return defaultDriver;
+  }
+  if (isBun3()) {
+    defaultDriver = createMemoryDriver();
+    return defaultDriver;
+  }
+  if (isNode()) {
+    defaultDriver = createSqliteDriver();
+    return defaultDriver;
+  }
+  defaultDriver = createMemoryDriver();
+  return defaultDriver;
+};
+var defaultStore = null;
+var defaultUsageTrackingDriver = null;
+var getDefaultSdkStore = () => {
+  if (!defaultStore) {
+    defaultStore = createSdkStore({ driver: getDefaultSdkDriver() });
+  }
+  return defaultStore.hydrate.then(() => defaultStore.store);
+};
+var getDefaultUsageTrackingDriver = () => {
+  if (defaultUsageTrackingDriver) return defaultUsageTrackingDriver;
+  const storageDriver = getDefaultSdkDriver();
+  if (isBrowser2()) {
+    defaultUsageTrackingDriver = createIndexedDBUsageTrackingDriver({
+      legacyStorageDriver: storageDriver
+    });
+    return defaultUsageTrackingDriver;
+  }
+  if (isBun3()) {
+    defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+    return defaultUsageTrackingDriver;
+  }
+  if (isNode()) {
+    defaultUsageTrackingDriver = createSqliteUsageTrackingDriver({
+      legacyStorageDriver: storageDriver
+    });
+    return defaultUsageTrackingDriver;
+  }
+  defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+  return defaultUsageTrackingDriver;
+};
+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 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") {
@@ -1986,7 +3144,13 @@ var RoutstrClient = class {
     this.streamProcessor = new StreamProcessor();
     this.providerManager = new ProviderManager(providerRegistry);
     this.alertLevel = alertLevel;
-    this.mode = mode;
+    if (mode === "lazyrefund") {
+      this.mode = "apikeys";
+    } else if (mode === "apikeys") {
+      this.mode = "lazyrefund";
+    } else {
+      this.mode = mode;
+    }
   }
   cashuSpender;
   balanceManager;
@@ -2060,6 +3224,80 @@ var RoutstrClient = class {
    * 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 = 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,
@@ -2115,13 +3353,43 @@ var RoutstrClient = class {
     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;
+    const contentType = response.headers.get("content-type") || "";
+    let processedResponse = response;
+    let capturedUsage;
+    let capturedResponseId;
+    if (contentType.includes("text/event-stream") && response.body) {
+      const nodeReadable = 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 = 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
@@ -2228,7 +3496,18 @@ var RoutstrClient = class {
           baseUrl: baseUrlUsed,
           initialTokenBalance: tokenBalanceInSats,
           fallbackSatsSpent: isApikeysEstimate ? this._getEstimatedCosts(selectedModel, streamingResult) : void 0,
-          response
+          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,
@@ -2645,7 +3924,16 @@ var RoutstrClient = class {
    * Handle post-response balance update for all modes
    */
   async _handlePostResponseBalanceUpdate(params) {
-    const { token, baseUrl, initialTokenBalance, fallbackSatsSpent, response } = 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;
@@ -2692,8 +3980,75 @@ var RoutstrClient = class {
         satsSpent = fallbackSatsSpent ?? initialTokenBalance;
       }
     }
+    await this._trackResponseUsage({
+      token,
+      baseUrl,
+      response,
+      modelId,
+      satsSpent,
+      usage,
+      requestId
+    });
     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
    */
@@ -2738,37 +4093,6 @@ var RoutstrClient = class {
       content: result.content || ""
     };
   }
-  /**
-   * Create a child key for a parent API key via the provider's API
-   * POST /v1/balance/child-key
-   */
-  async _createChildKey(baseUrl, parentApiKey, options) {
-    const response = await fetch(`${baseUrl}v1/balance/child-key`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${parentApiKey}`
-      },
-      body: JSON.stringify({
-        count: options?.count ?? 1,
-        balance_limit: options?.balanceLimit,
-        balance_limit_reset: options?.balanceLimitReset,
-        validity_date: options?.validityDate
-      })
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Failed to create child key: ${response.status} ${await response.text()}`
-      );
-    }
-    const data = await response.json();
-    return {
-      childKey: data.api_keys?.[0],
-      balance: data.balance ?? 0,
-      balanceLimit: data.balance_limit,
-      validityDate: data.validity_date
-    };
-  }
   /**
    * Calculate estimated costs from usage
    */
@@ -2979,6 +4303,6 @@ var RoutstrClient = class {
   }
 };
 
-export { ProviderManager, RoutstrClient, StreamProcessor };
+export { ProviderManager, RoutstrClient, StreamProcessor, createSSEParserTransform };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map