@routstr/sdk 0.3.5 → 0.3.7

package/dist/storage/index.js

@@ -1,1734 +0,0 @@
-'use strict';
-
-var vanilla = require('zustand/vanilla');
-
-// 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();
-  if (seed) {
-    for (const [key, value] of Object.entries(seed)) {
-      store.set(key, value);
-    }
-  }
-  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);
-    }
-  };
-};
-
-// core/types.ts
-function makeConsoleLogger(prefix) {
-  const fmt = (args) => prefix ? [prefix, ...args] : args;
-  return {
-    log: (...args) => console.log(...fmt(args)),
-    warn: (...args) => console.warn(...fmt(args)),
-    error: (...args) => console.error(...fmt(args)),
-    debug: (...args) => console.log(...fmt(args)),
-    child: (p) => makeConsoleLogger(prefix ? `${prefix}:${p}` : p)
-  };
-}
-var consoleLogger = makeConsoleLogger();
-
-// storage/drivers/sqlite.ts
-var isBun = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var cachedDbModule = null;
-var loadDatabase = async (dbPath) => {
-  if (isBun()) {
-    throw new Error(
-      "SQLite driver not supported in Bun. Use createBunSqliteDriver() instead."
-    );
-  }
-  try {
-    if (!cachedDbModule) {
-      cachedDbModule = (await import('better-sqlite3')).default;
-    }
-    return new cachedDbModule(dbPath);
-  } catch (error) {
-    throw new Error(
-      `better-sqlite3 is required for sqlite storage. Install it to use sqlite storage. (${error})`
-    );
-  }
-};
-var createSqliteDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "sdk_storage";
-  let db;
-  let selectStmt;
-  let upsertStmt;
-  let deleteStmt;
-  const initDb = async () => {
-    if (!db) {
-      db = await loadDatabase(dbPath);
-      db.exec(
-        `CREATE TABLE IF NOT EXISTS ${tableName} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
-      );
-      selectStmt = db.prepare(`SELECT value FROM ${tableName} WHERE key = ?`);
-      upsertStmt = db.prepare(
-        `INSERT INTO ${tableName} (key, value) VALUES (?, ?)
-     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
-      );
-      deleteStmt = db.prepare(`DELETE FROM ${tableName} WHERE key = ?`);
-    }
-  };
-  const ensureInit = async () => {
-    if (!db) {
-      await initDb();
-    }
-  };
-  return {
-    async getItem(key, defaultValue) {
-      try {
-        await ensureInit();
-        const row = selectStmt.get(key);
-        if (!row || typeof row.value !== "string") return defaultValue;
-        try {
-          return JSON.parse(row.value);
-        } catch (parseError) {
-          if (typeof defaultValue === "string") {
-            return row.value;
-          }
-          throw parseError;
-        }
-      } catch (error) {
-        console.error(`SQLite getItem failed for key "${key}":`, error);
-        return defaultValue;
-      }
-    },
-    async setItem(key, value) {
-      try {
-        await ensureInit();
-        upsertStmt.run(key, JSON.stringify(value));
-      } catch (error) {
-        console.error(`SQLite setItem failed for key "${key}":`, error);
-      }
-    },
-    async removeItem(key) {
-      try {
-        await ensureInit();
-        deleteStmt.run(key);
-      } catch (error) {
-        console.error(`SQLite removeItem failed for key "${key}":`, error);
-      }
-    }
-  };
-};
-async function createBunSqliteDriver(dbPath, options) {
-  const logger = (options?.logger ?? consoleLogger).child("BunSqliteDriver");
-  const SQLite = (await import(
-    /* webpackIgnore: true */
-    'bun:sqlite'
-  )).default;
-  const db = new SQLite(dbPath);
-  db.run(`
-    CREATE TABLE IF NOT EXISTS sdk_storage (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    )
-  `);
-  return {
-    async getItem(key, defaultValue) {
-      try {
-        const row = db.query("SELECT value FROM sdk_storage WHERE key = ?").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) {
-        logger.error(`getItem failed for key "${key}":`, error);
-        return defaultValue;
-      }
-    },
-    async setItem(key, value) {
-      try {
-        db.query(
-          "INSERT INTO sdk_storage (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
-        ).run(key, JSON.stringify(value));
-      } catch (error) {
-        logger.error(`setItem failed for key "${key}":`, error);
-      }
-    },
-    async removeItem(key) {
-      try {
-        db.query("DELETE FROM sdk_storage WHERE key = ?").run(key);
-      } catch (error) {
-        logger.error(`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"));
-  }
-  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",
-  API_KEYS: "api_keys",
-  CHILD_KEYS: "child_keys",
-  XCASHU_TOKENS: "xcashu_tokens",
-  ROUTSTR21_MODELS: "routstr21Models",
-  LAST_ROUTSTR21_MODELS_UPDATE: "lastRoutstr21ModelsUpdate",
-  CACHED_RECEIVE_TOKENS: "cached_receive_tokens",
-  USAGE_TRACKING: "usage_tracking",
-  CLIENT_IDS: "client_ids",
-  FAILED_PROVIDERS: "failed_providers",
-  LAST_FAILED: "last_failed",
-  PROVIDERS_ON_COOLDOWN: "providers_on_cooldown"
-};
-
-// storage/usageTracking/indexedDB.ts
-var DEFAULT_DB_NAME = "routstr-sdk";
-var DEFAULT_STORE_NAME = "usage_tracking";
-var MIGRATION_MARKER_KEY = "usage_tracking_migration_v1";
-var 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"));
-  }
-  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 = 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);
-      })();
-    }
-    await migrationPromise;
-  };
-  return {
-    async migrate() {
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureMigrated();
-      await putMany([entry]);
-    },
-    async appendMany(entries) {
-      await ensureMigrated();
-      await putMany(entries);
-    },
-    async list(options2 = {}) {
-      await ensureMigrated();
-      const db = await getDb();
-      return new Promise((resolve, reject) => {
-        const tx = db.transaction(storeName, "readonly");
-        const store = tx.objectStore(storeName);
-        const index = store.index("timestamp");
-        const direction = "prev";
-        const request = index.openCursor(null, direction);
-        const results = [];
-        const limit = options2.limit;
-        request.onsuccess = () => {
-          const cursor = request.result;
-          if (!cursor) {
-            resolve(results);
-            return;
-          }
-          const value = cursor.value;
-          if (matchesFilters(value, options2)) {
-            results.push(value);
-            if (typeof limit === "number" && results.length >= limit) {
-              resolve(results);
-              return;
-            }
-          }
-          cursor.continue();
-        };
-        request.onerror = () => reject(request.error);
-      });
-    },
-    async count(options2 = {}) {
-      const results = await this.list(options2);
-      return results.length;
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureMigrated();
-      const db = await getDb();
-      return new Promise((resolve, reject) => {
-        const tx = db.transaction(storeName, "readwrite");
-        const store = tx.objectStore(storeName);
-        const index = store.index("timestamp");
-        const range = IDBKeyRange.upperBound(timestamp, true);
-        const request = index.openCursor(range);
-        let deleted = 0;
-        request.onsuccess = () => {
-          const cursor = request.result;
-          if (!cursor) {
-            resolve(deleted);
-            return;
-          }
-          deleted += 1;
-          cursor.delete();
-          cursor.continue();
-        };
-        request.onerror = () => reject(request.error);
-      });
-    },
-    async clear() {
-      await ensureMigrated();
-      const db = await getDb();
-      await new Promise((resolve, reject) => {
-        const tx = db.transaction(storeName, "readwrite");
-        tx.objectStore(storeName).clear();
-        tx.oncomplete = () => resolve();
-        tx.onerror = () => reject(tx.error);
-      });
-    }
-  };
-};
-
-// storage/usageTracking/sqlite.ts
-var MIGRATION_MARKER_KEY2 = "usage_tracking_migration_v1";
-var normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var isBun2 = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var cachedDbModule2 = null;
-var loadDatabase2 = async (dbPath) => {
-  if (isBun2()) {
-    throw new Error(
-      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
-    );
-  }
-  try {
-    if (!cachedDbModule2) {
-      cachedDbModule2 = (await import('better-sqlite3')).default;
-    }
-    return new cachedDbModule2(dbPath);
-  } catch (error) {
-    throw new Error(
-      `better-sqlite3 is required for sqlite usage tracking. Install it to use sqlite storage. (${error})`
-    );
-  }
-};
-var buildWhereClause = (options = {}) => {
-  const clauses = [];
-  const params = [];
-  if (typeof options.before === "number") {
-    clauses.push("timestamp < ?");
-    params.push(options.before);
-  }
-  if (typeof options.after === "number") {
-    clauses.push("timestamp > ?");
-    params.push(options.after);
-  }
-  if (options.modelId) {
-    clauses.push("model_id = ?");
-    params.push(options.modelId);
-  }
-  if (options.baseUrl) {
-    clauses.push("base_url = ?");
-    params.push(normalizeBaseUrl2(options.baseUrl));
-  }
-  if (options.sessionId) {
-    clauses.push("session_id = ?");
-    params.push(options.sessionId);
-  }
-  if (options.client) {
-    clauses.push("client = ?");
-    params.push(options.client);
-  }
-  return {
-    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    params
-  };
-};
-var createSqliteUsageTrackingDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "usage_tracking";
-  const legacyStorageDriver = options.legacyStorageDriver;
-  let db;
-  let insertStmt;
-  let migrationComplete = false;
-  const initDb = async () => {
-    if (!db) {
-      db = await loadDatabase2(dbPath);
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS ${tableName} (
-          id TEXT PRIMARY KEY,
-          timestamp INTEGER NOT NULL,
-          model_id TEXT NOT NULL,
-          base_url TEXT NOT NULL,
-          request_id TEXT NOT NULL,
-          cost REAL NOT NULL,
-          sats_cost REAL NOT NULL,
-          prompt_tokens INTEGER NOT NULL,
-          completion_tokens INTEGER NOT NULL,
-          total_tokens INTEGER NOT NULL,
-          client TEXT,
-          session_id TEXT,
-          tags TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_session_id ON ${tableName}(session_id);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_client ON ${tableName}(client);
-      `);
-      insertStmt = db.prepare(`
-        INSERT OR REPLACE INTO ${tableName} (
-          id, timestamp, model_id, base_url, request_id,
-          cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
-          client, session_id, tags
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-    }
-  };
-  const ensureInit = async () => {
-    if (!db) {
-      await initDb();
-    }
-  };
-  const appendOne = (entry) => {
-    insertStmt.run(
-      entry.id,
-      entry.timestamp,
-      entry.modelId,
-      normalizeBaseUrl2(entry.baseUrl),
-      entry.requestId,
-      entry.cost,
-      entry.satsCost,
-      entry.promptTokens,
-      entry.completionTokens,
-      entry.totalTokens,
-      entry.client ?? null,
-      entry.sessionId ?? null,
-      JSON.stringify(entry.tags ?? [])
-    );
-  };
-  const ensureMigrated = async () => {
-    if (!legacyStorageDriver || migrationComplete) return;
-    const migrated = await legacyStorageDriver.getItem(
-      MIGRATION_MARKER_KEY2,
-      false
-    );
-    if (migrated) {
-      migrationComplete = true;
-      return;
-    }
-    const legacyEntries = await legacyStorageDriver.getItem(
-      SDK_STORAGE_KEYS.USAGE_TRACKING,
-      []
-    );
-    for (const entry of legacyEntries) {
-      appendOne(entry);
-    }
-    if (legacyEntries.length > 0) {
-      await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
-    }
-    await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY2, true);
-    migrationComplete = true;
-  };
-  const mapRow = (row) => ({
-    id: row.id,
-    timestamp: row.timestamp,
-    modelId: row.model_id,
-    baseUrl: row.base_url,
-    requestId: row.request_id,
-    cost: row.cost,
-    satsCost: row.sats_cost,
-    promptTokens: row.prompt_tokens,
-    completionTokens: row.completion_tokens,
-    totalTokens: row.total_tokens,
-    client: row.client ?? void 0,
-    sessionId: row.session_id ?? void 0,
-    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
-  });
-  return {
-    async migrate() {
-      await ensureInit();
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureInit();
-      await ensureMigrated();
-      appendOne(entry);
-    },
-    async appendMany(entries) {
-      await ensureInit();
-      await ensureMigrated();
-      for (const entry of entries) {
-        appendOne(entry);
-      }
-    },
-    async list(options2 = {}) {
-      await ensureInit();
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause(options2);
-      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
-      const stmt = db.prepare(
-        `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`
-      );
-      const rows = stmt.all(
-        ...typeof options2.limit === "number" ? [...params, options2.limit] : params
-      );
-      return rows.map(mapRow);
-    },
-    async count(options2 = {}) {
-      await ensureInit();
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause(options2);
-      const stmt = db.prepare(`SELECT COUNT(*) as count FROM ${tableName} ${sql}`);
-      const row = stmt.get(...params);
-      return Number(row?.count ?? 0);
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureInit();
-      await ensureMigrated();
-      const stmt = db.prepare(`DELETE FROM ${tableName} WHERE timestamp < ?`);
-      const result = stmt.run(timestamp);
-      return result.changes;
-    },
-    async clear() {
-      await ensureInit();
-      await ensureMigrated();
-      db.prepare(`DELETE FROM ${tableName}`).run();
-    }
-  };
-};
-
-// storage/usageTracking/bunSqlite.ts
-var MIGRATION_MARKER_KEY3 = "usage_tracking_migration_v1";
-var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var buildWhereClause2 = (options = {}) => {
-  const clauses = [];
-  const params = [];
-  if (typeof options.before === "number") {
-    clauses.push("timestamp < ?");
-    params.push(options.before);
-  }
-  if (typeof options.after === "number") {
-    clauses.push("timestamp > ?");
-    params.push(options.after);
-  }
-  if (options.modelId) {
-    clauses.push("model_id = ?");
-    params.push(options.modelId);
-  }
-  if (options.baseUrl) {
-    clauses.push("base_url = ?");
-    params.push(normalizeBaseUrl3(options.baseUrl));
-  }
-  if (options.sessionId) {
-    clauses.push("session_id = ?");
-    params.push(options.sessionId);
-  }
-  if (options.client) {
-    clauses.push("client = ?");
-    params.push(options.client);
-  }
-  return {
-    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    params
-  };
-};
-var createBunSqliteUsageTrackingDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "usage_tracking";
-  const legacyStorageDriver = options.legacyStorageDriver;
-  const SQLiteDatabase = options.sqlite?.Database;
-  let migrationPromise = null;
-  if (!SQLiteDatabase) {
-    throw new Error(
-      "Bun SQLite Database constructor is required. Pass { sqlite: { Database } } when creating the driver."
-    );
-  }
-  const db = new SQLiteDatabase(dbPath);
-  db.run(`
-    CREATE TABLE IF NOT EXISTS ${tableName} (
-      id TEXT PRIMARY KEY,
-      timestamp INTEGER NOT NULL,
-      model_id TEXT NOT NULL,
-      base_url TEXT NOT NULL,
-      request_id TEXT NOT NULL,
-      cost REAL NOT NULL,
-      sats_cost REAL NOT NULL,
-      prompt_tokens INTEGER NOT NULL,
-      completion_tokens INTEGER NOT NULL,
-      total_tokens INTEGER NOT NULL,
-      client TEXT,
-      session_id TEXT,
-      tags TEXT
-    )
-  `);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url)`);
-  const appendOne = (entry) => {
-    db.query(`
-      INSERT OR REPLACE INTO ${tableName} (
-        id, timestamp, model_id, base_url, request_id,
-        cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
-        client, session_id, tags
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      entry.id,
-      entry.timestamp,
-      entry.modelId,
-      normalizeBaseUrl3(entry.baseUrl),
-      entry.requestId,
-      entry.cost,
-      entry.satsCost,
-      entry.promptTokens,
-      entry.completionTokens,
-      entry.totalTokens,
-      entry.client ?? null,
-      entry.sessionId ?? null,
-      JSON.stringify(entry.tags ?? [])
-    );
-  };
-  const mapRow = (row) => ({
-    id: row.id,
-    timestamp: row.timestamp,
-    modelId: row.model_id,
-    baseUrl: row.base_url,
-    requestId: row.request_id,
-    cost: row.cost,
-    satsCost: row.sats_cost,
-    promptTokens: row.prompt_tokens,
-    completionTokens: row.completion_tokens,
-    totalTokens: row.total_tokens,
-    client: row.client ?? void 0,
-    sessionId: row.session_id ?? void 0,
-    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
-  });
-  const ensureMigrated = async () => {
-    if (!legacyStorageDriver) return;
-    if (!migrationPromise) {
-      migrationPromise = (async () => {
-        const migrated = await legacyStorageDriver.getItem(
-          MIGRATION_MARKER_KEY3,
-          false
-        );
-        if (migrated) return;
-        const legacyEntries = await legacyStorageDriver.getItem(
-          SDK_STORAGE_KEYS.USAGE_TRACKING,
-          []
-        );
-        if (legacyEntries.length > 0) {
-          for (const entry of legacyEntries) {
-            appendOne(entry);
-          }
-          await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
-        }
-        await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY3, true);
-      })();
-    }
-    await migrationPromise;
-  };
-  return {
-    async migrate() {
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureMigrated();
-      appendOne(entry);
-    },
-    async appendMany(entries) {
-      await ensureMigrated();
-      for (const entry of entries) {
-        appendOne(entry);
-      }
-    },
-    async list(options2 = {}) {
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause2(options2);
-      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
-      const query = `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`;
-      let rows;
-      if (typeof options2.limit === "number") {
-        rows = db.query(query).all(...params, options2.limit);
-      } else {
-        rows = db.query(query).all(...params);
-      }
-      return rows.map(mapRow);
-    },
-    async count(options2 = {}) {
-      const { sql, params } = buildWhereClause2(options2);
-      const query = `SELECT COUNT(*) as count FROM ${tableName} ${sql}`;
-      const row = db.query(query).get(...params);
-      return Number(row?.count ?? 0);
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureMigrated();
-      const before = timestamp;
-      const result = db.query(`DELETE FROM ${tableName} WHERE timestamp < ?`).run(before);
-      return result.changes ?? 0;
-    },
-    async clear() {
-      await ensureMigrated();
-      db.query(`DELETE FROM ${tableName}`).run();
-    }
-  };
-};
-
-// storage/usageTracking/memory.ts
-var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var matchesFilters2 = (entry, options = {}) => {
-  if (typeof options.before === "number" && entry.timestamp >= options.before) {
-    return false;
-  }
-  if (typeof options.after === "number" && entry.timestamp <= options.after) {
-    return false;
-  }
-  if (options.modelId && entry.modelId !== options.modelId) {
-    return false;
-  }
-  if (options.baseUrl && normalizeBaseUrl4(entry.baseUrl) !== normalizeBaseUrl4(options.baseUrl)) {
-    return false;
-  }
-  if (options.sessionId && entry.sessionId !== options.sessionId) {
-    return false;
-  }
-  if (options.client && entry.client !== options.client) {
-    return false;
-  }
-  return true;
-};
-var createMemoryUsageTrackingDriver = (seed = []) => {
-  const store = /* @__PURE__ */ new Map();
-  for (const entry of seed) {
-    store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
-  }
-  return {
-    async migrate() {
-      return;
-    },
-    async append(entry) {
-      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
-    },
-    async appendMany(entries) {
-      for (const entry of entries) {
-        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
-      }
-    },
-    async list(options = {}) {
-      const entries = [...store.values()].filter((entry) => matchesFilters2(entry, options)).sort((a, b) => b.timestamp - a.timestamp);
-      if (typeof options.limit === "number") {
-        return entries.slice(0, options.limit);
-      }
-      return entries;
-    },
-    async count(options = {}) {
-      return (await this.list(options)).length;
-    },
-    async deleteOlderThan(timestamp) {
-      let deleted = 0;
-      for (const [id, entry] of store.entries()) {
-        if (entry.timestamp < timestamp) {
-          store.delete(id);
-          deleted += 1;
-        }
-      }
-      return deleted;
-    },
-    async clear() {
-      store.clear();
-    }
-  };
-};
-var normalizeBaseUrl5 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
-  modelsFromAllProviders: {},
-  lastUsedModel: null,
-  baseUrlsList: [],
-  lastBaseUrlsUpdate: null,
-  disabledProviders: [],
-  mintsFromAllProviders: {},
-  infoFromAllProviders: {},
-  lastModelsUpdate: {},
-  apiKeys: [],
-  childKeys: [],
-  xcashuTokens: {},
-  routstr21Models: [],
-  lastRoutstr21ModelsUpdate: null,
-  cachedReceiveTokens: [],
-  clientIds: [],
-  failedProviders: [],
-  lastFailed: {},
-  providersOnCooldown: [],
-  setModelsFromAllProviders: (value) => {
-    const normalized = {};
-    for (const [baseUrl, models] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = models;
-    }
-    void driver.setItem(
-      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
-      normalized
-    );
-    set({ modelsFromAllProviders: normalized });
-  },
-  setLastUsedModel: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
-    set({ lastUsedModel: value });
-  },
-  setBaseUrlsList: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl5(url));
-    void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
-    set({ baseUrlsList: normalized });
-  },
-  setBaseUrlsLastUpdate: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
-    set({ lastBaseUrlsUpdate: value });
-  },
-  setDisabledProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl5(url));
-    void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
-    set({ disabledProviders: normalized });
-  },
-  setMintsFromAllProviders: (value) => {
-    const normalized = {};
-    for (const [baseUrl, mints] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = mints.map(
-        (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
-      );
-    }
-    void driver.setItem(
-      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
-      normalized
-    );
-    set({ mintsFromAllProviders: normalized });
-  },
-  setInfoFromAllProviders: (value) => {
-    const normalized = {};
-    for (const [baseUrl, info] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = info;
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
-    set({ infoFromAllProviders: normalized });
-  },
-  setLastModelsUpdate: (value) => {
-    const normalized = {};
-    for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = timestamp;
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
-    set({ lastModelsUpdate: normalized });
-  },
-  setApiKeys: (value) => {
-    set((state) => {
-      const updates = typeof value === "function" ? value(state.apiKeys) : value;
-      const normalized = updates.map((entry) => ({
-        ...entry,
-        baseUrl: normalizeBaseUrl5(entry.baseUrl),
-        balance: entry.balance ?? 0,
-        lastUsed: entry.lastUsed ?? null
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.API_KEYS, normalized);
-      return { apiKeys: normalized };
-    });
-  },
-  setChildKeys: (value) => {
-    set((state) => {
-      const updates = typeof value === "function" ? value(state.childKeys) : value;
-      const normalized = updates.map((entry) => ({
-        parentBaseUrl: normalizeBaseUrl5(entry.parentBaseUrl),
-        childKey: entry.childKey,
-        balance: entry.balance ?? 0,
-        balanceLimit: entry.balanceLimit,
-        validityDate: entry.validityDate,
-        createdAt: entry.createdAt ?? Date.now()
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
-      return { childKeys: normalized };
-    });
-  },
-  setXcashuTokens: (value) => {
-    const normalized = {};
-    for (const [baseUrl, tokens] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = tokens.map((entry) => ({
-        ...entry,
-        baseUrl: normalizeBaseUrl5(entry.baseUrl),
-        createdAt: entry.createdAt ?? Date.now(),
-        tryCount: entry.tryCount ?? 0
-      }));
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, normalized);
-    set({ xcashuTokens: normalized });
-  },
-  updateXcashuTokenTryCount: (token, tryCount) => {
-    const currentTokens = get().xcashuTokens;
-    const updatedTokens = {};
-    for (const [baseUrl, tokens] of Object.entries(currentTokens)) {
-      updatedTokens[baseUrl] = tokens.map(
-        (entry) => entry.token === token ? { ...entry, tryCount } : entry
-      );
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, updatedTokens);
-    set({ xcashuTokens: updatedTokens });
-  },
-  setRoutstr21Models: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
-    set({ routstr21Models: value });
-  },
-  setRoutstr21ModelsLastUpdate: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE, value);
-    set({ lastRoutstr21ModelsUpdate: value });
-  },
-  setCachedReceiveTokens: (value) => {
-    const normalized = value.map((entry) => ({
-      token: entry.token,
-      amount: entry.amount,
-      unit: entry.unit || "sat",
-      createdAt: entry.createdAt ?? Date.now()
-    }));
-    void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
-    set({ cachedReceiveTokens: normalized });
-  },
-  setClientIds: (value) => {
-    set((state) => {
-      const updates = typeof value === "function" ? value(state.clientIds) : value;
-      const normalized = updates.map((entry) => ({
-        ...entry,
-        createdAt: entry.createdAt ?? Date.now(),
-        lastUsed: entry.lastUsed ?? null
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.CLIENT_IDS, normalized);
-      return { clientIds: normalized };
-    });
-  },
-  // ========== Failure Tracking ==========
-  setFailedProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl5(url));
-    void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, normalized);
-    set({ failedProviders: normalized });
-  },
-  addFailedProvider: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().failedProviders;
-    if (!current.includes(normalized)) {
-      const updated = [...current, normalized];
-      void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
-      set({ failedProviders: updated });
-    }
-  },
-  removeFailedProvider: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().failedProviders;
-    const updated = current.filter((url) => url !== normalized);
-    void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
-    set({ failedProviders: updated });
-  },
-  setLastFailed: (value) => {
-    const normalized = {};
-    for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = timestamp;
-    }
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, normalized);
-    set({ lastFailed: normalized });
-  },
-  setLastFailedTimestamp: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().lastFailed;
-    const updated = { ...current, [normalized]: timestamp };
-    void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, updated);
-    set({ lastFailed: updated });
-  },
-  setProvidersOnCooldown: (value) => {
-    const normalized = value.map((entry) => ({
-      baseUrl: normalizeBaseUrl5(entry.baseUrl),
-      timestamp: entry.timestamp
-    }));
-    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, normalized);
-    set({ providersOnCooldown: normalized });
-  },
-  addProviderOnCooldown: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().providersOnCooldown;
-    if (!current.some((entry) => entry.baseUrl === normalized)) {
-      const updated = [...current, { baseUrl: normalized, timestamp }];
-      void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
-      set({ providersOnCooldown: updated });
-    }
-  },
-  removeProviderFromCooldown: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const current = get().providersOnCooldown;
-    const updated = current.filter((entry) => entry.baseUrl !== normalized);
-    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
-    set({ providersOnCooldown: updated });
-  },
-  clearProvidersOnCooldown: () => {
-    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, []);
-    set({ providersOnCooldown: [] });
-  }
-}));
-var hydrateStoreFromDriver = async (store, driver) => {
-  const [
-    rawModels,
-    lastUsedModel,
-    rawBaseUrls,
-    lastBaseUrlsUpdate,
-    rawDisabledProviders,
-    rawMints,
-    rawInfo,
-    rawLastModelsUpdate,
-    rawApiKeys,
-    rawChildKeys,
-    rawXcashuTokens,
-    rawRoutstr21Models,
-    rawLastRoutstr21ModelsUpdate,
-    rawCachedReceiveTokens,
-    rawClientIds,
-    rawFailedProviders,
-    rawLastFailed,
-    rawProvidersOnCooldown
-  ] = await Promise.all([
-    driver.getItem(
-      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
-      {}
-    ),
-    driver.getItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, null),
-    driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []),
-    driver.getItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, null),
-    driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []),
-    driver.getItem(
-      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
-      {}
-    ),
-    driver.getItem(
-      SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
-      {}
-    ),
-    driver.getItem(
-      SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
-      {}
-    ),
-    driver.getItem(SDK_STORAGE_KEYS.API_KEYS, []),
-    driver.getItem(SDK_STORAGE_KEYS.CHILD_KEYS, []),
-    driver.getItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, {}),
-    driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
-    driver.getItem(
-      SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
-      null
-    ),
-    driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
-    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, []),
-    driver.getItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, []),
-    driver.getItem(SDK_STORAGE_KEYS.LAST_FAILED, {}),
-    driver.getItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, [])
-  ]);
-  const modelsFromAllProviders = Object.fromEntries(
-    Object.entries(rawModels).map(([baseUrl, models]) => [
-      normalizeBaseUrl5(baseUrl),
-      models
-    ])
-  );
-  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl5(url));
-  const disabledProviders = rawDisabledProviders.map(
-    (url) => normalizeBaseUrl5(url)
-  );
-  const mintsFromAllProviders = Object.fromEntries(
-    Object.entries(rawMints).map(([baseUrl, mints]) => [
-      normalizeBaseUrl5(baseUrl),
-      mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
-    ])
-  );
-  const infoFromAllProviders = Object.fromEntries(
-    Object.entries(rawInfo).map(([baseUrl, info]) => [
-      normalizeBaseUrl5(baseUrl),
-      info
-    ])
-  );
-  const lastModelsUpdate = Object.fromEntries(
-    Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl5(baseUrl),
-      timestamp
-    ])
-  );
-  const apiKeys = rawApiKeys.map((entry) => ({
-    ...entry,
-    baseUrl: normalizeBaseUrl5(entry.baseUrl),
-    balance: entry.balance ?? 0,
-    lastUsed: entry.lastUsed ?? null
-  }));
-  const childKeys = rawChildKeys.map((entry) => ({
-    parentBaseUrl: normalizeBaseUrl5(entry.parentBaseUrl),
-    childKey: entry.childKey,
-    balance: entry.balance ?? 0,
-    balanceLimit: entry.balanceLimit,
-    validityDate: entry.validityDate,
-    createdAt: entry.createdAt ?? Date.now()
-  }));
-  const xcashuTokens = Object.fromEntries(
-    Object.entries(rawXcashuTokens).map(([baseUrl, tokens]) => [
-      normalizeBaseUrl5(baseUrl),
-      tokens.map((entry) => ({
-        baseUrl: normalizeBaseUrl5(entry.baseUrl),
-        token: entry.token,
-        createdAt: entry.createdAt ?? Date.now(),
-        tryCount: entry.tryCount ?? 0
-      }))
-    ])
-  );
-  const routstr21Models = rawRoutstr21Models;
-  const lastRoutstr21ModelsUpdate = rawLastRoutstr21ModelsUpdate;
-  const cachedReceiveTokens = rawCachedReceiveTokens?.map((entry) => ({
-    token: entry.token,
-    amount: entry.amount,
-    unit: entry.unit || "sat",
-    createdAt: entry.createdAt ?? Date.now()
-  }));
-  const clientIds = rawClientIds.map((entry) => ({
-    ...entry,
-    createdAt: entry.createdAt ?? Date.now(),
-    lastUsed: entry.lastUsed ?? null
-  }));
-  const failedProviders = rawFailedProviders.map((url) => normalizeBaseUrl5(url));
-  const lastFailed = Object.fromEntries(
-    Object.entries(rawLastFailed).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl5(baseUrl),
-      timestamp
-    ])
-  );
-  const providersOnCooldown = rawProvidersOnCooldown.map((entry) => ({
-    baseUrl: normalizeBaseUrl5(entry.baseUrl),
-    timestamp: entry.timestamp
-  }));
-  store.setState({
-    modelsFromAllProviders,
-    lastUsedModel,
-    baseUrlsList,
-    lastBaseUrlsUpdate,
-    disabledProviders,
-    mintsFromAllProviders,
-    infoFromAllProviders,
-    lastModelsUpdate,
-    apiKeys,
-    childKeys,
-    xcashuTokens,
-    routstr21Models,
-    lastRoutstr21ModelsUpdate,
-    cachedReceiveTokens,
-    clientIds,
-    failedProviders,
-    lastFailed,
-    providersOnCooldown
-  });
-};
-var createSdkStore = ({
-  driver
-}) => {
-  const store = createEmptyStore(driver);
-  return {
-    store,
-    hydrate: hydrateStoreFromDriver(store, driver)
-  };
-};
-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 = normalizeBaseUrl5(baseUrl);
-    const timestamps = store.getState().lastModelsUpdate;
-    return timestamps[normalized] || null;
-  },
-  setProviderLastUpdate: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl5(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) => ({
-  getApiKeyDistribution: () => {
-    const apiKeys = store.getState().apiKeys;
-    const distributionMap = {};
-    for (const entry of apiKeys) {
-      const sum = entry.balance || 0;
-      distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
-    }
-    return Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
-  },
-  saveProviderInfo: (baseUrl, info) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const next = { ...store.getState().infoFromAllProviders };
-    next[normalized] = info;
-    store.getState().setInfoFromAllProviders(next);
-  },
-  getProviderInfo: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    return store.getState().infoFromAllProviders[normalized] || null;
-  },
-  // ========== API Keys (for apikeys mode) ==========
-  getApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const entry = store.getState().apiKeys.find((key) => key.baseUrl === normalized);
-    if (!entry) return null;
-    return entry;
-  },
-  setApiKey: (baseUrl, key) => {
-    const normalized = normalizeBaseUrl5(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}`);
-    }
-    const next = [...keys];
-    next.push({
-      baseUrl: normalized,
-      key,
-      balance: 0,
-      lastUsed: Date.now()
-    });
-    store.getState().setApiKeys(next);
-  },
-  updateApiKeyBalance: (baseUrl, balance) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const keys = store.getState().apiKeys;
-    const next = keys.map(
-      (entry) => entry.baseUrl === normalized ? { ...entry, balance, lastUsed: Date.now() } : entry
-    );
-    store.getState().setApiKeys(next);
-  },
-  removeApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(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 = normalizeBaseUrl5(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 = normalizeBaseUrl5(parentBaseUrl);
-    const keys = store.getState().childKeys;
-    const existingIndex = keys.findIndex(
-      (entry) => entry.parentBaseUrl === normalized
-    );
-    if (existingIndex !== -1) {
-      const next = keys.map(
-        (entry) => entry.parentBaseUrl === normalized ? {
-          ...entry,
-          childKey,
-          balance: balance ?? 0,
-          validityDate,
-          balanceLimit,
-          createdAt: Date.now()
-        } : entry
-      );
-      store.getState().setChildKeys(next);
-    } else {
-      const next = [...keys];
-      next.push({
-        parentBaseUrl: normalized,
-        childKey,
-        balance: balance ?? 0,
-        validityDate,
-        balanceLimit,
-        createdAt: Date.now()
-      });
-      store.getState().setChildKeys(next);
-    }
-  },
-  updateChildKeyBalance: (parentBaseUrl, balance) => {
-    const normalized = normalizeBaseUrl5(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 = normalizeBaseUrl5(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);
-  },
-  // ========== XCashu Tokens (multiple tokens per baseUrl) ==========
-  getXcashuTokens: () => {
-    return store.getState().xcashuTokens;
-  },
-  getXcashuTokensForBaseUrl: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    return store.getState().xcashuTokens[normalized] || [];
-  },
-  addXcashuToken: (baseUrl, token) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const tokens = store.getState().xcashuTokens;
-    const existing = tokens[normalized] || [];
-    const next = { ...tokens };
-    next[normalized] = [
-      ...existing,
-      { baseUrl: normalized, token, createdAt: Date.now(), tryCount: 0 }
-    ];
-    store.getState().setXcashuTokens(next);
-  },
-  removeXcashuToken: (baseUrl, token) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const tokens = store.getState().xcashuTokens;
-    const existing = tokens[normalized] || [];
-    const next = { ...tokens };
-    next[normalized] = existing.filter((entry) => entry.token !== token);
-    if (next[normalized].length === 0) {
-      delete next[normalized];
-    }
-    store.getState().setXcashuTokens(next);
-  },
-  clearXcashuTokensForBaseUrl: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const tokens = store.getState().xcashuTokens;
-    const next = { ...tokens };
-    delete next[normalized];
-    store.getState().setXcashuTokens(next);
-  },
-  updateXcashuTokenTryCount: (token, tryCount) => {
-    store.getState().updateXcashuTokenTryCount(token, tryCount);
-  }
-});
-var createProviderRegistryFromStore = (store, logger) => {
-  const log = (logger ?? consoleLogger).child("ProviderRegistry");
-  return {
-    getModelsForProvider: (baseUrl) => {
-      const normalized = normalizeBaseUrl5(baseUrl);
-      return store.getState().modelsFromAllProviders[normalized] || [];
-    },
-    getDisabledProviders: () => store.getState().disabledProviders,
-    getProviderMints: (baseUrl) => {
-      const normalized = normalizeBaseUrl5(baseUrl);
-      return store.getState().mintsFromAllProviders[normalized] || [];
-    },
-    getProviderInfo: async (baseUrl) => {
-      const normalized = normalizeBaseUrl5(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) {
-        log.warn(`Failed to fetch provider info from ${normalized}:`, error);
-        return null;
-      }
-    },
-    getAllProvidersModels: () => store.getState().modelsFromAllProviders
-  };
-};
-
-// storage/index.ts
-var isBrowser3 = () => {
-  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 (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 = createBunSqliteUsageTrackingDriver();
-    return defaultUsageTrackingDriver;
-  }
-  if (isNode()) {
-    defaultUsageTrackingDriver = createSqliteUsageTrackingDriver({
-      legacyStorageDriver: storageDriver
-    });
-    return defaultUsageTrackingDriver;
-  }
-  defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
-  return defaultUsageTrackingDriver;
-};
-var setDefaultUsageTrackingDriver = (driver) => {
-  defaultUsageTrackingDriver = driver;
-};
-var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
-var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
-var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(await getDefaultSdkStore());
-
-exports.SDK_STORAGE_KEYS = SDK_STORAGE_KEYS;
-exports.createBunSqliteDriver = createBunSqliteDriver;
-exports.createBunSqliteUsageTrackingDriver = createBunSqliteUsageTrackingDriver;
-exports.createDiscoveryAdapterFromStore = createDiscoveryAdapterFromStore;
-exports.createIndexedDBDriver = createIndexedDBDriver;
-exports.createIndexedDBUsageTrackingDriver = createIndexedDBUsageTrackingDriver;
-exports.createMemoryDriver = createMemoryDriver;
-exports.createMemoryUsageTrackingDriver = createMemoryUsageTrackingDriver;
-exports.createProviderRegistryFromStore = createProviderRegistryFromStore;
-exports.createSdkStore = createSdkStore;
-exports.createSqliteDriver = createSqliteDriver;
-exports.createSqliteUsageTrackingDriver = createSqliteUsageTrackingDriver;
-exports.createStorageAdapterFromStore = createStorageAdapterFromStore;
-exports.getDefaultDiscoveryAdapter = getDefaultDiscoveryAdapter;
-exports.getDefaultProviderRegistry = getDefaultProviderRegistry;
-exports.getDefaultSdkDriver = getDefaultSdkDriver;
-exports.getDefaultSdkStore = getDefaultSdkStore;
-exports.getDefaultStorageAdapter = getDefaultStorageAdapter;
-exports.getDefaultUsageTrackingDriver = getDefaultUsageTrackingDriver;
-exports.localStorageDriver = localStorageDriver;
-exports.setDefaultUsageTrackingDriver = setDefaultUsageTrackingDriver;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map