@routstr/sdk 0.2.9 → 0.2.12

package/dist/index.mjs

@@ -4,6 +4,9 @@ import { tap } from 'rxjs';
 import { getDecodedToken } from '@cashu/cashu-ts';
 import { createStore } from 'zustand/vanilla';
 import { Transform, Readable } from 'stream';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 
 // core/errors.ts
 var InsufficientBalanceError = class extends Error {
@@ -688,10 +691,10 @@ var AuditLogger = class _AuditLogger {
     const logLine = JSON.stringify(fullEntry) + "\n";
     if (typeof window === "undefined") {
       try {
-        const fs = await import('fs');
-        const path = await import('path');
-        const logPath = path.join(process.cwd(), "audit.log");
-        fs.appendFileSync(logPath, logLine);
+        const fs2 = await import('fs');
+        const path2 = await import('path');
+        const logPath = path2.join(process.cwd(), "audit.log");
+        fs2.appendFileSync(logPath, logLine);
       } catch (error) {
         console.error("[AuditLogger] Failed to write to file:", error);
       }
@@ -1927,17 +1930,48 @@ function extractResponseId(body) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function extractUsageFromSSEJson(parsed, fallbackSatsCost = 0) {
-  if (!parsed || typeof parsed !== "object" || !parsed.usage) {
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  if (!parsed.usage && parsed.cost && typeof parsed.cost === "object") {
+    const costObj = parsed.cost;
+    const msats2 = costObj.total_msats ?? 0;
+    const cost2 = costObj.total_usd ?? 0;
+    if (msats2 === 0 && cost2 === 0) return null;
+    return {
+      promptTokens: Number(costObj.input_tokens ?? 0),
+      completionTokens: Number(costObj.output_tokens ?? 0),
+      totalTokens: Number((costObj.input_tokens ?? 0) + (costObj.output_tokens ?? 0)),
+      cost: Number(cost2),
+      satsCost: msats2 > 0 ? msats2 / 1e3 : fallbackSatsCost
+    };
+  }
+  if (!parsed.usage) {
     return null;
   }
   const usage = parsed.usage;
   const usageCost = usage.cost;
-  const cost = typeof usageCost === "number" ? usageCost : usageCost?.total_usd ?? parsed.metadata?.routstr?.cost?.total_usd ?? 0;
-  const msats = parsed.metadata?.routstr?.cost?.total_msats ?? (typeof usage.cost_sats === "number" ? usage.cost_sats * 1e3 : 0);
+  let cost = 0;
+  let msats = 0;
+  if (typeof usageCost === "number") {
+    cost = usageCost;
+  } else if (usageCost && typeof usageCost === "object") {
+    cost = usageCost.total_usd ?? 0;
+    msats = usageCost.total_msats ?? 0;
+  }
+  if (cost === 0) {
+    cost = parsed.metadata?.routstr?.cost?.total_usd ?? 0;
+  }
+  if (msats === 0) {
+    msats = parsed.metadata?.routstr?.cost?.total_msats ?? (typeof usage.cost_sats === "number" ? usage.cost_sats * 1e3 : 0);
+  }
+  const promptTokens = Number(usage.prompt_tokens ?? usage.input_tokens ?? 0);
+  const completionTokens = Number(usage.completion_tokens ?? usage.output_tokens ?? 0);
+  const totalTokens = Number(usage.total_tokens ?? promptTokens + completionTokens);
   const result = {
-    promptTokens: Number(usage.prompt_tokens ?? 0),
-    completionTokens: Number(usage.completion_tokens ?? 0),
-    totalTokens: Number(usage.total_tokens ?? 0),
+    promptTokens,
+    completionTokens,
+    totalTokens,
     cost: Number(cost ?? 0),
     satsCost: msats > 0 ? msats / 1e3 : fallbackSatsCost
   };
@@ -2063,11 +2097,14 @@ var StreamProcessor = class {
       if (parsed.choices?.[0]?.delta?.reasoning) {
         result.reasoning = parsed.choices[0].delta.reasoning;
       }
-      if (parsed.usage) {
-        result.usage = toUsageStats(extractUsageFromSSEJson(parsed)) ?? {
-          total_tokens: parsed.usage.total_tokens,
-          prompt_tokens: parsed.usage.prompt_tokens,
-          completion_tokens: parsed.usage.completion_tokens
+      const extractedUsage = extractUsageFromSSEJson(parsed);
+      if (extractedUsage) {
+        result.usage = toUsageStats(extractedUsage);
+      } else if (parsed.usage) {
+        result.usage = {
+          total_tokens: parsed.usage.total_tokens ?? parsed.usage.input_tokens + parsed.usage.output_tokens,
+          prompt_tokens: parsed.usage.prompt_tokens ?? parsed.usage.input_tokens,
+          completion_tokens: parsed.usage.completion_tokens ?? parsed.usage.output_tokens
         };
       }
       if (parsed.id) {
@@ -2381,6 +2418,7 @@ var ProviderManager = class _ProviderManager {
   }
   /**
    * Clean up expired cooldown entries
+   * Also removes the provider from failedProviders so it can be retried
    */
   cleanupExpiredCooldowns() {
     const now = Date.now();
@@ -2393,6 +2431,10 @@ var ProviderManager = class _ProviderManager {
           console.log(
             `[cleanupExpiredCooldowns:${this.instanceId}] Removing expired cooldown for ${url} (age: ${age}ms, cooldown: ${_ProviderManager.COOLDOWN_DURATION_MS}ms)`
           );
+          this.failedProviders.delete(url);
+          if (this.store) {
+            this.store.getState().removeFailedProvider(url);
+          }
         }
         return !isExpired;
       }
@@ -2566,22 +2608,49 @@ var ProviderManager = class _ProviderManager {
       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(([url]) => url)}`
+      );
       const allProviders = this.providerRegistry.getAllProvidersModels();
+      console.log(
+        `[findNextBestProvider:${this.instanceId}] Total providers in registry: ${Object.keys(allProviders).length}`
+      );
       const candidates = [];
       for (const [baseUrl, models] of Object.entries(allProviders)) {
-        if (baseUrl === currentBaseUrl || this.failedProviders.has(baseUrl) || disabledProviders.has(baseUrl) || this.isOnCooldown(baseUrl)) {
+        if (baseUrl === currentBaseUrl) {
+          console.log(
+            `[findNextBestProvider:${this.instanceId}] SKIP (current): ${baseUrl}`
+          );
+          continue;
+        }
+        if (disabledProviders.has(baseUrl)) {
+          continue;
+        }
+        if (this.isOnCooldown(baseUrl)) {
           continue;
         }
         if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl))) {
           continue;
         }
         const model = models.find((m) => m.id === modelId);
-        if (!model) continue;
+        if (!model) {
+          continue;
+        }
         const cost = model.sats_pricing?.completion ?? 0;
         candidates.push({ baseUrl, model, cost });
       }
       candidates.sort((a, b) => a.cost - b.cost);
-      return candidates.length > 0 ? candidates[0].baseUrl : null;
+      if (candidates.length > 0) {
+        return candidates[0].baseUrl;
+      } else {
+        return null;
+      }
     } catch (error) {
       console.error("Error finding next best provider:", error);
       return null;
@@ -4449,69 +4518,95 @@ var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await g
 var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(await getDefaultSdkStore());
 function createSSEParserTransform(onUsage, onResponseId) {
   let buffer = "";
-  let usageCaptured = false;
+  let capturedUsage = null;
   let responseIdCaptured = false;
-  const maybeCaptureUsageFromJson = (jsonText) => {
+  const mergeUsage = (previous, next) => {
+    if (!previous) return next;
+    return {
+      promptTokens: next.promptTokens > 0 ? next.promptTokens : previous.promptTokens,
+      completionTokens: next.completionTokens > 0 ? next.completionTokens : previous.completionTokens,
+      totalTokens: next.totalTokens > 0 ? next.totalTokens : previous.totalTokens,
+      cost: next.cost > 0 ? next.cost : previous.cost,
+      satsCost: next.satsCost > 0 ? next.satsCost : previous.satsCost
+    };
+  };
+  const hasUsageChanged = (previous, next) => {
+    if (!previous) return true;
+    return previous.promptTokens !== next.promptTokens || previous.completionTokens !== next.completionTokens || previous.totalTokens !== next.totalTokens || previous.cost !== next.cost || previous.satsCost !== next.satsCost;
+  };
+  const inspectDataPayload = (jsonText) => {
+    if (responseIdCaptured && capturedUsage?.satsCost && capturedUsage.totalTokens) {
+      return;
+    }
+    const trimmed = jsonText.trim();
+    if (!trimmed || trimmed === "[DONE]") return;
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return;
     try {
-      const data = JSON.parse(jsonText);
-      const responseId = data.id;
-      if (typeof responseId === "string" && responseId.trim().length > 0) {
-        onResponseId?.(responseId.trim());
-        responseIdCaptured = true;
+      const data = JSON.parse(trimmed);
+      if (!responseIdCaptured) {
+        const responseId = data?.id;
+        if (typeof responseId === "string" && responseId.trim().length > 0) {
+          onResponseId?.(responseId.trim());
+          responseIdCaptured = true;
+        }
       }
       const usage = extractUsageFromSSEJson(data);
       if (usage) {
-        onUsage(usage);
-        usageCaptured = true;
+        const mergedUsage = mergeUsage(capturedUsage, usage);
+        if (hasUsageChanged(capturedUsage, mergedUsage)) {
+          capturedUsage = mergedUsage;
+          onUsage(mergedUsage);
+        }
       }
     } catch {
     }
   };
-  const processLine = (self, line) => {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      return;
-    }
-    if (trimmed === "data: [DONE]" || trimmed === "[DONE]") {
-      self.push("data: [DONE]\n\n");
+  const inspectEventBlock = (eventBlock) => {
+    if (responseIdCaptured && capturedUsage?.satsCost && capturedUsage.totalTokens) {
       return;
     }
-    if (trimmed.startsWith("data:")) {
-      const dataStr = trimmed.startsWith("data: ") ? trimmed.slice(6) : trimmed.slice(5).trimStart();
-      if (dataStr === "[DONE]") {
-        self.push("data: [DONE]\n\n");
-        return;
+    const lines = eventBlock.split(/\r?\n/);
+    const dataParts = [];
+    for (const line of lines) {
+      if (!line || line.startsWith(":")) continue;
+      if (line.startsWith("data:")) {
+        const value = line.startsWith("data: ") ? line.slice(6) : line.slice(5);
+        dataParts.push(value);
       }
-      maybeCaptureUsageFromJson(dataStr);
-      self.push(`data: ${dataStr}
-
-`);
-      return;
-    }
-    if (trimmed.startsWith("{")) {
-      maybeCaptureUsageFromJson(trimmed);
-      self.push(`data: ${trimmed}
-
-`);
-      return;
     }
-    self.push(line + "\n");
+    if (dataParts.length === 0) return;
+    const payload = dataParts.join("\n");
+    inspectDataPayload(payload);
+  };
+  const emitEventBlock = (self, eventBlock) => {
+    if (eventBlock.length === 0) return;
+    inspectEventBlock(eventBlock);
+    self.push(eventBlock + "\n\n");
   };
   return new Transform({
-    transform(chunk, encoding, callback) {
+    transform(chunk, _encoding, callback) {
       buffer += chunk.toString();
-      const lines = buffer.split(/\r?\n/);
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        processLine(this, line);
+      const terminator = /\r?\n\r?\n/g;
+      let lastIndex = 0;
+      let match;
+      while ((match = terminator.exec(buffer)) !== null) {
+        const block = buffer.slice(lastIndex, match.index);
+        lastIndex = match.index + match[0].length;
+        emitEventBlock(this, block);
+      }
+      if (lastIndex > 0) {
+        buffer = buffer.slice(lastIndex);
       }
       callback();
     },
     flush(callback) {
-      if (buffer.trim()) {
-        processLine(this, buffer);
+      if (buffer.length > 0) {
+        const tail = buffer.replace(/\r?\n+$/, "");
+        if (tail.length > 0) {
+          emitEventBlock(this, tail);
+        }
+        buffer = "";
       }
-      buffer = "";
       callback();
     }
   });
@@ -4695,7 +4790,7 @@ var RoutstrClient = class {
   }
   async _prepareRoutedRequest(params) {
     const {
-      path,
+      path: requestPath,
       method,
       body,
       headers = {},
@@ -4736,7 +4831,7 @@ var RoutstrClient = class {
     const baseHeaders = this._buildBaseHeaders();
     const requestHeaders = this._withAuthHeader(baseHeaders, token);
     const response = await this._makeRequest({
-      path,
+      path: requestPath,
       method,
       body: method === "GET" ? void 0 : requestBody,
       baseUrl,
@@ -4755,7 +4850,20 @@ var RoutstrClient = class {
     let capturedUsage;
     let capturedResponseId;
     if (contentType.includes("text/event-stream") && response.body) {
+      const logDir = path.join(os.homedir(), ".routstrd", "stream-response");
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+      }
+      const logFile = path.join(logDir, `${Date.now()}.jsonl`);
+      const logStream = fs.createWriteStream(logFile);
       const nodeReadable = Readable.fromWeb(response.body);
+      const loggingTransform = new Transform({
+        transform(chunk, encoding, callback) {
+          const raw = chunk.toString();
+          logStream.write(JSON.stringify({ raw, timestamp: Date.now() }) + "\n");
+          callback(null, chunk);
+        }
+      });
       const sseParser = createSSEParserTransform(
         (usage) => {
           capturedUsage = usage;
@@ -4766,7 +4874,7 @@ var RoutstrClient = class {
           processedResponse.requestId = responseId;
         }
       );
-      const transformed = nodeReadable.pipe(sseParser, { end: true });
+      const transformed = nodeReadable.pipe(loggingTransform).pipe(sseParser, { end: true });
       const webStream = Readable.toWeb(
         transformed
       );
@@ -4835,7 +4943,6 @@ var RoutstrClient = class {
       callbacks.onTokenCreated?.(this._getPendingCashuTokenAmount());
       const baseHeaders = this._buildBaseHeaders(headers);
       const requestHeaders = this._withAuthHeader(baseHeaders, token);
-      this.providerManager.resetFailedProviders();
       const providerInfo = await this.providerRegistry.getProviderInfo(baseUrl);
       const providerVersion = providerInfo?.version ?? "";
       let modelIdForRequest = selectedModel.id;
@@ -4938,9 +5045,9 @@ var RoutstrClient = class {
    * Make the API request with failover support
    */
   async _makeRequest(params) {
-    const { path, method, body, baseUrl, token, headers } = params;
+    const { path: path2, method, body, baseUrl, token, headers } = params;
     try {
-      const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+      const url = `${baseUrl.replace(/\/$/, "")}${path2}`;
       if (this.mode === "xcashu") this._log("DEBUG", "HEADERS,", headers);
       const response = await fetch(url, {
         method,
@@ -4990,11 +5097,12 @@ var RoutstrClient = class {
    */
   async _handleErrorResponse(params, token, status, requestId, xCashuRefundToken, responseBody, retryCount = 0) {
     const MAX_RETRIES_PER_PROVIDER = 2;
-    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
+    const { path: path2, method, body, selectedModel, baseUrl, mintUrl } = params;
     let tryNextProvider = false;
+    const errorMessage = responseBody;
     this._log(
       "DEBUG",
-      `[RoutstrClient] _handleErrorResponse: status=${status}, baseUrl=${baseUrl}, mode=${this.mode}, token preview=${token}, requestId=${requestId}`
+      `[RoutstrClient] _handleErrorResponse: status=${status}, baseUrl=${baseUrl}, mode=${this.mode}, token preview=${token}, requestId=${requestId}, errorMessage=${errorMessage}`
     );
     this._log(
       "DEBUG",
@@ -5291,7 +5399,7 @@ var RoutstrClient = class {
       });
       return this._makeRequest({
         ...params,
-        path,
+        path: path2,
         method,
         body,
         baseUrl: nextProvider,
@@ -5699,7 +5807,7 @@ async function resolveRouteRequestContext(options) {
   const {
     modelId,
     requestBody,
-    path = "/v1/chat/completions",
+    path: path2 = "/v1/chat/completions",
     headers = {},
     forcedProvider,
     walletAdapter,
@@ -5798,17 +5906,17 @@ async function resolveRouteRequestContext(options) {
     client,
     baseUrl,
     mintUrl,
-    path,
+    path: path2,
     headers,
     modelId,
     proxiedBody
   };
 }
 async function routeRequests(options) {
-  const { client, baseUrl, mintUrl, path, headers, modelId, proxiedBody } = await resolveRouteRequestContext(options);
+  const { client, baseUrl, mintUrl, path: path2, headers, modelId, proxiedBody } = await resolveRouteRequestContext(options);
   try {
     const response = await client.routeRequest({
-      path,
+      path: path2,
       method: "POST",
       body: proxiedBody,
       headers,
@@ -5829,10 +5937,10 @@ async function routeRequests(options) {
 }
 async function routeRequestsToNodeResponse(options) {
   const { res } = options;
-  const { client, baseUrl, mintUrl, path, headers, modelId, proxiedBody } = await resolveRouteRequestContext(options);
+  const { client, baseUrl, mintUrl, path: path2, headers, modelId, proxiedBody } = await resolveRouteRequestContext(options);
   try {
     await client.routeRequestToNodeResponse({
-      path,
+      path: path2,
       method: "POST",
       body: proxiedBody,
       headers,