@blockrun/mcp 0.1.0

package/README.md

@@ -0,0 +1,337 @@
+# @blockrun/mcp
+
+**Access 30+ AI models in Claude Code with zero API keys.**
+
+One wallet. Pay-per-request. All major AI models.
+
+```bash
+claude mcp add blockrun npx @blockrun/mcp
+```
+
+## Why BlockRun MCP?
+
+| Feature | Other Solutions | BlockRun MCP |
+|---------|-----------------|--------------|
+| **API Keys** | Need 5+ keys (OpenAI, Anthropic, Google...) | **None needed** |
+| **Billing** | Manage 5+ subscriptions | **One wallet, unified balance** |
+| **Setup** | Complex config per provider | **One command, auto-wallet** |
+| **Models** | Usually 1 provider | **30+ models, 6 providers** |
+| **Payment** | Monthly subscriptions | **Pay only what you use** |
+| **Minimum** | $20-100/month per provider | **$0 minimum, start with $5** |
+
+## Quick Start
+
+### 1. Install (30 seconds)
+
+```bash
+# Add to Claude Code
+claude mcp add blockrun npx @blockrun/mcp
+```
+
+That's it! A wallet is automatically created for you.
+
+### 2. Get Your Wallet Address
+
+In Claude Code, run:
+```
+Use blockrun_setup to get my wallet address
+```
+
+Or:
+```
+Use blockrun_wallet to show my wallet info
+```
+
+### 3. Fund Your Wallet
+
+Send USDC to your wallet address on **Base** network. Even $5 gets you hundreds of requests.
+
+**Funding Options:**
+
+| Method | Steps |
+|--------|-------|
+| **From Coinbase** | Send → USDC → Select "Base" network → Paste your address |
+| **Bridge** | Visit [bridge.base.org](https://bridge.base.org) → Bridge USDC to Base |
+| **Buy Direct** | Visit [Coinbase Onramp](https://www.coinbase.com/onramp) → Buy USDC on Base |
+
+### 4. Start Using
+
+```
+You: Use blockrun_chat to ask claude-sonnet-4 what is quantum computing
+
+Claude: [calls blockrun_chat]
+        Quantum computing is a type of computation that harnesses...
+```
+
+## Available Tools
+
+### `blockrun_chat`
+Chat with any AI model.
+
+```javascript
+blockrun_chat({
+  model: "anthropic/claude-sonnet-4",  // Required
+  message: "Explain quantum computing", // Required
+  system: "You are a physics professor", // Optional
+  max_tokens: 2000,                      // Optional (default: 1024)
+  temperature: 0.7                       // Optional (default: 1)
+})
+```
+
+**Popular Models:**
+- `openai/gpt-5.2` - Most capable OpenAI model
+- `anthropic/claude-opus-4` - Best for complex reasoning
+- `anthropic/claude-sonnet-4` - Fast & capable (recommended)
+- `google/gemini-2.5-pro` - Great for long context (1M tokens)
+- `deepseek/deepseek-chat` - Very affordable
+
+### `blockrun_smart`
+Auto-select the best model for your needs.
+
+```javascript
+blockrun_smart({
+  mode: "balanced",  // Required: fast | balanced | powerful | cheap | reasoning
+  message: "Hello!"  // Required
+})
+```
+
+| Mode | Models Used | Best For | Cost |
+|------|-------------|----------|------|
+| `fast` | Gemini Flash, GPT-4o-mini | Quick responses | $ |
+| `balanced` | GPT-4o, Claude Sonnet | Daily tasks | $$ |
+| `powerful` | GPT-5.2, Claude Opus, o3 | Complex work | $$$$ |
+| `cheap` | Gemini Flash, DeepSeek | Budget-conscious | $ |
+| `reasoning` | o3, o1, DeepSeek Reasoner | Logic & math | $$$ |
+
+### `blockrun_models`
+List all available models with pricing.
+
+```javascript
+blockrun_models({
+  category: "chat",    // Optional: all, chat, reasoning, image, embedding
+  provider: "openai"   // Optional: filter by provider
+})
+```
+
+### `blockrun_image`
+Generate images with AI.
+
+```javascript
+blockrun_image({
+  prompt: "A sunset over mountains",  // Required
+  model: "openai/dall-e-3",           // Optional
+  size: "1024x1024",                  // Optional: 1024x1024, 1792x1024, 1024x1792
+  quality: "hd"                       // Optional: standard, hd
+})
+```
+
+### `blockrun_wallet`
+Check your wallet information.
+
+```javascript
+blockrun_wallet({})
+// Returns: address, network, balance link, funding options
+```
+
+### `blockrun_setup`
+Get detailed setup and funding instructions.
+
+```javascript
+blockrun_setup({})
+// Returns: complete setup guide with step-by-step funding instructions
+```
+
+## Supported Models & Pricing
+
+### Chat Models
+
+| Provider | Models | Input Price | Output Price |
+|----------|--------|-------------|--------------|
+| **OpenAI** | GPT-5.2, GPT-5-mini, GPT-4o, o3, o1 | $0.15 - $21/M | $0.60 - $84/M |
+| **Anthropic** | Claude Opus 4, Sonnet 4, Haiku | $0.25 - $15/M | $1.25 - $75/M |
+| **Google** | Gemini 3 Pro, 2.5 Pro/Flash | Free - $2.50/M | Free - $15/M |
+| **DeepSeek** | V3.2, Reasoner | $0.14 - $0.55/M | $0.28 - $2.19/M |
+| **xAI** | Grok 3, Grok 3 Mini | $3 - $5/M | $15 - $25/M |
+
+*M = million tokens. Prices in USD.*
+
+### Image Models
+
+| Model | Price per Image |
+|-------|-----------------|
+| DALL-E 3 (Standard) | $0.04 |
+| DALL-E 3 (HD) | $0.08 |
+| Flux Schnell | $0.02 |
+
+### Cost Examples
+
+| Task | Model | Approx. Cost |
+|------|-------|--------------|
+| Quick question | Gemini Flash | $0.0001 |
+| Code review | Claude Sonnet | $0.003 |
+| Complex analysis | GPT-4o | $0.005 |
+| Long document | Claude Opus | $0.02 |
+| Image generation | DALL-E 3 | $0.04 |
+
+**$5 gets you approximately:**
+- 50,000 Gemini Flash requests, OR
+- 1,600 Claude Sonnet requests, OR
+- 1,000 GPT-4o requests, OR
+- 125 DALL-E 3 images
+
+## Wallet Management
+
+### Auto-Generated Wallet
+
+When you first use BlockRun MCP, a wallet is automatically created and saved to:
+```
+~/.blockrun/.session
+```
+
+This wallet is:
+- Created locally on your machine
+- Never transmitted to any server
+- Used only for signing payment authorizations
+- Persistent across sessions
+
+### Using Your Own Wallet
+
+If you prefer to use an existing wallet:
+
+```bash
+# Option 1: Environment variable
+export BLOCKRUN_WALLET_KEY=0x...
+
+# Option 2: Add with Claude Code
+claude mcp add blockrun npx @blockrun/mcp --env BLOCKRUN_WALLET_KEY=0x...
+```
+
+### Wallet Priority
+
+1. Environment variable `BLOCKRUN_WALLET_KEY`
+2. Environment variable `BASE_CHAIN_WALLET_KEY`
+3. File at `~/.blockrun/.session`
+4. Auto-generate new wallet (saved to file)
+
+## How Payment Works
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  1. You send a request (e.g., chat with GPT-5)              │
+│                          ↓                                  │
+│  2. BlockRun calculates cost based on tokens                │
+│                          ↓                                  │
+│  3. Your wallet signs a payment authorization LOCALLY       │
+│     (private key NEVER leaves your machine)                 │
+│                          ↓                                  │
+│  4. Payment settles on Base network via USDC                │
+│                          ↓                                  │
+│  5. You receive your AI response                            │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**Security Guarantees:**
+- Private key is used ONLY for local signing
+- Key is NEVER transmitted to any server
+- Same security model as MetaMask transactions
+- You can verify all transactions on [Basescan](https://basescan.org)
+
+## Comparison with Alternatives
+
+### vs claude-code-proxy
+| | claude-code-proxy | BlockRun MCP |
+|---|---|---|
+| API Keys | Required (bring your own) | **Not needed** |
+| Setup | Configure each provider | **One command** |
+| Billing | Multiple subscriptions | **Unified wallet** |
+
+### vs gemini-mcp
+| | gemini-mcp | BlockRun MCP |
+|---|---|---|
+| Models | Gemini only | **30+ models, 6 providers** |
+| API Key | Required | **Not needed** |
+| Payment | Google billing | **Pay-per-use crypto** |
+
+### vs Direct API Keys
+| | Direct APIs | BlockRun MCP |
+|---|---|---|
+| Accounts | 5+ accounts needed | **One wallet** |
+| Minimums | $20-100/mo per provider | **$0 minimum** |
+| Management | Complex | **Simple** |
+
+## Troubleshooting
+
+### "Payment was rejected"
+Your wallet needs funding. Run `blockrun_setup` to get your address and funding instructions.
+
+### "Wallet key required"
+The MCP couldn't find or create a wallet. Check that `~/.blockrun/` directory is writable.
+
+### Model not responding
+Some models have rate limits. Try `blockrun_smart` with mode `fast` or `cheap` to use alternative models.
+
+### Check wallet balance
+Visit: `https://basescan.org/address/YOUR_ADDRESS`
+
+## Configuration
+
+### Claude Code Setup
+
+```bash
+# Basic (recommended)
+claude mcp add blockrun npx @blockrun/mcp
+
+# With explicit wallet
+claude mcp add blockrun npx @blockrun/mcp --env BLOCKRUN_WALLET_KEY=0x...
+
+# Project-specific
+claude mcp add blockrun --scope project npx @blockrun/mcp
+
+# User-wide (all projects)
+claude mcp add blockrun --scope user npx @blockrun/mcp
+```
+
+### Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `BLOCKRUN_WALLET_KEY` | Your wallet private key (hex, starts with 0x) |
+| `BASE_CHAIN_WALLET_KEY` | Alternative name for wallet key |
+
+## Development
+
+```bash
+# Clone
+git clone https://github.com/blockrunai/blockrun-mcp
+cd blockrun-mcp
+
+# Install dependencies
+npm install
+
+# Development mode (auto-reload)
+npm run dev
+
+# Build for production
+npm run build
+
+# Test locally
+echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | node dist/index.js
+```
+
+## Links
+
+- **Website:** [blockrun.ai](https://blockrun.ai)
+- **Documentation:** [docs.blockrun.ai](https://docs.blockrun.ai)
+- **Pricing:** [blockrun.ai/pricing](https://blockrun.ai/pricing)
+- **GitHub:** [github.com/blockrunai](https://github.com/blockrunai)
+- **Twitter:** [@blockaborama](https://twitter.com/blockaborama)
+
+## Support
+
+- **Issues:** [GitHub Issues](https://github.com/blockrunai/blockrun-mcp/issues)
+- **Discord:** [Join our Discord](https://discord.gg/blockrun)
+- **Email:** hello@blockrun.ai
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,485 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { LLMClient } from "@blockrun/llm";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var WALLET_DIR = path.join(os.homedir(), ".blockrun");
+var WALLET_FILE = path.join(WALLET_DIR, ".session");
+var MODEL_TIERS = {
+  fast: ["google/gemini-2.5-flash", "openai/gpt-4o-mini", "deepseek/deepseek-chat"],
+  balanced: ["openai/gpt-4o", "anthropic/claude-sonnet-4", "google/gemini-2.5-pro"],
+  powerful: ["openai/gpt-5.2", "anthropic/claude-opus-4", "openai/o3"],
+  cheap: ["google/gemini-2.5-flash", "deepseek/deepseek-chat", "openai/gpt-4o-mini"],
+  reasoning: ["openai/o3", "openai/o1", "deepseek/deepseek-reasoner"]
+};
+var walletWasCreated = false;
+var walletAddress = null;
+var client = null;
+var cachedModels = null;
+function getOrCreateWalletKey() {
+  const envKey = process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY;
+  if (envKey) {
+    const account2 = privateKeyToAccount(envKey);
+    walletAddress = account2.address;
+    return envKey;
+  }
+  if (fs.existsSync(WALLET_FILE)) {
+    try {
+      const savedKey = fs.readFileSync(WALLET_FILE, "utf-8").trim();
+      if (savedKey.startsWith("0x") && savedKey.length === 66) {
+        const account2 = privateKeyToAccount(savedKey);
+        walletAddress = account2.address;
+        return savedKey;
+      }
+    } catch {
+    }
+  }
+  const newKey = generatePrivateKey();
+  const account = privateKeyToAccount(newKey);
+  walletAddress = account.address;
+  walletWasCreated = true;
+  try {
+    if (!fs.existsSync(WALLET_DIR)) {
+      fs.mkdirSync(WALLET_DIR, { recursive: true, mode: 448 });
+    }
+    fs.writeFileSync(WALLET_FILE, newKey, { mode: 384 });
+    console.error(`[BlockRun] New wallet created and saved to ${WALLET_FILE}`);
+  } catch (err) {
+    console.error(`[BlockRun] Warning: Could not save wallet to file: ${err}`);
+  }
+  return newKey;
+}
+function getClient() {
+  if (!client) {
+    const privateKey = getOrCreateWalletKey();
+    client = new LLMClient({ privateKey });
+  }
+  return client;
+}
+function getWalletSetupInstructions() {
+  if (!walletAddress) {
+    getClient();
+  }
+  return `
+================================================================================
+                        BLOCKRUN WALLET SETUP
+================================================================================
+
+Your wallet address: ${walletAddress}
+
+To use BlockRun AI models, you need USDC on Base network.
+
+HOW TO FUND YOUR WALLET:
+------------------------
+
+Option 1: Transfer from Coinbase
+  1. Open Coinbase app or website
+  2. Go to Send/Receive
+  3. Select USDC
+  4. Choose "Base" network (important!)
+  5. Paste address: ${walletAddress}
+  6. Send any amount ($5 is enough to start)
+
+Option 2: Bridge from other chains
+  1. Go to https://bridge.base.org
+  2. Connect your existing wallet
+  3. Bridge USDC to Base
+  4. Send to: ${walletAddress}
+
+Option 3: Buy directly
+  1. Go to https://www.coinbase.com/onramp
+  2. Buy USDC on Base network
+  3. Send to: ${walletAddress}
+
+VERIFY YOUR BALANCE:
+  https://basescan.org/address/${walletAddress}
+
+PRICING (pay only for what you use):
+  - GPT-4o: ~$0.005 per request
+  - Claude Sonnet: ~$0.003 per request
+  - Gemini Flash: ~$0.0001 per request
+  - Full pricing: https://blockrun.ai/pricing
+
+SECURITY NOTE:
+  Your private key is stored at: ~/.blockrun/.session
+  This key NEVER leaves your machine - only used for signing payments locally.
+
+================================================================================
+`;
+}
+var tools = [
+  {
+    name: "blockrun_chat",
+    description: `Chat with any AI model via BlockRun. Supports 30+ models including GPT-5, Claude Opus 4, Gemini 3, and more.
+Pay-per-request with x402 micropayments - no API keys needed.
+
+Popular models:
+- openai/gpt-5.2: Most capable OpenAI model
+- anthropic/claude-opus-4: Best for complex reasoning
+- anthropic/claude-sonnet-4: Fast & capable (recommended)
+- google/gemini-2.5-pro: Great for long context
+- deepseek/deepseek-chat: Very affordable
+
+Use blockrun_models to see all available models with pricing.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        model: {
+          type: "string",
+          description: "Model ID (e.g., 'anthropic/claude-sonnet-4', 'openai/gpt-4o'). Use blockrun_models to list all."
+        },
+        message: {
+          type: "string",
+          description: "Your message to the AI"
+        },
+        system: {
+          type: "string",
+          description: "Optional system prompt to set context/behavior"
+        },
+        max_tokens: {
+          type: "number",
+          description: "Maximum tokens in response (default: 1024)"
+        },
+        temperature: {
+          type: "number",
+          description: "Creativity level 0-2 (default: 1)"
+        }
+      },
+      required: ["model", "message"]
+    }
+  },
+  {
+    name: "blockrun_smart",
+    description: `Smart model routing - automatically picks the best model based on your needs.
+
+Modes:
+- fast: Quickest response (Gemini Flash, GPT-4o-mini)
+- balanced: Good quality & speed (GPT-4o, Claude Sonnet)
+- powerful: Best quality (GPT-5.2, Claude Opus 4, o3)
+- cheap: Lowest cost (Gemini Flash, DeepSeek)
+- reasoning: Complex logic (o3, o1, DeepSeek Reasoner)
+
+Example: blockrun_smart({ mode: "fast", message: "Hello" })`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        mode: {
+          type: "string",
+          enum: ["fast", "balanced", "powerful", "cheap", "reasoning"],
+          description: "Routing mode: fast, balanced, powerful, cheap, or reasoning"
+        },
+        message: {
+          type: "string",
+          description: "Your message to the AI"
+        },
+        system: {
+          type: "string",
+          description: "Optional system prompt"
+        },
+        max_tokens: {
+          type: "number",
+          description: "Maximum tokens in response (default: 1024)"
+        }
+      },
+      required: ["mode", "message"]
+    }
+  },
+  {
+    name: "blockrun_models",
+    description: "List all available AI models with pricing. Use this to discover models and compare costs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        category: {
+          type: "string",
+          enum: ["all", "chat", "reasoning", "image", "embedding"],
+          description: "Filter by category (default: all)"
+        },
+        provider: {
+          type: "string",
+          description: "Filter by provider (e.g., 'openai', 'anthropic', 'google')"
+        }
+      }
+    }
+  },
+  {
+    name: "blockrun_image",
+    description: `Generate images using AI models. Supports DALL-E 3, Flux, and Nano Banana.
+
+Models:
+- openai/dall-e-3: High quality, creative ($0.04-0.08/image)
+- together/flux-schnell: Fast generation ($0.02/image)
+- google/nano-banana: Experimental Google model`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: {
+          type: "string",
+          description: "Description of the image to generate"
+        },
+        model: {
+          type: "string",
+          description: "Image model (default: openai/dall-e-3)",
+          enum: ["openai/dall-e-3", "together/flux-schnell", "google/nano-banana"]
+        },
+        size: {
+          type: "string",
+          description: "Image size (default: 1024x1024)",
+          enum: ["1024x1024", "1792x1024", "1024x1792"]
+        },
+        quality: {
+          type: "string",
+          description: "Quality level for DALL-E 3 (default: standard)",
+          enum: ["standard", "hd"]
+        }
+      },
+      required: ["prompt"]
+    }
+  },
+  {
+    name: "blockrun_wallet",
+    description: "Get information about your BlockRun wallet address. Shows address, network, and quick funding options.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "blockrun_setup",
+    description: `Get detailed wallet setup and funding instructions. Use this for first-time setup or if you need help adding funds to your wallet.
+
+Returns:
+- Your wallet address
+- Step-by-step funding instructions (Coinbase, bridge, direct purchase)
+- Pricing information
+- Security details`,
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  }
+];
+async function handleChat(args) {
+  const llm = getClient();
+  const response = await llm.chat(args.model, args.message, {
+    system: args.system,
+    maxTokens: args.max_tokens,
+    temperature: args.temperature
+  });
+  return response;
+}
+async function handleSmartRoute(args) {
+  const models = MODEL_TIERS[args.mode];
+  if (!models) {
+    throw new Error(`Invalid mode: ${args.mode}. Use: fast, balanced, powerful, cheap, or reasoning`);
+  }
+  let lastError = null;
+  for (const model of models) {
+    try {
+      const response = await handleChat({
+        model,
+        message: args.message,
+        system: args.system,
+        max_tokens: args.max_tokens
+      });
+      return `[Used: ${model}]
+
+${response}`;
+    } catch (error) {
+      lastError = error;
+      continue;
+    }
+  }
+  throw lastError || new Error("All models failed");
+}
+async function handleListModels(args) {
+  const llm = getClient();
+  if (!cachedModels) {
+    cachedModels = await llm.listModels();
+    setTimeout(() => {
+      cachedModels = null;
+    }, 5 * 60 * 1e3);
+  }
+  let models = cachedModels;
+  if (args.provider) {
+    const provider = args.provider.toLowerCase();
+    models = models.filter((m) => m.id.toLowerCase().startsWith(provider + "/"));
+  }
+  if (args.category && args.category !== "all") {
+    const category = args.category.toLowerCase();
+    if (category === "image") {
+      models = models.filter(
+        (m) => m.id.includes("dall-e") || m.id.includes("flux") || m.id.includes("banana")
+      );
+    } else if (category === "reasoning") {
+      models = models.filter(
+        (m) => m.id.includes("/o1") || m.id.includes("/o3") || m.id.includes("reasoner")
+      );
+    } else if (category === "embedding") {
+      models = models.filter((m) => m.id.includes("embed"));
+    }
+  }
+  const lines = models.map((m) => {
+    const input = m.inputPrice ? `$${m.inputPrice}/M in` : "";
+    const output = m.outputPrice ? `$${m.outputPrice}/M out` : "";
+    const pricing = [input, output].filter(Boolean).join(", ");
+    return `- ${m.id}: ${m.name || ""} ${pricing ? `(${pricing})` : ""}`;
+  });
+  return `Available models (${models.length}):
+
+${lines.join("\n")}`;
+}
+async function handleImageGeneration(args) {
+  const model = args.model || "openai/dall-e-3";
+  const llm = getClient();
+  const apiUrl = "https://blockrun.ai/api/v1/images/generations";
+  const body = {
+    model,
+    prompt: args.prompt,
+    size: args.size || "1024x1024",
+    quality: args.quality || "standard",
+    n: 1
+  };
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (response.status === 402) {
+    return `Image generation requires payment. Please ensure your wallet has USDC on Base.
+
+To generate "${args.prompt}" with ${model}, the approximate cost is $0.04-0.08 per image.`;
+  }
+  if (!response.ok) {
+    throw new Error(`Image generation failed: ${response.status}`);
+  }
+  const data = await response.json();
+  const imageUrl = data.data?.[0]?.url;
+  if (!imageUrl) {
+    throw new Error("No image URL in response");
+  }
+  return `Image generated successfully!
+
+URL: ${imageUrl}
+
+Prompt: ${args.prompt}
+Model: ${model}`;
+}
+function handleWalletInfo() {
+  const llm = getClient();
+  const address = llm.getWalletAddress();
+  const isNewWallet = walletWasCreated;
+  let response = `BlockRun Wallet Information
+============================
+
+Address: ${address}
+Network: Base (Chain ID: 8453)
+Currency: USDC
+
+View on Basescan: https://basescan.org/address/${address}
+`;
+  if (isNewWallet) {
+    response += `
+STATUS: NEW WALLET - NEEDS FUNDING
+${getWalletSetupInstructions()}`;
+  } else {
+    response += `
+HOW TO ADD FUNDS:
+-----------------
+Send USDC to the address above on Base network.
+
+Quick options:
+1. From Coinbase: Send USDC, select "Base" network
+2. Bridge: https://bridge.base.org
+3. Buy: https://www.coinbase.com/onramp
+
+Full instructions: Run blockrun_setup tool
+`;
+  }
+  return response;
+}
+function handleSetup() {
+  getClient();
+  return getWalletSetupInstructions();
+}
+var server = new Server(
+  {
+    name: "blockrun-mcp",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    let result;
+    switch (name) {
+      case "blockrun_chat":
+        result = await handleChat(args);
+        break;
+      case "blockrun_smart":
+        result = await handleSmartRoute(args);
+        break;
+      case "blockrun_models":
+        result = await handleListModels(args);
+        break;
+      case "blockrun_image":
+        result = await handleImageGeneration(args);
+        break;
+      case "blockrun_wallet":
+        result = handleWalletInfo();
+        break;
+      case "blockrun_setup":
+        result = handleSetup();
+        break;
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    return {
+      content: [{ type: "text", text: result }]
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const isPaymentError = message.toLowerCase().includes("payment") || message.toLowerCase().includes("402") || message.toLowerCase().includes("balance") || message.toLowerCase().includes("insufficient");
+    let errorText = `Error: ${message}`;
+    if (isPaymentError) {
+      errorText += `
+
+This error usually means your wallet needs funding.
+Run the blockrun_setup tool to get your wallet address and funding instructions.
+
+Quick fix: Send USDC to your wallet on Base network.`;
+    }
+    return {
+      content: [{ type: "text", text: errorText }],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("BlockRun MCP Server started");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@blockrun/mcp",
+  "version": "0.1.0",
+  "description": "BlockRun MCP Server - Access 30+ AI models via x402 micropayments. No API keys needed.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "blockrun-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "llm",
+    "ai",
+    "x402",
+    "micropayments",
+    "openai",
+    "anthropic",
+    "gemini",
+    "blockrun",
+    "model-context-protocol"
+  ],
+  "author": "BlockRun <hello@blockrun.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blockrunai/blockrun-mcp"
+  },
+  "homepage": "https://blockrun.ai",
+  "bugs": {
+    "url": "https://github.com/blockrunai/blockrun-mcp/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@blockrun/llm": "^0.1.1",
+    "viem": "^2.21.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}