@routstr/sdk 0.2.4 → 0.2.5

package/dist/storage/index.js

@@ -300,8 +300,439 @@ var SDK_STORAGE_KEYS = {
   CLIENT_IDS: "client_ids"
 };
 
-// storage/store.ts
+// 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 createDatabase2 = (dbPath) => {
+  if (isBun2()) {
+    throw new Error(
+      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
+    );
+  }
+  let Database = null;
+  try {
+    Database = __require("better-sqlite3");
+  } catch (error) {
+    throw new Error(
+      `better-sqlite3 is required for sqlite usage tracking. Install it to use sqlite storage. (${error})`
+    );
+  }
+  return new Database(dbPath);
+};
+var buildWhereClause = (options = {}) => {
+  const clauses = [];
+  const params = [];
+  if (typeof options.before === "number") {
+    clauses.push("timestamp < ?");
+    params.push(options.before);
+  }
+  if (typeof options.after === "number") {
+    clauses.push("timestamp > ?");
+    params.push(options.after);
+  }
+  if (options.modelId) {
+    clauses.push("model_id = ?");
+    params.push(options.modelId);
+  }
+  if (options.baseUrl) {
+    clauses.push("base_url = ?");
+    params.push(normalizeBaseUrl2(options.baseUrl));
+  }
+  if (options.sessionId) {
+    clauses.push("session_id = ?");
+    params.push(options.sessionId);
+  }
+  if (options.client) {
+    clauses.push("client = ?");
+    params.push(options.client);
+  }
+  return {
+    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
+    params
+  };
+};
+var createSqliteUsageTrackingDriver = (options = {}) => {
+  const dbPath = options.dbPath || "routstr.sqlite";
+  const tableName = options.tableName || "usage_tracking";
+  const db = createDatabase2(dbPath);
+  const legacyStorageDriver = options.legacyStorageDriver;
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS ${tableName} (
+      id TEXT PRIMARY KEY,
+      timestamp INTEGER NOT NULL,
+      model_id TEXT NOT NULL,
+      base_url TEXT NOT NULL,
+      request_id TEXT NOT NULL,
+      cost REAL NOT NULL,
+      sats_cost REAL NOT NULL,
+      prompt_tokens INTEGER NOT NULL,
+      completion_tokens INTEGER NOT NULL,
+      total_tokens INTEGER NOT NULL,
+      client TEXT,
+      session_id TEXT,
+      tags TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id);
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url);
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_session_id ON ${tableName}(session_id);
+    CREATE INDEX IF NOT EXISTS idx_${tableName}_client ON ${tableName}(client);
+  `);
+  const insertStmt = db.prepare(`
+    INSERT OR REPLACE INTO ${tableName} (
+      id, timestamp, model_id, base_url, request_id,
+      cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
+      client, session_id, tags
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  let migrationComplete = false;
+  const appendOne = (entry) => {
+    insertStmt.run(
+      entry.id,
+      entry.timestamp,
+      entry.modelId,
+      normalizeBaseUrl2(entry.baseUrl),
+      entry.requestId,
+      entry.cost,
+      entry.satsCost,
+      entry.promptTokens,
+      entry.completionTokens,
+      entry.totalTokens,
+      entry.client ?? null,
+      entry.sessionId ?? null,
+      JSON.stringify(entry.tags ?? [])
+    );
+  };
+  const ensureMigrated = async () => {
+    if (!legacyStorageDriver || migrationComplete) return;
+    const migrated = await legacyStorageDriver.getItem(
+      MIGRATION_MARKER_KEY2,
+      false
+    );
+    if (migrated) {
+      migrationComplete = true;
+      return;
+    }
+    const legacyEntries = await legacyStorageDriver.getItem(
+      SDK_STORAGE_KEYS.USAGE_TRACKING,
+      []
+    );
+    for (const entry of legacyEntries) {
+      appendOne(entry);
+    }
+    if (legacyEntries.length > 0) {
+      await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
+    }
+    await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY2, true);
+    migrationComplete = true;
+  };
+  const mapRow = (row) => ({
+    id: row.id,
+    timestamp: row.timestamp,
+    modelId: row.model_id,
+    baseUrl: row.base_url,
+    requestId: row.request_id,
+    cost: row.cost,
+    satsCost: row.sats_cost,
+    promptTokens: row.prompt_tokens,
+    completionTokens: row.completion_tokens,
+    totalTokens: row.total_tokens,
+    client: row.client ?? void 0,
+    sessionId: row.session_id ?? void 0,
+    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
+  });
+  return {
+    async migrate() {
+      await ensureMigrated();
+    },
+    async append(entry) {
+      await ensureMigrated();
+      appendOne(entry);
+    },
+    async appendMany(entries) {
+      await ensureMigrated();
+      for (const entry of entries) {
+        appendOne(entry);
+      }
+    },
+    async list(options2 = {}) {
+      await ensureMigrated();
+      const { sql, params } = buildWhereClause(options2);
+      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
+      const stmt = db.prepare(
+        `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`
+      );
+      const rows = stmt.all(
+        ...typeof options2.limit === "number" ? [...params, options2.limit] : params
+      );
+      return rows.map(mapRow);
+    },
+    async count(options2 = {}) {
+      await ensureMigrated();
+      const { sql, params } = buildWhereClause(options2);
+      const stmt = db.prepare(`SELECT COUNT(*) as count FROM ${tableName} ${sql}`);
+      const row = stmt.get(...params);
+      return Number(row?.count ?? 0);
+    },
+    async deleteOlderThan(timestamp) {
+      await ensureMigrated();
+      const stmt = db.prepare(`DELETE FROM ${tableName} WHERE timestamp < ?`);
+      const result = stmt.run(timestamp);
+      return result.changes;
+    },
+    async clear() {
+      await ensureMigrated();
+      db.prepare(`DELETE FROM ${tableName}`).run();
+    }
+  };
+};
+
+// storage/usageTracking/memory.ts
+var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var matchesFilters2 = (entry, options = {}) => {
+  if (typeof options.before === "number" && entry.timestamp >= options.before) {
+    return false;
+  }
+  if (typeof options.after === "number" && entry.timestamp <= options.after) {
+    return false;
+  }
+  if (options.modelId && entry.modelId !== options.modelId) {
+    return false;
+  }
+  if (options.baseUrl && normalizeBaseUrl3(entry.baseUrl) !== normalizeBaseUrl3(options.baseUrl)) {
+    return false;
+  }
+  if (options.sessionId && entry.sessionId !== options.sessionId) {
+    return false;
+  }
+  if (options.client && entry.client !== options.client) {
+    return false;
+  }
+  return true;
+};
+var createMemoryUsageTrackingDriver = (seed = []) => {
+  const store = /* @__PURE__ */ new Map();
+  for (const entry of seed) {
+    store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl3(entry.baseUrl) });
+  }
+  return {
+    async migrate() {
+      return;
+    },
+    async append(entry) {
+      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl3(entry.baseUrl) });
+    },
+    async appendMany(entries) {
+      for (const entry of entries) {
+        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl3(entry.baseUrl) });
+      }
+    },
+    async list(options = {}) {
+      const entries = [...store.values()].filter((entry) => matchesFilters2(entry, options)).sort((a, b) => b.timestamp - a.timestamp);
+      if (typeof options.limit === "number") {
+        return entries.slice(0, options.limit);
+      }
+      return entries;
+    },
+    async count(options = {}) {
+      return (await this.list(options)).length;
+    },
+    async deleteOlderThan(timestamp) {
+      let deleted = 0;
+      for (const [id, entry] of store.entries()) {
+        if (entry.timestamp < timestamp) {
+          store.delete(id);
+          deleted += 1;
+        }
+      }
+      return deleted;
+    },
+    async clear() {
+      store.clear();
+    }
+  };
+};
+var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 var getCashuTokenBalance = (token) => {
   try {
     const decoded = cashuTs.getDecodedToken(token);
@@ -330,12 +761,11 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   routstr21Models: [],
   lastRoutstr21ModelsUpdate: null,
   cachedReceiveTokens: [],
-  usageTracking: [],
   clientIds: [],
   setModelsFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, models] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(baseUrl)] = models;
+      normalized[normalizeBaseUrl4(baseUrl)] = models;
     }
     void driver.setItem(
       SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
@@ -348,7 +778,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set({ lastUsedModel: value });
   },
   setBaseUrlsList: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl(url));
+    const normalized = value.map((url) => normalizeBaseUrl4(url));
     void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
     set({ baseUrlsList: normalized });
   },
@@ -357,14 +787,14 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set({ lastBaseUrlsUpdate: value });
   },
   setDisabledProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl(url));
+    const normalized = value.map((url) => normalizeBaseUrl4(url));
     void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
     set({ disabledProviders: normalized });
   },
   setMintsFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, mints] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(baseUrl)] = mints.map(
+      normalized[normalizeBaseUrl4(baseUrl)] = mints.map(
         (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
       );
     }
@@ -377,7 +807,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setInfoFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, info] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(baseUrl)] = info;
+      normalized[normalizeBaseUrl4(baseUrl)] = info;
     }
     void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
     set({ infoFromAllProviders: normalized });
@@ -385,7 +815,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setLastModelsUpdate: (value) => {
     const normalized = {};
     for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(baseUrl)] = timestamp;
+      normalized[normalizeBaseUrl4(baseUrl)] = timestamp;
     }
     void driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
     set({ lastModelsUpdate: normalized });
@@ -395,7 +825,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
       const updates = typeof value === "function" ? value(state.cachedTokens) : value;
       const normalized = updates.map((entry) => ({
         ...entry,
-        baseUrl: normalizeBaseUrl(entry.baseUrl),
+        baseUrl: normalizeBaseUrl4(entry.baseUrl),
         balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
         lastUsed: entry.lastUsed ?? null
       }));
@@ -408,7 +838,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
       const updates = typeof value === "function" ? value(state.apiKeys) : value;
       const normalized = updates.map((entry) => ({
         ...entry,
-        baseUrl: normalizeBaseUrl(entry.baseUrl),
+        baseUrl: normalizeBaseUrl4(entry.baseUrl),
         balance: entry.balance ?? 0,
         lastUsed: entry.lastUsed ?? null
       }));
@@ -420,7 +850,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set((state) => {
       const updates = typeof value === "function" ? value(state.childKeys) : value;
       const normalized = updates.map((entry) => ({
-        parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
+        parentBaseUrl: normalizeBaseUrl4(entry.parentBaseUrl),
         childKey: entry.childKey,
         balance: entry.balance ?? 0,
         balanceLimit: entry.balanceLimit,
@@ -449,10 +879,6 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
     set({ cachedReceiveTokens: normalized });
   },
-  setUsageTracking: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.USAGE_TRACKING, value);
-    set({ usageTracking: value });
-  },
   setClientIds: (value) => {
     set((state) => {
       const updates = typeof value === "function" ? value(state.clientIds) : value;
@@ -482,7 +908,6 @@ var hydrateStoreFromDriver = async (store, driver) => {
     rawRoutstr21Models,
     rawLastRoutstr21ModelsUpdate,
     rawCachedReceiveTokens,
-    rawUsageTracking,
     rawClientIds
   ] = await Promise.all([
     driver.getItem(
@@ -514,51 +939,50 @@ var hydrateStoreFromDriver = async (store, driver) => {
       null
     ),
     driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
-    driver.getItem(SDK_STORAGE_KEYS.USAGE_TRACKING, []),
     driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, [])
   ]);
   const modelsFromAllProviders = Object.fromEntries(
     Object.entries(rawModels).map(([baseUrl, models]) => [
-      normalizeBaseUrl(baseUrl),
+      normalizeBaseUrl4(baseUrl),
       models
     ])
   );
-  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl(url));
+  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl4(url));
   const disabledProviders = rawDisabledProviders.map(
-    (url) => normalizeBaseUrl(url)
+    (url) => normalizeBaseUrl4(url)
   );
   const mintsFromAllProviders = Object.fromEntries(
     Object.entries(rawMints).map(([baseUrl, mints]) => [
-      normalizeBaseUrl(baseUrl),
+      normalizeBaseUrl4(baseUrl),
       mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
     ])
   );
   const infoFromAllProviders = Object.fromEntries(
     Object.entries(rawInfo).map(([baseUrl, info]) => [
-      normalizeBaseUrl(baseUrl),
+      normalizeBaseUrl4(baseUrl),
       info
     ])
   );
   const lastModelsUpdate = Object.fromEntries(
     Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl(baseUrl),
+      normalizeBaseUrl4(baseUrl),
       timestamp
     ])
   );
   const cachedTokens = rawCachedTokens.map((entry) => ({
     ...entry,
-    baseUrl: normalizeBaseUrl(entry.baseUrl),
+    baseUrl: normalizeBaseUrl4(entry.baseUrl),
     balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
     lastUsed: entry.lastUsed ?? null
   }));
   const apiKeys = rawApiKeys.map((entry) => ({
     ...entry,
-    baseUrl: normalizeBaseUrl(entry.baseUrl),
+    baseUrl: normalizeBaseUrl4(entry.baseUrl),
     balance: entry.balance ?? 0,
     lastUsed: entry.lastUsed ?? null
   }));
   const childKeys = rawChildKeys.map((entry) => ({
-    parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
+    parentBaseUrl: normalizeBaseUrl4(entry.parentBaseUrl),
     childKey: entry.childKey,
     balance: entry.balance ?? 0,
     balanceLimit: entry.balanceLimit,
@@ -573,7 +997,6 @@ var hydrateStoreFromDriver = async (store, driver) => {
     unit: entry.unit || "sat",
     createdAt: entry.createdAt ?? Date.now()
   }));
-  const usageTracking = rawUsageTracking;
   const clientIds = rawClientIds.map((entry) => ({
     ...entry,
     createdAt: entry.createdAt ?? Date.now(),
@@ -594,7 +1017,6 @@ var hydrateStoreFromDriver = async (store, driver) => {
     routstr21Models,
     lastRoutstr21ModelsUpdate,
     cachedReceiveTokens,
-    usageTracking,
     clientIds
   });
 };
@@ -615,12 +1037,12 @@ var createDiscoveryAdapterFromStore = (store) => ({
   getCachedProviderInfo: () => store.getState().infoFromAllProviders,
   setCachedProviderInfo: (info) => store.getState().setInfoFromAllProviders(info),
   getProviderLastUpdate: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const timestamps = store.getState().lastModelsUpdate;
     return timestamps[normalized] || null;
   },
   setProviderLastUpdate: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const timestamps = { ...store.getState().lastModelsUpdate };
     timestamps[normalized] = timestamp;
     store.getState().setLastModelsUpdate(timestamps);
@@ -639,7 +1061,7 @@ var createDiscoveryAdapterFromStore = (store) => ({
 });
 var createStorageAdapterFromStore = (store) => ({
   getToken: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const entry = store.getState().cachedTokens.find((token) => token.baseUrl === normalized);
     if (!entry) return null;
     const next = store.getState().cachedTokens.map(
@@ -649,7 +1071,7 @@ var createStorageAdapterFromStore = (store) => ({
     return entry.token;
   },
   setToken: (baseUrl, token) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const tokens = store.getState().cachedTokens;
     const balance = getCashuTokenBalance(token);
     const existingIndex = tokens.findIndex(
@@ -668,12 +1090,12 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setCachedTokens(next);
   },
   removeToken: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const next = store.getState().cachedTokens.filter((entry) => entry.baseUrl !== normalized);
     store.getState().setCachedTokens(next);
   },
   updateTokenBalance: (baseUrl, balance) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const tokens = store.getState().cachedTokens;
     const next = tokens.map(
       (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
@@ -703,18 +1125,18 @@ var createStorageAdapterFromStore = (store) => ({
     return Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
   },
   saveProviderInfo: (baseUrl, info) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const next = { ...store.getState().infoFromAllProviders };
     next[normalized] = info;
     store.getState().setInfoFromAllProviders(next);
   },
   getProviderInfo: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     return store.getState().infoFromAllProviders[normalized] || null;
   },
   // ========== API Keys (for apikeys mode) ==========
   getApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const entry = store.getState().apiKeys.find((key) => key.baseUrl === normalized);
     if (!entry) return null;
     const next = store.getState().apiKeys.map(
@@ -724,7 +1146,7 @@ var createStorageAdapterFromStore = (store) => ({
     return entry;
   },
   setApiKey: (baseUrl, key) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const keys = store.getState().apiKeys;
     const existingIndex = keys.findIndex(
       (entry) => entry.baseUrl === normalized
@@ -742,7 +1164,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setApiKeys(next);
   },
   updateApiKeyBalance: (baseUrl, balance) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const keys = store.getState().apiKeys;
     const next = keys.map(
       (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
@@ -750,7 +1172,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setApiKeys(next);
   },
   removeApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const next = store.getState().apiKeys.filter((entry) => entry.baseUrl !== normalized);
     store.getState().setApiKeys(next);
   },
@@ -764,7 +1186,7 @@ var createStorageAdapterFromStore = (store) => ({
   },
   // ========== Child Keys ==========
   getChildKey: (parentBaseUrl) => {
-    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const normalized = normalizeBaseUrl4(parentBaseUrl);
     const entry = store.getState().childKeys.find((key) => key.parentBaseUrl === normalized);
     if (!entry) return null;
     return {
@@ -777,7 +1199,7 @@ var createStorageAdapterFromStore = (store) => ({
     };
   },
   setChildKey: (parentBaseUrl, childKey, balance, validityDate, balanceLimit) => {
-    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const normalized = normalizeBaseUrl4(parentBaseUrl);
     const keys = store.getState().childKeys;
     const existingIndex = keys.findIndex(
       (entry) => entry.parentBaseUrl === normalized
@@ -808,7 +1230,7 @@ var createStorageAdapterFromStore = (store) => ({
     }
   },
   updateChildKeyBalance: (parentBaseUrl, balance) => {
-    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const normalized = normalizeBaseUrl4(parentBaseUrl);
     const keys = store.getState().childKeys;
     const next = keys.map(
       (entry) => entry.parentBaseUrl === normalized ? { ...entry, balance } : entry
@@ -816,7 +1238,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setChildKeys(next);
   },
   removeChildKey: (parentBaseUrl) => {
-    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const normalized = normalizeBaseUrl4(parentBaseUrl);
     const next = store.getState().childKeys.filter((entry) => entry.parentBaseUrl !== normalized);
     store.getState().setChildKeys(next);
   },
@@ -839,16 +1261,16 @@ var createStorageAdapterFromStore = (store) => ({
 });
 var createProviderRegistryFromStore = (store) => ({
   getModelsForProvider: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     return store.getState().modelsFromAllProviders[normalized] || [];
   },
   getDisabledProviders: () => store.getState().disabledProviders,
   getProviderMints: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     return store.getState().mintsFromAllProviders[normalized] || [];
   },
   getProviderInfo: async (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const cached = store.getState().infoFromAllProviders[normalized];
     if (cached) return cached;
     try {
@@ -870,7 +1292,7 @@ var createProviderRegistryFromStore = (store) => ({
 });
 
 // storage/index.ts
-var isBrowser2 = () => {
+var isBrowser3 = () => {
   try {
     return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
   } catch {
@@ -885,16 +1307,16 @@ var isNode = () => {
   }
 };
 var defaultDriver = null;
-var isBun2 = () => {
+var isBun3 = () => {
   return typeof process.versions.bun !== "undefined";
 };
 var getDefaultSdkDriver = () => {
   if (defaultDriver) return defaultDriver;
-  if (isBrowser2()) {
+  if (isBrowser3()) {
     defaultDriver = localStorageDriver;
     return defaultDriver;
   }
-  if (isBun2()) {
+  if (isBun3()) {
     defaultDriver = createMemoryDriver();
     return defaultDriver;
   }
@@ -906,12 +1328,35 @@ var getDefaultSdkDriver = () => {
   return defaultDriver;
 };
 var defaultStore = null;
+var defaultUsageTrackingDriver = null;
 var getDefaultSdkStore = () => {
   if (!defaultStore) {
     defaultStore = createSdkStore({ driver: getDefaultSdkDriver() });
   }
   return defaultStore.hydrate.then(() => defaultStore.store);
 };
+var getDefaultUsageTrackingDriver = () => {
+  if (defaultUsageTrackingDriver) return defaultUsageTrackingDriver;
+  const storageDriver = getDefaultSdkDriver();
+  if (isBrowser3()) {
+    defaultUsageTrackingDriver = createIndexedDBUsageTrackingDriver({
+      legacyStorageDriver: storageDriver
+    });
+    return defaultUsageTrackingDriver;
+  }
+  if (isBun3()) {
+    defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+    return defaultUsageTrackingDriver;
+  }
+  if (isNode()) {
+    defaultUsageTrackingDriver = createSqliteUsageTrackingDriver({
+      legacyStorageDriver: storageDriver
+    });
+    return defaultUsageTrackingDriver;
+  }
+  defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+  return defaultUsageTrackingDriver;
+};
 var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
 var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
 var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(await getDefaultSdkStore());
@@ -919,16 +1364,20 @@ var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(awa
 exports.SDK_STORAGE_KEYS = SDK_STORAGE_KEYS;
 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;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map