@blockrun/llm 1.4.3 → 1.6.1

package/dist/index.js

@@ -223,6 +223,61 @@ function extractPaymentDetails(paymentRequired, preferredNetwork) {
 
 // src/validation.ts
 var LOCALHOST_DOMAINS = ["localhost", "127.0.0.1"];
+var KNOWN_PROVIDERS = /* @__PURE__ */ new Set([
+  "openai",
+  "anthropic",
+  "google",
+  "deepseek",
+  "mistralai",
+  "meta-llama",
+  "together",
+  "xai",
+  "moonshot",
+  "nvidia",
+  "minimax",
+  "zai"
+]);
+function validateModel(model) {
+  if (!model || typeof model !== "string") {
+    throw new Error("Model must be a non-empty string");
+  }
+}
+function validateMaxTokens(maxTokens) {
+  if (maxTokens === void 0 || maxTokens === null) {
+    return;
+  }
+  if (typeof maxTokens !== "number" || !Number.isInteger(maxTokens)) {
+    throw new Error("maxTokens must be an integer");
+  }
+  if (maxTokens < 1) {
+    throw new Error("maxTokens must be positive (minimum: 1)");
+  }
+  if (maxTokens > 1e5) {
+    throw new Error("maxTokens too large (maximum: 100000)");
+  }
+}
+function validateTemperature(temperature) {
+  if (temperature === void 0 || temperature === null) {
+    return;
+  }
+  if (typeof temperature !== "number") {
+    throw new Error("temperature must be a number");
+  }
+  if (temperature < 0 || temperature > 2) {
+    throw new Error("temperature must be between 0 and 2");
+  }
+}
+function validateTopP(topP) {
+  if (topP === void 0 || topP === null) {
+    return;
+  }
+  if (typeof topP !== "number") {
+    throw new Error("topP must be a number");
+  }
+  if (topP < 0 || topP > 1) {
+    throw new Error("topP must be between 0 and 1");
+  }
+}
 function validatePrivateKey(key) {
   if (typeof key !== "string") {
     throw new Error("Private key must be a string");
@@ -298,9 +353,9 @@ var DEFAULT_API_URL = "https://blockrun.ai/api";
 var TESTNET_API_URL = "https://testnet.blockrun.ai/api";
 var DEFAULT_MAX_TOKENS = 1024;
 var DEFAULT_TIMEOUT = 6e4;
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "1.5.0";
 var USER_AGENT = `blockrun-ts/${SDK_VERSION}`;
-var LLMClient = class {
+var LLMClient = class _LLMClient {
   static DEFAULT_API_URL = DEFAULT_API_URL;
   static TESTNET_API_URL = TESTNET_API_URL;
   account;
@@ -311,6 +366,11 @@ var LLMClient = class {
   sessionCalls = 0;
   modelPricingCache = null;
   modelPricingPromise = null;
+  // Pre-auth cache: avoids the 402 round-trip on repeat requests to the same model.
+  // Key = "endpoint:model", value = cached payment header + timestamp.
+  // TTL: 1 hour (mirrors ClawRouter's payment-preauth.ts approach).
+  preAuthCache = /* @__PURE__ */ new Map();
+  static PRE_AUTH_TTL_MS = 36e5;
   /**
    * Initialize the BlockRun LLM client.
    *
@@ -335,13 +395,13 @@ var LLMClient = class {
   /**
    * Simple 1-line chat interface.
    *
-   * @param model - Model ID (e.g., 'openai/gpt-4o', 'anthropic/claude-sonnet-4')
+   * @param model - Model ID (e.g., 'openai/gpt-5.2', 'anthropic/claude-sonnet-4.6')
    * @param prompt - User message
    * @param options - Optional chat parameters
    * @returns Assistant's response text
    *
    * @example
-   * const response = await client.chat('gpt-4o', 'What is the capital of France?');
+   * const response = await client.chat('gpt-5.2', 'What is the capital of France?');
    * console.log(response); // 'The capital of France is Paris.'
    */
   async chat(model, prompt, options) {
@@ -487,6 +547,27 @@ var LLMClient = class {
       headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
       body: JSON.stringify(body)
     });
+    if (response.status === 502 || response.status === 503) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const retryResp = await this.fetchWithTimeout(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
+        body: JSON.stringify(body)
+      });
+      if (retryResp.status !== 502 && retryResp.status !== 503) {
+        if (retryResp.status === 402) return this.handlePaymentAndRetry(url, body, retryResp);
+        if (!retryResp.ok) {
+          let errorBody;
+          try {
+            errorBody = await retryResp.json();
+          } catch {
+            errorBody = { error: "Request failed" };
+          }
+          throw new APIError(`API error: ${retryResp.status}`, retryResp.status, sanitizeErrorResponse(errorBody));
+        }
+        return retryResp.json();
+      }
+    }
     if (response.status === 402) {
       return this.handlePaymentAndRetry(url, body, response);
     }
@@ -552,6 +633,34 @@ var LLMClient = class {
       },
       body: JSON.stringify(body)
     });
+    if (retryResponse.status === 502 || retryResponse.status === 503) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const retryResp2 = await this.fetchWithTimeout(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": USER_AGENT,
+          "PAYMENT-SIGNATURE": paymentPayload
+        },
+        body: JSON.stringify(body)
+      });
+      if (retryResp2.status !== 502 && retryResp2.status !== 503) {
+        if (retryResp2.status === 402) throw new PaymentError("Payment was rejected. Check your wallet balance.");
+        if (!retryResp2.ok) {
+          let errorBody;
+          try {
+            errorBody = await retryResp2.json();
+          } catch {
+            errorBody = { error: "Request failed" };
+          }
+          throw new APIError(`API error after payment: ${retryResp2.status}`, retryResp2.status, sanitizeErrorResponse(errorBody));
+        }
+        const costUsd2 = parseFloat(details.amount) / 1e6;
+        this.sessionCalls += 1;
+        this.sessionTotalUsd += costUsd2;
+        return retryResp2.json();
+      }
+    }
     if (retryResponse.status === 402) {
       throw new PaymentError("Payment was rejected. Check your wallet balance.");
     }
@@ -573,6 +682,131 @@ var LLMClient = class {
     this.sessionTotalUsd += costUsd;
     return retryResponse.json();
   }
+  /**
+   * Sign a payment header and return the PAYMENT-SIGNATURE value.
+   * Extracted to share logic between streaming and non-streaming flows.
+   */
+  async signPayment(paymentHeader) {
+    const paymentRequired = parsePaymentRequired(paymentHeader);
+    const details = extractPaymentDetails(paymentRequired);
+    const extensions = paymentRequired.extensions;
+    const paymentPayload = await createPaymentPayload(
+      this.privateKey,
+      this.account.address,
+      details.recipient,
+      details.amount,
+      details.network || "eip155:8453",
+      {
+        resourceUrl: validateResourceUrl(
+          details.resource?.url || `${this.apiUrl}/v1/chat/completions`,
+          this.apiUrl
+        ),
+        resourceDescription: details.resource?.description || "BlockRun AI API call",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra,
+        extensions
+      }
+    );
+    const costUsd = parseFloat(details.amount) / 1e6;
+    return { paymentPayload, costUsd };
+  }
+  /**
+   * Streaming chat completion with automatic x402 payment.
+   *
+   * Uses a pre-auth cache so repeat calls to the same model skip the 402
+   * round-trip (~200ms savings). Falls back to the normal 402 flow on cache
+   * miss or if the pre-signed payment is rejected.
+   *
+   * @returns Raw fetch Response with a streaming SSE body.
+   */
+  async chatCompletionStream(model, messages, options) {
+    const url = `${this.apiUrl}/v1/chat/completions`;
+    const body = {
+      model,
+      messages,
+      max_tokens: options?.maxTokens ?? DEFAULT_MAX_TOKENS,
+      stream: true
+    };
+    if (options?.temperature !== void 0) body.temperature = options.temperature;
+    if (options?.topP !== void 0) body.top_p = options.topP;
+    if (options?.tools !== void 0) body.tools = options.tools;
+    if (options?.toolChoice !== void 0) body.tool_choice = options.toolChoice;
+    const cacheKey2 = `/v1/chat/completions:${model}`;
+    const cached = this.preAuthCache.get(cacheKey2);
+    const now = Date.now();
+    if (cached && now - cached.cachedAt < _LLMClient.PRE_AUTH_TTL_MS) {
+      try {
+        const { paymentPayload: paymentPayload2, costUsd: costUsd2 } = await this.signPayment(cached.paymentHeader);
+        const preAuthResp = await this.fetchWithTimeout(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "User-Agent": USER_AGENT,
+            "PAYMENT-SIGNATURE": paymentPayload2
+          },
+          body: JSON.stringify(body)
+        });
+        if (preAuthResp.status !== 402 && preAuthResp.ok) {
+          this.sessionCalls += 1;
+          this.sessionTotalUsd += costUsd2;
+          return preAuthResp;
+        }
+        this.preAuthCache.delete(cacheKey2);
+      } catch {
+        this.preAuthCache.delete(cacheKey2);
+      }
+    }
+    const firstResp = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
+      body: JSON.stringify(body)
+    });
+    if (firstResp.status !== 402) {
+      if (!firstResp.ok) {
+        let errorBody;
+        try {
+          errorBody = await firstResp.json();
+        } catch {
+          errorBody = { error: "Request failed" };
+        }
+        throw new APIError(`API error: ${firstResp.status}`, firstResp.status, sanitizeErrorResponse(errorBody));
+      }
+      return firstResp;
+    }
+    let paymentHeader = firstResp.headers.get("payment-required");
+    if (!paymentHeader) {
+      try {
+        const rb = await firstResp.json();
+        if (rb.x402 || rb.accepts) paymentHeader = btoa(JSON.stringify(rb));
+      } catch {
+      }
+    }
+    if (!paymentHeader) throw new PaymentError("402 response but no payment requirements found");
+    this.preAuthCache.set(cacheKey2, { paymentHeader, cachedAt: now });
+    const { paymentPayload, costUsd } = await this.signPayment(paymentHeader);
+    const streamResp = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    if (streamResp.status === 402) throw new PaymentError("Payment was rejected. Check your wallet balance.");
+    if (!streamResp.ok) {
+      let errorBody;
+      try {
+        errorBody = await streamResp.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(`API error after payment: ${streamResp.status}`, streamResp.status, sanitizeErrorResponse(errorBody));
+    }
+    this.sessionCalls += 1;
+    this.sessionTotalUsd += costUsd;
+    return streamResp;
+  }
   /**
    * Make a request with automatic x402 payment handling, returning raw JSON.
    * Used for non-ChatResponse endpoints (X/Twitter, search, image edit, etc.).
@@ -584,6 +818,27 @@ var LLMClient = class {
       headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
       body: JSON.stringify(body)
     });
+    if (response.status === 502 || response.status === 503) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const retryResp = await this.fetchWithTimeout(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
+        body: JSON.stringify(body)
+      });
+      if (retryResp.status !== 502 && retryResp.status !== 503) {
+        if (retryResp.status === 402) return this.handlePaymentAndRetryRaw(url, body, retryResp);
+        if (!retryResp.ok) {
+          let errorBody;
+          try {
+            errorBody = await retryResp.json();
+          } catch {
+            errorBody = { error: "Request failed" };
+          }
+          throw new APIError(`API error: ${retryResp.status}`, retryResp.status, sanitizeErrorResponse(errorBody));
+        }
+        return retryResp.json();
+      }
+    }
     if (response.status === 402) {
       return this.handlePaymentAndRetryRaw(url, body, response);
     }
@@ -649,6 +904,34 @@ var LLMClient = class {
       },
       body: JSON.stringify(body)
     });
+    if (retryResponse.status === 502 || retryResponse.status === 503) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const retryResp2 = await this.fetchWithTimeout(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": USER_AGENT,
+          "PAYMENT-SIGNATURE": paymentPayload
+        },
+        body: JSON.stringify(body)
+      });
+      if (retryResp2.status !== 502 && retryResp2.status !== 503) {
+        if (retryResp2.status === 402) throw new PaymentError("Payment was rejected. Check your wallet balance.");
+        if (!retryResp2.ok) {
+          let errorBody;
+          try {
+            errorBody = await retryResp2.json();
+          } catch {
+            errorBody = { error: "Request failed" };
+          }
+          throw new APIError(`API error after payment: ${retryResp2.status}`, retryResp2.status, sanitizeErrorResponse(errorBody));
+        }
+        const costUsd2 = parseFloat(details.amount) / 1e6;
+        this.sessionCalls += 1;
+        this.sessionTotalUsd += costUsd2;
+        return retryResp2.json();
+      }
+    }
     if (retryResponse.status === 402) {
       throw new PaymentError("Payment was rejected. Check your wallet balance.");
     }
@@ -681,6 +964,26 @@ var LLMClient = class {
       method: "GET",
       headers: { "User-Agent": USER_AGENT }
     });
+    if (response.status === 502 || response.status === 503) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const retryResp = await this.fetchWithTimeout(url, {
+        method: "GET",
+        headers: { "User-Agent": USER_AGENT }
+      });
+      if (retryResp.status !== 502 && retryResp.status !== 503) {
+        if (retryResp.status === 402) return this.handleGetPaymentAndRetryRaw(url, endpoint, params, retryResp);
+        if (!retryResp.ok) {
+          let errorBody;
+          try {
+            errorBody = await retryResp.json();
+          } catch {
+            errorBody = { error: "Request failed" };
+          }
+          throw new APIError(`API error: ${retryResp.status}`, retryResp.status, sanitizeErrorResponse(errorBody));
+        }
+        return retryResp.json();
+      }
+    }
     if (response.status === 402) {
       return this.handleGetPaymentAndRetryRaw(url, endpoint, params, response);
     }
@@ -746,6 +1049,32 @@ var LLMClient = class {
         "PAYMENT-SIGNATURE": paymentPayload
       }
     });
+    if (retryResponse.status === 502 || retryResponse.status === 503) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const retryResp2 = await this.fetchWithTimeout(retryUrl, {
+        method: "GET",
+        headers: {
+          "User-Agent": USER_AGENT,
+          "PAYMENT-SIGNATURE": paymentPayload
+        }
+      });
+      if (retryResp2.status !== 502 && retryResp2.status !== 503) {
+        if (retryResp2.status === 402) throw new PaymentError("Payment was rejected. Check your wallet balance.");
+        if (!retryResp2.ok) {
+          let errorBody;
+          try {
+            errorBody = await retryResp2.json();
+          } catch {
+            errorBody = { error: "Request failed" };
+          }
+          throw new APIError(`API error after payment: ${retryResp2.status}`, retryResp2.status, sanitizeErrorResponse(errorBody));
+        }
+        const costUsd2 = parseFloat(details.amount) / 1e6;
+        this.sessionCalls += 1;
+        this.sessionTotalUsd += costUsd2;
+        return retryResp2.json();
+      }
+    }
     if (retryResponse.status === 402) {
       throw new PaymentError("Payment was rejected. Check your wallet balance.");
     }
@@ -807,12 +1136,12 @@ var LLMClient = class {
     return (data.data || []).map((m) => ({
       id: m.id,
       name: m.name || m.id,
-      provider: m.owned_by || "",
+      provider: m.provider || m.owned_by || "",
       description: m.description || "",
-      inputPrice: m.pricing?.input ?? m.pricing?.flat ?? 0,
-      outputPrice: m.pricing?.output ?? 0,
-      contextWindow: m.context_window || 0,
-      maxOutput: m.max_output || 0,
+      inputPrice: m.inputPrice ?? m.input_price ?? m.pricing?.input ?? 0,
+      outputPrice: m.outputPrice ?? m.output_price ?? m.pricing?.output ?? 0,
+      contextWindow: m.contextWindow ?? m.context_window ?? 0,
+      maxOutput: m.maxOutput ?? m.max_output ?? 0,
       categories: m.categories || [],
       available: true
     }));
@@ -900,6 +1229,58 @@ var LLMClient = class {
     const data = await this.requestWithPaymentRaw("/v1/search", body);
     return data;
   }
+  /**
+   * Neural web search via Exa. Returns semantically relevant URLs and metadata.
+   * Understands meaning, not just keywords. $0.01/call.
+   *
+   * @param query - Natural language search query
+   * @param options - Optional filters (numResults, category, date range, domains)
+   */
+  async exaSearch(query, options) {
+    const body = { query };
+    if (options?.numResults !== void 0) body.numResults = options.numResults;
+    if (options?.category !== void 0) body.category = options.category;
+    if (options?.startPublishedDate !== void 0) body.startPublishedDate = options.startPublishedDate;
+    if (options?.endPublishedDate !== void 0) body.endPublishedDate = options.endPublishedDate;
+    if (options?.includeDomains !== void 0) body.includeDomains = options.includeDomains;
+    if (options?.excludeDomains !== void 0) body.excludeDomains = options.excludeDomains;
+    const data = await this.requestWithPaymentRaw("/v1/exa/search", body);
+    return data.data;
+  }
+  /**
+   * Ask a question and get a cited, synthesized answer grounded in real web sources.
+   * No hallucinations — every claim is backed by a citation. $0.01/call.
+   *
+   * @param query - The question to answer
+   */
+  async exaAnswer(query) {
+    const data = await this.requestWithPaymentRaw("/v1/exa/answer", { query });
+    return data.data;
+  }
+  /**
+   * Fetch full Markdown text content from a list of URLs. $0.002 per URL.
+   * Returns clean text ready to feed into an LLM context window.
+   *
+   * @param urls - Array of URLs to fetch (up to 100)
+   */
+  async exaContents(urls) {
+    const data = await this.requestWithPaymentRaw("/v1/exa/contents", { urls });
+    return data.data;
+  }
+  /**
+   * Find pages semantically similar to a given URL. $0.01/call.
+   * Useful for discovering competitors, alternatives, and related resources.
+   *
+   * @param url - Reference URL
+   * @param options - Optional filters (numResults, excludeSourceDomain)
+   */
+  async exaFindSimilar(url, options) {
+    const body = { url };
+    if (options?.numResults !== void 0) body.numResults = options.numResults;
+    if (options?.excludeSourceDomain !== void 0) body.excludeSourceDomain = options.excludeSourceDomain;
+    const data = await this.requestWithPaymentRaw("/v1/exa/find-similar", body);
+    return data.data;
+  }
   /**
    * Get USDC balance on Base network.
    *
@@ -1913,6 +2294,55 @@ var SolanaLLMClient = class {
   async pmQuery(path5, query) {
     return this.requestWithPaymentRaw(`/v1/pm/${path5}`, query);
   }
+  // ── Exa Web Search (Powered by Exa) ──────────────────────────────────────
+  /**
+   * Generic Exa endpoint proxy (POST, Solana payment). Powered by Exa.
+   *
+   * @param path - Exa endpoint: "search" | "find-similar" | "contents" | "answer"
+   * @param body - Request body (see Exa API docs)
+   *
+   * @example
+   * const results = await client.exa("search", { query: "latest AI research", numResults: 5 });
+   */
+  async exa(path5, body) {
+    return this.requestWithPaymentRaw(`/v1/exa/${path5}`, body);
+  }
+  /**
+   * Neural and keyword web search via Exa (Solana payment, $0.01/request).
+   *
+   * @example
+   * const results = await client.exaSearch("latest AI papers", { numResults: 5 });
+   */
+  async exaSearch(query, options) {
+    return this.requestWithPaymentRaw("/v1/exa/search", { query, ...options });
+  }
+  /**
+   * Find pages semantically similar to a given URL via Exa (Solana payment, $0.01/request).
+   *
+   * @example
+   * const results = await client.exaFindSimilar("https://openai.com/research/gpt-4", { numResults: 5 });
+   */
+  async exaFindSimilar(url, options) {
+    return this.requestWithPaymentRaw("/v1/exa/find-similar", { url, ...options });
+  }
+  /**
+   * Extract full text content from URLs via Exa (Solana payment, $0.002/URL).
+   *
+   * @example
+   * const data = await client.exaContents(["https://arxiv.org/abs/2303.08774"]);
+   */
+  async exaContents(urls, options) {
+    return this.requestWithPaymentRaw("/v1/exa/contents", { urls, ...options });
+  }
+  /**
+   * AI-generated answer grounded in live web search via Exa (Solana payment, $0.01/request).
+   *
+   * @example
+   * const answer = await client.exaAnswer("What is the current state of AI safety research?");
+   */
+  async exaAnswer(query, options) {
+    return this.requestWithPaymentRaw("/v1/exa/answer", { query, ...options });
+  }
   /** Get session spending. */
   getSpending() {
     return { totalUsd: this.sessionTotalUsd, calls: this.sessionCalls };
@@ -2214,6 +2644,8 @@ import * as path3 from "path";
 import * as os3 from "os";
 import * as crypto2 from "crypto";
 var CACHE_DIR = path3.join(os3.homedir(), ".blockrun", "cache");
+var DATA_DIR = path3.join(os3.homedir(), ".blockrun", "data");
+var COST_LOG_FILE = path3.join(os3.homedir(), ".blockrun", "cost_log.jsonl");
 var DEFAULT_TTL = {
   "/v1/x/": 3600 * 1e3,
   "/v1/partner/": 3600 * 1e3,
@@ -2278,26 +2710,80 @@ function setCache(key, data, ttlMs) {
   } catch {
   }
 }
-function saveToCache(endpoint, body, response, costUsd = 0) {
-  const ttl = getTtl(endpoint);
-  if (ttl <= 0) return;
+function readableFilename(endpoint, body) {
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().slice(0, 10) + "_" + String(now.getHours()).padStart(2, "0") + String(now.getMinutes()).padStart(2, "0") + String(now.getSeconds()).padStart(2, "0");
+  let ep = endpoint.replace(/\/+$/, "").split("/").pop() || "";
+  if (endpoint.includes("/v1/chat/")) {
+    ep = "chat";
+  } else if (endpoint.includes("/v1/x/")) {
+    ep = "x_" + ep;
+  } else if (endpoint.includes("/v1/search")) {
+    ep = "search";
+  } else if (endpoint.includes("/v1/image")) {
+    ep = "image";
+  }
+  let label = body.query || body.username || body.handle || body.model || (typeof body.prompt === "string" ? body.prompt.slice(0, 40) : "") || "";
+  label = String(label).replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40).replace(/^_+|_+$/g, "");
+  return label ? `${ep}_${ts}_${label}.json` : `${ep}_${ts}.json`;
+}
+function saveReadable(endpoint, body, response, costUsd) {
   try {
-    fs3.mkdirSync(CACHE_DIR, { recursive: true });
+    fs3.mkdirSync(DATA_DIR, { recursive: true });
   } catch {
   }
-  const key = cacheKey(endpoint, body);
+  const filename = readableFilename(endpoint, body);
   const entry = {
-    cachedAt: Date.now(),
+    saved_at: (/* @__PURE__ */ new Date()).toISOString(),
     endpoint,
-    body,
-    response,
-    costUsd
+    cost_usd: costUsd,
+    request: body,
+    response
   };
   try {
-    fs3.writeFileSync(cachePath(key), JSON.stringify(entry));
+    fs3.writeFileSync(path3.join(DATA_DIR, filename), JSON.stringify(entry, null, 2));
   } catch {
   }
 }
+function appendCostLog(endpoint, costUsd) {
+  if (costUsd <= 0) return;
+  try {
+    fs3.mkdirSync(path3.dirname(COST_LOG_FILE), { recursive: true });
+  } catch {
+  }
+  const entry = {
+    ts: Date.now() / 1e3,
+    endpoint,
+    cost_usd: costUsd
+  };
+  try {
+    fs3.appendFileSync(COST_LOG_FILE, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+function saveToCache(endpoint, body, response, costUsd = 0) {
+  const ttl = getTtl(endpoint);
+  if (ttl > 0) {
+    try {
+      fs3.mkdirSync(CACHE_DIR, { recursive: true });
+    } catch {
+    }
+    const key = cacheKey(endpoint, body);
+    const entry = {
+      cachedAt: Date.now(),
+      endpoint,
+      body,
+      response,
+      costUsd
+    };
+    try {
+      fs3.writeFileSync(cachePath(key), JSON.stringify(entry));
+    } catch {
+    }
+  }
+  saveReadable(endpoint, body, response, costUsd);
+  appendCostLog(endpoint, costUsd);
+}
 function clearCache() {
   if (!fs3.existsSync(CACHE_DIR)) return 0;
   let count = 0;
@@ -2316,6 +2802,32 @@ function clearCache() {
   }
   return count;
 }
+function getCostLogSummary() {
+  if (!fs3.existsSync(COST_LOG_FILE)) {
+    return { totalUsd: 0, calls: 0, byEndpoint: {} };
+  }
+  let totalUsd = 0;
+  let calls = 0;
+  const byEndpoint = {};
+  try {
+    const content = fs3.readFileSync(COST_LOG_FILE, "utf-8").trim();
+    if (!content) return { totalUsd: 0, calls: 0, byEndpoint: {} };
+    for (const line of content.split("\n")) {
+      if (!line) continue;
+      try {
+        const entry = JSON.parse(line);
+        const cost = entry.cost_usd ?? 0;
+        const ep = entry.endpoint ?? "unknown";
+        totalUsd += cost;
+        calls += 1;
+        byEndpoint[ep] = (byEndpoint[ep] || 0) + cost;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { totalUsd, calls, byEndpoint };
+}
 
 // src/setup.ts
 function setupAgentWallet(options) {
@@ -2357,27 +2869,27 @@ async function status() {
 import * as fs4 from "fs";
 import * as path4 from "path";
 import * as os4 from "os";
-var DATA_DIR = path4.join(os4.homedir(), ".blockrun", "data");
-var COST_LOG_FILE = path4.join(DATA_DIR, "costs.jsonl");
+var DATA_DIR2 = path4.join(os4.homedir(), ".blockrun", "data");
+var COST_LOG_FILE2 = path4.join(DATA_DIR2, "costs.jsonl");
 function logCost(entry) {
   try {
-    fs4.mkdirSync(DATA_DIR, { recursive: true });
+    fs4.mkdirSync(DATA_DIR2, { recursive: true });
   } catch {
   }
   try {
-    fs4.appendFileSync(COST_LOG_FILE, JSON.stringify(entry) + "\n");
+    fs4.appendFileSync(COST_LOG_FILE2, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
 function getCostSummary() {
-  if (!fs4.existsSync(COST_LOG_FILE)) {
+  if (!fs4.existsSync(COST_LOG_FILE2)) {
     return { totalUsd: 0, calls: 0, byModel: {} };
   }
   let totalUsd = 0;
   let calls = 0;
   const byModel = {};
   try {
-    const content = fs4.readFileSync(COST_LOG_FILE, "utf-8").trim();
+    const content = fs4.readFileSync(COST_LOG_FILE2, "utf-8").trim();
     if (!content) return { totalUsd: 0, calls: 0, byModel: {} };
     for (const line of content.split("\n")) {
       if (!line) continue;
@@ -2476,46 +2988,18 @@ var ChatCompletions = class {
     return this.transformResponse(response);
   }
   async createStream(params) {
-    const url = `${this.apiUrl}/v1/chat/completions`;
-    const body = {
-      model: params.model,
-      messages: params.messages,
-      max_tokens: params.max_tokens || 1024,
-      temperature: params.temperature,
-      top_p: params.top_p,
-      stream: true
-    };
-    if (params.tools) {
-      body.tools = params.tools;
-    }
-    if (params.tool_choice) {
-      body.tool_choice = params.tool_choice;
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        signal: controller.signal
-      });
-      if (response.status === 402) {
-        const paymentHeader = response.headers.get("payment-required");
-        if (!paymentHeader) {
-          throw new Error("402 response but no payment requirements found");
-        }
-        throw new Error(
-          "Streaming with automatic payment requires direct wallet access. Please use non-streaming mode or contact support for streaming setup."
-        );
-      }
-      if (!response.ok) {
-        throw new Error(`API error: ${response.status}`);
+    const response = await this.client.chatCompletionStream(
+      params.model,
+      params.messages,
+      {
+        maxTokens: params.max_tokens,
+        temperature: params.temperature,
+        topP: params.top_p,
+        tools: params.tools,
+        toolChoice: params.tool_choice
       }
-      return new StreamingResponse(response, params.model);
-    } finally {
-      clearTimeout(timeoutId);
-    }
+    );
+    return new StreamingResponse(response, params.model);
   }
   transformResponse(response) {
     return {
@@ -2678,6 +3162,7 @@ export {
   BASE_CHAIN_ID,
   BlockrunError,
   ImageClient,
+  KNOWN_PROVIDERS,
   LLMClient,
   OpenAI,
   PaymentError,
@@ -2701,6 +3186,7 @@ export {
   formatWalletCreatedMessage,
   getCached,
   getCachedByRequest,
+  getCostLogSummary,
   getCostSummary,
   getEip681Uri,
   getOrCreateSolanaWallet,
@@ -2723,5 +3209,9 @@ export {
   solanaKeyToBytes,
   solanaPublicKey,
   status,
-  testnetClient
+  testnetClient,
+  validateMaxTokens,
+  validateModel,
+  validateTemperature,
+  validateTopP
 };