@routstr/sdk 0.3.8 → 0.3.10

package/dist/index.js

@@ -147,7 +147,10 @@ var ModelManager = class _ModelManager {
     this.includeProviderUrls = config.includeProviderUrls || [];
     this.excludeProviderUrls = config.excludeProviderUrls || [];
     this.routstrPubkey = config.routstrPubkey || "4ad6fa2d16e2a9b576c863b4cf7404a70d4dc320c0c447d10ad6ff58993eacc8";
+    this.nostrRelays = config.nostrRelays;
     this.logger = (config.logger ?? consoleLogger).child("ModelManager");
+    this.eventStoreDbPath = config.eventStoreDbPath;
+    this.persistentEventDatabaseFactory = config.persistentEventDatabaseFactory;
   }
   adapter;
   cacheTTL;
@@ -155,8 +158,15 @@ var ModelManager = class _ModelManager {
   includeProviderUrls;
   excludeProviderUrls;
   routstrPubkey;
+  nostrRelays;
   logger;
   providerNodePubkeysByUrl = /* @__PURE__ */ new Map();
+  /** Persistent event store for relay-fetched events (null if not configured/initialized) */
+  eventStore = null;
+  eventStoreDb = null;
+  eventStoreInitPromise = null;
+  eventStoreDbPath;
+  persistentEventDatabaseFactory;
   /**
    * Get the list of bootstrapped provider base URLs
    * @returns Array of provider base URLs
@@ -164,6 +174,103 @@ var ModelManager = class _ModelManager {
   getBaseUrls() {
     return this.adapter.getBaseUrlsList();
   }
+  /**
+   * Lazily initialize the persistent event store.
+   * Returns null if no eventStoreDbPath was provided.
+   */
+  async ensureEventStore() {
+    if (!this.eventStoreDbPath) return null;
+    if (this.eventStore) return this.eventStore;
+    if (!this.eventStoreInitPromise) {
+      this.eventStoreInitPromise = (async () => {
+        try {
+          const db = await this.createPersistentEventDatabase();
+          this.eventStoreDb = db;
+          this.eventStore = new applesauceCore.EventStore({ database: db });
+          this.initializeEventStoreMetadata();
+          this.logger.log(
+            `Persistent event store initialized at ${this.eventStoreDbPath}`
+          );
+          return this.eventStore;
+        } catch (error) {
+          this.eventStoreInitPromise = null;
+          throw new Error(
+            `Persistent Nostr event storage requires a runtime-specific database factory. Use @routstr/sdk/node, @routstr/sdk/bun, inject persistentEventDatabaseFactory, or omit eventStoreDbPath. (${error})`
+          );
+        }
+      })();
+    }
+    return this.eventStoreInitPromise;
+  }
+  /**
+   * Get the persistent event store, initializing it if configured.
+   * Returns null if no eventStoreDbPath was provided.
+   */
+  async getEventStore() {
+    return this.ensureEventStore();
+  }
+  async createPersistentEventDatabase() {
+    if (!this.eventStoreDbPath) {
+      throw new Error("eventStoreDbPath is required");
+    }
+    if (!this.persistentEventDatabaseFactory) {
+      throw new Error(
+        "persistentEventDatabaseFactory is required. Import ModelManager from @routstr/sdk/node or @routstr/sdk/bun for SQLite-backed persistent event storage."
+      );
+    }
+    return this.persistentEventDatabaseFactory(this.eventStoreDbPath);
+  }
+  /** Close the persistent event store database handle, if configured. */
+  closeEventStore() {
+    this.eventStoreDb?.close?.();
+    this.eventStore = null;
+    this.eventStoreDb = null;
+    this.eventStoreInitPromise = null;
+  }
+  initializeEventStoreMetadata() {
+    this.eventStoreDb?.db?.exec(
+      `CREATE TABLE IF NOT EXISTS routstr_event_cache_metadata (
+        event_id TEXT PRIMARY KEY,
+        fetched_at INTEGER NOT NULL
+      )`
+    );
+  }
+  markEventFetched(event, fetchedAt = Date.now()) {
+    const db = this.eventStoreDb?.db;
+    if (!db) return;
+    db.prepare(
+      `INSERT INTO routstr_event_cache_metadata (event_id, fetched_at)
+       VALUES (?, ?)
+       ON CONFLICT(event_id) DO UPDATE SET fetched_at = excluded.fetched_at`
+    ).run?.(event.id, fetchedAt);
+  }
+  getEventFetchedAt(event) {
+    const db = this.eventStoreDb?.db;
+    if (!db) return void 0;
+    const row = db.prepare(
+      `SELECT fetched_at FROM routstr_event_cache_metadata WHERE event_id = ?`
+    ).get?.(event.id);
+    return typeof row?.fetched_at === "number" ? row.fetched_at : void 0;
+  }
+  /**
+   * Check the persistent event store for fresh cached events.
+   * Returns events from SQLite if they were fetched within `maxAge`, otherwise
+   * returns empty array (caller should hit relays). Events without local fetch
+   * metadata fall back to Nostr created_at for backwards compatibility.
+   */
+  async getCachedNostrEvents(filter, maxAge, forceRefresh = false) {
+    const eventStore = await this.ensureEventStore();
+    if (forceRefresh) return [];
+    if (!eventStore) return [];
+    const timeline = eventStore.getTimeline(filter);
+    if (timeline.length === 0) return [];
+    const cutoff = Date.now() - maxAge;
+    const freshest = Math.max(
+      ...timeline.map((e) => this.getEventFetchedAt(e) ?? e.created_at * 1e3)
+    );
+    if (freshest < cutoff) return [];
+    return timeline;
+  }
   static async init(adapter, config = {}, options = {}) {
     const manager = new _ModelManager(adapter, config);
     const torMode = options.torMode ?? false;
@@ -192,19 +299,31 @@ var ModelManager = class _ModelManager {
             torMode
           );
           await this.fetchRoutstr21Models(forceRefresh);
-          await this.syncReviewedProvidersFromNostr(filteredCachedUrls);
+          await this.syncReviewedProvidersFromNostr(
+            filteredCachedUrls,
+            this.providerNodePubkeysByUrl,
+            forceRefresh
+          );
           return filteredCachedUrls;
         }
       }
     }
     try {
-      const nostrProviders = await this.bootstrapFromNostr(38421, torMode);
+      const nostrProviders = await this.bootstrapFromNostr(
+        38421,
+        torMode,
+        forceRefresh
+      );
       if (nostrProviders.length > 0) {
         const filtered = this.filterBaseUrlsForTor(nostrProviders, torMode);
         this.adapter.setBaseUrlsList(filtered);
         this.adapter.setBaseUrlsLastUpdate(Date.now());
         await this.fetchRoutstr21Models(forceRefresh);
-        await this.syncReviewedProvidersFromNostr(filtered);
+        await this.syncReviewedProvidersFromNostr(
+          filtered,
+          this.providerNodePubkeysByUrl,
+          forceRefresh
+        );
         return filtered;
       }
     } catch (e) {
@@ -213,42 +332,59 @@ var ModelManager = class _ModelManager {
     return this.bootstrapFromHttp(torMode, forceRefresh);
   }
   /**
-   * Bootstrap providers from Nostr network (kind 30421)
+   * Resolve Nostr relay URLs for a given use case.
+   * Returns user-configured relays if set, otherwise the provided defaults.
+   */
+  getNostrRelays(defaults) {
+    return this.nostrRelays && this.nostrRelays.length > 0 ? this.nostrRelays : defaults;
+  }
+  /**
+   * Bootstrap providers from Nostr network (kind 38421)
    * @param kind The Nostr kind to fetch
    * @param torMode Whether running in Tor context
    * @returns Array of provider base URLs
    */
-  async bootstrapFromNostr(kind, torMode) {
-    const DEFAULT_RELAYS = [
+  async bootstrapFromNostr(kind, torMode, forceRefresh = false) {
+    const relays = this.getNostrRelays([
       "wss://relay.primal.net",
       "wss://nos.lol",
       "wss://relay.damus.io"
-    ];
-    const pool = new applesauceRelay.RelayPool();
-    const localEventStore = new applesauceCore.EventStore();
-    const timeoutMs = 5e3;
-    await new Promise((resolve) => {
-      pool.req(DEFAULT_RELAYS, {
-        kinds: [kind],
-        limit: 100
-      }).pipe(
-        applesauceRelay.onlyEvents(),
-        rxjs.tap((event) => {
-          localEventStore.add(event);
-        })
-      ).subscribe({
-        complete: () => {
+    ]);
+    const cached = await this.getCachedNostrEvents(
+      { kinds: [kind] },
+      this.cacheTTL,
+      forceRefresh
+    );
+    let sessionEvents = cached;
+    if (cached.length === 0) {
+      const pool = new applesauceRelay.RelayPool();
+      const timeoutMs = 5e3;
+      await new Promise((resolve) => {
+        pool.req(relays, {
+          kinds: [kind],
+          limit: 100
+        }).pipe(
+          applesauceRelay.onlyEvents(),
+          rxjs.tap((event) => {
+            sessionEvents.push(event);
+            this.eventStore?.add(event);
+            this.markEventFetched(event);
+          })
+        ).subscribe({
+          complete: () => {
+            resolve();
+          }
+        });
+        setTimeout(() => {
           resolve();
-        }
+        }, timeoutMs);
       });
-      setTimeout(() => {
-        resolve();
-      }, timeoutMs);
-    });
-    const timeline = localEventStore.getTimeline({ kinds: [kind] });
+    } else {
+      this.logger.log(`Using ${cached.length} cached kind ${kind} events from persistent store`);
+    }
     const bases = /* @__PURE__ */ new Set();
     this.providerNodePubkeysByUrl = /* @__PURE__ */ new Map();
-    for (const event of timeline) {
+    for (const event of sessionEvents) {
       const eventUrls = [];
       for (const tag of event.tags) {
         if (tag[0] === "u" && typeof tag[1] === "string") {
@@ -356,7 +492,11 @@ var ModelManager = class _ModelManager {
         this.adapter.setBaseUrlsList(list);
         this.adapter.setBaseUrlsLastUpdate(Date.now());
         await this.fetchRoutstr21Models(forceRefresh);
-        await this.syncReviewedProvidersFromNostr(list);
+        await this.syncReviewedProvidersFromNostr(
+          list,
+          this.providerNodePubkeysByUrl,
+          forceRefresh
+        );
       }
       return list;
     } catch (e) {
@@ -375,7 +515,7 @@ var ModelManager = class _ModelManager {
    * @param baseUrls Current provider base URLs to evaluate
    * @returns Array of provider base URLs disabled by the review set
    */
-  async syncReviewedProvidersFromNostr(baseUrls = this.adapter.getBaseUrlsList(), providerNodes = this.providerNodePubkeysByUrl) {
+  async syncReviewedProvidersFromNostr(baseUrls = this.adapter.getBaseUrlsList(), providerNodes = this.providerNodePubkeysByUrl, forceRefresh = false) {
     if (baseUrls.length === 0) return [];
     if (!this.adapter.setDisabledProviders) {
       this.logger.warn(
@@ -383,30 +523,43 @@ var ModelManager = class _ModelManager {
       );
       return [];
     }
-    const LGTM_RELAYS = [
-      "wss://relay.primal.net",
-      "wss://nos.lol",
-      "wss://relay.damus.io",
-      "wss://relay.routstr.com"
-    ];
     const reviewedNodePubkeys = /* @__PURE__ */ new Set();
     {
-      const pool = new applesauceRelay.RelayPool();
-      const store = new applesauceCore.EventStore();
-      const timeoutMs = 5e3;
-      await new Promise((resolve) => {
-        pool.req(LGTM_RELAYS, {
-          kinds: [38425],
-          "#t": ["lgtm"],
-          limit: 500,
-          authors: [this.routstrPubkey]
-        }).pipe(
-          applesauceRelay.onlyEvents(),
-          rxjs.tap((event) => store.add(event))
-        ).subscribe({ complete: () => resolve() });
-        setTimeout(() => resolve(), timeoutMs);
-      });
-      for (const event of store.getTimeline({ kinds: [38425] })) {
+      const cached = await this.getCachedNostrEvents(
+        { kinds: [38425], "#t": ["lgtm"], authors: [this.routstrPubkey] },
+        this.cacheTTL,
+        forceRefresh
+      );
+      let sessionEvents = cached;
+      if (cached.length === 0) {
+        const lgtmRelays = this.getNostrRelays([
+          "wss://relay.primal.net",
+          "wss://nos.lol",
+          "wss://relay.damus.io",
+          "wss://relay.routstr.com"
+        ]);
+        const pool = new applesauceRelay.RelayPool();
+        const timeoutMs = 5e3;
+        await new Promise((resolve) => {
+          pool.req(lgtmRelays, {
+            kinds: [38425],
+            "#t": ["lgtm"],
+            limit: 500,
+            authors: [this.routstrPubkey]
+          }).pipe(
+            applesauceRelay.onlyEvents(),
+            rxjs.tap((event) => {
+              sessionEvents.push(event);
+              this.eventStore?.add(event);
+              this.markEventFetched(event);
+            })
+          ).subscribe({ complete: () => resolve() });
+          setTimeout(() => resolve(), timeoutMs);
+        });
+      } else {
+        this.logger.log(`Using ${cached.length} cached kind 38425 events from persistent store`);
+      }
+      for (const event of sessionEvents) {
         const hasLgtmTag = event.tags.some(
           (tag) => tag[0] === "t" && tag[1]?.toLowerCase() === "lgtm"
         );
@@ -515,7 +668,7 @@ var ModelManager = class _ModelManager {
         if (this.isProviderDownError(error)) {
           this.logger.warn(`Provider ${base} is down right now.`);
         } else {
-          this.logger.warn(`Failed to fetch models from ${base}:`, error);
+          this.logger.warn(`Provider ${base} unreachable: ${error.message}`);
         }
         this.adapter.setProviderLastUpdate(base, Date.now());
         return { success: false, base };
@@ -630,39 +783,49 @@ var ModelManager = class _ModelManager {
         return cachedModels;
       }
     }
-    const DEFAULT_RELAYS = [
+    const relays = this.getNostrRelays([
       "wss://relay.damus.io",
       "wss://nos.lol",
       "wss://relay.routstr.com"
-    ];
-    const pool = new applesauceRelay.RelayPool();
-    const localEventStore = new applesauceCore.EventStore();
-    const timeoutMs = 5e3;
-    await new Promise((resolve) => {
-      pool.req(DEFAULT_RELAYS, {
-        kinds: [38423],
-        "#d": ["routstr-21-models"],
-        limit: 1,
-        authors: [this.routstrPubkey]
-      }).pipe(
-        applesauceRelay.onlyEvents(),
-        rxjs.tap((event2) => {
-          localEventStore.add(event2);
-        })
-      ).subscribe({
-        complete: () => {
+    ]);
+    const cached = await this.getCachedNostrEvents(
+      { kinds: [38423], "#d": ["routstr-21-models"], authors: [this.routstrPubkey] },
+      this.cacheTTL,
+      forceRefresh
+    );
+    let sessionEvents = cached;
+    if (cached.length === 0) {
+      const pool = new applesauceRelay.RelayPool();
+      const timeoutMs = 5e3;
+      await new Promise((resolve) => {
+        pool.req(relays, {
+          kinds: [38423],
+          "#d": ["routstr-21-models"],
+          limit: 1,
+          authors: [this.routstrPubkey]
+        }).pipe(
+          applesauceRelay.onlyEvents(),
+          rxjs.tap((event2) => {
+            sessionEvents.push(event2);
+            this.eventStore?.add(event2);
+            this.markEventFetched(event2);
+          })
+        ).subscribe({
+          complete: () => {
+            resolve();
+          }
+        });
+        setTimeout(() => {
           resolve();
-        }
+        }, timeoutMs);
       });
-      setTimeout(() => {
-        resolve();
-      }, timeoutMs);
-    });
-    const timeline = localEventStore.getTimeline({ kinds: [38423] });
-    if (timeline.length === 0) {
+    } else {
+      this.logger.log(`Using ${cached.length} cached kind 38423 events from persistent store`);
+    }
+    if (sessionEvents.length === 0) {
       return cachedModels.length > 0 ? cachedModels : [];
     }
-    const event = timeline[0];
+    const event = sessionEvents[0];
     try {
       const content = JSON.parse(event.content);
       const models = Array.isArray(content?.models) ? content.models : [];
@@ -1380,7 +1543,7 @@ var CashuSpender = class {
             });
             continue;
           }
-          if (balanceResult.amount >= 0) {
+          if (balanceResult.amount >= 0 && !balanceResult.balanceUnknown) {
             const balanceSat = balanceResult.unit === "msat" ? Math.floor(balanceResult.amount / 1e3) : balanceResult.amount;
             this.storageAdapter.updateApiKeyBalance(
               apiKeyEntry.baseUrl,
@@ -2129,17 +2292,24 @@ var BalanceManager = class _BalanceManager {
         this.logger.warn("getTokenBalance: FAILED", data);
         const isInvalidApiKey = response.status === 401 && data?.detail?.error?.code === "invalid_api_key" && data?.detail?.error?.message?.includes("proofs already spent");
         return {
-          amount: -1,
+          amount: 0,
           reserved: data.reserved ?? 0,
           unit: "msat",
           apiKey: data.api_key,
-          isInvalidApiKey
+          isInvalidApiKey,
+          balanceUnknown: true
         };
       }
     } catch (error) {
       this.logger.error("getTokenBalance error", error);
     }
-    return { amount: -1, reserved: 0, unit: "sat", apiKey: "" };
+    return {
+      amount: 0,
+      reserved: 0,
+      unit: "sat",
+      apiKey: "",
+      balanceUnknown: true
+    };
   }
   /**
    * Handle topup errors with specific error types
@@ -2174,529 +2344,210 @@ var BalanceManager = class _BalanceManager {
   }
 };
 
-// client/usage.ts
-function extractUsageFromResponseBody(body, fallbackSatsCost = 0) {
-  if (!body || typeof body !== "object") return null;
-  const usage = body.usage;
-  if (!usage || typeof usage !== "object") return null;
-  const promptTokens = Number(usage.prompt_tokens ?? 0);
-  const completionTokens = Number(usage.completion_tokens ?? 0);
-  const totalTokens = Number(usage.total_tokens ?? 0);
-  const costValue = usage.cost;
-  let cost = 0;
-  let satsCost = fallbackSatsCost;
-  if (typeof costValue === "number") {
-    cost = costValue;
-  } else if (costValue && typeof costValue === "object") {
-    const costObj = costValue;
-    const totalUsd = costObj.total_usd;
-    const totalMsats = costObj.total_msats;
-    cost = typeof totalUsd === "number" ? totalUsd : 0;
-    if (typeof totalMsats === "number") {
-      satsCost = totalMsats / 1e3;
-    }
-  }
-  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0 && cost === 0 && satsCost === 0) {
-    return null;
-  }
-  return {
-    promptTokens,
-    completionTokens,
-    totalTokens,
-    cost,
-    satsCost
-  };
-}
-function extractResponseId(body) {
-  if (!body || typeof body !== "object") return void 0;
-  const id = body.id;
-  if (typeof id !== "string") return void 0;
-  const trimmed = id.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function extractUsageFromSSEJson(parsed, fallbackSatsCost = 0) {
-  if (!parsed || typeof parsed !== "object") {
-    return null;
-  }
-  if (!parsed.usage && parsed.cost && typeof parsed.cost === "object") {
-    const costObj = parsed.cost;
-    const msats2 = costObj.total_msats ?? 0;
-    const cost2 = costObj.total_usd ?? 0;
-    if (msats2 === 0 && cost2 === 0) return null;
-    return {
-      promptTokens: Number(costObj.input_tokens ?? 0),
-      completionTokens: Number(costObj.output_tokens ?? 0),
-      totalTokens: Number((costObj.input_tokens ?? 0) + (costObj.output_tokens ?? 0)),
-      cost: Number(cost2),
-      satsCost: msats2 > 0 ? msats2 / 1e3 : fallbackSatsCost
-    };
-  }
-  if (!parsed.usage) {
-    return null;
-  }
-  const usage = parsed.usage;
-  const usageCost = usage.cost;
-  let cost = 0;
-  let msats = 0;
-  if (typeof usageCost === "number") {
-    cost = usageCost;
-  } else if (usageCost && typeof usageCost === "object") {
-    cost = usageCost.total_usd ?? 0;
-    msats = usageCost.total_msats ?? 0;
+// utils/torUtils.ts
+var TOR_ONION_SUFFIX = ".onion";
+var isTorContext = () => {
+  if (typeof window === "undefined") return false;
+  const hostname = window.location.hostname.toLowerCase();
+  return hostname.endsWith(TOR_ONION_SUFFIX);
+};
+var isOnionUrl = (url) => {
+  if (!url) return false;
+  const trimmed = url.trim().toLowerCase();
+  if (!trimmed) return false;
+  try {
+    const candidate = trimmed.startsWith("http") ? trimmed : `http://${trimmed}`;
+    return new URL(candidate).hostname.endsWith(TOR_ONION_SUFFIX);
+  } catch {
+    return trimmed.includes(TOR_ONION_SUFFIX);
   }
-  if (cost === 0) {
-    cost = parsed.metadata?.routstr?.cost?.total_usd ?? 0;
+};
+var shouldAllowHttp = (url, torMode) => {
+  if (!url.startsWith("http://")) return true;
+  if (url.includes("localhost") || url.includes("127.0.0.1")) return true;
+  return torMode && isOnionUrl(url);
+};
+var normalizeProviderUrl = (url, torMode = false) => {
+  if (!url || typeof url !== "string") return null;
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
   }
-  if (msats === 0) {
-    msats = parsed.metadata?.routstr?.cost?.total_msats ?? (typeof usage.cost_sats === "number" ? usage.cost_sats * 1e3 : 0);
+  const useHttpForOnion = torMode && isOnionUrl(trimmed);
+  const withProto = `${useHttpForOnion ? "http" : "https"}://${trimmed}`;
+  return withProto.endsWith("/") ? withProto : `${withProto}/`;
+};
+var dedupePreserveOrder = (urls) => {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const url of urls) {
+    if (!seen.has(url)) {
+      seen.add(url);
+      out.push(url);
+    }
   }
-  const promptTokens = Number(usage.prompt_tokens ?? usage.input_tokens ?? 0);
-  const completionTokens = Number(usage.completion_tokens ?? usage.output_tokens ?? 0);
-  const totalTokens = Number(usage.total_tokens ?? promptTokens + completionTokens);
-  const result = {
-    promptTokens,
-    completionTokens,
-    totalTokens,
-    cost: Number(cost ?? 0),
-    satsCost: msats > 0 ? msats / 1e3 : fallbackSatsCost
-  };
-  if (result.promptTokens === 0 && result.completionTokens === 0 && result.totalTokens === 0 && result.cost === 0 && result.satsCost === 0) {
-    return null;
+  return out;
+};
+var getProviderEndpoints = (provider, torMode) => {
+  const rawUrls = [
+    provider.endpoint_url,
+    ...Array.isArray(provider.endpoint_urls) ? provider.endpoint_urls : [],
+    provider.onion_url,
+    ...Array.isArray(provider.onion_urls) ? provider.onion_urls : []
+  ];
+  const normalized = rawUrls.map((value) => normalizeProviderUrl(value, torMode)).filter((value) => Boolean(value));
+  const unique = dedupePreserveOrder(normalized).filter(
+    (value) => shouldAllowHttp(value, torMode)
+  );
+  if (unique.length === 0) return [];
+  const onion = unique.filter((value) => isOnionUrl(value));
+  const clearnet = unique.filter((value) => !isOnionUrl(value));
+  if (torMode) {
+    return onion.length > 0 ? onion : clearnet;
   }
-  return result;
-}
-function toUsageStats(usage) {
-  if (!usage) return void 0;
-  return {
-    total_tokens: usage.totalTokens,
-    prompt_tokens: usage.promptTokens,
-    completion_tokens: usage.completionTokens,
-    cost: usage.cost,
-    sats_cost: usage.satsCost
-  };
-}
+  return clearnet;
+};
+var filterBaseUrlsForTor = (baseUrls, torMode) => {
+  if (!Array.isArray(baseUrls)) return [];
+  const normalized = baseUrls.map((value) => normalizeProviderUrl(value, torMode)).filter((value) => Boolean(value));
+  const filtered = normalized.filter(
+    (value) => torMode ? true : !isOnionUrl(value)
+  );
+  return dedupePreserveOrder(
+    filtered.filter((value) => shouldAllowHttp(value, torMode))
+  );
+};
 
-// client/StreamProcessor.ts
-var StreamProcessor = class {
-  accumulatedContent = "";
-  accumulatedThinking = "";
-  accumulatedImages = [];
-  isInThinking = false;
-  isInContent = false;
-  /**
-   * Process a streaming response
-   */
-  async process(response, callbacks, modelId) {
-    if (!response.body) {
-      throw new Error("Response body is not available");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder("utf-8");
-    let buffer = "";
-    this.accumulatedContent = "";
-    this.accumulatedThinking = "";
-    this.accumulatedImages = [];
-    this.isInThinking = false;
-    this.isInContent = false;
-    let usage;
-    let model;
-    let finish_reason;
-    let citations;
-    let annotations;
-    let responseId;
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        const chunk = decoder.decode(value, { stream: true });
-        buffer += chunk;
-        const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
-        for (const line of lines) {
-          const parsed = this._parseLine(line);
-          if (!parsed) continue;
-          if (parsed.content) {
-            this._handleContent(parsed.content, callbacks, modelId);
-          }
-          if (parsed.reasoning) {
-            this._handleThinking(parsed.reasoning, callbacks);
-          }
-          if (parsed.usage) {
-            usage = parsed.usage;
-          }
-          if (parsed.model) {
-            model = parsed.model;
-          }
-          if (parsed.finish_reason) {
-            finish_reason = parsed.finish_reason;
-          }
-          if (parsed.responseId) {
-            responseId = parsed.responseId;
-          }
-          if (parsed.citations) {
-            citations = parsed.citations;
-          }
-          if (parsed.annotations) {
-            annotations = parsed.annotations;
-          }
-          if (parsed.images) {
-            this._mergeImages(parsed.images);
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-    return {
-      content: this.accumulatedContent,
-      thinking: this.accumulatedThinking || void 0,
-      images: this.accumulatedImages.length > 0 ? this.accumulatedImages : void 0,
-      usage,
-      model,
-      responseId,
-      finish_reason,
-      citations,
-      annotations
-    };
-  }
-  /**
-   * Parse a single SSE line
-   */
-  _parseLine(line) {
-    if (!line.trim()) return null;
-    if (!line.startsWith("data: ")) {
+// client/ProviderManager.ts
+function getImageResolutionFromDataUrl(dataUrl) {
+  try {
+    if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:"))
       return null;
-    }
-    const jsonData = line.slice(6);
-    if (jsonData === "[DONE]") {
+    const commaIdx = dataUrl.indexOf(",");
+    if (commaIdx === -1) return null;
+    const meta = dataUrl.slice(5, commaIdx);
+    const base64 = dataUrl.slice(commaIdx + 1);
+    const binary = typeof atob === "function" ? atob(base64) : Buffer.from(base64, "base64").toString("binary");
+    const len = binary.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) bytes[i] = binary.charCodeAt(i);
+    const isPNG = meta.includes("image/png");
+    const isJPEG = meta.includes("image/jpeg") || meta.includes("image/jpg");
+    if (isPNG) {
+      const sig = [137, 80, 78, 71, 13, 10, 26, 10];
+      for (let i = 0; i < sig.length; i++) {
+        if (bytes[i] !== sig[i]) return null;
+      }
+      const view = new DataView(
+        bytes.buffer,
+        bytes.byteOffset,
+        bytes.byteLength
+      );
+      const width = view.getUint32(16, false);
+      const height = view.getUint32(20, false);
+      if (width > 0 && height > 0) return { width, height };
       return null;
     }
-    try {
-      const parsed = JSON.parse(jsonData);
-      const result = {};
-      if (parsed.choices?.[0]?.delta?.content) {
-        result.content = parsed.choices[0].delta.content;
-      }
-      if (parsed.choices?.[0]?.delta?.reasoning) {
-        result.reasoning = parsed.choices[0].delta.reasoning;
-      }
-      const extractedUsage = extractUsageFromSSEJson(parsed);
-      if (extractedUsage) {
-        result.usage = toUsageStats(extractedUsage);
-      } else if (parsed.usage) {
-        result.usage = {
-          total_tokens: parsed.usage.total_tokens ?? parsed.usage.input_tokens + parsed.usage.output_tokens,
-          prompt_tokens: parsed.usage.prompt_tokens ?? parsed.usage.input_tokens,
-          completion_tokens: parsed.usage.completion_tokens ?? parsed.usage.output_tokens
-        };
-      }
-      if (parsed.id) {
-        result.responseId = parsed.id;
-      }
-      if (parsed.model) {
-        result.model = parsed.model;
-      }
-      if (parsed.citations) {
-        result.citations = parsed.citations;
-      }
-      if (parsed.annotations) {
-        result.annotations = parsed.annotations;
-      }
-      if (parsed.choices?.[0]?.finish_reason) {
-        result.finish_reason = parsed.choices[0].finish_reason;
-      }
-      const images = parsed.choices?.[0]?.message?.images || parsed.choices?.[0]?.delta?.images;
-      if (images && Array.isArray(images)) {
-        result.images = images;
+    if (isJPEG) {
+      let offset = 0;
+      if (bytes[offset++] !== 255 || bytes[offset++] !== 216) return null;
+      while (offset < bytes.length) {
+        while (offset < bytes.length && bytes[offset] !== 255) offset++;
+        if (offset + 1 >= bytes.length) break;
+        while (bytes[offset] === 255) offset++;
+        const marker = bytes[offset++];
+        if (marker === 216 || marker === 217) continue;
+        if (offset + 1 >= bytes.length) break;
+        const length = bytes[offset] << 8 | bytes[offset + 1];
+        offset += 2;
+        if (marker === 192 || marker === 194) {
+          if (length < 7 || offset + length - 2 > bytes.length) return null;
+          const precision = bytes[offset];
+          const height = bytes[offset + 1] << 8 | bytes[offset + 2];
+          const width = bytes[offset + 3] << 8 | bytes[offset + 4];
+          if (precision > 0 && width > 0 && height > 0)
+            return { width, height };
+          return null;
+        } else {
+          offset += length - 2;
+        }
       }
-      return result;
-    } catch {
       return null;
     }
+    return null;
+  } catch {
+    return null;
   }
-  /**
-   * Handle content delta with thinking support
-   */
-  _handleContent(content, callbacks, modelId) {
-    if (this.isInThinking && !this.isInContent) {
-      this.accumulatedThinking += "</thinking>";
-      callbacks.onThinking(this.accumulatedThinking);
-      this.isInThinking = false;
-      this.isInContent = true;
+}
+function calculateImageTokens(width, height, detail = "auto") {
+  if (detail === "low") return 85;
+  let w = width;
+  let h = height;
+  if (w > 2048 || h > 2048) {
+    const aspectRatio = w / h;
+    if (w > h) {
+      w = 2048;
+      h = Math.floor(w / aspectRatio);
+    } else {
+      h = 2048;
+      w = Math.floor(h * aspectRatio);
     }
-    if (modelId) {
-      this._extractThinkingFromContent(content, callbacks);
+  }
+  if (w > 768 || h > 768) {
+    const aspectRatio = w / h;
+    if (w > h) {
+      w = 768;
+      h = Math.floor(w / aspectRatio);
     } else {
-      this.accumulatedContent += content;
+      h = 768;
+      w = Math.floor(h * aspectRatio);
+    }
+  }
+  const tilesWidth = Math.floor((w + 511) / 512);
+  const tilesHeight = Math.floor((h + 511) / 512);
+  const numTiles = tilesWidth * tilesHeight;
+  return 85 + 170 * numTiles;
+}
+var ProviderManager = class _ProviderManager {
+  constructor(providerRegistry, store, logger) {
+    this.providerRegistry = providerRegistry;
+    this.instanceId = `pm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    this.logger = (logger ?? consoleLogger).child(`ProviderManager:${this.instanceId}`);
+    if (store) {
+      this.store = store;
+      this.hydrateFromStore();
     }
-    callbacks.onContent(this.accumulatedContent);
   }
+  providerRegistry;
+  failedProviders = /* @__PURE__ */ new Set();
+  /** Track when each provider last failed (provider URL -> timestamp) */
+  lastFailed = /* @__PURE__ */ new Map();
+  /** Providers on cooldown: [provider_url, cooldown_started_timestamp][] */
+  providersOnCoolDown = [];
+  /** Cooldown duration in milliseconds (42 seconds) */
+  static COOLDOWN_DURATION_MS = 42 * 1e3;
+  /** Optional persistent store for failure tracking */
+  store = null;
+  /** Instance ID for debugging */
+  instanceId;
+  logger;
   /**
-   * Handle thinking/reasoning content
+   * Hydrate in-memory state from persistent store
    */
-  _handleThinking(reasoning, callbacks) {
-    if (!this.isInThinking) {
-      this.accumulatedThinking += "<thinking> ";
-      this.isInThinking = true;
-    }
-    this.accumulatedThinking += reasoning;
-    callbacks.onThinking(this.accumulatedThinking);
+  hydrateFromStore() {
+    if (!this.store) return;
+    const state = this.store.getState();
+    this.failedProviders = new Set(state.failedProviders);
+    this.lastFailed = new Map(Object.entries(state.lastFailed));
+    const now = Date.now();
+    this.providersOnCoolDown = state.providersOnCooldown.filter(
+      (entry) => now - entry.timestamp < _ProviderManager.COOLDOWN_DURATION_MS
+    ).map((entry) => [entry.baseUrl, entry.timestamp]);
+    this.logger.log(`Hydrated from store: failedProviders=${this.failedProviders.size} lastFailed=${this.lastFailed.size} providersOnCooldown=${this.providersOnCoolDown.length}`);
   }
   /**
-   * Extract thinking blocks from content (for models with inline thinking)
-   */
-  _extractThinkingFromContent(content, callbacks) {
-    const parts = content.split(/(<thinking>|<\/thinking>)/);
-    for (const part of parts) {
-      if (part === "<thinking>") {
-        this.isInThinking = true;
-        if (!this.accumulatedThinking.includes("<thinking>")) {
-          this.accumulatedThinking += "<thinking> ";
-        }
-      } else if (part === "</thinking>") {
-        this.isInThinking = false;
-        this.accumulatedThinking += "</thinking>";
-      } else if (this.isInThinking) {
-        this.accumulatedThinking += part;
-      } else {
-        this.accumulatedContent += part;
-      }
-    }
-  }
-  /**
-   * Merge images into accumulated array, avoiding duplicates
-   */
-  _mergeImages(newImages) {
-    for (const img of newImages) {
-      const newUrl = img.image_url?.url;
-      const existingIndex = this.accumulatedImages.findIndex((existing) => {
-        const existingUrl = existing.image_url?.url;
-        if (newUrl && existingUrl) {
-          return existingUrl === newUrl;
-        }
-        if (img.index !== void 0 && existing.index !== void 0) {
-          return existing.index === img.index;
-        }
-        return false;
-      });
-      if (existingIndex === -1) {
-        this.accumulatedImages.push(img);
-      } else {
-        this.accumulatedImages[existingIndex] = img;
-      }
-    }
-  }
-};
-
-// utils/torUtils.ts
-var TOR_ONION_SUFFIX = ".onion";
-var isTorContext = () => {
-  if (typeof window === "undefined") return false;
-  const hostname = window.location.hostname.toLowerCase();
-  return hostname.endsWith(TOR_ONION_SUFFIX);
-};
-var isOnionUrl = (url) => {
-  if (!url) return false;
-  const trimmed = url.trim().toLowerCase();
-  if (!trimmed) return false;
-  try {
-    const candidate = trimmed.startsWith("http") ? trimmed : `http://${trimmed}`;
-    return new URL(candidate).hostname.endsWith(TOR_ONION_SUFFIX);
-  } catch {
-    return trimmed.includes(TOR_ONION_SUFFIX);
-  }
-};
-var shouldAllowHttp = (url, torMode) => {
-  if (!url.startsWith("http://")) return true;
-  if (url.includes("localhost") || url.includes("127.0.0.1")) return true;
-  return torMode && isOnionUrl(url);
-};
-var normalizeProviderUrl = (url, torMode = false) => {
-  if (!url || typeof url !== "string") return null;
-  const trimmed = url.trim();
-  if (!trimmed) return null;
-  if (/^https?:\/\//i.test(trimmed)) {
-    return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
-  }
-  const useHttpForOnion = torMode && isOnionUrl(trimmed);
-  const withProto = `${useHttpForOnion ? "http" : "https"}://${trimmed}`;
-  return withProto.endsWith("/") ? withProto : `${withProto}/`;
-};
-var dedupePreserveOrder = (urls) => {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const url of urls) {
-    if (!seen.has(url)) {
-      seen.add(url);
-      out.push(url);
-    }
-  }
-  return out;
-};
-var getProviderEndpoints = (provider, torMode) => {
-  const rawUrls = [
-    provider.endpoint_url,
-    ...Array.isArray(provider.endpoint_urls) ? provider.endpoint_urls : [],
-    provider.onion_url,
-    ...Array.isArray(provider.onion_urls) ? provider.onion_urls : []
-  ];
-  const normalized = rawUrls.map((value) => normalizeProviderUrl(value, torMode)).filter((value) => Boolean(value));
-  const unique = dedupePreserveOrder(normalized).filter(
-    (value) => shouldAllowHttp(value, torMode)
-  );
-  if (unique.length === 0) return [];
-  const onion = unique.filter((value) => isOnionUrl(value));
-  const clearnet = unique.filter((value) => !isOnionUrl(value));
-  if (torMode) {
-    return onion.length > 0 ? onion : clearnet;
-  }
-  return clearnet;
-};
-var filterBaseUrlsForTor = (baseUrls, torMode) => {
-  if (!Array.isArray(baseUrls)) return [];
-  const normalized = baseUrls.map((value) => normalizeProviderUrl(value, torMode)).filter((value) => Boolean(value));
-  const filtered = normalized.filter(
-    (value) => torMode ? true : !isOnionUrl(value)
-  );
-  return dedupePreserveOrder(
-    filtered.filter((value) => shouldAllowHttp(value, torMode))
-  );
-};
-
-// client/ProviderManager.ts
-function getImageResolutionFromDataUrl(dataUrl) {
-  try {
-    if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:"))
-      return null;
-    const commaIdx = dataUrl.indexOf(",");
-    if (commaIdx === -1) return null;
-    const meta = dataUrl.slice(5, commaIdx);
-    const base64 = dataUrl.slice(commaIdx + 1);
-    const binary = typeof atob === "function" ? atob(base64) : Buffer.from(base64, "base64").toString("binary");
-    const len = binary.length;
-    const bytes = new Uint8Array(len);
-    for (let i = 0; i < len; i++) bytes[i] = binary.charCodeAt(i);
-    const isPNG = meta.includes("image/png");
-    const isJPEG = meta.includes("image/jpeg") || meta.includes("image/jpg");
-    if (isPNG) {
-      const sig = [137, 80, 78, 71, 13, 10, 26, 10];
-      for (let i = 0; i < sig.length; i++) {
-        if (bytes[i] !== sig[i]) return null;
-      }
-      const view = new DataView(
-        bytes.buffer,
-        bytes.byteOffset,
-        bytes.byteLength
-      );
-      const width = view.getUint32(16, false);
-      const height = view.getUint32(20, false);
-      if (width > 0 && height > 0) return { width, height };
-      return null;
-    }
-    if (isJPEG) {
-      let offset = 0;
-      if (bytes[offset++] !== 255 || bytes[offset++] !== 216) return null;
-      while (offset < bytes.length) {
-        while (offset < bytes.length && bytes[offset] !== 255) offset++;
-        if (offset + 1 >= bytes.length) break;
-        while (bytes[offset] === 255) offset++;
-        const marker = bytes[offset++];
-        if (marker === 216 || marker === 217) continue;
-        if (offset + 1 >= bytes.length) break;
-        const length = bytes[offset] << 8 | bytes[offset + 1];
-        offset += 2;
-        if (marker === 192 || marker === 194) {
-          if (length < 7 || offset + length - 2 > bytes.length) return null;
-          const precision = bytes[offset];
-          const height = bytes[offset + 1] << 8 | bytes[offset + 2];
-          const width = bytes[offset + 3] << 8 | bytes[offset + 4];
-          if (precision > 0 && width > 0 && height > 0)
-            return { width, height };
-          return null;
-        } else {
-          offset += length - 2;
-        }
-      }
-      return null;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function calculateImageTokens(width, height, detail = "auto") {
-  if (detail === "low") return 85;
-  let w = width;
-  let h = height;
-  if (w > 2048 || h > 2048) {
-    const aspectRatio = w / h;
-    if (w > h) {
-      w = 2048;
-      h = Math.floor(w / aspectRatio);
-    } else {
-      h = 2048;
-      w = Math.floor(h * aspectRatio);
-    }
-  }
-  if (w > 768 || h > 768) {
-    const aspectRatio = w / h;
-    if (w > h) {
-      w = 768;
-      h = Math.floor(w / aspectRatio);
-    } else {
-      h = 768;
-      w = Math.floor(h * aspectRatio);
-    }
-  }
-  const tilesWidth = Math.floor((w + 511) / 512);
-  const tilesHeight = Math.floor((h + 511) / 512);
-  const numTiles = tilesWidth * tilesHeight;
-  return 85 + 170 * numTiles;
-}
-function isInsecureHttpUrl(url) {
-  return url.startsWith("http://");
-}
-var ProviderManager = class _ProviderManager {
-  constructor(providerRegistry, store, logger) {
-    this.providerRegistry = providerRegistry;
-    this.instanceId = `pm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-    this.logger = (logger ?? consoleLogger).child(`ProviderManager:${this.instanceId}`);
-    if (store) {
-      this.store = store;
-      this.hydrateFromStore();
-    }
-  }
-  providerRegistry;
-  failedProviders = /* @__PURE__ */ new Set();
-  /** Track when each provider last failed (provider URL -> timestamp) */
-  lastFailed = /* @__PURE__ */ new Map();
-  /** Providers on cooldown: [provider_url, cooldown_started_timestamp][] */
-  providersOnCoolDown = [];
-  /** Cooldown duration in milliseconds (42 seconds) */
-  static COOLDOWN_DURATION_MS = 42 * 1e3;
-  /** Optional persistent store for failure tracking */
-  store = null;
-  /** Instance ID for debugging */
-  instanceId;
-  logger;
-  /**
-   * Hydrate in-memory state from persistent store
-   */
-  hydrateFromStore() {
-    if (!this.store) return;
-    const state = this.store.getState();
-    this.failedProviders = new Set(state.failedProviders);
-    this.lastFailed = new Map(Object.entries(state.lastFailed));
-    const now = Date.now();
-    this.providersOnCoolDown = state.providersOnCooldown.filter(
-      (entry) => now - entry.timestamp < _ProviderManager.COOLDOWN_DURATION_MS
-    ).map((entry) => [entry.baseUrl, entry.timestamp]);
-    this.logger.log(`Hydrated from store: failedProviders=${this.failedProviders.size} lastFailed=${this.lastFailed.size} providersOnCooldown=${this.providersOnCoolDown.length}`);
-  }
-  /**
-   * Get instance ID for debugging
+   * Get instance ID for debugging
    */
   getInstanceId() {
     return this.instanceId;
@@ -2874,7 +2725,7 @@ var ProviderManager = class _ProviderManager {
         if (this.isOnCooldown(baseUrl)) {
           continue;
         }
-        if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl))) {
+        if (!torMode && isOnionUrl(baseUrl)) {
           continue;
         }
         const model = models.find((m) => m.id === modelId);
@@ -2925,7 +2776,7 @@ var ProviderManager = class _ProviderManager {
     for (const [baseUrl, models] of Object.entries(allProviders)) {
       if (disabledProviders.has(baseUrl)) continue;
       if (this.isOnCooldown(baseUrl)) continue;
-      if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl)))
+      if (!torMode && isOnionUrl(baseUrl))
         continue;
       const model = models.find((m) => m.id === modelId);
       if (!model) continue;
@@ -2940,16 +2791,18 @@ var ProviderManager = class _ProviderManager {
   getProviderPriceRankingForModel(modelId, options = {}) {
     const includeDisabled = options.includeDisabled ?? false;
     const torMode = options.torMode ?? false;
-    const disabledProviders = new Set(
-      this.providerRegistry.getDisabledProviders()
-    );
+    const disabledProviderList = this.providerRegistry.getDisabledProviders();
+    const disabledProviders = new Set(disabledProviderList);
+    if (disabledProviderList.length > 0) {
+      this.logger.log(`getProviderPriceRankingForModel: disabled providers (${disabledProviderList.length}): ${disabledProviderList.join(", ")}`);
+    }
     const allModels = this.providerRegistry.getAllProvidersModels();
     const results = [];
     for (const [baseUrl, models] of Object.entries(allModels)) {
       if (!includeDisabled && disabledProviders.has(baseUrl)) continue;
       if (this.isOnCooldown(baseUrl)) continue;
       if (torMode && !baseUrl.includes(".onion")) continue;
-      if (!torMode && (baseUrl.includes(".onion") || isInsecureHttpUrl(baseUrl)))
+      if (!torMode && baseUrl.includes(".onion"))
         continue;
       const match = models.find((model) => model.id === modelId);
       if (!match?.sats_pricing) continue;
@@ -2969,12 +2822,20 @@ var ProviderManager = class _ProviderManager {
         totalPerMillion
       });
     }
-    return results.sort((a, b) => {
+    results.sort((a, b) => {
       if (a.totalPerMillion !== b.totalPerMillion) {
         return a.totalPerMillion - b.totalPerMillion;
       }
       return a.baseUrl.localeCompare(b.baseUrl);
     });
+    if (results.length > 0) {
+      const ranking = results.map((r, i) => `  ${i + 1}. ${r.baseUrl} total=${r.totalPerMillion.toFixed(2)} sats/M (prompt=${r.promptPerMillion.toFixed(2)} completion=${r.completionPerMillion.toFixed(2)})`).join("\n");
+      this.logger.log(`getProviderPriceRankingForModel: ${modelId} ranking (${results.length} providers):
+${ranking}`);
+    } else {
+      this.logger.log(`getProviderPriceRankingForModel: ${modelId} no providers found`);
+    }
+    return results;
   }
   /**
    * Get best-priced provider for a specific model
@@ -3167,141 +3028,6 @@ var createMemoryDriver = (seed) => {
   };
 };
 
-// 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) => {
@@ -3309,15 +3035,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 = {}) => {
@@ -3430,9 +3173,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 });
@@ -3440,10 +3184,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 = {}) => {
@@ -3465,6 +3224,9 @@ var matchesFilters = (entry, options = {}) => {
   if (options.client && entry.client !== options.client) {
     return false;
   }
+  if (options.provider && entry.provider !== options.provider) {
+    return false;
+  }
   return true;
 };
 var createIndexedDBUsageTrackingDriver = (options = {}) => {
@@ -3596,393 +3358,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;
@@ -3993,7 +3370,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) {
@@ -4002,23 +3379,26 @@ var matchesFilters2 = (entry, options = {}) => {
   if (options.client && entry.client !== options.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 = {}) {
@@ -4046,7 +3426,7 @@ var createMemoryUsageTrackingDriver = (seed = []) => {
     }
   };
 };
-var normalizeBaseUrl5 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   modelsFromAllProviders: {},
   lastUsedModel: null,
@@ -4069,7 +3449,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,
@@ -4082,7 +3462,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 });
   },
@@ -4091,14 +3471,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
       );
     }
@@ -4111,7 +3491,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 });
@@ -4119,7 +3499,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 });
@@ -4129,7 +3509,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
       }));
@@ -4141,7 +3521,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,
@@ -4155,9 +3535,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
       }));
@@ -4208,12 +3588,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];
@@ -4222,7 +3602,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);
@@ -4231,13 +3611,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);
@@ -4245,14 +3625,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 }];
@@ -4261,7 +3641,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);
@@ -4332,40 +3712,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,
@@ -4374,9 +3754,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
@@ -4397,16 +3777,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({
@@ -4447,12 +3827,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);
@@ -4481,24 +3861,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
@@ -4516,7 +3896,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
@@ -4524,7 +3904,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);
   },
@@ -4538,7 +3918,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 {
@@ -4551,7 +3931,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
@@ -4582,7 +3962,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
@@ -4590,7 +3970,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);
   },
@@ -4615,11 +3995,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 };
@@ -4630,7 +4010,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 };
@@ -4641,7 +4021,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];
@@ -4655,16 +4035,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 {
@@ -4686,39 +4066,292 @@ var createProviderRegistryFromStore = (store, logger) => {
   };
 };
 
-// storage/index.ts
-var isBrowser3 = () => {
-  try {
-    return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
-  } catch {
-    return false;
+// 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);
   }
-};
-var isNode = () => {
-  try {
-    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-  } catch {
-    return false;
+  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));
   }
-};
-var defaultDriver = null;
-var isBun3 = () => {
-  return typeof process.versions.bun !== "undefined";
-};
-var getDefaultSdkDriver = () => {
+  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;
   }
-  if (isBun3()) {
-    defaultDriver = createMemoryDriver();
-    return defaultDriver;
-  }
-  if (isNode()) {
-    defaultDriver = createSqliteDriver();
-    return defaultDriver;
-  }
   defaultDriver = createMemoryDriver();
   return defaultDriver;
 };
@@ -4739,38 +4372,195 @@ var getDefaultUsageTrackingDriver = () => {
     });
     return defaultUsageTrackingDriver;
   }
-  if (isBun3()) {
-    defaultUsageTrackingDriver = createBunSqliteUsageTrackingDriver();
-    return defaultUsageTrackingDriver;
-  }
-  if (isNode()) {
-    defaultUsageTrackingDriver = createSqliteUsageTrackingDriver({
-      legacyStorageDriver: storageDriver
-    });
-    return defaultUsageTrackingDriver;
-  }
   defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
   return defaultUsageTrackingDriver;
 };
 var setDefaultUsageTrackingDriver = (driver) => {
   defaultUsageTrackingDriver = driver;
 };
-var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
+var 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 () => createProviderRegistryFromStore(await getDefaultSdkStore());
+var getDefaultProviderRegistry = async () => createProviderRegistryFromDiscoveryAdapter(await getDefaultDiscoveryAdapter());
+
+// client/usage.ts
+var numOrUndef = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+function extractCostBreakdown(costObj) {
+  if (!costObj || typeof costObj !== "object") return {};
+  return {
+    baseMsats: numOrUndef(costObj.base_msats),
+    inputMsats: numOrUndef(costObj.input_msats),
+    outputMsats: numOrUndef(costObj.output_msats),
+    totalMsats: numOrUndef(costObj.total_msats),
+    totalUsd: numOrUndef(costObj.total_usd),
+    cacheReadInputTokens: numOrUndef(costObj.cache_read_input_tokens),
+    cacheCreationInputTokens: numOrUndef(costObj.cache_creation_input_tokens),
+    cacheReadMsats: numOrUndef(costObj.cache_read_msats),
+    cacheCreationMsats: numOrUndef(costObj.cache_creation_msats),
+    remainingBalanceMsats: numOrUndef(costObj.remaining_balance_msats)
+  };
+}
+function extractUsageFromResponseBody(body, fallbackSatsCost = 0) {
+  if (!body || typeof body !== "object") return null;
+  const usage = body.usage;
+  if (!usage || typeof usage !== "object") return null;
+  const promptTokens = Number(usage.prompt_tokens ?? 0);
+  const completionTokens = Number(usage.completion_tokens ?? 0);
+  const totalTokens = Number(usage.total_tokens ?? 0);
+  const costValue = usage.cost;
+  let cost = 0;
+  let satsCost = fallbackSatsCost;
+  let breakdown = {};
+  if (typeof costValue === "number") {
+    cost = costValue;
+  } else if (costValue && typeof costValue === "object") {
+    const costObj = costValue;
+    const totalUsd = costObj.total_usd;
+    const totalMsats = costObj.total_msats;
+    cost = typeof totalUsd === "number" ? totalUsd : 0;
+    if (typeof totalMsats === "number") {
+      satsCost = totalMsats / 1e3;
+    }
+    breakdown = extractCostBreakdown(costObj);
+  }
+  const provider = typeof body.provider === "string" ? body.provider : void 0;
+  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0 && cost === 0 && satsCost === 0) {
+    return null;
+  }
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    cost,
+    satsCost,
+    provider,
+    ...breakdown
+  };
+}
+function extractResponseId(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const id = body.id;
+  if (typeof id !== "string") return void 0;
+  const trimmed = id.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function extractUsageFromSSEJson(parsed, fallbackSatsCost = 0) {
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const provider = typeof parsed.provider === "string" ? parsed.provider : void 0;
+  if (!parsed.usage && parsed.cost && typeof parsed.cost === "object") {
+    const costObj = parsed.cost;
+    const msats2 = costObj.total_msats ?? 0;
+    const cost2 = costObj.total_usd ?? 0;
+    if (msats2 === 0 && cost2 === 0) return null;
+    return {
+      promptTokens: Number(costObj.input_tokens ?? 0),
+      completionTokens: Number(costObj.output_tokens ?? 0),
+      totalTokens: Number((costObj.input_tokens ?? 0) + (costObj.output_tokens ?? 0)),
+      cost: Number(cost2),
+      satsCost: msats2 > 0 ? msats2 / 1e3 : fallbackSatsCost,
+      provider,
+      ...extractCostBreakdown(costObj)
+    };
+  }
+  if (!parsed.usage) {
+    return null;
+  }
+  const usage = parsed.usage;
+  const usageCost = usage.cost;
+  let cost = 0;
+  let msats = 0;
+  let breakdown = {};
+  if (typeof usageCost === "number") {
+    cost = usageCost;
+  } else if (usageCost && typeof usageCost === "object") {
+    cost = usageCost.total_usd ?? 0;
+    msats = usageCost.total_msats ?? 0;
+    breakdown = extractCostBreakdown(usageCost);
+  }
+  const routstrCost = parsed.metadata?.routstr?.cost;
+  if (routstrCost && typeof routstrCost === "object") {
+    breakdown = { ...extractCostBreakdown(routstrCost), ...breakdown };
+  }
+  if (cost === 0) {
+    cost = parsed.metadata?.routstr?.cost?.total_usd ?? 0;
+  }
+  if (msats === 0) {
+    msats = parsed.metadata?.routstr?.cost?.total_msats ?? (typeof usage.cost_sats === "number" ? usage.cost_sats * 1e3 : 0);
+  }
+  const promptTokens = Number(usage.prompt_tokens ?? usage.input_tokens ?? 0);
+  const completionTokens = Number(usage.completion_tokens ?? usage.output_tokens ?? 0);
+  const totalTokens = Number(usage.total_tokens ?? promptTokens + completionTokens);
+  const result = {
+    promptTokens,
+    completionTokens,
+    totalTokens,
+    cost: Number(cost ?? 0),
+    satsCost: msats > 0 ? msats / 1e3 : fallbackSatsCost,
+    provider,
+    ...breakdown
+  };
+  if (result.promptTokens === 0 && result.completionTokens === 0 && result.totalTokens === 0 && result.cost === 0 && result.satsCost === 0) {
+    return null;
+  }
+  return result;
+}
+function toUsageStats(usage) {
+  if (!usage) return void 0;
+  return {
+    total_tokens: usage.totalTokens,
+    prompt_tokens: usage.promptTokens,
+    completion_tokens: usage.completionTokens,
+    cost: usage.cost,
+    sats_cost: usage.satsCost
+  };
+}
 function mergeUsage(previous, next) {
   if (!previous) return next;
+  const pickNum = (n, p) => typeof n === "number" && n > 0 ? n : p ?? n;
   return {
     promptTokens: next.promptTokens > 0 ? next.promptTokens : previous.promptTokens,
     completionTokens: next.completionTokens > 0 ? next.completionTokens : previous.completionTokens,
     totalTokens: next.totalTokens > 0 ? next.totalTokens : previous.totalTokens,
     cost: next.cost > 0 ? next.cost : previous.cost,
-    satsCost: next.satsCost > 0 ? next.satsCost : previous.satsCost
+    satsCost: next.satsCost > 0 ? next.satsCost : previous.satsCost,
+    provider: next.provider ?? previous.provider,
+    baseMsats: pickNum(next.baseMsats, previous.baseMsats),
+    inputMsats: pickNum(next.inputMsats, previous.inputMsats),
+    outputMsats: pickNum(next.outputMsats, previous.outputMsats),
+    totalMsats: pickNum(next.totalMsats, previous.totalMsats),
+    totalUsd: pickNum(next.totalUsd, previous.totalUsd),
+    cacheReadInputTokens: pickNum(
+      next.cacheReadInputTokens,
+      previous.cacheReadInputTokens
+    ),
+    cacheCreationInputTokens: pickNum(
+      next.cacheCreationInputTokens,
+      previous.cacheCreationInputTokens
+    ),
+    cacheReadMsats: pickNum(next.cacheReadMsats, previous.cacheReadMsats),
+    cacheCreationMsats: pickNum(
+      next.cacheCreationMsats,
+      previous.cacheCreationMsats
+    ),
+    remainingBalanceMsats: pickNum(
+      next.remainingBalanceMsats,
+      previous.remainingBalanceMsats
+    )
   };
 }
 function hasUsageChanged(previous, next) {
   if (!previous) return true;
-  return previous.promptTokens !== next.promptTokens || previous.completionTokens !== next.completionTokens || previous.totalTokens !== next.totalTokens || previous.cost !== next.cost || previous.satsCost !== next.satsCost;
+  return previous.promptTokens !== next.promptTokens || previous.completionTokens !== next.completionTokens || previous.totalTokens !== next.totalTokens || previous.cost !== next.cost || previous.satsCost !== next.satsCost || previous.provider !== next.provider || previous.totalMsats !== next.totalMsats || previous.remainingBalanceMsats !== next.remainingBalanceMsats;
+}
+function isInspectionComplete(responseIdCaptured, usage) {
+  return responseIdCaptured && !!usage && usage.totalTokens > 0 && typeof usage.totalMsats === "number" && !!usage.provider;
 }
 async function inspectSSEWebStream(stream, onUsage, onResponseId) {
   const reader = stream.getReader();
@@ -4780,14 +4570,22 @@ async function inspectSSEWebStream(stream, onUsage, onResponseId) {
   let capturedResponseId;
   let responseIdCaptured = false;
   const inspectDataPayload = (jsonText) => {
-    if (responseIdCaptured && capturedUsage && capturedUsage.totalTokens > 0) {
+    const trimmed = jsonText.trim();
+    if (!trimmed || trimmed === "[DONE]") {
+      if (trimmed === "[DONE]") console.log("[routstr:sse] [DONE]");
+      return;
+    }
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      console.log("[routstr:sse] non-JSON payload:", trimmed.slice(0, 200));
       return;
     }
-    const trimmed = jsonText.trim();
-    if (!trimmed || trimmed === "[DONE]") return;
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return;
     try {
       const data = JSON.parse(trimmed);
+      console.log("[routstr:sse] chunk:", JSON.stringify(data));
+      if (isInspectionComplete(responseIdCaptured, capturedUsage)) {
+        console.log("[routstr:sse] (inspection already complete, skipping)");
+        return;
+      }
       if (!responseIdCaptured) {
         const responseId = data?.id;
         if (typeof responseId === "string" && responseId.trim().length > 0) {
@@ -4798,19 +4596,21 @@ async function inspectSSEWebStream(stream, onUsage, onResponseId) {
       }
       const usage = extractUsageFromSSEJson(data);
       if (usage) {
+        console.log("[routstr:sse] \u2192 usage detected:", usage);
         const merged = mergeUsage(capturedUsage, usage);
         if (hasUsageChanged(capturedUsage, merged)) {
           capturedUsage = merged;
+          console.log("[routstr:sse] \u2192 merged (changed):", merged);
           onUsage(merged);
+        } else {
+          console.log("[routstr:sse] \u2192 merged (no change)");
         }
       }
     } catch {
+      console.log("[routstr:sse] failed to parse payload:", trimmed.slice(0, 200));
     }
   };
   const inspectEventBlock = (eventBlock) => {
-    if (responseIdCaptured && capturedUsage && capturedUsage.totalTokens > 0) {
-      return;
-    }
     const lines = eventBlock.split(/\r?\n/);
     const dataParts = [];
     for (const line of lines) {
@@ -4868,14 +4668,22 @@ function createSSEParserTransform(onUsage, onResponseId) {
   let capturedUsage = null;
   let responseIdCaptured = false;
   const inspectDataPayload = (jsonText) => {
-    if (responseIdCaptured && capturedUsage && capturedUsage.totalTokens > 0) {
+    const trimmed = jsonText.trim();
+    if (!trimmed || trimmed === "[DONE]") {
+      if (trimmed === "[DONE]") console.log("[routstr:sse] [DONE]");
+      return;
+    }
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      console.log("[routstr:sse] non-JSON payload:", trimmed.slice(0, 200));
       return;
     }
-    const trimmed = jsonText.trim();
-    if (!trimmed || trimmed === "[DONE]") return;
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return;
     try {
       const data = JSON.parse(trimmed);
+      console.log("[routstr:sse] chunk:", JSON.stringify(data));
+      if (isInspectionComplete(responseIdCaptured, capturedUsage)) {
+        console.log("[routstr:sse] (inspection already complete, skipping)");
+        return;
+      }
       if (!responseIdCaptured) {
         const responseId = data?.id;
         if (typeof responseId === "string" && responseId.trim().length > 0) {
@@ -4885,19 +4693,21 @@ function createSSEParserTransform(onUsage, onResponseId) {
       }
       const usage = extractUsageFromSSEJson(data);
       if (usage) {
+        console.log("[routstr:sse] \u2192 usage detected:", usage);
         const mergedUsage = mergeUsage(capturedUsage, usage);
         if (hasUsageChanged(capturedUsage, mergedUsage)) {
           capturedUsage = mergedUsage;
+          console.log("[routstr:sse] \u2192 merged (changed):", mergedUsage);
           onUsage(mergedUsage);
+        } else {
+          console.log("[routstr:sse] \u2192 merged (no change)");
         }
       }
     } catch {
+      console.log("[routstr:sse] failed to parse payload:", trimmed.slice(0, 200));
     }
   };
   const inspectEventBlock = (eventBlock) => {
-    if (responseIdCaptured && capturedUsage && capturedUsage.totalTokens > 0) {
-      return;
-    }
     const lines = eventBlock.split(/\r?\n/);
     const dataParts = [];
     for (const line of lines) {
@@ -4970,7 +4780,6 @@ var RoutstrClient = class {
       this.balanceManager,
       this.logger
     );
-    this.streamProcessor = new StreamProcessor();
     this.alertLevel = alertLevel;
     this.mode = mode;
     this.usageTrackingDriver = options.usageTrackingDriver;
@@ -4982,7 +4791,6 @@ var RoutstrClient = class {
   providerRegistry;
   cashuSpender;
   balanceManager;
-  streamProcessor;
   providerManager;
   alertLevel;
   mode;
@@ -5067,6 +4875,8 @@ var RoutstrClient = class {
         baseUrl: prepared.baseUrlUsed,
         mintUrl: params.mintUrl,
         initialTokenBalance: prepared.tokenBalanceInSats,
+        initialTokenBalanceUnknown: prepared.tokenBalanceUnknown,
+        fallbackSatsSpent: usage?.satsCost,
         response: prepared.response,
         modelId: prepared.modelId,
         usage,
@@ -5131,7 +4941,7 @@ var RoutstrClient = class {
         );
       }
     }
-    const { token, tokenBalance, tokenBalanceUnit } = await this._spendToken({
+    const { token, tokenBalance, tokenBalanceUnit, tokenBalanceUnknown } = await this._spendToken({
       mintUrl,
       amount: requiredSats,
       baseUrl
@@ -5157,9 +4967,20 @@ var RoutstrClient = class {
       baseHeaders,
       selectedModel
     });
-    const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
+    let tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
+    let initialTokenBalanceUnknown = tokenBalanceUnknown;
     const baseUrlUsed = response.baseUrl || baseUrl;
     const tokenUsed = response.token || token;
+    if (baseUrlUsed !== baseUrl || tokenUsed !== token) {
+      if (typeof response.initialTokenBalanceInSats === "number") {
+        tokenBalanceInSats = response.initialTokenBalanceInSats;
+        initialTokenBalanceUnknown = Boolean(
+          response.initialTokenBalanceUnknown
+        );
+      } else {
+        initialTokenBalanceUnknown = true;
+      }
+    }
     const contentType = response.headers.get("content-type") || "";
     let processedResponse = response;
     let capturedUsage;
@@ -5192,6 +5013,7 @@ var RoutstrClient = class {
       tokenUsed,
       baseUrlUsed,
       tokenBalanceInSats,
+      tokenBalanceUnknown: initialTokenBalanceUnknown,
       modelId,
       capturedUsage,
       capturedResponseId,
@@ -5211,899 +5033,1049 @@ var RoutstrClient = class {
     return void 0;
   }
   /**
-   * Fetch AI response with streaming
+   * Make the API request with failover support
    */
-  async fetchAIResponse(options, callbacks) {
-    const {
-      messageHistory,
-      selectedModel,
-      baseUrl,
-      mintUrl,
-      balance,
-      transactionHistory,
-      maxTokens,
-      headers
-    } = options;
-    const apiMessages = await this._convertMessages(messageHistory);
-    const requiredSats = this.providerManager.getRequiredSatsForModel(
-      selectedModel,
-      apiMessages,
-      maxTokens
-    );
+  async _makeRequest(params) {
+    const { path, method, body, baseUrl, token, headers } = params;
     try {
-      await this._checkBalance();
-      callbacks.onPaymentProcessing?.(true);
-      const spendResult = await this._spendToken({
-        mintUrl,
-        amount: requiredSats,
-        baseUrl
+      const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+      if (this.mode === "xcashu") this._log("DEBUG", "HEADERS,", headers);
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: body === void 0 || method === "GET" ? void 0 : JSON.stringify(body)
       });
-      let token = spendResult.token;
-      let tokenBalance = spendResult.tokenBalance;
-      let tokenBalanceUnit = spendResult.tokenBalanceUnit;
-      const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
-      callbacks.onTokenCreated?.(this._getPendingCashuTokenAmount());
-      const baseHeaders = this._buildBaseHeaders(headers);
-      const requestHeaders = this._withAuthHeader(baseHeaders, token);
-      const providerInfo = await this.providerRegistry.getProviderInfo(baseUrl);
-      const providerVersion = providerInfo?.version ?? "";
-      let modelIdForRequest = selectedModel.id;
-      if (/^0\.1\./.test(providerVersion)) {
-        const newModel = await this.providerManager.getModelForProvider(
-          baseUrl,
-          selectedModel.id
+      if (this.mode === "xcashu") this._log("DEBUG", "response,", response);
+      response.baseUrl = baseUrl;
+      response.token = token;
+      if (!response.ok) {
+        const requestId = response.headers.get("x-routstr-request-id") || void 0;
+        let bodyText;
+        try {
+          bodyText = await response.text();
+        } catch (e) {
+          bodyText = void 0;
+        }
+        return await this._handleErrorResponse(
+          params,
+          token,
+          response.status,
+          requestId,
+          this.mode === "xcashu" ? response.headers.get("x-cashu") ?? void 0 : void 0,
+          bodyText,
+          params.retryCount ?? 0
         );
-        modelIdForRequest = newModel?.id ?? selectedModel.id;
       }
-      const body = {
-        model: modelIdForRequest,
-        messages: apiMessages,
-        stream: true
-      };
-      if (maxTokens !== void 0) {
-        body.max_tokens = maxTokens;
+      return response;
+    } catch (error) {
+      if (isNetworkErrorMessage(error?.message || "")) {
+        return await this._handleErrorResponse(
+          params,
+          token,
+          -1,
+          // just for Network Error to skip all statuses
+          void 0,
+          void 0,
+          void 0,
+          params.retryCount ?? 0
+        );
       }
-      if (selectedModel?.name?.startsWith("OpenAI:")) {
-        body.tools = [{ type: "web_search" }];
+      throw error;
+    }
+  }
+  /**
+   * Handle error responses with failover
+   */
+  async _handleErrorResponse(params, token, status, requestId, xCashuRefundToken, responseBody, retryCount = 0) {
+    const MAX_RETRIES_PER_PROVIDER = 2;
+    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
+    let tryNextProvider = false;
+    const errorMessage = responseBody;
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _handleErrorResponse: status=${status}, baseUrl=${baseUrl}, mode=${this.mode}, token preview=${token}, requestId=${requestId}, errorMessage=${errorMessage}`
+    );
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _handleErrorResponse: Attempting to receive/restore token for ${baseUrl}`
+    );
+    if (params.token.startsWith("cashu")) {
+      const receiveResult = await this.cashuSpender.receiveToken(
+        params.token
+      );
+      if (receiveResult.success) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${receiveResult.amount}`
+        );
+        tryNextProvider = true;
+      } else {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Failed to receive token: ${receiveResult.message}`
+        );
       }
-      const response = await this._makeRequest({
-        path: "/v1/chat/completions",
-        method: "POST",
-        body,
-        selectedModel,
-        baseUrl,
-        mintUrl,
-        token,
-        requiredSats,
-        maxTokens,
-        headers: requestHeaders,
-        baseHeaders
-      });
-      if (!response.body) {
-        throw new Error("Response body is not available");
+    }
+    if (this.mode === "xcashu") {
+      if (xCashuRefundToken) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Attempting to receive xcashu refund token, preview=${xCashuRefundToken.substring(0, 20)}...`
+        );
+        const receiveResult = await this.cashuSpender.receiveToken(xCashuRefundToken);
+        if (receiveResult.success) {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: xcashu refund received, amount=${receiveResult.amount}`
+          );
+          tryNextProvider = true;
+        } else {
+          this._log(
+            "ERROR",
+            `[xcashu] Failed to receive refund token: ${receiveResult.message}`
+          );
+          throw new ProviderError(
+            baseUrl,
+            status,
+            "[xcashu] Failed to receive refund token",
+            requestId
+          );
+        }
+      } else {
+        if (!tryNextProvider)
+          throw new ProviderError(
+            baseUrl,
+            status,
+            "[xcashu] Failed to receive refund token",
+            requestId
+          );
       }
-      if (response.status === 200) {
-        const baseUrlUsed = response.baseUrl || baseUrl;
-        const streamingResult = await this.streamProcessor.process(
-          response,
-          {
-            onContent: callbacks.onStreamingUpdate,
-            onThinking: callbacks.onThinkingUpdate
-          },
-          selectedModel.id
+    }
+    if (status === 402 && !tryNextProvider && this.mode === "apikeys") {
+      this.storageAdapter.getApiKey(baseUrl);
+      let topupAmount = params.requiredSats;
+      try {
+        const currentBalanceInfo = await this.balanceManager.getTokenBalance(
+          params.token,
+          baseUrl
         );
-        if (streamingResult.finish_reason === "content_filter") {
-          callbacks.onMessageAppend({
-            role: "assistant",
-            content: "Your request was denied due to content filtering."
-          });
-        } else if (streamingResult.content || streamingResult.images && streamingResult.images.length > 0) {
-          const message = await this._createAssistantMessage(streamingResult);
-          callbacks.onMessageAppend(message);
+        if (currentBalanceInfo.balanceUnknown) {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Current balance unknown for ${baseUrl}; using default topup amount=${topupAmount}`
+          );
         } else {
-          callbacks.onMessageAppend({
-            role: "system",
-            content: "The provider did not respond to this request."
-          });
+          const currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
+          const reservedBalance = currentBalanceInfo.unit === "msat" ? (currentBalanceInfo.reserved ?? 0) / 1e3 : currentBalanceInfo.reserved ?? 0;
+          const shortfall = Math.max(
+            0,
+            params.requiredSats - currentBalance + reservedBalance
+          );
+          topupAmount = shortfall > 0.21 * params.requiredSats ? shortfall : 0.21 * params.requiredSats;
+          this._log(
+            "DEBUG",
+            `The shortfall is: ${shortfall}. requiredSats: ${params.requiredSats}. Current Balance: ${currentBalance}. Reserved Balance: ${reservedBalance}. Available Balance: ${currentBalance - reservedBalance}`
+          );
         }
-        callbacks.onStreamingUpdate("");
-        callbacks.onThinkingUpdate("");
-        const isApikeysEstimate = this.mode === "apikeys";
-        let satsSpent = await this._handlePostResponseBalanceUpdate({
-          token,
-          baseUrl: baseUrlUsed,
-          mintUrl,
-          initialTokenBalance: tokenBalanceInSats,
-          fallbackSatsSpent: isApikeysEstimate ? this._getEstimatedCosts(selectedModel, streamingResult) : void 0,
-          response,
-          modelId: selectedModel.id,
-          usage: streamingResult.usage ? {
-            promptTokens: Number(streamingResult.usage.prompt_tokens ?? 0),
-            completionTokens: Number(
-              streamingResult.usage.completion_tokens ?? 0
-            ),
-            totalTokens: Number(streamingResult.usage.total_tokens ?? 0),
-            cost: Number(streamingResult.usage.cost ?? 0),
-            satsCost: Number(streamingResult.usage.sats_cost ?? 0)
-          } : void 0,
-          requestId: streamingResult.responseId
-        });
-        const estimatedCosts = this._getEstimatedCosts(
-          selectedModel,
-          streamingResult
+      } catch (e) {
+        this._log(
+          "WARN",
+          "Could not get current token balance for topup calculation:",
+          e
         );
-        const onLastMessageSatsUpdate = callbacks.onLastMessageSatsUpdate;
-        onLastMessageSatsUpdate?.(satsSpent, estimatedCosts);
+      }
+      const topupResult = await this.balanceManager.topUp({
+        mintUrl,
+        baseUrl,
+        amount: topupAmount * TOPUP_MARGIN,
+        token: params.token
+      });
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Topup result for ${baseUrl}: success=${topupResult.success}, message=${topupResult.message}`
+      );
+      if (!topupResult.success) {
+        const message = topupResult.message || "";
+        if (message.includes("Insufficient balance")) {
+          const needMatch = message.match(/need (\d+)/);
+          const haveMatch = message.match(/have (\d+)/);
+          const required = needMatch ? parseInt(needMatch[1], 10) : params.requiredSats;
+          const available = haveMatch ? parseInt(haveMatch[1], 10) : 0;
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
+          );
+          throw new InsufficientBalanceError(
+            required,
+            available,
+            0,
+            "",
+            message
+          );
+        } else {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Topup failed with non-insufficient-balance error, will try next provider`
+          );
+          tryNextProvider = true;
+        }
       } else {
-        throw new Error(`${response.status} ${response.statusText}`);
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Topup successful, will retry with new token`
+        );
+      }
+      if (!tryNextProvider) {
+        if (retryCount < MAX_RETRIES_PER_PROVIDER) {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Retrying 402 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
+          );
+          return this._makeRequest({
+            ...params,
+            token: params.token,
+            headers: this._withAuthHeader(params.baseHeaders, params.token),
+            retryCount: retryCount + 1
+          });
+        } else {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: 402 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
+          );
+          tryNextProvider = true;
+        }
       }
-    } catch (error) {
-      this._handleError(error, callbacks);
-    } finally {
-      callbacks.onPaymentProcessing?.(false);
     }
-  }
-  /**
-   * Make the API request with failover support
-   */
-  async _makeRequest(params) {
-    const { path, method, body, baseUrl, token, headers } = params;
-    try {
-      const url = `${baseUrl.replace(/\/$/, "")}${path}`;
-      if (this.mode === "xcashu") this._log("DEBUG", "HEADERS,", headers);
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: body === void 0 || method === "GET" ? void 0 : JSON.stringify(body)
-      });
-      if (this.mode === "xcashu") this._log("DEBUG", "response,", response);
-      response.baseUrl = baseUrl;
-      response.token = token;
-      if (!response.ok) {
-        const requestId = response.headers.get("x-routstr-request-id") || void 0;
-        let bodyText;
-        try {
-          bodyText = await response.text();
-        } catch (e) {
-          bodyText = void 0;
+    const isInsufficientBalance413 = status === 413 && responseBody?.includes("Insufficient balance");
+    if (isInsufficientBalance413 && !tryNextProvider && this.mode === "apikeys") {
+      let retryToken = params.token;
+      try {
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+          params.token,
+          baseUrl
+        );
+        if (latestBalanceInfo.isInvalidApiKey) {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Invalid API key (proofs already spent), removing for ${baseUrl}`
+          );
+          this.storageAdapter.removeApiKey(baseUrl);
+          tryNextProvider = true;
+        } else {
+          const latestTokenBalance = latestBalanceInfo.balanceUnknown ? void 0 : latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+          if (latestBalanceInfo.apiKey) {
+            const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+            if (storedApiKeyEntry?.key !== latestBalanceInfo.apiKey) {
+              if (storedApiKeyEntry) {
+                this.storageAdapter.removeApiKey(baseUrl);
+              }
+              this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
+            }
+            retryToken = latestBalanceInfo.apiKey;
+          }
+          if (latestTokenBalance !== void 0 && latestTokenBalance >= 0) {
+            this.storageAdapter.updateApiKeyBalance(
+              baseUrl,
+              latestTokenBalance
+            );
+          }
         }
-        return await this._handleErrorResponse(
-          params,
-          token,
-          response.status,
-          requestId,
-          this.mode === "xcashu" ? response.headers.get("x-cashu") ?? void 0 : void 0,
-          bodyText,
-          params.retryCount ?? 0
+      } catch (error) {
+        this._log(
+          "WARN",
+          `[RoutstrClient] _handleErrorResponse: Failed to refresh API key after 413 insufficient balance for ${baseUrl}`,
+          error
         );
       }
-      return response;
-    } catch (error) {
-      if (isNetworkErrorMessage(error?.message || "")) {
-        return await this._handleErrorResponse(
-          params,
+      if (retryCount < MAX_RETRIES_PER_PROVIDER) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Retrying 413 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
+        );
+        return this._makeRequest({
+          ...params,
+          token: retryToken,
+          headers: this._withAuthHeader(params.baseHeaders, retryToken),
+          retryCount: retryCount + 1
+        });
+      } else {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: 413 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
+        );
+        tryNextProvider = true;
+      }
+    }
+    if (status === 401 && this.mode === "apikeys") {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Checking balance for ${baseUrl}, key preview=${token}`
+      );
+      const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+        token,
+        baseUrl
+      );
+      if (latestBalanceInfo.isInvalidApiKey) {
+        this.storageAdapter.removeApiKey(baseUrl);
+        tryNextProvider = true;
+      }
+    }
+    if ((status === 401 || status === 403 || status === 404 || status === 413 || status === 400 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Status ${status} (${status === 429 ? "rate limited" : "auth/server error"}), attempting refund for ${baseUrl}, mode=${this.mode}`
+      );
+      if (this.mode === "apikeys") {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`
+        );
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
           token,
-          -1,
-          // just for Network Error to skip all statuses
-          void 0,
-          void 0,
-          void 0,
-          params.retryCount ?? 0
+          baseUrl
         );
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${latestBalanceInfo.amount}`
+        );
+        const refundResult = await this.balanceManager.refundApiKey({
+          mintUrl,
+          baseUrl,
+          apiKey: token,
+          forceRefund: true
+        });
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
+        );
+        if (!refundResult.success && latestBalanceInfo.amount > 0 && !latestBalanceInfo.balanceUnknown) {
+          throw new ProviderError(
+            baseUrl,
+            status,
+            refundResult.message ?? "Unknown error"
+          );
+        }
       }
-      throw error;
     }
+    this.providerManager.markFailed(baseUrl);
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _handleErrorResponse: Marked provider ${baseUrl} as failed`
+    );
+    if (!selectedModel) {
+      throw new ProviderError(
+        baseUrl,
+        status,
+        "Funny, no selected model. HMM. "
+      );
+    }
+    const nextProvider = this.providerManager.findNextBestProvider(
+      selectedModel.id,
+      baseUrl
+    );
+    if (nextProvider) {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Failing over to next provider: ${nextProvider}, model: ${selectedModel.id}`
+      );
+      const newModel = await this.providerManager.getModelForProvider(
+        nextProvider,
+        selectedModel.id
+      ) ?? selectedModel;
+      const messagesForPricing = Array.isArray(
+        body?.messages
+      ) ? body.messages : [];
+      const newRequiredSats = this.providerManager.getRequiredSatsForModel(
+        newModel,
+        messagesForPricing,
+        params.maxTokens
+      );
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Creating new token for failover provider ${nextProvider}, required sats: ${newRequiredSats}`
+      );
+      const spendResult = await this._spendToken({
+        mintUrl,
+        amount: newRequiredSats,
+        baseUrl: nextProvider
+      });
+      const retryResponse = await this._makeRequest({
+        ...params,
+        path,
+        method,
+        body,
+        baseUrl: nextProvider,
+        selectedModel: newModel,
+        token: spendResult.token,
+        requiredSats: newRequiredSats,
+        headers: this._withAuthHeader(params.baseHeaders, spendResult.token),
+        retryCount: 0
+      });
+      retryResponse.initialTokenBalanceInSats = spendResult.tokenBalanceUnit === "msat" ? spendResult.tokenBalance / 1e3 : spendResult.tokenBalance;
+      retryResponse.initialTokenBalanceUnknown = spendResult.tokenBalanceUnknown;
+      return retryResponse;
+    }
+    throw new FailoverError(
+      baseUrl,
+      Array.from(this.providerManager.getFailedProviders())
+    );
   }
   /**
-   * Handle error responses with failover
+   * Handle post-response balance update for all modes
    */
-  async _handleErrorResponse(params, token, status, requestId, xCashuRefundToken, responseBody, retryCount = 0) {
-    const MAX_RETRIES_PER_PROVIDER = 2;
-    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
-    let tryNextProvider = false;
-    const errorMessage = responseBody;
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: status=${status}, baseUrl=${baseUrl}, mode=${this.mode}, token preview=${token}, requestId=${requestId}, errorMessage=${errorMessage}`
-    );
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: Attempting to receive/restore token for ${baseUrl}`
-    );
-    if (params.token.startsWith("cashu")) {
-      const receiveResult = await this.cashuSpender.receiveToken(
-        params.token
-      );
-      if (receiveResult.success) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${receiveResult.amount}`
-        );
-        tryNextProvider = true;
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Failed to receive token: ${receiveResult.message}`
-        );
-      }
-    }
-    if (this.mode === "xcashu") {
-      if (xCashuRefundToken) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Attempting to receive xcashu refund token, preview=${xCashuRefundToken.substring(0, 20)}...`
-        );
-        const receiveResult = await this.cashuSpender.receiveToken(xCashuRefundToken);
+  async _handlePostResponseBalanceUpdate(params) {
+    const {
+      token,
+      baseUrl,
+      mintUrl,
+      initialTokenBalance,
+      initialTokenBalanceUnknown,
+      fallbackSatsSpent,
+      response,
+      modelId,
+      usage,
+      requestId,
+      clientApiKey
+    } = params;
+    let satsSpent = initialTokenBalance;
+    if (this.mode === "xcashu" && response) {
+      const refundToken = response.headers.get("x-cashu") ?? void 0;
+      if (refundToken) {
+        const receiveResult = await this.cashuSpender.receiveToken(refundToken);
         if (receiveResult.success) {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: xcashu refund received, amount=${receiveResult.amount}`
-          );
-          tryNextProvider = true;
+          this.storageAdapter.removeXcashuToken(baseUrl, token);
+          satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
         } else {
           this._log(
             "ERROR",
             `[xcashu] Failed to receive refund token: ${receiveResult.message}`
           );
-          throw new ProviderError(
-            baseUrl,
-            status,
-            "[xcashu] Failed to receive refund token",
-            requestId
-          );
         }
-      } else {
-        if (!tryNextProvider)
-          throw new ProviderError(
-            baseUrl,
-            status,
-            "[xcashu] Failed to receive refund token",
-            requestId
-          );
       }
-    }
-    if (status === 402 && !tryNextProvider && this.mode === "apikeys") {
-      this.storageAdapter.getApiKey(baseUrl);
-      let topupAmount = params.requiredSats;
+    } else if (this.mode === "apikeys") {
       try {
-        const currentBalanceInfo = await this.balanceManager.getTokenBalance(
-          params.token,
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+          token,
           baseUrl
         );
-        const currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
-        const reservedBalance = currentBalanceInfo.unit === "msat" ? (currentBalanceInfo.reserved ?? 0) / 1e3 : currentBalanceInfo.reserved ?? 0;
-        const shortfall = Math.max(0, params.requiredSats - currentBalance + reservedBalance);
-        topupAmount = shortfall > 0.21 * params.requiredSats ? shortfall : 0.21 * params.requiredSats;
         this._log(
           "DEBUG",
-          `The shortfall is: ${shortfall}. requiredSats: ${params.requiredSats}. Current Balance: ${currentBalance}. Reserved Balance: ${reservedBalance}. Available Balance: ${currentBalance - reservedBalance}`
+          "LATEST Balance",
+          latestBalanceInfo.amount,
+          latestBalanceInfo.reserved,
+          latestBalanceInfo.apiKey,
+          baseUrl
         );
+        const latestTokenBalance = latestBalanceInfo.balanceUnknown ? void 0 : latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+        const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+        if (storedApiKeyEntry?.key.startsWith("cashu") && latestBalanceInfo.apiKey) {
+          this.storageAdapter.removeApiKey(baseUrl);
+          this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
+        }
+        if (latestTokenBalance !== void 0) {
+          this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
+        }
+        satsSpent = latestTokenBalance !== void 0 && !initialTokenBalanceUnknown ? Math.max(0, initialTokenBalance - latestTokenBalance) : fallbackSatsSpent ?? usage?.satsCost ?? 0;
       } catch (e) {
-        this._log(
-          "WARN",
-          "Could not get current token balance for topup calculation:",
-          e
-        );
+        this._log("WARN", "Could not get updated API key balance:", e);
+        satsSpent = fallbackSatsSpent ?? usage?.satsCost ?? 0;
       }
-      const topupResult = await this.balanceManager.topUp({
-        mintUrl,
-        baseUrl,
-        amount: topupAmount * TOPUP_MARGIN,
-        token: params.token
-      });
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Topup result for ${baseUrl}: success=${topupResult.success}, message=${topupResult.message}`
-      );
-      if (!topupResult.success) {
-        const message = topupResult.message || "";
-        if (message.includes("Insufficient balance")) {
-          const needMatch = message.match(/need (\d+)/);
-          const haveMatch = message.match(/have (\d+)/);
-          const required = needMatch ? parseInt(needMatch[1], 10) : params.requiredSats;
-          const available = haveMatch ? parseInt(haveMatch[1], 10) : 0;
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
-          );
-          throw new InsufficientBalanceError(
-            required,
-            available,
-            0,
-            "",
-            message
-          );
+    }
+    await this._trackResponseUsage({
+      token,
+      baseUrl,
+      response,
+      modelId,
+      satsSpent,
+      usage,
+      requestId,
+      clientApiKey
+    });
+    (async () => {
+    })();
+    return satsSpent;
+  }
+  async _trackResponseUsage(params) {
+    const {
+      token,
+      baseUrl,
+      response,
+      modelId,
+      satsSpent,
+      usage: providedUsage,
+      requestId: providedRequestId,
+      clientApiKey
+    } = params;
+    if (!response || !modelId) {
+      return;
+    }
+    try {
+      let usage = providedUsage;
+      let requestId = providedRequestId;
+      if (!usage || !requestId) {
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("text/event-stream")) {
+          usage = usage ?? response.usage;
+          requestId = requestId ?? response.requestId ?? response.headers.get("x-routstr-request-id") ?? void 0;
+          if (!usage) {
+            return;
+          }
         } else {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Topup failed with non-insufficient-balance error, will try next provider`
-          );
-          tryNextProvider = true;
+          const cloned = response.clone();
+          const responseBody = await cloned.json();
+          usage = usage ?? extractUsageFromResponseBody(responseBody, satsSpent) ?? void 0;
+          requestId = requestId ?? extractResponseId(responseBody) ?? response.headers.get("x-routstr-request-id") ?? void 0;
         }
-      } else {
+      }
+      if (!usage) {
+        return;
+      }
+      const finalRequestId = requestId || "unknown";
+      const store = this.sdkStore ?? await getDefaultSdkStore();
+      const state = store.getState();
+      const matchKey = clientApiKey ?? token;
+      const matchingClient = state.clientIds.find(
+        (client) => client.apiKey === matchKey
+      );
+      const entryId = finalRequestId === "unknown" ? `req-${Date.now()}-${modelId}` : finalRequestId;
+      const usageTracking = this.usageTrackingDriver ?? getDefaultUsageTrackingDriver();
+      const entry = {
+        id: entryId,
+        timestamp: Date.now(),
+        modelId,
+        baseUrl,
+        requestId: finalRequestId,
+        client: matchingClient?.clientId,
+        ...usage
+      };
+      if (this.mode === "xcashu") {
+        entry.satsCost = satsSpent;
+      }
+      await usageTracking.append(entry);
+    } catch (error) {
+    }
+  }
+  /**
+   * Check wallet balance and throw if insufficient
+   */
+  async _checkBalance() {
+    const balances = await this.walletAdapter.getBalances();
+    const totalBalance = Object.values(balances).reduce((sum, v) => sum + v, 0);
+    if (totalBalance <= 0) {
+      throw new InsufficientBalanceError(1, 0);
+    }
+  }
+  /**
+   * Spend a token using CashuSpender with standardized error handling
+   */
+  async _spendToken(params) {
+    const { mintUrl, amount, baseUrl } = params;
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _spendToken: mode=${this.mode}, amount=${amount}, baseUrl=${baseUrl}, mintUrl=${mintUrl}`
+    );
+    if (this.mode === "apikeys") {
+      let parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+      if (!parentApiKey) {
         this._log(
           "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Topup successful, will retry with new token`
+          `[RoutstrClient] _spendToken: No existing API key for ${baseUrl}, creating new one via Cashu`
         );
-      }
-      if (!tryNextProvider) {
-        if (retryCount < MAX_RETRIES_PER_PROVIDER) {
+        const spendResult2 = await this.cashuSpender.spend({
+          mintUrl,
+          amount: amount * TOPUP_MARGIN,
+          baseUrl: "",
+          reuseToken: false
+        });
+        if (!spendResult2.token) {
           this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Retrying 402 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
+            "ERROR",
+            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error:`,
+            spendResult2.error
+          );
+          throw new Error(
+            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error: ${spendResult2.error}`
           );
-          return this._makeRequest({
-            ...params,
-            token: params.token,
-            headers: this._withAuthHeader(params.baseHeaders, params.token),
-            retryCount: retryCount + 1
-          });
         } else {
           this._log(
             "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: 402 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
+            `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult2.token}`
           );
-          tryNextProvider = true;
         }
-      }
-    }
-    const isInsufficientBalance413 = status === 413 && responseBody?.includes("Insufficient balance");
-    if (isInsufficientBalance413 && !tryNextProvider && this.mode === "apikeys") {
-      let retryToken = params.token;
-      try {
-        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-          params.token,
-          baseUrl
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _spendToken: Created API key for ${baseUrl}, key preview: ${spendResult2.token}, balance: ${spendResult2.balance}`
         );
-        if (latestBalanceInfo.isInvalidApiKey) {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Invalid API key (proofs already spent), removing for ${baseUrl}`
-          );
-          this.storageAdapter.removeApiKey(baseUrl);
-          tryNextProvider = true;
-        } else {
-          const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
-          if (latestBalanceInfo.apiKey) {
-            const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
-            if (storedApiKeyEntry?.key !== latestBalanceInfo.apiKey) {
-              if (storedApiKeyEntry) {
-                this.storageAdapter.removeApiKey(baseUrl);
-              }
-              this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
+        try {
+          this.storageAdapter.setApiKey(baseUrl, spendResult2.token);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("ApiKey already exists")) {
+            const receiveResult = await this.cashuSpender.receiveToken(
+              spendResult2.token
+            );
+            if (receiveResult.success) {
+              this._log(
+                "DEBUG",
+                `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${receiveResult.amount}`
+              );
+            } else {
+              this._log(
+                "DEBUG",
+                `[RoutstrClient] _handleErrorResponse: Token restore failed: ${receiveResult.message}`
+              );
             }
-            retryToken = latestBalanceInfo.apiKey;
-          }
-          if (latestTokenBalance >= 0) {
-            this.storageAdapter.updateApiKeyBalance(
-              baseUrl,
-              latestTokenBalance
+            this._log(
+              "DEBUG",
+              `[RoutstrClient] _spendToken: API key already exists for ${baseUrl}, using existing key`
             );
+          } else {
+            throw error;
           }
         }
-      } catch (error) {
-        this._log(
-          "WARN",
-          `[RoutstrClient] _handleErrorResponse: Failed to refresh API key after 413 insufficient balance for ${baseUrl}`,
-          error
-        );
-      }
-      if (retryCount < MAX_RETRIES_PER_PROVIDER) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Retrying 413 (attempt ${retryCount + 1}/${MAX_RETRIES_PER_PROVIDER})`
-        );
-        return this._makeRequest({
-          ...params,
-          token: retryToken,
-          headers: this._withAuthHeader(params.baseHeaders, retryToken),
-          retryCount: retryCount + 1
-        });
+        parentApiKey = this.storageAdapter.getApiKey(baseUrl);
       } else {
         this._log(
           "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: 413 retry limit reached (${retryCount}/${MAX_RETRIES_PER_PROVIDER}), failing over to next provider`
+          `[RoutstrClient] _spendToken: Using existing API key for ${baseUrl}, key preview: ${parentApiKey.key}`
         );
-        tryNextProvider = true;
       }
-    }
-    if (status === 401 && this.mode === "apikeys") {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Checking balance for ${baseUrl}, key preview=${token}`
-      );
-      const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-        token,
-        baseUrl
+      let tokenBalance = 0;
+      let tokenBalanceUnit = "sat";
+      let tokenBalanceUnknown = false;
+      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+      const distributionForBaseUrl = apiKeyDistribution.find(
+        (d) => d.baseUrl === baseUrl
       );
-      if (latestBalanceInfo.isInvalidApiKey) {
-        this.storageAdapter.removeApiKey(baseUrl);
-        tryNextProvider = true;
+      if (distributionForBaseUrl) {
+        tokenBalance = distributionForBaseUrl.amount;
       }
-    }
-    if ((status === 401 || status === 403 || status === 404 || status === 413 || status === 400 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Status ${status} (${status === 429 ? "rate limited" : "auth/server error"}), attempting refund for ${baseUrl}, mode=${this.mode}`
-      );
-      if (this.mode === "apikeys") {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`
-        );
-        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-          token,
-          baseUrl
-        );
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${latestBalanceInfo.amount}`
-        );
-        const refundResult = await this.balanceManager.refundApiKey({
-          mintUrl,
-          baseUrl,
-          apiKey: token,
-          forceRefund: true
-        });
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
-        );
-        if (!refundResult.success && latestBalanceInfo.amount > 0) {
-          throw new ProviderError(
-            baseUrl,
-            status,
-            refundResult.message ?? "Unknown error"
+      if (tokenBalance === 0 && parentApiKey) {
+        try {
+          const balanceInfo = await this.balanceManager.getTokenBalance(
+            parentApiKey.key,
+            baseUrl
           );
+          tokenBalance = balanceInfo.amount;
+          tokenBalanceUnit = balanceInfo.unit;
+          tokenBalanceUnknown = Boolean(balanceInfo.balanceUnknown);
+        } catch (e) {
+          this._log("WARN", "Could not get initial API key balance:", e);
         }
       }
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _spendToken: Returning token with balance=${tokenBalance} ${tokenBalanceUnit}`
+      );
+      return {
+        token: parentApiKey?.key ?? "",
+        tokenBalance,
+        tokenBalanceUnit,
+        tokenBalanceUnknown
+      };
     }
-    this.providerManager.markFailed(baseUrl);
     this._log(
       "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: Marked provider ${baseUrl} as failed`
-    );
-    if (!selectedModel) {
-      throw new ProviderError(
-        baseUrl,
-        status,
-        "Funny, no selected model. HMM. "
-      );
-    }
-    const nextProvider = this.providerManager.findNextBestProvider(
-      selectedModel.id,
-      baseUrl
+      `[RoutstrClient] _spendToken: Calling CashuSpender.spend for amount=${amount}, mintUrl=${mintUrl}, mode=${this.mode}`
     );
-    if (nextProvider) {
+    const spendResult = await this.cashuSpender.spend({
+      mintUrl,
+      amount,
+      baseUrl: "",
+      reuseToken: false
+    });
+    if (!spendResult.token) {
       this._log(
-        "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Failing over to next provider: ${nextProvider}, model: ${selectedModel.id}`
-      );
-      const newModel = await this.providerManager.getModelForProvider(
-        nextProvider,
-        selectedModel.id
-      ) ?? selectedModel;
-      const messagesForPricing = Array.isArray(
-        body?.messages
-      ) ? body.messages : [];
-      const newRequiredSats = this.providerManager.getRequiredSatsForModel(
-        newModel,
-        messagesForPricing,
-        params.maxTokens
+        "ERROR",
+        `[RoutstrClient] _spendToken: CashuSpender.spend failed, error:`,
+        spendResult.error
       );
+    } else {
       this._log(
         "DEBUG",
-        `[RoutstrClient] _handleErrorResponse: Creating new token for failover provider ${nextProvider}, required sats: ${newRequiredSats}`
+        `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult.token}, balance: ${spendResult.balance} ${spendResult.unit ?? "sat"}`
       );
-      const spendResult = await this._spendToken({
-        mintUrl,
-        amount: newRequiredSats,
-        baseUrl: nextProvider
-      });
-      return this._makeRequest({
-        ...params,
-        path,
-        method,
-        body,
-        baseUrl: nextProvider,
-        selectedModel: newModel,
-        token: spendResult.token,
-        requiredSats: newRequiredSats,
-        headers: this._withAuthHeader(params.baseHeaders, spendResult.token),
-        retryCount: 0
-      });
+      this.storageAdapter.addXcashuToken(baseUrl, spendResult.token);
     }
-    throw new FailoverError(
-      baseUrl,
-      Array.from(this.providerManager.getFailedProviders())
-    );
+    return {
+      token: spendResult.token,
+      tokenBalance: spendResult.balance,
+      tokenBalanceUnit: spendResult.unit ?? "sat",
+      tokenBalanceUnknown: false
+    };
+  }
+  /**
+   * Build request headers with common defaults and dev mock controls
+   */
+  _buildBaseHeaders(additionalHeaders = {}, token) {
+    const headers = {
+      ...additionalHeaders,
+      "Content-Type": "application/json"
+    };
+    return headers;
+  }
+  /**
+   * Attach auth headers using the active client mode
+   */
+  _withAuthHeader(headers, token) {
+    const nextHeaders = { ...headers };
+    if (this.mode === "xcashu") {
+      nextHeaders["X-Cashu"] = token;
+    } else {
+      nextHeaders["Authorization"] = `Bearer ${token}`;
+    }
+    return nextHeaders;
   }
+};
+
+// client/StreamProcessor.ts
+var StreamProcessor = class {
+  accumulatedContent = "";
+  accumulatedThinking = "";
+  accumulatedImages = [];
+  isInThinking = false;
+  isInContent = false;
   /**
-   * Handle post-response balance update for all modes
+   * Process a streaming response
    */
-  async _handlePostResponseBalanceUpdate(params) {
-    const {
-      token,
-      baseUrl,
-      mintUrl,
-      initialTokenBalance,
-      fallbackSatsSpent,
-      response,
-      modelId,
-      usage,
-      requestId,
-      clientApiKey
-    } = params;
-    let satsSpent = initialTokenBalance;
-    if (this.mode === "xcashu" && response) {
-      const refundToken = response.headers.get("x-cashu") ?? void 0;
-      if (refundToken) {
-        const receiveResult = await this.cashuSpender.receiveToken(refundToken);
-        if (receiveResult.success) {
-          this.storageAdapter.removeXcashuToken(baseUrl, token);
-          satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
-        } else {
-          this._log(
-            "ERROR",
-            `[xcashu] Failed to receive refund token: ${receiveResult.message}`
-          );
+  async process(response, callbacks, modelId) {
+    if (!response.body) {
+      throw new Error("Response body is not available");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    this.accumulatedContent = "";
+    this.accumulatedThinking = "";
+    this.accumulatedImages = [];
+    this.isInThinking = false;
+    this.isInContent = false;
+    let usage;
+    let model;
+    let finish_reason;
+    let citations;
+    let annotations;
+    let responseId;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
         }
-      }
-    } else if (this.mode === "apikeys") {
-      try {
-        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-          token,
-          baseUrl
-        );
-        this._log(
-          "DEBUG",
-          "LATEST Balance",
-          latestBalanceInfo.amount,
-          latestBalanceInfo.reserved,
-          latestBalanceInfo.apiKey,
-          baseUrl
-        );
-        const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
-        const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
-        if (storedApiKeyEntry?.key.startsWith("cashu") && latestBalanceInfo.apiKey) {
-          this.storageAdapter.removeApiKey(baseUrl);
-          this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
+        const chunk = decoder.decode(value, { stream: true });
+        buffer += chunk;
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const parsed = this._parseLine(line);
+          if (!parsed) continue;
+          if (parsed.content) {
+            this._handleContent(parsed.content, callbacks, modelId);
+          }
+          if (parsed.reasoning) {
+            this._handleThinking(parsed.reasoning, callbacks);
+          }
+          if (parsed.usage) {
+            usage = parsed.usage;
+          }
+          if (parsed.model) {
+            model = parsed.model;
+          }
+          if (parsed.finish_reason) {
+            finish_reason = parsed.finish_reason;
+          }
+          if (parsed.responseId) {
+            responseId = parsed.responseId;
+          }
+          if (parsed.citations) {
+            citations = parsed.citations;
+          }
+          if (parsed.annotations) {
+            annotations = parsed.annotations;
+          }
+          if (parsed.images) {
+            this._mergeImages(parsed.images);
+          }
         }
-        this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
-        satsSpent = initialTokenBalance - latestTokenBalance;
-      } catch (e) {
-        this._log("WARN", "Could not get updated API key balance:", e);
-        satsSpent = fallbackSatsSpent ?? initialTokenBalance;
       }
+    } finally {
+      reader.releaseLock();
     }
-    await this._trackResponseUsage({
-      token,
-      baseUrl,
-      response,
-      modelId,
-      satsSpent,
+    return {
+      content: this.accumulatedContent,
+      thinking: this.accumulatedThinking || void 0,
+      images: this.accumulatedImages.length > 0 ? this.accumulatedImages : void 0,
       usage,
-      requestId,
-      clientApiKey
-    });
-    (async () => {
-    })();
-    return satsSpent;
+      model,
+      responseId,
+      finish_reason,
+      citations,
+      annotations
+    };
   }
-  async _trackResponseUsage(params) {
-    const {
-      token,
-      baseUrl,
-      response,
-      modelId,
-      satsSpent,
-      usage: providedUsage,
-      requestId: providedRequestId,
-      clientApiKey
-    } = params;
-    if (!response || !modelId) {
-      return;
+  /**
+   * Parse a single SSE line
+   */
+  _parseLine(line) {
+    if (!line.trim()) return null;
+    if (!line.startsWith("data: ")) {
+      return null;
+    }
+    const jsonData = line.slice(6);
+    if (jsonData === "[DONE]") {
+      return null;
     }
     try {
-      let usage = providedUsage;
-      let requestId = providedRequestId;
-      if (!usage || !requestId) {
-        const contentType = response.headers.get("content-type") || "";
-        if (contentType.includes("text/event-stream")) {
-          usage = usage ?? response.usage;
-          requestId = requestId ?? response.requestId ?? response.headers.get("x-routstr-request-id") ?? void 0;
-          if (!usage) {
-            return;
-          }
-        } else {
-          const cloned = response.clone();
-          const responseBody = await cloned.json();
-          usage = usage ?? extractUsageFromResponseBody(responseBody, satsSpent) ?? void 0;
-          requestId = requestId ?? extractResponseId(responseBody) ?? response.headers.get("x-routstr-request-id") ?? void 0;
-        }
+      const parsed = JSON.parse(jsonData);
+      const result = {};
+      if (parsed.choices?.[0]?.delta?.content) {
+        result.content = parsed.choices[0].delta.content;
       }
-      if (!usage) {
-        return;
+      if (parsed.choices?.[0]?.delta?.reasoning) {
+        result.reasoning = parsed.choices[0].delta.reasoning;
       }
-      const finalRequestId = requestId || "unknown";
-      const store = this.sdkStore ?? await getDefaultSdkStore();
-      const state = store.getState();
-      const matchKey = clientApiKey ?? token;
-      const matchingClient = state.clientIds.find(
-        (client) => client.apiKey === matchKey
-      );
-      const entryId = finalRequestId === "unknown" ? `req-${Date.now()}-${modelId}` : finalRequestId;
-      const usageTracking = this.usageTrackingDriver ?? getDefaultUsageTrackingDriver();
-      const entry = {
-        id: entryId,
-        timestamp: Date.now(),
-        modelId,
-        baseUrl,
-        requestId: finalRequestId,
-        client: matchingClient?.clientId,
-        ...usage
-      };
-      if (this.mode === "xcashu") {
-        entry.satsCost = satsSpent;
+      const extractedUsage = extractUsageFromSSEJson(parsed);
+      if (extractedUsage) {
+        result.usage = toUsageStats(extractedUsage);
+      } else if (parsed.usage) {
+        result.usage = {
+          total_tokens: parsed.usage.total_tokens ?? parsed.usage.input_tokens + parsed.usage.output_tokens,
+          prompt_tokens: parsed.usage.prompt_tokens ?? parsed.usage.input_tokens,
+          completion_tokens: parsed.usage.completion_tokens ?? parsed.usage.output_tokens
+        };
       }
-      await usageTracking.append(entry);
-    } catch (error) {
+      if (parsed.id) {
+        result.responseId = parsed.id;
+      }
+      if (parsed.model) {
+        result.model = parsed.model;
+      }
+      if (parsed.citations) {
+        result.citations = parsed.citations;
+      }
+      if (parsed.annotations) {
+        result.annotations = parsed.annotations;
+      }
+      if (parsed.choices?.[0]?.finish_reason) {
+        result.finish_reason = parsed.choices[0].finish_reason;
+      }
+      const images = parsed.choices?.[0]?.message?.images || parsed.choices?.[0]?.delta?.images;
+      if (images && Array.isArray(images)) {
+        result.images = images;
+      }
+      return result;
+    } catch {
+      return null;
     }
   }
   /**
-   * Convert messages for API format
-   */
-  async _convertMessages(messages) {
-    return Promise.all(
-      messages.filter((m) => m.role !== "system").map(async (m) => ({
-        role: m.role,
-        content: typeof m.content === "string" ? m.content : m.content
-      }))
-    );
-  }
-  /**
-   * Create assistant message from streaming result
+   * Handle content delta with thinking support
    */
-  async _createAssistantMessage(result) {
-    if (result.images && result.images.length > 0) {
-      const content = [];
-      if (result.content) {
-        content.push({
-          type: "text",
-          text: result.content,
-          thinking: result.thinking,
-          citations: result.citations,
-          annotations: result.annotations
-        });
-      }
-      for (const img of result.images) {
-        content.push({
-          type: "image_url",
-          image_url: {
-            url: img.image_url.url
-          }
-        });
-      }
-      return {
-        role: "assistant",
-        content
-      };
+  _handleContent(content, callbacks, modelId) {
+    if (this.isInThinking && !this.isInContent) {
+      this.accumulatedThinking += "</thinking>";
+      callbacks.onThinking(this.accumulatedThinking);
+      this.isInThinking = false;
+      this.isInContent = true;
+    }
+    if (modelId) {
+      this._extractThinkingFromContent(content, callbacks);
+    } else {
+      this.accumulatedContent += content;
     }
-    return {
-      role: "assistant",
-      content: result.content || ""
-    };
+    callbacks.onContent(this.accumulatedContent);
   }
   /**
-   * Calculate estimated costs from usage
+   * Handle thinking/reasoning content
    */
-  _getEstimatedCosts(selectedModel, streamingResult) {
-    let estimatedCosts = 0;
-    if (streamingResult.usage) {
-      const { completion_tokens, prompt_tokens } = streamingResult.usage;
-      if (completion_tokens !== void 0 && prompt_tokens !== void 0) {
-        estimatedCosts = (selectedModel.sats_pricing?.completion ?? 0) * completion_tokens + (selectedModel.sats_pricing?.prompt ?? 0) * prompt_tokens;
-      }
+  _handleThinking(reasoning, callbacks) {
+    if (!this.isInThinking) {
+      this.accumulatedThinking += "<thinking> ";
+      this.isInThinking = true;
     }
-    return estimatedCosts;
+    this.accumulatedThinking += reasoning;
+    callbacks.onThinking(this.accumulatedThinking);
   }
   /**
-   * Get pending API key amount
+   * Extract thinking blocks from content (for models with inline thinking)
    */
-  _getPendingCashuTokenAmount() {
-    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-    return apiKeyDistribution.reduce((total, item) => total + item.amount, 0);
+  _extractThinkingFromContent(content, callbacks) {
+    const parts = content.split(/(<thinking>|<\/thinking>)/);
+    for (const part of parts) {
+      if (part === "<thinking>") {
+        this.isInThinking = true;
+        if (!this.accumulatedThinking.includes("<thinking>")) {
+          this.accumulatedThinking += "<thinking> ";
+        }
+      } else if (part === "</thinking>") {
+        this.isInThinking = false;
+        this.accumulatedThinking += "</thinking>";
+      } else if (this.isInThinking) {
+        this.accumulatedThinking += part;
+      } else {
+        this.accumulatedContent += part;
+      }
+    }
   }
   /**
-   * Handle errors and notify callbacks
+   * Merge images into accumulated array, avoiding duplicates
    */
-  _handleError(error, callbacks) {
-    this._log("ERROR", "[RoutstrClient] _handleError: Error occurred", error);
-    if (error instanceof Error) {
-      const isStreamError = error.message.includes("Error in input stream") || error.message.includes("Load failed");
-      const modifiedErrorMsg = isStreamError ? "AI stream was cut off, turn on Keep Active or please try again" : error.message;
-      this._log(
-        "ERROR",
-        `[RoutstrClient] _handleError: Error type=${error.constructor.name}, message=${modifiedErrorMsg}, isStreamError=${isStreamError}`
-      );
+  _mergeImages(newImages) {
+    for (const img of newImages) {
+      const newUrl = img.image_url?.url;
+      const existingIndex = this.accumulatedImages.findIndex((existing) => {
+        const existingUrl = existing.image_url?.url;
+        if (newUrl && existingUrl) {
+          return existingUrl === newUrl;
+        }
+        if (img.index !== void 0 && existing.index !== void 0) {
+          return existing.index === img.index;
+        }
+        return false;
+      });
+      if (existingIndex === -1) {
+        this.accumulatedImages.push(img);
+      } else {
+        this.accumulatedImages[existingIndex] = img;
+      }
+    }
+  }
+};
+
+// client/fetchAIResponse.ts
+async function fetchAIResponse(options, callbacks, deps) {
+  const {
+    messageHistory,
+    selectedModel,
+    baseUrl,
+    mintUrl,
+    maxTokens,
+    headers
+  } = options;
+  try {
+    const apiMessages = await convertMessages(messageHistory);
+    callbacks.onPaymentProcessing?.(true);
+    callbacks.onTokenCreated?.(deps.getPendingCashuTokenAmount?.() ?? 0);
+    const providerInfo = await deps.providerRegistry.getProviderInfo(baseUrl);
+    const providerVersion = providerInfo?.version ?? "";
+    let modelIdForRequest = selectedModel.id;
+    if (/^0\.1\./.test(providerVersion)) {
+      const newModel = await deps.client.getProviderManager().getModelForProvider(baseUrl, selectedModel.id);
+      modelIdForRequest = newModel?.id ?? selectedModel.id;
+    }
+    const body = {
+      model: modelIdForRequest,
+      messages: apiMessages,
+      stream: true
+    };
+    if (maxTokens !== void 0) {
+      body.max_tokens = maxTokens;
+    }
+    if (selectedModel?.name?.startsWith("OpenAI:")) {
+      body.tools = [{ type: "web_search" }];
+    }
+    const response = await deps.client.routeRequest({
+      path: "/v1/chat/completions",
+      method: "POST",
+      body,
+      headers,
+      baseUrl,
+      mintUrl,
+      modelId: selectedModel.id
+    });
+    if (!response.body) {
+      throw new Error("Response body is not available");
+    }
+    if (response.status !== 200) {
+      throw new Error(`${response.status} ${response.statusText}`);
+    }
+    const streamProcessor = new StreamProcessor();
+    const streamingResult = await streamProcessor.process(
+      response,
+      {
+        onContent: callbacks.onStreamingUpdate,
+        onThinking: callbacks.onThinkingUpdate
+      },
+      selectedModel.id
+    );
+    if (streamingResult.finish_reason === "content_filter") {
       callbacks.onMessageAppend({
-        role: "system",
-        content: "Uncaught Error: " + modifiedErrorMsg + (this.alertLevel === "max" ? " | " + error.stack : "")
+        role: "assistant",
+        content: "Your request was denied due to content filtering."
       });
+    } else if (streamingResult.content || streamingResult.images && streamingResult.images.length > 0) {
+      const message = await createAssistantMessage(streamingResult);
+      callbacks.onMessageAppend(message);
     } else {
       callbacks.onMessageAppend({
         role: "system",
-        content: "Unknown Error: Please tag Routstr on Nostr and/or retry."
+        content: "The provider did not respond to this request."
       });
     }
+    callbacks.onStreamingUpdate("");
+    callbacks.onThinkingUpdate("");
+  } catch (error) {
+    handleError(error, callbacks, deps.alertLevel, deps.logger);
+  } finally {
+    callbacks.onPaymentProcessing?.(false);
   }
-  /**
-   * Check wallet balance and throw if insufficient
-   */
-  async _checkBalance() {
-    const balances = await this.walletAdapter.getBalances();
-    const totalBalance = Object.values(balances).reduce((sum, v) => sum + v, 0);
-    if (totalBalance <= 0) {
-      throw new InsufficientBalanceError(1, 0);
+}
+async function convertMessages(messages) {
+  return Promise.all(
+    messages.filter((m) => m.role !== "system").map(async (m) => ({
+      role: m.role,
+      content: typeof m.content === "string" ? m.content : m.content
+    }))
+  );
+}
+async function createAssistantMessage(result) {
+  if (result.images && result.images.length > 0) {
+    const content = [];
+    if (result.content) {
+      content.push({
+        type: "text",
+        text: result.content,
+        thinking: result.thinking,
+        citations: result.citations,
+        annotations: result.annotations
+      });
     }
-  }
-  /**
-   * Spend a token using CashuSpender with standardized error handling
-   */
-  async _spendToken(params) {
-    const { mintUrl, amount, baseUrl } = params;
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _spendToken: mode=${this.mode}, amount=${amount}, baseUrl=${baseUrl}, mintUrl=${mintUrl}`
-    );
-    if (this.mode === "apikeys") {
-      let parentApiKey = this.storageAdapter.getApiKey(baseUrl);
-      if (!parentApiKey) {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: No existing API key for ${baseUrl}, creating new one via Cashu`
-        );
-        const spendResult2 = await this.cashuSpender.spend({
-          mintUrl,
-          amount: amount * TOPUP_MARGIN,
-          baseUrl: "",
-          reuseToken: false
-        });
-        if (!spendResult2.token) {
-          this._log(
-            "ERROR",
-            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error:`,
-            spendResult2.error
-          );
-          throw new Error(
-            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error: ${spendResult2.error}`
-          );
-        } else {
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult2.token}`
-          );
-        }
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: Created API key for ${baseUrl}, key preview: ${spendResult2.token}, balance: ${spendResult2.balance}`
-        );
-        try {
-          this.storageAdapter.setApiKey(baseUrl, spendResult2.token);
-        } catch (error) {
-          if (error instanceof Error && error.message.includes("ApiKey already exists")) {
-            const receiveResult = await this.cashuSpender.receiveToken(
-              spendResult2.token
-            );
-            if (receiveResult.success) {
-              this._log(
-                "DEBUG",
-                `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${receiveResult.amount}`
-              );
-            } else {
-              this._log(
-                "DEBUG",
-                `[RoutstrClient] _handleErrorResponse: Token restore failed: ${receiveResult.message}`
-              );
-            }
-            this._log(
-              "DEBUG",
-              `[RoutstrClient] _spendToken: API key already exists for ${baseUrl}, using existing key`
-            );
-          } else {
-            throw error;
-          }
-        }
-        parentApiKey = this.storageAdapter.getApiKey(baseUrl);
-      } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: Using existing API key for ${baseUrl}, key preview: ${parentApiKey.key}`
-        );
-      }
-      let tokenBalance = 0;
-      let tokenBalanceUnit = "sat";
-      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-      const distributionForBaseUrl = apiKeyDistribution.find(
-        (d) => d.baseUrl === baseUrl
-      );
-      if (distributionForBaseUrl) {
-        tokenBalance = distributionForBaseUrl.amount;
-      }
-      if (tokenBalance === 0 && parentApiKey) {
-        try {
-          const balanceInfo = await this.balanceManager.getTokenBalance(
-            parentApiKey.key,
-            baseUrl
-          );
-          tokenBalance = balanceInfo.amount;
-          tokenBalanceUnit = balanceInfo.unit;
-        } catch (e) {
-          this._log("WARN", "Could not get initial API key balance:", e);
+    for (const img of result.images) {
+      content.push({
+        type: "image_url",
+        image_url: {
+          url: img.image_url.url
         }
-      }
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _spendToken: Returning token with balance=${tokenBalance} ${tokenBalanceUnit}`
-      );
-      return {
-        token: parentApiKey?.key ?? "",
-        tokenBalance,
-        tokenBalanceUnit
-      };
-    }
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _spendToken: Calling CashuSpender.spend for amount=${amount}, mintUrl=${mintUrl}, mode=${this.mode}`
-    );
-    const spendResult = await this.cashuSpender.spend({
-      mintUrl,
-      amount,
-      baseUrl: "",
-      reuseToken: false
-    });
-    if (!spendResult.token) {
-      this._log(
-        "ERROR",
-        `[RoutstrClient] _spendToken: CashuSpender.spend failed, error:`,
-        spendResult.error
-      );
-    } else {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult.token}, balance: ${spendResult.balance} ${spendResult.unit ?? "sat"}`
-      );
-      this.storageAdapter.addXcashuToken(baseUrl, spendResult.token);
+      });
     }
     return {
-      token: spendResult.token,
-      tokenBalance: spendResult.balance,
-      tokenBalanceUnit: spendResult.unit ?? "sat"
-    };
-  }
-  /**
-   * Build request headers with common defaults and dev mock controls
-   */
-  _buildBaseHeaders(additionalHeaders = {}, token) {
-    const headers = {
-      ...additionalHeaders,
-      "Content-Type": "application/json"
+      role: "assistant",
+      content
     };
-    return headers;
   }
-  /**
-   * Attach auth headers using the active client mode
-   */
-  _withAuthHeader(headers, token) {
-    const nextHeaders = { ...headers };
-    if (this.mode === "xcashu") {
-      nextHeaders["X-Cashu"] = token;
-    } else {
-      nextHeaders["Authorization"] = `Bearer ${token}`;
-    }
-    return nextHeaders;
+  return {
+    role: "assistant",
+    content: result.content || ""
+  };
+}
+function handleError(error, callbacks, alertLevel, logger) {
+  logger.error("[fetchAIResponse] Error occurred", error);
+  if (error instanceof Error) {
+    const isStreamError = error.message.includes("Error in input stream") || error.message.includes("Load failed");
+    const modifiedErrorMsg = isStreamError ? "AI stream was cut off, turn on Keep Active or please try again" : error.message;
+    logger.error(
+      `[fetchAIResponse] Error type=${error.constructor.name}, message=${modifiedErrorMsg}, isStreamError=${isStreamError}`
+    );
+    callbacks.onMessageAppend({
+      role: "system",
+      content: "Uncaught Error: " + modifiedErrorMsg + (alertLevel === "max" ? " | " + error.stack : "")
+    });
+  } else {
+    callbacks.onMessageAppend({
+      role: "system",
+      content: "Unknown Error: Please tag Routstr on Nostr and/or retry."
+    });
   }
-};
+}
 
 // routeRequests.ts
 async function resolveRouteRequestContext(options) {
@@ -6274,19 +6246,18 @@ exports.StreamProcessor = StreamProcessor;
 exports.StreamingError = StreamingError;
 exports.TokenOperationError = TokenOperationError;
 exports.consoleLogger = consoleLogger;
-exports.createBunSqliteDriver = createBunSqliteDriver;
-exports.createBunSqliteUsageTrackingDriver = createBunSqliteUsageTrackingDriver;
 exports.createDiscoveryAdapterFromStore = createDiscoveryAdapterFromStore;
 exports.createIndexedDBDriver = createIndexedDBDriver;
 exports.createIndexedDBUsageTrackingDriver = createIndexedDBUsageTrackingDriver;
 exports.createMemoryDriver = createMemoryDriver;
 exports.createMemoryUsageTrackingDriver = createMemoryUsageTrackingDriver;
+exports.createProviderRegistryFromDiscoveryAdapter = createProviderRegistryFromDiscoveryAdapter;
 exports.createProviderRegistryFromStore = createProviderRegistryFromStore;
 exports.createSSEParserTransform = createSSEParserTransform;
 exports.createSdkStore = createSdkStore;
-exports.createSqliteDriver = createSqliteDriver;
-exports.createSqliteUsageTrackingDriver = createSqliteUsageTrackingDriver;
+exports.createShardedDiscoveryAdapter = createShardedDiscoveryAdapter;
 exports.createStorageAdapterFromStore = createStorageAdapterFromStore;
+exports.fetchAIResponse = fetchAIResponse;
 exports.filterBaseUrlsForTor = filterBaseUrlsForTor;
 exports.getDefaultDiscoveryAdapter = getDefaultDiscoveryAdapter;
 exports.getDefaultProviderRegistry = getDefaultProviderRegistry;