routstrd 0.1.1 → 0.1.4

package/dist/daemon/index.js

@@ -23628,7 +23628,8 @@ async function resolveRouteRequestContext(options) {
     debugLevel,
     mode = "apikeys",
     usageTrackingDriver,
-    sdkStore
+    sdkStore,
+    providerManager: providedProviderManager
   } = options;
   let modelManager;
   let providers;
@@ -23648,7 +23649,7 @@ async function resolveRouteRequestContext(options) {
     }
     await modelManager.fetchModels(providers, forceRefresh);
   }
-  const providerManager = new ProviderManager(providerRegistry);
+  const providerManager = providedProviderManager ?? new ProviderManager(providerRegistry, sdkStore);
   let baseUrl;
   let selectedModel;
   if (forcedProvider) {
@@ -23683,7 +23684,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 });
+  const client2 = new RoutstrClient(walletAdapter, storageAdapter, providerRegistry, "min", mode, { usageTrackingDriver, sdkStore, providerManager });
   if (debugLevel) {
     client2.setDebugLevel(debugLevel);
   }
@@ -24066,7 +24067,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       }
     }
     const DEFAULT_RELAYS = [
-      "wss://relay.primal.net",
+      "wss://relay.damus.io",
       "wss://nos.lol",
       "wss://relay.routstr.com"
     ];
@@ -24559,7 +24560,14 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         continue;
       for (const xcashuToken of tokens) {
         try {
-          const receiveResult = await this.receiveToken(xcashuToken.token);
+          if (!this.balanceManager) {
+            throw new Error("BalanceManager not available for xcashu refund");
+          }
+          const fetchResult = await this.balanceManager.fetchRefundToken(baseUrl, xcashuToken.token, true);
+          if (!fetchResult.success || !fetchResult.token) {
+            throw new Error(fetchResult.error || "Failed to fetch refund token from provider");
+          }
+          const receiveResult = await this.receiveToken(fetchResult.token);
           if (receiveResult.success) {
             this.storageAdapter.removeXcashuToken(baseUrl, xcashuToken.token);
             results.push({
@@ -24578,7 +24586,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
               success: false,
               error: receiveResult.message ?? "Refund failed"
             });
-            this._log("DEBUG", `[CashuSpender] refundXcashuTokens: Failed to refund xcashu token for ${baseUrl}, incremented tryCount to ${newTryCount}`);
+            this._log("DEBUG", `[CashuSpender] refundXcashuTokens: Failed to receive refund token for ${baseUrl}, incremented tryCount to ${newTryCount}`);
           }
         } catch (error) {
           const currentTryCount = xcashuToken.tryCount ?? 0;
@@ -24727,7 +24735,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     }
     let fetchResult;
     try {
-      fetchResult = await this._fetchRefundTokenWithApiKey(baseUrl, apiKey);
+      fetchResult = await this.fetchRefundToken(baseUrl, apiKey);
       if (!fetchResult.success) {
         return {
           success: false,
@@ -24760,7 +24768,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       return this._handleRefundError(error, mintUrl, fetchResult?.requestId);
     }
   }
-  async _fetchRefundTokenWithApiKey(baseUrl, apiKey) {
+  async fetchRefundToken(baseUrl, apiKeyOrToken, xCashu = false) {
     if (!baseUrl) {
       return {
         success: false,
@@ -24774,12 +24782,17 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       controller.abort();
     }, 60000);
     try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (xCashu) {
+        headers["X-Cashu"] = apiKeyOrToken;
+      } else {
+        headers["Authorization"] = `Bearer ${apiKeyOrToken}`;
+      }
       const response = await fetch(url2, {
         method: "POST",
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          "Content-Type": "application/json"
-        },
+        headers,
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -24800,7 +24813,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       };
     } catch (error) {
       clearTimeout(timeoutId);
-      console.error("[BalanceManager._fetchRefundTokenWithApiKey] Fetch error", error);
+      console.error("[BalanceManager.fetchRefundToken] Fetch error", error);
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           return {
@@ -25141,7 +25154,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         console.log(response.status);
         const data = await response.json();
         console.log("FAILED ", data);
-        const isInvalidApiKey = response.status === 401 && data?.code === "invalid_api_key" && data?.message?.includes("proofs already spent");
+        const isInvalidApiKey = response.status === 401 && data?.detail?.error?.code === "invalid_api_key" && data?.detail?.error?.message?.includes("proofs already spent");
         return {
           amount: -1,
           reserved: data.reserved ?? 0,
@@ -25445,23 +25458,59 @@ 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) {
+  constructor(providerRegistry, store) {
     this.providerRegistry = providerRegistry;
+    this.instanceId = `pm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    if (store) {
+      this.store = store;
+      this.hydrateFromStore();
+    }
   }
   failedProviders = /* @__PURE__ */ new Set;
   lastFailed = /* @__PURE__ */ new Map;
   providersOnCoolDown = [];
   static COOLDOWN_DURATION_MS = 300000;
+  store = null;
+  instanceId;
+  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 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}`);
+  }
+  getInstanceId() {
+    return this.instanceId;
+  }
   cleanupExpiredCooldowns() {
     const now2 = Date.now();
-    this.providersOnCoolDown = this.providersOnCoolDown.filter(([, timestamp]) => now2 - timestamp < _ProviderManager.COOLDOWN_DURATION_MS);
+    const before = this.providersOnCoolDown.length;
+    this.providersOnCoolDown = this.providersOnCoolDown.filter(([url2, timestamp]) => {
+      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)`);
+      }
+      return !isExpired;
+    });
+    const after = this.providersOnCoolDown.length;
+    if (before !== after) {
+      console.log(`[cleanupExpiredCooldowns:${this.instanceId}] Cleaned up ${before - after} expired cooldown(s), ${after} remaining`);
+    }
   }
   getCooldownDurationMs() {
     return _ProviderManager.COOLDOWN_DURATION_MS;
   }
   isOnCooldown(baseUrl) {
     this.cleanupExpiredCooldowns();
-    return this.providersOnCoolDown.some(([url2]) => url2 === baseUrl);
+    const result = this.providersOnCoolDown.some(([url2]) => url2 === baseUrl);
+    return result;
   }
   getProvidersOnCooldown() {
     this.cleanupExpiredCooldowns();
@@ -25469,6 +25518,9 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
   }
   resetFailedProviders() {
     this.failedProviders.clear();
+    if (this.store) {
+      this.store.getState().setFailedProviders([]);
+    }
   }
   getLastFailed(baseUrl) {
     return this.lastFailed.get(baseUrl);
@@ -25479,23 +25531,59 @@ 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}`);
+    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.lastFailed.set(baseUrl, now2);
     this.failedProviders.add(baseUrl);
+    if (this.store) {
+      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}`);
     if (lastFailure !== undefined && now2 - lastFailure < _ProviderManager.COOLDOWN_DURATION_MS) {
+      console.log(`[markFailed:${this.instanceId}] Second failure detected within cooldown window for ${baseUrl}`);
       if (!this.isOnCooldown(baseUrl)) {
         this.providersOnCoolDown.push([baseUrl, now2]);
-        console.log(`Provider ${baseUrl} added to cooldown after second failure within 5 minutes`);
+        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`);
+      } else {
+        console.log(`[markFailed:${this.instanceId}] Provider ${baseUrl} is already on cooldown`);
+      }
+    } else {
+      if (lastFailure === undefined) {
+        console.log(`[markFailed:${this.instanceId}] First failure for ${baseUrl} - not adding to cooldown yet`);
+      } else {
+        console.log(`[markFailed:${this.instanceId}] Failure outside cooldown window for ${baseUrl} (timeSinceLastFailure: ${now2 - lastFailure}ms)`);
       }
     }
   }
   removeFromCooldown(baseUrl) {
     this.providersOnCoolDown = this.providersOnCoolDown.filter(([url2]) => url2 !== baseUrl);
+    if (this.store) {
+      this.store.getState().removeProviderFromCooldown(baseUrl);
+    }
   }
   clearCooldowns() {
     this.providersOnCoolDown = [];
+    if (this.store) {
+      this.store.getState().clearProvidersOnCooldown();
+    }
   }
   clearFailureHistory() {
     this.lastFailed.clear();
+    if (this.store) {
+      this.store.getState().setLastFailed({});
+    }
   }
   hasFailed(baseUrl) {
     return this.failedProviders.has(baseUrl);
@@ -26432,6 +26520,9 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
   lastRoutstr21ModelsUpdate: null,
   cachedReceiveTokens: [],
   clientIds: [],
+  failedProviders: [],
+  lastFailed: {},
+  providersOnCooldown: [],
   setModelsFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, models] of Object.entries(value)) {
@@ -26561,6 +26652,70 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       driver.setItem(SDK_STORAGE_KEYS.CLIENT_IDS, normalized);
       return { clientIds: normalized };
     });
+  },
+  setFailedProviders: (value) => {
+    const normalized = value.map((url2) => normalizeBaseUrl5(url2));
+    driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, normalized);
+    set({ failedProviders: normalized });
+  },
+  addFailedProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().failedProviders;
+    if (!current.includes(normalized)) {
+      const updated = [...current, normalized];
+      driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
+      set({ failedProviders: updated });
+    }
+  },
+  removeFailedProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().failedProviders;
+    const updated = current.filter((url2) => url2 !== normalized);
+    driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
+    set({ failedProviders: updated });
+  },
+  setLastFailed: (value) => {
+    const normalized = {};
+    for (const [baseUrl, timestamp] of Object.entries(value)) {
+      normalized[normalizeBaseUrl5(baseUrl)] = timestamp;
+    }
+    driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, normalized);
+    set({ lastFailed: normalized });
+  },
+  setLastFailedTimestamp: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().lastFailed;
+    const updated = { ...current, [normalized]: timestamp };
+    driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, updated);
+    set({ lastFailed: updated });
+  },
+  setProvidersOnCooldown: (value) => {
+    const normalized = value.map((entry) => ({
+      baseUrl: normalizeBaseUrl5(entry.baseUrl),
+      timestamp: entry.timestamp
+    }));
+    driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, normalized);
+    set({ providersOnCooldown: normalized });
+  },
+  addProviderOnCooldown: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().providersOnCooldown;
+    if (!current.some((entry) => entry.baseUrl === normalized)) {
+      const updated = [...current, { baseUrl: normalized, timestamp }];
+      driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
+      set({ providersOnCooldown: updated });
+    }
+  },
+  removeProviderFromCooldown: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().providersOnCooldown;
+    const updated = current.filter((entry) => entry.baseUrl !== normalized);
+    driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
+    set({ providersOnCooldown: updated });
+  },
+  clearProvidersOnCooldown: () => {
+    driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, []);
+    set({ providersOnCooldown: [] });
   }
 })), hydrateStoreFromDriver = async (store, driver) => {
   const [
@@ -26578,7 +26733,10 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     rawRoutstr21Models,
     rawLastRoutstr21ModelsUpdate,
     rawCachedReceiveTokens,
-    rawClientIds
+    rawClientIds,
+    rawFailedProviders,
+    rawLastFailed,
+    rawProvidersOnCooldown
   ] = await Promise.all([
     driver.getItem(SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS, {}),
     driver.getItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, null),
@@ -26594,7 +26752,10 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
     driver.getItem(SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE, null),
     driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
-    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, [])
+    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, []),
+    driver.getItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, []),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_FAILED, {}),
+    driver.getItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, [])
   ]);
   const modelsFromAllProviders = Object.fromEntries(Object.entries(rawModels).map(([baseUrl, models]) => [
     normalizeBaseUrl5(baseUrl),
@@ -26650,6 +26811,15 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     createdAt: entry.createdAt ?? Date.now(),
     lastUsed: entry.lastUsed ?? null
   }));
+  const failedProviders = rawFailedProviders.map((url2) => normalizeBaseUrl5(url2));
+  const lastFailed = Object.fromEntries(Object.entries(rawLastFailed).map(([baseUrl, timestamp]) => [
+    normalizeBaseUrl5(baseUrl),
+    timestamp
+  ]));
+  const providersOnCooldown = rawProvidersOnCooldown.map((entry) => ({
+    baseUrl: normalizeBaseUrl5(entry.baseUrl),
+    timestamp: entry.timestamp
+  }));
   store.setState({
     modelsFromAllProviders,
     lastUsedModel,
@@ -26665,7 +26835,10 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     routstr21Models,
     lastRoutstr21ModelsUpdate,
     cachedReceiveTokens,
-    clientIds
+    clientIds,
+    failedProviders,
+    lastFailed,
+    providersOnCooldown
   });
 }, createSdkStore = ({
   driver
@@ -26974,11 +27147,11 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
     this.balanceManager = new BalanceManager(walletAdapter, storageAdapter, providerRegistry);
     this.cashuSpender = new CashuSpender(walletAdapter, storageAdapter, providerRegistry, this.balanceManager);
     this.streamProcessor = new StreamProcessor;
-    this.providerManager = new ProviderManager(providerRegistry);
     this.alertLevel = alertLevel;
     this.mode = mode;
     this.usageTrackingDriver = options.usageTrackingDriver;
     this.sdkStore = options.sdkStore;
+    this.providerManager = options.providerManager ?? new ProviderManager(providerRegistry, this.sdkStore);
   }
   cashuSpender;
   balanceManager;
@@ -27395,6 +27568,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         const currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1000 : currentBalanceInfo.amount;
         const shortfall = Math.max(0, params.requiredSats - currentBalance);
         topupAmount = shortfall > 0 ? shortfall : params.requiredSats;
+        this._log("DEBUG", `The shortfall is: ${shortfall}. requiredSats: ${params.requiredSats}. Current Balance: ${currentBalance} `);
       } catch (e) {
         this._log("WARN", "Could not get current token balance for topup calculation:", e);
       }
@@ -27477,12 +27651,20 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
         tryNextProvider = true;
       }
     }
+    if (status === 401 && this.mode === "apikeys") {
+      this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: Checking balance for ${baseUrl}, key preview=${token}`);
+      const latestBalanceInfo = await this.balanceManager.getTokenBalance(token, baseUrl);
+      if (latestBalanceInfo.isInvalidApiKey) {
+        this.storageAdapter.removeApiKey(baseUrl);
+        tryNextProvider = true;
+      }
+    }
     if ((status === 401 || status === 403 || status === 413 || status === 400 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
       this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: Status ${status} (auth/server error), attempting refund for ${baseUrl}, mode=${this.mode}`);
       if (this.mode === "apikeys") {
         this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`);
-        const initialBalance = await this.balanceManager.getTokenBalance(token, baseUrl);
-        this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${initialBalance.amount}`);
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(token, baseUrl);
+        this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${latestBalanceInfo.amount}`);
         const refundResult = await this.balanceManager.refundApiKey({
           mintUrl,
           baseUrl,
@@ -27490,7 +27672,7 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
           forceRefund: true
         });
         this._log("DEBUG", `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`);
-        if (!refundResult.success && initialBalance.amount > 0) {
+        if (!refundResult.success && latestBalanceInfo.amount > 0) {
           throw new ProviderError(baseUrl, status, refundResult.message ?? "Unknown error");
         }
       }
@@ -27585,7 +27767,6 @@ var import_rxjs24, InsufficientBalanceError, ProviderError, MintUnreachableError
       try {
         const xcashuResults = await this.cashuSpender.refundXcashuTokens(mintUrl);
         this._log("DEBUG", "Refund xcashu tokens results:", xcashuResults);
-        const results = await this.cashuSpender.refundProviders(mintUrl);
       } catch (error) {
         this._log("ERROR", "Failed to refund providers:", error);
       }
@@ -27986,7 +28167,10 @@ var init_dist3 = __esm(() => {
     LAST_ROUTSTR21_MODELS_UPDATE: "lastRoutstr21ModelsUpdate",
     CACHED_RECEIVE_TOKENS: "cached_receive_tokens",
     USAGE_TRACKING: "usage_tracking",
-    CLIENT_IDS: "client_ids"
+    CLIENT_IDS: "client_ids",
+    FAILED_PROVIDERS: "failed_providers",
+    LAST_FAILED: "last_failed",
+    PROVIDERS_ON_COOLDOWN: "providers_on_cooldown"
   };
   isBrowser2 = typeof indexedDB !== "undefined";
 });
@@ -27994,7 +28178,7 @@ var init_dist3 = __esm(() => {
 // src/daemon/index.ts
 init_dist3();
 import { createServer } from "http";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 
 // src/utils/config.ts
 var HOME = process.env.HOME || process.env.USERPROFILE || "";
@@ -28003,7 +28187,7 @@ var SOCKET_PATH = process.env.ROUTSTRD_SOCKET || `${CONFIG_DIR}/routstrd.sock`;
 var PID_FILE = process.env.ROUTSTRD_PID || `${CONFIG_DIR}/routstrd.pid`;
 var DB_PATH = `${CONFIG_DIR}/routstr.db`;
 var CONFIG_FILE = `${CONFIG_DIR}/config.json`;
-var LOG_FILE = `${CONFIG_DIR}/routstrd.log`;
+var LOGS_DIR = `${CONFIG_DIR}/logs`;
 var DEFAULT_CONFIG = {
   port: 8008,
   provider: null,
@@ -28017,10 +28201,16 @@ import { existsSync } from "fs";
 import { join as join2 } from "path";
 var HOME2 = process.env.HOME || process.env.USERPROFILE || "";
 var LOG_DIR = process.env.ROUTSTRD_DIR || `${HOME2}/.routstrd`;
-var LOG_FILE2 = join2(LOG_DIR, "routstrd.log");
+var LOGS_DIR2 = join2(LOG_DIR, "logs");
+function getLogFileForDate(date = new Date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return join2(LOGS_DIR2, `${year}-${month}-${day}.log`);
+}
 async function ensureLogDir() {
-  if (!existsSync(LOG_DIR)) {
-    await mkdir(LOG_DIR, { recursive: true });
+  if (!existsSync(LOGS_DIR2)) {
+    await mkdir(LOGS_DIR2, { recursive: true });
   }
 }
 async function writeLog(level, ...args) {
@@ -28042,8 +28232,9 @@ ${a.stack}` : ""}`;
   }).join(" ");
   const line = `[${timestamp}] [${level}] ${message}
 `;
+  const logFile = getLogFileForDate(new Date(timestamp));
   try {
-    await appendFile(LOG_FILE2, line);
+    await appendFile(logFile, line);
   } catch (error) {
     console.error("Failed to write log:", error);
   }
@@ -28053,6 +28244,9 @@ var logger3 = {
     console.log(...args);
     writeLog("INFO", ...args);
   },
+  debug: (...args) => {
+    writeLog("DEBUG", ...args);
+  },
   error: (...args) => {
     console.error(...args);
     writeLog("ERROR", ...args);
@@ -28159,7 +28353,10 @@ var SDK_STORAGE_KEYS2 = {
   LAST_ROUTSTR21_MODELS_UPDATE: "lastRoutstr21ModelsUpdate",
   CACHED_RECEIVE_TOKENS: "cached_receive_tokens",
   USAGE_TRACKING: "usage_tracking",
-  CLIENT_IDS: "client_ids"
+  CLIENT_IDS: "client_ids",
+  FAILED_PROVIDERS: "failed_providers",
+  LAST_FAILED: "last_failed",
+  PROVIDERS_ON_COOLDOWN: "providers_on_cooldown"
 };
 var MIGRATION_MARKER_KEY32 = "usage_tracking_migration_v1";
 var normalizeBaseUrl32 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
@@ -28315,9 +28512,6 @@ var createBunSqliteUsageTrackingDriver2 = (options = {}) => {
   };
 };
 
-// src/daemon/wallet/index.ts
-import { spawn } from "child_process";
-
 // node_modules/@scure/base/index.js
 /*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 function isBytes3(a) {
@@ -33719,91 +33913,232 @@ function Ir(s) {
   return `authA${Re(t)}`;
 }
 
-// src/daemon/wallet/index.ts
-async function runWalletCommand(args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn("cocod", args, {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
+// src/daemon/wallet/cocod-client.ts
+import { createHash } from "crypto";
+var DEFAULT_CONFIG_DIR = `${process.env.HOME || process.env.USERPROFILE || ""}/.cocod`;
+var DEFAULT_SOCKET_PATH = process.env.COCOD_SOCKET || `${DEFAULT_CONFIG_DIR}/cocod.sock`;
+
+class CocodHttpError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "CocodHttpError";
+    this.status = status;
+  }
+}
+function resolveCocodExecutable(cocodPath) {
+  const trimmed = cocodPath?.trim();
+  return trimmed || "cocod";
+}
+function normalizeBalances(output4) {
+  if (!output4)
+    return {};
+  return Object.fromEntries(Object.entries(output4).map(([mintUrl, value]) => {
+    if (typeof value === "number") {
+      return [mintUrl, value];
+    }
+    return [mintUrl, Number(value?.sats ?? 0)];
+  }));
+}
+function parseMintList(output4) {
+  return (output4 || "").split(`
+`).map((line) => line.trim()).filter(Boolean);
+}
+function delay(ms2) {
+  return new Promise((resolve) => setTimeout(resolve, ms2));
+}
+function toErrorText(value) {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (value === null || value === undefined) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function tokenFingerprint(token) {
+  return createHash("sha256").update(token).digest("hex").slice(0, 12);
+}
+function createCocodClient(options = {}) {
+  const executable = resolveCocodExecutable(options.cocodPath);
+  const socketPath = options.socketPath || DEFAULT_SOCKET_PATH;
+  const fetchImpl = options.fetchImpl || fetch;
+  const pollIntervalMs = options.pollIntervalMs ?? 100;
+  const startupTimeoutMs = options.startupTimeoutMs ?? 5000;
+  const spawnDaemon = options.spawnDaemon || ((args, env) => {
+    const proc = Bun.spawn(args, {
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+      detached: true,
+      env
     });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
+    proc.unref();
+    return proc;
+  });
+  let startPromise = null;
+  async function fetchJson(path, init = {}) {
+    const method = init.method || "GET";
+    const requestInit = {
+      ...init,
+      unix: socketPath
+    };
+    const response = await fetchImpl(`http://localhost${path}`, requestInit);
+    const rawText = await response.text();
+    if (!rawText.trim()) {
+      throw new CocodHttpError(response.ok ? 502 : response.status, `Empty response from cocod for ${method} ${path}`);
+    }
+    let data;
+    try {
+      data = JSON.parse(rawText);
+    } catch {
+      throw new CocodHttpError(response.ok ? 502 : response.status, `Invalid JSON response from cocod for ${method} ${path}`);
+    }
+    if (!data || typeof data !== "object") {
+      throw new CocodHttpError(response.ok ? 502 : response.status, `Unexpected response shape from cocod for ${method} ${path}`);
+    }
+    const errorMessage = toErrorText(data.error);
+    if (errorMessage) {
+      throw new CocodHttpError(response.ok ? 400 : response.status, errorMessage);
+    }
+    if (!response.ok) {
+      throw new CocodHttpError(response.status, data.error || response.statusText || `HTTP ${response.status}`);
+    }
+    return data;
+  }
+  async function pingInternal() {
+    try {
+      await fetchJson("/ping");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async function startDaemon() {
+    const env = { ...process.env, COCOD_SOCKET: socketPath };
+    const proc = spawnDaemon([executable, "daemon"], env);
+    const maxPolls = Math.ceil(startupTimeoutMs / pollIntervalMs);
+    let exitCode = null;
+    proc.exited.then((code) => {
+      exitCode = code;
     });
-    child.on("error", (error) => reject(error));
-    child.on("close", (code) => {
-      if (code && code !== 0) {
-        reject(new Error(stderr.trim() || stdout.trim() || "Wallet CLI failed"));
+    for (let i4 = 0;i4 < maxPolls; i4++) {
+      await delay(pollIntervalMs);
+      if (exitCode !== null) {
+        throw new Error(`cocod daemon exited early with code ${exitCode}`);
+      }
+      if (await pingInternal()) {
+        logger3.debug(`Connected to cocod daemon on ${socketPath}`);
         return;
       }
-      resolve(stdout.trim());
-    });
-  });
-}
-function parseBalances(output4) {
-  const trimmed = output4.trim();
-  if (!trimmed)
-    return {};
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (parsed && typeof parsed === "object") {
-      return Object.fromEntries(Object.entries(parsed).map(([mintUrl, value]) => {
-        if (typeof value === "number") {
-          return [mintUrl, value];
-        }
-        if (value && typeof value === "object" && "sats" in value) {
-          return [mintUrl, Number(value.sats ?? 0)];
-        }
-        return [mintUrl, 0];
-      }));
     }
-  } catch {}
-  const balances = {};
-  trimmed.split(`
-`).map((line) => line.trim()).forEach((line) => {
-    const match = line.match(/^(\S+):\s+(\d+)\s+s$/);
-    const mintUrl = match?.[1];
-    const amount = match?.[2];
-    if (mintUrl && amount) {
-      balances[mintUrl] = Number.parseInt(amount, 10);
+    throw new Error(`cocod daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds`);
+  }
+  async function ensureDaemonRunning() {
+    if (await pingInternal()) {
+      return;
     }
-  });
-  return balances;
-}
-function parseMints(output4) {
-  return output4.split(`
-`).map((line) => line.trim()).map((line) => {
-    const urlMatch = line.match(/https?:\/\/\S+/i);
-    if (!urlMatch)
-      return null;
-    const trustedMatch = line.match(/trusted:\s*(true|false)/i);
-    const trustedValue = trustedMatch?.[1];
-    return {
-      url: urlMatch[0],
-      trusted: trustedMatch ? trustedValue?.toLowerCase() === "true" : false
-    };
-  }).filter((entry) => Boolean(entry));
-}
-function pickTokenLine(output4) {
-  const lines = output4.split(`
-`).map((line) => line.trim()).filter(Boolean);
-  return lines[lines.length - 1] || "";
+    if (!startPromise) {
+      logger3.debug(`Starting cocod daemon via ${executable}...`);
+      startPromise = startDaemon().finally(() => {
+        startPromise = null;
+      });
+    }
+    await startPromise;
+  }
+  async function callDaemon(path, init = {}) {
+    await ensureDaemonRunning();
+    const response = await fetchJson(path, init);
+    return response.output;
+  }
+  function post(path, body) {
+    return callDaemon(path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  }
+  return {
+    async ping() {
+      return pingInternal();
+    },
+    async getStatus() {
+      return callDaemon("/status");
+    },
+    async unlock(passphrase) {
+      return post("/unlock", { passphrase });
+    },
+    async getBalances() {
+      const output4 = await callDaemon("/balance");
+      return normalizeBalances(output4);
+    },
+    async receiveCashu(token) {
+      logger3.debug(`[receiveCashu] Receiving Cashu token ${tokenFingerprint(token)}`);
+      const message = await callDaemon("/receive/cashu", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token })
+      });
+      if (typeof message !== "string" || !message.trim()) {
+        throw new CocodHttpError(502, "Unexpected response from cocod while receiving Cashu token.");
+      }
+      logger3.debug(`[receiveCashu] Full response.output:`, message);
+      return message;
+    },
+    async receiveBolt11(amount, mintUrl) {
+      return post("/receive/bolt11", { amount, mintUrl });
+    },
+    async sendCashu(amount, mintUrl) {
+      return post("/send/cashu", { amount, mintUrl });
+    },
+    async sendBolt11(invoice, mintUrl) {
+      return post("/send/bolt11", { invoice, mintUrl });
+    },
+    async listMints() {
+      const output4 = await callDaemon("/mints/list");
+      return parseMintList(output4);
+    },
+    async addMint(url2) {
+      return post("/mints/add", { url: url2 });
+    },
+    async getMintInfo(url2) {
+      return post("/mints/info", { url: url2 });
+    }
+  };
 }
-async function createWalletAdapter() {
+
+// src/daemon/wallet/index.ts
+function decodeCashuTokenAmount(token) {
+  const decoded = ar(token);
+  const amount = decoded?.proofs?.reduce((sum, proof) => sum + proof.amount, 0) ?? 0;
+  const unit = decoded?.unit === "msat" ? "msat" : "sat";
+  return { amount, unit };
+}
+async function createWalletAdapter(options = {}) {
+  const client2 = options.walletClient || createCocodClient({ cocodPath: options.cocodPath });
   let activeMintUrl = null;
   let mintUnits = {};
-  const walletAdapter = {
-    async getBalances() {
-      const output4 = await runWalletCommand(["balance"]);
-      const balances = parseBalances(output4);
-      mintUnits = Object.fromEntries(Object.keys(balances).map((mintUrl) => [mintUrl, "sat"]));
+  async function syncMintState(balances) {
+    const nextBalances = balances || await client2.getBalances();
+    mintUnits = Object.fromEntries(Object.keys(nextBalances).map((mintUrl) => [mintUrl, "sat"]));
+    try {
+      const mints = await client2.listMints();
+      activeMintUrl = mints[0] || Object.keys(nextBalances)[0] || null;
+    } catch (error) {
+      logger3.error("Failed to list cocod mints:", error);
       if (!activeMintUrl) {
-        activeMintUrl = Object.keys(balances)[0] || null;
+        activeMintUrl = Object.keys(nextBalances)[0] || null;
       }
-      return balances;
+    }
+    return nextBalances;
+  }
+  const walletAdapter = {
+    async getBalances() {
+      return syncMintState();
     },
     getMintUnits() {
       return mintUnits;
@@ -33817,18 +34152,7 @@ async function createWalletAdapter() {
       const retryErrorPattern = "Proof already reserved by operation";
       for (let attempt = 0;attempt <= maxRetries; attempt++) {
         try {
-          const output4 = await runWalletCommand([
-            "send",
-            "cashu",
-            String(amount),
-            "--mint-url",
-            mintUrl
-          ]);
-          const token = pickTokenLine(output4);
-          if (!token) {
-            throw new Error("Wallet CLI did not return a token.");
-          }
-          return token;
+          return await client2.sendCashu(amount, mintUrl);
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
           const shouldRetry = attempt < maxRetries && errorMessage.includes(retryErrorPattern);
@@ -33845,28 +34169,25 @@ async function createWalletAdapter() {
     },
     async receiveToken(token) {
       try {
-        await runWalletCommand(["receive", "cashu", token]);
-        const decoded = ar(token);
-        const amount = decoded?.proofs?.reduce((sum, proof) => sum + proof.amount, 0);
-        const unit = decoded?.unit === "msat" ? "msat" : "sat";
-        return { success: true, amount: amount ?? 0, unit };
+        const message = await client2.receiveCashu(token);
+        const { amount, unit } = decodeCashuTokenAmount(token);
+        return { success: true, amount, unit, message };
       } catch (error) {
-        console.log("Eerro in receive", error);
         const errorMessage = error instanceof Error ? error.message : String(error);
-        const message = errorMessage.includes("Failed to fetch mint") ? errorMessage : undefined;
-        return { success: false, amount: 0, unit: "sat", message };
+        logger3.error("Error in walletAdapter receiveToken:", error);
+        return { success: false, amount: 0, unit: "sat", message: errorMessage };
       }
-    },
-    isUsingNip60() {
-      return false;
     }
   };
   try {
-    const mintsOutput = await runWalletCommand(["mints", "list"]);
-    const mints = parseMints(mintsOutput);
-    activeMintUrl = mints.find((mint) => mint.trusted)?.url || mints[0]?.url || null;
+    const [balances, mints] = await Promise.all([
+      client2.getBalances(),
+      client2.listMints().catch(() => [])
+    ]);
+    mintUnits = Object.fromEntries(Object.keys(balances).map((mintUrl) => [mintUrl, "sat"]));
+    activeMintUrl = mints[0] || Object.keys(balances)[0] || null;
   } catch (error) {
-    logger3.error("Failed to read mints from wallet:", error);
+    logger3.error("Failed to initialize wallet adapter state:", error);
   }
   return walletAdapter;
 }
@@ -33908,6 +34229,11 @@ function createModelService(modelManager) {
 
 // src/daemon/http/index.ts
 init_dist3();
+import { randomBytes as randomBytes4 } from "crypto";
+function generateApiKey() {
+  const bytes4 = randomBytes4(24);
+  return `sk-${bytes4.toString("hex")}`;
+}
 async function readBody(req) {
   return new Promise((resolve, reject) => {
     let data = "";
@@ -33918,60 +34244,255 @@ async function readBody(req) {
     req.on("error", reject);
   });
 }
+async function readJsonBody(req) {
+  const bodyText = await readBody(req);
+  if (!bodyText) {
+    return {};
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch {
+    throw new CocodHttpError(400, "Invalid JSON body.");
+  }
+}
 function parseLimit(value, fallback = 10) {
   const requested = Number.parseInt(value || String(fallback), 10);
-  return Number.isFinite(requested) && requested > 0 ? Math.min(requested, 1000) : fallback;
+  return Number.isFinite(requested) && requested > 0 ? Math.min(requested, 1e5) : fallback;
+}
+function sendJson(res, status, payload) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function getWalletStateMessage(state) {
+  switch (state) {
+    case "LOCKED":
+      return "Wallet is locked. Unlock it before performing wallet operations.";
+    case "UNINITIALIZED":
+      return "Wallet is not initialized. Run 'routstrd onboard' first.";
+    case "ERROR":
+      return "Wallet is in an error state.";
+    default:
+      return "Wallet is unavailable.";
+  }
+}
+function respondWithError(res, error, fallbackStatus = 500) {
+  if (error instanceof CocodHttpError) {
+    sendJson(res, error.status, { error: error.message });
+    return;
+  }
+  sendJson(res, fallbackStatus, { error: toErrorMessage(error) });
+}
+async function respond(res, getPayload) {
+  try {
+    sendJson(res, 200, await getPayload());
+  } catch (error) {
+    respondWithError(res, error);
+  }
+}
+function requireStringField(body, field) {
+  const value = body[field];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function getRequiredStringField(body, field) {
+  const value = requireStringField(body, field);
+  if (!value) {
+    throw new CocodHttpError(400, `Missing required '${field}' field.`);
+  }
+  return value;
+}
+function getRequiredPositiveNumberField(body, field) {
+  const value = body[field];
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number.parseInt(value.trim(), 10);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  throw new CocodHttpError(400, `Missing required '${field}' field.`);
+}
+function optionalStringField(body, field) {
+  const value = body[field];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function getCurrentMode(deps) {
+  const stateMode = deps.store.getState()?.mode;
+  return stateMode || deps.mode || "apikeys";
+}
+async function buildStatusOutput(deps) {
+  const mode = getCurrentMode(deps);
+  try {
+    const walletState = await deps.walletClient.getStatus();
+    if (walletState !== "UNLOCKED") {
+      return {
+        daemon: "running",
+        wallet: "error",
+        walletState,
+        mode,
+        error: getWalletStateMessage(walletState)
+      };
+    }
+    const balances = await deps.walletAdapter.getBalances();
+    return {
+      daemon: "running",
+      wallet: "connected",
+      walletState,
+      balances,
+      mode
+    };
+  } catch (error) {
+    return {
+      daemon: "running",
+      wallet: "error",
+      walletState: "ERROR",
+      mode,
+      error: toErrorMessage(error)
+    };
+  }
+}
+async function buildWalletDetails(deps) {
+  const state = await deps.walletClient.getStatus();
+  if (state !== "UNLOCKED") {
+    return { state, ready: false };
+  }
+  const balances = await deps.walletAdapter.getBalances();
+  return {
+    state,
+    ready: true,
+    balances,
+    unit: "sat",
+    activeMint: deps.walletAdapter.getActiveMintUrl()
+  };
 }
 function createDaemonRequestHandler(deps) {
   return async function handler(req, res) {
     const host = req.headers.host || "localhost";
     const url2 = new URL(req.url || "/", `http://${host}`);
     if (req.method === "GET" && url2.pathname === "/health") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: true }));
+      sendJson(res, 200, { ok: true });
       return;
     }
     if (req.method === "GET" && url2.pathname === "/ping") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ output: "pong" }));
+      sendJson(res, 200, { output: "pong" });
       return;
     }
     if (req.method === "GET" && url2.pathname === "/status") {
-      try {
-        const balancesOutput = await deps.runWalletCommand(["balance"]);
-        const balances = deps.parseBalances(balancesOutput);
-        const state = deps.store.getState();
-        const mode = state.mode || deps.mode || "apikeys";
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
+      const output4 = await buildStatusOutput(deps);
+      sendJson(res, 200, { output: output4 });
+      return;
+    }
+    if (req.method === "GET" && url2.pathname === "/wallet/status") {
+      await respond(res, async () => ({
+        output: await buildWalletDetails(deps)
+      }));
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/wallet/unlock") {
+      await respond(res, async () => {
+        const body = await readJsonBody(req);
+        const passphrase = getRequiredStringField(body, "passphrase");
+        const message = await deps.walletClient.unlock(passphrase);
+        const state = await deps.walletClient.getStatus();
+        return { output: { message, state } };
+      });
+      return;
+    }
+    if (req.method === "GET" && url2.pathname === "/wallet/balance") {
+      await respond(res, async () => {
+        const balances = await deps.walletAdapter.getBalances();
+        return {
           output: {
-            daemon: "running",
-            wallet: "connected",
-            mode,
-            balances
+            balances,
+            unit: "sat",
+            activeMint: deps.walletAdapter.getActiveMintUrl(),
+            walletState: "UNLOCKED"
           }
-        }));
-      } catch (error) {
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
+        };
+      });
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/wallet/receive/cashu") {
+      await respond(res, async () => {
+        const body = await readJsonBody(req);
+        const token = getRequiredStringField(body, "token");
+        const message = await deps.walletClient.receiveCashu(token);
+        const { amount, unit } = decodeCashuTokenAmount(token);
+        return { output: { message, amount, unit } };
+      });
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/wallet/receive/bolt11") {
+      await respond(res, async () => {
+        const body = await readJsonBody(req);
+        const amount = getRequiredPositiveNumberField(body, "amount");
+        const mintUrl = optionalStringField(body, "mintUrl");
+        const invoice = await deps.walletClient.receiveBolt11(amount, mintUrl);
+        return { output: { invoice, amount, mintUrl } };
+      });
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/wallet/send/cashu") {
+      await respond(res, async () => {
+        const body = await readJsonBody(req);
+        const amount = getRequiredPositiveNumberField(body, "amount");
+        const mintUrl = optionalStringField(body, "mintUrl");
+        const token = await deps.walletClient.sendCashu(amount, mintUrl);
+        return { output: { token, amount, mintUrl } };
+      });
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/wallet/send/bolt11") {
+      await respond(res, async () => {
+        const body = await readJsonBody(req);
+        const invoice = getRequiredStringField(body, "invoice");
+        const mintUrl = optionalStringField(body, "mintUrl");
+        const message = await deps.walletClient.sendBolt11(invoice, mintUrl);
+        return { output: { message, invoice, mintUrl } };
+      });
+      return;
+    }
+    if (req.method === "GET" && url2.pathname === "/wallet/mints") {
+      await respond(res, async () => {
+        const mints = await deps.walletClient.listMints();
+        return {
           output: {
-            daemon: "running",
-            wallet: "error",
-            error: String(error)
+            mints,
+            activeMint: mints[0] || null
           }
-        }));
-      }
+        };
+      });
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/wallet/mints") {
+      await respond(res, async () => {
+        const body = await readJsonBody(req);
+        const mintUrl = getRequiredStringField(body, "url");
+        const message = await deps.walletClient.addMint(mintUrl);
+        return { output: { message, url: mintUrl } };
+      });
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/wallet/mints/info") {
+      await respond(res, async () => {
+        const body = await readJsonBody(req);
+        const mintUrl = getRequiredStringField(body, "url");
+        const info = await deps.walletClient.getMintInfo(mintUrl);
+        return { output: { url: mintUrl, info } };
+      });
       return;
     }
     if (req.method === "GET" && url2.pathname === "/models") {
       try {
         const forceRefresh = url2.searchParams.get("refresh")?.toLowerCase() === "true";
         const models = await deps.getRoutstr21Models(forceRefresh);
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ output: { models } }));
+        sendJson(res, 200, { output: { models } });
       } catch (error) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: String(error) }));
+        sendJson(res, 500, { error: toErrorMessage(error) });
       }
       return;
     }
@@ -33979,20 +34500,17 @@ function createDaemonRequestHandler(deps) {
       try {
         const forceRefresh = url2.searchParams.get("refresh")?.toLowerCase() === "true";
         const models = await deps.getRoutstr21Models(forceRefresh);
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
+        sendJson(res, 200, {
           object: "list",
           data: models.map((model2) => ({ ...model2, object: "model" }))
-        }));
+        });
       } catch (error) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: String(error) }));
+        sendJson(res, 500, { error: toErrorMessage(error) });
       }
       return;
     }
     if (req.method === "POST" && url2.pathname === "/stop") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ output: "stopping" }));
+      sendJson(res, 200, { output: "stopping" });
       setTimeout(() => {
         deps.server.close(() => {
           process.exit(0);
@@ -34002,14 +34520,8 @@ function createDaemonRequestHandler(deps) {
     }
     if (req.method === "POST" && url2.pathname === "/refund") {
       try {
-        const bodyText = await readBody(req);
-        const body = bodyText ? JSON.parse(bodyText) : {};
-        const mintUrl = body.mintUrl;
-        if (!mintUrl) {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Missing required 'mintUrl' field." }));
-          return;
-        }
+        const body = await readJsonBody(req);
+        const mintUrl = getRequiredStringField(body, "mintUrl");
         const state = deps.store.getState();
         const pendingDistribution = (state.cachedTokens || []).map((t) => ({
           baseUrl: t.baseUrl,
@@ -34020,19 +34532,17 @@ function createDaemonRequestHandler(deps) {
           amount: k.balance || 0
         }));
         if (pendingDistribution.length === 0 && apiKeysStored.length === 0) {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({
+          sendJson(res, 200, {
             output: { message: "No pending tokens to refund", results: [] }
-          }));
+          });
           return;
         }
         const refundBaseUrls = pendingDistribution.map((p) => p.baseUrl).concat(apiKeysStored.map((p) => p.baseUrl));
         const { RoutstrClient: RoutstrClient2 } = await Promise.resolve().then(() => (init_dist3(), exports_dist));
         const client2 = new RoutstrClient2(deps.walletAdapter, deps.storageAdapter, deps.providerRegistry, "min", "apikeys");
         const spender = client2.getCashuSpender();
-        const results = await spender.refundProviders(mintUrl);
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
+        const results = await spender.refundProviders(mintUrl, true);
+        sendJson(res, 200, {
           output: {
             message: `Refunded to ${mintUrl}`,
             pendingTokens: pendingDistribution.length,
@@ -34042,29 +34552,25 @@ function createDaemonRequestHandler(deps) {
               success: r.success
             }))
           }
-        }));
+        });
       } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger3.error(`Refund error: ${message}`);
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: message }));
+        logger3.error(`Refund error: ${toErrorMessage(error)}`);
+        respondWithError(res, error);
       }
       return;
     }
     if (req.method === "GET" && url2.pathname === "/balance") {
       try {
         const balances = await deps.walletAdapter.getBalances();
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
+        sendJson(res, 200, {
           output: {
             balances,
             unit: "sat",
             activeMint: deps.walletAdapter.getActiveMintUrl()
           }
-        }));
+        });
       } catch (error) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: String(error) }));
+        respondWithError(res, error);
       }
       return;
     }
@@ -34090,14 +34596,120 @@ function createDaemonRequestHandler(deps) {
             balance: k.balance || 0
           }))
         ];
-        res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({
+        sendJson(res, 200, {
           output: {
             keys: keys2,
             total: totalWallet + totalCached + totalApiKeys,
             unit: "sat",
             apikeysCalled: apiKeys.length
           }
+        });
+      } catch (error) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(error) }));
+      }
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/providers/disable") {
+      try {
+        const bodyText = await readBody(req);
+        const body = bodyText ? JSON.parse(bodyText) : {};
+        const indices = body.indices;
+        if (!Array.isArray(indices)) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Missing or invalid 'indices' field (expected number[])."
+          }));
+          return;
+        }
+        const state = deps.store.getState();
+        const baseUrlsList = state.baseUrlsList || [];
+        const disabledProviders = [
+          ...state.disabledProviders || []
+        ];
+        const toDisable = [];
+        for (const idx of indices) {
+          if (typeof idx === "number" && idx >= 0 && idx < baseUrlsList.length) {
+            const baseUrl = baseUrlsList[idx];
+            if (!disabledProviders.includes(baseUrl)) {
+              disabledProviders.push(baseUrl);
+              toDisable.push(baseUrl);
+            }
+          }
+        }
+        deps.store.getState().setDisabledProviders(disabledProviders);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          output: {
+            message: `Disabled ${toDisable.length} provider(s)`,
+            disabled: toDisable
+          }
+        }));
+      } catch (error) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(error) }));
+      }
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/providers/enable") {
+      try {
+        const bodyText = await readBody(req);
+        const body = bodyText ? JSON.parse(bodyText) : {};
+        const indices = body.indices;
+        if (!Array.isArray(indices)) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Missing or invalid 'indices' field (expected number[])."
+          }));
+          return;
+        }
+        const state = deps.store.getState();
+        const baseUrlsList = state.baseUrlsList || [];
+        const disabledProviders = [
+          ...state.disabledProviders || []
+        ];
+        const toEnable = [];
+        for (const idx of indices) {
+          if (typeof idx === "number" && idx >= 0 && idx < baseUrlsList.length) {
+            const baseUrl = baseUrlsList[idx];
+            const pos = disabledProviders.indexOf(baseUrl);
+            if (pos !== -1) {
+              disabledProviders.splice(pos, 1);
+              toEnable.push(baseUrl);
+            }
+          }
+        }
+        deps.store.getState().setDisabledProviders(disabledProviders);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          output: {
+            message: `Enabled ${toEnable.length} provider(s)`,
+            enabled: toEnable
+          }
+        }));
+      } catch (error) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(error) }));
+      }
+      return;
+    }
+    if (req.method === "GET" && url2.pathname === "/clients") {
+      try {
+        const state = deps.store.getState();
+        const clientIds = state.clientIds || [];
+        const clients = clientIds.map((c) => ({
+          id: c.clientId,
+          name: c.name,
+          apiKey: c.apiKey,
+          createdAt: c.createdAt,
+          lastUsed: c.lastUsed
+        }));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          output: {
+            clients,
+            totalCount: clients.length
+          }
         }));
       } catch (error) {
         res.writeHead(500, { "Content-Type": "application/json" });
@@ -34105,6 +34717,65 @@ function createDaemonRequestHandler(deps) {
       }
       return;
     }
+    if (req.method === "POST" && url2.pathname === "/clients/add") {
+      try {
+        const bodyText = await readBody(req);
+        const body = bodyText ? JSON.parse(bodyText) : {};
+        const name = body.name;
+        if (!name || typeof name !== "string" || name.trim() === "") {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Missing required 'name' field (must be a non-empty string)."
+          }));
+          return;
+        }
+        const clientId = name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+        if (!clientId) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Invalid client name. Must contain alphanumeric characters."
+          }));
+          return;
+        }
+        const state = deps.store.getState();
+        const existingClients = state.clientIds || [];
+        const existingClient = existingClients.find((c) => c.clientId === clientId);
+        if (existingClient) {
+          res.writeHead(409, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: `Client with id '${clientId}' already exists.`
+          }));
+          return;
+        }
+        const apiKey = generateApiKey();
+        const newClient = {
+          clientId,
+          name: name.trim(),
+          apiKey,
+          createdAt: Date.now()
+        };
+        deps.store.getState().setClientIds((prev) => [
+          ...prev || [],
+          newClient
+        ]);
+        logger3.log(`Added client '${name}' with id '${clientId}'`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          output: {
+            message: `Client '${name}' added successfully`,
+            client: {
+              id: clientId,
+              name: name.trim(),
+              apiKey,
+              createdAt: newClient.createdAt
+            }
+          }
+        }));
+      } catch (error) {
+        respondWithError(res, error);
+      }
+      return;
+    }
     if (req.method === "GET" && url2.pathname === "/providers") {
       try {
         const state = deps.store.getState();
@@ -34115,11 +34786,12 @@ function createDaemonRequestHandler(deps) {
           baseUrl,
           disabled: disabledProviders.includes(baseUrl)
         }));
+        const activeDisabledCount = providers.filter((p) => p.disabled).length;
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({
           output: {
             providers,
-            disabledCount: disabledProviders.length,
+            disabledCount: activeDisabledCount,
             totalCount: baseUrlsList.length
           }
         }));
@@ -34212,22 +34884,82 @@ function createDaemonRequestHandler(deps) {
       }
       return;
     }
-    if (req.method === "GET" && url2.pathname === "/usage") {
+    if (req.method === "GET" && url2.pathname === "/clients") {
       try {
-        const usageDriver = deps.usageTrackingDriver;
-        const limit2 = parseLimit(url2.searchParams.get("limit"));
-        const entries = await usageDriver.list({ limit: limit2 });
-        const totalEntries = await usageDriver.count();
-        const totalSatsCost = (await usageDriver.list()).reduce((sum, entry) => sum + (entry.satsCost || 0), 0);
-        const recentSatsCost = entries.reduce((sum, entry) => sum + (entry.satsCost || 0), 0);
+        const state = deps.store.getState();
+        const clientIds = state.clientIds || [];
+        const clients = clientIds.map((c) => ({
+          id: c.clientId,
+          name: c.name,
+          apiKey: c.apiKey,
+          createdAt: c.createdAt,
+          lastUsed: c.lastUsed
+        }));
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({
           output: {
-            entries,
-            totalEntries,
-            totalSatsCost,
-            recentSatsCost,
-            limit: limit2
+            clients,
+            totalCount: clients.length
+          }
+        }));
+      } catch (error) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(error) }));
+      }
+      return;
+    }
+    if (req.method === "POST" && url2.pathname === "/clients/add") {
+      try {
+        const bodyText = await readBody(req);
+        const body = bodyText ? JSON.parse(bodyText) : {};
+        const name = body.name;
+        if (!name || typeof name !== "string" || name.trim() === "") {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Missing required 'name' field (must be a non-empty string)."
+          }));
+          return;
+        }
+        const clientId = name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+        if (!clientId) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Invalid client name. Must contain alphanumeric characters."
+          }));
+          return;
+        }
+        const state = deps.store.getState();
+        const existingClients = state.clientIds || [];
+        const existingClient = existingClients.find((c) => c.clientId === clientId);
+        if (existingClient) {
+          res.writeHead(409, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: `Client with id '${clientId}' already exists.`
+          }));
+          return;
+        }
+        const apiKey = generateApiKey();
+        const newClient = {
+          clientId,
+          name: name.trim(),
+          apiKey,
+          createdAt: Date.now()
+        };
+        deps.store.getState().setClientIds((prev) => [
+          ...prev || [],
+          newClient
+        ]);
+        logger3.log(`Added client '${name}' with id '${clientId}'`);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          output: {
+            message: `Client '${name}' added successfully`,
+            client: {
+              id: clientId,
+              name: name.trim(),
+              apiKey,
+              createdAt: newClient.createdAt
+            }
           }
         }));
       } catch (error) {
@@ -34236,14 +34968,25 @@ function createDaemonRequestHandler(deps) {
       }
       return;
     }
+    if (req.method === "GET" && url2.pathname === "/usage") {
+      try {
+        const output4 = await deps.usageTrackingDriver.list({
+          limit: parseLimit(url2.searchParams.get("limit"))
+        });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ output: output4 }));
+      } catch (error) {
+        sendJson(res, 500, { error: toErrorMessage(error) });
+      }
+      return;
+    }
     if (req.method === "GET" && url2.pathname === "/usagePi") {
       try {
         const timestamp = (url2.searchParams.get("timestamp") || "").trim();
         if (!timestamp) {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({
+          sendJson(res, 400, {
             error: "Missing required 'timestamp' query parameter."
-          }));
+          });
           return;
         }
         const usageDriver = deps.usageTrackingDriver;
@@ -34267,33 +35010,29 @@ function createDaemonRequestHandler(deps) {
           }
         }));
       } catch (error) {
-        res.writeHead(500, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ error: String(error) }));
+        sendJson(res, 500, { error: toErrorMessage(error) });
       }
       return;
     }
-    if (req.method !== "POST") {
+    if (req.method !== "POST" && !url2.pathname.startsWith("/clients")) {
       res.writeHead(405, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Only POST is supported." }));
       return;
     }
     let requestBody = {};
     try {
-      const bodyText = await readBody(req);
-      requestBody = bodyText ? JSON.parse(bodyText) : {};
+      requestBody = await readJsonBody(req);
     } catch (error) {
-      res.writeHead(400, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({
+      sendJson(res, 400, {
         error: "Invalid JSON body.",
-        details: error instanceof Error ? error.message : String(error)
-      }));
+        details: toErrorMessage(error)
+      });
       return;
     }
     const bodyObj = requestBody;
     const modelId = typeof bodyObj.model === "string" ? bodyObj.model : "";
     if (!modelId) {
-      res.writeHead(400, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ error: "Missing required 'model' field." }));
+      sendJson(res, 400, { error: "Missing required 'model' field." });
       return;
     }
     const forcedProvider = url2.searchParams.get("provider") || req.headers["x-routstr-provider"] || deps.provider || undefined;
@@ -34323,6 +35062,7 @@ function createDaemonRequestHandler(deps) {
         mode: deps.mode,
         usageTrackingDriver: deps.usageTrackingDriver,
         sdkStore: deps.store,
+        providerManager: deps.providerManager,
         res
       });
       return;
@@ -34348,7 +35088,287 @@ function createDaemonRequestHandler(deps) {
   };
 }
 
+// src/integrations/opencode.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+
+// src/integrations/registry.ts
+import { randomBytes as randomBytes5 } from "crypto";
+import { join as join4 } from "path";
+
+// src/integrations/pi.ts
+import { existsSync as existsSync3, mkdirSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+async function installPiIntegration(config, store, integrationConfig) {
+  const { clientId, name, configPath } = integrationConfig;
+  logger3.log(`
+Installing routstr models in pi models.json...`);
+  const port = config.port || 8008;
+  const baseUrl = `http://localhost:${port}/v1`;
+  const state = store.getState();
+  const existingClient = (state.clientIds || []).find((c) => c.clientId === clientId);
+  let apiKey;
+  if (existingClient) {
+    apiKey = existingClient.apiKey;
+    logger3.log(`Using existing API key for ${name}`);
+  } else {
+    apiKey = generateApiKey2();
+    store.getState().setClientIds((prev) => [
+      ...prev || [],
+      {
+        clientId,
+        name,
+        apiKey,
+        createdAt: Date.now()
+      }
+    ]);
+    logger3.log(`Created new API key for ${name}`);
+  }
+  let piConfig = {};
+  try {
+    if (existsSync3(configPath)) {
+      const content2 = await readFile(configPath, "utf-8");
+      piConfig = JSON.parse(content2);
+    }
+  } catch {
+    piConfig = {};
+  }
+  if (!piConfig.providers) {
+    piConfig.providers = {};
+  }
+  try {
+    mkdirSync(dirname(configPath), { recursive: true });
+    const response = await fetch(`http://localhost:${port}/models`);
+    const data = await response.json();
+    const models = data.output?.models || [];
+    if (models.length === 0) {
+      logger3.log("No models found from routstr daemon.");
+      return;
+    }
+    const providerModels = models.map((model2) => ({
+      id: model2.id
+    }));
+    piConfig.providers["routstr"] = {
+      baseUrl,
+      api: "openai-completions",
+      apiKey,
+      models: providerModels
+    };
+    await writeFile(configPath, JSON.stringify(piConfig, null, 2));
+    logger3.log(`Added "routstr" provider with ${models.length} models to pi models.json`);
+  } catch (error) {
+    logger3.error("Failed to install models in pi models.json:", error);
+  }
+}
+
+// src/integrations/openclaw.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var OPENCLAW_PROVIDER_ID = "routstr";
+var OPENCLAW_DEFAULT_PRIMARY_MODEL = "routstr/minimax-m2.5";
+var OPENCLAW_DEFAULT_FALLBACK_MODEL = "routstr/kimi-k2.5";
+async function installOpenClawIntegration(config, store, integrationConfig) {
+  const { clientId, name, configPath } = integrationConfig;
+  logger3.log(`
+Installing routstr models in openclaw.json...`);
+  const port = config.port || 8008;
+  const state = store.getState();
+  const existingClient = (state.clientIds || []).find((c) => c.clientId === clientId);
+  let apiKey;
+  if (existingClient) {
+    apiKey = existingClient.apiKey;
+    logger3.log(`Using existing API key for ${name}`);
+  } else {
+    apiKey = generateApiKey2();
+    store.getState().setClientIds((prev) => [
+      ...prev || [],
+      {
+        clientId,
+        name,
+        apiKey,
+        createdAt: Date.now()
+      }
+    ]);
+    logger3.log(`Created new API key for ${name}`);
+  }
+  let openclawConfig = {};
+  try {
+    if (existsSync4(configPath)) {
+      const content2 = await readFile2(configPath, "utf-8");
+      openclawConfig = JSON.parse(content2);
+    }
+  } catch {
+    openclawConfig = {};
+  }
+  if (!openclawConfig.models) {
+    openclawConfig.models = {};
+  }
+  if (!openclawConfig.models.providers) {
+    openclawConfig.models.providers = {};
+  }
+  if (!openclawConfig.agents) {
+    openclawConfig.agents = {};
+  }
+  if (!openclawConfig.agents.defaults) {
+    openclawConfig.agents.defaults = {};
+  }
+  try {
+    mkdirSync2(dirname2(configPath), { recursive: true });
+    const response = await fetch(`http://localhost:${port}/models`);
+    const data = await response.json();
+    const models = data.output?.models || [];
+    if (models.length === 0) {
+      logger3.log("No models found from routstr daemon.");
+      return;
+    }
+    const providerModels = models.map((model2) => ({
+      id: model2.id,
+      name: model2.name || model2.id,
+      reasoning: true
+    }));
+    openclawConfig.models.providers[OPENCLAW_PROVIDER_ID] = {
+      baseUrl: `http://localhost:${port}/v1`,
+      apiKey,
+      api: "openai-completions",
+      models: providerModels
+    };
+    const availableModelIds = new Set(providerModels.map((model2) => model2.id));
+    const primaryId = availableModelIds.has("gpt-5.3-codex") ? "gpt-5.3-codex" : providerModels[0]?.id;
+    const fallbackId = availableModelIds.has("minimax-m2.5") ? "minimax-m2.5" : providerModels.find((model2) => model2.id !== primaryId)?.id;
+    if (primaryId) {
+      openclawConfig.agents.defaults.model = {
+        primary: `${OPENCLAW_PROVIDER_ID}/${primaryId}`,
+        fallbacks: fallbackId ? [`${OPENCLAW_PROVIDER_ID}/${fallbackId}`] : []
+      };
+    } else {
+      openclawConfig.agents.defaults.model = {
+        primary: OPENCLAW_DEFAULT_PRIMARY_MODEL,
+        fallbacks: [OPENCLAW_DEFAULT_FALLBACK_MODEL]
+      };
+    }
+    await writeFile2(configPath, JSON.stringify(openclawConfig, null, 2));
+    logger3.log(`Added "${OPENCLAW_PROVIDER_ID}" provider with ${models.length} models to openclaw.json`);
+  } catch (error) {
+    logger3.error("Failed to install models in openclaw.json:", error);
+  }
+}
+
+// src/integrations/registry.ts
+function generateApiKey2() {
+  const bytes4 = randomBytes5(24);
+  return `sk-${bytes4.toString("hex")}`;
+}
+var CLIENT_CONFIGS = {
+  opencode: {
+    clientId: "opencode",
+    name: "OpenCode",
+    configPath: join4(process.env.HOME || "", ".config/opencode/opencode.json")
+  },
+  "pi-agent": {
+    clientId: "pi-agent",
+    name: "Pi Agent",
+    configPath: join4(process.env.HOME || "", ".pi/agent/models.json")
+  },
+  openclaw: {
+    clientId: "openclaw",
+    name: "OpenClaw",
+    configPath: join4(process.env.HOME || "", ".openclaw/openclaw.json")
+  }
+};
+var CLIENT_INTEGRATIONS = {
+  opencode: installOpencodeIntegration,
+  "pi-agent": installPiIntegration,
+  openclaw: installOpenClawIntegration
+};
+async function runIntegrationsForClients(clientIds, config, store) {
+  for (const client2 of clientIds) {
+    const integrationFn = CLIENT_INTEGRATIONS[client2.clientId];
+    const integrationConfig = CLIENT_CONFIGS[client2.clientId];
+    if (integrationFn && integrationConfig) {
+      try {
+        await integrationFn(config, store, integrationConfig);
+      } catch (error) {
+        console.error(`Integration failed for ${client2.clientId}:`, error);
+      }
+    }
+  }
+}
+
+// src/integrations/opencode.ts
+var OPENCODE_SMALL_MODEL = "routstr/minimax-m2.5";
+async function installOpencodeIntegration(config, store, integrationConfig) {
+  const { clientId, name, configPath } = integrationConfig;
+  logger3.log(`
+Installing routstr models in opencode.json...`);
+  const port = config.port || 8008;
+  const state = store.getState();
+  const existingClient = (state.clientIds || []).find((c) => c.clientId === clientId);
+  let apiKey;
+  if (existingClient) {
+    apiKey = existingClient.apiKey;
+    logger3.log(`Using existing API key for ${name}`);
+  } else {
+    apiKey = generateApiKey2();
+    store.getState().setClientIds((prev) => [
+      ...prev || [],
+      {
+        clientId,
+        name,
+        apiKey,
+        createdAt: Date.now()
+      }
+    ]);
+    logger3.log(`Created new API key for ${name}`);
+  }
+  let opencodeConfig;
+  try {
+    if (existsSync5(configPath)) {
+      const content2 = await readFile3(configPath, "utf-8");
+      opencodeConfig = JSON.parse(content2);
+    } else {
+      opencodeConfig = { provider: {} };
+    }
+  } catch {
+    opencodeConfig = { provider: {} };
+  }
+  if (!opencodeConfig.provider) {
+    opencodeConfig.provider = {};
+  }
+  try {
+    mkdirSync3(dirname3(configPath), { recursive: true });
+    const response = await fetch(`http://localhost:${port}/models`);
+    const data = await response.json();
+    const models = data.output?.models || [];
+    if (models.length === 0) {
+      logger3.log("No models found from routstr daemon.");
+      return;
+    }
+    const modelsObj = {};
+    for (const model2 of models) {
+      modelsObj[model2.id] = { name: model2.name || model2.id };
+    }
+    opencodeConfig.provider["routstr"] = {
+      npm: "@ai-sdk/openai-compatible",
+      name: "routstr",
+      options: {
+        baseURL: `http://localhost:${port}/`,
+        apiKey,
+        includeUsage: true
+      },
+      models: modelsObj
+    };
+    opencodeConfig.small_model = OPENCODE_SMALL_MODEL;
+    await writeFile3(configPath, JSON.stringify(opencodeConfig, null, 2));
+    logger3.log(`Added "routstr" provider with ${models.length} models to opencode.json`);
+  } catch (error) {
+    logger3.error("Failed to install models in opencode.json:", error);
+  }
+}
 // src/daemon/index.ts
+init_dist3();
 async function main() {
   const args = parseArgs(process.argv);
   const config = await loadDaemonConfig();
@@ -34369,13 +35389,19 @@ async function main() {
   const providerRegistry = createProviderRegistryFromStore(store);
   const storageAdapter = createStorageAdapterFromStore(store);
   const modelManager = new ModelManager(discoveryAdapter);
+  const providerManager = new ProviderManager(providerRegistry, store);
   const { ensureProvidersBootstrapped, getRoutstr21Models } = createModelService(modelManager);
-  const walletAdapter = await createWalletAdapter();
+  const walletClient = createCocodClient({ cocodPath: config.cocodPath });
+  const walletAdapter = await createWalletAdapter({
+    cocodPath: config.cocodPath,
+    walletClient
+  });
   const server = createServer();
   server.on("request", createDaemonRequestHandler({
     provider,
     server,
     store,
+    walletClient,
     walletAdapter,
     storageAdapter,
     providerRegistry,
@@ -34383,18 +35409,17 @@ async function main() {
     modelManager,
     ensureProvidersBootstrapped,
     getRoutstr21Models,
-    runWalletCommand,
-    parseBalances,
     mode: config.mode || "apikeys",
-    usageTrackingDriver
+    usageTrackingDriver,
+    providerManager
   }));
   Bun.write(PID_FILE, String(process.pid));
   try {
-    if (existsSync3(SOCKET_PATH)) {
+    if (existsSync6(SOCKET_PATH)) {
       Bun.spawn(["rm", SOCKET_PATH]);
     }
   } catch {}
-  const REFRESH_INTERVAL_MS = 12600000;
+  const REFRESH_INTERVAL_MS = 1260000;
   let refreshInterval = null;
   const startModelRefreshJob = () => {
     logger3.log(`Starting recurring model refresh job (every ${REFRESH_INTERVAL_MS / 1000 / 60 / 60} hours)`);
@@ -34403,6 +35428,13 @@ async function main() {
       try {
         await getRoutstr21Models(true);
         logger3.log("Scheduled model refresh completed successfully.");
+        const state = store.getState();
+        const clientIds = state.clientIds || [];
+        if (clientIds.length > 0) {
+          logger3.log(`Refreshing ${clientIds.length} client integration(s)...`);
+          await runIntegrationsForClients(clientIds, updatedConfig, store);
+          logger3.log("Client integrations refreshed.");
+        }
       } catch (error) {
         logger3.error("Scheduled model refresh failed:", error);
       }
@@ -34415,8 +35447,51 @@ async function main() {
       logger3.log("Stopped recurring model refresh job.");
     }
   };
+  const REFUND_INTERVAL_MS = 600000;
+  let refundInterval = null;
+  const startRefundJob = async () => {
+    logger3.log(`Starting recurring refund job (every ${REFUND_INTERVAL_MS / 1000 / 60} minutes)`);
+    refundInterval = setInterval(async () => {
+      logger3.log("Running scheduled refund...");
+      try {
+        const state = store.getState();
+        const pendingDistribution = (state.cachedTokens || []).map((t) => ({
+          baseUrl: t.baseUrl,
+          amount: t.balance || 0
+        }));
+        const apiKeysStored = (state.apiKeys || []).map((k) => ({
+          baseUrl: k.baseUrl,
+          amount: k.balance || 0
+        }));
+        if (pendingDistribution.length === 0 && apiKeysStored.length === 0) {
+          logger3.log("No pending tokens to refund.");
+          return;
+        }
+        const mintUrl = walletAdapter.getActiveMintUrl();
+        if (!mintUrl) {
+          logger3.log("No active mint URL for refund.");
+          return;
+        }
+        const client2 = new RoutstrClient(walletAdapter, storageAdapter, providerRegistry, "min", "apikeys");
+        const spender = client2.getCashuSpender();
+        const results = await spender.refundProviders(mintUrl);
+        const successCount = results.filter((r) => r.success).length;
+        logger3.log(`Scheduled refund completed: ${successCount}/${results.length} providers refunded.`);
+      } catch (error) {
+        logger3.error("Scheduled refund failed:", error);
+      }
+    }, REFUND_INTERVAL_MS);
+  };
+  const stopRefundJob = () => {
+    if (refundInterval) {
+      clearInterval(refundInterval);
+      refundInterval = null;
+      logger3.log("Stopped recurring refund job.");
+    }
+  };
   server.on("close", () => {
     stopModelRefreshJob();
+    stopRefundJob();
   });
   server.listen(port, async () => {
     logger3.log(`Routstr daemon listening on http://localhost:${port}`);
@@ -34424,8 +35499,15 @@ async function main() {
       startModelRefreshJob();
       logger3.log("Running initial model refresh...");
       return getRoutstr21Models(true);
-    }).then(() => {
+    }).then(async () => {
       logger3.log("Initial model refresh completed.");
+      const state = store.getState();
+      const clientIds = state.clientIds || [];
+      if (clientIds.length > 0) {
+        logger3.log(`Refreshing ${clientIds.length} client integration(s)...`);
+        await runIntegrationsForClients(clientIds, updatedConfig, store);
+        logger3.log("Client integrations refreshed.");
+      }
     }).catch((error) => {
       logger3.error("Initial model refresh failed:", error);
       startModelRefreshJob();