@routstr/sdk 0.3.9 → 0.3.11

package/dist/client/index.mjs

@@ -1059,8 +1059,8 @@ var BalanceManager = class _BalanceManager {
     const refundableProviderBalance = Object.entries(
       balanceState.providerBalances
     ).filter(([providerBaseUrl]) => providerBaseUrl !== baseUrl).reduce((sum, [, value]) => sum + value, 0);
-    if (totalMintBalance + targetProviderBalance < adjustedAmount && totalMintBalance + targetProviderBalance + refundableProviderBalance >= adjustedAmount && retryCount < 2) {
-      await this._refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount);
+    if (totalMintBalance + targetProviderBalance < adjustedAmount && totalMintBalance + targetProviderBalance + refundableProviderBalance >= adjustedAmount && retryCount < 3) {
+      await this._refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount, adjustedAmount);
       return this.createProviderToken({
         ...options,
         retryCount: retryCount + 1
@@ -1199,33 +1199,47 @@ var BalanceManager = class _BalanceManager {
     }
     return candidates;
   }
-  async _refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount) {
+  async _refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount, requiredAmount) {
     const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
     const forceRefund = retryCount >= 2;
-    const apiKeysToRefund = apiKeyDistribution.filter(
-      (apiKey) => apiKey.baseUrl !== baseUrl && apiKey.amount > 0
-    );
-    const apiKeyRefundResults = await Promise.allSettled(
-      apiKeysToRefund.map(async (apiKeyEntry) => {
-        const fullApiKeyEntry = this.storageAdapter.getApiKey(
-          apiKeyEntry.baseUrl
-        );
-        if (!fullApiKeyEntry) {
-          return { baseUrl: apiKeyEntry.baseUrl, success: false };
-        }
-        const result = await this.refundApiKey({
+    const candidates = apiKeyDistribution.filter((apiKey) => apiKey.baseUrl !== baseUrl && apiKey.amount > 0).map((apiKey) => {
+      const full = this.storageAdapter.getApiKey(apiKey.baseUrl);
+      return {
+        baseUrl: apiKey.baseUrl,
+        amount: apiKey.amount,
+        lastUsed: full?.lastUsed ?? 0,
+        key: full?.key
+      };
+    }).filter((c) => c.key != null).sort((a, b) => a.lastUsed - b.lastUsed);
+    if (candidates.length === 0) return;
+    if (forceRefund) {
+      for (const candidate of candidates) {
+        await this.refundApiKey({
           mintUrl,
-          baseUrl: apiKeyEntry.baseUrl,
-          apiKey: fullApiKeyEntry.key,
-          forceRefund
+          baseUrl: candidate.baseUrl,
+          apiKey: candidate.key,
+          forceRefund: true
         });
-        return { baseUrl: apiKeyEntry.baseUrl, success: result.success };
-      })
-    );
-    for (const result of apiKeyRefundResults) {
-      if (result.status === "fulfilled" && result.value.success) {
-        this.storageAdapter.updateApiKeyBalance(result.value.baseUrl, 0);
+        const newState = await this.getBalanceState();
+        const newAvailable = (newState.mintBalances[mintUrl] || 0) + (newState.providerBalances[baseUrl] || 0);
+        if (newAvailable >= requiredAmount) {
+          this.logger.log(
+            `_refundOtherProvidersForTopUp: freed enough balance (${newAvailable} >= ${requiredAmount}), stopping early`
+          );
+          return;
+        }
       }
+    } else {
+      await Promise.allSettled(
+        candidates.map(
+          (candidate) => this.refundApiKey({
+            mintUrl,
+            baseUrl: candidate.baseUrl,
+            apiKey: candidate.key,
+            forceRefund: false
+          })
+        )
+      );
     }
   }
   /**
@@ -1404,690 +1418,371 @@ 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;
+// 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);
   }
-  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") {
+};
+
+// 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;
-  }
-  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) {
+  } catch {
     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;
+}
+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 (cost === 0) {
-    cost = parsed.metadata?.routstr?.cost?.total_usd ?? 0;
+  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);
+    }
   }
-  if (msats === 0) {
-    msats = parsed.metadata?.routstr?.cost?.total_msats ?? (typeof usage.cost_sats === "number" ? usage.cost_sats * 1e3 : 0);
+  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();
+    }
   }
-  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;
+  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}`);
   }
-  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
-  };
-}
-
-// client/StreamProcessor.ts
-var StreamProcessor = class {
-  accumulatedContent = "";
-  accumulatedThinking = "";
-  accumulatedImages = [];
-  isInThinking = false;
-  isInContent = false;
   /**
-   * Process a streaming response
+   * Get instance ID for debugging
    */
-  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);
+  getInstanceId() {
+    return this.instanceId;
+  }
+  /**
+   * Clean up expired cooldown entries
+   * Also removes the provider from failedProviders so it can be retried
+   */
+  cleanupExpiredCooldowns() {
+    const now = Date.now();
+    const before = this.providersOnCoolDown.length;
+    this.providersOnCoolDown = this.providersOnCoolDown.filter(
+      ([url, timestamp]) => {
+        const age = now - timestamp;
+        const isExpired = age >= _ProviderManager.COOLDOWN_DURATION_MS;
+        if (isExpired) {
+          this.logger.log(`Removing expired cooldown for ${url} (age: ${age}ms)`);
+          this.failedProviders.delete(url);
+          if (this.store) {
+            this.store.getState().removeFailedProvider(url);
           }
         }
+        return !isExpired;
       }
-    } finally {
-      reader.releaseLock();
+    );
+    const after = this.providersOnCoolDown.length;
+    if (before !== after) {
+      this.logger.log(`Cleaned up ${before - after} expired cooldown(s), ${after} remaining`);
     }
-    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
+   * Get the cooldown duration in milliseconds
    */
-  _parseLine(line) {
-    if (!line.trim()) return null;
-    if (!line.startsWith("data: ")) {
-      return null;
-    }
-    const jsonData = line.slice(6);
-    if (jsonData === "[DONE]") {
-      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;
-      }
-      return result;
-    } catch {
-      return null;
-    }
+  getCooldownDurationMs() {
+    return _ProviderManager.COOLDOWN_DURATION_MS;
   }
   /**
-   * Handle content delta with thinking support
+   * Check if a provider is currently on cooldown
    */
-  _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;
-    }
-    callbacks.onContent(this.accumulatedContent);
+  isOnCooldown(baseUrl) {
+    this.cleanupExpiredCooldowns();
+    const result = this.providersOnCoolDown.some(([url]) => url === baseUrl);
+    return result;
   }
   /**
-   * Handle thinking/reasoning content
+   * Get all providers currently on cooldown
    */
-  _handleThinking(reasoning, callbacks) {
-    if (!this.isInThinking) {
-      this.accumulatedThinking += "<thinking> ";
-      this.isInThinking = true;
+  getProvidersOnCooldown() {
+    this.cleanupExpiredCooldowns();
+    return [...this.providersOnCoolDown];
+  }
+  /**
+   * Reset the failed providers list
+   */
+  resetFailedProviders() {
+    this.failedProviders.clear();
+    if (this.store) {
+      this.store.getState().setFailedProviders([]);
     }
-    this.accumulatedThinking += reasoning;
-    callbacks.onThinking(this.accumulatedThinking);
   }
   /**
-   * Extract thinking blocks from content (for models with inline thinking)
+   * Get the last failed timestamp for a provider
    */
-  _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> ";
+  getLastFailed(baseUrl) {
+    return this.lastFailed.get(baseUrl);
+  }
+  /**
+   * Get all providers with their last failed timestamps
+   */
+  getAllLastFailed() {
+    return new Map(this.lastFailed);
+  }
+  /**
+   * Mark a provider as failed
+   * If a provider fails twice within 5 minutes, it's added to cooldown
+   */
+  markFailed(baseUrl) {
+    const now = Date.now();
+    const lastFailure = this.lastFailed.get(baseUrl);
+    this.logger.log(`markFailed: ${baseUrl} lastFailure=${lastFailure} now=${now}`);
+    if (lastFailure !== void 0) {
+      const timeSinceLastFailure = now - lastFailure;
+      this.logger.log(`markFailed: timeSinceLastFailure=${timeSinceLastFailure}ms withinCooldown=${timeSinceLastFailure < _ProviderManager.COOLDOWN_DURATION_MS}`);
+    }
+    this.lastFailed.set(baseUrl, now);
+    this.failedProviders.add(baseUrl);
+    if (this.store) {
+      this.store.getState().setLastFailedTimestamp(baseUrl, now);
+      this.store.getState().addFailedProvider(baseUrl);
+    }
+    this.logger.log(`markFailed: updated ${baseUrl} to ${now}, failedProviders=${this.failedProviders.size}`);
+    if (lastFailure !== void 0 && now - lastFailure < _ProviderManager.COOLDOWN_DURATION_MS) {
+      this.logger.log(`markFailed: second failure within cooldown window for ${baseUrl}`);
+      if (!this.isOnCooldown(baseUrl)) {
+        this.providersOnCoolDown.push([baseUrl, now]);
+        if (this.store) {
+          this.store.getState().addProviderOnCooldown(baseUrl, now);
         }
-      } else if (part === "</thinking>") {
-        this.isInThinking = false;
-        this.accumulatedThinking += "</thinking>";
-      } else if (this.isInThinking) {
-        this.accumulatedThinking += part;
+        this.logger.log(`markFailed: ${baseUrl} added to cooldown`);
       } else {
-        this.accumulatedContent += part;
+        this.logger.log(`markFailed: ${baseUrl} already on cooldown`);
+      }
+    } else {
+      if (lastFailure === void 0) {
+        this.logger.log(`markFailed: first failure for ${baseUrl}`);
+      } else {
+        this.logger.log(`markFailed: failure outside cooldown window for ${baseUrl} (${now - lastFailure}ms ago)`);
       }
     }
   }
   /**
-   * Merge images into accumulated array, avoiding duplicates
+   * Remove a provider from cooldown (e.g., after successful request)
    */
-  _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);
-  }
-};
-
-// 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);
+  removeFromCooldown(baseUrl) {
+    this.providersOnCoolDown = this.providersOnCoolDown.filter(
+      ([url]) => url !== baseUrl
+    );
+    if (this.store) {
+      this.store.getState().removeProviderFromCooldown(baseUrl);
     }
   }
-  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);
+  /**
+   * Clear all cooldown tracking
+   */
+  clearCooldowns() {
+    this.providersOnCoolDown = [];
+    if (this.store) {
+      this.store.getState().clearProvidersOnCooldown();
     }
   }
-  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();
+  /**
+   * Clear all failure tracking (lastFailed timestamps)
+   */
+  clearFailureHistory() {
+    this.lastFailed.clear();
+    if (this.store) {
+      this.store.getState().setLastFailed({});
     }
   }
-  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
+   * Check if a provider has failed
    */
-  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}`);
+  hasFailed(baseUrl) {
+    return this.failedProviders.has(baseUrl);
   }
   /**
-   * Get instance ID for debugging
+   * Get a copy of the failed providers set
    */
-  getInstanceId() {
-    return this.instanceId;
+  getFailedProviders() {
+    return new Set(this.failedProviders);
   }
   /**
-   * Clean up expired cooldown entries
-   * Also removes the provider from failedProviders so it can be retried
+   * Find the next best provider for a model
+   * @param modelId The model ID to find a provider for
+   * @param currentBaseUrl The current provider to exclude
+   * @returns The best provider URL or null if none available
    */
-  cleanupExpiredCooldowns() {
-    const now = Date.now();
-    const before = this.providersOnCoolDown.length;
-    this.providersOnCoolDown = this.providersOnCoolDown.filter(
-      ([url, timestamp]) => {
-        const age = now - timestamp;
-        const isExpired = age >= _ProviderManager.COOLDOWN_DURATION_MS;
-        if (isExpired) {
-          this.logger.log(`Removing expired cooldown for ${url} (age: ${age}ms)`);
-          this.failedProviders.delete(url);
-          if (this.store) {
-            this.store.getState().removeFailedProvider(url);
-          }
+  findNextBestProvider(modelId, currentBaseUrl) {
+    try {
+      const torMode = isTorContext();
+      const disabledProviders = new Set(
+        this.providerRegistry.getDisabledProviders()
+      );
+      this.logger.log(`findNextBestProvider: model=${modelId} disabled=${[...disabledProviders].length} onCooldown=${this.providersOnCoolDown.length}`);
+      const allProviders = this.providerRegistry.getAllProvidersModels();
+      this.logger.log(`findNextBestProvider: total providers=${Object.keys(allProviders).length}`);
+      const candidates = [];
+      for (const [baseUrl, models] of Object.entries(allProviders)) {
+        if (baseUrl === currentBaseUrl) {
+          continue;
         }
-        return !isExpired;
+        if (disabledProviders.has(baseUrl)) {
+          continue;
+        }
+        if (this.isOnCooldown(baseUrl)) {
+          continue;
+        }
+        if (!torMode && isOnionUrl(baseUrl)) {
+          continue;
+        }
+        const model = models.find((m) => m.id === modelId);
+        if (!model) {
+          continue;
+        }
+        const cost = model.sats_pricing?.completion ?? 0;
+        candidates.push({ baseUrl, model, cost });
       }
-    );
-    const after = this.providersOnCoolDown.length;
-    if (before !== after) {
-      this.logger.log(`Cleaned up ${before - after} expired cooldown(s), ${after} remaining`);
+      candidates.sort((a, b) => a.cost - b.cost);
+      if (candidates.length > 0) {
+        return candidates[0].baseUrl;
+      } else {
+        return null;
+      }
+    } catch (error) {
+      this.logger.error("findNextBestProvider error:", error);
+      return null;
     }
   }
   /**
-   * Get the cooldown duration in milliseconds
+   * Find the best model for a provider
+   * Useful when switching providers and need to find equivalent model
    */
-  getCooldownDurationMs() {
-    return _ProviderManager.COOLDOWN_DURATION_MS;
+  async getModelForProvider(baseUrl, modelId) {
+    const models = this.providerRegistry.getModelsForProvider(baseUrl);
+    const exactMatch = models.find((m) => m.id === modelId);
+    if (exactMatch) return exactMatch;
+    const providerInfo = await this.providerRegistry.getProviderInfo(baseUrl);
+    if (providerInfo?.version && /^0\.1\./.test(providerInfo.version)) {
+      const suffix = modelId.split("/").pop();
+      const suffixMatch = models.find((m) => m.id === suffix);
+      if (suffixMatch) return suffixMatch;
+    }
+    return null;
   }
   /**
-   * Check if a provider is currently on cooldown
-   */
-  isOnCooldown(baseUrl) {
-    this.cleanupExpiredCooldowns();
-    const result = this.providersOnCoolDown.some(([url]) => url === baseUrl);
-    return result;
-  }
-  /**
-   * Get all providers currently on cooldown
-   */
-  getProvidersOnCooldown() {
-    this.cleanupExpiredCooldowns();
-    return [...this.providersOnCoolDown];
-  }
-  /**
-   * Reset the failed providers list
-   */
-  resetFailedProviders() {
-    this.failedProviders.clear();
-    if (this.store) {
-      this.store.getState().setFailedProviders([]);
-    }
-  }
-  /**
-   * Get the last failed timestamp for a provider
-   */
-  getLastFailed(baseUrl) {
-    return this.lastFailed.get(baseUrl);
-  }
-  /**
-   * Get all providers with their last failed timestamps
-   */
-  getAllLastFailed() {
-    return new Map(this.lastFailed);
-  }
-  /**
-   * Mark a provider as failed
-   * If a provider fails twice within 5 minutes, it's added to cooldown
-   */
-  markFailed(baseUrl) {
-    const now = Date.now();
-    const lastFailure = this.lastFailed.get(baseUrl);
-    this.logger.log(`markFailed: ${baseUrl} lastFailure=${lastFailure} now=${now}`);
-    if (lastFailure !== void 0) {
-      const timeSinceLastFailure = now - lastFailure;
-      this.logger.log(`markFailed: timeSinceLastFailure=${timeSinceLastFailure}ms withinCooldown=${timeSinceLastFailure < _ProviderManager.COOLDOWN_DURATION_MS}`);
-    }
-    this.lastFailed.set(baseUrl, now);
-    this.failedProviders.add(baseUrl);
-    if (this.store) {
-      this.store.getState().setLastFailedTimestamp(baseUrl, now);
-      this.store.getState().addFailedProvider(baseUrl);
-    }
-    this.logger.log(`markFailed: updated ${baseUrl} to ${now}, failedProviders=${this.failedProviders.size}`);
-    if (lastFailure !== void 0 && now - lastFailure < _ProviderManager.COOLDOWN_DURATION_MS) {
-      this.logger.log(`markFailed: second failure within cooldown window for ${baseUrl}`);
-      if (!this.isOnCooldown(baseUrl)) {
-        this.providersOnCoolDown.push([baseUrl, now]);
-        if (this.store) {
-          this.store.getState().addProviderOnCooldown(baseUrl, now);
-        }
-        this.logger.log(`markFailed: ${baseUrl} added to cooldown`);
-      } else {
-        this.logger.log(`markFailed: ${baseUrl} already on cooldown`);
-      }
-    } else {
-      if (lastFailure === void 0) {
-        this.logger.log(`markFailed: first failure for ${baseUrl}`);
-      } else {
-        this.logger.log(`markFailed: failure outside cooldown window for ${baseUrl} (${now - lastFailure}ms ago)`);
-      }
-    }
-  }
-  /**
-   * Remove a provider from cooldown (e.g., after successful request)
-   */
-  removeFromCooldown(baseUrl) {
-    this.providersOnCoolDown = this.providersOnCoolDown.filter(
-      ([url]) => url !== baseUrl
-    );
-    if (this.store) {
-      this.store.getState().removeProviderFromCooldown(baseUrl);
-    }
-  }
-  /**
-   * Clear all cooldown tracking
-   */
-  clearCooldowns() {
-    this.providersOnCoolDown = [];
-    if (this.store) {
-      this.store.getState().clearProvidersOnCooldown();
-    }
-  }
-  /**
-   * Clear all failure tracking (lastFailed timestamps)
-   */
-  clearFailureHistory() {
-    this.lastFailed.clear();
-    if (this.store) {
-      this.store.getState().setLastFailed({});
-    }
-  }
-  /**
-   * Check if a provider has failed
-   */
-  hasFailed(baseUrl) {
-    return this.failedProviders.has(baseUrl);
-  }
-  /**
-   * Get a copy of the failed providers set
-   */
-  getFailedProviders() {
-    return new Set(this.failedProviders);
-  }
-  /**
-   * Find the next best provider for a model
-   * @param modelId The model ID to find a provider for
-   * @param currentBaseUrl The current provider to exclude
-   * @returns The best provider URL or null if none available
-   */
-  findNextBestProvider(modelId, currentBaseUrl) {
-    try {
-      const torMode = isTorContext();
-      const disabledProviders = new Set(
-        this.providerRegistry.getDisabledProviders()
-      );
-      this.logger.log(`findNextBestProvider: model=${modelId} disabled=${[...disabledProviders].length} onCooldown=${this.providersOnCoolDown.length}`);
-      const allProviders = this.providerRegistry.getAllProvidersModels();
-      this.logger.log(`findNextBestProvider: total providers=${Object.keys(allProviders).length}`);
-      const candidates = [];
-      for (const [baseUrl, models] of Object.entries(allProviders)) {
-        if (baseUrl === currentBaseUrl) {
-          continue;
-        }
-        if (disabledProviders.has(baseUrl)) {
-          continue;
-        }
-        if (this.isOnCooldown(baseUrl)) {
-          continue;
-        }
-        if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl))) {
-          continue;
-        }
-        const model = models.find((m) => m.id === modelId);
-        if (!model) {
-          continue;
-        }
-        const cost = model.sats_pricing?.completion ?? 0;
-        candidates.push({ baseUrl, model, cost });
-      }
-      candidates.sort((a, b) => a.cost - b.cost);
-      if (candidates.length > 0) {
-        return candidates[0].baseUrl;
-      } else {
-        return null;
-      }
-    } catch (error) {
-      this.logger.error("findNextBestProvider error:", error);
-      return null;
-    }
-  }
-  /**
-   * Find the best model for a provider
-   * Useful when switching providers and need to find equivalent model
-   */
-  async getModelForProvider(baseUrl, modelId) {
-    const models = this.providerRegistry.getModelsForProvider(baseUrl);
-    const exactMatch = models.find((m) => m.id === modelId);
-    if (exactMatch) return exactMatch;
-    const providerInfo = await this.providerRegistry.getProviderInfo(baseUrl);
-    if (providerInfo?.version && /^0\.1\./.test(providerInfo.version)) {
-      const suffix = modelId.split("/").pop();
-      const suffixMatch = models.find((m) => m.id === suffix);
-      if (suffixMatch) return suffixMatch;
-    }
-    return null;
-  }
-  /**
-   * Get all available providers for a model
-   * Returns sorted list by price
+   * Get all available providers for a model
+   * Returns sorted list by price
    */
   getAllProvidersForModel(modelId) {
     const candidates = [];
@@ -2099,7 +1794,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;
@@ -2114,16 +1809,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;
@@ -2143,12 +1840,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
@@ -2336,92 +2041,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);
-      }
-    }
-  };
-};
-
 // storage/keys.ts
 var SDK_STORAGE_KEYS = {
   MODELS_FROM_ALL_PROVIDERS: "modelsFromAllProviders",
@@ -2445,6 +2064,91 @@ var SDK_STORAGE_KEYS = {
   PROVIDERS_ON_COOLDOWN: "providers_on_cooldown"
 };
 
+// storage/usageTracking/aggregate.ts
+var pad2 = (n) => String(n).padStart(2, "0");
+var jsGroupKey = (entry, groupBy, tzOffsetMinutes) => {
+  switch (groupBy) {
+    case "modelId":
+      return entry.modelId ?? null;
+    case "baseUrl":
+      return entry.baseUrl ?? null;
+    case "client":
+      return entry.client ?? null;
+    case "sessionId":
+      return entry.sessionId ?? null;
+    case "provider":
+      return entry.provider ?? null;
+    case "day": {
+      const d = new Date(entry.timestamp - tzOffsetMinutes * 6e4);
+      return `${d.getUTCFullYear()}-${pad2(d.getUTCMonth() + 1)}-${pad2(d.getUTCDate())}`;
+    }
+    case "hour": {
+      const d = new Date(entry.timestamp - tzOffsetMinutes * 6e4);
+      return pad2(d.getUTCHours());
+    }
+  }
+};
+var reduceAggregate = (entries, options = {}) => {
+  const emptyRow = (group) => ({
+    group,
+    requests: 0,
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+    cost: 0,
+    satsCost: 0,
+    baseMsats: 0,
+    inputMsats: 0,
+    outputMsats: 0,
+    totalMsats: 0,
+    totalUsd: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    cacheReadMsats: 0,
+    cacheCreationMsats: 0
+  });
+  const accumulate = (row, entry) => {
+    row.requests += 1;
+    row.promptTokens += entry.promptTokens;
+    row.completionTokens += entry.completionTokens;
+    row.totalTokens += entry.totalTokens;
+    row.cost += entry.cost;
+    row.satsCost += entry.satsCost;
+    row.baseMsats += entry.baseMsats ?? 0;
+    row.inputMsats += entry.inputMsats ?? 0;
+    row.outputMsats += entry.outputMsats ?? 0;
+    row.totalMsats += entry.totalMsats ?? 0;
+    row.totalUsd += entry.totalUsd ?? 0;
+    row.cacheReadInputTokens += entry.cacheReadInputTokens ?? 0;
+    row.cacheCreationInputTokens += entry.cacheCreationInputTokens ?? 0;
+    row.cacheReadMsats += entry.cacheReadMsats ?? 0;
+    row.cacheCreationMsats += entry.cacheCreationMsats ?? 0;
+  };
+  if (!options.groupBy) {
+    const total = emptyRow(null);
+    for (const entry of entries) accumulate(total, entry);
+    return [total];
+  }
+  const tz = options.tzOffsetMinutes ?? 0;
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = jsGroupKey(entry, options.groupBy, tz);
+    let row = groups.get(key);
+    if (!row) {
+      row = emptyRow(key);
+      groups.set(key, row);
+    }
+    accumulate(row, entry);
+  }
+  const rows = [...groups.values()];
+  if (options.groupBy === "day" || options.groupBy === "hour") {
+    rows.sort((a, b) => (a.group ?? "").localeCompare(b.group ?? ""));
+  } else {
+    rows.sort((a, b) => b.satsCost - a.satsCost);
+  }
+  return rows;
+};
+
 // storage/usageTracking/indexedDB.ts
 var DEFAULT_DB_NAME = "routstr-sdk";
 var DEFAULT_STORE_NAME = "usage_tracking";
@@ -2456,9 +2160,10 @@ 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, 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 });
@@ -2466,10 +2171,25 @@ var openDatabase = (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 = {}) => {
@@ -2491,6 +2211,12 @@ var matchesFilters = (entry, options = {}) => {
   if (options.client && entry.client !== options.client) {
     return false;
   }
+  if (options.clients && options.clients.length > 0 && (entry.client == null || !options.clients.includes(entry.client))) {
+    return false;
+  }
+  if (options.provider && entry.provider !== options.provider) {
+    return false;
+  }
   return true;
 };
 var createIndexedDBUsageTrackingDriver = (options = {}) => {
@@ -2586,6 +2312,10 @@ var createIndexedDBUsageTrackingDriver = (options = {}) => {
       const results = await this.list(options2);
       return results.length;
     },
+    async aggregate(options2 = {}) {
+      const entries = await this.list(options2);
+      return reduceAggregate(entries, options2);
+    },
     async deleteOlderThan(timestamp) {
       await ensureMigrated();
       const db = await getDb();
@@ -2622,410 +2352,31 @@ var createIndexedDBUsageTrackingDriver = (options = {}) => {
   };
 };
 
-// storage/usageTracking/sqlite.ts
-var MIGRATION_MARKER_KEY2 = "usage_tracking_migration_v1";
+// storage/usageTracking/memory.ts
 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 matchesFilters2 = (entry, options = {}) => {
+  if (typeof options.before === "number" && entry.timestamp >= options.before) {
+    return false;
   }
-};
-var buildWhereClause = (options = {}) => {
-  const clauses = [];
-  const params = [];
-  if (typeof options.before === "number") {
-    clauses.push("timestamp < ?");
-    params.push(options.before);
+  if (typeof options.after === "number" && entry.timestamp <= options.after) {
+    return false;
   }
-  if (typeof options.after === "number") {
-    clauses.push("timestamp > ?");
-    params.push(options.after);
+  if (options.modelId && entry.modelId !== options.modelId) {
+    return false;
   }
-  if (options.modelId) {
-    clauses.push("model_id = ?");
-    params.push(options.modelId);
+  if (options.baseUrl && normalizeBaseUrl2(entry.baseUrl) !== normalizeBaseUrl2(options.baseUrl)) {
+    return false;
   }
-  if (options.baseUrl) {
-    clauses.push("base_url = ?");
-    params.push(normalizeBaseUrl2(options.baseUrl));
-  }
-  if (options.sessionId) {
-    clauses.push("session_id = ?");
-    params.push(options.sessionId);
-  }
-  if (options.client) {
-    clauses.push("client = ?");
-    params.push(options.client);
-  }
-  return {
-    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    params
-  };
-};
-var createSqliteUsageTrackingDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "usage_tracking";
-  const legacyStorageDriver = options.legacyStorageDriver;
-  let db;
-  let insertStmt;
-  let migrationComplete = false;
-  const initDb = async () => {
-    if (!db) {
-      db = await loadDatabase2(dbPath);
-      db.exec(`
-        CREATE TABLE IF NOT EXISTS ${tableName} (
-          id TEXT PRIMARY KEY,
-          timestamp INTEGER NOT NULL,
-          model_id TEXT NOT NULL,
-          base_url TEXT NOT NULL,
-          request_id TEXT NOT NULL,
-          cost REAL NOT NULL,
-          sats_cost REAL NOT NULL,
-          prompt_tokens INTEGER NOT NULL,
-          completion_tokens INTEGER NOT NULL,
-          total_tokens INTEGER NOT NULL,
-          client TEXT,
-          session_id TEXT,
-          tags TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_session_id ON ${tableName}(session_id);
-        CREATE INDEX IF NOT EXISTS idx_${tableName}_client ON ${tableName}(client);
-      `);
-      insertStmt = db.prepare(`
-        INSERT OR REPLACE INTO ${tableName} (
-          id, timestamp, model_id, base_url, request_id,
-          cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
-          client, session_id, tags
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-    }
-  };
-  const ensureInit = async () => {
-    if (!db) {
-      await initDb();
-    }
-  };
-  const appendOne = (entry) => {
-    insertStmt.run(
-      entry.id,
-      entry.timestamp,
-      entry.modelId,
-      normalizeBaseUrl2(entry.baseUrl),
-      entry.requestId,
-      entry.cost,
-      entry.satsCost,
-      entry.promptTokens,
-      entry.completionTokens,
-      entry.totalTokens,
-      entry.client ?? null,
-      entry.sessionId ?? null,
-      JSON.stringify(entry.tags ?? [])
-    );
-  };
-  const ensureMigrated = async () => {
-    if (!legacyStorageDriver || migrationComplete) return;
-    const migrated = await legacyStorageDriver.getItem(
-      MIGRATION_MARKER_KEY2,
-      false
-    );
-    if (migrated) {
-      migrationComplete = true;
-      return;
-    }
-    const legacyEntries = await legacyStorageDriver.getItem(
-      SDK_STORAGE_KEYS.USAGE_TRACKING,
-      []
-    );
-    for (const entry of legacyEntries) {
-      appendOne(entry);
-    }
-    if (legacyEntries.length > 0) {
-      await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
-    }
-    await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY2, true);
-    migrationComplete = true;
-  };
-  const mapRow = (row) => ({
-    id: row.id,
-    timestamp: row.timestamp,
-    modelId: row.model_id,
-    baseUrl: row.base_url,
-    requestId: row.request_id,
-    cost: row.cost,
-    satsCost: row.sats_cost,
-    promptTokens: row.prompt_tokens,
-    completionTokens: row.completion_tokens,
-    totalTokens: row.total_tokens,
-    client: row.client ?? void 0,
-    sessionId: row.session_id ?? void 0,
-    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
-  });
-  return {
-    async migrate() {
-      await ensureInit();
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureInit();
-      await ensureMigrated();
-      appendOne(entry);
-    },
-    async appendMany(entries) {
-      await ensureInit();
-      await ensureMigrated();
-      for (const entry of entries) {
-        appendOne(entry);
-      }
-    },
-    async list(options2 = {}) {
-      await ensureInit();
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause(options2);
-      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
-      const stmt = db.prepare(
-        `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`
-      );
-      const rows = stmt.all(
-        ...typeof options2.limit === "number" ? [...params, options2.limit] : params
-      );
-      return rows.map(mapRow);
-    },
-    async count(options2 = {}) {
-      await ensureInit();
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause(options2);
-      const stmt = db.prepare(`SELECT COUNT(*) as count FROM ${tableName} ${sql}`);
-      const row = stmt.get(...params);
-      return Number(row?.count ?? 0);
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureInit();
-      await ensureMigrated();
-      const stmt = db.prepare(`DELETE FROM ${tableName} WHERE timestamp < ?`);
-      const result = stmt.run(timestamp);
-      return result.changes;
-    },
-    async clear() {
-      await ensureInit();
-      await ensureMigrated();
-      db.prepare(`DELETE FROM ${tableName}`).run();
-    }
-  };
-};
-
-// storage/usageTracking/bunSqlite.ts
-var MIGRATION_MARKER_KEY3 = "usage_tracking_migration_v1";
-var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var buildWhereClause2 = (options = {}) => {
-  const clauses = [];
-  const params = [];
-  if (typeof options.before === "number") {
-    clauses.push("timestamp < ?");
-    params.push(options.before);
-  }
-  if (typeof options.after === "number") {
-    clauses.push("timestamp > ?");
-    params.push(options.after);
-  }
-  if (options.modelId) {
-    clauses.push("model_id = ?");
-    params.push(options.modelId);
-  }
-  if (options.baseUrl) {
-    clauses.push("base_url = ?");
-    params.push(normalizeBaseUrl3(options.baseUrl));
-  }
-  if (options.sessionId) {
-    clauses.push("session_id = ?");
-    params.push(options.sessionId);
-  }
-  if (options.client) {
-    clauses.push("client = ?");
-    params.push(options.client);
-  }
-  return {
-    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
-    params
-  };
-};
-var createBunSqliteUsageTrackingDriver = (options = {}) => {
-  const dbPath = options.dbPath || "routstr.sqlite";
-  const tableName = options.tableName || "usage_tracking";
-  const legacyStorageDriver = options.legacyStorageDriver;
-  const SQLiteDatabase = options.sqlite?.Database;
-  let migrationPromise = null;
-  if (!SQLiteDatabase) {
-    throw new Error(
-      "Bun SQLite Database constructor is required. Pass { sqlite: { Database } } when creating the driver."
-    );
-  }
-  const db = new SQLiteDatabase(dbPath);
-  db.run(`
-    CREATE TABLE IF NOT EXISTS ${tableName} (
-      id TEXT PRIMARY KEY,
-      timestamp INTEGER NOT NULL,
-      model_id TEXT NOT NULL,
-      base_url TEXT NOT NULL,
-      request_id TEXT NOT NULL,
-      cost REAL NOT NULL,
-      sats_cost REAL NOT NULL,
-      prompt_tokens INTEGER NOT NULL,
-      completion_tokens INTEGER NOT NULL,
-      total_tokens INTEGER NOT NULL,
-      client TEXT,
-      session_id TEXT,
-      tags TEXT
-    )
-  `);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url)`);
-  const appendOne = (entry) => {
-    db.query(`
-      INSERT OR REPLACE INTO ${tableName} (
-        id, timestamp, model_id, base_url, request_id,
-        cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
-        client, session_id, tags
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      entry.id,
-      entry.timestamp,
-      entry.modelId,
-      normalizeBaseUrl3(entry.baseUrl),
-      entry.requestId,
-      entry.cost,
-      entry.satsCost,
-      entry.promptTokens,
-      entry.completionTokens,
-      entry.totalTokens,
-      entry.client ?? null,
-      entry.sessionId ?? null,
-      JSON.stringify(entry.tags ?? [])
-    );
-  };
-  const mapRow = (row) => ({
-    id: row.id,
-    timestamp: row.timestamp,
-    modelId: row.model_id,
-    baseUrl: row.base_url,
-    requestId: row.request_id,
-    cost: row.cost,
-    satsCost: row.sats_cost,
-    promptTokens: row.prompt_tokens,
-    completionTokens: row.completion_tokens,
-    totalTokens: row.total_tokens,
-    client: row.client ?? void 0,
-    sessionId: row.session_id ?? void 0,
-    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
-  });
-  const ensureMigrated = async () => {
-    if (!legacyStorageDriver) return;
-    if (!migrationPromise) {
-      migrationPromise = (async () => {
-        const migrated = await legacyStorageDriver.getItem(
-          MIGRATION_MARKER_KEY3,
-          false
-        );
-        if (migrated) return;
-        const legacyEntries = await legacyStorageDriver.getItem(
-          SDK_STORAGE_KEYS.USAGE_TRACKING,
-          []
-        );
-        if (legacyEntries.length > 0) {
-          for (const entry of legacyEntries) {
-            appendOne(entry);
-          }
-          await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
-        }
-        await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY3, true);
-      })();
-    }
-    await migrationPromise;
-  };
-  return {
-    async migrate() {
-      await ensureMigrated();
-    },
-    async append(entry) {
-      await ensureMigrated();
-      appendOne(entry);
-    },
-    async appendMany(entries) {
-      await ensureMigrated();
-      for (const entry of entries) {
-        appendOne(entry);
-      }
-    },
-    async list(options2 = {}) {
-      await ensureMigrated();
-      const { sql, params } = buildWhereClause2(options2);
-      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
-      const query = `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`;
-      let rows;
-      if (typeof options2.limit === "number") {
-        rows = db.query(query).all(...params, options2.limit);
-      } else {
-        rows = db.query(query).all(...params);
-      }
-      return rows.map(mapRow);
-    },
-    async count(options2 = {}) {
-      const { sql, params } = buildWhereClause2(options2);
-      const query = `SELECT COUNT(*) as count FROM ${tableName} ${sql}`;
-      const row = db.query(query).get(...params);
-      return Number(row?.count ?? 0);
-    },
-    async deleteOlderThan(timestamp) {
-      await ensureMigrated();
-      const before = timestamp;
-      const result = db.query(`DELETE FROM ${tableName} WHERE timestamp < ?`).run(before);
-      return result.changes ?? 0;
-    },
-    async clear() {
-      await ensureMigrated();
-      db.query(`DELETE FROM ${tableName}`).run();
-    }
-  };
-};
-
-// storage/usageTracking/memory.ts
-var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var matchesFilters2 = (entry, options = {}) => {
-  if (typeof options.before === "number" && entry.timestamp >= options.before) {
-    return false;
-  }
-  if (typeof options.after === "number" && entry.timestamp <= options.after) {
-    return false;
-  }
-  if (options.modelId && entry.modelId !== options.modelId) {
+  if (options.sessionId && entry.sessionId !== options.sessionId) {
     return false;
   }
-  if (options.baseUrl && normalizeBaseUrl4(entry.baseUrl) !== normalizeBaseUrl4(options.baseUrl)) {
+  if (options.client && entry.client !== options.client) {
     return false;
   }
-  if (options.sessionId && entry.sessionId !== options.sessionId) {
+  if (options.clients && options.clients.length > 0 && (entry.client == null || !options.clients.includes(entry.client))) {
     return false;
   }
-  if (options.client && entry.client !== options.client) {
+  if (options.provider && entry.provider !== options.provider) {
     return false;
   }
   return true;
@@ -3033,18 +2384,18 @@ var matchesFilters2 = (entry, options = {}) => {
 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 = {}) {
@@ -3057,6 +2408,10 @@ var createMemoryUsageTrackingDriver = (seed = []) => {
     async count(options = {}) {
       return (await this.list(options)).length;
     },
+    async aggregate(options = {}) {
+      const entries = [...store.values()].filter((entry) => matchesFilters2(entry, options));
+      return reduceAggregate(entries, options);
+    },
     async deleteOlderThan(timestamp) {
       let deleted = 0;
       for (const [id, entry] of store.entries()) {
@@ -3072,7 +2427,7 @@ var createMemoryUsageTrackingDriver = (seed = []) => {
     }
   };
 };
-var normalizeBaseUrl5 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 var createEmptyStore = (driver) => createStore((set, get) => ({
   modelsFromAllProviders: {},
   lastUsedModel: null,
@@ -3095,7 +2450,7 @@ var createEmptyStore = (driver) => 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,
@@ -3108,7 +2463,7 @@ var createEmptyStore = (driver) => 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 });
   },
@@ -3117,14 +2472,14 @@ var createEmptyStore = (driver) => 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
       );
     }
@@ -3137,7 +2492,7 @@ var createEmptyStore = (driver) => 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 });
@@ -3145,7 +2500,7 @@ var createEmptyStore = (driver) => 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 });
@@ -3155,7 +2510,7 @@ var createEmptyStore = (driver) => 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
       }));
@@ -3167,7 +2522,7 @@ var createEmptyStore = (driver) => 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,
@@ -3181,9 +2536,9 @@ var createEmptyStore = (driver) => 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
       }));
@@ -3234,12 +2589,12 @@ var createEmptyStore = (driver) => 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];
@@ -3248,7 +2603,7 @@ var createEmptyStore = (driver) => 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);
@@ -3257,13 +2612,13 @@ var createEmptyStore = (driver) => 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);
@@ -3271,14 +2626,14 @@ var createEmptyStore = (driver) => 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 }];
@@ -3287,7 +2642,7 @@ var createEmptyStore = (driver) => 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);
@@ -3358,40 +2713,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,
@@ -3400,9 +2755,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
@@ -3423,16 +2778,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({
@@ -3474,31 +2829,13 @@ var isBrowser2 = () => {
     return false;
   }
 };
-var isNode = () => {
-  try {
-    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
-  } catch {
-    return false;
-  }
-};
 var defaultDriver = null;
-var isBun3 = () => {
-  return typeof process.versions.bun !== "undefined";
-};
 var getDefaultSdkDriver = () => {
   if (defaultDriver) return defaultDriver;
   if (isBrowser2()) {
     defaultDriver = localStorageDriver;
     return defaultDriver;
   }
-  if (isBun3()) {
-    defaultDriver = createMemoryDriver();
-    return defaultDriver;
-  }
-  if (isNode()) {
-    defaultDriver = createSqliteDriver();
-    return defaultDriver;
-  }
   defaultDriver = createMemoryDriver();
   return defaultDriver;
 };
@@ -3519,49 +2856,209 @@ var getDefaultUsageTrackingDriver = () => {
     });
     return defaultUsageTrackingDriver;
   }
-  if (isBun3()) {
-    defaultUsageTrackingDriver = createBunSqliteUsageTrackingDriver();
-    return defaultUsageTrackingDriver;
-  }
-  if (isNode()) {
-    defaultUsageTrackingDriver = createSqliteUsageTrackingDriver({
-      legacyStorageDriver: storageDriver
-    });
-    return defaultUsageTrackingDriver;
-  }
   defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
   return defaultUsageTrackingDriver;
 };
+
+// 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
-  };
-}
-function hasUsageChanged(previous, next) {
+    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) {
+async function inspectSSEWebStream(stream, onUsage, onResponseId, options) {
   const reader = stream.getReader();
   const decoder = new TextDecoder("utf-8");
   let buffer = "";
   let capturedUsage = null;
   let capturedResponseId;
   let responseIdCaptured = false;
+  let rawChunkSequence = 0;
   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) {
@@ -3572,19 +3069,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) {
@@ -3613,7 +3112,9 @@ async function inspectSSEWebStream(stream, onUsage, onResponseId) {
       const { value, done } = await reader.read();
       if (done) break;
       if (value && value.byteLength > 0) {
-        buffer += decoder.decode(value, { stream: true });
+        const text = decoder.decode(value, { stream: true });
+        void options?.onRawChunk?.(value, rawChunkSequence++, text);
+        buffer += text;
         drainBufferedEvents();
       }
     }
@@ -3642,14 +3143,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) {
@@ -3659,19 +3168,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) {
@@ -3744,11 +3255,11 @@ var RoutstrClient = class {
       this.balanceManager,
       this.logger
     );
-    this.streamProcessor = new StreamProcessor();
     this.alertLevel = alertLevel;
     this.mode = mode;
     this.usageTrackingDriver = options.usageTrackingDriver;
     this.sdkStore = options.sdkStore;
+    this.requestResponseLogSink = options.requestResponseLogSink;
     this.providerManager = options.providerManager ?? new ProviderManager(providerRegistry, this.sdkStore, this.logger);
   }
   walletAdapter;
@@ -3756,7 +3267,6 @@ var RoutstrClient = class {
   providerRegistry;
   cashuSpender;
   balanceManager;
-  streamProcessor;
   providerManager;
   alertLevel;
   mode;
@@ -3764,6 +3274,7 @@ var RoutstrClient = class {
   usageTrackingDriver;
   sdkStore;
   logger;
+  requestResponseLogSink;
   /**
    * Get the current client mode
    */
@@ -3954,6 +3465,7 @@ var RoutstrClient = class {
     let usagePromise = Promise.resolve({});
     if (contentType.includes("text/event-stream") && response.body) {
       const [clientStream, inspectStream] = response.body.tee();
+      const requestResponseLogId = response.requestResponseLogId;
       processedResponse = new Response(clientStream, {
         status: response.status,
         statusText: response.statusText,
@@ -3961,6 +3473,7 @@ var RoutstrClient = class {
       });
       processedResponse.baseUrl = response.baseUrl;
       processedResponse.token = response.token;
+      processedResponse.requestResponseLogId = requestResponseLogId;
       usagePromise = inspectSSEWebStream(
         inspectStream,
         (usage) => {
@@ -3970,8 +3483,23 @@ var RoutstrClient = class {
         (responseId) => {
           capturedResponseId = responseId;
           processedResponse.requestId = responseId;
+        },
+        {
+          onRawChunk: (_chunk, sequence, text) => {
+            void this.requestResponseLogSink?.logResponseChunk?.(
+              requestResponseLogId,
+              sequence,
+              text
+            );
+          }
         }
-      );
+      ).then(async (result) => {
+        await this.requestResponseLogSink?.logResponseEnd?.(requestResponseLogId);
+        return result;
+      }).catch(async (error) => {
+        await this.requestResponseLogSink?.logResponseError?.(requestResponseLogId, error);
+        throw error;
+      });
       processedResponse.usagePromise = usagePromise;
     }
     return {
@@ -3998,153 +3526,6 @@ var RoutstrClient = class {
     }
     return void 0;
   }
-  /**
-   * Fetch AI response with streaming
-   */
-  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
-    );
-    try {
-      await this._checkBalance();
-      callbacks.onPaymentProcessing?.(true);
-      const spendResult = await this._spendToken({
-        mintUrl,
-        amount: requiredSats,
-        baseUrl
-      });
-      let token = spendResult.token;
-      let tokenBalance = spendResult.tokenBalance;
-      let tokenBalanceUnit = spendResult.tokenBalanceUnit;
-      let tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
-      let initialTokenBalanceUnknown = spendResult.tokenBalanceUnknown;
-      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
-        );
-        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 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 (response.status === 200) {
-        const baseUrlUsed = response.baseUrl || baseUrl;
-        const responseToken = response.token || token;
-        if (baseUrlUsed !== baseUrl || responseToken !== token) {
-          token = responseToken;
-          if (typeof response.initialTokenBalanceInSats === "number") {
-            tokenBalanceInSats = response.initialTokenBalanceInSats;
-            initialTokenBalanceUnknown = Boolean(
-              response.initialTokenBalanceUnknown
-            );
-          } else {
-            initialTokenBalanceUnknown = true;
-          }
-        }
-        const streamingResult = await this.streamProcessor.process(
-          response,
-          {
-            onContent: callbacks.onStreamingUpdate,
-            onThinking: callbacks.onThinkingUpdate
-          },
-          selectedModel.id
-        );
-        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);
-        } else {
-          callbacks.onMessageAppend({
-            role: "system",
-            content: "The provider did not respond to this request."
-          });
-        }
-        callbacks.onStreamingUpdate("");
-        callbacks.onThinkingUpdate("");
-        const isApikeysEstimate = this.mode === "apikeys";
-        let satsSpent = await this._handlePostResponseBalanceUpdate({
-          token,
-          baseUrl: baseUrlUsed,
-          mintUrl,
-          initialTokenBalance: tokenBalanceInSats,
-          initialTokenBalanceUnknown,
-          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
-        );
-        const onLastMessageSatsUpdate = callbacks.onLastMessageSatsUpdate;
-        onLastMessageSatsUpdate?.(satsSpent, estimatedCosts);
-      } else {
-        throw new Error(`${response.status} ${response.statusText}`);
-      }
-    } catch (error) {
-      this._handleError(error, callbacks);
-    } finally {
-      callbacks.onPaymentProcessing?.(false);
-    }
-  }
   /**
    * Make the API request with failover support
    */
@@ -4152,16 +3533,30 @@ var RoutstrClient = class {
     const { path, method, body, baseUrl, token, headers } = params;
     try {
       const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+      const requestBodyText = body === void 0 || method === "GET" ? void 0 : JSON.stringify(body);
+      const requestLogId = await this.requestResponseLogSink?.logRequest?.({
+        method,
+        url,
+        path,
+        baseUrl,
+        headers,
+        body,
+        rawBody: requestBodyText
+      });
       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)
+        body: requestBodyText
       });
       if (this.mode === "xcashu") this._log("DEBUG", "response,", response);
       response.baseUrl = baseUrl;
       response.token = token;
+      response.requestResponseLogId = requestLogId;
+      await this.requestResponseLogSink?.logResponseStart?.(requestLogId, response);
+      const contentType = response.headers.get("content-type") || "";
       if (!response.ok) {
+        void this.requestResponseLogSink?.logResponseBody?.(requestLogId, response.clone());
         const requestId = response.headers.get("x-routstr-request-id") || void 0;
         let bodyText;
         try {
@@ -4179,6 +3574,9 @@ var RoutstrClient = class {
           params.retryCount ?? 0
         );
       }
+      if (!contentType.includes("text/event-stream")) {
+        void this.requestResponseLogSink?.logResponseBody?.(requestLogId, response.clone());
+      }
       return response;
     } catch (error) {
       if (isNetworkErrorMessage(error?.message || "")) {
@@ -4669,264 +4067,520 @@ var RoutstrClient = class {
     }
   }
   /**
-   * Convert messages for API format
+   * Check wallet balance and throw if insufficient
    */
-  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
-      }))
-    );
+  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);
+    }
   }
   /**
-   * Create assistant message from streaming result
+   * Spend a token using CashuSpender with standardized error handling
    */
-  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
+  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
         });
-      }
-      for (const img of result.images) {
-        content.push({
-          type: "image_url",
-          image_url: {
-            url: img.image_url.url
+        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";
+      let tokenBalanceUnknown = false;
+      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;
+          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 {
-        role: "assistant",
-        content
+        token: parentApiKey?.key ?? "",
+        tokenBalance,
+        tokenBalanceUnit,
+        tokenBalanceUnknown
       };
     }
+    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 {
-      role: "assistant",
-      content: result.content || ""
+      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;
   }
   /**
-   * Calculate estimated costs from usage
+   * Attach auth headers using the active client mode
    */
-  _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;
+  _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;
+  /**
+   * 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 estimatedCosts;
+    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
+    };
   }
   /**
-   * Get pending API key amount
+   * Parse a single SSE line
    */
-  _getPendingCashuTokenAmount() {
-    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-    return apiKeyDistribution.reduce((total, item) => total + item.amount, 0);
+  _parseLine(line) {
+    if (!line.trim()) return null;
+    if (!line.startsWith("data: ")) {
+      return null;
+    }
+    const jsonData = line.slice(6);
+    if (jsonData === "[DONE]") {
+      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;
+      }
+      return result;
+    } catch {
+      return null;
+    }
   }
   /**
-   * Handle errors and notify callbacks
+   * Handle content delta with thinking support
    */
-  _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}`
-      );
-      callbacks.onMessageAppend({
-        role: "system",
-        content: "Uncaught Error: " + modifiedErrorMsg + (this.alertLevel === "max" ? " | " + error.stack : "")
-      });
+  _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 {
-      callbacks.onMessageAppend({
-        role: "system",
-        content: "Unknown Error: Please tag Routstr on Nostr and/or retry."
-      });
+      this.accumulatedContent += content;
     }
+    callbacks.onContent(this.accumulatedContent);
   }
   /**
-   * Check wallet balance and throw if insufficient
+   * Handle thinking/reasoning content
    */
-  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);
+  _handleThinking(reasoning, callbacks) {
+    if (!this.isInThinking) {
+      this.accumulatedThinking += "<thinking> ";
+      this.isInThinking = true;
     }
+    this.accumulatedThinking += reasoning;
+    callbacks.onThinking(this.accumulatedThinking);
   }
   /**
-   * Spend a token using CashuSpender with standardized error handling
+   * Extract thinking blocks from content (for models with inline thinking)
    */
-  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;
-          }
+  _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> ";
         }
-        parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+      } else if (part === "</thinking>") {
+        this.isInThinking = false;
+        this.accumulatedThinking += "</thinking>";
+      } else if (this.isInThinking) {
+        this.accumulatedThinking += part;
       } else {
-        this._log(
-          "DEBUG",
-          `[RoutstrClient] _spendToken: Using existing API key for ${baseUrl}, key preview: ${parentApiKey.key}`
-        );
-      }
-      let tokenBalance = 0;
-      let tokenBalanceUnit = "sat";
-      let tokenBalanceUnknown = false;
-      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-      const distributionForBaseUrl = apiKeyDistribution.find(
-        (d) => d.baseUrl === baseUrl
-      );
-      if (distributionForBaseUrl) {
-        tokenBalance = distributionForBaseUrl.amount;
+        this.accumulatedContent += part;
       }
-      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);
+    }
+  }
+  /**
+   * 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;
       }
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _spendToken: Returning token with balance=${tokenBalance} ${tokenBalanceUnit}`
-      );
-      return {
-        token: parentApiKey?.key ?? "",
-        tokenBalance,
-        tokenBalanceUnit,
-        tokenBalanceUnknown
-      };
     }
-    this._log(
-      "DEBUG",
-      `[RoutstrClient] _spendToken: Calling CashuSpender.spend for amount=${amount}, mintUrl=${mintUrl}, mode=${this.mode}`
-    );
-    const spendResult = await this.cashuSpender.spend({
+  }
+};
+
+// 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 body = {
+      model: selectedModel.id,
+      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,
-      amount,
-      baseUrl: "",
-      reuseToken: false
+      modelId: selectedModel.id
     });
-    if (!spendResult.token) {
-      this._log(
-        "ERROR",
-        `[RoutstrClient] _spendToken: CashuSpender.spend failed, error:`,
-        spendResult.error
-      );
+    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: "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 {
-      this._log(
-        "DEBUG",
-        `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult.token}, balance: ${spendResult.balance} ${spendResult.unit ?? "sat"}`
-      );
-      this.storageAdapter.addXcashuToken(baseUrl, spendResult.token);
+      callbacks.onMessageAppend({
+        role: "system",
+        content: "The provider did not respond to this request."
+      });
     }
-    return {
-      token: spendResult.token,
-      tokenBalance: spendResult.balance,
-      tokenBalanceUnit: spendResult.unit ?? "sat",
-      tokenBalanceUnknown: false
-    };
+    callbacks.onStreamingUpdate("");
+    callbacks.onThinkingUpdate("");
+  } catch (error) {
+    handleError(error, callbacks, deps.alertLevel, deps.logger);
+  } finally {
+    callbacks.onPaymentProcessing?.(false);
   }
-  /**
-   * Build request headers with common defaults and dev mock controls
-   */
-  _buildBaseHeaders(additionalHeaders = {}, token) {
-    const headers = {
-      ...additionalHeaders,
-      "Content-Type": "application/json"
+}
+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
+      });
+    }
+    for (const img of result.images) {
+      content.push({
+        type: "image_url",
+        image_url: {
+          url: img.image_url.url
+        }
+      });
+    }
+    return {
+      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."
+    });
   }
-};
+}
 
-export { ProviderManager, RoutstrClient, StreamProcessor, createSSEParserTransform, inspectSSEWebStream };
+export { ProviderManager, RoutstrClient, StreamProcessor, createSSEParserTransform, extractResponseId, extractUsageFromResponseBody, extractUsageFromSSEJson, fetchAIResponse, inspectSSEWebStream, toUsageStats };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map