@blockrun/llm 0.1.1 → 0.2.0

package/package.json

@@ -1,15 +1,16 @@
 {
   "name": "@blockrun/llm",
-  "version": "0.1.1",
-  "description": "BlockRun LLM Gateway SDK - Pay-per-request AI via x402 on Base and Solana",
+  "version": "0.2.0",
+  "type": "module",
+  "description": "BlockRun LLM Gateway SDK - Pay-per-request AI via x402 on Base",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.js"
     }
   },
   "files": [
@@ -54,12 +55,16 @@
     "@solana/spl-token": "^0.4.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.0.0",
     "@types/node": "^20.0.0",
+    "eslint": "^9.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0",
+    "typescript-eslint": "^8.0.0",
     "vitest": "^1.0.0"
   },
   "engines": {
-    "node": ">=18"
-  }
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@9.15.4"
 }

package/dist/chunk-FCKQTBEP.mjs

@@ -1,90 +0,0 @@
-// 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 (error) {
-    throw new Error("Invalid API URL format");
-  }
-  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}//`
-    );
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(
-      `Invalid protocol: ${parsed.protocol}. Use http:// or https://`
-    );
-  }
-}
-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 (error) {
-    console.warn(`Invalid resource URL format: ${url}. Using safe default.`);
-    return `${baseUrl}/v1/chat/completions`;
-  }
-}
-function extractPrivateKey(account) {
-  if ("source" in account && typeof account.source === "string") {
-    return account.source;
-  }
-  if ("key" in account && typeof account.key === "string") {
-    return account.key;
-  }
-  throw new Error(
-    "Unable to extract private key from account. This may indicate an incompatible viem version."
-  );
-}
-
-export {
-  validatePrivateKey,
-  validateApiUrl,
-  sanitizeErrorResponse,
-  validateResourceUrl,
-  extractPrivateKey
-};

package/dist/chunk-TYQEUMVI.mjs

@@ -1,206 +0,0 @@
-// 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 SOLANA_USDC_DECIMALS = 6;
-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-FLTVMT4C.mjs");
-  const { getAssociatedTokenAddress, createTransferCheckedInstruction, getMint } = await import("./esm-3BUZROFC.mjs");
-  const { Keypair } = await import("./index.esm-FLTVMT4C.mjs");
-  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
-  };
-}
-function isSolanaNetwork(network) {
-  return network.startsWith("solana:");
-}
-function getAvailableNetworks(paymentRequired) {
-  return paymentRequired.accepts.map((opt) => opt.network).filter((network) => Boolean(network));
-}
-
-export {
-  BASE_CHAIN_ID,
-  USDC_BASE,
-  SOLANA_NETWORK,
-  USDC_SOLANA,
-  SOLANA_USDC_DECIMALS,
-  createPaymentPayload,
-  createSolanaPaymentPayload,
-  parsePaymentRequired,
-  extractPaymentDetails,
-  isSolanaNetwork,
-  getAvailableNetworks
-};

package/dist/index.d.mts

@@ -1,295 +0,0 @@
-/**
- * Type definitions for BlockRun LLM SDK
- */
-interface ChatMessage {
-    role: "system" | "user" | "assistant";
-    content: string;
-}
-interface ChatChoice {
-    index: number;
-    message: ChatMessage;
-    finish_reason?: string;
-}
-interface ChatUsage {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-}
-interface ChatResponse {
-    id: string;
-    object: string;
-    created: number;
-    model: string;
-    choices: ChatChoice[];
-    usage?: ChatUsage;
-}
-interface Model {
-    id: string;
-    name: string;
-    provider: string;
-    description: string;
-    inputPrice: number;
-    outputPrice: number;
-    contextWindow: number;
-    maxOutput: number;
-    available: boolean;
-}
-interface LLMClientOptions {
-    /** EVM wallet private key (hex string starting with 0x). Optional if BASE_CHAIN_WALLET_KEY env var is set. */
-    privateKey?: `0x${string}` | string;
-    /** API endpoint URL (default: https://blockrun.ai/api) */
-    apiUrl?: string;
-    /** Request timeout in milliseconds (default: 60000) */
-    timeout?: number;
-}
-interface ChatOptions {
-    /** System prompt */
-    system?: string;
-    /** Max tokens to generate */
-    maxTokens?: number;
-    /** Sampling temperature */
-    temperature?: number;
-    /** Nucleus sampling parameter */
-    topP?: number;
-}
-interface ChatCompletionOptions {
-    /** Max tokens to generate */
-    maxTokens?: number;
-    /** Sampling temperature */
-    temperature?: number;
-    /** Nucleus sampling parameter */
-    topP?: number;
-}
-declare class BlockrunError extends Error {
-    constructor(message: string);
-}
-declare class PaymentError extends BlockrunError {
-    constructor(message: string);
-}
-declare class APIError extends BlockrunError {
-    statusCode: number;
-    response?: unknown;
-    constructor(message: string, statusCode: number, response?: unknown);
-}
-
-/**
- * BlockRun LLM Client - Main SDK entry point.
- *
- * Usage:
- *   import { LLMClient } from '@blockrun/llm';
- *
- *   // Option 1: Use BASE_CHAIN_WALLET_KEY env var
- *   const client = new LLMClient();
- *
- *   // Option 2: Pass private key directly
- *   const client = new LLMClient({ privateKey: '0x...' });
- *
- *   const response = await client.chat('openai/gpt-4o', 'Hello!');
- *   console.log(response);
- */
-
-/**
- * BlockRun LLM Gateway Client.
- *
- * Provides access to multiple LLM providers (OpenAI, Anthropic, Google, etc.)
- * with automatic x402 micropayments on Base chain.
- */
-declare class LLMClient {
-    private account;
-    private privateKey;
-    private apiUrl;
-    private timeout;
-    /**
-     * Initialize the BlockRun LLM client.
-     *
-     * @param options - Client configuration options (optional if BASE_CHAIN_WALLET_KEY env var is set)
-     */
-    constructor(options?: LLMClientOptions);
-    /**
-     * 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.'
-     */
-    chat(model: string, prompt: string, options?: ChatOptions): Promise<string>;
-    /**
-     * 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
-     */
-    chatCompletion(model: string, messages: ChatMessage[], options?: ChatCompletionOptions): Promise<ChatResponse>;
-    /**
-     * Make a request with automatic x402 payment handling.
-     */
-    private requestWithPayment;
-    /**
-     * Handle 402 response: parse requirements, sign payment, retry.
-     */
-    private handlePaymentAndRetry;
-    /**
-     * Fetch with timeout.
-     */
-    private fetchWithTimeout;
-    /**
-     * List available models with pricing.
-     */
-    listModels(): Promise<Model[]>;
-    /**
-     * Get the wallet address being used for payments.
-     */
-    getWalletAddress(): string;
-}
-
-/**
- * x402 Payment Protocol v2 Implementation for BlockRun.
- *
- * This module handles creating signed payment payloads for the x402 v2 protocol.
- * The private key is used ONLY for local signing and NEVER leaves the client.
- */
-
-declare const BASE_CHAIN_ID = 8453;
-declare const USDC_BASE: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-
-/**
- * OpenAI-compatible API wrapper for BlockRun LLM SDK.
- *
- * Drop-in replacement for OpenAI SDK - just change the import and use walletKey instead of apiKey.
- *
- * @example
- * // Before (OpenAI)
- * import OpenAI from 'openai';
- * const client = new OpenAI({ apiKey: 'sk-...' });
- *
- * // After (BlockRun)
- * import { OpenAI } from '@blockrun/llm';
- * const client = new OpenAI({ walletKey: '0x...' });
- *
- * // Rest of your code stays exactly the same!
- * const response = await client.chat.completions.create({
- *   model: 'gpt-4o',
- *   messages: [{ role: 'user', content: 'Hello!' }]
- * });
- */
-
-interface OpenAIClientOptions {
-    /** EVM wallet private key (replaces apiKey) */
-    walletKey?: `0x${string}` | string;
-    /** Alternative: use privateKey like LLMClient */
-    privateKey?: `0x${string}` | string;
-    /** API endpoint URL (default: https://blockrun.ai/api) */
-    baseURL?: string;
-    /** Request timeout in milliseconds */
-    timeout?: number;
-}
-interface OpenAIChatCompletionParams {
-    model: string;
-    messages: Array<{
-        role: "system" | "user" | "assistant";
-        content: string;
-    }>;
-    max_tokens?: number;
-    temperature?: number;
-    top_p?: number;
-    stream?: boolean;
-    n?: number;
-    stop?: string | string[];
-    presence_penalty?: number;
-    frequency_penalty?: number;
-    user?: string;
-}
-interface OpenAIChatCompletionChoice {
-    index: number;
-    message: {
-        role: "assistant";
-        content: string;
-    };
-    finish_reason: string | null;
-}
-interface OpenAIChatCompletionResponse {
-    id: string;
-    object: "chat.completion";
-    created: number;
-    model: string;
-    choices: OpenAIChatCompletionChoice[];
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-}
-interface OpenAIChatCompletionChunk {
-    id: string;
-    object: "chat.completion.chunk";
-    created: number;
-    model: string;
-    choices: Array<{
-        index: number;
-        delta: {
-            role?: "assistant";
-            content?: string;
-        };
-        finish_reason: string | null;
-    }>;
-}
-/**
- * Chat completions API (OpenAI-compatible)
- */
-declare class ChatCompletions {
-    private client;
-    private apiUrl;
-    private timeout;
-    constructor(client: LLMClient, apiUrl: string, timeout: number);
-    /**
-     * Create a chat completion (OpenAI-compatible).
-     */
-    create(params: OpenAIChatCompletionParams): Promise<OpenAIChatCompletionResponse>;
-    create(params: OpenAIChatCompletionParams & {
-        stream: true;
-    }): Promise<AsyncIterable<OpenAIChatCompletionChunk>>;
-    private createStream;
-    private transformResponse;
-}
-/**
- * Chat API namespace
- */
-declare class Chat {
-    completions: ChatCompletions;
-    constructor(client: LLMClient, apiUrl: string, timeout: number);
-}
-/**
- * OpenAI-compatible client for BlockRun.
- *
- * Drop-in replacement for the OpenAI SDK.
- *
- * @example
- * import { OpenAI } from '@blockrun/llm';
- *
- * const client = new OpenAI({ walletKey: '0x...' });
- *
- * const response = await client.chat.completions.create({
- *   model: 'gpt-4o',
- *   messages: [{ role: 'user', content: 'Hello!' }]
- * });
- *
- * console.log(response.choices[0].message.content);
- */
-declare class OpenAI {
-    chat: Chat;
-    private client;
-    constructor(options?: OpenAIClientOptions);
-    /**
-     * Get the wallet address being used for payments.
-     */
-    getWalletAddress(): string;
-}
-
-export { APIError, BASE_CHAIN_ID, BlockrunError, type ChatChoice, type ChatCompletionOptions, type ChatMessage, type ChatOptions, type ChatResponse, type ChatUsage, LLMClient, type LLMClientOptions, type Model, OpenAI, type OpenAIChatCompletionChoice, type OpenAIChatCompletionChunk, type OpenAIChatCompletionParams, type OpenAIChatCompletionResponse, type OpenAIClientOptions, PaymentError, USDC_BASE, LLMClient as default };