@blockrun/llm 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1074 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIError: () => APIError,
+  BASE_CHAIN_ID: () => BASE_CHAIN_ID,
+  BlockrunError: () => BlockrunError,
+  ImageClient: () => ImageClient,
+  LLMClient: () => LLMClient,
+  OpenAI: () => OpenAI,
+  PaymentError: () => PaymentError,
+  USDC_BASE: () => USDC_BASE,
+  USDC_BASE_CONTRACT: () => USDC_BASE_CONTRACT,
+  WALLET_DIR_PATH: () => WALLET_DIR_PATH,
+  WALLET_FILE_PATH: () => WALLET_FILE_PATH,
+  createWallet: () => createWallet,
+  default: () => client_default,
+  formatFundingMessageCompact: () => formatFundingMessageCompact,
+  formatNeedsFundingMessage: () => formatNeedsFundingMessage,
+  formatWalletCreatedMessage: () => formatWalletCreatedMessage,
+  getEip681Uri: () => getEip681Uri,
+  getOrCreateWallet: () => getOrCreateWallet,
+  getPaymentLinks: () => getPaymentLinks,
+  getWalletAddress: () => getWalletAddress,
+  loadWallet: () => loadWallet,
+  saveWallet: () => saveWallet
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_accounts2 = require("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/x402.ts
+var import_accounts = require("viem/accounts");
+var BASE_CHAIN_ID = 8453;
+var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+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 (0, import_accounts.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));
+}
+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 DEFAULT_MAX_TOKENS = 1024;
+var DEFAULT_TIMEOUT = 6e4;
+var LLMClient = class {
+  account;
+  privateKey;
+  apiUrl;
+  timeout;
+  sessionTotalUsd = 0;
+  sessionCalls = 0;
+  /**
+   * 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 = (0, import_accounts2.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;
+  }
+  /**
+   * 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" };
+    }
+    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" },
+      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",
+        "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();
+  }
+  /**
+   * 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];
+  }
+  /**
+   * 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;
+  }
+};
+var client_default = LLMClient;
+
+// src/image.ts
+var import_accounts3 = require("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 = (0, import_accounts3.privateKeyToAccount)(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);
+  }
+  /**
+   * 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
+var import_accounts4 = require("viem/accounts");
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+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 = (0, import_accounts4.generatePrivateKey)();
+  const account = (0, import_accounts4.privateKeyToAccount)(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 loadWallet() {
+  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 = (0, import_accounts4.privateKeyToAccount)(envKey);
+    return { address: account.address, privateKey: envKey, isNew: false };
+  }
+  const fileKey = loadWallet();
+  if (fileKey) {
+    const account = (0, import_accounts4.privateKeyToAccount)(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 (0, import_accounts4.privateKeyToAccount)(envKey).address;
+  }
+  const fileKey = loadWallet();
+  if (fileKey) {
+    return (0, import_accounts4.privateKeyToAccount)(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/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
+      }
+    );
+    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
+    };
+    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
+        },
+        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();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIError,
+  BASE_CHAIN_ID,
+  BlockrunError,
+  ImageClient,
+  LLMClient,
+  OpenAI,
+  PaymentError,
+  USDC_BASE,
+  USDC_BASE_CONTRACT,
+  WALLET_DIR_PATH,
+  WALLET_FILE_PATH,
+  createWallet,
+  formatFundingMessageCompact,
+  formatNeedsFundingMessage,
+  formatWalletCreatedMessage,
+  getEip681Uri,
+  getOrCreateWallet,
+  getPaymentLinks,
+  getWalletAddress,
+  loadWallet,
+  saveWallet
+});