@blockrun/llm 1.4.1 → 1.4.2

package/dist/index.js

@@ -0,0 +1,2716 @@
+import {
+  __require,
+  __toCommonJS,
+  index_esm_exports,
+  init_index_esm
+} from "./chunk-KRDGCX7W.js";
+
+// src/client.ts
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/types.ts
+var BlockrunError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BlockrunError";
+  }
+};
+var PaymentError = class extends BlockrunError {
+  constructor(message) {
+    super(message);
+    this.name = "PaymentError";
+  }
+};
+var APIError = class extends BlockrunError {
+  statusCode;
+  response;
+  constructor(message, statusCode, response) {
+    super(message);
+    this.name = "APIError";
+    this.statusCode = statusCode;
+    this.response = response;
+  }
+};
+
+// src/client.ts
+import { route, DEFAULT_ROUTING_CONFIG } from "@blockrun/clawrouter";
+
+// src/x402.ts
+import { signTypedData } from "viem/accounts";
+var BASE_CHAIN_ID = 8453;
+var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var SOLANA_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var USDC_SOLANA = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1;
+var DEFAULT_COMPUTE_UNIT_LIMIT = 8e3;
+var USDC_DOMAIN = {
+  name: "USD Coin",
+  version: "2",
+  chainId: BASE_CHAIN_ID,
+  verifyingContract: USDC_BASE
+};
+var TRANSFER_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function createNonce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+async function createPaymentPayload(privateKey, fromAddress, recipient, amount, network = "eip155:8453", options = {}) {
+  const now = Math.floor(Date.now() / 1e3);
+  const validAfter = now - 600;
+  const validBefore = now + (options.maxTimeoutSeconds || 300);
+  const nonce = createNonce();
+  const domain = USDC_DOMAIN;
+  const signature = await signTypedData({
+    privateKey,
+    domain,
+    types: TRANSFER_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: fromAddress,
+      to: recipient,
+      value: BigInt(amount),
+      validAfter: BigInt(validAfter),
+      validBefore: BigInt(validBefore),
+      nonce
+    }
+  });
+  const paymentData = {
+    x402Version: 2,
+    resource: {
+      url: options.resourceUrl || "https://blockrun.ai/api/v1/chat/completions",
+      description: options.resourceDescription || "BlockRun AI API call",
+      mimeType: "application/json"
+    },
+    accepted: {
+      scheme: "exact",
+      network,
+      amount,
+      asset: USDC_BASE,
+      payTo: recipient,
+      maxTimeoutSeconds: options.maxTimeoutSeconds || 300,
+      extra: { name: "USD Coin", version: "2" }
+    },
+    payload: {
+      signature,
+      authorization: {
+        from: fromAddress,
+        to: recipient,
+        value: amount,
+        validAfter: validAfter.toString(),
+        validBefore: validBefore.toString(),
+        nonce
+      }
+    },
+    extensions: options.extensions || {}
+  };
+  return btoa(JSON.stringify(paymentData));
+}
+async function createSolanaPaymentPayload(secretKey, fromAddress, recipient, amount, feePayer, options = {}) {
+  const { Connection, PublicKey, TransactionMessage, VersionedTransaction, ComputeBudgetProgram } = await import("./index.esm-SXKIFLA7.js");
+  const { getAssociatedTokenAddress, createTransferCheckedInstruction, getMint } = await import("./esm-PTFDM6PE.js");
+  const { Keypair } = await import("./index.esm-SXKIFLA7.js");
+  const rpcUrl = options.rpcUrl || "https://api.mainnet-beta.solana.com";
+  const connection = new Connection(rpcUrl);
+  const keypair = Keypair.fromSecretKey(secretKey);
+  const feePayerPubkey = new PublicKey(feePayer);
+  const ownerPubkey = keypair.publicKey;
+  const tokenMint = new PublicKey(USDC_SOLANA);
+  const payToPubkey = new PublicKey(recipient);
+  const mintInfo = await getMint(connection, tokenMint);
+  const sourceATA = await getAssociatedTokenAddress(tokenMint, ownerPubkey, false);
+  const destinationATA = await getAssociatedTokenAddress(tokenMint, payToPubkey, false);
+  const { blockhash } = await connection.getLatestBlockhash();
+  const setComputeUnitPriceIx = ComputeBudgetProgram.setComputeUnitPrice({
+    microLamports: DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS
+  });
+  const setComputeUnitLimitIx = ComputeBudgetProgram.setComputeUnitLimit({
+    units: DEFAULT_COMPUTE_UNIT_LIMIT
+  });
+  const transferIx = createTransferCheckedInstruction(
+    sourceATA,
+    tokenMint,
+    destinationATA,
+    ownerPubkey,
+    BigInt(amount),
+    mintInfo.decimals
+  );
+  const messageV0 = new TransactionMessage({
+    payerKey: feePayerPubkey,
+    recentBlockhash: blockhash,
+    instructions: [setComputeUnitLimitIx, setComputeUnitPriceIx, transferIx]
+  }).compileToV0Message();
+  const transaction = new VersionedTransaction(messageV0);
+  transaction.sign([keypair]);
+  const serializedTx = Buffer.from(transaction.serialize()).toString("base64");
+  const paymentData = {
+    x402Version: 2,
+    resource: {
+      url: options.resourceUrl || "https://blockrun.ai/api/v1/chat/completions",
+      description: options.resourceDescription || "BlockRun AI API call",
+      mimeType: "application/json"
+    },
+    accepted: {
+      scheme: "exact",
+      network: SOLANA_NETWORK,
+      amount,
+      asset: USDC_SOLANA,
+      payTo: recipient,
+      maxTimeoutSeconds: options.maxTimeoutSeconds || 300,
+      extra: options.extra || { feePayer }
+    },
+    payload: {
+      transaction: serializedTx
+    },
+    extensions: options.extensions || {}
+  };
+  return btoa(JSON.stringify(paymentData));
+}
+function parsePaymentRequired(headerValue) {
+  try {
+    const decoded = atob(headerValue);
+    const parsed = JSON.parse(decoded);
+    if (!parsed.accepts || !Array.isArray(parsed.accepts)) {
+      throw new Error("Invalid payment required structure: missing or invalid 'accepts' field");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("Invalid payment required structure")) {
+        throw error;
+      }
+      throw new Error("Failed to parse payment required header: invalid format");
+    }
+    throw new Error("Failed to parse payment required header");
+  }
+}
+function extractPaymentDetails(paymentRequired, preferredNetwork) {
+  const accepts = paymentRequired.accepts || [];
+  if (accepts.length === 0) {
+    throw new Error("No payment options in payment required response");
+  }
+  let option = null;
+  if (preferredNetwork) {
+    option = accepts.find((opt) => opt.network === preferredNetwork) || null;
+  }
+  if (!option) {
+    option = accepts[0];
+  }
+  const amount = option.amount || option.maxAmountRequired;
+  if (!amount) {
+    throw new Error("No amount found in payment requirements");
+  }
+  return {
+    amount,
+    recipient: option.payTo,
+    network: option.network,
+    asset: option.asset,
+    scheme: option.scheme,
+    maxTimeoutSeconds: option.maxTimeoutSeconds || 300,
+    extra: option.extra,
+    resource: paymentRequired.resource
+  };
+}
+
+// src/validation.ts
+var LOCALHOST_DOMAINS = ["localhost", "127.0.0.1"];
+function validatePrivateKey(key) {
+  if (typeof key !== "string") {
+    throw new Error("Private key must be a string");
+  }
+  if (!key.startsWith("0x")) {
+    throw new Error("Private key must start with 0x");
+  }
+  if (key.length !== 66) {
+    throw new Error(
+      "Private key must be 66 characters (0x + 64 hexadecimal characters)"
+    );
+  }
+  if (!/^0x[0-9a-fA-F]{64}$/.test(key)) {
+    throw new Error(
+      "Private key must contain only hexadecimal characters (0-9, a-f, A-F)"
+    );
+  }
+}
+function validateApiUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error("Invalid API URL format");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(
+      `Invalid protocol: ${parsed.protocol}. Use http:// or https://`
+    );
+  }
+  const isLocalhost = LOCALHOST_DOMAINS.includes(parsed.hostname);
+  if (parsed.protocol !== "https:" && !isLocalhost) {
+    throw new Error(
+      `API URL must use HTTPS for non-localhost endpoints. Use https:// instead of ${parsed.protocol}//`
+    );
+  }
+}
+function sanitizeErrorResponse(errorBody) {
+  if (typeof errorBody !== "object" || errorBody === null) {
+    return { message: "API request failed" };
+  }
+  const body = errorBody;
+  return {
+    message: typeof body.error === "string" ? body.error : "API request failed",
+    code: typeof body.code === "string" ? body.code : void 0
+  };
+}
+function validateResourceUrl(url, baseUrl) {
+  try {
+    const parsed = new URL(url);
+    const baseParsed = new URL(baseUrl);
+    if (parsed.hostname !== baseParsed.hostname) {
+      console.warn(
+        `Resource URL hostname mismatch: ${parsed.hostname} vs ${baseParsed.hostname}. Using safe default instead.`
+      );
+      return `${baseUrl}/v1/chat/completions`;
+    }
+    if (parsed.protocol !== baseParsed.protocol) {
+      console.warn(
+        `Resource URL protocol mismatch: ${parsed.protocol} vs ${baseParsed.protocol}. Using safe default instead.`
+      );
+      return `${baseUrl}/v1/chat/completions`;
+    }
+    return url;
+  } catch {
+    console.warn(`Invalid resource URL format: ${url}. Using safe default.`);
+    return `${baseUrl}/v1/chat/completions`;
+  }
+}
+
+// src/client.ts
+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 USER_AGENT = `blockrun-ts/${SDK_VERSION}`;
+var LLMClient = class {
+  static DEFAULT_API_URL = DEFAULT_API_URL;
+  static TESTNET_API_URL = TESTNET_API_URL;
+  account;
+  privateKey;
+  apiUrl;
+  timeout;
+  sessionTotalUsd = 0;
+  sessionCalls = 0;
+  modelPricingCache = null;
+  modelPricingPromise = null;
+  /**
+   * Initialize the BlockRun LLM client.
+   *
+   * @param options - Client configuration options (optional if BASE_CHAIN_WALLET_KEY env var is set)
+   */
+  constructor(options = {}) {
+    const envKey = typeof process !== "undefined" && process.env ? process.env.BASE_CHAIN_WALLET_KEY : void 0;
+    const privateKey = options.privateKey || envKey;
+    if (!privateKey) {
+      throw new Error(
+        "Private key required. Pass privateKey in options or set BASE_CHAIN_WALLET_KEY environment variable."
+      );
+    }
+    validatePrivateKey(privateKey);
+    this.privateKey = privateKey;
+    this.account = privateKeyToAccount(privateKey);
+    const apiUrl = options.apiUrl || DEFAULT_API_URL;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+  }
+  /**
+   * Simple 1-line chat interface.
+   *
+   * @param model - Model ID (e.g., 'openai/gpt-4o', 'anthropic/claude-sonnet-4')
+   * @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?');
+   * console.log(response); // 'The capital of France is Paris.'
+   */
+  async chat(model, prompt, options) {
+    const messages = [];
+    if (options?.system) {
+      messages.push({ role: "system", content: options.system });
+    }
+    messages.push({ role: "user", content: prompt });
+    const result = await this.chatCompletion(model, messages, {
+      maxTokens: options?.maxTokens,
+      temperature: options?.temperature,
+      topP: options?.topP,
+      search: options?.search,
+      searchParameters: options?.searchParameters
+    });
+    return result.choices[0].message.content || "";
+  }
+  /**
+   * Smart chat with automatic model routing.
+   *
+   * Uses ClawRouter's 14-dimension rule-based scoring algorithm (<1ms, 100% local)
+   * to select the cheapest model that can handle your request.
+   *
+   * @param prompt - User message
+   * @param options - Optional chat and routing parameters
+   * @returns SmartChatResponse with response text, selected model, and routing metadata
+   *
+   * @example Simple usage (auto profile)
+   * ```ts
+   * const result = await client.smartChat('What is 2+2?');
+   * console.log(result.response); // '4'
+   * console.log(result.model); // 'google/gemini-2.5-flash-lite'
+   * console.log(result.routing.savings); // 0.78 (78% savings)
+   * ```
+   *
+   * @example With routing profile
+   * ```ts
+   * // Free tier only (zero cost)
+   * const result = await client.smartChat('Hello!', { routingProfile: 'free' });
+   *
+   * // Eco mode (budget optimized)
+   * const result = await client.smartChat('Explain quantum computing', { routingProfile: 'eco' });
+   *
+   * // Premium mode (best quality)
+   * const result = await client.smartChat('Write a business plan', { routingProfile: 'premium' });
+   * ```
+   */
+  async smartChat(prompt, options) {
+    const modelPricing = await this.getModelPricing();
+    const maxOutputTokens = options?.maxOutputTokens || options?.maxTokens || 1024;
+    const decision = route(prompt, options?.system, maxOutputTokens, {
+      config: DEFAULT_ROUTING_CONFIG,
+      modelPricing,
+      routingProfile: options?.routingProfile
+    });
+    const response = await this.chat(decision.model, prompt, {
+      system: options?.system,
+      maxTokens: options?.maxTokens,
+      temperature: options?.temperature,
+      topP: options?.topP,
+      search: options?.search,
+      searchParameters: options?.searchParameters
+    });
+    return {
+      response,
+      model: decision.model,
+      routing: decision
+    };
+  }
+  /**
+   * Get model pricing map (cached).
+   * Fetches from API on first call, then returns cached result.
+   */
+  async getModelPricing() {
+    if (this.modelPricingCache) {
+      return this.modelPricingCache;
+    }
+    if (this.modelPricingPromise) {
+      return this.modelPricingPromise;
+    }
+    this.modelPricingPromise = this.fetchModelPricing();
+    try {
+      this.modelPricingCache = await this.modelPricingPromise;
+      return this.modelPricingCache;
+    } finally {
+      this.modelPricingPromise = null;
+    }
+  }
+  /**
+   * Fetch model pricing from API.
+   */
+  async fetchModelPricing() {
+    const models = await this.listModels();
+    const pricing = /* @__PURE__ */ new Map();
+    for (const model of models) {
+      pricing.set(model.id, {
+        inputPrice: model.inputPrice,
+        outputPrice: model.outputPrice
+      });
+    }
+    return pricing;
+  }
+  /**
+   * Full chat completion interface (OpenAI-compatible).
+   *
+   * @param model - Model ID
+   * @param messages - Array of messages with role and content
+   * @param options - Optional completion parameters
+   * @returns ChatResponse object with choices and usage
+   */
+  async chatCompletion(model, messages, options) {
+    const body = {
+      model,
+      messages,
+      max_tokens: options?.maxTokens || DEFAULT_MAX_TOKENS
+    };
+    if (options?.temperature !== void 0) {
+      body.temperature = options.temperature;
+    }
+    if (options?.topP !== void 0) {
+      body.top_p = options.topP;
+    }
+    if (options?.searchParameters !== void 0) {
+      body.search_parameters = options.searchParameters;
+    } else if (options?.search === true) {
+      body.search_parameters = { mode: "on" };
+    }
+    if (options?.tools !== void 0) {
+      body.tools = options.tools;
+    }
+    if (options?.toolChoice !== void 0) {
+      body.tool_choice = options.toolChoice;
+    }
+    return this.requestWithPayment("/v1/chat/completions", body);
+  }
+  /**
+   * Make a request with automatic x402 payment handling.
+   */
+  async requestWithPayment(endpoint, body) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
+      body: JSON.stringify(body)
+    });
+    if (response.status === 402) {
+      return this.handlePaymentAndRetry(url, body, 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: parse requirements, sign payment, retry.
+   */
+  async handlePaymentAndRetry(url, body, 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 (parseError) {
+        console.debug("Failed to parse payment header from response body", parseError);
+      }
+    }
+    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 || `${this.apiUrl}/v1/chat/completions`,
+          this.apiUrl
+        ),
+        resourceDescription: details.resource?.description || "BlockRun AI API call",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra,
+        extensions
+      }
+    );
+    const retryResponse = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    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();
+  }
+  /**
+   * Make a request with automatic x402 payment handling, returning raw JSON.
+   * Used for non-ChatResponse endpoints (X/Twitter, search, image edit, etc.).
+   */
+  async requestWithPaymentRaw(endpoint, body) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT },
+      body: JSON.stringify(body)
+    });
+    if (response.status === 402) {
+      return this.handlePaymentAndRetryRaw(url, body, 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 raw endpoints: parse requirements, sign payment, retry.
+   */
+  async handlePaymentAndRetryRaw(url, body, 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 retryResponse = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    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();
+  }
+  /**
+   * 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.
+   */
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * List available LLM models with pricing.
+   */
+  async listModels() {
+    const response = await this.fetchWithTimeout(`${this.apiUrl}/v1/models`, {
+      method: "GET"
+    });
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = { error: "Request failed" };
+      }
+      throw new APIError(
+        `Failed to list models: ${response.status}`,
+        response.status,
+        sanitizeErrorResponse(errorBody)
+      );
+    }
+    const data = await response.json();
+    return data.data || [];
+  }
+  /**
+   * List available image generation models with pricing.
+   */
+  async listImageModels() {
+    const response = await this.fetchWithTimeout(
+      `${this.apiUrl}/v1/images/models`,
+      { method: "GET" }
+    );
+    if (!response.ok) {
+      throw new APIError(
+        `Failed to list image models: ${response.status}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    return data.data || [];
+  }
+  /**
+   * List all available models (both LLM and image) with pricing.
+   *
+   * @returns Array of all models with 'type' field ('llm' or 'image')
+   *
+   * @example
+   * const models = await client.listAllModels();
+   * for (const model of models) {
+   *   if (model.type === 'llm') {
+   *     console.log(`LLM: ${model.id} - $${model.inputPrice}/M input`);
+   *   } else {
+   *     console.log(`Image: ${model.id} - $${model.pricePerImage}/image`);
+   *   }
+   * }
+   */
+  async listAllModels() {
+    const llmModels = await this.listModels();
+    for (const model of llmModels) {
+      model.type = "llm";
+    }
+    const imageModels = await this.listImageModels();
+    for (const model of imageModels) {
+      model.type = "image";
+    }
+    return [...llmModels, ...imageModels];
+  }
+  /**
+   * Edit an image using img2img.
+   *
+   * @param prompt - Text description of the desired edit
+   * @param image - Base64-encoded image or URL of the source image
+   * @param options - Optional edit parameters
+   * @returns ImageResponse with edited image URLs
+   */
+  async imageEdit(prompt, image, options) {
+    const body = {
+      model: options?.model || "openai/gpt-image-1",
+      prompt,
+      image,
+      size: options?.size || "1024x1024",
+      n: options?.n || 1
+    };
+    if (options?.mask !== void 0) {
+      body.mask = options.mask;
+    }
+    const data = await this.requestWithPaymentRaw("/v1/images/image2image", body);
+    return data;
+  }
+  /**
+   * Standalone search (web, X/Twitter, news).
+   *
+   * @param query - Search query
+   * @param options - Optional search parameters
+   * @returns SearchResult with summary and citations
+   */
+  async search(query, options) {
+    const body = {
+      query,
+      max_results: options?.maxResults || 10
+    };
+    if (options?.sources !== void 0) body.sources = options.sources;
+    if (options?.fromDate !== void 0) body.from_date = options.fromDate;
+    if (options?.toDate !== void 0) body.to_date = options.toDate;
+    const data = await this.requestWithPaymentRaw("/v1/search", body);
+    return data;
+  }
+  /**
+   * Get USDC balance on Base network.
+   *
+   * Automatically detects mainnet vs testnet based on API URL.
+   *
+   * @returns USDC balance as a float (6 decimal places normalized)
+   *
+   * @example
+   * const balance = await client.getBalance();
+   * console.log(`Balance: $${balance.toFixed(2)} USDC`);
+   */
+  async getBalance() {
+    const isTestnet = this.isTestnet();
+    const usdcContract = isTestnet ? "0x036CbD53842c5426634e7929541eC2318f3dCF7e" : "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+    const rpcs = isTestnet ? ["https://sepolia.base.org", "https://base-sepolia-rpc.publicnode.com"] : ["https://base.publicnode.com", "https://mainnet.base.org", "https://base.meowrpc.com"];
+    const selector = "0x70a08231";
+    const paddedAddress = this.account.address.slice(2).toLowerCase().padStart(64, "0");
+    const data = selector + paddedAddress;
+    const payload = {
+      jsonrpc: "2.0",
+      method: "eth_call",
+      params: [{ to: usdcContract, data }, "latest"],
+      id: 1
+    };
+    let lastError;
+    for (const rpc of rpcs) {
+      try {
+        const response = await fetch(rpc, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload)
+        });
+        const result = await response.json();
+        const balanceRaw = parseInt(result.result || "0x0", 16);
+        return balanceRaw / 1e6;
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    throw lastError || new Error("All RPCs failed");
+  }
+  // ============================================================
+  // X/Twitter endpoints (powered by AttentionVC)
+  // ============================================================
+  /**
+   * Look up X/Twitter user profiles by username.
+   *
+   * Powered by AttentionVC. $0.002 per user (min $0.02, max $0.20).
+   *
+   * @param usernames - Single username or array of usernames (without @)
+   */
+  async xUserLookup(usernames) {
+    const names = Array.isArray(usernames) ? usernames : [usernames];
+    const data = await this.requestWithPaymentRaw("/v1/x/users/lookup", { usernames: names });
+    return data;
+  }
+  /**
+   * Get followers of an X/Twitter user.
+   *
+   * Powered by AttentionVC. $0.05 per page (~200 accounts).
+   *
+   * @param username - X/Twitter username (without @)
+   * @param cursor - Pagination cursor from previous response
+   */
+  async xFollowers(username, cursor) {
+    const body = { username };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/followers", body);
+    return data;
+  }
+  /**
+   * Get accounts an X/Twitter user is following.
+   *
+   * Powered by AttentionVC. $0.05 per page (~200 accounts).
+   *
+   * @param username - X/Twitter username (without @)
+   * @param cursor - Pagination cursor from previous response
+   */
+  async xFollowings(username, cursor) {
+    const body = { username };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/followings", body);
+    return data;
+  }
+  /**
+   * Get detailed profile info for a single X/Twitter user.
+   *
+   * Powered by AttentionVC. $0.002 per request.
+   *
+   * @param username - X/Twitter username (without @)
+   */
+  async xUserInfo(username) {
+    const data = await this.requestWithPaymentRaw("/v1/x/users/info", { username });
+    return data;
+  }
+  /**
+   * Get verified (blue-check) followers of an X/Twitter user.
+   *
+   * Powered by AttentionVC. $0.048 per page.
+   *
+   * @param userId - X/Twitter user ID (not username)
+   * @param cursor - Pagination cursor from previous response
+   */
+  async xVerifiedFollowers(userId, cursor) {
+    const body = { userId };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/verified-followers", body);
+    return data;
+  }
+  /**
+   * Get tweets posted by an X/Twitter user.
+   *
+   * Powered by AttentionVC. $0.032 per page.
+   *
+   * @param username - X/Twitter username (without @)
+   * @param includeReplies - Include reply tweets (default: false)
+   * @param cursor - Pagination cursor from previous response
+   */
+  async xUserTweets(username, includeReplies = false, cursor) {
+    const body = { username, includeReplies };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/tweets", body);
+    return data;
+  }
+  /**
+   * Get tweets that mention an X/Twitter user.
+   *
+   * Powered by AttentionVC. $0.032 per page.
+   *
+   * @param username - X/Twitter username (without @)
+   * @param sinceTime - Start time filter (ISO8601 or Unix timestamp)
+   * @param untilTime - End time filter (ISO8601 or Unix timestamp)
+   * @param cursor - Pagination cursor from previous response
+   */
+  async xUserMentions(username, sinceTime, untilTime, cursor) {
+    const body = { username };
+    if (sinceTime !== void 0) body.sinceTime = sinceTime;
+    if (untilTime !== void 0) body.untilTime = untilTime;
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/mentions", body);
+    return data;
+  }
+  /**
+   * Fetch full tweet data for up to 200 tweet IDs.
+   *
+   * Powered by AttentionVC. $0.16 per batch.
+   *
+   * @param tweetIds - Single tweet ID or array of tweet IDs (max 200)
+   */
+  async xTweetLookup(tweetIds) {
+    const ids = Array.isArray(tweetIds) ? tweetIds : [tweetIds];
+    const data = await this.requestWithPaymentRaw("/v1/x/tweets/lookup", { tweet_ids: ids });
+    return data;
+  }
+  /**
+   * Get replies to a specific tweet.
+   *
+   * Powered by AttentionVC. $0.032 per page.
+   *
+   * @param tweetId - The tweet ID to get replies for
+   * @param queryType - Sort order: 'Latest' or 'Default'
+   * @param cursor - Pagination cursor from previous response
+   */
+  async xTweetReplies(tweetId, queryType = "Latest", cursor) {
+    const body = { tweetId, queryType };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/tweets/replies", body);
+    return data;
+  }
+  /**
+   * Get the full thread context for a tweet.
+   *
+   * Powered by AttentionVC. $0.032 per page.
+   *
+   * @param tweetId - The tweet ID to get thread for
+   * @param cursor - Pagination cursor from previous response
+   */
+  async xTweetThread(tweetId, cursor) {
+    const body = { tweetId };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/tweets/thread", body);
+    return data;
+  }
+  /**
+   * Search X/Twitter with advanced query operators.
+   *
+   * Powered by AttentionVC. $0.032 per page.
+   *
+   * @param query - Search query (supports Twitter search operators)
+   * @param queryType - Sort order: 'Latest', 'Top', or 'Default'
+   * @param cursor - Pagination cursor from previous response
+   */
+  async xSearch(query, queryType = "Latest", cursor) {
+    const body = { query, queryType };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/search", body);
+    return data;
+  }
+  /**
+   * Get current trending topics on X/Twitter.
+   *
+   * Powered by AttentionVC. $0.002 per request.
+   */
+  async xTrending() {
+    const data = await this.requestWithPaymentRaw("/v1/x/trending", {});
+    return data;
+  }
+  /**
+   * Get rising/viral articles from X/Twitter.
+   *
+   * Powered by AttentionVC intelligence layer. $0.05 per request.
+   */
+  async xArticlesRising() {
+    const data = await this.requestWithPaymentRaw("/v1/x/articles/rising", {});
+    return data;
+  }
+  /**
+   * Get author analytics and intelligence metrics for an X/Twitter user.
+   *
+   * Powered by AttentionVC intelligence layer. $0.02 per request.
+   *
+   * @param handle - X/Twitter handle (without @)
+   */
+  async xAuthorAnalytics(handle) {
+    const data = await this.requestWithPaymentRaw("/v1/x/authors", { handle });
+    return data;
+  }
+  /**
+   * Compare two X/Twitter authors side-by-side with intelligence metrics.
+   *
+   * Powered by AttentionVC intelligence layer. $0.05 per request.
+   *
+   * @param handle1 - First X/Twitter handle (without @)
+   * @param handle2 - Second X/Twitter handle (without @)
+   */
+  async xCompareAuthors(handle1, handle2) {
+    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.
+   *
+   * @returns Object with totalUsd and calls count
+   *
+   * @example
+   * const spending = client.getSpending();
+   * console.log(`Spent $${spending.totalUsd.toFixed(4)} across ${spending.calls} calls`);
+   */
+  getSpending() {
+    return {
+      totalUsd: this.sessionTotalUsd,
+      calls: this.sessionCalls
+    };
+  }
+  /**
+   * Get the wallet address being used for payments.
+   */
+  getWalletAddress() {
+    return this.account.address;
+  }
+  /**
+   * Check if client is configured for testnet.
+   */
+  isTestnet() {
+    return this.apiUrl.includes("testnet.blockrun.ai");
+  }
+};
+function testnetClient(options = {}) {
+  return new LLMClient({
+    ...options,
+    apiUrl: TESTNET_API_URL
+  });
+}
+var client_default = LLMClient;
+
+// src/image.ts
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+var DEFAULT_API_URL2 = "https://blockrun.ai/api";
+var DEFAULT_MODEL = "google/nano-banana";
+var DEFAULT_SIZE = "1024x1024";
+var DEFAULT_TIMEOUT2 = 12e4;
+var ImageClient = class {
+  account;
+  privateKey;
+  apiUrl;
+  timeout;
+  sessionTotalUsd = 0;
+  sessionCalls = 0;
+  /**
+   * Initialize the BlockRun Image client.
+   *
+   * @param options - Client configuration options
+   */
+  constructor(options = {}) {
+    const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
+    const privateKey = options.privateKey || envKey;
+    if (!privateKey) {
+      throw new Error(
+        "Private key required. Pass privateKey in options or set BLOCKRUN_WALLET_KEY environment variable."
+      );
+    }
+    validatePrivateKey(privateKey);
+    this.privateKey = privateKey;
+    this.account = privateKeyToAccount2(privateKey);
+    const apiUrl = options.apiUrl || DEFAULT_API_URL2;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.timeout = options.timeout || DEFAULT_TIMEOUT2;
+  }
+  /**
+   * Generate an image from a text prompt.
+   *
+   * @param prompt - Text description of the image to generate
+   * @param options - Optional generation parameters
+   * @returns ImageResponse with generated image URLs
+   *
+   * @example
+   * const result = await client.generate('A sunset over mountains');
+   * console.log(result.data[0].url);
+   */
+  async generate(prompt, options) {
+    const body = {
+      model: options?.model || DEFAULT_MODEL,
+      prompt,
+      size: options?.size || DEFAULT_SIZE,
+      n: options?.n || 1
+    };
+    if (options?.quality) {
+      body.quality = options.quality;
+    }
+    return this.requestWithPayment("/v1/images/generations", body);
+  }
+  /**
+   * Edit an image using img2img.
+   *
+   * @param prompt - Text description of the desired edit
+   * @param image - Base64-encoded image or URL of the source image
+   * @param options - Optional edit parameters
+   * @returns ImageResponse with edited image URLs
+   *
+   * @example
+   * const result = await client.edit('Make it a painting', imageBase64);
+   * console.log(result.data[0].url);
+   */
+  async edit(prompt, image, options) {
+    const body = {
+      model: options?.model || "openai/gpt-image-1",
+      prompt,
+      image,
+      size: options?.size || "1024x1024",
+      n: options?.n || 1
+    };
+    if (options?.mask !== void 0) {
+      body.mask = options.mask;
+    }
+    return this.requestWithPayment("/v1/images/image2image", body);
+  }
+  /**
+   * List available image generation models with pricing.
+   */
+  async listImageModels() {
+    const response = await this.fetchWithTimeout(
+      `${this.apiUrl}/v1/images/models`,
+      { method: "GET" }
+    );
+    if (!response.ok) {
+      throw new APIError(
+        `Failed to list image models: ${response.status}`,
+        response.status
+      );
+    }
+    const data = await response.json();
+    return data.data || [];
+  }
+  /**
+   * Make a request with automatic x402 payment handling.
+   */
+  async requestWithPayment(endpoint, body) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (response.status === 402) {
+      return this.handlePaymentAndRetry(url, body, 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: parse requirements, sign payment, retry.
+   */
+  async handlePaymentAndRetry(url, body, 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 {
+      }
+    }
+    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 || `${this.apiUrl}/v1/images/generations`,
+          this.apiUrl
+        ),
+        resourceDescription: details.resource?.description || "BlockRun Image Generation",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra,
+        extensions
+      }
+    );
+    const retryResponse = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    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)
+      );
+    }
+    return retryResponse.json();
+  }
+  /**
+   * Fetch with timeout.
+   */
+  async fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Get the wallet address being used for payments.
+   */
+  getWalletAddress() {
+    return this.account.address;
+  }
+  /**
+   * Get session spending information.
+   */
+  getSpending() {
+    return {
+      totalUsd: this.sessionTotalUsd,
+      calls: this.sessionCalls
+    };
+  }
+};
+
+// src/wallet.ts
+import { privateKeyToAccount as privateKeyToAccount3, generatePrivateKey } from "viem/accounts";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var USDC_BASE_CONTRACT = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var BASE_CHAIN_ID2 = "8453";
+var WALLET_DIR = path.join(os.homedir(), ".blockrun");
+var WALLET_FILE = path.join(WALLET_DIR, ".session");
+function createWallet() {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount3(privateKey);
+  return {
+    address: account.address,
+    privateKey
+  };
+}
+function saveWallet(privateKey) {
+  if (!fs.existsSync(WALLET_DIR)) {
+    fs.mkdirSync(WALLET_DIR, { recursive: true });
+  }
+  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;
+  }
+  const legacyFile = path.join(WALLET_DIR, "wallet.key");
+  if (fs.existsSync(legacyFile)) {
+    const key = fs.readFileSync(legacyFile, "utf-8").trim();
+    if (key) return key;
+  }
+  return null;
+}
+function getOrCreateWallet() {
+  const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
+  if (envKey) {
+    const account = privateKeyToAccount3(envKey);
+    return { address: account.address, privateKey: envKey, isNew: false };
+  }
+  const fileKey = loadWallet();
+  if (fileKey) {
+    const account = privateKeyToAccount3(fileKey);
+    return { address: account.address, privateKey: fileKey, isNew: false };
+  }
+  const { address, privateKey } = createWallet();
+  saveWallet(privateKey);
+  return { address, privateKey, isNew: true };
+}
+function getWalletAddress() {
+  const envKey = typeof process !== "undefined" && process.env ? process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY : void 0;
+  if (envKey) {
+    return privateKeyToAccount3(envKey).address;
+  }
+  const fileKey = loadWallet();
+  if (fileKey) {
+    return privateKeyToAccount3(fileKey).address;
+  }
+  return null;
+}
+function getEip681Uri(address, amountUsdc = 1) {
+  const amountWei = Math.floor(amountUsdc * 1e6);
+  return `ethereum:${USDC_BASE_CONTRACT}@${BASE_CHAIN_ID2}/transfer?address=${address}&uint256=${amountWei}`;
+}
+function getPaymentLinks(address) {
+  return {
+    basescan: `https://basescan.org/address/${address}`,
+    walletLink: `ethereum:${USDC_BASE_CONTRACT}@${BASE_CHAIN_ID2}/transfer?address=${address}`,
+    ethereum: `ethereum:${address}@${BASE_CHAIN_ID2}`,
+    blockrun: `https://blockrun.ai/fund?address=${address}`
+  };
+}
+function formatWalletCreatedMessage(address) {
+  const links = getPaymentLinks(address);
+  return `
+I'm your BlockRun Agent! I can access GPT-4, Grok, image generation, and more.
+
+Please send $1-5 USDC on Base to start:
+
+${address}
+
+What is Base? Base is Coinbase's blockchain network.
+You can buy USDC on Coinbase and send it directly to me.
+
+What $1 USDC gets you:
+- ~1,000 GPT-4o calls
+- ~100 image generations
+- ~10,000 DeepSeek calls
+
+Quick links:
+- Check my balance: ${links.basescan}
+- Get USDC: https://www.coinbase.com or https://bridge.base.org
+
+Questions? care@blockrun.ai | Issues? github.com/BlockRunAI/blockrun-llm-ts/issues
+
+Key stored securely in ~/.blockrun/
+Your private key never leaves your machine - only signatures are sent.
+`;
+}
+function formatNeedsFundingMessage(address) {
+  const links = getPaymentLinks(address);
+  return `
+I've run out of funds! Please send more USDC on Base to continue helping you.
+
+Send to my address:
+${address}
+
+Check my balance: ${links.basescan}
+
+What $1 USDC gets you: ~1,000 GPT-4o calls or ~100 images.
+Questions? care@blockrun.ai | Issues? github.com/BlockRunAI/blockrun-llm-ts/issues
+
+Your private key never leaves your machine - only signatures are sent.
+`;
+}
+function formatFundingMessageCompact(address) {
+  const links = getPaymentLinks(address);
+  return `I need a little top-up to keep helping you! Send USDC on Base to: ${address}
+Check my balance: ${links.basescan}`;
+}
+var WALLET_FILE_PATH = WALLET_FILE;
+var WALLET_DIR_PATH = WALLET_DIR;
+
+// src/solana-wallet.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+var WALLET_DIR2 = path2.join(os2.homedir(), ".blockrun");
+var SOLANA_WALLET_FILE = path2.join(WALLET_DIR2, ".solana-session");
+function createSolanaWallet() {
+  const { Keypair } = (init_index_esm(), __toCommonJS(index_esm_exports));
+  const bs58 = __require("bs58");
+  const keypair = Keypair.generate();
+  return {
+    address: keypair.publicKey.toBase58(),
+    privateKey: bs58.default?.encode(keypair.secretKey) ?? bs58.encode(keypair.secretKey)
+  };
+}
+async function solanaKeyToBytes(privateKey) {
+  try {
+    const bs58 = await import("bs58");
+    const bytes = (bs58.default ?? bs58).decode(privateKey);
+    if (bytes.length !== 64) {
+      throw new Error(`Invalid Solana key length: expected 64 bytes, got ${bytes.length}`);
+    }
+    return bytes;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid Solana private key: ${msg}`);
+  }
+}
+async function solanaPublicKey(privateKey) {
+  const { Keypair } = await import("./index.esm-SXKIFLA7.js");
+  const bytes = await solanaKeyToBytes(privateKey);
+  return Keypair.fromSecretKey(bytes).publicKey.toBase58();
+}
+function saveSolanaWallet(privateKey) {
+  if (!fs2.existsSync(WALLET_DIR2)) fs2.mkdirSync(WALLET_DIR2, { recursive: true });
+  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;
+  }
+  return null;
+}
+async function getOrCreateSolanaWallet() {
+  const envKey = typeof process !== "undefined" && process.env ? process.env.SOLANA_WALLET_KEY : void 0;
+  if (envKey) {
+    const address2 = await solanaPublicKey(envKey);
+    return { privateKey: envKey, 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);
+  return { address, privateKey, isNew: true };
+}
+
+// src/solana-client.ts
+var SOLANA_API_URL = "https://sol.blockrun.ai/api";
+var DEFAULT_MAX_TOKENS2 = 1024;
+var DEFAULT_TIMEOUT3 = 6e4;
+var SDK_VERSION2 = "0.3.0";
+var USER_AGENT2 = `blockrun-ts/${SDK_VERSION2}`;
+var SolanaLLMClient = class {
+  static SOLANA_API_URL = SOLANA_API_URL;
+  privateKey;
+  apiUrl;
+  rpcUrl;
+  timeout;
+  sessionTotalUsd = 0;
+  sessionCalls = 0;
+  addressCache = null;
+  constructor(options = {}) {
+    const envKey = typeof process !== "undefined" && process.env ? process.env.SOLANA_WALLET_KEY : void 0;
+    const privateKey = options.privateKey || envKey;
+    if (!privateKey) {
+      throw new Error(
+        "Private key required. Pass privateKey in options or set SOLANA_WALLET_KEY environment variable."
+      );
+    }
+    this.privateKey = privateKey;
+    const apiUrl = options.apiUrl || SOLANA_API_URL;
+    validateApiUrl(apiUrl);
+    this.apiUrl = apiUrl.replace(/\/$/, "");
+    this.rpcUrl = options.rpcUrl || "https://api.mainnet-beta.solana.com";
+    this.timeout = options.timeout || DEFAULT_TIMEOUT3;
+  }
+  /** Get Solana wallet address (public key in base58). */
+  async getWalletAddress() {
+    if (!this.addressCache) {
+      this.addressCache = await solanaPublicKey(this.privateKey);
+    }
+    return this.addressCache;
+  }
+  /** Simple 1-line chat. */
+  async chat(model, prompt, options) {
+    const messages = [];
+    if (options?.system) messages.push({ role: "system", content: options.system });
+    messages.push({ role: "user", content: prompt });
+    const result = await this.chatCompletion(model, messages, {
+      maxTokens: options?.maxTokens,
+      temperature: options?.temperature,
+      topP: options?.topP,
+      search: options?.search,
+      searchParameters: options?.searchParameters
+    });
+    return result.choices[0].message.content || "";
+  }
+  /** Full chat completion (OpenAI-compatible). */
+  async chatCompletion(model, messages, options) {
+    const body = {
+      model,
+      messages,
+      max_tokens: options?.maxTokens || DEFAULT_MAX_TOKENS2
+    };
+    if (options?.temperature !== void 0) body.temperature = options.temperature;
+    if (options?.topP !== void 0) body.top_p = options.topP;
+    if (options?.searchParameters !== void 0) body.search_parameters = options.searchParameters;
+    else if (options?.search === true) body.search_parameters = { mode: "on" };
+    if (options?.tools !== void 0) body.tools = options.tools;
+    if (options?.toolChoice !== void 0) body.tool_choice = options.toolChoice;
+    return this.requestWithPayment("/v1/chat/completions", body);
+  }
+  /** List available models. */
+  async listModels() {
+    const response = await this.fetchWithTimeout(`${this.apiUrl}/v1/models`, { method: "GET" });
+    if (!response.ok) {
+      throw new APIError(`Failed to list models: ${response.status}`, response.status);
+    }
+    const data = await response.json();
+    return data.data || [];
+  }
+  /**
+   * Get Solana USDC balance.
+   *
+   * @returns USDC balance as a float
+   */
+  async getBalance() {
+    const usdc_mint = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+    const address = await this.getWalletAddress();
+    try {
+      const response = await fetch(this.rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "getTokenAccountsByOwner",
+          params: [address, { mint: usdc_mint }, { encoding: "jsonParsed" }]
+        })
+      });
+      const data = await response.json();
+      const accounts = data.result?.value || [];
+      if (!accounts.length) return 0;
+      let total = 0;
+      for (const acct of accounts) {
+        total += acct.account?.data?.parsed?.info?.tokenAmount?.uiAmount || 0;
+      }
+      return total;
+    } catch {
+      return 0;
+    }
+  }
+  /** Edit an image using img2img (Solana payment). */
+  async imageEdit(prompt, image, options) {
+    const body = {
+      model: options?.model || "openai/gpt-image-1",
+      prompt,
+      image,
+      size: options?.size || "1024x1024",
+      n: options?.n || 1
+    };
+    if (options?.mask !== void 0) body.mask = options.mask;
+    const data = await this.requestWithPaymentRaw("/v1/images/image2image", body);
+    return data;
+  }
+  /** Standalone search (Solana payment). */
+  async search(query, options) {
+    const body = { query, max_results: options?.maxResults || 10 };
+    if (options?.sources !== void 0) body.sources = options.sources;
+    if (options?.fromDate !== void 0) body.from_date = options.fromDate;
+    if (options?.toDate !== void 0) body.to_date = options.toDate;
+    const data = await this.requestWithPaymentRaw("/v1/search", body);
+    return data;
+  }
+  // ============================================================
+  // X/Twitter endpoints (powered by AttentionVC)
+  // ============================================================
+  async xUserLookup(usernames) {
+    const names = Array.isArray(usernames) ? usernames : [usernames];
+    const data = await this.requestWithPaymentRaw("/v1/x/users/lookup", { usernames: names });
+    return data;
+  }
+  async xFollowers(username, cursor) {
+    const body = { username };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/followers", body);
+    return data;
+  }
+  async xFollowings(username, cursor) {
+    const body = { username };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/followings", body);
+    return data;
+  }
+  async xUserInfo(username) {
+    const data = await this.requestWithPaymentRaw("/v1/x/users/info", { username });
+    return data;
+  }
+  async xVerifiedFollowers(userId, cursor) {
+    const body = { userId };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/verified-followers", body);
+    return data;
+  }
+  async xUserTweets(username, includeReplies = false, cursor) {
+    const body = { username, includeReplies };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/tweets", body);
+    return data;
+  }
+  async xUserMentions(username, sinceTime, untilTime, cursor) {
+    const body = { username };
+    if (sinceTime !== void 0) body.sinceTime = sinceTime;
+    if (untilTime !== void 0) body.untilTime = untilTime;
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/users/mentions", body);
+    return data;
+  }
+  async xTweetLookup(tweetIds) {
+    const ids = Array.isArray(tweetIds) ? tweetIds : [tweetIds];
+    const data = await this.requestWithPaymentRaw("/v1/x/tweets/lookup", { tweet_ids: ids });
+    return data;
+  }
+  async xTweetReplies(tweetId, queryType = "Latest", cursor) {
+    const body = { tweetId, queryType };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/tweets/replies", body);
+    return data;
+  }
+  async xTweetThread(tweetId, cursor) {
+    const body = { tweetId };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/tweets/thread", body);
+    return data;
+  }
+  async xSearch(query, queryType = "Latest", cursor) {
+    const body = { query, queryType };
+    if (cursor !== void 0) body.cursor = cursor;
+    const data = await this.requestWithPaymentRaw("/v1/x/search", body);
+    return data;
+  }
+  async xTrending() {
+    const data = await this.requestWithPaymentRaw("/v1/x/trending", {});
+    return data;
+  }
+  async xArticlesRising() {
+    const data = await this.requestWithPaymentRaw("/v1/x/articles/rising", {});
+    return data;
+  }
+  async xAuthorAnalytics(handle) {
+    const data = await this.requestWithPaymentRaw("/v1/x/authors", { handle });
+    return data;
+  }
+  async xCompareAuthors(handle1, handle2) {
+    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 };
+  }
+  /** True if using sol.blockrun.ai. */
+  isSolana() {
+    return this.apiUrl.includes("sol.blockrun.ai");
+  }
+  async requestWithPayment(endpoint, body) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT2 },
+      body: JSON.stringify(body)
+    });
+    if (response.status === 402) {
+      return this.handlePaymentAndRetry(url, body, 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 handlePaymentAndRetry(url, body, 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 || `${this.apiUrl}/v1/chat/completions`,
+          this.apiUrl
+        ),
+        resourceDescription: details.resource?.description || "BlockRun Solana AI API call",
+        maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+        extra: details.extra,
+        extensions,
+        rpcUrl: this.rpcUrl
+      }
+    );
+    const retryResponse = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT2,
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    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 requestWithPaymentRaw(endpoint, body) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const response = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": USER_AGENT2 },
+      body: JSON.stringify(body)
+    });
+    if (response.status === 402) {
+      return this.handlePaymentAndRetryRaw(url, body, 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 handlePaymentAndRetryRaw(url, body, 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 retryResponse = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT2,
+        "PAYMENT-SIGNATURE": paymentPayload
+      },
+      body: JSON.stringify(body)
+    });
+    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 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);
+    try {
+      return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+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;
+  decoder;
+  buffer = "";
+  model;
+  id;
+  constructor(response, model) {
+    if (!response.body) {
+      throw new Error("Response body is null");
+    }
+    this.reader = response.body.getReader();
+    this.decoder = new TextDecoder();
+    this.model = model;
+    this.id = `chatcmpl-${Date.now()}`;
+  }
+  async *[Symbol.asyncIterator]() {
+    try {
+      while (true) {
+        const { done, value } = await this.reader.read();
+        if (done) break;
+        this.buffer += this.decoder.decode(value, { stream: true });
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") return;
+          try {
+            const parsed = JSON.parse(data);
+            yield this.transformChunk(parsed);
+          } catch {
+          }
+        }
+      }
+    } finally {
+      this.reader.releaseLock();
+    }
+  }
+  transformChunk(data) {
+    const choices = data.choices || [];
+    return {
+      id: data.id || this.id,
+      object: "chat.completion.chunk",
+      created: data.created || Math.floor(Date.now() / 1e3),
+      model: data.model || this.model,
+      choices: choices.map((choice, index) => ({
+        index: choice.index ?? index,
+        delta: {
+          role: choice.delta?.role,
+          content: choice.delta?.content
+        },
+        finish_reason: choice.finish_reason || null
+      }))
+    };
+  }
+};
+var ChatCompletions = class {
+  constructor(client, apiUrl, timeout) {
+    this.client = client;
+    this.apiUrl = apiUrl;
+    this.timeout = timeout;
+  }
+  async create(params) {
+    if (params.stream) {
+      return this.createStream(params);
+    }
+    const response = await this.client.chatCompletion(
+      params.model,
+      params.messages,
+      {
+        maxTokens: params.max_tokens,
+        temperature: params.temperature,
+        topP: params.top_p,
+        tools: params.tools,
+        toolChoice: params.tool_choice
+      }
+    );
+    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}`);
+      }
+      return new StreamingResponse(response, params.model);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  transformResponse(response) {
+    return {
+      id: response.id || `chatcmpl-${Date.now()}`,
+      object: "chat.completion",
+      created: response.created || Math.floor(Date.now() / 1e3),
+      model: response.model,
+      choices: response.choices.map((choice, index) => ({
+        index: choice.index ?? index,
+        message: {
+          role: "assistant",
+          content: choice.message.content,
+          tool_calls: choice.message.tool_calls
+        },
+        finish_reason: choice.finish_reason || "stop"
+      })),
+      usage: response.usage
+    };
+  }
+};
+var Chat = class {
+  completions;
+  constructor(client, apiUrl, timeout) {
+    this.completions = new ChatCompletions(client, apiUrl, timeout);
+  }
+};
+var OpenAI = class {
+  chat;
+  client;
+  constructor(options = {}) {
+    const privateKey = options.walletKey || options.privateKey;
+    const apiUrl = options.baseURL || "https://blockrun.ai/api";
+    const timeout = options.timeout || 6e4;
+    this.client = new LLMClient({
+      privateKey,
+      apiUrl,
+      timeout
+    });
+    this.chat = new Chat(this.client, apiUrl, timeout);
+  }
+  /**
+   * Get the wallet address being used for payments.
+   */
+  getWalletAddress() {
+    return this.client.getWalletAddress();
+  }
+};
+
+// src/anthropic-compat.ts
+import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
+var AnthropicClient = class {
+  _client = null;
+  _clientPromise = null;
+  _privateKey;
+  _account;
+  _apiUrl;
+  _timeout;
+  constructor(options = {}) {
+    const wallet = getOrCreateWallet();
+    const key = options.privateKey ?? wallet.privateKey;
+    validatePrivateKey(key);
+    this._privateKey = key;
+    this._account = privateKeyToAccount4(this._privateKey);
+    const apiUrl = options.apiUrl ?? "https://blockrun.ai/api";
+    validateApiUrl(apiUrl);
+    this._apiUrl = apiUrl.replace(/\/$/, "");
+    this._timeout = options.timeout ?? 6e4;
+  }
+  async _getClient() {
+    if (this._client) return this._client;
+    if (this._clientPromise) return this._clientPromise;
+    this._clientPromise = (async () => {
+      const { default: Anthropic } = await import("@anthropic-ai/sdk");
+      this._client = new Anthropic({
+        baseURL: this._apiUrl,
+        apiKey: "blockrun",
+        fetch: this._x402Fetch.bind(this)
+      });
+      return this._client;
+    })();
+    return this._clientPromise;
+  }
+  async _x402Fetch(input, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this._timeout);
+    try {
+      const mergedInit = { ...init, signal: controller.signal };
+      let response = await globalThis.fetch(input, mergedInit);
+      if (response.status === 402) {
+        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 {
+          }
+        }
+        if (!paymentHeader) {
+          throw new Error("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 || `${this._apiUrl}/v1/messages`,
+              this._apiUrl
+            ),
+            resourceDescription: details.resource?.description || "BlockRun AI API call",
+            maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+            extra: details.extra,
+            extensions
+          }
+        );
+        const newHeaders = new Headers(init?.headers);
+        newHeaders.set("PAYMENT-SIGNATURE", paymentPayload);
+        response = await globalThis.fetch(input, {
+          ...init,
+          headers: newHeaders,
+          signal: controller.signal
+        });
+        if (response.status === 402) {
+          throw new Error(
+            "Payment was rejected. Check your wallet balance."
+          );
+        }
+      }
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  get messages() {
+    const handler = {
+      get: (_target, prop) => {
+        return async (...args) => {
+          const client = await this._getClient();
+          const messages = client.messages;
+          return messages[prop](...args);
+        };
+      }
+    };
+    return new Proxy({}, handler);
+  }
+  getWalletAddress() {
+    return this._account.address;
+  }
+};
+export {
+  APIError,
+  AnthropicClient,
+  BASE_CHAIN_ID,
+  BlockrunError,
+  ImageClient,
+  LLMClient,
+  OpenAI,
+  PaymentError,
+  SOLANA_NETWORK,
+  SOLANA_WALLET_FILE as SOLANA_WALLET_FILE_PATH,
+  SolanaLLMClient,
+  USDC_BASE,
+  USDC_BASE_CONTRACT,
+  USDC_SOLANA,
+  WALLET_DIR_PATH,
+  WALLET_FILE_PATH,
+  clearCache,
+  createPaymentPayload,
+  createSolanaPaymentPayload,
+  createSolanaWallet,
+  createWallet,
+  client_default as default,
+  extractPaymentDetails,
+  formatFundingMessageCompact,
+  formatNeedsFundingMessage,
+  formatWalletCreatedMessage,
+  getCached,
+  getCachedByRequest,
+  getCostSummary,
+  getEip681Uri,
+  getOrCreateSolanaWallet,
+  getOrCreateWallet,
+  getPaymentLinks,
+  getWalletAddress,
+  loadSolanaWallet,
+  loadWallet,
+  logCost,
+  parsePaymentRequired,
+  saveSolanaWallet,
+  saveToCache,
+  saveWallet,
+  scanSolanaWallets,
+  scanWallets,
+  setCache,
+  setupAgentSolanaWallet,
+  setupAgentWallet,
+  solanaClient,
+  solanaKeyToBytes,
+  solanaPublicKey,
+  status,
+  testnetClient
+};