@routstr/sdk 0.3.11 → 0.3.13

package/dist/client/index.js

@@ -930,15 +930,27 @@ var BalanceManager = class _BalanceManager {
       clearTimeout(timeoutId);
       const requestId = response.headers.get("x-routstr-request-id") || void 0;
       if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
-        this.logger.warn(
-          `fetchRefundToken: non-ok response for ${url} status=${response.status} statusText=${response.statusText}`,
-          errorData
-        );
+        const responseBody = await response.text().catch(() => void 0);
+        let errorData = {};
+        if (responseBody) {
+          try {
+            errorData = JSON.parse(responseBody);
+          } catch {
+            errorData = {};
+          }
+        }
+        this.logger.error("Upstream wallet refund error response", {
+          baseUrl,
+          url,
+          status: response.status,
+          statusText: response.statusText,
+          requestId,
+          body: responseBody ?? "<unable to read response body>"
+        });
         return {
           success: false,
           requestId,
-          error: `API key refund failed: ${errorData?.detail || response.statusText}`
+          error: `API key refund failed: ${errorData?.detail || responseBody || response.statusText}`
         };
       }
       const data = await response.json();
@@ -1274,11 +1286,27 @@ var BalanceManager = class _BalanceManager {
       clearTimeout(timeoutId);
       const requestId = response.headers.get("x-routstr-request-id") || void 0;
       if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
+        const responseBody = await response.text().catch(() => void 0);
+        let errorData = {};
+        if (responseBody) {
+          try {
+            errorData = JSON.parse(responseBody);
+          } catch {
+            errorData = {};
+          }
+        }
+        this.logger.error("Upstream wallet topup error response", {
+          baseUrl,
+          url,
+          status: response.status,
+          statusText: response.statusText,
+          requestId,
+          body: responseBody ?? "<unable to read response body>"
+        });
         return {
           success: false,
           requestId,
-          error: errorData?.detail || `Top up failed with status ${response.status}`
+          error: errorData?.detail || responseBody || `Top up failed with status ${response.status}`
         };
       }
       return { success: true, requestId };
@@ -2985,6 +3013,29 @@ function extractUsageFromSSEJson(parsed, fallbackSatsCost = 0) {
   }
   return result;
 }
+function extractUsageFromResponseHeaders(headers) {
+  const get = (name) => {
+    if (headers instanceof Headers) return headers.get(name);
+    const lower = name.toLowerCase();
+    for (const [k, v] of Object.entries(headers)) {
+      if (k.toLowerCase() === lower) return v;
+    }
+    return null;
+  };
+  const totalMsats = Number(get("X-Routstr-Cost-Msats"));
+  if (!totalMsats || !Number.isFinite(totalMsats)) return null;
+  return {
+    promptTokens: 0,
+    completionTokens: 0,
+    totalTokens: 0,
+    cost: Number(get("X-Routstr-Cost-Usd")) || 0,
+    satsCost: totalMsats / 1e3,
+    totalMsats,
+    inputMsats: Number(get("X-Routstr-Input-Cost-Msats")) || 0,
+    outputMsats: Number(get("X-Routstr-Output-Cost-Msats")) || 0,
+    totalUsd: Number(get("X-Routstr-Cost-Usd")) || void 0
+  };
+}
 function toUsageStats(usage) {
   if (!usage) return void 0;
   return {
@@ -3071,14 +3122,11 @@ async function inspectSSEWebStream(stream, onUsage, onResponseId, options) {
       }
       const usage = extractUsageFromSSEJson(data);
       if (usage) {
-        console.log("[routstr:sse] \u2192 usage detected:", usage);
         const merged = mergeUsage(capturedUsage, usage);
         if (hasUsageChanged(capturedUsage, merged)) {
           capturedUsage = merged;
-          console.log("[routstr:sse] \u2192 merged (changed):", merged);
           onUsage(merged);
         } else {
-          console.log("[routstr:sse] \u2192 merged (no change)");
         }
       }
     } catch {
@@ -3235,6 +3283,177 @@ function createSSEParserTransform(onUsage, onResponseId) {
   });
 }
 
+// client/TinfoilSecure.ts
+var TINFOIL_MODEL_PREFIX = "tinfoil-";
+var clientCache = /* @__PURE__ */ new Map();
+function isTinfoilModel(modelId) {
+  return modelId.startsWith(TINFOIL_MODEL_PREFIX);
+}
+function getTinfoilUpstreamModelId(modelId) {
+  return modelId.slice(TINFOIL_MODEL_PREFIX.length);
+}
+function normalizeBaseUrl4(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function cacheKey(options) {
+  return JSON.stringify({
+    baseUrl: options.baseUrl,
+    attestationBundleURL: options.attestationBundleURL,
+    enclaveURL: options.enclaveURL,
+    configRepo: options.configRepo
+  });
+}
+function envOrUndefined(name) {
+  const maybeProcess = globalThis;
+  const value = maybeProcess.process?.env?.[name];
+  return value && value.trim() ? value.trim() : void 0;
+}
+function resolveOptions(options) {
+  return {
+    ...options,
+    baseUrl: normalizeBaseUrl4(options.baseUrl),
+    attestationBundleURL: options.attestationBundleURL ?? envOrUndefined("ROUTSTR_TINFOIL_ATTESTATION_BUNDLE_URL"),
+    enclaveURL: options.enclaveURL ?? envOrUndefined("ROUTSTR_TINFOIL_ENCLAVE_URL"),
+    configRepo: options.configRepo ?? envOrUndefined("ROUTSTR_TINFOIL_CONFIG_REPO")
+  };
+}
+async function prepareTinfoilClient(options) {
+  const resolved = resolveOptions(options);
+  const key = cacheKey(resolved);
+  let pending = clientCache.get(key);
+  if (!pending) {
+    pending = (async () => {
+      const { SecureClient } = await import('tinfoil');
+      const client = new SecureClient({
+        // baseURL is the proxy/provider URL that receives the EHBP request.
+        baseURL: resolved.baseUrl,
+        // Leave undefined by default so tinfoil uses its public ATC. If set,
+        // SecureClient will fetch `${attestationBundleURL}/attestation`.
+        attestationBundleURL: resolved.attestationBundleURL,
+        enclaveURL: resolved.enclaveURL,
+        configRepo: resolved.configRepo,
+        transport: "ehbp"
+      });
+      await client.ready();
+      const verification = client.getVerificationDocument();
+      return { client, verification };
+    })();
+    clientCache.set(key, pending);
+  }
+  try {
+    return await pending;
+  } catch (error) {
+    clientCache.delete(key);
+    throw error;
+  }
+}
+function normalizeFetchArgs(input, init) {
+  if (typeof input === "string") {
+    return { url: input, init };
+  }
+  if (input instanceof URL) {
+    return { url: input.toString(), init };
+  }
+  const cloned = input.clone();
+  return {
+    url: cloned.url,
+    init: {
+      method: cloned.method,
+      headers: new Headers(cloned.headers),
+      body: cloned.body ?? void 0,
+      signal: cloned.signal,
+      ...init
+    }
+  };
+}
+function isProblemJsonContentType(contentType) {
+  const mediaType = contentType?.split(";", 1)[0]?.trim().toLowerCase();
+  return mediaType === "application/problem+json";
+}
+async function isEhbpKeyConfigMismatchResponse(response, protocol) {
+  if (response.status !== 422) {
+    return false;
+  }
+  if (!isProblemJsonContentType(response.headers.get("content-type"))) {
+    return false;
+  }
+  try {
+    const problem = await response.clone().json();
+    return problem?.type === protocol.KEY_CONFIG_PROBLEM_TYPE;
+  } catch {
+    return false;
+  }
+}
+async function fetchTinfoilEhbpOnce(context, options, normalized, ehbp) {
+  const { Identity, PROTOCOL, decryptResponseWithToken, extractSessionRecoveryToken } = ehbp;
+  const resolved = resolveOptions(options);
+  const baseURL = context.client.getBaseURL() ?? resolved.baseUrl;
+  const enclaveURL = context.client.getEnclaveURL();
+  const baseOrigin = new URL(baseURL).origin;
+  const allowedOrigins = /* @__PURE__ */ new Set([baseOrigin]);
+  if (enclaveURL) {
+    allowedOrigins.add(new URL(enclaveURL).origin);
+  }
+  const targetUrl = new URL(normalized.url, baseURL);
+  if (!allowedOrigins.has(targetUrl.origin)) {
+    throw new Error(
+      `refusing to send Tinfoil request to ${targetUrl.origin}: client is bound to the verified enclave/proxy`
+    );
+  }
+  const headers = new Headers(normalized.init?.headers);
+  if (enclaveURL && new URL(enclaveURL).origin !== baseOrigin) {
+    headers.set("X-Tinfoil-Enclave-Url", enclaveURL);
+  }
+  const method = normalized.init?.method ?? "GET";
+  const body = normalized.init?.body ?? null;
+  const serverIdentity = await Identity.fromPublicKeyHex(
+    context.verification.hpkePublicKey
+  );
+  const request = new Request(targetUrl.toString(), {
+    method,
+    headers,
+    body,
+    duplex: "half"
+  });
+  const { request: encryptedRequest, context: requestContext } = await serverIdentity.encryptRequestWithContext(request);
+  const response = await fetch(encryptedRequest);
+  if (!requestContext) {
+    return response;
+  }
+  if (await isEhbpKeyConfigMismatchResponse(response, PROTOCOL)) {
+    throw new ehbp.KeyConfigMismatchError("EHBP key configuration mismatch");
+  }
+  if (!response.headers.get(PROTOCOL.RESPONSE_NONCE_HEADER)) {
+    return response;
+  }
+  const token = await extractSessionRecoveryToken(requestContext);
+  return await decryptResponseWithToken(response, token);
+}
+async function fetchTinfoilPreservingPlaintextErrors(options, input, init) {
+  const context = await prepareTinfoilClient(options);
+  const ehbp = await import('ehbp');
+  const normalized = normalizeFetchArgs(input, init);
+  try {
+    return await fetchTinfoilEhbpOnce(context, options, normalized, ehbp);
+  } catch (error) {
+    if (error instanceof ehbp.KeyConfigMismatchError) {
+      context.client.reset();
+      try {
+        await context.client.ready();
+        context.verification = context.client.getVerificationDocument();
+      } catch (reattestError) {
+        clientCache.delete(cacheKey(resolveOptions(options)));
+        throw reattestError;
+      }
+      return await fetchTinfoilEhbpOnce(context, options, normalized, ehbp);
+    }
+    throw error;
+  }
+}
+function clearTinfoilClientCache() {
+  clientCache.clear();
+}
+
 // client/RoutstrClient.ts
 var TOPUP_MARGIN = 1.2;
 var RoutstrClient = class {
@@ -3420,11 +3639,6 @@ var RoutstrClient = class {
         );
       }
     }
-    const { token, tokenBalance, tokenBalanceUnit, tokenBalanceUnknown } = await this._spendToken({
-      mintUrl,
-      amount: requiredSats,
-      baseUrl
-    });
     let requestBody = body;
     if (body && typeof body === "object") {
       const bodyObj = body;
@@ -3433,7 +3647,36 @@ var RoutstrClient = class {
       }
     }
     const baseHeaders = this._buildBaseHeaders();
-    const requestHeaders = this._withAuthHeader(baseHeaders, token);
+    const tinfoilEnabled = Boolean(modelId && isTinfoilModel(modelId));
+    if (tinfoilEnabled) {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] Attesting Tinfoil model ${modelId} before spend`
+      );
+      const { verification } = await prepareTinfoilClient({ baseUrl });
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] Tinfoil attestation passed, enclave=${verification.enclaveHost}, codeFingerprint=${verification.codeFingerprint.slice(0, 16)}...`
+      );
+      if (requestBody && typeof requestBody === "object" && modelId) {
+        requestBody = {
+          ...requestBody,
+          model: getTinfoilUpstreamModelId(modelId)
+        };
+      }
+    }
+    const spendResult = await this._spendToken({
+      mintUrl,
+      amount: requiredSats,
+      baseUrl
+    });
+    const { token, tokenBalance, tokenBalanceUnit, tokenBalanceUnknown } = spendResult;
+    const finalHeaders = this._withAuthAndTinfoilHeaders(
+      baseHeaders,
+      token,
+      tinfoilEnabled,
+      modelId
+    );
     const response = await this._makeRequest({
       path: requestPath,
       method,
@@ -3442,9 +3685,10 @@ var RoutstrClient = class {
       mintUrl,
       token,
       requiredSats,
-      headers: requestHeaders,
+      headers: finalHeaders,
       baseHeaders,
-      selectedModel
+      selectedModel,
+      tinfoilEnabled
     });
     let tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
     let initialTokenBalanceUnknown = tokenBalanceUnknown;
@@ -3532,7 +3776,7 @@ var RoutstrClient = class {
    * Make the API request with failover support
    */
   async _makeRequest(params) {
-    const { path, method, body, baseUrl, token, headers } = params;
+    const { path, method, body, baseUrl, token, headers, tinfoilEnabled } = params;
     try {
       const url = `${baseUrl.replace(/\/$/, "")}${path}`;
       const requestBodyText = body === void 0 || method === "GET" ? void 0 : JSON.stringify(body);
@@ -3546,7 +3790,15 @@ var RoutstrClient = class {
         rawBody: requestBodyText
       });
       if (this.mode === "xcashu") this._log("DEBUG", "HEADERS,", headers);
-      const response = await fetch(url, {
+      const response = tinfoilEnabled ? await fetchTinfoilPreservingPlaintextErrors(
+        { baseUrl },
+        url,
+        {
+          method,
+          headers,
+          body: requestBodyText
+        }
+      ) : await fetch(url, {
         method,
         headers,
         body: requestBodyText
@@ -3566,6 +3818,15 @@ var RoutstrClient = class {
         } catch (e) {
           bodyText = void 0;
         }
+        this._log("ERROR", "[RoutstrClient] Upstream error response", {
+          baseUrl,
+          url,
+          path,
+          status: response.status,
+          statusText: response.statusText,
+          requestId,
+          body: bodyText ?? "<unable to read response body>"
+        });
         return await this._handleErrorResponse(
           params,
           token,
@@ -3596,6 +3857,9 @@ var RoutstrClient = class {
       throw error;
     }
   }
+  /**
+   * Store request details to a file in the reqs/ folder before fetch.
+   */
   /**
    * Handle error responses with failover
    */
@@ -3747,7 +4011,12 @@ var RoutstrClient = class {
           return this._makeRequest({
             ...params,
             token: params.token,
-            headers: this._withAuthHeader(params.baseHeaders, params.token),
+            headers: this._withAuthAndTinfoilHeaders(
+              params.baseHeaders,
+              params.token,
+              params.tinfoilEnabled,
+              params.selectedModel?.id
+            ),
             retryCount: retryCount + 1
           });
         } else {
@@ -3808,7 +4077,12 @@ var RoutstrClient = class {
         return this._makeRequest({
           ...params,
           token: retryToken,
-          headers: this._withAuthHeader(params.baseHeaders, retryToken),
+          headers: this._withAuthAndTinfoilHeaders(
+            params.baseHeaders,
+            retryToken,
+            params.tinfoilEnabled,
+            params.selectedModel?.id
+          ),
           retryCount: retryCount + 1
         });
       } else {
@@ -3903,6 +4177,13 @@ var RoutstrClient = class {
         messagesForPricing,
         params.maxTokens
       );
+      if (params.tinfoilEnabled) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Attesting Tinfoil failover provider ${nextProvider} before spend`
+        );
+        await prepareTinfoilClient({ baseUrl: nextProvider });
+      }
       this._log(
         "DEBUG",
         `[RoutstrClient] _handleErrorResponse: Creating new token for failover provider ${nextProvider}, required sats: ${newRequiredSats}`
@@ -3921,7 +4202,12 @@ var RoutstrClient = class {
         selectedModel: newModel,
         token: spendResult.token,
         requiredSats: newRequiredSats,
-        headers: this._withAuthHeader(params.baseHeaders, spendResult.token),
+        headers: this._withAuthAndTinfoilHeaders(
+          params.baseHeaders,
+          spendResult.token,
+          params.tinfoilEnabled,
+          newModel.id
+        ),
         retryCount: 0
       });
       retryResponse.initialTokenBalanceInSats = spendResult.tokenBalanceUnit === "msat" ? spendResult.tokenBalance / 1e3 : spendResult.tokenBalance;
@@ -3988,10 +4274,10 @@ var RoutstrClient = class {
         if (latestTokenBalance !== void 0) {
           this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
         }
-        satsSpent = latestTokenBalance !== void 0 && !initialTokenBalanceUnknown ? Math.max(0, initialTokenBalance - latestTokenBalance) : fallbackSatsSpent ?? usage?.satsCost ?? 0;
+        satsSpent = latestTokenBalance !== void 0 && !initialTokenBalanceUnknown ? Math.max(0, initialTokenBalance - latestTokenBalance) : fallbackSatsSpent ?? usage?.satsCost ?? this._headerSatsCost(response) ?? 0;
       } catch (e) {
         this._log("WARN", "Could not get updated API key balance:", e);
-        satsSpent = fallbackSatsSpent ?? usage?.satsCost ?? 0;
+        satsSpent = fallbackSatsSpent ?? usage?.satsCost ?? this._headerSatsCost(response) ?? 0;
       }
     }
     await this._trackResponseUsage({
@@ -4008,6 +4294,15 @@ var RoutstrClient = class {
     })();
     return satsSpent;
   }
+  /**
+   * Extract sats cost from EHBP/Tinfoil response headers as a last-resort
+   * fallback when neither balance delta nor SSE/body usage provides a cost.
+   */
+  _headerSatsCost(response) {
+    if (!response) return void 0;
+    const headerUsage = extractUsageFromResponseHeaders(response.headers);
+    return headerUsage?.satsCost;
+  }
   async _trackResponseUsage(params) {
     const {
       token,
@@ -4041,7 +4336,24 @@ var RoutstrClient = class {
         }
       }
       if (!usage) {
-        return;
+        const headerUsage = extractUsageFromResponseHeaders(response.headers);
+        if (headerUsage) {
+          usage = headerUsage;
+        } else {
+          return;
+        }
+      } else {
+        const headerUsage = extractUsageFromResponseHeaders(response.headers);
+        if (headerUsage) {
+          if (headerUsage.totalMsats) {
+            usage.totalMsats = headerUsage.totalMsats;
+            usage.satsCost = headerUsage.satsCost;
+          }
+          if (headerUsage.cost) usage.cost = headerUsage.cost;
+          if (headerUsage.inputMsats) usage.inputMsats = headerUsage.inputMsats;
+          if (headerUsage.outputMsats) usage.outputMsats = headerUsage.outputMsats;
+          if (headerUsage.totalUsd) usage.totalUsd = headerUsage.totalUsd;
+        }
       }
       const finalRequestId = requestId || "unknown";
       const store = this.sdkStore ?? await getDefaultSdkStore();
@@ -4238,6 +4550,19 @@ var RoutstrClient = class {
     }
     return nextHeaders;
   }
+  /**
+   * Attach auth headers and preserve the plaintext model hint required by the
+   * Routstr proxy for Tinfoil/EHBP requests. EHBP encrypts the JSON body, so
+   * retries/failover must not rebuild headers from baseHeaders alone or the
+   * proxy cannot route/price the encrypted request.
+   */
+  _withAuthAndTinfoilHeaders(headers, token, tinfoilEnabled, modelId) {
+    const nextHeaders = this._withAuthHeader(headers, token);
+    if (tinfoilEnabled && modelId) {
+      nextHeaders["X-Routstr-Model"] = modelId;
+    }
+    return nextHeaders;
+  }
 };
 
 // client/StreamProcessor.ts
@@ -4586,12 +4911,18 @@ function handleError(error, callbacks, alertLevel, logger) {
 exports.ProviderManager = ProviderManager;
 exports.RoutstrClient = RoutstrClient;
 exports.StreamProcessor = StreamProcessor;
+exports.clearTinfoilClientCache = clearTinfoilClientCache;
 exports.createSSEParserTransform = createSSEParserTransform;
 exports.extractResponseId = extractResponseId;
 exports.extractUsageFromResponseBody = extractUsageFromResponseBody;
+exports.extractUsageFromResponseHeaders = extractUsageFromResponseHeaders;
 exports.extractUsageFromSSEJson = extractUsageFromSSEJson;
 exports.fetchAIResponse = fetchAIResponse;
+exports.fetchTinfoilPreservingPlaintextErrors = fetchTinfoilPreservingPlaintextErrors;
+exports.getTinfoilUpstreamModelId = getTinfoilUpstreamModelId;
 exports.inspectSSEWebStream = inspectSSEWebStream;
+exports.isTinfoilModel = isTinfoilModel;
+exports.prepareTinfoilClient = prepareTinfoilClient;
 exports.toUsageStats = toUsageStats;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map