routstrd 0.2.18 → 0.2.20

package/dist/daemon/index.js

@@ -32087,6 +32087,7 @@ __export(exports_dist, {
   setDefaultUsageTrackingDriver: () => setDefaultUsageTrackingDriver,
   routeRequests: () => routeRequests,
   normalizeProviderUrl: () => normalizeProviderUrl,
+  noopLogger: () => noopLogger,
   localStorageDriver: () => localStorageDriver,
   isTorContext: () => isTorContext,
   isOnionUrl: () => isOnionUrl,
@@ -32112,6 +32113,7 @@ __export(exports_dist, {
   createDiscoveryAdapterFromStore: () => createDiscoveryAdapterFromStore,
   createBunSqliteUsageTrackingDriver: () => createBunSqliteUsageTrackingDriver,
   createBunSqliteDriver: () => createBunSqliteDriver,
+  consoleLogger: () => consoleLogger,
   TokenOperationError: () => TokenOperationError,
   StreamingError: () => StreamingError,
   StreamProcessor: () => StreamProcessor,
@@ -32133,6 +32135,16 @@ __export(exports_dist, {
 });
 import { Transform } from "stream";
 import { StringDecoder } from "string_decoder";
+function makeConsoleLogger(prefix) {
+  const fmt = (args) => prefix ? [prefix, ...args] : args;
+  return {
+    log: (...args) => console.log(...fmt(args)),
+    warn: (...args) => console.warn(...fmt(args)),
+    error: (...args) => console.error(...fmt(args)),
+    debug: (...args) => console.log(...fmt(args)),
+    child: (p) => makeConsoleLogger(prefix ? `${prefix}:${p}` : p)
+  };
+}
 function isNetworkErrorMessage(message) {
   return message.includes("NetworkError when attempting to fetch resource") || message.includes("Failed to fetch") || message.includes("Load failed") || message.includes("ERR_TLS_CERT_ALTNAME_INVALID") || message.includes("ERR_TLS_CERT_NOT_YET_VALID") || message.includes("ERR_TLS_CERT_EXPIRED") || message.includes("UNABLE_TO_VERIFY_LEAF_SIGNATURE") || message.includes("SELF_SIGNED_CERT_IN_CHAIN");
 }
@@ -32357,7 +32369,8 @@ function calculateImageTokens(width, height, detail = "auto") {
 function isInsecureHttpUrl(url2) {
   return url2.startsWith("http://");
 }
-async function createBunSqliteDriver(dbPath) {
+async function createBunSqliteDriver(dbPath, options) {
+  const logger3 = (options?.logger ?? consoleLogger).child("BunSqliteDriver");
   const SQLite = (await import("bun:sqlite")).default;
   const db = new SQLite(dbPath);
   db.run(`
@@ -32381,7 +32394,7 @@ async function createBunSqliteDriver(dbPath) {
           throw parseError;
         }
       } catch (error) {
-        console.error(`SQLite getItem failed for key "${key}":`, error);
+        logger3.error(`getItem failed for key "${key}":`, error);
         return defaultValue;
       }
     },
@@ -32389,14 +32402,14 @@ async function createBunSqliteDriver(dbPath) {
       try {
         db.query("INSERT INTO sdk_storage (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, JSON.stringify(value));
       } catch (error) {
-        console.error(`SQLite setItem failed for key "${key}":`, error);
+        logger3.error(`setItem failed for key "${key}":`, error);
       }
     },
     async removeItem(key) {
       try {
         db.query("DELETE FROM sdk_storage WHERE key = ?").run(key);
       } catch (error) {
-        console.error(`SQLite removeItem failed for key "${key}":`, error);
+        logger3.error(`removeItem failed for key "${key}":`, error);
       }
     }
   };
@@ -32625,7 +32638,8 @@ async function resolveRouteRequestContext(options) {
     mode = "apikeys",
     usageTrackingDriver,
     sdkStore,
-    providerManager: providedProviderManager
+    providerManager: providedProviderManager,
+    logger: logger3
   } = options;
   let modelManager;
   let providers;
@@ -32637,7 +32651,8 @@ async function resolveRouteRequestContext(options) {
     }
   } else {
     modelManager = new ModelManager(discoveryAdapter, {
-      includeProviderUrls: forcedProvider ? [forcedProvider, ...includeProviderUrls] : includeProviderUrls
+      includeProviderUrls: forcedProvider ? [forcedProvider, ...includeProviderUrls] : includeProviderUrls,
+      logger: logger3
     });
     providers = await modelManager.bootstrapProviders(torMode);
     if (providers.length === 0) {
@@ -32645,7 +32660,7 @@ async function resolveRouteRequestContext(options) {
     }
     await modelManager.fetchModels(providers, forceRefresh);
   }
-  const providerManager = providedProviderManager ?? new ProviderManager(providerRegistry, sdkStore);
+  const providerManager = providedProviderManager ?? new ProviderManager(providerRegistry, sdkStore, logger3);
   let baseUrl;
   let selectedModel;
   if (forcedProvider) {
@@ -32680,7 +32695,7 @@ async function resolveRouteRequestContext(options) {
   if (!mintUrl) {
     throw new Error("No mint configured in wallet");
   }
-  const client2 = new RoutstrClient(walletAdapter, storageAdapter, providerRegistry, "min", mode, { usageTrackingDriver, sdkStore, providerManager });
+  const client2 = new RoutstrClient(walletAdapter, storageAdapter, providerRegistry, "min", mode, { usageTrackingDriver, sdkStore, providerManager, logger: logger3 });
   if (debugLevel) {
     client2.setDebugLevel(debugLevel);
   }
@@ -32743,18 +32758,20 @@ function extractStream(requestBody) {
   const stream = body.stream;
   return typeof stream === "boolean" ? stream : undefined;
 }
-var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError, TokenOperationError, FailoverError, StreamingError, ModelNotFoundError, ProviderBootstrapError, NoProvidersAvailableError, MintDiscoveryError, ModelManager = class _ModelManager {
+var import_rxjs24, consoleLogger, noopLogger, InsufficientBalanceError, ProviderError, MintUnreachableError, TokenOperationError, FailoverError, StreamingError, ModelNotFoundError, ProviderBootstrapError, NoProvidersAvailableError, MintDiscoveryError, ModelManager = class _ModelManager {
   constructor(adapter, config = {}) {
     this.adapter = adapter;
     this.providerDirectoryUrl = config.providerDirectoryUrl || "https://api.routstr.com/v1/providers/";
     this.cacheTTL = config.cacheTTL || 210 * 60 * 1000;
     this.includeProviderUrls = config.includeProviderUrls || [];
     this.excludeProviderUrls = config.excludeProviderUrls || [];
+    this.logger = (config.logger ?? consoleLogger).child("ModelManager");
   }
   cacheTTL;
   providerDirectoryUrl;
   includeProviderUrls;
   excludeProviderUrls;
+  logger;
   getBaseUrls() {
     return this.adapter.getBaseUrlsList();
   }
@@ -32788,7 +32805,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         return filtered;
       }
     } catch (e) {
-      console.warn("Nostr bootstrap failed, falling back to HTTP:", e);
+      this.logger.warn("Nostr bootstrap failed, falling back to HTTP:", e);
     }
     return this.bootstrapFromHttp(torMode, forceRefresh);
   }
@@ -32855,7 +32872,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
             }
           }
         } catch {
-          console.warn("[NostrBootstrap] Failed to parse Nostr event content:", event3.id);
+          this.logger.warn("NostrBootstrap: failed to parse event content:", event3.id);
         }
       }
     }
@@ -32899,7 +32916,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       }
       return list;
     } catch (e) {
-      console.error("Failed to bootstrap providers", e);
+      this.logger.error("Failed to bootstrap providers", e);
       throw new ProviderBootstrapError([], `Provider bootstrap failed: ${e}`);
     }
   }
@@ -32958,9 +32975,9 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         return { success: true, base: base2, list };
       } catch (error) {
         if (this.isProviderDownError(error)) {
-          console.warn(`Provider ${base2} is down right now.`);
+          this.logger.warn(`Provider ${base2} is down right now.`);
         } else {
-          console.warn(`Failed to fetch models from ${base2}:`, error);
+          this.logger.warn(`Failed to fetch models from ${base2}:`, error);
         }
         this.adapter.setProviderLastUpdate(base2, Date.now());
         return { success: false, base: base2 };
@@ -33082,7 +33099,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       this.adapter.setRoutstr21ModelsLastUpdate(Date.now());
       return models;
     } catch {
-      console.warn("[Routstr21Models] Failed to parse Nostr event content:", event3.id);
+      this.logger.warn("Routstr21Models: failed to parse Nostr event content:", event3.id);
       return cachedModels.length > 0 ? cachedModels : [];
     }
   }
@@ -33090,8 +33107,10 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
   constructor(adapter, config = {}) {
     this.adapter = adapter;
     this.cacheTTL = config.cacheTTL || 21 * 60 * 1000;
+    this.logger = (config.logger ?? consoleLogger).child("MintDiscovery");
   }
   cacheTTL;
+  logger;
   async discoverMints(baseUrls, options = {}) {
     if (baseUrls.length === 0) {
       return { mintsFromProviders: {}, infoFromProviders: {} };
@@ -33134,9 +33153,9 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       } catch (error) {
         this.adapter.setProviderLastUpdate(base2, Date.now());
         if (this.isProviderDownError(error)) {
-          console.warn(`Provider ${base2} is down right now.`);
+          this.logger.warn(`Provider ${base2} is down right now.`);
         } else {
-          console.warn(`Failed to fetch mints from ${base2}:`, error);
+          this.logger.warn(`Failed to fetch mints from ${base2}:`, error);
         }
         return { success: false, base: base2, mints: [], info: null };
       }
@@ -33150,14 +33169,14 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
           infoFromAllProviders[base2] = info;
         }
       } else {
-        console.error("Mint discovery error:", result.reason);
+        this.logger.error("Mint discovery error:", result.reason);
       }
     }
     try {
       this.adapter.setCachedMints(mintsFromAllProviders);
       this.adapter.setCachedProviderInfo(infoFromAllProviders);
     } catch (error) {
-      console.error("Error caching mint discovery results:", error);
+      this.logger.error("Error caching mint discovery results:", error);
     }
     return {
       mintsFromProviders: mintsFromAllProviders,
@@ -33254,14 +33273,16 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     });
   }
 }, auditLogger, CashuSpender = class {
-  constructor(walletAdapter, storageAdapter, _providerRegistry, balanceManager) {
+  constructor(walletAdapter, storageAdapter, _providerRegistry, balanceManager, logger3) {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
     this._providerRegistry = _providerRegistry;
     this.balanceManager = balanceManager;
+    this.logger = (logger3 ?? consoleLogger).child("CashuSpender");
   }
   _isBusy = false;
   debugLevel = "WARN";
+  logger;
   async receiveToken(token) {
     try {
       const result = await this.walletAdapter.receiveToken(token);
@@ -33351,13 +33372,13 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     if (levelPriority[level] >= levelPriority[this.debugLevel]) {
       switch (level) {
         case "DEBUG":
-          console.log(...args);
+          this.logger.log(...args);
           break;
         case "WARN":
-          console.warn(...args);
+          this.logger.warn(...args);
           break;
         case "ERROR":
-          console.error(...args);
+          this.logger.error(...args);
           break;
       }
     }
@@ -33607,16 +33628,38 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     for (const apiKeyEntry of apiKeyDistribution) {
       const apiKeyEntryFull = this.storageAdapter.getApiKey(apiKeyEntry.baseUrl);
       if (apiKeyEntryFull && this.balanceManager) {
+        try {
+          const balanceResult = await this.balanceManager.getTokenBalance(apiKeyEntryFull.key, apiKeyEntry.baseUrl);
+          if (balanceResult.isInvalidApiKey) {
+            this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
+            results.push({
+              baseUrl: apiKeyEntry.baseUrl,
+              success: true
+            });
+            continue;
+          }
+          if (balanceResult.amount >= 0) {
+            const balanceSat = balanceResult.unit === "msat" ? Math.floor(balanceResult.amount / 1000) : balanceResult.amount;
+            this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, balanceSat);
+          }
+        } catch {
+        }
+        const refreshedEntry = this.storageAdapter.getApiKey(apiKeyEntry.baseUrl);
+        if (!refreshedEntry)
+          continue;
         const refundResult = await this.balanceManager.refundApiKey({
           mintUrl,
           baseUrl: apiKeyEntry.baseUrl,
-          apiKey: apiKeyEntryFull.key,
+          apiKey: refreshedEntry.key,
           forceRefund
         });
         if (refundResult.success) {
           this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
         } else {
-          this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, apiKeyEntry.amount);
+          const currentEntry = this.storageAdapter.getApiKey(apiKeyEntry.baseUrl);
+          if (currentEntry) {
+            this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, currentEntry.balance);
+          }
         }
         results.push({
           baseUrl: apiKeyEntry.baseUrl,
@@ -33672,10 +33715,11 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     return 0;
   }
 }, BalanceManager = class _BalanceManager {
-  constructor(walletAdapter, storageAdapter, providerRegistry, cashuSpender) {
+  constructor(walletAdapter, storageAdapter, providerRegistry, cashuSpender, logger3) {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
     this.providerRegistry = providerRegistry;
+    this.logger = (logger3 ?? consoleLogger).child("BalanceManager");
     if (cashuSpender) {
       this.cashuSpender = cashuSpender;
     } else {
@@ -33685,6 +33729,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
   cashuSpender;
   providerWalletOps = /* @__PURE__ */ new Map;
   static PROVIDER_WALLET_COOLDOWN_MS = 1e4;
+  logger;
   _canRunProviderWalletOperation(baseUrl, type) {
     const existing = this.providerWalletOps.get(baseUrl);
     if (!existing) {
@@ -33750,7 +33795,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     const { mintUrl, baseUrl, apiKey, forceRefund } = options;
     const guard = this._canRunProviderWalletOperation(baseUrl, "refund");
     if (!guard.allowed) {
-      console.log(`[BalanceManager] Skipping refund for ${baseUrl} - ${guard.reason}`);
+      this.logger.log(`Skipping refund for ${baseUrl} - ${guard.reason}`);
       return { success: false, message: guard.reason };
     }
     this._beginProviderWalletOperation(baseUrl, "refund");
@@ -33770,7 +33815,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       if (apiKeyEntry?.lastUsed) {
         const fiveMinutesAgo = Date.now() - 300000;
         if (apiKeyEntry.lastUsed > fiveMinutesAgo) {
-          console.log(`[BalanceManager] Skipping refund for ${baseUrl} - used ${Math.round((Date.now() - apiKeyEntry.lastUsed) / 1000)}s ago`);
+          this.logger.log(`Skipping refund for ${baseUrl} - used ${Math.round((Date.now() - apiKeyEntry.lastUsed) / 1000)}s ago`);
           return {
             success: false,
             message: "API key was used recently, skipping refund"
@@ -33796,7 +33841,8 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         };
       }
       if (fetchResult.error === "No balance to refund") {
-        return { success: false, message: "No balance to refund" };
+        this.storageAdapter.removeApiKey(baseUrl);
+        return { success: true, message: "No balance to refund, key cleaned up" };
       }
       const receiveResult = await this.cashuSpender.receiveToken(fetchResult.token);
       const totalAmountMsat = receiveResult.unit === "msat" ? receiveResult.amount : receiveResult.amount * 1000;
@@ -33810,7 +33856,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         requestId: fetchResult.requestId
       };
     } catch (error) {
-      console.error("[BalanceManager] API key refund error", error);
+      this.logger.error("API key refund error", error);
       return this._handleRefundError(error, mintUrl, fetchResult?.requestId);
     }
   }
@@ -33859,7 +33905,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       };
     } catch (error) {
       clearTimeout(timeoutId);
-      console.error("[BalanceManager.fetchRefundToken] Fetch error", error);
+      this.logger.error("fetchRefundToken fetch error", error);
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           return {
@@ -33882,7 +33928,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     const { mintUrl, baseUrl, amount, token: providedToken } = options;
     const guard = this._canRunProviderWalletOperation(baseUrl, "topup");
     if (!guard.allowed) {
-      console.log(`[BalanceManager] Skipping topup for ${baseUrl} - ${guard.reason}`);
+      this.logger.log(`Skipping topup for ${baseUrl} - ${guard.reason}`);
       return { success: false, message: guard.reason };
     }
     this._beginProviderWalletOperation(baseUrl, "topup");
@@ -33919,7 +33965,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       cashuToken = tokenResult.token;
       const topUpResult = await this._postTopUp(baseUrl, apiKey, cashuToken);
       requestId = topUpResult.requestId;
-      console.log(topUpResult);
+      this.logger.log("topUpResult:", topUpResult);
       if (!topUpResult.success) {
         await this._recoverFailedTopUp(cashuToken);
         return {
@@ -33935,7 +33981,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         requestId
       };
     } catch (error) {
-      console.log("DEBUG", `[TopuPU] topup: Topup result for ${baseUrl}: error=${error}`);
+      this.logger.log(`topup error for ${baseUrl}: ${error}`);
       if (cashuToken) {
         await this._recoverFailedTopUp(cashuToken);
       }
@@ -33952,9 +33998,9 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       p2pkPubkey
     } = options;
     const adjustedAmount = Math.ceil(amount);
-    console.log(`[BalanceManager.createProviderToken] Starting: baseUrl=${baseUrl}, mintUrl=${mintUrl}, amount=${amount}, adjustedAmount=${adjustedAmount}, retryCount=${retryCount}`);
+    this.logger.log(`createProviderToken: baseUrl=${baseUrl} mintUrl=${mintUrl} amount=${amount} adjustedAmount=${adjustedAmount} retryCount=${retryCount}`);
     if (!adjustedAmount || isNaN(adjustedAmount)) {
-      console.error(`[BalanceManager.createProviderToken] FAILURE: Invalid amount - amount=${amount}, adjustedAmount=${adjustedAmount}`);
+      this.logger.error(`createProviderToken: invalid amount=${amount}`);
       return { success: false, error: "Invalid top up amount" };
     }
     const balanceState = await this.getBalanceState();
@@ -33972,7 +34018,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     }
     if (totalMintBalance + targetProviderBalance < adjustedAmount) {
       const error = new InsufficientBalanceError(adjustedAmount, totalMintBalance + targetProviderBalance, totalMintBalance, Object.entries(balanceState.mintBalances).reduce((max, [url2, balance]) => balance > max.balance ? { url: url2, balance } : max, { url: "", balance: 0 }).url);
-      console.error(`[BalanceManager.createProviderToken] FAILURE: Insufficient balance - required=${adjustedAmount}, available=${totalMintBalance + targetProviderBalance}, totalMintBalance=${totalMintBalance}, targetProviderBalance=${targetProviderBalance}, refundableProviderBalance=${refundableProviderBalance}`);
+      this.logger.error(`createProviderToken: insufficient balance required=${adjustedAmount} available=${totalMintBalance + targetProviderBalance} totalMint=${totalMintBalance} targetProvider=${targetProviderBalance}`);
       return { success: false, error: error.message };
     }
     const providerMints = baseUrl && this.providerRegistry ? this.providerRegistry.getProviderMints(baseUrl) : [];
@@ -34008,16 +34054,16 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
           maxMintUrl = mintUrl2;
         }
       }
-      console.error(`[BalanceManager.createProviderToken] FAILURE: No candidate mints found - requiredAmount=${requiredAmount}, totalMintBalance=${totalMintBalance}, maxBalance=${maxBalance}, maxMintUrl=${maxMintUrl}, providerMints=${JSON.stringify(providerMints)}`);
+      this.logger.error(`createProviderToken: no candidate mints required=${requiredAmount} totalMint=${totalMintBalance} maxBalance=${maxBalance} maxMint=${maxMintUrl}`);
       const error = new InsufficientBalanceError(adjustedAmount, totalMintBalance, maxBalance, maxMintUrl);
       return { success: false, error: error.message };
     }
     let lastError;
     for (const candidateMint of candidates) {
       try {
-        console.log(`[BalanceManager.createProviderToken] Attempting mint: ${candidateMint}, amount: ${requiredAmount}`);
+        this.logger.log(`createProviderToken: attempting mint=${candidateMint} amount=${requiredAmount}`);
         const token = await this.walletAdapter.sendToken(candidateMint, requiredAmount, p2pkPubkey);
-        console.log(`[BalanceManager.createProviderToken] SUCCESS: Token created from mint ${candidateMint}, all mint balances: ${JSON.stringify(Object.fromEntries(Object.entries(balances).map(([mint, balance]) => [mint, getBalanceInSats(balance, units[mint])])))}`);
+        this.logger.log(`createProviderToken: success from mint=${candidateMint}`);
         return {
           success: true,
           token,
@@ -34026,11 +34072,11 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         };
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        console.error(`[BalanceManager.createProviderToken] FAILURE: Mint ${candidateMint} failed with error: ${errorMsg}`);
+        this.logger.error(`createProviderToken: mint=${candidateMint} failed: ${errorMsg}`);
         if (error instanceof Error) {
           lastError = errorMsg;
           if (isNetworkErrorMessage(error.message)) {
-            console.warn(`[BalanceManager.createProviderToken] Network error from ${candidateMint}, trying next mint...`);
+            this.logger.warn(`createProviderToken: network error from ${candidateMint}, trying next mint...`);
             continue;
           }
         }
@@ -34040,7 +34086,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         };
       }
     }
-    console.error(`[BalanceManager.createProviderToken] FAILURE: All candidate mints exhausted - lastError=${lastError}, candidates=${JSON.stringify(candidates)}`);
+    this.logger.error(`createProviderToken: all candidate mints exhausted lastError=${lastError}`);
     return {
       success: false,
       error: lastError || "All candidate mints failed while creating top up token"
@@ -34141,7 +34187,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       return { success: true, requestId };
     } catch (error) {
       clearTimeout(timeoutId);
-      console.error("[BalanceManager._postTopUp] Fetch error", error);
+      this.logger.error("_postTopUp fetch error", error);
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           return {
@@ -34164,7 +34210,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     try {
       await this.cashuSpender.receiveToken(cashuToken);
     } catch (error) {
-      console.error("[BalanceManager._recoverFailedTopUp] Failed to recover token", error);
+      this.logger.error("_recoverFailedTopUp: failed to recover token", error);
     }
   }
   _handleRefundError(error, mintUrl, requestId) {
@@ -34211,9 +34257,9 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
           apiKey: data.api_key
         };
       } else {
-        console.log(response.status);
+        this.logger.warn(`getTokenBalance: status=${response.status}`);
         const data = await response.json();
-        console.log("FAILED ", data);
+        this.logger.warn("getTokenBalance: FAILED", data);
         const isInvalidApiKey = response.status === 401 && data?.detail?.error?.code === "invalid_api_key" && data?.detail?.error?.message?.includes("proofs already spent");
         return {
           amount: -1,
@@ -34224,7 +34270,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         };
       }
     } catch (error) {
-      console.error("ERRORR IN RESTPONSE", error);
+      this.logger.error("getTokenBalance error", error);
     }
     return { amount: -1, reserved: 0, unit: "sat", apiKey: "" };
   }
@@ -34521,9 +34567,10 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
   const filtered = normalized.filter((value) => torMode ? true : !isOnionUrl(value));
   return dedupePreserveOrder(filtered.filter((value) => shouldAllowHttp(value, torMode)));
 }, ProviderManager = class _ProviderManager {
-  constructor(providerRegistry, store) {
+  constructor(providerRegistry, store, logger3) {
     this.providerRegistry = providerRegistry;
     this.instanceId = `pm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    this.logger = (logger3 ?? consoleLogger).child(`ProviderManager:${this.instanceId}`);
     if (store) {
       this.store = store;
       this.hydrateFromStore();
@@ -34535,6 +34582,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
   static COOLDOWN_DURATION_MS = 42000;
   store = null;
   instanceId;
+  logger;
   hydrateFromStore() {
     if (!this.store)
       return;
@@ -34543,10 +34591,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     this.lastFailed = new Map(Object.entries(state.lastFailed));
     const now2 = Date.now();
     this.providersOnCoolDown = state.providersOnCooldown.filter((entry) => now2 - entry.timestamp < _ProviderManager.COOLDOWN_DURATION_MS).map((entry) => [entry.baseUrl, entry.timestamp]);
-    console.log(`[ProviderManager:${this.instanceId}] Hydrated from store:`);
-    console.log(`  failedProviders: ${this.failedProviders.size}`);
-    console.log(`  lastFailed: ${this.lastFailed.size}`);
-    console.log(`  providersOnCooldown: ${this.providersOnCoolDown.length}`);
+    this.logger.log(`Hydrated from store: failedProviders=${this.failedProviders.size} lastFailed=${this.lastFailed.size} providersOnCooldown=${this.providersOnCoolDown.length}`);
   }
   getInstanceId() {
     return this.instanceId;
@@ -34558,7 +34603,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       const age = now2 - timestamp;
       const isExpired = age >= _ProviderManager.COOLDOWN_DURATION_MS;
       if (isExpired) {
-        console.log(`[cleanupExpiredCooldowns:${this.instanceId}] Removing expired cooldown for ${url2} (age: ${age}ms, cooldown: ${_ProviderManager.COOLDOWN_DURATION_MS}ms)`);
+        this.logger.log(`Removing expired cooldown for ${url2} (age: ${age}ms)`);
         this.failedProviders.delete(url2);
         if (this.store) {
           this.store.getState().removeFailedProvider(url2);
@@ -34568,7 +34613,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     });
     const after = this.providersOnCoolDown.length;
     if (before !== after) {
-      console.log(`[cleanupExpiredCooldowns:${this.instanceId}] Cleaned up ${before - after} expired cooldown(s), ${after} remaining`);
+      this.logger.log(`Cleaned up ${before - after} expired cooldown(s), ${after} remaining`);
     }
   }
   getCooldownDurationMs() {
@@ -34598,14 +34643,10 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
   markFailed(baseUrl) {
     const now2 = Date.now();
     const lastFailure = this.lastFailed.get(baseUrl);
-    console.log(`[markFailed:${this.instanceId}] baseUrl: ${baseUrl}`);
-    console.log(`[markFailed:${this.instanceId}] lastFailure from map: ${lastFailure}`);
-    console.log(`[markFailed:${this.instanceId}] current timestamp (now): ${now2}`);
-    console.log(`[markFailed:${this.instanceId}] COOLDOWN_DURATION_MS: ${_ProviderManager.COOLDOWN_DURATION_MS}`);
+    this.logger.log(`markFailed: ${baseUrl} lastFailure=${lastFailure} now=${now2}`);
     if (lastFailure !== undefined) {
       const timeSinceLastFailure = now2 - lastFailure;
-      console.log(`[markFailed:${this.instanceId}] timeSinceLastFailure: ${timeSinceLastFailure}ms`);
-      console.log(`[markFailed:${this.instanceId}] isWithinCooldownWindow: ${timeSinceLastFailure < _ProviderManager.COOLDOWN_DURATION_MS}`);
+      this.logger.log(`markFailed: timeSinceLastFailure=${timeSinceLastFailure}ms withinCooldown=${timeSinceLastFailure < _ProviderManager.COOLDOWN_DURATION_MS}`);
     }
     this.lastFailed.set(baseUrl, now2);
     this.failedProviders.add(baseUrl);
@@ -34613,24 +34654,23 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       this.store.getState().setLastFailedTimestamp(baseUrl, now2);
       this.store.getState().addFailedProvider(baseUrl);
     }
-    console.log(`[markFailed:${this.instanceId}] Updated lastFailed map for ${baseUrl} to ${now2}`);
-    console.log(`[markFailed:${this.instanceId}] failedProviders set size: ${this.failedProviders.size}`);
+    this.logger.log(`markFailed: updated ${baseUrl} to ${now2}, failedProviders=${this.failedProviders.size}`);
     if (lastFailure !== undefined && now2 - lastFailure < _ProviderManager.COOLDOWN_DURATION_MS) {
-      console.log(`[markFailed:${this.instanceId}] Second failure detected within cooldown window for ${baseUrl}`);
+      this.logger.log(`markFailed: second failure within cooldown window for ${baseUrl}`);
       if (!this.isOnCooldown(baseUrl)) {
         this.providersOnCoolDown.push([baseUrl, now2]);
         if (this.store) {
           this.store.getState().addProviderOnCooldown(baseUrl, now2);
         }
-        console.log(`[markFailed:${this.instanceId}] Provider ${baseUrl} added to cooldown after second failure within 5 minutes`);
+        this.logger.log(`markFailed: ${baseUrl} added to cooldown`);
       } else {
-        console.log(`[markFailed:${this.instanceId}] Provider ${baseUrl} is already on cooldown`);
+        this.logger.log(`markFailed: ${baseUrl} already on cooldown`);
       }
     } else {
       if (lastFailure === undefined) {
-        console.log(`[markFailed:${this.instanceId}] First failure for ${baseUrl} - not adding to cooldown yet`);
+        this.logger.log(`markFailed: first failure for ${baseUrl}`);
       } else {
-        console.log(`[markFailed:${this.instanceId}] Failure outside cooldown window for ${baseUrl} (timeSinceLastFailure: ${now2 - lastFailure}ms)`);
+        this.logger.log(`markFailed: failure outside cooldown window for ${baseUrl} (${now2 - lastFailure}ms ago)`);
       }
     }
   }
@@ -34662,15 +34702,12 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     try {
       const torMode = isTorContext();
       const disabledProviders = new Set(this.providerRegistry.getDisabledProviders());
-      console.log(`[findNextBestProvider:${this.instanceId}] Starting search for model: ${modelId}`);
-      console.log(`[findNextBestProvider:${this.instanceId}] disabledProviders: ${[...disabledProviders]}`);
-      console.log(`[findNextBestProvider:${this.instanceId}] providersOnCooldown: ${this.providersOnCoolDown.map(([url2]) => url2)}`);
+      this.logger.log(`findNextBestProvider: model=${modelId} disabled=${[...disabledProviders].length} onCooldown=${this.providersOnCoolDown.length}`);
       const allProviders = this.providerRegistry.getAllProvidersModels();
-      console.log(`[findNextBestProvider:${this.instanceId}] Total providers in registry: ${Object.keys(allProviders).length}`);
+      this.logger.log(`findNextBestProvider: total providers=${Object.keys(allProviders).length}`);
       const candidates = [];
       for (const [baseUrl, models] of Object.entries(allProviders)) {
         if (baseUrl === currentBaseUrl) {
-          console.log(`[findNextBestProvider:${this.instanceId}] SKIP (current): ${baseUrl}`);
           continue;
         }
         if (disabledProviders.has(baseUrl)) {
@@ -34696,7 +34733,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         return null;
       }
     } catch (error) {
-      console.error("Error finding next best provider:", error);
+      this.logger.error("findNextBestProvider error:", error);
       return null;
     }
   }
@@ -34804,13 +34841,9 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
                 if (res) {
                   const tokensFromImage = calculateImageTokens(res.width, res.height);
                   imageTokens += tokensFromImage;
-                  console.log("IMAGE INPUT RESOLUTION", {
-                    width: res.width,
-                    height: res.height,
-                    tokensFromImage
-                  });
+                  this.logger.log(`IMAGE INPUT RESOLUTION width=${res.width} height=${res.height} tokens=${tokensFromImage}`);
                 } else {
-                  console.log("IMAGE INPUT RESOLUTION", "unknown (unsupported format or parse failure)");
+                  this.logger.log("IMAGE INPUT RESOLUTION: unknown format");
                 }
               }
             }
@@ -34841,7 +34874,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       const totalEstimatedCosts = (promptCosts + completionCost) * 1.05;
       return totalEstimatedCosts;
     } catch (e) {
-      console.error(e);
+      this.logger.error("getRequiredSatsForModel error:", e);
       return 0;
     }
   }
@@ -35967,9 +36000,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     const distributionMap = {};
     for (const entry of apiKeys) {
       const sum = entry.balance || 0;
-      if (sum > 0) {
-        distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
-      }
+      distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
     }
     return Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
   },
@@ -36132,38 +36163,41 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
   updateXcashuTokenTryCount: (token, tryCount) => {
     store.getState().updateXcashuTokenTryCount(token, tryCount);
   }
-}), createProviderRegistryFromStore = (store) => ({
-  getModelsForProvider: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    return store.getState().modelsFromAllProviders[normalized] || [];
-  },
-  getDisabledProviders: () => store.getState().disabledProviders,
-  getProviderMints: (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    return store.getState().mintsFromAllProviders[normalized] || [];
-  },
-  getProviderInfo: async (baseUrl) => {
-    const normalized = normalizeBaseUrl5(baseUrl);
-    const cached = store.getState().infoFromAllProviders[normalized];
-    if (cached)
-      return cached;
-    try {
-      const response = await fetch(`${normalized}v1/info`);
-      if (!response.ok) {
-        throw new Error(`Failed ${response.status}`);
+}), createProviderRegistryFromStore = (store, logger3) => {
+  const log3 = (logger3 ?? consoleLogger).child("ProviderRegistry");
+  return {
+    getModelsForProvider: (baseUrl) => {
+      const normalized = normalizeBaseUrl5(baseUrl);
+      return store.getState().modelsFromAllProviders[normalized] || [];
+    },
+    getDisabledProviders: () => store.getState().disabledProviders,
+    getProviderMints: (baseUrl) => {
+      const normalized = normalizeBaseUrl5(baseUrl);
+      return store.getState().mintsFromAllProviders[normalized] || [];
+    },
+    getProviderInfo: async (baseUrl) => {
+      const normalized = normalizeBaseUrl5(baseUrl);
+      const cached = store.getState().infoFromAllProviders[normalized];
+      if (cached)
+        return cached;
+      try {
+        const response = await fetch(`${normalized}v1/info`);
+        if (!response.ok) {
+          throw new Error(`Failed ${response.status}`);
+        }
+        const info = await response.json();
+        const next = { ...store.getState().infoFromAllProviders };
+        next[normalized] = info;
+        store.getState().setInfoFromAllProviders(next);
+        return info;
+      } catch (error) {
+        log3.warn(`Failed to fetch provider info from ${normalized}:`, error);
+        return null;
       }
-      const info = await response.json();
-      const next = { ...store.getState().infoFromAllProviders };
-      next[normalized] = info;
-      store.getState().setInfoFromAllProviders(next);
-      return info;
-    } catch (error) {
-      console.warn(`Failed to fetch provider info from ${normalized}:`, error);
-      return null;
-    }
-  },
-  getAllProvidersModels: () => store.getState().modelsFromAllProviders
-}), isBrowser3 = () => {
+    },
+    getAllProvidersModels: () => store.getState().modelsFromAllProviders
+  };
+}, isBrowser3 = () => {
   try {
     return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
   } catch {
@@ -36228,6 +36262,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
     this.providerRegistry = providerRegistry;
+    this.logger = (options.logger ?? consoleLogger).child("RoutstrClient");
     this.balanceManager = new BalanceManager(walletAdapter, storageAdapter, providerRegistry);
     this.cashuSpender = new CashuSpender(walletAdapter, storageAdapter, providerRegistry, this.balanceManager);
     this.streamProcessor = new StreamProcessor;
@@ -36235,7 +36270,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     this.mode = mode;
     this.usageTrackingDriver = options.usageTrackingDriver;
     this.sdkStore = options.sdkStore;
-    this.providerManager = options.providerManager ?? new ProviderManager(providerRegistry, this.sdkStore);
+    this.providerManager = options.providerManager ?? new ProviderManager(providerRegistry, this.sdkStore, this.logger);
   }
   cashuSpender;
   balanceManager;
@@ -36246,6 +36281,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
   debugLevel = "WARN";
   usageTrackingDriver;
   sdkStore;
+  logger;
   getMode() {
     return this.mode;
   }
@@ -36264,13 +36300,13 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     if (levelPriority[level] >= levelPriority[this.debugLevel]) {
       switch (level) {
         case "DEBUG":
-          console.log(...args);
+          this.logger.log(...args);
           break;
         case "WARN":
-          console.warn(...args);
+          this.logger.warn(...args);
           break;
         case "ERROR":
-          console.error(...args);
+          this.logger.error(...args);
           break;
       }
     }
@@ -36702,7 +36738,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         tryNextProvider = true;
       }
     }
-    if ((status === 401 || status === 403 || status === 413 || status === 400 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
+    if ((status === 401 || status === 403 || status === 404 || status === 413 || status === 400 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
       this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: Status ${status} (${status === 429 ? "rate limited" : "auth/server error"}), attempting refund for ${baseUrl}, mode=${this.mode}`);
       if (this.mode === "apikeys") {
         this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`);
@@ -37044,6 +37080,18 @@ var init_dist3 = __esm(() => {
   import_rxjs24 = __toESM(require_cjs(), 1);
   init_cashu_ts_es();
   init_vanilla();
+  consoleLogger = makeConsoleLogger();
+  noopLogger = {
+    log: () => {
+    },
+    warn: () => {
+    },
+    error: () => {
+    },
+    debug: () => {
+    },
+    child: () => noopLogger
+  };
   InsufficientBalanceError = class extends Error {
     constructor(required, available, maxMintBalance = 0, maxMintUrl = "", customMessage) {
       super(customMessage ?? `Insufficient balance: need ${required} sats, have ${available} sats available. ` + (maxMintBalance > 0 ? `Largest mint balance: ${maxMintBalance} sats from ${maxMintUrl}` : ""));
@@ -37332,7 +37380,19 @@ function saveDaemonConfig(config) {
 }
 
 // node_modules/@routstr/sdk/dist/storage/index.mjs
-async function createBunSqliteDriver2(dbPath) {
+function makeConsoleLogger2(prefix) {
+  const fmt = (args) => prefix ? [prefix, ...args] : args;
+  return {
+    log: (...args) => console.log(...fmt(args)),
+    warn: (...args) => console.warn(...fmt(args)),
+    error: (...args) => console.error(...fmt(args)),
+    debug: (...args) => console.log(...fmt(args)),
+    child: (p) => makeConsoleLogger2(prefix ? `${prefix}:${p}` : p)
+  };
+}
+var consoleLogger2 = makeConsoleLogger2();
+async function createBunSqliteDriver2(dbPath, options) {
+  const logger4 = (options?.logger ?? consoleLogger2).child("BunSqliteDriver");
   const SQLite = (await import("bun:sqlite")).default;
   const db = new SQLite(dbPath);
   db.run(`
@@ -37356,7 +37416,7 @@ async function createBunSqliteDriver2(dbPath) {
           throw parseError;
         }
       } catch (error) {
-        console.error(`SQLite getItem failed for key "${key}":`, error);
+        logger4.error(`getItem failed for key "${key}":`, error);
         return defaultValue;
       }
     },
@@ -37364,14 +37424,14 @@ async function createBunSqliteDriver2(dbPath) {
       try {
         db.query("INSERT INTO sdk_storage (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, JSON.stringify(value));
       } catch (error) {
-        console.error(`SQLite setItem failed for key "${key}":`, error);
+        logger4.error(`setItem failed for key "${key}":`, error);
       }
     },
     async removeItem(key) {
       try {
         db.query("DELETE FROM sdk_storage WHERE key = ?").run(key);
       } catch (error) {
-        console.error(`SQLite removeItem failed for key "${key}":`, error);
+        logger4.error(`removeItem failed for key "${key}":`, error);
       }
     }
   };