@blockrun/llm 0.1.1

package/dist/index.mjs

@@ -0,0 +1,428 @@
+import {
+  BASE_CHAIN_ID,
+  USDC_BASE,
+  createPaymentPayload,
+  extractPaymentDetails,
+  parsePaymentRequired
+} from "./chunk-TYQEUMVI.mjs";
+import {
+  sanitizeErrorResponse,
+  validateApiUrl,
+  validatePrivateKey,
+  validateResourceUrl
+} from "./chunk-FCKQTBEP.mjs";
+import "./chunk-HEBXNMVQ.mjs";
+
+// 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
+var DEFAULT_API_URL = "https://blockrun.ai/api";
+var DEFAULT_MAX_TOKENS = 1024;
+var DEFAULT_TIMEOUT = 6e4;
+var LLMClient = class {
+  account;
+  privateKey;
+  apiUrl;
+  timeout;
+  /**
+   * 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
+    });
+    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;
+    }
+    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)
+      );
+    }
+    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 models with pricing.
+   */
+  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 the wallet address being used for payments.
+   */
+  getWalletAddress() {
+    return this.account.address;
+  }
+};
+var client_default = LLMClient;
+
+// 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 {
+      let 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");
+        }
+        const { createPaymentPayload: createPaymentPayload2, parsePaymentRequired: parsePaymentRequired2, extractPaymentDetails: extractPaymentDetails2 } = await import("./x402-ELHVFRUU.mjs");
+        const { validateResourceUrl: validateResourceUrl2 } = await import("./validation-FPOEEOR4.mjs");
+        const { privateKeyToAccount: privateKeyToAccount2 } = await import("viem/accounts");
+        const paymentRequired = parsePaymentRequired2(paymentHeader);
+        const details = extractPaymentDetails2(paymentRequired);
+        const walletAddress = this.client.getWalletAddress();
+        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();
+  }
+};
+export {
+  APIError,
+  BASE_CHAIN_ID,
+  BlockrunError,
+  LLMClient,
+  OpenAI,
+  PaymentError,
+  USDC_BASE,
+  client_default as default
+};

package/dist/validation-FPOEEOR4.mjs

@@ -0,0 +1,15 @@
+import {
+  extractPrivateKey,
+  sanitizeErrorResponse,
+  validateApiUrl,
+  validatePrivateKey,
+  validateResourceUrl
+} from "./chunk-FCKQTBEP.mjs";
+import "./chunk-HEBXNMVQ.mjs";
+export {
+  extractPrivateKey,
+  sanitizeErrorResponse,
+  validateApiUrl,
+  validatePrivateKey,
+  validateResourceUrl
+};

package/dist/x402-ELHVFRUU.mjs

@@ -0,0 +1,27 @@
+import {
+  BASE_CHAIN_ID,
+  SOLANA_NETWORK,
+  SOLANA_USDC_DECIMALS,
+  USDC_BASE,
+  USDC_SOLANA,
+  createPaymentPayload,
+  createSolanaPaymentPayload,
+  extractPaymentDetails,
+  getAvailableNetworks,
+  isSolanaNetwork,
+  parsePaymentRequired
+} from "./chunk-TYQEUMVI.mjs";
+import "./chunk-HEBXNMVQ.mjs";
+export {
+  BASE_CHAIN_ID,
+  SOLANA_NETWORK,
+  SOLANA_USDC_DECIMALS,
+  USDC_BASE,
+  USDC_SOLANA,
+  createPaymentPayload,
+  createSolanaPaymentPayload,
+  extractPaymentDetails,
+  getAvailableNetworks,
+  isSolanaNetwork,
+  parsePaymentRequired
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@blockrun/llm",
+  "version": "0.1.1",
+  "description": "BlockRun LLM Gateway SDK - Pay-per-request AI via x402 on Base and Solana",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "llm",
+    "ai",
+    "x402",
+    "base",
+    "solana",
+    "usdc",
+    "micropayments",
+    "openai",
+    "claude",
+    "gemini",
+    "blockchain"
+  ],
+  "author": "BlockRun <hello@blockrun.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BlockRunAI/blockrun-llm-ts"
+  },
+  "homepage": "https://blockrun.ai",
+  "bugs": {
+    "url": "https://github.com/BlockRunAI/blockrun-llm-ts/issues"
+  },
+  "dependencies": {
+    "viem": "^2.21.0"
+  },
+  "optionalDependencies": {
+    "@solana/web3.js": "^1.98.0",
+    "@solana/spl-token": "^0.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}