@blockrun/mcp 0.4.1 → 0.5.1

package/dist/http-server.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * BlockRun MCP Server — HTTP Transport
+ *
+ * Runs as an HTTP server for:
+ * - Claude.ai connectors (claudeai-proxy)
+ * - Claude Code Remote (CCR) cloud sessions
+ * - Web-based agents
+ * - Any MCP client supporting HTTP transport
+ *
+ * Usage:
+ *   npx @blockrun/mcp --http              # Start HTTP server on port 3402
+ *   npx @blockrun/mcp --http --port 8080  # Custom port
+ *
+ * The server implements the MCP Streamable HTTP transport specification,
+ * supporting both SSE streaming and direct HTTP responses.
+ */
+declare function startHttpServer(port?: number): Promise<void>;
+
+export { startHttpServer };

package/dist/http-server.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import {
+  initializeMcpServer
+} from "./chunk-NHJMKXNS.js";
+
+// src/http-server.ts
+import { createServer } from "http";
+import { randomUUID } from "crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+var DEFAULT_PORT = 3402;
+async function startHttpServer(port = DEFAULT_PORT) {
+  const server = new McpServer({
+    name: "blockrun-mcp",
+    version: "0.5.1"
+  });
+  initializeMcpServer(server);
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID()
+  });
+  await server.connect(transport);
+  const httpServer = createServer((req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, mcp-session-id, Authorization");
+    res.setHeader("Access-Control-Expose-Headers", "mcp-session-id");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.method === "GET" && req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "ok", server: "blockrun-mcp", version: "0.5.1", transport: "http" }));
+      return;
+    }
+    if (req.url === "/mcp" || req.url === "/") {
+      transport.handleRequest(req, res);
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not found");
+  });
+  httpServer.listen(port, () => {
+    console.error(`BlockRun MCP Server (HTTP) listening on http://localhost:${port}`);
+    console.error(`MCP endpoint: http://localhost:${port}/mcp`);
+    console.error(`Health check: http://localhost:${port}/health`);
+  });
+  const shutdown = () => {
+    console.error("Shutting down...");
+    httpServer.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+export {
+  startHttpServer
+};

package/dist/index.js

@@ -1,567 +1,29 @@
 #!/usr/bin/env node
+import {
+  initializeMcpServer
+} from "./chunk-NHJMKXNS.js";
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { LLMClient, ImageClient } from "@blockrun/llm";
-import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import QRCode from "qrcode";
-import { Jimp } from "jimp";
-import open from "open";
-var WALLET_DIR = path.join(os.homedir(), ".blockrun");
-var WALLET_FILE = path.join(WALLET_DIR, ".session");
-var QR_FILE = path.join(WALLET_DIR, "qr.png");
-var USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var BASE_CHAIN_ID = "8453";
-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 imageClient = null;
-var cachedModels = null;
-var sessionBudget = { limit: null, spent: 0, calls: 0 };
-var BASE_RPC_URLS = [
-  "https://mainnet.base.org",
-  "https://base.llamarpc.com",
-  "https://1rpc.io/base"
-];
-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 getImageClient() {
-  if (!imageClient) {
-    const privateKey = getOrCreateWalletKey();
-    imageClient = new ImageClient({ privateKey });
-  }
-  return imageClient;
-}
-function getWalletInfo() {
-  const llm = getClient();
-  const address = llm.getWalletAddress();
-  return {
-    address,
-    network: "Base",
-    chainId: 8453,
-    currency: "USDC",
-    isNew: walletWasCreated,
-    basescanUrl: `https://basescan.org/address/${address}`
-  };
-}
-async function getUsdcBalance(address) {
-  const data = {
-    jsonrpc: "2.0",
-    method: "eth_call",
-    params: [{
-      to: USDC_ADDRESS,
-      data: `0x70a08231000000000000000000000000${address.slice(2)}`
-    }, "latest"],
-    id: 1
-  };
-  for (const rpcUrl of BASE_RPC_URLS) {
-    try {
-      const response = await fetch(rpcUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(data)
-      });
-      const result = await response.json();
-      if (result.result) {
-        return parseInt(result.result, 16) / 1e6;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function getEip681Uri(address, amountUsdc = 1) {
-  const amountWei = Math.floor(amountUsdc * 1e6);
-  return `ethereum:${USDC_ADDRESS}@${BASE_CHAIN_ID}/transfer?address=${address}&uint256=${amountWei}`;
-}
-async function generateQrPng(address) {
-  const eip681Uri = getEip681Uri(address);
-  const qrBuffer = await QRCode.toBuffer(eip681Uri, {
-    type: "png",
-    width: 400,
-    margin: 2,
-    errorCorrectionLevel: "H",
-    color: { dark: "#000000", light: "#FFFFFF" }
-  });
-  const qrImage = await Jimp.read(qrBuffer);
-  try {
-    const logoUrl = "https://avatars.githubusercontent.com/u/108554348?s=200&v=4";
-    const logo = await Jimp.read(logoUrl);
-    const logoSize = Math.floor(qrImage.width * 0.2);
-    logo.resize({ w: logoSize, h: logoSize });
-    const x = Math.floor((qrImage.width - logoSize) / 2);
-    const y = Math.floor((qrImage.height - logoSize) / 2);
-    qrImage.composite(logo, x, y);
-  } catch {
-  }
-  if (!fs.existsSync(WALLET_DIR)) {
-    fs.mkdirSync(WALLET_DIR, { recursive: true, mode: 448 });
-  }
-  await qrImage.write(QR_FILE);
-  return QR_FILE;
-}
-async function openQrInViewer(qrPath) {
-  try {
-    await open(qrPath);
-  } catch {
-  }
-}
-function recordSpending(cost) {
-  sessionBudget.spent += cost;
-  sessionBudget.calls += 1;
-}
-function checkBudget() {
-  if (sessionBudget.limit === null) {
-    return { allowed: true, remaining: null };
-  }
-  const remaining = sessionBudget.limit - sessionBudget.spent;
-  return { allowed: remaining > 0, remaining };
-}
-function formatError(message) {
-  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 blockrun_wallet with action: "setup" to get funding instructions.
-
-Quick fix: Send USDC to your wallet on Base network.`;
-  }
-  return errorText;
-}
-var server = new McpServer({
-  name: "blockrun-mcp",
-  version: "0.4.0"
-});
-server.registerTool(
-  "blockrun_wallet",
-  {
-    description: `Manage your BlockRun wallet - check status, get funding instructions, open QR code, or manage session budget.
-
-Actions:
-- status: Show wallet address, balance, and basescan link (default)
-- setup: Full funding instructions with QR code
-- qr: Generate and open QR code for easy funding
-- budget: Manage session spending limit
-
-Examples:
-  blockrun_wallet()                                    -> status + balance
-  blockrun_wallet({ action: "setup" })                 -> funding instructions + QR
-  blockrun_wallet({ action: "qr" })                    -> open QR code
-  blockrun_wallet({ action: "budget", budget_action: "set", budget_amount: 1.00 })`,
-    inputSchema: {
-      action: z.enum(["status", "setup", "qr", "budget"]).optional().default("status").describe("What to do"),
-      budget_action: z.enum(["set", "check", "clear"]).optional().describe("Budget action (for action='budget')"),
-      budget_amount: z.number().optional().describe("Budget limit in USD (for budget_action='set')")
-    }
-  },
-  async ({ action, budget_action, budget_amount }) => {
-    const info = getWalletInfo();
-    const address = info.address;
-    if (action === "budget") {
-      const budgetAct = budget_action || "check";
-      if (budgetAct === "set") {
-        if (budget_amount === void 0 || budget_amount <= 0) {
-          return {
-            content: [{ type: "text", text: "Error: Provide a positive budget_amount (e.g., 1.00 for $1.00)" }],
-            isError: true
-          };
-        }
-        sessionBudget.limit = budget_amount;
-      } else if (budgetAct === "clear") {
-        sessionBudget.limit = null;
-      }
-      const remaining = sessionBudget.limit !== null ? sessionBudget.limit - sessionBudget.spent : null;
-      const limitStr = sessionBudget.limit !== null ? `$${sessionBudget.limit.toFixed(2)}` : "Unlimited";
-      const remainingStr = remaining !== null ? `$${remaining.toFixed(4)}` : "N/A";
-      return {
-        content: [{ type: "text", text: `Session Budget: ${limitStr} | Spent: $${sessionBudget.spent.toFixed(4)} | Calls: ${sessionBudget.calls} | Remaining: ${remainingStr}${budgetAct === "set" ? ` | Set to $${budget_amount?.toFixed(2)}` : ""}${budgetAct === "clear" ? " | Limit removed" : ""}` }],
-        structuredContent: {
-          limit: sessionBudget.limit,
-          spent: sessionBudget.spent,
-          calls: sessionBudget.calls,
-          remaining
-        }
-      };
-    }
-    if (action === "qr") {
-      try {
-        const qrPath = await generateQrPng(address);
-        await openQrInViewer(qrPath);
-        return {
-          content: [{ type: "text", text: `QR code opened! Scan with MetaMask to send USDC on Base.
-
-Address: ${address}
-QR saved: ${qrPath}` }]
-        };
-      } catch (err) {
-        return {
-          content: [{ type: "text", text: `Failed to generate QR: ${err}` }],
-          isError: true
-        };
-      }
-    }
-    if (action === "setup") {
-      let qrMessage = "";
-      try {
-        const qrPath = await generateQrPng(address);
-        await openQrInViewer(qrPath);
-        qrMessage = `
-QR code opened for scanning! (${qrPath})`;
-      } catch {
-        qrMessage = "\n(QR generation failed - use address above)";
-      }
-      const text2 = `
-================================================================================
-                        BLOCKRUN WALLET SETUP
-================================================================================
-
-Your wallet address: ${address}
-${qrMessage}
-
-HOW TO FUND YOUR WALLET:
-------------------------
-
-Option 1: Transfer from Coinbase
-  1. Open Coinbase app or website
-  2. Go to Send/Receive -> Select USDC
-  3. Choose "Base" network (important!)
-  4. Paste: ${address}
-  5. Send $1-5 to start
-
-Option 2: Bridge from other chains
-  https://bridge.base.org -> Bridge USDC to Base -> Send to address above
-
-Option 3: Buy directly
-  https://www.coinbase.com/onramp -> Buy USDC on Base -> Send to address above
-
-VERIFY BALANCE: https://basescan.org/address/${address}
-
-PRICING (pay per use):
-  - GPT-4o: ~$0.005/request | Claude Sonnet: ~$0.003/request
-  - Gemini Flash: ~$0.0001/request | Full pricing: https://blockrun.ai/pricing
-
-SECURITY: Private key stored at ~/.blockrun/.session (never leaves your machine)
-================================================================================`;
-      return { content: [{ type: "text", text: text2 }] };
-    }
-    const balance = await getUsdcBalance(address);
-    const balanceStr = balance !== null ? `$${balance.toFixed(6)} USDC` : "Unable to fetch";
-    const lowBalance = balance !== null && balance < 1;
-    const text = `Wallet: ${address}
-Balance: ${balanceStr}${lowBalance ? " (low - add funds)" : ""}
-Network: Base | View: ${info.basescanUrl}
-${info.isNew ? "\nNEW WALLET - Run with action: 'setup' for funding instructions" : ""}`;
-    return {
-      content: [{ type: "text", text }],
-      structuredContent: {
-        address: info.address,
-        balance,
-        network: info.network,
-        chainId: info.chainId,
-        isNew: info.isNew,
-        basescanUrl: info.basescanUrl
-      }
-    };
-  }
-);
-server.registerTool(
-  "blockrun_chat",
-  {
-    description: `Chat with AI models via BlockRun. Supports 30+ models with pay-per-request micropayments.
-
-Two ways to use:
-1. Specify a model directly: model: "openai/gpt-4o"
-2. Use smart routing: mode: "fast" | "balanced" | "powerful" | "cheap" | "reasoning"
-
-Popular models:
-- openai/gpt-5.2, openai/gpt-4o, openai/gpt-4o-mini
-- anthropic/claude-opus-4, anthropic/claude-sonnet-4
-- google/gemini-2.5-pro, google/gemini-2.5-flash
-- deepseek/deepseek-chat (very affordable)
-
-Smart routing modes:
-- fast: Gemini Flash, GPT-4o-mini (quickest)
-- balanced: GPT-4o, Claude Sonnet (good default)
-- powerful: GPT-5.2, Claude Opus 4 (best quality)
-- cheap: DeepSeek, Gemini Flash (lowest cost)
-- reasoning: o3, o1 (complex logic)
-
-Use blockrun_models to see all available models with pricing.`,
-    inputSchema: {
-      message: z.string().describe("Your message to the AI"),
-      model: z.string().optional().describe("Specific model ID (e.g., 'openai/gpt-4o')"),
-      mode: z.enum(["fast", "balanced", "powerful", "cheap", "reasoning"]).optional().describe("Smart routing mode (ignored if model specified)"),
-      system: z.string().optional().describe("Optional system prompt"),
-      max_tokens: z.number().optional().default(1024).describe("Max tokens in response"),
-      temperature: z.number().optional().default(1).describe("Creativity 0-2")
-    }
-  },
-  async ({ message, model, mode, system, max_tokens, temperature }) => {
-    const llm = getClient();
-    if (model) {
-      try {
-        const response = await llm.chat(model, message, {
-          system,
-          maxTokens: max_tokens,
-          temperature
-        });
-        return { content: [{ type: "text", text: response }] };
-      } catch (error) {
-        const errorMessage2 = error instanceof Error ? error.message : String(error);
-        return {
-          content: [{ type: "text", text: formatError(errorMessage2) }],
-          isError: true
-        };
-      }
-    }
-    const routingMode = mode || "balanced";
-    const models = MODEL_TIERS[routingMode];
-    let lastError = null;
-    for (const m of models) {
-      try {
-        const response = await llm.chat(m, message, {
-          system,
-          maxTokens: max_tokens
-        });
-        return {
-          content: [{ type: "text", text: `[${m}]
-
-${response}` }],
-          structuredContent: { model_used: m, response }
-        };
-      } catch (error) {
-        lastError = error;
-        continue;
-      }
-    }
-    const errorMessage = lastError?.message || "All models failed";
-    return {
-      content: [{ type: "text", text: formatError(errorMessage) }],
-      isError: true
-    };
-  }
-);
-server.registerTool(
-  "blockrun_models",
-  {
-    description: "List available AI models with pricing. Use to discover models and compare costs.",
-    inputSchema: {
-      category: z.enum(["all", "chat", "reasoning", "image", "embedding"]).optional().default("all").describe("Filter by category"),
-      provider: z.string().optional().describe("Filter by provider (e.g., 'openai', 'anthropic')")
-    }
-  },
-  async ({ category, provider }) => {
-    const llm = getClient();
-    if (!cachedModels) {
-      cachedModels = await llm.listModels();
-      setTimeout(() => {
-        cachedModels = null;
-      }, 5 * 60 * 1e3);
-    }
-    let models = cachedModels;
-    if (provider) {
-      const p = provider.toLowerCase();
-      models = models.filter((m) => m.id.toLowerCase().startsWith(p + "/"));
-    }
-    if (category && category !== "all") {
-      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}${pricing ? ` (${pricing})` : ""}`;
+var args = process.argv.slice(2);
+var isHttp = args.includes("--http");
+var portIdx = args.indexOf("--port");
+var port = portIdx !== -1 ? parseInt(args[portIdx + 1], 10) : 3402;
+async function main() {
+  if (isHttp) {
+    const { startHttpServer } = await import("./http-server.js");
+    await startHttpServer(port);
+  } else {
+    const server = new McpServer({
+      name: "blockrun-mcp",
+      version: "0.5.1"
     });
-    return {
-      content: [{ type: "text", text: `Models (${models.length}):
-${lines.join("\n")}` }],
-      structuredContent: { count: models.length, models }
-    };
-  }
-);
-server.registerTool(
-  "blockrun_image",
-  {
-    description: `Generate images. Models: openai/dall-e-3 ($0.04-0.08), together/flux-schnell ($0.02), google/nano-banana`,
-    inputSchema: {
-      prompt: z.string().describe("Image description"),
-      model: z.enum(["openai/dall-e-3", "together/flux-schnell", "google/nano-banana"]).optional().default("openai/dall-e-3"),
-      size: z.enum(["1024x1024", "1792x1024", "1024x1792"]).optional().default("1024x1024"),
-      quality: z.enum(["standard", "hd"]).optional().default("standard")
-    }
-  },
-  async ({ prompt, model, size, quality }) => {
-    try {
-      const imgClient = getImageClient();
-      const response = await imgClient.generate(prompt, {
-        model,
-        size,
-        quality
-      });
-      const imageUrl = response.data?.[0]?.url;
-      if (!imageUrl) {
-        return {
-          content: [{ type: "text", text: formatError("No image URL in response") }],
-          isError: true
-        };
-      }
-      return {
-        content: [{ type: "text", text: `Image: ${imageUrl}
-Prompt: ${prompt}
-Model: ${model}` }],
-        structuredContent: { url: imageUrl, prompt, model }
-      };
-    } catch (err) {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      if (errMsg.includes("balance") || errMsg.includes("payment") || errMsg.includes("402")) {
-        return {
-          content: [{ type: "text", text: `Image generation requires payment. Run blockrun_wallet with action: "setup" for funding instructions.
-Error: ${errMsg}` }],
-          isError: true
-        };
-      }
-      return {
-        content: [{ type: "text", text: formatError(`Image generation failed: ${errMsg}`) }],
-        isError: true
-      };
-    }
-  }
-);
-server.registerTool(
-  "blockrun_twitter",
-  {
-    description: `Search real-time X/Twitter via Grok. Use for trending topics, @handles, breaking news.`,
-    inputSchema: {
-      query: z.string().describe("Search query (can include @handles, topics)"),
-      max_results: z.number().optional().default(10).describe("Max results (1-25)")
-    }
-  },
-  async ({ query, max_results }) => {
-    const budget = checkBudget();
-    if (!budget.allowed) {
-      return {
-        content: [{ type: "text", text: `Budget limit reached ($${sessionBudget.spent.toFixed(4)} of $${sessionBudget.limit?.toFixed(2)}). Use blockrun_wallet with action: "budget" to adjust.` }],
-        isError: true
-      };
-    }
-    try {
-      const llm = getClient();
-      const response = await llm.chat("xai/grok-3", query, {
-        system: `Real-time X/Twitter search. Focus on recent posts, key accounts, engagement. Max results: ${max_results}`,
-        search: true
-      });
-      recordSpending(2e-3);
-      return {
-        content: [{ type: "text", text: `[X/Twitter via Grok]
-
-${response}` }],
-        structuredContent: { query, model: "xai/grok-3", response }
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return {
-        content: [{ type: "text", text: formatError(errorMessage) }],
-        isError: true
-      };
-    }
-  }
-);
-server.registerResource(
-  "wallet",
-  "blockrun://wallet",
-  { description: "Wallet address and status", mimeType: "application/json" },
-  async () => ({
-    contents: [{
-      uri: "blockrun://wallet",
-      mimeType: "application/json",
-      text: JSON.stringify(getWalletInfo(), null, 2)
-    }]
-  })
-);
-server.registerResource(
-  "models",
-  "blockrun://models",
-  { description: "Available AI models with pricing", mimeType: "application/json" },
-  async () => {
-    const llm = getClient();
-    if (!cachedModels) {
-      cachedModels = await llm.listModels();
-      setTimeout(() => {
-        cachedModels = null;
-      }, 5 * 60 * 1e3);
-    }
-    return {
-      contents: [{
-        uri: "blockrun://models",
-        mimeType: "application/json",
-        text: JSON.stringify(cachedModels, null, 2)
-      }]
-    };
+    initializeMcpServer(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("BlockRun MCP Server started (v0.5.1) \u2014 stdio transport");
   }
-);
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error("BlockRun MCP Server started (v0.4.0)");
 }
 main().catch((error) => {
   console.error("Fatal error:", error);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@blockrun/mcp",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "mcpName": "io.github.BlockRunAI/blockrun-mcp",
-  "description": "BlockRun MCP Server - Access 30+ AI models via x402 micropayments. No API keys needed.",
+  "description": "BlockRun MCP Server - Access 41+ AI models + on-chain data via x402 micropayments. Supports stdio and HTTP transport.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,7 +14,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts src/http-server.ts --format esm --dts --clean",
     "dev": "tsx watch src/index.ts",
     "start": "node dist/index.js",
     "typecheck": "tsc --noEmit",
@@ -44,7 +44,7 @@
     "url": "https://github.com/blockrunai/blockrun-mcp/issues"
   },
   "dependencies": {
-    "@blockrun/llm": "^0.2.0",
+    "@blockrun/llm": "^1.5.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "jimp": "^1.6.0",
     "open": "^11.0.0",