@blockrun/llm 1.2.0 → 1.3.1

package/dist/index.js

@@ -670,6 +670,103 @@ var LLMClient = class {
     this.sessionTotalUsd += costUsd;
     return retryResponse.json();
   }
+  /**
+   * GET with automatic x402 payment handling, returning raw JSON.
+   * Used for Predexon prediction market endpoints that use GET + query params.
+   */
+  async getWithPaymentRaw(endpoint, params) {
+    const query = params ? "?" + new URLSearchParams(params).toString() : "";
+    const url = `${this.apiUrl}${endpoint}${query}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: { "User-Agent": USER_AGENT }
+    });
+    if (response.status === 402) {
+      return this.handleGetPaymentAndRetryRaw(url, endpoint, params, response);
+    }
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(
+        `API error: ${response.status}`,
+        response.status,
+        sanitizeErrorResponse(errorBody)
+      );
+    }
+    return response.json();
+  }
+  /**
+   * Handle 402 response for GET endpoints: parse requirements, sign payment, retry with GET.
+   */
+  async handleGetPaymentAndRetryRaw(url, endpoint, params, response) {
+    let paymentHeader = response.headers.get("payment-required");
+    if (!paymentHeader) {
+      try {
+        const respBody = await response.json();
+        if (respBody.x402 || respBody.accepts) {
+          paymentHeader = btoa(JSON.stringify(respBody));
+        }
+      } catch {
+        console.debug("Failed to parse payment header from response body");
+      }
+    }
+    if (!paymentHeader) {
+      throw new PaymentError("402 response but no payment requirements found");
+    }
+    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 || url,
+          this.apiUrl
+        ),
+        resourceDescription: details.resource?.description || "BlockRun AI API call",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra,
+        extensions
+      }
+    );
+    const query = params ? "?" + new URLSearchParams(params).toString() : "";
+    const retryUrl = `${this.apiUrl}${endpoint}${query}`;
+    const retryResponse = await this.fetchWithTimeout(retryUrl, {
+      method: "GET",
+      headers: {
+        "User-Agent": USER_AGENT,
+        "PAYMENT-SIGNATURE": paymentPayload
+      }
+    });
+    if (retryResponse.status === 402) {
+      throw new PaymentError("Payment was rejected. Check your wallet balance.");
+    }
+    if (!retryResponse.ok) {
+      let errorBody;
+      try {
+        errorBody = await retryResponse.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(
+        `API error after payment: ${retryResponse.status}`,
+        retryResponse.status,
+        sanitizeErrorResponse(errorBody)
+      );
+    }
+    const costUsd = parseFloat(details.amount) / 1e6;
+    this.sessionCalls += 1;
+    this.sessionTotalUsd += costUsd;
+    return retryResponse.json();
+  }
   /**
    * Fetch with timeout.
    */
@@ -1031,6 +1128,38 @@ var LLMClient = class {
     const data = await this.requestWithPaymentRaw("/v1/x/compare", { handle1, handle2 });
     return data;
   }
+  // ── Prediction Markets (Powered by Predexon) ────────────────────────────
+  /**
+   * Query Predexon prediction market data (GET endpoints).
+   *
+   * Access real-time data from Polymarket, Kalshi, dFlow, and Binance Futures.
+   * Powered by Predexon. $0.001 per request.
+   *
+   * @param path - Endpoint path, e.g. "polymarket/events", "kalshi/markets/12345"
+   * @param params - Query parameters passed to the endpoint
+   *
+   * @example
+   * const events = await client.pm("polymarket/events");
+   * const market = await client.pm("kalshi/markets/KXBTC-25MAR14");
+   * const results = await client.pm("polymarket/search", { q: "bitcoin" });
+   */
+  async pm(path5, params) {
+    return this.getWithPaymentRaw(`/v1/pm/${path5}`, params);
+  }
+  /**
+   * Structured query for Predexon prediction market data (POST endpoints).
+   *
+   * For complex queries that require a JSON body. $0.005 per request.
+   *
+   * @param path - Endpoint path, e.g. "polymarket/query", "kalshi/query"
+   * @param query - JSON body for the structured query
+   *
+   * @example
+   * const data = await client.pmQuery("polymarket/query", { filter: "active", limit: 10 });
+   */
+  async pmQuery(path5, query) {
+    return this.requestWithPaymentRaw(`/v1/pm/${path5}`, query);
+  }
   /**
    * Get current session spending.
    *
@@ -1316,7 +1445,35 @@ function saveWallet(privateKey) {
   fs.writeFileSync(WALLET_FILE, privateKey, { mode: 384 });
   return WALLET_FILE;
 }
+function scanWallets() {
+  const home = os.homedir();
+  const results = [];
+  try {
+    const entries = fs.readdirSync(home, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.name.startsWith(".") || !entry.isDirectory()) continue;
+      const walletFile = path.join(home, entry.name, "wallet.json");
+      if (!fs.existsSync(walletFile)) continue;
+      try {
+        const data = JSON.parse(fs.readFileSync(walletFile, "utf-8"));
+        const pk = data.privateKey || "";
+        const addr = data.address || "";
+        if (pk && addr) {
+          const mtime = fs.statSync(walletFile).mtimeMs;
+          results.push({ mtime, privateKey: pk, address: addr });
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  results.sort((a, b) => b.mtime - a.mtime);
+  return results.map(({ privateKey, address }) => ({ privateKey, address }));
+}
 function loadWallet() {
+  const wallets = scanWallets();
+  if (wallets.length > 0) return wallets[0].privateKey;
   if (fs.existsSync(WALLET_FILE)) {
     const key = fs.readFileSync(WALLET_FILE, "utf-8").trim();
     if (key) return key;
@@ -1455,7 +1612,50 @@ function saveSolanaWallet(privateKey) {
   fs2.writeFileSync(SOLANA_WALLET_FILE, privateKey, { mode: 384 });
   return SOLANA_WALLET_FILE;
 }
+function scanSolanaWallets() {
+  const home = os2.homedir();
+  const results = [];
+  try {
+    const entries = fs2.readdirSync(home, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.name.startsWith(".") || !entry.isDirectory()) continue;
+      const solanaWalletFile = path2.join(home, entry.name, "solana-wallet.json");
+      if (fs2.existsSync(solanaWalletFile)) {
+        try {
+          const data = JSON.parse(fs2.readFileSync(solanaWalletFile, "utf-8"));
+          const pk = data.privateKey || "";
+          const addr = data.address || "";
+          if (pk && addr) {
+            const mtime = fs2.statSync(solanaWalletFile).mtimeMs;
+            results.push({ mtime, secretKey: pk, publicKey: addr });
+          }
+        } catch {
+        }
+      }
+      if (entry.name === ".brcc") {
+        const brccWalletFile = path2.join(home, entry.name, "wallet.json");
+        if (fs2.existsSync(brccWalletFile)) {
+          try {
+            const data = JSON.parse(fs2.readFileSync(brccWalletFile, "utf-8"));
+            const pk = data.privateKey || "";
+            const addr = data.address || "";
+            if (pk && addr) {
+              const mtime = fs2.statSync(brccWalletFile).mtimeMs;
+              results.push({ mtime, secretKey: pk, publicKey: addr });
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  results.sort((a, b) => b.mtime - a.mtime);
+  return results.map(({ secretKey, publicKey }) => ({ secretKey, publicKey }));
+}
 function loadSolanaWallet() {
+  const wallets = scanSolanaWallets();
+  if (wallets.length > 0) return wallets[0].secretKey;
   if (fs2.existsSync(SOLANA_WALLET_FILE)) {
     const key = fs2.readFileSync(SOLANA_WALLET_FILE, "utf-8").trim();
     if (key) return key;
@@ -1468,10 +1668,16 @@ async function getOrCreateSolanaWallet() {
     const address2 = await solanaPublicKey(envKey);
     return { privateKey: envKey, address: address2, isNew: false };
   }
-  const fileKey = loadSolanaWallet();
-  if (fileKey) {
-    const address2 = await solanaPublicKey(fileKey);
-    return { privateKey: fileKey, address: address2, isNew: false };
+  const wallets = scanSolanaWallets();
+  if (wallets.length > 0) {
+    return { privateKey: wallets[0].secretKey, address: wallets[0].publicKey, isNew: false };
+  }
+  if (fs2.existsSync(SOLANA_WALLET_FILE)) {
+    const fileKey = fs2.readFileSync(SOLANA_WALLET_FILE, "utf-8").trim();
+    if (fileKey) {
+      const address2 = await solanaPublicKey(fileKey);
+      return { privateKey: fileKey, address: address2, isNew: false };
+    }
   }
   const { address, privateKey } = createSolanaWallet();
   saveSolanaWallet(privateKey);
@@ -1689,6 +1895,13 @@ var SolanaLLMClient = class {
     const data = await this.requestWithPaymentRaw("/v1/x/compare", { handle1, handle2 });
     return data;
   }
+  // ── Prediction Markets (Powered by Predexon) ────────────────────────────
+  async pm(path5, params) {
+    return this.getWithPaymentRaw(`/v1/pm/${path5}`, params);
+  }
+  async pmQuery(path5, query) {
+    return this.requestWithPaymentRaw(`/v1/pm/${path5}`, query);
+  }
   /** Get session spending. */
   getSpending() {
     return { totalUsd: this.sessionTotalUsd, calls: this.sessionCalls };
@@ -1879,6 +2092,97 @@ var SolanaLLMClient = class {
     this.sessionTotalUsd += costUsd;
     return retryResponse.json();
   }
+  async getWithPaymentRaw(endpoint, params) {
+    const query = params ? "?" + new URLSearchParams(params).toString() : "";
+    const url = `${this.apiUrl}${endpoint}${query}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: { "User-Agent": USER_AGENT2 }
+    });
+    if (response.status === 402) {
+      return this.handleGetPaymentAndRetryRaw(url, endpoint, params, response);
+    }
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(`API error: ${response.status}`, response.status, sanitizeErrorResponse(errorBody));
+    }
+    return response.json();
+  }
+  async handleGetPaymentAndRetryRaw(url, endpoint, params, response) {
+    let paymentHeader = response.headers.get("payment-required");
+    if (!paymentHeader) {
+      try {
+        const respBody = await response.json();
+        if (respBody.accepts || respBody.x402Version) {
+          paymentHeader = btoa(JSON.stringify(respBody));
+        }
+      } catch {
+      }
+    }
+    if (!paymentHeader) {
+      throw new PaymentError("402 response but no payment requirements found");
+    }
+    const paymentRequired = parsePaymentRequired(paymentHeader);
+    const details = extractPaymentDetails(paymentRequired, SOLANA_NETWORK);
+    if (!details.network?.startsWith("solana:")) {
+      throw new PaymentError(
+        `Expected Solana payment network, got: ${details.network}. Use LLMClient for Base payments.`
+      );
+    }
+    const feePayer = details.extra?.feePayer;
+    if (!feePayer) throw new PaymentError("Missing feePayer in 402 extra field");
+    const fromAddress = await this.getWalletAddress();
+    const secretKey = await solanaKeyToBytes(this.privateKey);
+    const extensions = paymentRequired.extensions;
+    const paymentPayload = await createSolanaPaymentPayload(
+      secretKey,
+      fromAddress,
+      details.recipient,
+      details.amount,
+      feePayer,
+      {
+        resourceUrl: validateResourceUrl(
+          details.resource?.url || url,
+          this.apiUrl
+        ),
+        resourceDescription: details.resource?.description || "BlockRun Solana AI API call",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra,
+        extensions,
+        rpcUrl: this.rpcUrl
+      }
+    );
+    const query = params ? "?" + new URLSearchParams(params).toString() : "";
+    const retryUrl = `${this.apiUrl}${endpoint}${query}`;
+    const retryResponse = await this.fetchWithTimeout(retryUrl, {
+      method: "GET",
+      headers: {
+        "User-Agent": USER_AGENT2,
+        "PAYMENT-SIGNATURE": paymentPayload
+      }
+    });
+    if (retryResponse.status === 402) {
+      throw new PaymentError("Payment was rejected. Check your Solana USDC balance.");
+    }
+    if (!retryResponse.ok) {
+      let errorBody;
+      try {
+        errorBody = await retryResponse.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(`API error after payment: ${retryResponse.status}`, retryResponse.status, sanitizeErrorResponse(errorBody));
+    }
+    const costUsd = parseFloat(details.amount) / 1e6;
+    this.sessionCalls += 1;
+    this.sessionTotalUsd += costUsd;
+    return retryResponse.json();
+  }
   async fetchWithTimeout(url, options) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.timeout);
@@ -1893,6 +2197,192 @@ function solanaClient(options = {}) {
   return new SolanaLLMClient({ ...options, apiUrl: SOLANA_API_URL });
 }
 
+// src/cache.ts
+import * as fs3 from "fs";
+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 DEFAULT_TTL = {
+  "/v1/x/": 3600 * 1e3,
+  "/v1/partner/": 3600 * 1e3,
+  "/v1/pm/": 1800 * 1e3,
+  "/v1/chat/": 0,
+  "/v1/search": 900 * 1e3,
+  "/v1/image": 0,
+  "/v1/models": 86400 * 1e3
+};
+function getTtl(endpoint) {
+  for (const [pattern, ttl] of Object.entries(DEFAULT_TTL)) {
+    if (endpoint.includes(pattern)) return ttl;
+  }
+  return 3600 * 1e3;
+}
+function cacheKey(endpoint, body) {
+  const keyData = JSON.stringify({ endpoint, body }, Object.keys({ endpoint, body }).sort());
+  return crypto2.createHash("sha256").update(keyData).digest("hex").slice(0, 16);
+}
+function cachePath(key) {
+  return path3.join(CACHE_DIR, `${key}.json`);
+}
+function getCached(key) {
+  const filePath = cachePath(key);
+  if (!fs3.existsSync(filePath)) return null;
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    const entry = JSON.parse(raw);
+    const ttl = entry.ttlMs ?? getTtl(entry.endpoint ?? "");
+    if (ttl <= 0) return null;
+    if (Date.now() - entry.cachedAt > ttl) {
+      try {
+        fs3.unlinkSync(filePath);
+      } catch {
+      }
+      return null;
+    }
+    return entry.response;
+  } catch {
+    return null;
+  }
+}
+function getCachedByRequest(endpoint, body) {
+  const ttl = getTtl(endpoint);
+  if (ttl <= 0) return null;
+  const key = cacheKey(endpoint, body);
+  return getCached(key);
+}
+function setCache(key, data, ttlMs) {
+  if (ttlMs <= 0) return;
+  try {
+    fs3.mkdirSync(CACHE_DIR, { recursive: true });
+  } catch {
+  }
+  const entry = {
+    cachedAt: Date.now(),
+    response: data,
+    ttlMs
+  };
+  try {
+    fs3.writeFileSync(cachePath(key), JSON.stringify(entry));
+  } catch {
+  }
+}
+function saveToCache(endpoint, body, response, costUsd = 0) {
+  const ttl = getTtl(endpoint);
+  if (ttl <= 0) return;
+  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 {
+  }
+}
+function clearCache() {
+  if (!fs3.existsSync(CACHE_DIR)) return 0;
+  let count = 0;
+  try {
+    const files = fs3.readdirSync(CACHE_DIR);
+    for (const file of files) {
+      if (file.endsWith(".json")) {
+        try {
+          fs3.unlinkSync(path3.join(CACHE_DIR, file));
+          count++;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return count;
+}
+
+// src/setup.ts
+function setupAgentWallet(options) {
+  const { address, privateKey, isNew } = getOrCreateWallet();
+  if (isNew && !options?.silent) {
+    console.error(
+      `
+BlockRun Agent Wallet Created!
+Address: ${address}
+Send USDC on Base to get started.
+`
+    );
+  }
+  return new LLMClient({ privateKey });
+}
+async function setupAgentSolanaWallet(options) {
+  const result = await getOrCreateSolanaWallet();
+  if (result.isNew && !options?.silent) {
+    console.error(
+      `
+BlockRun Solana Agent Wallet Created!
+Address: ${result.address}
+Send USDC on Solana to get started.
+`
+    );
+  }
+  return new SolanaLLMClient({ privateKey: result.privateKey });
+}
+async function status() {
+  const client = setupAgentWallet({ silent: true });
+  const address = client.getWalletAddress();
+  const balance = await client.getBalance();
+  console.log(`Wallet: ${address}`);
+  console.log(`Balance: $${balance.toFixed(2)} USDC`);
+  return { address, balance };
+}
+
+// src/cost-log.ts
+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");
+function logCost(entry) {
+  try {
+    fs4.mkdirSync(DATA_DIR, { recursive: true });
+  } catch {
+  }
+  try {
+    fs4.appendFileSync(COST_LOG_FILE, JSON.stringify(entry) + "\n");
+  } catch {
+  }
+}
+function getCostSummary() {
+  if (!fs4.existsSync(COST_LOG_FILE)) {
+    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();
+    if (!content) return { totalUsd: 0, calls: 0, byModel: {} };
+    for (const line of content.split("\n")) {
+      if (!line) continue;
+      try {
+        const entry = JSON.parse(line);
+        totalUsd += entry.costUsd;
+        calls += 1;
+        byModel[entry.model] = (byModel[entry.model] || 0) + entry.costUsd;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { totalUsd, calls, byModel };
+}
+
 // src/openai-compat.ts
 var StreamingResponse = class {
   reader;
@@ -2078,6 +2568,7 @@ export {
   USDC_SOLANA,
   WALLET_DIR_PATH,
   WALLET_FILE_PATH,
+  clearCache,
   createSolanaPaymentPayload,
   createSolanaWallet,
   createWallet,
@@ -2085,6 +2576,9 @@ export {
   formatFundingMessageCompact,
   formatNeedsFundingMessage,
   formatWalletCreatedMessage,
+  getCached,
+  getCachedByRequest,
+  getCostSummary,
   getEip681Uri,
   getOrCreateSolanaWallet,
   getOrCreateWallet,
@@ -2092,10 +2586,18 @@ export {
   getWalletAddress,
   loadSolanaWallet,
   loadWallet,
+  logCost,
   saveSolanaWallet,
+  saveToCache,
   saveWallet,
+  scanSolanaWallets,
+  scanWallets,
+  setCache,
+  setupAgentSolanaWallet,
+  setupAgentWallet,
   solanaClient,
   solanaKeyToBytes,
   solanaPublicKey,
+  status,
   testnetClient
 };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@blockrun/llm",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "type": "module",
-  "description": "BlockRun LLM Gateway SDK - Pay-per-request AI via x402 on Base",
+  "description": "BlockRun LLM Gateway SDK - Pay-per-request AI via x402 on Base and Solana",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",