@routstr/sdk 0.3.9 → 0.3.11

package/dist/storage/index.js

@@ -110,154 +110,6 @@ var createMemoryDriver = (seed) => {
   };
 };
 
-// core/types.ts
-function makeConsoleLogger(prefix) {
-  const fmt = (args) => prefix ? [prefix, ...args] : args;
-  return {
-    log: (...args) => console.log(...fmt(args)),
-    warn: (...args) => console.warn(...fmt(args)),
-    error: (...args) => console.error(...fmt(args)),
-    debug: (...args) => console.log(...fmt(args)),
-    child: (p) => makeConsoleLogger(prefix ? `${prefix}:${p}` : p)
-  };
-}
-var consoleLogger = makeConsoleLogger();
-
-// storage/drivers/sqlite.ts
-var isBun = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var cachedDbModule = null;
-var loadDatabase = async (dbPath) => {
-  if (isBun()) {
-    throw new Error(
-      "SQLite driver not supported in Bun. Use createBunSqliteDriver() instead."
-    );
-  }
-  try {
-    if (!cachedDbModule) {
-      cachedDbModule = (await import('better-sqlite3')).default;
-    }
-    return new cachedDbModule(dbPath);
-  } catch (error) {
-    throw new Error(
-      `better-sqlite3 is required for sqlite storage. Install it to use sqlite storage. (${error})`
-    );
-  }
-};
-var createSqliteDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "sdk_storage";
-  let db;
-  let selectStmt;
-  let upsertStmt;
-  let deleteStmt;
-  const initDb = async () => {
-    if (!db) {
-      db = await loadDatabase(dbPath);
-      db.exec(
-        `CREATE TABLE IF NOT EXISTS ${tableName} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
-      );
-      selectStmt = db.prepare(`SELECT value FROM ${tableName} WHERE key = ?`);
-      upsertStmt = db.prepare(
-        `INSERT INTO ${tableName} (key, value) VALUES (?, ?)
-     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
-      );
-      deleteStmt = db.prepare(`DELETE FROM ${tableName} WHERE key = ?`);
-    }
-  };
-  const ensureInit = async () => {
-    if (!db) {
-      await initDb();
-    }
-  };
-  return {
-    async getItem(key, defaultValue) {
-      try {
-        await ensureInit();
-        const row = selectStmt.get(key);
-        if (!row || typeof row.value !== "string") return defaultValue;
-        try {
-          return JSON.parse(row.value);
-        } catch (parseError) {
-          if (typeof defaultValue === "string") {
-            return row.value;
-          }
-          throw parseError;
-        }
-      } catch (error) {
-        console.error(`SQLite getItem failed for key "${key}":`, error);
-        return defaultValue;
-      }
-    },
-    async setItem(key, value) {
-      try {
-        await ensureInit();
-        upsertStmt.run(key, JSON.stringify(value));
-      } catch (error) {
-        console.error(`SQLite setItem failed for key "${key}":`, error);
-      }
-    },
-    async removeItem(key) {
-      try {
-        await ensureInit();
-        deleteStmt.run(key);
-      } catch (error) {
-        console.error(`SQLite removeItem failed for key "${key}":`, error);
-      }
-    }
-  };
-};
-async function createBunSqliteDriver(dbPath, options) {
-  const logger = (options?.logger ?? consoleLogger).child("BunSqliteDriver");
-  const SQLite = (await import(
-    /* webpackIgnore: true */
-    'bun:sqlite'
-  )).default;
-  const db = new SQLite(dbPath);
-  db.run(`
-    CREATE TABLE IF NOT EXISTS sdk_storage (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    )
-  `);
-  return {
-    async getItem(key, defaultValue) {
-      try {
-        const row = db.query("SELECT value FROM sdk_storage WHERE key = ?").get(key);
-        if (!row || typeof row.value !== "string") return defaultValue;
-        try {
-          return JSON.parse(row.value);
-        } catch (parseError) {
-          if (typeof defaultValue === "string") {
-            return row.value;
-          }
-          throw parseError;
-        }
-      } catch (error) {
-        logger.error(`getItem failed for key "${key}":`, error);
-        return defaultValue;
-      }
-    },
-    async setItem(key, value) {
-      try {
-        db.query(
-          "INSERT INTO sdk_storage (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
-        ).run(key, JSON.stringify(value));
-      } catch (error) {
-        logger.error(`setItem failed for key "${key}":`, error);
-      }
-    },
-    async removeItem(key) {
-      try {
-        db.query("DELETE FROM sdk_storage WHERE key = ?").run(key);
-      } catch (error) {
-        logger.error(`removeItem failed for key "${key}":`, error);
-      }
-    }
-  };
-}
-
 // storage/drivers/indexedDB.ts
 var isBrowser = typeof indexedDB !== "undefined";
 var openDatabase = (dbName, storeName) => {
@@ -265,15 +117,32 @@ var openDatabase = (dbName, storeName) => {
     return Promise.reject(new Error("IndexedDB is not available"));
   }
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(dbName, 1);
+    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 = {}) => {
@@ -375,6 +244,91 @@ var SDK_STORAGE_KEYS = {
   PROVIDERS_ON_COOLDOWN: "providers_on_cooldown"
 };
 
+// storage/usageTracking/aggregate.ts
+var pad2 = (n) => String(n).padStart(2, "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";
@@ -386,9 +340,10 @@ var openDatabase2 = (dbName, storeName) => {
     return Promise.reject(new Error("IndexedDB is not available"));
   }
   return new Promise((resolve, reject) => {
-    const request = indexedDB.open(dbName, 1);
+    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 });
@@ -396,10 +351,25 @@ var openDatabase2 = (dbName, storeName) => {
         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 = {}) => {
@@ -421,6 +391,12 @@ var matchesFilters = (entry, options = {}) => {
   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 = {}) => {
@@ -516,6 +492,10 @@ var createIndexedDBUsageTrackingDriver = (options = {}) => {
       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();
@@ -552,393 +532,8 @@ var createIndexedDBUsageTrackingDriver = (options = {}) => {
   };
 };
 
-// storage/usageTracking/sqlite.ts
-var MIGRATION_MARKER_KEY2 = "usage_tracking_migration_v1";
-var normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var isBun2 = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var cachedDbModule2 = null;
-var loadDatabase2 = async (dbPath) => {
-  if (isBun2()) {
-    throw new Error(
-      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
-    );
-  }
-  try {
-    if (!cachedDbModule2) {
-      cachedDbModule2 = (await import('better-sqlite3')).default;
-    }
-    return new cachedDbModule2(dbPath);
-  } catch (error) {
-    throw new Error(
-      `better-sqlite3 is required for sqlite usage tracking. Install it to use sqlite storage. (${error})`
-    );
-  }
-};
-var buildWhereClause = (options = {}) => {
-  const clauses = [];
-  const params = [];
-  if (typeof options.before === "number") {
-    clauses.push("timestamp < ?");
-    params.push(options.before);
-  }
-  if (typeof options.after === "number") {
-    clauses.push("timestamp > ?");
-    params.push(options.after);
-  }
-  if (options.modelId) {
-    clauses.push("model_id = ?");
-    params.push(options.modelId);
-  }
-  if (options.baseUrl) {
-    clauses.push("base_url = ?");
-    params.push(normalizeBaseUrl2(options.baseUrl));
-  }
-  if (options.sessionId) {
-    clauses.push("session_id = ?");
-    params.push(options.sessionId);
-  }
-  if (options.client) {
-    clauses.push("client = ?");
-    params.push(options.client);
-  }
-  return {
-    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    params
-  };
-};
-var createSqliteUsageTrackingDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "usage_tracking";
-  const legacyStorageDriver = options.legacyStorageDriver;
-  let db;
-  let insertStmt;
-  let migrationComplete = false;
-  const initDb = async () => {
-    if (!db) {
-      db = await loadDatabase2(dbPath);
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS ${tableName} (
-          id TEXT PRIMARY KEY,
-          timestamp INTEGER NOT NULL,
-          model_id TEXT NOT NULL,
-          base_url TEXT NOT NULL,
-          request_id TEXT NOT NULL,
-          cost REAL NOT NULL,
-          sats_cost REAL NOT NULL,
-          prompt_tokens INTEGER NOT NULL,
-          completion_tokens INTEGER NOT NULL,
-          total_tokens INTEGER NOT NULL,
-          client TEXT,
-          session_id TEXT,
-          tags TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_session_id ON ${tableName}(session_id);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_client ON ${tableName}(client);
-      `);
-      insertStmt = db.prepare(`
-        INSERT OR REPLACE INTO ${tableName} (
-          id, timestamp, model_id, base_url, request_id,
-          cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
-          client, session_id, tags
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-    }
-  };
-  const ensureInit = async () => {
-    if (!db) {
-      await initDb();
-    }
-  };
-  const appendOne = (entry) => {
-    insertStmt.run(
-      entry.id,
-      entry.timestamp,
-      entry.modelId,
-      normalizeBaseUrl2(entry.baseUrl),
-      entry.requestId,
-      entry.cost,
-      entry.satsCost,
-      entry.promptTokens,
-      entry.completionTokens,
-      entry.totalTokens,
-      entry.client ?? null,
-      entry.sessionId ?? null,
-      JSON.stringify(entry.tags ?? [])
-    );
-  };
-  const ensureMigrated = async () => {
-    if (!legacyStorageDriver || migrationComplete) return;
-    const migrated = await legacyStorageDriver.getItem(
-      MIGRATION_MARKER_KEY2,
-      false
-    );
-    if (migrated) {
-      migrationComplete = true;
-      return;
-    }
-    const legacyEntries = await legacyStorageDriver.getItem(
-      SDK_STORAGE_KEYS.USAGE_TRACKING,
-      []
-    );
-    for (const entry of legacyEntries) {
-      appendOne(entry);
-    }
-    if (legacyEntries.length > 0) {
-      await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
-    }
-    await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY2, true);
-    migrationComplete = true;
-  };
-  const mapRow = (row) => ({
-    id: row.id,
-    timestamp: row.timestamp,
-    modelId: row.model_id,
-    baseUrl: row.base_url,
-    requestId: row.request_id,
-    cost: row.cost,
-    satsCost: row.sats_cost,
-    promptTokens: row.prompt_tokens,
-    completionTokens: row.completion_tokens,
-    totalTokens: row.total_tokens,
-    client: row.client ?? void 0,
-    sessionId: row.session_id ?? void 0,
-    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
-  });
-  return {
-    async migrate() {
-      await ensureInit();
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureInit();
-      await ensureMigrated();
-      appendOne(entry);
-    },
-    async appendMany(entries) {
-      await ensureInit();
-      await ensureMigrated();
-      for (const entry of entries) {
-        appendOne(entry);
-      }
-    },
-    async list(options2 = {}) {
-      await ensureInit();
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause(options2);
-      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
-      const stmt = db.prepare(
-        `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`
-      );
-      const rows = stmt.all(
-        ...typeof options2.limit === "number" ? [...params, options2.limit] : params
-      );
-      return rows.map(mapRow);
-    },
-    async count(options2 = {}) {
-      await ensureInit();
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause(options2);
-      const stmt = db.prepare(`SELECT COUNT(*) as count FROM ${tableName} ${sql}`);
-      const row = stmt.get(...params);
-      return Number(row?.count ?? 0);
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureInit();
-      await ensureMigrated();
-      const stmt = db.prepare(`DELETE FROM ${tableName} WHERE timestamp < ?`);
-      const result = stmt.run(timestamp);
-      return result.changes;
-    },
-    async clear() {
-      await ensureInit();
-      await ensureMigrated();
-      db.prepare(`DELETE FROM ${tableName}`).run();
-    }
-  };
-};
-
-// storage/usageTracking/bunSqlite.ts
-var MIGRATION_MARKER_KEY3 = "usage_tracking_migration_v1";
-var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var buildWhereClause2 = (options = {}) => {
-  const clauses = [];
-  const params = [];
-  if (typeof options.before === "number") {
-    clauses.push("timestamp < ?");
-    params.push(options.before);
-  }
-  if (typeof options.after === "number") {
-    clauses.push("timestamp > ?");
-    params.push(options.after);
-  }
-  if (options.modelId) {
-    clauses.push("model_id = ?");
-    params.push(options.modelId);
-  }
-  if (options.baseUrl) {
-    clauses.push("base_url = ?");
-    params.push(normalizeBaseUrl3(options.baseUrl));
-  }
-  if (options.sessionId) {
-    clauses.push("session_id = ?");
-    params.push(options.sessionId);
-  }
-  if (options.client) {
-    clauses.push("client = ?");
-    params.push(options.client);
-  }
-  return {
-    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    params
-  };
-};
-var createBunSqliteUsageTrackingDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "usage_tracking";
-  const legacyStorageDriver = options.legacyStorageDriver;
-  const SQLiteDatabase = options.sqlite?.Database;
-  let migrationPromise = null;
-  if (!SQLiteDatabase) {
-    throw new Error(
-      "Bun SQLite Database constructor is required. Pass { sqlite: { Database } } when creating the driver."
-    );
-  }
-  const db = new SQLiteDatabase(dbPath);
-  db.run(`
-    CREATE TABLE IF NOT EXISTS ${tableName} (
-      id TEXT PRIMARY KEY,
-      timestamp INTEGER NOT NULL,
-      model_id TEXT NOT NULL,
-      base_url TEXT NOT NULL,
-      request_id TEXT NOT NULL,
-      cost REAL NOT NULL,
-      sats_cost REAL NOT NULL,
-      prompt_tokens INTEGER NOT NULL,
-      completion_tokens INTEGER NOT NULL,
-      total_tokens INTEGER NOT NULL,
-      client TEXT,
-      session_id TEXT,
-      tags TEXT
-    )
-  `);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url)`);
-  const appendOne = (entry) => {
-    db.query(`
-      INSERT OR REPLACE INTO ${tableName} (
-        id, timestamp, model_id, base_url, request_id,
-        cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
-        client, session_id, tags
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      entry.id,
-      entry.timestamp,
-      entry.modelId,
-      normalizeBaseUrl3(entry.baseUrl),
-      entry.requestId,
-      entry.cost,
-      entry.satsCost,
-      entry.promptTokens,
-      entry.completionTokens,
-      entry.totalTokens,
-      entry.client ?? null,
-      entry.sessionId ?? null,
-      JSON.stringify(entry.tags ?? [])
-    );
-  };
-  const mapRow = (row) => ({
-    id: row.id,
-    timestamp: row.timestamp,
-    modelId: row.model_id,
-    baseUrl: row.base_url,
-    requestId: row.request_id,
-    cost: row.cost,
-    satsCost: row.sats_cost,
-    promptTokens: row.prompt_tokens,
-    completionTokens: row.completion_tokens,
-    totalTokens: row.total_tokens,
-    client: row.client ?? void 0,
-    sessionId: row.session_id ?? void 0,
-    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
-  });
-  const ensureMigrated = async () => {
-    if (!legacyStorageDriver) return;
-    if (!migrationPromise) {
-      migrationPromise = (async () => {
-        const migrated = await legacyStorageDriver.getItem(
-          MIGRATION_MARKER_KEY3,
-          false
-        );
-        if (migrated) return;
-        const legacyEntries = await legacyStorageDriver.getItem(
-          SDK_STORAGE_KEYS.USAGE_TRACKING,
-          []
-        );
-        if (legacyEntries.length > 0) {
-          for (const entry of legacyEntries) {
-            appendOne(entry);
-          }
-          await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
-        }
-        await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY3, true);
-      })();
-    }
-    await migrationPromise;
-  };
-  return {
-    async migrate() {
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureMigrated();
-      appendOne(entry);
-    },
-    async appendMany(entries) {
-      await ensureMigrated();
-      for (const entry of entries) {
-        appendOne(entry);
-      }
-    },
-    async list(options2 = {}) {
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause2(options2);
-      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
-      const query = `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`;
-      let rows;
-      if (typeof options2.limit === "number") {
-        rows = db.query(query).all(...params, options2.limit);
-      } else {
-        rows = db.query(query).all(...params);
-      }
-      return rows.map(mapRow);
-    },
-    async count(options2 = {}) {
-      const { sql, params } = buildWhereClause2(options2);
-      const query = `SELECT COUNT(*) as count FROM ${tableName} ${sql}`;
-      const row = db.query(query).get(...params);
-      return Number(row?.count ?? 0);
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureMigrated();
-      const before = timestamp;
-      const result = db.query(`DELETE FROM ${tableName} WHERE timestamp < ?`).run(before);
-      return result.changes ?? 0;
-    },
-    async clear() {
-      await ensureMigrated();
-      db.query(`DELETE FROM ${tableName}`).run();
-    }
-  };
-};
-
 // storage/usageTracking/memory.ts
-var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 var matchesFilters2 = (entry, options = {}) => {
   if (typeof options.before === "number" && entry.timestamp >= options.before) {
     return false;
@@ -949,7 +544,7 @@ var matchesFilters2 = (entry, options = {}) => {
   if (options.modelId && entry.modelId !== options.modelId) {
     return false;
   }
-  if (options.baseUrl && normalizeBaseUrl4(entry.baseUrl) !== normalizeBaseUrl4(options.baseUrl)) {
+  if (options.baseUrl && normalizeBaseUrl2(entry.baseUrl) !== normalizeBaseUrl2(options.baseUrl)) {
     return false;
   }
   if (options.sessionId && entry.sessionId !== options.sessionId) {
@@ -958,23 +553,29 @@ var matchesFilters2 = (entry, options = {}) => {
   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: normalizeBaseUrl4(entry.baseUrl) });
+    store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl2(entry.baseUrl) });
   }
   return {
     async migrate() {
       return;
     },
     async append(entry) {
-      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
+      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl2(entry.baseUrl) });
     },
     async appendMany(entries) {
       for (const entry of entries) {
-        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
+        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl2(entry.baseUrl) });
       }
     },
     async list(options = {}) {
@@ -987,6 +588,10 @@ var createMemoryUsageTrackingDriver = (seed = []) => {
     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()) {
@@ -1002,7 +607,22 @@ var createMemoryUsageTrackingDriver = (seed = []) => {
     }
   };
 };
-var normalizeBaseUrl5 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+
+// 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) => vanilla.createStore((set, get) => ({
   modelsFromAllProviders: {},
   lastUsedModel: null,
@@ -1025,7 +645,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setModelsFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, models] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = models;
+      normalized[normalizeBaseUrl3(baseUrl)] = models;
     }
     void driver.setItem(
       SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
@@ -1038,7 +658,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set({ lastUsedModel: value });
   },
   setBaseUrlsList: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl5(url));
+    const normalized = value.map((url) => normalizeBaseUrl3(url));
     void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
     set({ baseUrlsList: normalized });
   },
@@ -1047,14 +667,14 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set({ lastBaseUrlsUpdate: value });
   },
   setDisabledProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl5(url));
+    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[normalizeBaseUrl5(baseUrl)] = mints.map(
+      normalized[normalizeBaseUrl3(baseUrl)] = mints.map(
         (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
       );
     }
@@ -1067,7 +687,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setInfoFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, info] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = info;
+      normalized[normalizeBaseUrl3(baseUrl)] = info;
     }
     void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
     set({ infoFromAllProviders: normalized });
@@ -1075,7 +695,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setLastModelsUpdate: (value) => {
     const normalized = {};
     for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = timestamp;
+      normalized[normalizeBaseUrl3(baseUrl)] = timestamp;
     }
     void driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
     set({ lastModelsUpdate: normalized });
@@ -1085,7 +705,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
       const updates = typeof value === "function" ? value(state.apiKeys) : value;
       const normalized = updates.map((entry) => ({
         ...entry,
-        baseUrl: normalizeBaseUrl5(entry.baseUrl),
+        baseUrl: normalizeBaseUrl3(entry.baseUrl),
         balance: entry.balance ?? 0,
         lastUsed: entry.lastUsed ?? null
       }));
@@ -1097,7 +717,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: normalizeBaseUrl5(entry.parentBaseUrl),
+        parentBaseUrl: normalizeBaseUrl3(entry.parentBaseUrl),
         childKey: entry.childKey,
         balance: entry.balance ?? 0,
         balanceLimit: entry.balanceLimit,
@@ -1111,9 +731,9 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setXcashuTokens: (value) => {
     const normalized = {};
     for (const [baseUrl, tokens] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = tokens.map((entry) => ({
+      normalized[normalizeBaseUrl3(baseUrl)] = tokens.map((entry) => ({
         ...entry,
-        baseUrl: normalizeBaseUrl5(entry.baseUrl),
+        baseUrl: normalizeBaseUrl3(entry.baseUrl),
         createdAt: entry.createdAt ?? Date.now(),
         tryCount: entry.tryCount ?? 0
       }));
@@ -1164,12 +784,12 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   },
   // ========== Failure Tracking ==========
   setFailedProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl5(url));
+    const normalized = value.map((url) => normalizeBaseUrl3(url));
     void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, normalized);
     set({ failedProviders: normalized });
   },
   addFailedProvider: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const current = get().failedProviders;
     if (!current.includes(normalized)) {
       const updated = [...current, normalized];
@@ -1178,7 +798,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     }
   },
   removeFailedProvider: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(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);
@@ -1187,13 +807,13 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setLastFailed: (value) => {
     const normalized = {};
     for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl5(baseUrl)] = timestamp;
+      normalized[normalizeBaseUrl3(baseUrl)] = timestamp;
     }
     void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, normalized);
     set({ lastFailed: normalized });
   },
   setLastFailedTimestamp: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const current = get().lastFailed;
     const updated = { ...current, [normalized]: timestamp };
     void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, updated);
@@ -1201,14 +821,14 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   },
   setProvidersOnCooldown: (value) => {
     const normalized = value.map((entry) => ({
-      baseUrl: normalizeBaseUrl5(entry.baseUrl),
+      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 = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const current = get().providersOnCooldown;
     if (!current.some((entry) => entry.baseUrl === normalized)) {
       const updated = [...current, { baseUrl: normalized, timestamp }];
@@ -1217,7 +837,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     }
   },
   removeProviderFromCooldown: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(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);
@@ -1288,40 +908,40 @@ var hydrateStoreFromDriver = async (store, driver) => {
   ]);
   const modelsFromAllProviders = Object.fromEntries(
     Object.entries(rawModels).map(([baseUrl, models]) => [
-      normalizeBaseUrl5(baseUrl),
+      normalizeBaseUrl3(baseUrl),
       models
     ])
   );
-  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl5(url));
+  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl3(url));
   const disabledProviders = rawDisabledProviders.map(
-    (url) => normalizeBaseUrl5(url)
+    (url) => normalizeBaseUrl3(url)
   );
   const mintsFromAllProviders = Object.fromEntries(
     Object.entries(rawMints).map(([baseUrl, mints]) => [
-      normalizeBaseUrl5(baseUrl),
+      normalizeBaseUrl3(baseUrl),
       mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
     ])
   );
   const infoFromAllProviders = Object.fromEntries(
     Object.entries(rawInfo).map(([baseUrl, info]) => [
-      normalizeBaseUrl5(baseUrl),
+      normalizeBaseUrl3(baseUrl),
       info
     ])
   );
   const lastModelsUpdate = Object.fromEntries(
     Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl5(baseUrl),
+      normalizeBaseUrl3(baseUrl),
       timestamp
     ])
   );
   const apiKeys = rawApiKeys.map((entry) => ({
     ...entry,
-    baseUrl: normalizeBaseUrl5(entry.baseUrl),
+    baseUrl: normalizeBaseUrl3(entry.baseUrl),
     balance: entry.balance ?? 0,
     lastUsed: entry.lastUsed ?? null
   }));
   const childKeys = rawChildKeys.map((entry) => ({
-    parentBaseUrl: normalizeBaseUrl5(entry.parentBaseUrl),
+    parentBaseUrl: normalizeBaseUrl3(entry.parentBaseUrl),
     childKey: entry.childKey,
     balance: entry.balance ?? 0,
     balanceLimit: entry.balanceLimit,
@@ -1330,9 +950,9 @@ var hydrateStoreFromDriver = async (store, driver) => {
   }));
   const xcashuTokens = Object.fromEntries(
     Object.entries(rawXcashuTokens).map(([baseUrl, tokens]) => [
-      normalizeBaseUrl5(baseUrl),
+      normalizeBaseUrl3(baseUrl),
       tokens.map((entry) => ({
-        baseUrl: normalizeBaseUrl5(entry.baseUrl),
+        baseUrl: normalizeBaseUrl3(entry.baseUrl),
         token: entry.token,
         createdAt: entry.createdAt ?? Date.now(),
         tryCount: entry.tryCount ?? 0
@@ -1353,16 +973,16 @@ var hydrateStoreFromDriver = async (store, driver) => {
     lastUsed: entry.lastUsed ?? null
   }));
   const failedProviders = rawFailedProviders.map(
-    (url) => normalizeBaseUrl5(url)
+    (url) => normalizeBaseUrl3(url)
   );
   const lastFailed = Object.fromEntries(
     Object.entries(rawLastFailed).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl5(baseUrl),
+      normalizeBaseUrl3(baseUrl),
       timestamp
     ])
   );
   const providersOnCooldown = rawProvidersOnCooldown.map((entry) => ({
-    baseUrl: normalizeBaseUrl5(entry.baseUrl),
+    baseUrl: normalizeBaseUrl3(entry.baseUrl),
     timestamp: entry.timestamp
   }));
   store.setState({
@@ -1403,12 +1023,12 @@ var createDiscoveryAdapterFromStore = (store) => ({
   getCachedProviderInfo: () => store.getState().infoFromAllProviders,
   setCachedProviderInfo: (info) => store.getState().setInfoFromAllProviders(info),
   getProviderLastUpdate: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const timestamps = store.getState().lastModelsUpdate;
     return timestamps[normalized] || null;
   },
   setProviderLastUpdate: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const timestamps = { ...store.getState().lastModelsUpdate };
     timestamps[normalized] = timestamp;
     store.getState().setLastModelsUpdate(timestamps);
@@ -1437,24 +1057,24 @@ 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 = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const next = { ...store.getState().infoFromAllProviders };
     next[normalized] = info;
     store.getState().setInfoFromAllProviders(next);
   },
   getProviderInfo: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     return store.getState().infoFromAllProviders[normalized] || null;
   },
   // ========== API Keys (for apikeys mode) ==========
   getApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(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 = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const keys = store.getState().apiKeys;
     const existingIndex = keys.findIndex(
       (entry) => entry.baseUrl === normalized
@@ -1472,7 +1092,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setApiKeys(next);
   },
   updateApiKeyBalance: (baseUrl, balance) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const keys = store.getState().apiKeys;
     const next = keys.map(
       (entry) => entry.baseUrl === normalized ? { ...entry, balance, lastUsed: Date.now() } : entry
@@ -1480,7 +1100,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setApiKeys(next);
   },
   removeApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const next = store.getState().apiKeys.filter((entry) => entry.baseUrl !== normalized);
     store.getState().setApiKeys(next);
   },
@@ -1494,7 +1114,7 @@ var createStorageAdapterFromStore = (store) => ({
   },
   // ========== Child Keys ==========
   getChildKey: (parentBaseUrl) => {
-    const normalized = normalizeBaseUrl5(parentBaseUrl);
+    const normalized = normalizeBaseUrl3(parentBaseUrl);
     const entry = store.getState().childKeys.find((key) => key.parentBaseUrl === normalized);
     if (!entry) return null;
     return {
@@ -1507,7 +1127,7 @@ var createStorageAdapterFromStore = (store) => ({
     };
   },
   setChildKey: (parentBaseUrl, childKey, balance, validityDate, balanceLimit) => {
-    const normalized = normalizeBaseUrl5(parentBaseUrl);
+    const normalized = normalizeBaseUrl3(parentBaseUrl);
     const keys = store.getState().childKeys;
     const existingIndex = keys.findIndex(
       (entry) => entry.parentBaseUrl === normalized
@@ -1538,7 +1158,7 @@ var createStorageAdapterFromStore = (store) => ({
     }
   },
   updateChildKeyBalance: (parentBaseUrl, balance) => {
-    const normalized = normalizeBaseUrl5(parentBaseUrl);
+    const normalized = normalizeBaseUrl3(parentBaseUrl);
     const keys = store.getState().childKeys;
     const next = keys.map(
       (entry) => entry.parentBaseUrl === normalized ? { ...entry, balance } : entry
@@ -1546,7 +1166,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setChildKeys(next);
   },
   removeChildKey: (parentBaseUrl) => {
-    const normalized = normalizeBaseUrl5(parentBaseUrl);
+    const normalized = normalizeBaseUrl3(parentBaseUrl);
     const next = store.getState().childKeys.filter((entry) => entry.parentBaseUrl !== normalized);
     store.getState().setChildKeys(next);
   },
@@ -1571,11 +1191,11 @@ var createStorageAdapterFromStore = (store) => ({
     return store.getState().xcashuTokens;
   },
   getXcashuTokensForBaseUrl: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     return store.getState().xcashuTokens[normalized] || [];
   },
   addXcashuToken: (baseUrl, token) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const tokens = store.getState().xcashuTokens;
     const existing = tokens[normalized] || [];
     const next = { ...tokens };
@@ -1586,7 +1206,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setXcashuTokens(next);
   },
   removeXcashuToken: (baseUrl, token) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const tokens = store.getState().xcashuTokens;
     const existing = tokens[normalized] || [];
     const next = { ...tokens };
@@ -1597,7 +1217,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setXcashuTokens(next);
   },
   clearXcashuTokensForBaseUrl: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
+    const normalized = normalizeBaseUrl3(baseUrl);
     const tokens = store.getState().xcashuTokens;
     const next = { ...tokens };
     delete next[normalized];
@@ -1611,16 +1231,16 @@ var createProviderRegistryFromStore = (store, logger) => {
   const log = (logger ?? consoleLogger).child("ProviderRegistry");
   return {
     getModelsForProvider: (baseUrl) => {
-      const normalized = normalizeBaseUrl5(baseUrl);
+      const normalized = normalizeBaseUrl3(baseUrl);
       return store.getState().modelsFromAllProviders[normalized] || [];
     },
     getDisabledProviders: () => store.getState().disabledProviders,
     getProviderMints: (baseUrl) => {
-      const normalized = normalizeBaseUrl5(baseUrl);
+      const normalized = normalizeBaseUrl3(baseUrl);
       return store.getState().mintsFromAllProviders[normalized] || [];
     },
     getProviderInfo: async (baseUrl) => {
-      const normalized = normalizeBaseUrl5(baseUrl);
+      const normalized = normalizeBaseUrl3(baseUrl);
       const cached = store.getState().infoFromAllProviders[normalized];
       if (cached) return cached;
       try {
@@ -1646,11 +1266,11 @@ var createProviderRegistryFromStore = (store, logger) => {
 var MODEL_KEY_PREFIX = "models:provider:";
 var MODEL_TS_KEY_PREFIX = "models:provider_timestamp:";
 var PROVIDER_INDEX_KEY = "models:provider_index";
-var MIGRATION_MARKER_KEY4 = "models_sharded_migration_v1";
+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 normalizeBaseUrl6 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${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, {});
@@ -1658,7 +1278,7 @@ var createShardedDiscoveryAdapter = async (options) => {
   if (Object.keys(legacyModels).length > 0) {
     const migratedProviders = [];
     for (const [baseUrl, models] of Object.entries(legacyModels)) {
-      const normalized = normalizeBaseUrl6(baseUrl);
+      const normalized = normalizeBaseUrl4(baseUrl);
       await driver.setItem(modelKey(normalized), models);
       const ts = legacyTimestamps[normalized] ?? Date.now();
       await driver.setItem(modelTsKey(normalized), ts);
@@ -1673,7 +1293,7 @@ var createShardedDiscoveryAdapter = async (options) => {
     await driver.removeItem(SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS);
     await driver.removeItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE);
   }
-  await driver.setItem(MIGRATION_MARKER_KEY4, true);
+  await driver.setItem(MIGRATION_MARKER_KEY2, true);
   const [
     rawMints,
     rawInfo,
@@ -1707,31 +1327,31 @@ var createShardedDiscoveryAdapter = async (options) => {
   const providerIndex = /* @__PURE__ */ new Set();
   const knownProviders = /* @__PURE__ */ new Set();
   for (const baseUrl of Object.keys(rawInfo)) {
-    knownProviders.add(normalizeBaseUrl6(baseUrl));
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
   }
   for (const baseUrl of Object.keys(rawMints)) {
-    knownProviders.add(normalizeBaseUrl6(baseUrl));
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
   }
   for (const baseUrl of rawBaseUrls) {
-    knownProviders.add(normalizeBaseUrl6(baseUrl));
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
   }
   for (const baseUrl of rawDisabled) {
-    knownProviders.add(normalizeBaseUrl6(baseUrl));
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
   }
   for (const baseUrl of Object.keys(legacyModels)) {
-    knownProviders.add(normalizeBaseUrl6(baseUrl));
+    knownProviders.add(normalizeBaseUrl4(baseUrl));
   }
   const indexProviders = await driver.getItem(
     PROVIDER_INDEX_KEY,
     []
   );
   for (const baseUrl of indexProviders) {
-    const normalized = normalizeBaseUrl6(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     providerIndex.add(normalized);
     knownProviders.add(normalized);
   }
   for (const baseUrl of knownProviders) {
-    const normalized = normalizeBaseUrl6(baseUrl);
+    const normalized = normalizeBaseUrl4(baseUrl);
     const models = await driver.getItem(
       modelKey(normalized),
       null
@@ -1752,19 +1372,19 @@ var createShardedDiscoveryAdapter = async (options) => {
   }
   let mints = Object.fromEntries(
     Object.entries(rawMints).map(([baseUrl, mintList]) => [
-      normalizeBaseUrl6(baseUrl),
+      normalizeBaseUrl4(baseUrl),
       mintList.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
     ])
   );
   let info = Object.fromEntries(
     Object.entries(rawInfo).map(([baseUrl, entry]) => [
-      normalizeBaseUrl6(baseUrl),
+      normalizeBaseUrl4(baseUrl),
       entry
     ])
   );
   let _lastUsedModel = lastUsedModel;
-  let _disabledProviders = rawDisabled.map(normalizeBaseUrl6);
-  let _baseUrlsList = rawBaseUrls.map(normalizeBaseUrl6);
+  let _disabledProviders = rawDisabled.map(normalizeBaseUrl4);
+  let _baseUrlsList = rawBaseUrls.map(normalizeBaseUrl4);
   let _lastBaseUrlsUpdate = lastBaseUrlsUpdate;
   let _routstr21Models = rawRoutstr21Models;
   let _lastRoutstr21ModelsUpdate = lastRoutstr21ModelsUpdate;
@@ -1782,10 +1402,10 @@ var createShardedDiscoveryAdapter = async (options) => {
     },
     setCachedModels: (models) => {
       const nextKeys = new Set(
-        Object.keys(models).map((baseUrl) => normalizeBaseUrl6(baseUrl))
+        Object.keys(models).map((baseUrl) => normalizeBaseUrl4(baseUrl))
       );
       for (const baseUrl of [...modelsByBaseUrl.keys()]) {
-        if (!nextKeys.has(normalizeBaseUrl6(baseUrl))) {
+        if (!nextKeys.has(normalizeBaseUrl4(baseUrl))) {
           providerIndex.delete(baseUrl);
           modelsByBaseUrl.delete(baseUrl);
           timestampsByBaseUrl.delete(baseUrl);
@@ -1794,7 +1414,7 @@ var createShardedDiscoveryAdapter = async (options) => {
         }
       }
       for (const [baseUrl, modelList] of Object.entries(models)) {
-        const normalized = normalizeBaseUrl6(baseUrl);
+        const normalized = normalizeBaseUrl4(baseUrl);
         providerIndex.add(normalized);
         modelsByBaseUrl.set(normalized, modelList);
         const ts = timestampsByBaseUrl.get(normalized) ?? Date.now();
@@ -1805,10 +1425,10 @@ var createShardedDiscoveryAdapter = async (options) => {
       persistProviderIndex();
     },
     getProviderLastUpdate: (baseUrl) => {
-      return timestampsByBaseUrl.get(normalizeBaseUrl6(baseUrl)) ?? null;
+      return timestampsByBaseUrl.get(normalizeBaseUrl4(baseUrl)) ?? null;
     },
     setProviderLastUpdate: (baseUrl, timestamp) => {
-      const normalized = normalizeBaseUrl6(baseUrl);
+      const normalized = normalizeBaseUrl4(baseUrl);
       providerIndex.add(normalized);
       timestampsByBaseUrl.set(normalized, timestamp);
       void driver.setItem(modelTsKey(normalized), timestamp);
@@ -1819,7 +1439,7 @@ var createShardedDiscoveryAdapter = async (options) => {
     setCachedMints: (value) => {
       const normalized = {};
       for (const [baseUrl, mintList] of Object.entries(value)) {
-        normalized[normalizeBaseUrl6(baseUrl)] = mintList.map(
+        normalized[normalizeBaseUrl4(baseUrl)] = mintList.map(
           (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
         );
       }
@@ -1831,7 +1451,7 @@ var createShardedDiscoveryAdapter = async (options) => {
     setCachedProviderInfo: (value) => {
       const normalized = {};
       for (const [baseUrl, entry] of Object.entries(value)) {
-        normalized[normalizeBaseUrl6(baseUrl)] = entry;
+        normalized[normalizeBaseUrl4(baseUrl)] = entry;
       }
       info = normalized;
       void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
@@ -1845,7 +1465,7 @@ var createShardedDiscoveryAdapter = async (options) => {
     // -- Disabled providers (kv) --
     getDisabledProviders: () => _disabledProviders,
     setDisabledProviders: (urls) => {
-      const normalized = urls.map(normalizeBaseUrl6);
+      const normalized = urls.map(normalizeBaseUrl4);
       _disabledProviders = normalized;
       void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
     },
@@ -1853,7 +1473,7 @@ var createShardedDiscoveryAdapter = async (options) => {
     getBaseUrlsList: () => _baseUrlsList,
     getBaseUrlsLastUpdate: () => _lastBaseUrlsUpdate,
     setBaseUrlsList: (urls) => {
-      const normalized = urls.map(normalizeBaseUrl6);
+      const normalized = urls.map(normalizeBaseUrl4);
       _baseUrlsList = normalized;
       void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
     },
@@ -1881,16 +1501,16 @@ var createProviderRegistryFromDiscoveryAdapter = (adapter, logger) => {
   const log = (logger ?? consoleLogger).child("ProviderRegistry");
   return {
     getModelsForProvider: (baseUrl) => {
-      const normalized = normalizeBaseUrl6(baseUrl);
+      const normalized = normalizeBaseUrl4(baseUrl);
       return adapter.getCachedModels()[normalized] || [];
     },
     getDisabledProviders: () => adapter.getDisabledProviders(),
     getProviderMints: (baseUrl) => {
-      const normalized = normalizeBaseUrl6(baseUrl);
+      const normalized = normalizeBaseUrl4(baseUrl);
       return adapter.getCachedMints()[normalized] || [];
     },
     getProviderInfo: async (baseUrl) => {
-      const normalized = normalizeBaseUrl6(baseUrl);
+      const normalized = normalizeBaseUrl4(baseUrl);
       const cached = adapter.getCachedProviderInfo()[normalized];
       if (cached) return cached;
       try {
@@ -1921,31 +1541,13 @@ var isBrowser3 = () => {
     return false;
   }
 };
-var isNode = () => {
-  try {
-    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-  } catch {
-    return false;
-  }
-};
 var defaultDriver = null;
-var isBun3 = () => {
-  return typeof process.versions.bun !== "undefined";
-};
 var getDefaultSdkDriver = () => {
   if (defaultDriver) return defaultDriver;
   if (isBrowser3()) {
     defaultDriver = localStorageDriver;
     return defaultDriver;
   }
-  if (isBun3()) {
-    defaultDriver = createMemoryDriver();
-    return defaultDriver;
-  }
-  if (isNode()) {
-    defaultDriver = createSqliteDriver();
-    return defaultDriver;
-  }
   defaultDriver = createMemoryDriver();
   return defaultDriver;
 };
@@ -1966,16 +1568,6 @@ var getDefaultUsageTrackingDriver = () => {
     });
     return defaultUsageTrackingDriver;
   }
-  if (isBun3()) {
-    defaultUsageTrackingDriver = createBunSqliteUsageTrackingDriver();
-    return defaultUsageTrackingDriver;
-  }
-  if (isNode()) {
-    defaultUsageTrackingDriver = createSqliteUsageTrackingDriver({
-      legacyStorageDriver: storageDriver
-    });
-    return defaultUsageTrackingDriver;
-  }
   defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
   return defaultUsageTrackingDriver;
 };
@@ -1993,8 +1585,6 @@ var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await g
 var getDefaultProviderRegistry = async () => createProviderRegistryFromDiscoveryAdapter(await getDefaultDiscoveryAdapter());
 
 exports.SDK_STORAGE_KEYS = SDK_STORAGE_KEYS;
-exports.createBunSqliteDriver = createBunSqliteDriver;
-exports.createBunSqliteUsageTrackingDriver = createBunSqliteUsageTrackingDriver;
 exports.createDiscoveryAdapterFromStore = createDiscoveryAdapterFromStore;
 exports.createIndexedDBDriver = createIndexedDBDriver;
 exports.createIndexedDBUsageTrackingDriver = createIndexedDBUsageTrackingDriver;
@@ -2004,8 +1594,6 @@ exports.createProviderRegistryFromDiscoveryAdapter = createProviderRegistryFromD
 exports.createProviderRegistryFromStore = createProviderRegistryFromStore;
 exports.createSdkStore = createSdkStore;
 exports.createShardedDiscoveryAdapter = createShardedDiscoveryAdapter;
-exports.createSqliteDriver = createSqliteDriver;
-exports.createSqliteUsageTrackingDriver = createSqliteUsageTrackingDriver;
 exports.createStorageAdapterFromStore = createStorageAdapterFromStore;
 exports.getDefaultDiscoveryAdapter = getDefaultDiscoveryAdapter;
 exports.getDefaultProviderRegistry = getDefaultProviderRegistry;