@routstr/sdk 0.3.9 → 0.3.11

package/dist/storage/node.mjs

@@ -0,0 +1,2012 @@
+import { createStore } from '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);
+    }
+  };
+};
+
+// 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, 2);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+      if (storeName !== "usage_tracking" && !db.objectStoreNames.contains("usage_tracking")) {
+        const utStore = db.createObjectStore("usage_tracking", { keyPath: "id" });
+        utStore.createIndex("timestamp", "timestamp", { unique: false });
+        utStore.createIndex("modelId", "modelId", { unique: false });
+        utStore.createIndex("baseUrl", "baseUrl", { unique: false });
+        utStore.createIndex("sessionId", "sessionId", { unique: false });
+        utStore.createIndex("client", "client", { unique: false });
+      }
+      if (storeName !== "sdk_storage" && !db.objectStoreNames.contains("sdk_storage")) {
+        db.createObjectStore("sdk_storage");
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+    request.onblocked = () => {
+      console.warn(
+        `[IndexedDB driver] open blocked for "${dbName}" (store: "${storeName}") \u2014 close other tabs using this DB`
+      );
+      reject(new Error(`IndexedDB "${dbName}" blocked by another connection`));
+    };
+  });
+};
+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/aggregate.ts
+var pad2 = (n) => String(n).padStart(2, "0");
+var aggregateColumns = "COUNT(*) AS requests, COALESCE(SUM(prompt_tokens), 0) AS promptTokens, COALESCE(SUM(completion_tokens), 0) AS completionTokens, COALESCE(SUM(total_tokens), 0) AS totalTokens, COALESCE(SUM(cost), 0) AS cost, COALESCE(SUM(sats_cost), 0) AS satsCost, COALESCE(SUM(base_msats), 0) AS baseMsats, COALESCE(SUM(input_msats), 0) AS inputMsats, COALESCE(SUM(output_msats), 0) AS outputMsats, COALESCE(SUM(total_msats), 0) AS totalMsats, COALESCE(SUM(total_usd), 0) AS totalUsd, COALESCE(SUM(cache_read_input_tokens), 0) AS cacheReadInputTokens, COALESCE(SUM(cache_creation_input_tokens), 0) AS cacheCreationInputTokens, COALESCE(SUM(cache_read_msats), 0) AS cacheReadMsats, COALESCE(SUM(cache_creation_msats), 0) AS cacheCreationMsats";
+var sqlGroupExpr = (groupBy) => {
+  switch (groupBy) {
+    case "modelId":
+      return { expr: "model_id", usesTz: false };
+    case "baseUrl":
+      return { expr: "base_url", usesTz: false };
+    case "client":
+      return { expr: "client", usesTz: false };
+    case "sessionId":
+      return { expr: "session_id", usesTz: false };
+    case "provider":
+      return { expr: "provider", usesTz: false };
+    case "day":
+      return {
+        expr: "strftime('%Y-%m-%d', (timestamp - ? * 60000) / 1000, 'unixepoch')",
+        usesTz: true
+      };
+    case "hour":
+      return {
+        expr: "strftime('%H', (timestamp - ? * 60000) / 1000, 'unixepoch')",
+        usesTz: true
+      };
+  }
+};
+var buildAggregateSql = (tableName, where, options = {}) => {
+  if (!options.groupBy) {
+    return {
+      sql: `SELECT NULL AS grp, ${aggregateColumns} FROM ${tableName} ${where.sql}`,
+      params: where.params
+    };
+  }
+  const { expr, usesTz } = sqlGroupExpr(options.groupBy);
+  const tzParams = usesTz ? [options.tzOffsetMinutes ?? 0] : [];
+  const orderBy = options.groupBy === "day" || options.groupBy === "hour" ? "ORDER BY grp ASC" : "ORDER BY satsCost DESC";
+  return {
+    sql: `SELECT ${expr} AS grp, ${aggregateColumns} FROM ${tableName} ${where.sql} GROUP BY grp ${orderBy}`,
+    params: [...tzParams, ...where.params]
+  };
+};
+var mapAggregateRow = (row) => ({
+  group: row.grp == null ? null : String(row.grp),
+  requests: Number(row.requests ?? 0),
+  promptTokens: Number(row.promptTokens ?? 0),
+  completionTokens: Number(row.completionTokens ?? 0),
+  totalTokens: Number(row.totalTokens ?? 0),
+  cost: Number(row.cost ?? 0),
+  satsCost: Number(row.satsCost ?? 0),
+  baseMsats: Number(row.baseMsats ?? 0),
+  inputMsats: Number(row.inputMsats ?? 0),
+  outputMsats: Number(row.outputMsats ?? 0),
+  totalMsats: Number(row.totalMsats ?? 0),
+  totalUsd: Number(row.totalUsd ?? 0),
+  cacheReadInputTokens: Number(row.cacheReadInputTokens ?? 0),
+  cacheCreationInputTokens: Number(row.cacheCreationInputTokens ?? 0),
+  cacheReadMsats: Number(row.cacheReadMsats ?? 0),
+  cacheCreationMsats: Number(row.cacheCreationMsats ?? 0)
+});
+var jsGroupKey = (entry, groupBy, tzOffsetMinutes) => {
+  switch (groupBy) {
+    case "modelId":
+      return entry.modelId ?? null;
+    case "baseUrl":
+      return entry.baseUrl ?? null;
+    case "client":
+      return entry.client ?? null;
+    case "sessionId":
+      return entry.sessionId ?? null;
+    case "provider":
+      return entry.provider ?? null;
+    case "day": {
+      const d = new Date(entry.timestamp - tzOffsetMinutes * 6e4);
+      return `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+    }
+    case "hour": {
+      const d = new Date(entry.timestamp - tzOffsetMinutes * 6e4);
+      return pad2(d.getUTCHours());
+    }
+  }
+};
+var reduceAggregate = (entries, options = {}) => {
+  const emptyRow = (group) => ({
+    group,
+    requests: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+    cost: 0,
+    satsCost: 0,
+    baseMsats: 0,
+    inputMsats: 0,
+    outputMsats: 0,
+    totalMsats: 0,
+    totalUsd: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheReadMsats: 0,
+    cacheCreationMsats: 0
+  });
+  const accumulate = (row, entry) => {
+    row.requests += 1;
+    row.promptTokens += entry.promptTokens;
+    row.completionTokens += entry.completionTokens;
+    row.totalTokens += entry.totalTokens;
+    row.cost += entry.cost;
+    row.satsCost += entry.satsCost;
+    row.baseMsats += entry.baseMsats ?? 0;
+    row.inputMsats += entry.inputMsats ?? 0;
+    row.outputMsats += entry.outputMsats ?? 0;
+    row.totalMsats += entry.totalMsats ?? 0;
+    row.totalUsd += entry.totalUsd ?? 0;
+    row.cacheReadInputTokens += entry.cacheReadInputTokens ?? 0;
+    row.cacheCreationInputTokens += entry.cacheCreationInputTokens ?? 0;
+    row.cacheReadMsats += entry.cacheReadMsats ?? 0;
+    row.cacheCreationMsats += entry.cacheCreationMsats ?? 0;
+  };
+  if (!options.groupBy) {
+    const total = emptyRow(null);
+    for (const entry of entries) accumulate(total, entry);
+    return [total];
+  }
+  const tz = options.tzOffsetMinutes ?? 0;
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = jsGroupKey(entry, options.groupBy, tz);
+    let row = groups.get(key);
+    if (!row) {
+      row = emptyRow(key);
+      groups.set(key, row);
+    }
+    accumulate(row, entry);
+  }
+  const rows = [...groups.values()];
+  if (options.groupBy === "day" || options.groupBy === "hour") {
+    rows.sort((a, b) => (a.group ?? "").localeCompare(b.group ?? ""));
+  } else {
+    rows.sort((a, b) => b.satsCost - a.satsCost);
+  }
+  return rows;
+};
+
+// 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, 3);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      const tx = request.transaction;
+      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 });
+        store.createIndex("provider", "provider", { unique: false });
+      } else if (tx) {
+        const store = tx.objectStore(storeName);
+        if (!store.indexNames.contains("provider")) {
+          store.createIndex("provider", "provider", { unique: false });
+        }
+      }
+      if (storeName !== "sdk_storage" && !db.objectStoreNames.contains("sdk_storage")) {
+        db.createObjectStore("sdk_storage");
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+    request.onblocked = () => {
+      console.warn(
+        `[usageTracking IndexedDB] open blocked for "${dbName}" \u2014 close other tabs using this DB`
+      );
+      reject(new Error(`IndexedDB "${dbName}" blocked by another connection`));
+    };
+  });
+};
+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;
+  }
+  if (options.clients && options.clients.length > 0 && (entry.client == null || !options.clients.includes(entry.client))) {
+    return false;
+  }
+  if (options.provider && entry.provider !== options.provider) {
+    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 aggregate(options2 = {}) {
+      const entries = await this.list(options2);
+      return reduceAggregate(entries, options2);
+    },
+    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/memory.ts
+var normalizeBaseUrl2 = (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 && normalizeBaseUrl2(entry.baseUrl) !== normalizeBaseUrl2(options.baseUrl)) {
+    return false;
+  }
+  if (options.sessionId && entry.sessionId !== options.sessionId) {
+    return false;
+  }
+  if (options.client && entry.client !== options.client) {
+    return false;
+  }
+  if (options.clients && options.clients.length > 0 && (entry.client == null || !options.clients.includes(entry.client))) {
+    return false;
+  }
+  if (options.provider && entry.provider !== options.provider) {
+    return false;
+  }
+  return true;
+};
+var createMemoryUsageTrackingDriver = (seed = []) => {
+  const store = /* @__PURE__ */ new Map();
+  for (const entry of seed) {
+    store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl2(entry.baseUrl) });
+  }
+  return {
+    async migrate() {
+      return;
+    },
+    async append(entry) {
+      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl2(entry.baseUrl) });
+    },
+    async appendMany(entries) {
+      for (const entry of entries) {
+        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl2(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 aggregate(options = {}) {
+      const entries = [...store.values()].filter((entry) => matchesFilters2(entry, options));
+      return reduceAggregate(entries, options);
+    },
+    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();
+    }
+  };
+};
+
+// 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/store.ts
+var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var createEmptyStore = (driver) => 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[normalizeBaseUrl3(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) => normalizeBaseUrl3(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) => normalizeBaseUrl3(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[normalizeBaseUrl3(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[normalizeBaseUrl3(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[normalizeBaseUrl3(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: normalizeBaseUrl3(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: normalizeBaseUrl3(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[normalizeBaseUrl3(baseUrl)] = tokens.map((entry) => ({
+        ...entry,
+        baseUrl: normalizeBaseUrl3(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) => normalizeBaseUrl3(url));
+    void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, normalized);
+    set({ failedProviders: normalized });
+  },
+  addFailedProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl3(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 = normalizeBaseUrl3(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[normalizeBaseUrl3(baseUrl)] = timestamp;
+    }
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, normalized);
+    set({ lastFailed: normalized });
+  },
+  setLastFailedTimestamp: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl3(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: normalizeBaseUrl3(entry.baseUrl),
+      timestamp: entry.timestamp
+    }));
+    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, normalized);
+    set({ providersOnCooldown: normalized });
+  },
+  addProviderOnCooldown: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl3(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 = normalizeBaseUrl3(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]) => [
+      normalizeBaseUrl3(baseUrl),
+      models
+    ])
+  );
+  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl3(url));
+  const disabledProviders = rawDisabledProviders.map(
+    (url) => normalizeBaseUrl3(url)
+  );
+  const mintsFromAllProviders = Object.fromEntries(
+    Object.entries(rawMints).map(([baseUrl, mints]) => [
+      normalizeBaseUrl3(baseUrl),
+      mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
+    ])
+  );
+  const infoFromAllProviders = Object.fromEntries(
+    Object.entries(rawInfo).map(([baseUrl, info]) => [
+      normalizeBaseUrl3(baseUrl),
+      info
+    ])
+  );
+  const lastModelsUpdate = Object.fromEntries(
+    Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
+      normalizeBaseUrl3(baseUrl),
+      timestamp
+    ])
+  );
+  const apiKeys = rawApiKeys.map((entry) => ({
+    ...entry,
+    baseUrl: normalizeBaseUrl3(entry.baseUrl),
+    balance: entry.balance ?? 0,
+    lastUsed: entry.lastUsed ?? null
+  }));
+  const childKeys = rawChildKeys.map((entry) => ({
+    parentBaseUrl: normalizeBaseUrl3(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]) => [
+      normalizeBaseUrl3(baseUrl),
+      tokens.map((entry) => ({
+        baseUrl: normalizeBaseUrl3(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) => normalizeBaseUrl3(url)
+  );
+  const lastFailed = Object.fromEntries(
+    Object.entries(rawLastFailed).map(([baseUrl, timestamp]) => [
+      normalizeBaseUrl3(baseUrl),
+      timestamp
+    ])
+  );
+  const providersOnCooldown = rawProvidersOnCooldown.map((entry) => ({
+    baseUrl: normalizeBaseUrl3(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 = normalizeBaseUrl3(baseUrl);
+    const timestamps = store.getState().lastModelsUpdate;
+    return timestamps[normalized] || null;
+  },
+  setProviderLastUpdate: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl3(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,
+  setDisabledProviders: (urls) => store.getState().setDisabledProviders(urls),
+  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 = normalizeBaseUrl3(baseUrl);
+    const next = { ...store.getState().infoFromAllProviders };
+    next[normalized] = info;
+    store.getState().setInfoFromAllProviders(next);
+  },
+  getProviderInfo: (baseUrl) => {
+    const normalized = normalizeBaseUrl3(baseUrl);
+    return store.getState().infoFromAllProviders[normalized] || null;
+  },
+  // ========== API Keys (for apikeys mode) ==========
+  getApiKey: (baseUrl) => {
+    const normalized = normalizeBaseUrl3(baseUrl);
+    const entry = store.getState().apiKeys.find((key) => key.baseUrl === normalized);
+    if (!entry) return null;
+    return entry;
+  },
+  setApiKey: (baseUrl, key) => {
+    const normalized = normalizeBaseUrl3(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 = normalizeBaseUrl3(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 = normalizeBaseUrl3(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 = normalizeBaseUrl3(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 = normalizeBaseUrl3(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 = normalizeBaseUrl3(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 = normalizeBaseUrl3(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 = normalizeBaseUrl3(baseUrl);
+    return store.getState().xcashuTokens[normalized] || [];
+  },
+  addXcashuToken: (baseUrl, token) => {
+    const normalized = normalizeBaseUrl3(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 = normalizeBaseUrl3(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 = normalizeBaseUrl3(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 = normalizeBaseUrl3(baseUrl);
+      return store.getState().modelsFromAllProviders[normalized] || [];
+    },
+    getDisabledProviders: () => store.getState().disabledProviders,
+    getProviderMints: (baseUrl) => {
+      const normalized = normalizeBaseUrl3(baseUrl);
+      return store.getState().mintsFromAllProviders[normalized] || [];
+    },
+    getProviderInfo: async (baseUrl) => {
+      const normalized = normalizeBaseUrl3(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/shardedDiscoveryAdapter.ts
+var MODEL_KEY_PREFIX = "models:provider:";
+var MODEL_TS_KEY_PREFIX = "models:provider_timestamp:";
+var PROVIDER_INDEX_KEY = "models:provider_index";
+var MIGRATION_MARKER_KEY2 = "models_sharded_migration_v1";
+var encodeBaseUrl = (baseUrl) => encodeURIComponent(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+var modelKey = (baseUrl) => `${MODEL_KEY_PREFIX}${encodeBaseUrl(baseUrl)}`;
+var modelTsKey = (baseUrl) => `${MODEL_TS_KEY_PREFIX}${encodeBaseUrl(baseUrl)}`;
+var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var createShardedDiscoveryAdapter = async (options) => {
+  const { driver } = options;
+  const legacyModels = await driver.getItem(SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS, {});
+  const legacyTimestamps = await driver.getItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, {});
+  if (Object.keys(legacyModels).length > 0) {
+    const migratedProviders = [];
+    for (const [baseUrl, models] of Object.entries(legacyModels)) {
+      const normalized = normalizeBaseUrl4(baseUrl);
+      await driver.setItem(modelKey(normalized), models);
+      const ts = legacyTimestamps[normalized] ?? Date.now();
+      await driver.setItem(modelTsKey(normalized), ts);
+      migratedProviders.push(normalized);
+    }
+    const existingIndex = await driver.getItem(
+      PROVIDER_INDEX_KEY,
+      []
+    );
+    const merged = [.../* @__PURE__ */ new Set([...existingIndex, ...migratedProviders])];
+    await driver.setItem(PROVIDER_INDEX_KEY, merged);
+    await driver.removeItem(SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS);
+    await driver.removeItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE);
+  }
+  await driver.setItem(MIGRATION_MARKER_KEY2, true);
+  const [
+    rawMints,
+    rawInfo,
+    lastUsedModel,
+    rawDisabled,
+    rawBaseUrls,
+    lastBaseUrlsUpdate,
+    rawRoutstr21Models,
+    lastRoutstr21ModelsUpdate
+  ] = await Promise.all([
+    driver.getItem(
+      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(
+      SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, null),
+    driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []),
+    driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, null),
+    driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
+    driver.getItem(
+      SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
+      null
+    )
+  ]);
+  const modelsByBaseUrl = /* @__PURE__ */ new Map();
+  const timestampsByBaseUrl = /* @__PURE__ */ new Map();
+  const providerIndex = /* @__PURE__ */ new Set();
+  const knownProviders = /* @__PURE__ */ new Set();
+  for (const baseUrl of Object.keys(rawInfo)) {
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
+  }
+  for (const baseUrl of Object.keys(rawMints)) {
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
+  }
+  for (const baseUrl of rawBaseUrls) {
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
+  }
+  for (const baseUrl of rawDisabled) {
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
+  }
+  for (const baseUrl of Object.keys(legacyModels)) {
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
+  }
+  const indexProviders = await driver.getItem(
+    PROVIDER_INDEX_KEY,
+    []
+  );
+  for (const baseUrl of indexProviders) {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    providerIndex.add(normalized);
+    knownProviders.add(normalized);
+  }
+  for (const baseUrl of knownProviders) {
+    const normalized = normalizeBaseUrl4(baseUrl);
+    const models = await driver.getItem(
+      modelKey(normalized),
+      null
+    );
+    const ts = await driver.getItem(
+      modelTsKey(normalized),
+      null
+    );
+    if (models !== null) {
+      modelsByBaseUrl.set(normalized, models);
+    }
+    if (ts !== null) {
+      timestampsByBaseUrl.set(normalized, ts);
+    }
+    if (models !== null || ts !== null) {
+      providerIndex.add(normalized);
+    }
+  }
+  let mints = Object.fromEntries(
+    Object.entries(rawMints).map(([baseUrl, mintList]) => [
+      normalizeBaseUrl4(baseUrl),
+      mintList.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
+    ])
+  );
+  let info = Object.fromEntries(
+    Object.entries(rawInfo).map(([baseUrl, entry]) => [
+      normalizeBaseUrl4(baseUrl),
+      entry
+    ])
+  );
+  let _lastUsedModel = lastUsedModel;
+  let _disabledProviders = rawDisabled.map(normalizeBaseUrl4);
+  let _baseUrlsList = rawBaseUrls.map(normalizeBaseUrl4);
+  let _lastBaseUrlsUpdate = lastBaseUrlsUpdate;
+  let _routstr21Models = rawRoutstr21Models;
+  let _lastRoutstr21ModelsUpdate = lastRoutstr21ModelsUpdate;
+  const persistProviderIndex = () => {
+    void driver.setItem(PROVIDER_INDEX_KEY, [...providerIndex]);
+  };
+  return {
+    // -- Models (sharded kv) --
+    getCachedModels: () => {
+      const result = {};
+      for (const [baseUrl, models] of modelsByBaseUrl.entries()) {
+        result[baseUrl] = models;
+      }
+      return result;
+    },
+    setCachedModels: (models) => {
+      const nextKeys = new Set(
+        Object.keys(models).map((baseUrl) => normalizeBaseUrl4(baseUrl))
+      );
+      for (const baseUrl of [...modelsByBaseUrl.keys()]) {
+        if (!nextKeys.has(normalizeBaseUrl4(baseUrl))) {
+          providerIndex.delete(baseUrl);
+          modelsByBaseUrl.delete(baseUrl);
+          timestampsByBaseUrl.delete(baseUrl);
+          void driver.removeItem(modelKey(baseUrl));
+          void driver.removeItem(modelTsKey(baseUrl));
+        }
+      }
+      for (const [baseUrl, modelList] of Object.entries(models)) {
+        const normalized = normalizeBaseUrl4(baseUrl);
+        providerIndex.add(normalized);
+        modelsByBaseUrl.set(normalized, modelList);
+        const ts = timestampsByBaseUrl.get(normalized) ?? Date.now();
+        timestampsByBaseUrl.set(normalized, ts);
+        void driver.setItem(modelKey(normalized), modelList);
+        void driver.setItem(modelTsKey(normalized), ts);
+      }
+      persistProviderIndex();
+    },
+    getProviderLastUpdate: (baseUrl) => {
+      return timestampsByBaseUrl.get(normalizeBaseUrl4(baseUrl)) ?? null;
+    },
+    setProviderLastUpdate: (baseUrl, timestamp) => {
+      const normalized = normalizeBaseUrl4(baseUrl);
+      providerIndex.add(normalized);
+      timestampsByBaseUrl.set(normalized, timestamp);
+      void driver.setItem(modelTsKey(normalized), timestamp);
+      persistProviderIndex();
+    },
+    // -- Mints (kv) --
+    getCachedMints: () => mints,
+    setCachedMints: (value) => {
+      const normalized = {};
+      for (const [baseUrl, mintList] of Object.entries(value)) {
+        normalized[normalizeBaseUrl4(baseUrl)] = mintList.map(
+          (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
+        );
+      }
+      mints = normalized;
+      void driver.setItem(SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS, normalized);
+    },
+    // -- Provider info (kv) --
+    getCachedProviderInfo: () => info,
+    setCachedProviderInfo: (value) => {
+      const normalized = {};
+      for (const [baseUrl, entry] of Object.entries(value)) {
+        normalized[normalizeBaseUrl4(baseUrl)] = entry;
+      }
+      info = normalized;
+      void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
+    },
+    // -- Last used model (kv) --
+    getLastUsedModel: () => _lastUsedModel,
+    setLastUsedModel: (modelId) => {
+      _lastUsedModel = modelId;
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, modelId);
+    },
+    // -- Disabled providers (kv) --
+    getDisabledProviders: () => _disabledProviders,
+    setDisabledProviders: (urls) => {
+      const normalized = urls.map(normalizeBaseUrl4);
+      _disabledProviders = normalized;
+      void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
+    },
+    // -- Base URLs (kv) --
+    getBaseUrlsList: () => _baseUrlsList,
+    getBaseUrlsLastUpdate: () => _lastBaseUrlsUpdate,
+    setBaseUrlsList: (urls) => {
+      const normalized = urls.map(normalizeBaseUrl4);
+      _baseUrlsList = normalized;
+      void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
+    },
+    setBaseUrlsLastUpdate: (timestamp) => {
+      _lastBaseUrlsUpdate = timestamp;
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, timestamp);
+    },
+    // -- Routstr21 models (kv) --
+    getRoutstr21Models: () => _routstr21Models,
+    setRoutstr21Models: (models) => {
+      _routstr21Models = models;
+      void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, models);
+    },
+    getRoutstr21ModelsLastUpdate: () => _lastRoutstr21ModelsUpdate,
+    setRoutstr21ModelsLastUpdate: (timestamp) => {
+      _lastRoutstr21ModelsUpdate = timestamp;
+      void driver.setItem(
+        SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
+        timestamp
+      );
+    }
+  };
+};
+var createProviderRegistryFromDiscoveryAdapter = (adapter, logger) => {
+  const log = (logger ?? consoleLogger).child("ProviderRegistry");
+  return {
+    getModelsForProvider: (baseUrl) => {
+      const normalized = normalizeBaseUrl4(baseUrl);
+      return adapter.getCachedModels()[normalized] || [];
+    },
+    getDisabledProviders: () => adapter.getDisabledProviders(),
+    getProviderMints: (baseUrl) => {
+      const normalized = normalizeBaseUrl4(baseUrl);
+      return adapter.getCachedMints()[normalized] || [];
+    },
+    getProviderInfo: async (baseUrl) => {
+      const normalized = normalizeBaseUrl4(baseUrl);
+      const cached = adapter.getCachedProviderInfo()[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();
+        adapter.setCachedProviderInfo({
+          ...adapter.getCachedProviderInfo(),
+          [normalized]: info
+        });
+        return info;
+      } catch (error) {
+        log.warn(`Failed to fetch provider info from ${normalized}:`, error);
+        return null;
+      }
+    },
+    getAllProvidersModels: () => adapter.getCachedModels()
+  };
+};
+
+// storage/index.ts
+var isBrowser3 = () => {
+  try {
+    return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+  } catch {
+    return false;
+  }
+};
+var defaultDriver = null;
+var getDefaultSdkDriver = () => {
+  if (defaultDriver) return defaultDriver;
+  if (isBrowser3()) {
+    defaultDriver = localStorageDriver;
+    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;
+  }
+  defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+  return defaultUsageTrackingDriver;
+};
+var setDefaultUsageTrackingDriver = (driver) => {
+  defaultUsageTrackingDriver = driver;
+};
+var defaultDiscoveryAdapter = null;
+var getDefaultDiscoveryAdapter = async () => {
+  if (defaultDiscoveryAdapter) return defaultDiscoveryAdapter;
+  const driver = getDefaultSdkDriver();
+  defaultDiscoveryAdapter = await createShardedDiscoveryAdapter({ driver });
+  return defaultDiscoveryAdapter;
+};
+var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
+var getDefaultProviderRegistry = async () => createProviderRegistryFromDiscoveryAdapter(await getDefaultDiscoveryAdapter());
+
+// 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);
+      }
+    }
+  };
+};
+
+// storage/usageTracking/sqlite.ts
+var MIGRATION_MARKER_KEY3 = "usage_tracking_migration_v1";
+var ADDED_COLUMNS = [
+  { name: "provider", type: "TEXT" },
+  { name: "base_msats", type: "REAL" },
+  { name: "input_msats", type: "REAL" },
+  { name: "output_msats", type: "REAL" },
+  { name: "total_msats", type: "REAL" },
+  { name: "total_usd", type: "REAL" },
+  { name: "cache_read_input_tokens", type: "INTEGER" },
+  { name: "cache_creation_input_tokens", type: "INTEGER" },
+  { name: "cache_read_msats", type: "REAL" },
+  { name: "cache_creation_msats", type: "REAL" },
+  { name: "remaining_balance_msats", type: "REAL" }
+];
+var normalizeBaseUrl5 = (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(normalizeBaseUrl5(options.baseUrl));
+  }
+  if (options.sessionId) {
+    clauses.push("session_id = ?");
+    params.push(options.sessionId);
+  }
+  if (options.client) {
+    clauses.push("client = ?");
+    params.push(options.client);
+  }
+  if (options.clients && options.clients.length > 0) {
+    const placeholders = options.clients.map(() => "?").join(", ");
+    clauses.push(`client IN (${placeholders})`);
+    params.push(...options.clients);
+  }
+  if (options.provider) {
+    clauses.push("provider = ?");
+    params.push(options.provider);
+  }
+  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);
+      `);
+      const existingColumns = new Set(
+        db.prepare(`PRAGMA table_info(${tableName})`).all().map((row) => String(row.name))
+      );
+      for (const column of ADDED_COLUMNS) {
+        if (!existingColumns.has(column.name)) {
+          db.exec(
+            `ALTER TABLE ${tableName} ADD COLUMN ${column.name} ${column.type}`
+          );
+        }
+      }
+      db.exec(
+        `CREATE INDEX IF NOT EXISTS idx_${tableName}_provider ON ${tableName}(provider)`
+      );
+      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,
+          provider, base_msats, input_msats, output_msats, total_msats,
+          total_usd, cache_read_input_tokens, cache_creation_input_tokens,
+          cache_read_msats, cache_creation_msats, remaining_balance_msats
+        ) VALUES (
+          ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+          ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+        )
+      `);
+    }
+  };
+  const ensureInit = async () => {
+    if (!db) {
+      await initDb();
+    }
+  };
+  const appendOne = (entry) => {
+    insertStmt.run(
+      entry.id,
+      entry.timestamp,
+      entry.modelId,
+      normalizeBaseUrl5(entry.baseUrl),
+      entry.requestId,
+      entry.cost,
+      entry.satsCost,
+      entry.promptTokens,
+      entry.completionTokens,
+      entry.totalTokens,
+      entry.client ?? null,
+      entry.sessionId ?? null,
+      JSON.stringify(entry.tags ?? []),
+      entry.provider ?? null,
+      entry.baseMsats ?? null,
+      entry.inputMsats ?? null,
+      entry.outputMsats ?? null,
+      entry.totalMsats ?? null,
+      entry.totalUsd ?? null,
+      entry.cacheReadInputTokens ?? null,
+      entry.cacheCreationInputTokens ?? null,
+      entry.cacheReadMsats ?? null,
+      entry.cacheCreationMsats ?? null,
+      entry.remainingBalanceMsats ?? null
+    );
+  };
+  const ensureMigrated = async () => {
+    if (!legacyStorageDriver || migrationComplete) return;
+    const migrated = await legacyStorageDriver.getItem(
+      MIGRATION_MARKER_KEY3,
+      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_KEY3, 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,
+    provider: row.provider ?? void 0,
+    baseMsats: row.base_msats ?? void 0,
+    inputMsats: row.input_msats ?? void 0,
+    outputMsats: row.output_msats ?? void 0,
+    totalMsats: row.total_msats ?? void 0,
+    totalUsd: row.total_usd ?? void 0,
+    cacheReadInputTokens: row.cache_read_input_tokens ?? void 0,
+    cacheCreationInputTokens: row.cache_creation_input_tokens ?? void 0,
+    cacheReadMsats: row.cache_read_msats ?? void 0,
+    cacheCreationMsats: row.cache_creation_msats ?? void 0,
+    remainingBalanceMsats: row.remaining_balance_msats ?? 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 aggregate(options2 = {}) {
+      await ensureInit();
+      await ensureMigrated();
+      const where = buildWhereClause(options2);
+      const { sql, params } = buildAggregateSql(tableName, where, options2);
+      const rows = db.prepare(sql).all(...params);
+      return rows.map(mapAggregateRow);
+    },
+    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();
+    }
+  };
+};
+
+export { SDK_STORAGE_KEYS, createDiscoveryAdapterFromStore, createIndexedDBDriver, createIndexedDBUsageTrackingDriver, createMemoryDriver, createMemoryUsageTrackingDriver, createProviderRegistryFromDiscoveryAdapter, createProviderRegistryFromStore, createSdkStore, createShardedDiscoveryAdapter, createSqliteDriver, createSqliteUsageTrackingDriver, createStorageAdapterFromStore, getDefaultDiscoveryAdapter, getDefaultProviderRegistry, getDefaultSdkDriver, getDefaultSdkStore, getDefaultStorageAdapter, getDefaultUsageTrackingDriver, localStorageDriver, setDefaultUsageTrackingDriver };
+//# sourceMappingURL=node.mjs.map
+//# sourceMappingURL=node.mjs.map