@blockrun/mcp 0.4.1 → 0.4.2

package/README.md

@@ -1,4 +1,6 @@
-# @blockrun/mcp
+# @blockrun/mcp — BlockRun MCP Server for Claude Code
+
+> **@blockrun/mcp** is an MCP (Model Context Protocol) server that gives Claude Code access to 30+ AI models (GPT-5, Gemini, Grok, DeepSeek, and more), image generation, and real-time X/Twitter data — all with pay-per-request USDC micropayments via x402. No API keys, no subscriptions. One command to install.
 
 ## The Problem
 
@@ -335,17 +337,31 @@ 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)
+- **Documentation:** [GitHub Docs](https://github.com/BlockRunAI/awesome-blockrun/tree/main/docs)
 - **Pricing:** [blockrun.ai/pricing](https://blockrun.ai/pricing)
 - **GitHub:** [github.com/blockrunai](https://github.com/blockrunai)
-- **Twitter:** [@blockaborama](https://twitter.com/blockaborama)
+- **Twitter:** [@BlockRunAI](https://x.com/BlockRunAI)
 
 ## Support
 
 - **Issues:** [GitHub Issues](https://github.com/blockrunai/blockrun-mcp/issues)
-- **Discord:** [Join our Discord](https://discord.gg/blockrun)
+- **Telegram:** [Join our Telegram](https://t.me/+mroQv4-4hGgzOGUx)
 - **Email:** hello@blockrun.ai
 
+## Frequently Asked Questions
+
+### What is BlockRun MCP?
+BlockRun MCP is a Model Context Protocol (MCP) server that gives Claude Code users access to 30+ AI models from OpenAI, Google, xAI, DeepSeek, and more. It uses USDC micropayments via the x402 protocol — no API keys or subscriptions needed.
+
+### How do I install BlockRun MCP?
+One command: `claude mcp add blockrun npx @blockrun/mcp`. A wallet is automatically created for you. Fund it with USDC on Base network and start using any model.
+
+### How much does it cost?
+Pay only for what you use — no minimums or subscriptions. $5 in USDC gets you approximately 50,000 Gemini Flash requests or 1,000 GPT-4o requests. A quick question costs around $0.0001.
+
+### Why use BlockRun MCP instead of direct API keys?
+With direct APIs, you need 5+ accounts, 5+ API keys, and 5+ billing systems. BlockRun MCP gives you one wallet for all providers, one command to install, and zero API key management.
+
 ## License
 
 MIT

package/dist/index.js

@@ -18,11 +18,11 @@ 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"]
+  fast: ["google/gemini-2.5-flash", "openai/gpt-5-mini", "deepseek/deepseek-chat", "google/gemini-3-flash-preview"],
+  balanced: ["openai/gpt-5.4", "anthropic/claude-sonnet-4.6", "google/gemini-2.5-pro", "openai/gpt-5.3"],
+  powerful: ["openai/gpt-5.4", "anthropic/claude-opus-4.6", "anthropic/claude-opus-4.5", "openai/o3"],
+  cheap: ["nvidia/gpt-oss-120b", "google/gemini-2.5-flash", "deepseek/deepseek-chat", "openai/gpt-5.4-nano"],
+  reasoning: ["openai/o3", "openai/o1", "openai/o3-mini", "deepseek/deepseek-reasoner"]
 };
 var walletWasCreated = false;
 var walletAddress = null;
@@ -169,9 +169,16 @@ function checkBudget() {
   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");
+  const msgLower = message.toLowerCase();
+  const isPaymentError = msgLower.includes("402") || msgLower.includes("balance") || msgLower.includes("insufficient") || msgLower.includes("payment") && !msgLower.includes("500");
+  const isServerError = msgLower.includes("500") || msgLower.includes("api error after payment");
   let errorText = `Error: ${message}`;
-  if (isPaymentError) {
+  if (isServerError) {
+    errorText += `
+
+This is a temporary API issue. The xAI/Grok API may be experiencing problems.
+Try again in a few minutes, or use a different model (e.g., openai/gpt-4o).`;
+  } else if (isPaymentError) {
     errorText += `
 
 This error usually means your wallet needs funding.
@@ -323,19 +330,19 @@ server.registerTool(
     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"
+1. Specify a model directly: model: "openai/gpt-5.4"
 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
+- openai/gpt-5.4, openai/gpt-5.4-mini, openai/gpt-5.4-nano
+- anthropic/claude-opus-4.6, anthropic/claude-sonnet-4.6
 - 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)
+- fast: Gemini Flash, GPT-5 Mini (quickest)
+- balanced: GPT-5.4, Claude Sonnet 4.6 (good default)
+- powerful: GPT-5.4, Claude Opus 4.6 (best quality)
 - cheap: DeepSeek, Gemini Flash (lowest cost)
 - reasoning: o3, o1 (complex logic)
 
@@ -419,17 +426,19 @@ server.registerTool(
     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"));
+      } else {
+        models = models.filter((m) => m.categories?.includes(category));
       }
     }
     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})` : ""}`;
+      const ctx = m.contextWindow ? ` | ${Math.round(m.contextWindow / 1e3)}K ctx` : "";
+      const cats = m.categories?.length ? ` [${m.categories.join(", ")}]` : "";
+      return `- ${m.id}${pricing ? ` (${pricing})` : ""}${ctx}${cats}`;
     });
     return {
       content: [{ type: "text", text: `Models (${models.length}):
@@ -525,6 +534,575 @@ ${response}` }],
     }
   }
 );
+server.registerTool(
+  "blockrun_dex",
+  {
+    description: `Get real-time DEX data from DexScreener. FREE - no payment required.
+
+Use for:
+- Token prices and liquidity across chains
+- Trading volume and price changes
+- Finding token pairs and contracts
+
+Examples:
+  blockrun_dex({ query: "SOL" })           -> Search for SOL pairs
+  blockrun_dex({ token: "So11...xxx" })    -> Get specific token data
+  blockrun_dex({ symbol: "PEPE" })         -> Search by symbol`,
+    inputSchema: {
+      query: z.string().optional().describe("Search query (token name, symbol, or address)"),
+      token: z.string().optional().describe("Token address for direct lookup"),
+      symbol: z.string().optional().describe("Token symbol to search"),
+      chain: z.string().optional().describe("Filter by chain (ethereum, solana, base, etc.)")
+    }
+  },
+  async ({ query, token, symbol, chain }) => {
+    try {
+      let url;
+      let searchTerm = query || symbol || "";
+      if (token) {
+        url = `https://api.dexscreener.com/latest/dex/tokens/${token}`;
+      } else if (searchTerm) {
+        url = `https://api.dexscreener.com/latest/dex/search?q=${encodeURIComponent(searchTerm)}`;
+      } else {
+        return {
+          content: [{ type: "text", text: "Provide query, token address, or symbol" }],
+          isError: true
+        };
+      }
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`DexScreener API error: ${response.status}`);
+      }
+      const data = await response.json();
+      let pairs = data.pairs || [];
+      if (chain && pairs.length > 0) {
+        const chainLower = chain.toLowerCase();
+        pairs = pairs.filter((p) => p.chainId.toLowerCase().includes(chainLower));
+      }
+      pairs = pairs.sort((a, b) => (b.volume?.h24 || 0) - (a.volume?.h24 || 0)).slice(0, 10);
+      if (pairs.length === 0) {
+        return {
+          content: [{ type: "text", text: `No pairs found for: ${searchTerm || token}` }]
+        };
+      }
+      const lines = pairs.map((p) => {
+        const price = p.priceUsd ? `$${parseFloat(p.priceUsd).toFixed(6)}` : "N/A";
+        const change = p.priceChange?.h24 ? `${p.priceChange.h24 > 0 ? "+" : ""}${p.priceChange.h24.toFixed(2)}%` : "";
+        const vol = p.volume?.h24 ? `$${(p.volume.h24 / 1e6).toFixed(2)}M` : "";
+        const liq = p.liquidity?.usd ? `$${(p.liquidity.usd / 1e6).toFixed(2)}M liq` : "";
+        const buySell = p.txns?.h24 ? `${p.txns.h24.buys}B/${p.txns.h24.sells}S` : "";
+        return `${p.baseToken.symbol}/${p.quoteToken.symbol} (${p.chainId}/${p.dexId})
+  Price: ${price} ${change} | Vol: ${vol} | ${liq} | Txns: ${buySell}
+  Token: ${p.baseToken.address}`;
+      });
+      return {
+        content: [{ type: "text", text: `[DexScreener - FREE]
+
+${lines.join("\n\n")}` }],
+        structuredContent: { pairs, count: pairs.length }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `DexScreener error: ${errorMessage}` }],
+        isError: true
+      };
+    }
+  }
+);
+var KNOWN_LABELS = {
+  "0x28c6c06298d514db089934071355e5743bf21d60": "Binance 14",
+  "0x21a31ee1afc51d94c2efccaa2092ad1028285549": "Binance 15",
+  "0xdfd5293d8e347dfe59e90efd55b2956a1343963d": "Binance 16",
+  "0x56eddb7aa87536c09ccc2793473599fd21a8b17f": "Binance 17",
+  "0x9696f59e4d72e237be84ffd425dcad154bf96976": "Binance 18",
+  "0x4976a4a02f38326660d17bf34b431dc6e2eb2327": "Binance 19",
+  "0xf977814e90da44bfa03b6295a0616a897441acec": "Binance 8",
+  "0x5a52e96bacdabb82fd05763e25335261b270efcb": "Binance",
+  "0x3f5ce5fbfe3e9af3971dd833d26ba9b5c936f0be": "Binance",
+  "0xd24400ae8bfebb18ca49be86258a3c749cf46853": "Gemini 2",
+  "0x6fc82a5fe25a5cdb58bc74600a40a69c065263f8": "Gemini 3",
+  "0x61edcdf5bb737adffe5043706e7c5bb1f1a56eea": "Gemini 4",
+  "0x07ee55aa48bb72dcc6e9d78256648910de513eca": "Gemini 5",
+  "0xdc76cd25977e0a5ae17155770273ad58648900d3": "Coinbase Prime",
+  "0xa9d1e08c7793af67e9d92fe308d5697fb81d3e43": "Coinbase 10",
+  "0x503828976d22510aad0201ac7ec88293211d23da": "Coinbase 2",
+  "0xddfabcdc4d8ffc6d5beaf154f18b778f892a0740": "Coinbase 3",
+  "0x3cd751e6b0078be393132286c442345e5dc49699": "Coinbase 4",
+  "0xb5d85cbf7cb3ee0d56b3bb207d5fc4b82f43f511": "Coinbase 5",
+  "0xeb2629a2734e272bcc07bda959863f316f4bd4cf": "Coinbase 6",
+  "0x02466e547bfdab679fc49e96bbfc62b9747d997c": "Coinbase 8",
+  "0xa090e606e30bd747d4e6245a1517ebe430f0057e": "Coinbase",
+  "0x8103683202aa8da10536036edef04cdd865c225e": "Kraken 13",
+  "0x6cc5f688a315f3dc28a7781717a9a798a59fda7b": "OKX 1",
+  "0x236f9f97e0e62388479bf9e5ba4889e46b0273c3": "OKX 2",
+  "0x5041ed759dd4afc3a72b8192c143f72f4724081a": "OKX 4",
+  "0x75e89d5979e4f6fba9f97c104c2f0afb3f1dcb88": "MEXC",
+  "0x0d0707963952f2fba59dd06f2b425ace40b492fe": "Gate.io",
+  "0x1c4b70a3968436b9a0a9cf5205c787eb81bb558c": "Gate.io 3",
+  "0xd793281182a0e3e023116004778f45c29fc14f19": "Gate.io 4",
+  "0x974caa59e49682cda0ad2bbe82983419a2ecc400": "HTX",
+  "0x0211f3cedbef3143223d3acf0e589747933e8527": "HTX 2",
+  "0x1062a747393198f70f71ec65a582423dba7e5ab3": "Bybit",
+  "0xee5b5b923ffce93a870b3104b7ca09c3db80047a": "Bybit 2",
+  "0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503": "Binance: Foundation",
+  "0xbe0eb53f46cd790cd13851d5eff43d12404d33e8": "Binance 7",
+  "0x40ec5b33f54e0e8a33a975908c5ba1c14e5bbbdf": "Polygon Bridge",
+  "0xa3a7b6f88361f48403514059f1f16c8e78d60eec": "Arbitrum Bridge",
+  "0x99c9fc46f92e8a1c0dec1b1747d010903e884be1": "Optimism Bridge",
+  "0x8315177ab297ba92a06054ce80a67ed4dbd7ed3a": "Arbitrum: Delayed Inbox",
+  "0x0000000000000000000000000000000000000000": "Null/Burn Address"
+};
+function getAddressLabel(address) {
+  const lower = address.toLowerCase();
+  return KNOWN_LABELS[lower] || shortenAddress(address);
+}
+function shortenAddress(address) {
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+server.registerTool(
+  "blockrun_whale",
+  {
+    description: `Track large ETH transfers (whale movements). Uses BigQuery public data.
+
+Shows:
+- Large transfers (100+ ETH)
+- Exchange inflows/outflows
+- Labels for known addresses (Binance, Coinbase, etc.)
+
+Note: Requires GOOGLE_APPLICATION_CREDENTIALS env var for BigQuery auth.
+For MVP/demo: Returns simulated data if BigQuery not configured.`,
+    inputSchema: {
+      hours: z.number().optional().default(24).describe("Hours to look back (default: 24)"),
+      min_eth: z.number().optional().default(100).describe("Minimum ETH amount (default: 100)"),
+      limit: z.number().optional().default(20).describe("Max results (default: 20)")
+    }
+  },
+  async ({ hours, min_eth, limit }) => {
+    const hasGoogleCreds = process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
+    if (!hasGoogleCreds) {
+      const demoData = [
+        { from: "0xf977814e90da44bfa03b6295a0616a897441acec", to: "0x28c6c06298d514db089934071355e5743bf21d60", value: 5e3, time: "2h ago" },
+        { from: "0x503828976d22510aad0201ac7ec88293211d23da", to: "0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503", value: 3200, time: "4h ago" },
+        { from: "0x6cc5f688a315f3dc28a7781717a9a798a59fda7b", to: "0xd24400ae8bfebb18ca49be86258a3c749cf46853", value: 2100, time: "6h ago" },
+        { from: "0x1062a747393198f70f71ec65a582423dba7e5ab3", to: "0x99c9fc46f92e8a1c0dec1b1747d010903e884be1", value: 1800, time: "8h ago" },
+        { from: "0x75e89d5979e4f6fba9f97c104c2f0afb3f1dcb88", to: "0xa3a7b6f88361f48403514059f1f16c8e78d60eec", value: 1500, time: "12h ago" }
+      ];
+      const lines = demoData.map((t) => {
+        const fromLabel = getAddressLabel(t.from);
+        const toLabel = getAddressLabel(t.to);
+        return `${t.value.toLocaleString()} ETH | ${fromLabel} \u2192 ${toLabel} | ${t.time}`;
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `[Whale Tracker - DEMO MODE]
+\u26A0\uFE0F BigQuery not configured. Showing sample data.
+
+To enable real data:
+1. Create GCP project: console.cloud.google.com
+2. Enable BigQuery API
+3. Set GOOGLE_APPLICATION_CREDENTIALS env var
+
+Sample whale movements:
+${lines.join("\n")}
+
+Total: ${demoData.reduce((s, t) => s + t.value, 0).toLocaleString()} ETH across ${demoData.length} transfers`
+        }],
+        structuredContent: { demo: true, transfers: demoData }
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `[Whale Tracker]
+
+BigQuery credentials detected. Real-time query:
+- Looking back: ${hours}h
+- Min transfer: ${min_eth} ETH
+- Limit: ${limit} results
+
+Query would run:
+SELECT block_timestamp, from_address, to_address, value/1e18 as eth
+FROM \`bigquery-public-data.crypto_ethereum.transactions\`
+WHERE value > ${min_eth} * 1e18
+  AND block_timestamp > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL ${hours} HOUR)
+ORDER BY value DESC
+LIMIT ${limit}
+
+Note: Full BigQuery integration coming soon.`
+      }]
+    };
+  }
+);
+server.registerTool(
+  "blockrun_analyze",
+  {
+    description: `Comprehensive trading analysis combining multiple data sources.
+
+Analyzes:
+- DEX data (price, volume, liquidity) via DexScreener
+- Twitter/X sentiment via Grok
+- Whale movements (if BigQuery configured)
+- AI synthesis of all data
+
+Example: blockrun_analyze({ token: "SOL", question: "Should I buy?" })`,
+    inputSchema: {
+      token: z.string().describe("Token symbol or address to analyze"),
+      question: z.string().optional().describe("Specific question (default: general analysis)"),
+      include_twitter: z.boolean().optional().default(true).describe("Include Twitter sentiment"),
+      include_whale: z.boolean().optional().default(false).describe("Include whale tracking")
+    }
+  },
+  async ({ token, question, include_twitter, include_whale }) => {
+    const llm = getClient();
+    const analysisPrompt = question || `Provide comprehensive trading analysis for ${token}`;
+    let contextData = "";
+    try {
+      const dexUrl = `https://api.dexscreener.com/latest/dex/search?q=${encodeURIComponent(token)}`;
+      const dexResponse = await fetch(dexUrl);
+      const dexData = await dexResponse.json();
+      if (dexData.pairs && dexData.pairs.length > 0) {
+        const topPair = dexData.pairs[0];
+        contextData += `
+## DEX Data (DexScreener)
+`;
+        contextData += `- Token: ${topPair.baseToken.name} (${topPair.baseToken.symbol})
+`;
+        contextData += `- Price: $${parseFloat(topPair.priceUsd).toFixed(6)}
+`;
+        contextData += `- 24h Change: ${topPair.priceChange?.h24?.toFixed(2) || "N/A"}%
+`;
+        contextData += `- 24h Volume: $${((topPair.volume?.h24 || 0) / 1e6).toFixed(2)}M
+`;
+        contextData += `- Liquidity: $${((topPair.liquidity?.usd || 0) / 1e6).toFixed(2)}M
+`;
+        contextData += `- FDV: $${((topPair.fdv || 0) / 1e9).toFixed(2)}B
+`;
+        contextData += `- Chain: ${topPair.chainId}
+`;
+      }
+    } catch (err) {
+      contextData += `
+## DEX Data: Error fetching
+`;
+    }
+    if (include_twitter) {
+      try {
+        const twitterResponse = await llm.chat("xai/grok-3", `What are people saying about ${token} on Twitter/X right now? Focus on: sentiment, key influencers, trending topics, price predictions.`, {
+          system: "Real-time X/Twitter search. Provide factual summary of recent posts.",
+          search: true
+        });
+        contextData += `
+## Twitter/X Sentiment (via Grok)
+${twitterResponse}
+`;
+      } catch {
+        contextData += `
+## Twitter: Unable to fetch
+`;
+      }
+    }
+    if (include_whale) {
+      contextData += `
+## Whale Movements
+`;
+      contextData += `Note: BigQuery not configured. In production, this would show:
+`;
+      contextData += `- Large transfers to/from exchanges
+`;
+      contextData += `- Smart money wallet movements
+`;
+      contextData += `- Exchange inflow/outflow trends
+`;
+    }
+    const synthesisPrompt = `You are a crypto trading analyst. Based on the following data, answer: "${analysisPrompt}"
+
+${contextData}
+
+Provide:
+1. Key findings (bullet points)
+2. Risk assessment (Low/Medium/High)
+3. Trading suggestion (if asked)
+4. What to watch for
+
+Be factual and balanced. Don't give financial advice, but provide analysis based on the data.`;
+    try {
+      const analysis = await llm.chat("openai/gpt-4o", synthesisPrompt, {
+        system: "Expert crypto trading analyst. Provide data-driven analysis.",
+        maxTokens: 1500
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `[BlockRun Trading Analysis: ${token}]
+
+${analysis}
+
+---
+Data sources: DexScreener${include_twitter ? ", Twitter/X (Grok)" : ""}${include_whale ? ", Whale Tracker" : ""}`
+        }],
+        structuredContent: { token, question: analysisPrompt, analysis }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: formatError(errorMessage) }],
+        isError: true
+      };
+    }
+  }
+);
+function calculateEMA(prices, period) {
+  const k = 2 / (period + 1);
+  const ema = [prices[0]];
+  for (let i = 1; i < prices.length; i++) {
+    ema.push(prices[i] * k + ema[i - 1] * (1 - k));
+  }
+  return ema;
+}
+function calculateRSI(prices, period = 14) {
+  if (prices.length < period + 1) return 50;
+  let gains = 0, losses = 0;
+  for (let i = prices.length - period; i < prices.length; i++) {
+    const change = prices[i] - prices[i - 1];
+    if (change > 0) gains += change;
+    else losses -= change;
+  }
+  const avgGain = gains / period;
+  const avgLoss = losses / period;
+  if (avgLoss === 0) return 100;
+  const rs = avgGain / avgLoss;
+  return 100 - 100 / (1 + rs);
+}
+function calculateMACD(prices) {
+  const ema12 = calculateEMA(prices, 12);
+  const ema26 = calculateEMA(prices, 26);
+  const macdLine = ema12.map((v, i) => v - ema26[i]);
+  const signalLine = calculateEMA(macdLine.slice(-9), 9);
+  const macd = macdLine[macdLine.length - 1];
+  const signal = signalLine[signalLine.length - 1];
+  return { macd, signal, histogram: macd - signal };
+}
+server.registerTool(
+  "blockrun_signal",
+  {
+    description: `Generate trading signals using RSI + MACD + EMA strategy.
+
+Strategy (from freqtrade-strategies):
+- BUY when: RSI < 40 (oversold) + MACD > Signal + Price > EMA200
+- SELL when: RSI > 70 (overbought) or take profit/stop loss
+
+Returns: BUY / SELL / HOLD signal with confidence level.
+
+Example: blockrun_signal({ symbol: "BTCUSDT" })`,
+    inputSchema: {
+      symbol: z.string().describe("Trading pair (e.g., BTCUSDT, ETHUSDT, SOLUSDT)"),
+      timeframe: z.enum(["5m", "15m", "1h", "4h"]).optional().default("1h").describe("Candle timeframe")
+    }
+  },
+  async ({ symbol, timeframe }) => {
+    try {
+      const url = `https://api.binance.com/api/v3/klines?symbol=${symbol.toUpperCase()}&interval=${timeframe}&limit=250`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Binance API error: ${response.status}`);
+      }
+      const candles = await response.json();
+      const closes = candles.map((c) => parseFloat(c[4]));
+      const currentPrice = closes[closes.length - 1];
+      const rsi = calculateRSI(closes);
+      const { macd, signal, histogram } = calculateMACD(closes);
+      const ema200 = calculateEMA(closes, 200);
+      const currentEMA200 = ema200[ema200.length - 1];
+      const ema50 = calculateEMA(closes, 50);
+      const currentEMA50 = ema50[ema50.length - 1];
+      let signalType = "HOLD";
+      let confidence = 0;
+      let reasons = [];
+      const rsiOversold = rsi < 40;
+      const macdBullish = macd > signal;
+      const aboveEMA200 = currentPrice > currentEMA200;
+      const aboveEMA50 = currentPrice > currentEMA50;
+      const rsiOverbought = rsi > 70;
+      const macdBearish = macd < signal;
+      const belowEMA200 = currentPrice < currentEMA200;
+      if (rsiOversold && macdBullish && aboveEMA200) {
+        signalType = "BUY";
+        confidence = 80;
+        reasons.push("RSI oversold (<40)");
+        reasons.push("MACD bullish crossover");
+        reasons.push("Price above EMA200 (uptrend)");
+        if (aboveEMA50) {
+          confidence += 10;
+          reasons.push("Price above EMA50 (strong)");
+        }
+      } else if (rsiOverbought || macdBearish && belowEMA200) {
+        signalType = "SELL";
+        confidence = rsiOverbought ? 75 : 60;
+        if (rsiOverbought) reasons.push("RSI overbought (>70)");
+        if (macdBearish) reasons.push("MACD bearish");
+        if (belowEMA200) reasons.push("Price below EMA200 (downtrend)");
+      } else {
+        signalType = "HOLD";
+        confidence = 50;
+        reasons.push("No clear signal");
+        if (rsi < 50 && macdBullish) reasons.push("Slight bullish bias");
+        if (rsi > 50 && macdBearish) reasons.push("Slight bearish bias");
+      }
+      const stopLoss = signalType === "BUY" ? currentPrice * 0.9 : null;
+      const takeProfit = signalType === "BUY" ? currentPrice * 1.2 : null;
+      const result = `[Trading Signal: ${symbol}]
+
+Signal: ${signalType} (${confidence}% confidence)
+Price: $${currentPrice.toFixed(2)}
+
+Indicators:
+- RSI (14): ${rsi.toFixed(1)} ${rsi < 30 ? "\u{1F7E2} Oversold" : rsi > 70 ? "\u{1F534} Overbought" : "\u26AA Neutral"}
+- MACD: ${macd.toFixed(4)} | Signal: ${signal.toFixed(4)} | ${histogram > 0 ? "\u{1F7E2} Bullish" : "\u{1F534} Bearish"}
+- EMA 50: $${currentEMA50.toFixed(2)} ${currentPrice > currentEMA50 ? "\u{1F7E2} Above" : "\u{1F534} Below"}
+- EMA 200: $${currentEMA200.toFixed(2)} ${currentPrice > currentEMA200 ? "\u{1F7E2} Above" : "\u{1F534} Below"}
+
+Reasons:
+${reasons.map((r) => `\u2022 ${r}`).join("\n")}
+${signalType === "BUY" ? `
+Suggested:
+\u2022 Stop Loss: $${stopLoss?.toFixed(2)} (-10%)
+\u2022 Take Profit: $${takeProfit?.toFixed(2)} (+20%)` : ""}
+
+Strategy: RSI + MACD + EMA (freqtrade-strategies)
+Timeframe: ${timeframe}`;
+      return {
+        content: [{ type: "text", text: result }],
+        structuredContent: {
+          symbol,
+          signal: signalType,
+          confidence,
+          price: currentPrice,
+          indicators: { rsi, macd, signal, ema50: currentEMA50, ema200: currentEMA200 },
+          stopLoss,
+          takeProfit,
+          reasons
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `Signal error: ${errorMessage}` }],
+        isError: true
+      };
+    }
+  }
+);
+var ZERO_X_API = "https://api.0x.org/swap/v1";
+var BASE_CHAIN_ID_NUM = 8453;
+var BASE_TOKENS = {
+  "ETH": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+  "WETH": "0x4200000000000000000000000000000000000006",
+  "USDC": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  "USDbC": "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA",
+  "DAI": "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+  "cbETH": "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22"
+};
+server.registerTool(
+  "blockrun_swap",
+  {
+    description: `Execute token swaps on Base network using 0x aggregator.
+
+\u26A0\uFE0F REAL MONEY - requires user confirmation before execution.
+
+Example: blockrun_swap({ from: "USDC", to: "ETH", amount: 10 })`,
+    inputSchema: {
+      from: z.string().describe("Token to sell (USDC, ETH, WETH, etc.)"),
+      to: z.string().describe("Token to buy"),
+      amount: z.number().describe("Amount in 'from' token"),
+      slippage: z.number().optional().default(0.5).describe("Max slippage % (default 0.5)"),
+      execute: z.boolean().optional().default(false).describe("Set true to execute (requires confirmation)")
+    }
+  },
+  async ({ from, to, amount, slippage, execute }) => {
+    const fromUpper = from.toUpperCase();
+    const toUpper = to.toUpperCase();
+    const fromToken = BASE_TOKENS[fromUpper];
+    const toToken = BASE_TOKENS[toUpper];
+    if (!fromToken) {
+      return {
+        content: [{ type: "text", text: `Unknown token: ${from}. Supported: ${Object.keys(BASE_TOKENS).join(", ")}` }],
+        isError: true
+      };
+    }
+    if (!toToken) {
+      return {
+        content: [{ type: "text", text: `Unknown token: ${to}. Supported: ${Object.keys(BASE_TOKENS).join(", ")}` }],
+        isError: true
+      };
+    }
+    const decimals = fromUpper === "USDC" || fromUpper === "USDbC" ? 6 : 18;
+    const amountWei = BigInt(Math.floor(amount * 10 ** decimals));
+    try {
+      const quoteUrl = `${ZERO_X_API}/quote?` + new URLSearchParams({
+        sellToken: fromToken,
+        buyToken: toToken,
+        sellAmount: amountWei.toString(),
+        slippagePercentage: (slippage / 100).toString(),
+        chainId: BASE_CHAIN_ID_NUM.toString()
+      });
+      const estimatedOutput = fromUpper === "USDC" ? amount / 3300 : amount * 3300;
+      const quoteResult = `[Swap Quote: ${fromUpper} \u2192 ${toUpper}]
+
+Sell: ${amount} ${fromUpper}
+Buy (est): ~${estimatedOutput.toFixed(6)} ${toUpper}
+Slippage: ${slippage}%
+Network: Base
+
+${execute ? "\u26A0\uFE0F EXECUTION REQUESTED" : "\u{1F4A1} Set execute: true to swap"}
+
+Note: Full 0x integration requires API key.
+For demo, this shows the quote flow.
+
+To execute:
+1. User confirms the swap
+2. Wallet signs transaction
+3. Swap executes on-chain
+4. Returns tx hash`;
+      if (execute) {
+        return {
+          content: [{
+            type: "text",
+            text: `\u26A0\uFE0F SWAP EXECUTION DISABLED FOR SAFETY
+
+To enable real swaps:
+1. Add 0x API key
+2. Implement transaction signing
+3. Add confirmation flow
+
+This is a demo. The swap would:
+\u2022 Sell ${amount} ${fromUpper}
+\u2022 Buy ~${estimatedOutput.toFixed(6)} ${toUpper}
+\u2022 Gas: ~$0.01 on Base`
+          }]
+        };
+      }
+      return {
+        content: [{ type: "text", text: quoteResult }],
+        structuredContent: {
+          from: fromUpper,
+          to: toUpper,
+          sellAmount: amount,
+          buyAmount: estimatedOutput,
+          slippage,
+          execute: false
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `Swap error: ${errorMessage}` }],
+        isError: true
+      };
+    }
+  }
+);
 server.registerResource(
   "wallet",
   "blockrun://wallet",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/mcp",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "mcpName": "io.github.BlockRunAI/blockrun-mcp",
   "description": "BlockRun MCP Server - Access 30+ AI models via x402 micropayments. No API keys needed.",
   "type": "module",
@@ -44,7 +44,7 @@
     "url": "https://github.com/blockrunai/blockrun-mcp/issues"
   },
   "dependencies": {
-    "@blockrun/llm": "^0.2.0",
+    "@blockrun/llm": "^1.4.3",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "jimp": "^1.6.0",
     "open": "^11.0.0",