@blockrun/mcp 0.13.0 → 0.14.1

package/README.md

@@ -66,6 +66,14 @@ Prompts and a worked example for these are in [`skills/image-prompting/SKILL.md`
 
 ---
 
+## Prerequisites
+
+- **Node.js ≥ 18** (`node -v`)
+- **~$5 USDC** on Base or Solana (the server auto-creates a wallet on first run; see [Fund your wallet](#fund-your-wallet))
+- **An MCP client**: Claude Code, Claude Desktop, Cursor, Windsurf, or ChatGPT Desktop
+
+---
+
 ## Install
 
 **Claude Code (recommended)**
@@ -93,6 +101,23 @@ ensures `-y` is passed to `npx`, not parsed by `claude mcp add`.
 claude mcp add blockrun -s user --transport http https://mcp.blockrun.ai/mcp
 ```
 
+**Cursor** — add to `~/.cursor/mcp.json` (macOS / Linux) or `%APPDATA%\Cursor\mcp.json` (Windows):
+```json
+{
+  "mcpServers": {
+    "blockrun": {
+      "command": "npx",
+      "args": ["-y", "@blockrun/mcp@latest"]
+    }
+  }
+}
+```
+
+**Windsurf** — same JSON, in:
+- macOS: `~/.codeium/windsurf/mcp_config.json`
+- Linux: `~/.config/.codeium/windsurf/mcp_config.json`
+- Windows: `%APPDATA%\Codeium\windsurf\mcp_config.json`
+
 ---
 
 ## Fund your wallet
@@ -118,7 +143,7 @@ $5 covers ~5,000 market queries, ~500 Exa searches, ~250 image generations, or ~
 | `blockrun_music` | MiniMax music generation | per track |
 | `blockrun_price` | Pyth-backed realtime + OHLC — crypto / FX / commodity (free), 12 stock markets (paid) | free or $0.001/call |
 | `blockrun_markets` | Polymarket (markets, candles, trades, orderbooks, leaderboards, smart-wallet PnL/clusters, UMA oracle), Kalshi, Limitless, Opinion, Predict.Fun, dFlow, Binance Futures, cross-platform match + search | $0.001–0.005/query |
-| `blockrun_x` | X/Twitter — profiles, tweets, followers, mentions, search (AttentionVC) | per call |
+| `blockrun_surf` | Surf (asksurf.ai) — 84 endpoints: CEX market data, on-chain SQL (13 chains, 80+ ClickHouse tables), 100M+ labeled wallets, Polymarket + Kalshi side-by-side, social mindshare, news, search, Surf-1.5 chat with citations | $0.001–0.02/call |
 | `blockrun_exa` | Neural web search (Exa) — research, competitors, papers, URL content | $0.01/query |
 | `blockrun_search` | Grok Live Search — web + news with citations | ~$0.025 per source |
 | `blockrun_dex` | Live DEX prices via DexScreener | free |
@@ -127,28 +152,127 @@ $5 covers ~5,000 market queries, ~500 Exa searches, ~250 image generations, or ~
 
 ---
 
+## Tips for effective LLMs
+
+> **For LLMs and agents invoking BlockRun MCP tools:**
+
+- **CRITICAL: When any `blockrun_*` tool returns a payment / balance / 402 error, call `blockrun_wallet` *first* to check status, then `action:"setup"` to get funding instructions.** Don't retry the failing tool blindly — the wallet is empty.
+- **CRITICAL: For `blockrun_markets` and `blockrun_surf`, the 80+ endpoint catalog lives in `skills/markets/SKILL.md` and `skills/surf/SKILL.md`, NOT in the tool description.** Browse the skill before guessing endpoint paths.
+- **CRITICAL: `blockrun_chat routing:"smart"` (ClawRouter) only works on Base wallets.** On Solana, pass `mode:` or `model:` to pick a model directly.
+- **CRITICAL: `blockrun_music` and `blockrun_video` are payment-on-completion async.** Failures or client-side timeouts do NOT charge. Don't retry-loop them — they may take 60–180s.
+- **CRITICAL: Before spawning child agents, allocate per-agent budget:** `blockrun_wallet action:"delegate" agent_id:"X" agent_limit:1.00`. Pass `agent_id:"X"` to every downstream `blockrun_*` call — the child is auto-blocked when the budget hits zero.
+- **Free tier first for drafts**: `blockrun_chat mode:"free"` (NVIDIA), `blockrun_dex`, `blockrun_price` (crypto / FX / commodity), and `blockrun_models` are all $0. Use them to scaffold before paying for premium models.
+
+---
+
+## Key Use Cases
+
+What kinds of questions can Claude (or any LLM agent) answer once BlockRun MCP is installed:
+
+1. **Price reads / market data**
+   > *"What's BTC trading at? Compare with last week's average."* → `blockrun_price` (free) or `blockrun_surf` path:`market/price`
+
+2. **Prediction-market consensus**
+   > *"What's Polymarket's odds for the next Fed rate decision?"* → `blockrun_markets` path:`polymarket/events` + filter
+
+3. **On-chain forensics**
+   > *"This wallet (0xabc...) — what's it labeled as? What does it hold? When did it whale up?"* → `blockrun_surf` paths:`wallet/labels/batch`, `wallet/detail`, `wallet/net-worth`
+
+4. **Cited research with sources**
+   > *"Find the 5 most-cited papers on speculative decoding from the last 90 days. Summarize the dominant approach."* → `blockrun_exa` action:`search` then `contents`
+
+5. **Image generation with on-image text**
+   > *"Generate a poster announcing GPT-5.5 on BlockRun, retro-futuristic, with the headline 'NOW LIVE'."* → `blockrun_image` + the `image-prompting` skill 5-section framework
+
+6. **Voice phone-out**
+   > *"Call +1-415-555-... and confirm the appointment on Friday at 3pm."* → `blockrun_phone` path:`voice/call`, body: `{ to, task, from }` (provision `from` first via `phone/numbers/buy`), then poll `voice/call/{call_id}`
+
+7. **Multi-agent research with budget cap**
+   > *"Spawn 3 research agents on competing L1 narratives. Cap each at $0.50."* → `blockrun_wallet delegate × 3` → children call `blockrun_chat` + `blockrun_exa` with their `agent_id`
+
+8. **Cross-chain SQL forensics**
+   > *"Top 10 tokens by DEX volume on Base in the last 24h."* → `blockrun_surf` path:`onchain/sql`, body: `{ sql: "SELECT..." }`
+
+---
+
 ## Why not just use the APIs directly?
 
 | | Direct APIs | BlockRun |
 |---|---|---|
 | Exa | Sign up, $20/mo minimum | $0.01/call, no subscription |
 | Polymarket | Undocumented, rate-limited | $0.001/call, clean JSON |
-| Twitter/X API | $100–$5000/month | $0.03/page, no approval |
-| Multiple sources | 4 accounts, 4 API keys, 4 billing pages | 1 wallet |
+| Surf (asksurf.ai) | Account + monthly plan | $0.001/call, no Surf account, 84 endpoints |
+| Multiple sources | 3 accounts, 3 API keys, 3 billing pages | 1 wallet |
 
 One wallet. All sources. No dashboards.
 
 ---
 
+## When NOT to use BlockRun MCP
+
+BlockRun shines when you want **unified billing + many sources + LLM-readable errors**. It is not the right fit for:
+
+- **High-volume single-API workloads (≥10k calls/day to one source).** Direct subscriptions amortize better past the break-even point — Polymarket's free public API plus your own caching beats $0.001 × 10k/day if you don't need cross-source aggregation.
+- **Compliance-sensitive flows that need a fiat invoice / audit trail.** BlockRun settles in USDC; receipts are on-chain (Basescan / Solscan) but are not tax invoices. For enterprise procurement, contract directly with the upstream provider.
+- **Latency-critical sub-100ms reads.** Each x402 call adds ~200–500ms of payment-signing + settlement overhead vs. a direct authenticated request. For HFT-style flows, run your own infra.
+- **You only need one source forever.** If you'll only ever call Polymarket, or only ever Exa, save the indirection — sign up upstream and skip the wallet.
+
+Use BlockRun when you want pay-per-call for *exploration*, *aggregation*, or *agent-driven* workloads where you can't predict which source you'll reach for next.
+
+---
+
 ## Multi-agent budget delegation
 
 Delegate a spending budget to a child agent with `agent_id`. The child is auto-blocked when the budget runs out — useful for autonomous agents that shouldn't run up unbounded costs.
 
 ---
 
+## Troubleshooting
+
+- **`Insufficient balance` / HTTP 402 after retry** → Run `blockrun_wallet action:"setup"`. Send USDC on Base (or Solana — see [Environment Variables](#environment-variables)).
+- **`Smart routing (ClawRouter) is not available on Solana`** → Pass `model:` or `mode:` explicitly to `blockrun_chat`, or switch back to Base by unsetting `SOLANA_WALLET_KEY` and removing `~/.blockrun/.solana-session`.
+- **`claude mcp list` doesn't show `blockrun`** → Check `node -v` (must be ≥18). Clear the npx cache: `rm -rf ~/.npm/_npx`. Re-run the install command from above.
+- **`fetch failed` / timeout when checking wallet balance** → Base RPC transient outage. The tool already falls through 3 public RPCs; retry after 30s. Persistent failures usually = local proxy / firewall blocking outbound RPC.
+- **`ENOENT: ~/.blockrun/.session`** → Expected on first run. The server auto-creates the wallet; check stderr for the `WALLET_CREATED` line confirming the address.
+- **`Video generation timed out` (5-min cap)** → Upstream Seedance / xAI queue congestion. **No charge** (payment-on-completion). Retry, or pick a faster model (`bytedance/seedance-1.5-pro`).
+- **`Music generation timed out` (200s cap)** → Same pattern. **No charge**. Retry; if it persists, the upstream model is rate-limited — try off-peak.
+
+---
+
+## Environment Variables
+
+| Variable / File | Default | Effect |
+|---|---|---|
+| `~/.blockrun/.session` | auto-created on first run | EVM private key (0x...). File exists → use Base. |
+| `~/.blockrun/.solana-session` | not created | Solana private key. File exists → switch to Solana. |
+| `SOLANA_WALLET_KEY` | unset | Env-var override of `.solana-session`. Set → use Solana. |
+
+Chain selection priority (see `src/utils/wallet.ts:24`):
+
+1. `SOLANA_WALLET_KEY` env var present → Solana
+2. `~/.blockrun/.solana-session` exists → Solana
+3. Otherwise → Base (`~/.blockrun/.session` auto-created)
+
+**Switching chains:**
+
+- Base → Solana: `export SOLANA_WALLET_KEY=...`, or `echo "<secret>" > ~/.blockrun/.solana-session`
+- Solana → Base: `unset SOLANA_WALLET_KEY && rm ~/.blockrun/.solana-session` (the existing `.session` is reused, so it's the same Base wallet)
+
+The server also runs a non-blocking npm registry check at startup and prints an `Update available` notice to stderr when a newer `@blockrun/mcp` version exists. Upgrade by re-running the install command — no manual `npm update` needed.
+
+---
+
 ## How it works
 
-Pay-per-call via [x402](https://x402.org) micropayments in USDC on Base. Your wallet lives at `~/.blockrun/.session`. Private key never leaves your machine.
+Pay-per-call via [x402](https://x402.org) micropayments in USDC. Your wallet lives at `~/.blockrun/.session` (Base) or `~/.blockrun/.solana-session` (Solana). The private key never leaves your machine.
+
+---
+
+## Contributing
+
+PRs welcome. See [CONTRIBUTING.md](./CONTRIBUTING.md) for setup, the tool-vs-skill design rule, and how to add a new partner API.
+
+Issues: [github.com/blockrunai/blockrun-mcp/issues](https://github.com/blockrunai/blockrun-mcp/issues)
 
 ---
 

package/dist/index.js

@@ -6,38 +6,78 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/utils/wallet.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
 import {
   LLMClient,
   ImageClient,
   PriceClient,
+  SolanaLLMClient,
   getOrCreateWallet,
+  loadSolanaWallet,
   getPaymentLinks,
   formatWalletCreatedMessage,
-  formatNeedsFundingMessage
+  formatNeedsFundingMessage,
+  SOLANA_WALLET_FILE_PATH
 } from "@blockrun/llm";
-var _client = null;
+var BLOCKRUN_DIR = path.join(os.homedir(), ".blockrun");
+var CHAIN_PREFERENCE_FILES = [
+  path.join(BLOCKRUN_DIR, ".chain"),
+  path.join(BLOCKRUN_DIR, "payment-chain")
+];
+var _evmClient = null;
 var _imageClient = null;
 var _priceClient = null;
-var _walletInfo = null;
-function ensureWallet() {
-  if (!_walletInfo) {
-    _walletInfo = getOrCreateWallet();
-    if (_walletInfo.isNew) {
-      console.error(formatWalletCreatedMessage(_walletInfo.address));
+var _evmWalletInfo = null;
+var _solanaClient = null;
+function readChainPreference() {
+  for (const file of CHAIN_PREFERENCE_FILES) {
+    try {
+      if (!fs.existsSync(file)) continue;
+      const value = fs.readFileSync(file, "utf-8").trim().toLowerCase();
+      if (value === "base" || value === "solana") return value;
+    } catch {
     }
   }
-  return _walletInfo;
+  return null;
+}
+function getChain() {
+  const preferred = readChainPreference();
+  if (preferred) return preferred;
+  if (process.env.SOLANA_WALLET_KEY) return "solana";
+  try {
+    if (fs.existsSync(SOLANA_WALLET_FILE_PATH)) return "solana";
+  } catch {
+  }
+  return "base";
+}
+function ensureEvmWallet() {
+  if (!_evmWalletInfo) {
+    _evmWalletInfo = getOrCreateWallet();
+    if (_evmWalletInfo.isNew) {
+      console.error(formatWalletCreatedMessage(_evmWalletInfo.address));
+    }
+  }
+  return _evmWalletInfo;
 }
 function getOrCreateWalletKey() {
-  const info = ensureWallet();
+  const info = ensureEvmWallet();
   return info.privateKey;
 }
 function getClient() {
-  if (!_client) {
+  if (getChain() === "solana") {
+    if (!_solanaClient) {
+      const privateKey = process.env.SOLANA_WALLET_KEY || loadSolanaWallet() || void 0;
+      _solanaClient = new SolanaLLMClient(privateKey ? { privateKey } : void 0);
+    }
+    return _solanaClient;
+  }
+  if (!_evmClient) {
     const privateKey = getOrCreateWalletKey();
-    _client = new LLMClient({ privateKey });
+    _evmClient = new LLMClient({ privateKey });
   }
-  return _client;
+  return _evmClient;
 }
 function getImageClient() {
   if (!_imageClient) {
@@ -53,8 +93,21 @@ function getPriceClient() {
   }
   return _priceClient;
 }
-function getWalletInfo() {
-  const info = ensureWallet();
+async function getWalletInfo() {
+  if (getChain() === "solana") {
+    const client = getClient();
+    const address = await client.getWalletAddress();
+    return {
+      address,
+      network: "Solana",
+      chainId: null,
+      currency: "USDC",
+      isNew: false,
+      explorerUrl: `https://solscan.io/account/${address}`,
+      fundingUrl: "https://sol.blockrun.ai"
+    };
+  }
+  const info = ensureEvmWallet();
   const links = getPaymentLinks(info.address);
   return {
     address: info.address,
@@ -62,11 +115,19 @@ function getWalletInfo() {
     chainId: 8453,
     currency: "USDC",
     isNew: info.isNew,
-    basescanUrl: links.basescan,
+    explorerUrl: links.basescan,
     fundingUrl: links.blockrun
   };
 }
 async function getUsdcBalance(address) {
+  if (getChain() === "solana") {
+    try {
+      const client = getClient();
+      return await client.getBalance();
+    } catch {
+      return null;
+    }
+  }
   const USDC_ADDRESS2 = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
   const BASE_RPC_URLS = [
     "https://mainnet.base.org",
@@ -101,14 +162,15 @@ import { z } from "zod";
 // src/utils/qr.ts
 import QRCode from "qrcode";
 import open from "open";
-import * as fs from "fs";
+import * as fs2 from "fs";
+import sharp from "sharp";
 
 // src/utils/constants.ts
-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 QR_FILE = path.join(WALLET_DIR, "qr.png");
+import * as path2 from "path";
+import * as os2 from "os";
+var WALLET_DIR = path2.join(os2.homedir(), ".blockrun");
+var WALLET_FILE = path2.join(WALLET_DIR, ".session");
+var QR_FILE = path2.join(WALLET_DIR, "qr.png");
 var USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
 var BASE_CHAIN_ID = "8453";
 var MODEL_TIERS = {
@@ -123,22 +185,53 @@ var MODEL_TIERS = {
 };
 
 // src/utils/qr.ts
+var SOLANA_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
 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);
-  if (!fs.existsSync(WALLET_DIR)) {
-    fs.mkdirSync(WALLET_DIR, { recursive: true, mode: 448 });
+function getSolanaPayUri(address, amountUsdc = 1) {
+  return `solana:${address}?spl-token=${SOLANA_USDC_MINT}&amount=${amountUsdc}&label=BlockRun`;
+}
+function buildSolanaLogoSvg(size) {
+  const half = size / 2;
+  return `<svg width="${size}" height="${size}" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="g" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#9945FF"/>
+      <stop offset="100%" style="stop-color:#14F195"/>
+    </linearGradient>
+    <clipPath id="c"><circle cx="${half}" cy="${half}" r="${half}"/></clipPath>
+  </defs>
+  <circle cx="${half}" cy="${half}" r="${half}" fill="url(#g)" clip-path="url(#c)"/>
+  <text x="${half}" y="${half + 14}" font-size="40" font-weight="bold" fill="white"
+    font-family="Arial,sans-serif" text-anchor="middle">\u25CE</text>
+</svg>`;
+}
+async function overlayLogo(qrBuf, chain, qrSize) {
+  if (chain !== "solana") return qrBuf;
+  const logoSize = Math.round(qrSize * 0.18);
+  const pad = Math.round(logoSize * 0.08);
+  const logoBuf = await sharp(Buffer.from(buildSolanaLogoSvg(logoSize))).resize(logoSize, logoSize).extend({ top: pad, bottom: pad, left: pad, right: pad, background: { r: 255, g: 255, b: 255, alpha: 1 } }).toBuffer();
+  const totalSize = logoSize + pad * 2;
+  const offset = Math.round((qrSize - totalSize) / 2);
+  return sharp(qrBuf).composite([{ input: logoBuf, left: offset, top: offset }]).toBuffer();
+}
+async function generateQrPng(address, chain = "base") {
+  const uri = chain === "solana" ? getSolanaPayUri(address) : getEip681Uri(address);
+  const qrSize = 400;
+  if (!fs2.existsSync(WALLET_DIR)) {
+    fs2.mkdirSync(WALLET_DIR, { recursive: true, mode: 448 });
   }
-  await QRCode.toFile(QR_FILE, eip681Uri, {
+  const qrBuf = await QRCode.toBuffer(uri, {
     type: "png",
-    width: 400,
+    width: qrSize,
     margin: 2,
     errorCorrectionLevel: "H",
     color: { dark: "#000000", light: "#FFFFFF" }
   });
+  const finalBuf = await overlayLogo(qrBuf, chain, qrSize);
+  fs2.writeFileSync(QR_FILE, finalBuf);
   return QR_FILE;
 }
 async function openQrInViewer(qrPath) {
@@ -149,6 +242,32 @@ async function openQrInViewer(qrPath) {
 }
 
 // src/utils/errors.ts
+function extractErrorMessage(err) {
+  if (!err || typeof err !== "object") return String(err);
+  const e = err;
+  const base = typeof e.message === "string" ? e.message : String(err);
+  if (e.response === void 0 || e.response === null) return base;
+  try {
+    const body = e.response;
+    if (typeof body === "string") return body.trim() ? `${base} \u2014 ${body}` : base;
+    if (typeof body === "object") {
+      const b = body;
+      const parts = [];
+      if (typeof b.message === "string") parts.push(b.message);
+      if (typeof b.hint === "string") parts.push(`Hint: ${b.hint}`);
+      if (Array.isArray(b.missing_params) && b.missing_params.length) {
+        parts.push(`Missing: ${b.missing_params.join(", ")}`);
+      }
+      if (parts.length === 0) {
+        parts.push(JSON.stringify(b));
+      }
+      return `${base}
+${parts.join("\n")}`;
+    }
+  } catch {
+  }
+  return base;
+}
 function formatError(message) {
   const msgLower = message.toLowerCase();
   const isPaymentError = msgLower.includes("402") || msgLower.includes("balance") || msgLower.includes("insufficient") || msgLower.includes("payment") && !msgLower.includes("500");
@@ -157,15 +276,17 @@ function formatError(message) {
   if (isServerError) {
     errorText += `
 
-This is a temporary API issue. The xAI/Grok API may be experiencing problems.
+This is a temporary API issue. The API may be experiencing problems.
 Try again in a few minutes, or use a different model (e.g., openai/gpt-4o).`;
   } else if (isPaymentError) {
+    const chain = getChain();
+    const network = chain === "solana" ? "Solana" : "Base";
     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.`;
+Quick fix: Send USDC to your wallet on ${network} network.`;
   }
   return errorText;
 }
@@ -210,8 +331,9 @@ Do NOT call this for actual AI queries \u2014 use blockrun_chat for that.`,
       }
     },
     async ({ action, budget_action, budget_amount, agent_id, agent_limit }) => {
-      const info = getWalletInfo();
+      const info = await getWalletInfo();
       const address = info.address;
+      const chain = getChain();
       if (action === "budget") {
         const budgetAct = budget_action || "check";
         if (budgetAct === "set") {
@@ -289,10 +411,11 @@ Pass agent_id: "${agent_id}" in any blockrun_* tool call to track and enforce th
       }
       if (action === "qr") {
         try {
-          const qrPath = await generateQrPng(address);
+          const qrPath = await generateQrPng(address, chain);
           await openQrInViewer(qrPath);
+          const scanNote = chain === "solana" ? "Scan with a Solana wallet (Phantom, Solflare) to send USDC on Solana." : "Scan with MetaMask to send USDC on Base.";
           return {
-            content: [{ type: "text", text: `QR code opened! Scan with MetaMask to send USDC on Base.
+            content: [{ type: "text", text: `QR code opened! ${scanNote}
 
 Address: ${address}
 QR saved: ${qrPath}` }]
@@ -307,14 +430,46 @@ QR saved: ${qrPath}` }]
       if (action === "setup") {
         let qrMessage = "";
         try {
-          const qrPath = await generateQrPng(address);
+          const qrPath = await generateQrPng(address, chain);
           await openQrInViewer(qrPath);
           qrMessage = `
 QR code opened for scanning! (${qrPath})`;
         } catch {
           qrMessage = "\n(QR generation failed - use address above)";
         }
-        const text2 = `
+        const text2 = chain === "solana" ? `
+================================================================================
+                        BLOCKRUN WALLET SETUP (SOLANA)
+================================================================================
+
+Your Solana 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 \u2192 Select USDC
+  3. Choose "Solana" network (important!)
+  4. Paste: ${address}
+  5. Send $1-5 to start
+
+Option 2: Transfer from any Solana wallet (Phantom, Solflare, Backpack)
+  - Send USDC (SPL) to: ${address}
+  - Make sure to use Solana network, not EVM
+
+Option 3: Bridge from other chains
+  https://portalbridge.com \u2192 Bridge USDC to Solana \u2192 Send to address above
+
+VERIFY BALANCE: https://solscan.io/account/${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/.solana-session (never leaves your machine)
+================================================================================` : `
 ================================================================================
                         BLOCKRUN WALLET SETUP
 ================================================================================
@@ -351,9 +506,10 @@ SECURITY: Private key stored at ~/.blockrun/.session (never leaves your machine)
       const balance = await getUsdcBalance(address);
       const balanceStr = balance !== null ? `$${balance.toFixed(6)} USDC` : "Unable to fetch";
       const lowBalance = balance !== null && balance < 1;
+      const explorerLabel = chain === "solana" ? "Solscan" : "Basescan";
       const text = `Wallet: ${address}
 Balance: ${balanceStr}${lowBalance ? " (low - add funds)" : ""}
-Network: Base | View: ${info.basescanUrl}
+Network: ${info.network} | View: ${info.explorerUrl}
 ${info.isNew ? "\nNEW WALLET - Run with action: 'setup' for funding instructions" : ""}`;
       return {
         content: [{ type: "text", text }],
@@ -363,7 +519,8 @@ ${info.isNew ? "\nNEW WALLET - Run with action: 'setup' for funding instructions
           network: info.network,
           chainId: info.chainId,
           isNew: info.isNew,
-          basescanUrl: info.basescanUrl
+          explorerUrl: info.explorerUrl,
+          explorerLabel
         }
       };
     }
@@ -372,6 +529,7 @@ ${info.isNew ? "\nNEW WALLET - Run with action: 'setup' for funding instructions
 
 // src/tools/chat.ts
 import { z as z2 } from "zod";
+import { LLMClient as LLMClient2 } from "@blockrun/llm";
 
 // src/utils/budget.ts
 function checkBudget(budget, agentId) {
@@ -448,6 +606,12 @@ Run blockrun_models to see all 41+ models with pricing.`,
         };
       }
       if (routing === "smart") {
+        if (!(llm instanceof LLMClient2)) {
+          return {
+            content: [{ type: "text", text: "Smart routing (ClawRouter) is not available on Solana. Use a specific model or mode instead." }],
+            isError: true
+          };
+        }
         try {
           const result = await llm.smartChat(message, {
             system,
@@ -1006,39 +1170,31 @@ function registerSearchTool(server) {
   server.registerTool(
     "blockrun_search",
     {
-      description: `Real-time web, X/Twitter, and news search with AI-summarized results and citations.
+      description: `Grok Live Search \u2014 real-time web + X/Twitter + news with AI-summarized results and citations. ~$0.025 per source.
+
+Common shape:
+- body: { query: "...", sources: ["web","x","news"], maxResults: 10, fromDate: "YYYY-MM-DD", toDate: "YYYY-MM-DD" }
 
-Sources: web, x (X/Twitter), news \u2014 defaults to all three.
-Pricing: ~$0.01/search
+\`sources\` accepts any subset of ["web","x","news"] (defaults to all three). For tweet-only searches, use ["x"].
 
-Returns a summary with cited sources.`,
+Full request shape + worked examples in the \`search\` skill (\`skills/search/SKILL.md\`).`,
       inputSchema: {
-        query: z7.string().describe("Search query"),
-        sources: z7.array(z7.enum(["web", "x", "news"])).optional().describe("Sources to search (default: web + x + news)"),
-        max_results: z7.number().optional().default(10).describe("Max results per source (1-20)"),
-        from_date: z7.string().optional().describe("Start date filter (YYYY-MM-DD)"),
-        to_date: z7.string().optional().describe("End date filter (YYYY-MM-DD)")
+        path: z7.string().optional().default("").describe("Endpoint sub-path under /v1/search/ (default empty = root /v1/search). Reserved for future surfaces."),
+        body: z7.any().optional().describe("Request body. At minimum { query: '...' }. Sent as POST.")
       }
     },
-    async ({ query, sources, max_results, from_date, to_date }) => {
+    async ({ path: path4, body }) => {
       try {
-        const llm = getClient();
-        const result = await llm.search(query, {
-          sources,
-          maxResults: max_results,
-          fromDate: from_date,
-          toDate: to_date
-        });
+        const client = getClient();
+        const cleanPath = (path4 ?? "").replace(/^\/+/, "").replace(/^v1\/search\/?/, "");
+        const endpoint = cleanPath ? `/v1/search/${cleanPath}` : "/v1/search";
+        const result = await client.requestWithPaymentRaw(endpoint, body ?? {});
         return {
           content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
           structuredContent: result
         };
       } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: formatError(errMsg) }],
-          isError: true
-        };
+        return { content: [{ type: "text", text: formatError(extractErrorMessage(err)) }], isError: true };
       }
     }
   );
@@ -1050,68 +1206,34 @@ function registerExaTool(server) {
   server.registerTool(
     "blockrun_exa",
     {
-      description: `Neural web search via Exa. Understands meaning, not just keywords. Great for research.
+      description: `Neural web search via Exa \u2014 understands meaning, not just keywords. Great for research.
 
-Actions:
-- search: Find semantically relevant URLs and metadata ($0.01/call)
-- answer: Get a cited, hallucination-free answer grounded in real web sources ($0.01/call)
-- contents: Fetch full Markdown text from URLs, ready for LLM context ($0.002/URL)
-- similar: Find pages semantically similar to a given URL ($0.01/call)`,
+Common paths (all POST, body shapes documented in the exa-research skill):
+- search       \u2014 body: { query, numResults?, category?, includeDomains?, excludeDomains? }   ($0.01/call)
+- answer       \u2014 body: { query }                                                              ($0.01/call)
+- contents     \u2014 body: { urls: [...] }                                                        ($0.002/URL, up to 100)
+- find-similar \u2014 body: { url, numResults? }                                                   ($0.01/call)
+
+Categories for search: "news", "research paper", "company", "tweet", "github", "pdf".
+
+Full request/response shapes + worked research workflows in the \`exa-research\` skill.`,
       inputSchema: {
-        action: z8.enum(["search", "answer", "contents", "similar"]).describe("Action to perform"),
-        query: z8.string().optional().describe("Natural language query (for search/answer)"),
-        url: z8.string().optional().describe("Reference URL to find similar pages (for similar action)"),
-        urls: z8.array(z8.string()).optional().describe("URLs to fetch content from (for contents action, up to 100)"),
-        num_results: z8.number().optional().describe("Number of results to return (default: 10)"),
-        category: z8.string().optional().describe("Category filter: 'news', 'research paper', 'company', 'tweet', 'github', 'pdf'"),
-        include_domains: z8.array(z8.string()).optional().describe("Only search within these domains"),
-        exclude_domains: z8.array(z8.string()).optional().describe("Exclude these domains from results")
+        path: z8.string().describe("Endpoint name under /v1/exa/, e.g. 'search', 'answer', 'contents', 'find-similar'"),
+        body: z8.any().optional().describe("JSON body for the call. Sent as POST. Required for all four endpoints.")
       }
     },
-    async ({ action, query, url, urls, num_results, category, include_domains, exclude_domains }) => {
+    async ({ path: path4, body }) => {
       try {
-        const llm = getClient();
-        let result;
-        const req = llm;
-        switch (action) {
-          case "search":
-            if (!query) throw new Error("query required for search action");
-            result = await req.requestWithPaymentRaw("/v1/exa/search", {
-              query,
-              numResults: num_results,
-              category,
-              includeDomains: include_domains,
-              excludeDomains: exclude_domains
-            });
-            break;
-          case "answer":
-            if (!query) throw new Error("query required for answer action");
-            result = await req.requestWithPaymentRaw("/v1/exa/answer", { query });
-            break;
-          case "contents":
-            if (!urls?.length) throw new Error("urls array required for contents action");
-            result = await req.requestWithPaymentRaw("/v1/exa/contents", { urls });
-            break;
-          case "similar":
-            if (!url) throw new Error("url required for similar action");
-            result = await req.requestWithPaymentRaw("/v1/exa/find-similar", {
-              url,
-              numResults: num_results
-            });
-            break;
-          default:
-            throw new Error(`Unknown action: ${action}`);
-        }
+        const client = getClient();
+        const cleanPath = path4.replace(/^\/+/, "").replace(/^v1\/exa\//, "");
+        const endpoint = `/v1/exa/${cleanPath}`;
+        const result = await client.requestWithPaymentRaw(endpoint, body ?? {});
         return {
           content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
           structuredContent: result
         };
       } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: formatError(errMsg) }],
-          isError: true
-        };
+        return { content: [{ type: "text", text: formatError(extractErrorMessage(err)) }], isError: true };
       }
     }
   );
@@ -1180,10 +1302,10 @@ Pass query params via 'params' (GET). Use 'body' only for POST endpoints (e.g. p
         body: z9.any().optional().describe("JSON body for POST queries (triggers pmQuery \u2014 most endpoints are GET)")
       }
     },
-    async ({ path: path3, params, body }) => {
+    async ({ path: path4, params, body }) => {
       try {
         const llm = getClient();
-        const result = body ? await llm.pmQuery(path3, body) : await llm.pm(path3, params);
+        const result = body ? await llm.pmQuery(path4, body) : await llm.pm(path4, params);
         return {
           content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
           structuredContent: result
@@ -1302,132 +1424,8 @@ Examples:
   );
 }
 
-// src/tools/twitter.ts
-import { z as z11 } from "zod";
-var ACTION2 = z11.enum([
-  "user_lookup",
-  "user_info",
-  "followers",
-  "followings",
-  "verified_followers",
-  "user_tweets",
-  "user_mentions",
-  "tweet_lookup",
-  "tweet_replies",
-  "tweet_thread",
-  "search"
-]);
-function registerTwitterTool(server) {
-  server.registerTool(
-    "blockrun_x",
-    {
-      description: `Structured X/Twitter data via AttentionVC partner API.
-
-Actions:
-- user_lookup (usernames: string | string[])
-- user_info (username)
-- followers (username, cursor?)
-- followings (username, cursor?)
-- verified_followers (user_id, cursor?)
-- user_tweets (username, includeReplies?, cursor?)
-- user_mentions (username, sinceTime?, untilTime?, cursor?)
-- tweet_lookup (tweet_ids: string | string[])
-- tweet_replies (tweet_id, cursor?, queryType?)
-- tweet_thread (tweet_id, cursor?)
-- search (query, queryType?, cursor?)
-
-Paid per request via x402; prices scale with the endpoint (e.g. user_lookup ~ $0.02, followers ~ $0.05/page).`,
-      inputSchema: {
-        action: ACTION2,
-        usernames: z11.union([z11.string(), z11.array(z11.string())]).optional(),
-        username: z11.string().optional(),
-        user_id: z11.string().optional(),
-        tweet_id: z11.string().optional(),
-        tweet_ids: z11.union([z11.string(), z11.array(z11.string())]).optional(),
-        query: z11.string().optional(),
-        queryType: z11.enum(["Latest", "Top", "Default"]).optional(),
-        cursor: z11.string().optional(),
-        sinceTime: z11.string().optional(),
-        untilTime: z11.string().optional(),
-        includeReplies: z11.boolean().optional()
-      }
-    },
-    async (args) => {
-      try {
-        const llm = getClient();
-        const a = args.action;
-        const require2 = (value, name) => {
-          if (value === void 0 || value === null || value === "") {
-            throw new Error(`${name} is required for action='${a}'`);
-          }
-          return value;
-        };
-        let result;
-        switch (a) {
-          case "user_lookup":
-            result = await llm.xUserLookup(require2(args.usernames, "usernames"));
-            break;
-          case "user_info":
-            result = await llm.xUserInfo(require2(args.username, "username"));
-            break;
-          case "followers":
-            result = await llm.xFollowers(require2(args.username, "username"), args.cursor);
-            break;
-          case "followings":
-            result = await llm.xFollowings(require2(args.username, "username"), args.cursor);
-            break;
-          case "verified_followers":
-            result = await llm.xVerifiedFollowers(require2(args.user_id, "user_id"), args.cursor);
-            break;
-          case "user_tweets":
-            result = await llm.xUserTweets(
-              require2(args.username, "username"),
-              args.includeReplies,
-              args.cursor
-            );
-            break;
-          case "user_mentions":
-            result = await llm.xUserMentions(
-              require2(args.username, "username"),
-              args.sinceTime,
-              args.untilTime,
-              args.cursor
-            );
-            break;
-          case "tweet_lookup":
-            result = await llm.xTweetLookup(require2(args.tweet_ids, "tweet_ids"));
-            break;
-          case "tweet_replies":
-            result = await llm.xTweetReplies(
-              require2(args.tweet_id, "tweet_id"),
-              args.queryType,
-              args.cursor
-            );
-            break;
-          case "tweet_thread":
-            result = await llm.xTweetThread(require2(args.tweet_id, "tweet_id"), args.cursor);
-            break;
-          case "search":
-            result = await llm.xSearch(require2(args.query, "query"), args.queryType, args.cursor);
-            break;
-        }
-        return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-          structuredContent: result
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text", text: formatError(msg) }],
-          isError: true
-        };
-      }
-    }
-  );
-}
-
 // src/tools/dex.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 function registerDexTool(server) {
   server.registerTool(
     "blockrun_dex",
@@ -1444,10 +1442,10 @@ Examples:
   blockrun_dex({ token: "So11...xxx" })    -> Get specific token data
   blockrun_dex({ symbol: "PEPE" })         -> Search by symbol`,
       inputSchema: {
-        query: z12.string().optional().describe("Search query (token name, symbol, or address)"),
-        token: z12.string().optional().describe("Token address for direct lookup"),
-        symbol: z12.string().optional().describe("Token symbol to search"),
-        chain: z12.string().optional().describe("Filter by chain (ethereum, solana, base, etc.)")
+        query: z11.string().optional().describe("Search query (token name, symbol, or address)"),
+        token: z11.string().optional().describe("Token address for direct lookup"),
+        symbol: z11.string().optional().describe("Token symbol to search"),
+        chain: z11.string().optional().describe("Filter by chain (ethereum, solana, base, etc.)")
       }
     },
     async ({ query, token, symbol, chain }) => {
@@ -1508,85 +1506,135 @@ ${lines.join("\n\n")}` }],
 }
 
 // src/tools/modal.ts
-import { z as z13 } from "zod";
-var MODAL_GPU_TYPES = ["T4", "L4", "A10G", "A100", "A100-80GB", "H100"];
+import { z as z12 } from "zod";
 function registerModalTool(server) {
   server.registerTool(
     "blockrun_modal",
     {
-      description: `Run isolated code in a BlockRun-hosted Modal sandbox.
+      description: `Run isolated code in a BlockRun-hosted Modal sandbox \u2014 disposable remote container, optional GPU.
 
-Use this when you need:
-- a disposable remote container
-- GPU access
-- a clean environment that will not affect the local machine
-- a safer place to run untrusted or heavy code
+Use when you need: a clean ephemeral environment, GPU access (T4/L4/A10G/A100/A100-80GB/H100), or a safer place for untrusted code. Prefer local tools for normal repo work.
 
-Prefer local tools for normal repo work. Modal is best for isolation or remote execution.
+Common paths (all POST):
+- sandbox/create     \u2014 body: { image?, timeout?, cpu?, memory?, gpu?, setup_commands? }    ($0.01)
+- sandbox/exec       \u2014 body: { sandbox_id, command: ["python","-c","..."], timeout? }      ($0.001)
+- sandbox/status     \u2014 body: { sandbox_id }                                                ($0.001)
+- sandbox/terminate  \u2014 body: { sandbox_id }                                                ($0.001)
 
-Pricing:
-- create: $0.01
-- exec/status/terminate: $0.001 each`,
+Full action shapes + GPU type details in the \`modal\` skill.`,
       inputSchema: {
-        action: z13.enum(["create", "exec", "status", "terminate"]).describe(
-          "Sandbox action to perform"
-        ),
-        sandbox_id: z13.string().optional().describe("Sandbox ID returned by a previous create"),
-        command: z13.array(z13.string()).optional().describe('Command array for exec, for example ["python", "-c", "print(2+2)"]'),
-        image: z13.string().optional().describe("Container image for create (default: python:3.11)"),
-        timeout: z13.number().optional().describe("Timeout in seconds for create or exec"),
-        cpu: z13.number().optional().describe("CPU cores for create"),
-        memory: z13.number().optional().describe("Memory in MB for create"),
-        gpu: z13.enum(MODAL_GPU_TYPES).optional().describe("Optional GPU type for create"),
-        setup_commands: z13.array(z13.string()).optional().describe("Shell commands to run during sandbox setup")
+        path: z12.string().describe("Endpoint under /v1/modal/, e.g. 'sandbox/create', 'sandbox/exec'"),
+        body: z12.any().optional().describe("JSON body. Sent as POST.")
       }
     },
-    async ({ action, sandbox_id, command, image, timeout, cpu, memory, gpu, setup_commands }) => {
+    async ({ path: path4, body }) => {
       try {
-        const llm = getClient();
-        const req = llm;
-        let result;
-        switch (action) {
-          case "create":
-            result = await req.requestWithPaymentRaw("/v1/modal/sandbox/create", {
-              image,
-              timeout,
-              cpu,
-              memory,
-              gpu,
-              setup_commands
-            });
-            break;
-          case "exec":
-            if (!sandbox_id) throw new Error("sandbox_id required for exec action");
-            if (!command?.length) throw new Error("command array required for exec action");
-            result = await req.requestWithPaymentRaw("/v1/modal/sandbox/exec", {
-              sandbox_id,
-              command,
-              timeout
-            });
-            break;
-          case "status":
-            if (!sandbox_id) throw new Error("sandbox_id required for status action");
-            result = await req.requestWithPaymentRaw("/v1/modal/sandbox/status", { sandbox_id });
-            break;
-          case "terminate":
-            if (!sandbox_id) throw new Error("sandbox_id required for terminate action");
-            result = await req.requestWithPaymentRaw("/v1/modal/sandbox/terminate", {
-              sandbox_id
-            });
-            break;
-          default:
-            throw new Error(`Unknown action: ${String(action)}`);
-        }
+        const client = getClient();
+        const cleanPath = path4.replace(/^\/+/, "").replace(/^v1\/modal\//, "");
+        const endpoint = `/v1/modal/${cleanPath}`;
+        const result = await client.requestWithPaymentRaw(endpoint, body ?? {});
         return {
           content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
           structuredContent: result
         };
       } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: formatError(extractErrorMessage(err)) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/phone.ts
+import { z as z13 } from "zod";
+function registerPhoneTool(server) {
+  server.registerTool(
+    "blockrun_phone",
+    {
+      description: `Phone-number intelligence, US/CA number provisioning, and outbound AI voice calls.
+
+Common paths (path = everything after /v1/):
+- phone/lookup               POST body: { phoneNumber }                                          ($0.01)
+- phone/lookup/fraud         POST body: { phoneNumber } \u2014 SIM-swap + call-forwarding signals    ($0.05)
+- phone/numbers/buy          POST body: { country?: "US"|"CA", areaCode? } \u2014 30-day lease       ($5.00)
+- phone/numbers/renew        POST body: { phoneNumber } \u2014 extend 30 days                        ($5.00)
+- phone/numbers/list         POST body: {} \u2014 your wallet-owned numbers                          ($0.001)
+- phone/numbers/release      POST body: { phoneNumber } \u2014 release back to pool                  (free)
+- voice/call                 POST body: { to, task, from, voice?, max_duration?, ... }          ($0.54 flat)
+- voice/call/{call_id}       GET (no body) \u2014 poll status + transcript                           (free)
+
+REQUIRED for voice/call: \`from\` must be a number your wallet owns. Provision one with \`phone/numbers/buy\` first ($5, 30-day lease).
+
+Voice presets: nat, josh, maya, june, paige, derek, florian. Phone numbers use E.164: +14155550100.
+
+Voice call flow + voice preset details + full body shapes in the \`phone\` skill.`,
+      inputSchema: {
+        path: z13.string().describe("Endpoint after /v1/. Use 'phone/...' for lookup + number ops, 'voice/call' for outbound AI calls, 'voice/call/{id}' (no body) to poll status."),
+        body: z13.any().optional().describe("JSON body. Sent as POST. Omit for the free GET poll (voice/call/{call_id}).")
+      }
+    },
+    async ({ path: path4, body }) => {
+      try {
+        const client = getClient();
+        const cleanPath = path4.replace(/^\/+/, "").replace(/^v1\//, "");
+        const endpoint = `/v1/${cleanPath}`;
+        const result = body !== void 0 ? await client.requestWithPaymentRaw(endpoint, body) : await client.getWithPaymentRaw(endpoint);
         return {
-          content: [{ type: "text", text: formatError(errMsg) }],
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          structuredContent: result
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: formatError(extractErrorMessage(err)) }], isError: true };
+      }
+    }
+  );
+}
+
+// src/tools/surf.ts
+import { z as z14 } from "zod";
+function registerSurfTool(server) {
+  server.registerTool(
+    "blockrun_surf",
+    {
+      description: `Unified crypto data via Surf (asksurf.ai) \u2014 84 endpoints, one API.
+
+Coverage: CEX market data (16 exchanges), on-chain SQL across 13 chains, 100M+ labeled wallets, prediction markets (Polymarket + Kalshi), social mindshare / CT intelligence, news, unified search, and Surf-1.5 chat with citations.
+
+Pricing (settled in USDC to Surf's Base treasury):
+- Tier 1 $0.001 \u2014 prices, rankings, lists, news, profiles, simple reads
+- Tier 2 $0.005 \u2014 order books, candles, search, wallet detail, social aggregates
+- Tier 3 $0.020 \u2014 raw on-chain SQL, structured queries, surf-1.5 chat
+
+Common paths (full 84-endpoint catalog in the surf skill):
+- market/price?symbol=BTC                     (T1)
+- exchange/price?pair=BTC-USDT                (T1)
+- prediction-market/polymarket/ranking         (T1)
+- search/web?q=ethereum+pectra+upgrade        (T2)
+- wallet/detail?address=0x...                 (T2)
+- social/mindshare?q=ethereum&interval=1d     (T2)
+- onchain/sql        + body:{ sql: "SELECT ..." }                  (T3)
+- chat/completions   + body:{ model:"surf/surf-1.5", messages:[]}  (T3, $0.02 flat)
+
+Method is auto-routed: pass 'body' for POST endpoints; otherwise GET with 'params'.
+Each Surf endpoint pre-validates required params before settling \u2014 you get a 400 (not a charge) if a required field is missing. Browse the full catalog: https://blockrun.ai/marketplace/surf`,
+      inputSchema: {
+        path: z14.string().describe("Endpoint path under /v1/surf/, e.g. 'market/price', 'prediction-market/polymarket/ranking', 'wallet/detail', 'onchain/sql', 'chat/completions'"),
+        params: z14.record(z14.string(), z14.string()).optional().describe("Query parameters for GET endpoints, e.g. { symbol: 'BTC' } or { address: '0x...', chain: 'ethereum' }"),
+        body: z14.any().optional().describe("JSON body for POST endpoints. Provide for: onchain/query, onchain/sql, chat/completions. When set, the call is sent as POST; otherwise GET with params.")
+      }
+    },
+    async ({ path: path4, params, body }) => {
+      try {
+        const client = getClient();
+        const cleanPath = path4.replace(/^\/+/, "").replace(/^v1\/surf\//, "").replace(/^api\/v1\/surf\//, "");
+        const endpoint = `/v1/surf/${cleanPath}`;
+        const result = body !== void 0 ? await client.requestWithPaymentRaw(endpoint, body) : await client.getWithPaymentRaw(endpoint, params);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+          structuredContent: result
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: formatError(extractErrorMessage(err)) }],
           isError: true
         };
       }
@@ -1608,20 +1656,24 @@ function initializeMcpServer(server) {
   registerExaTool(server);
   registerMarketsTool(server);
   registerPriceTool(server);
-  registerTwitterTool(server);
   registerDexTool(server);
   registerModalTool(server);
+  registerPhoneTool(server);
+  registerSurfTool(server);
   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)
-      }]
-    })
+    async () => {
+      const info = await getWalletInfo();
+      return {
+        contents: [{
+          uri: "blockrun://wallet",
+          mimeType: "application/json",
+          text: JSON.stringify(info, null, 2)
+        }]
+      };
+    }
   );
   server.registerResource(
     "models",
@@ -1647,9 +1699,9 @@ function initializeMcpServer(server) {
 }
 
 // src/utils/key-leak-scanner.ts
-import fs2 from "fs";
-import path2 from "path";
-import os2 from "os";
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
 function looksLikeRawPrivateKey(value) {
   if (typeof value !== "string") return false;
   if (/^0x[0-9a-fA-F]{64}$/.test(value)) return true;
@@ -1674,8 +1726,8 @@ function walk(obj, file, jsonPath, out) {
 }
 function scanFile(file) {
   try {
-    if (!fs2.existsSync(file)) return [];
-    const raw = fs2.readFileSync(file, "utf-8");
+    if (!fs3.existsSync(file)) return [];
+    const raw = fs3.readFileSync(file, "utf-8");
     const data = JSON.parse(raw);
     const out = [];
     walk(data, file, "", out);
@@ -1685,12 +1737,12 @@ function scanFile(file) {
   }
 }
 function warnOnLeakedKeys() {
-  const home = os2.homedir();
+  const home = os3.homedir();
   const candidates = [
-    path2.join(home, ".claude.json"),
-    path2.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
-    path2.join(home, ".config", "claude", "claude_desktop_config.json"),
-    path2.join(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json")
+    path3.join(home, ".claude.json"),
+    path3.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+    path3.join(home, ".config", "claude", "claude_desktop_config.json"),
+    path3.join(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json")
   ];
   const findings = [];
   for (const f of candidates) findings.push(...scanFile(f));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/mcp",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "mcpName": "io.github.BlockRunAI/blockrun-mcp",
   "description": "BlockRun MCP Server - Give your AI agent web search, deep research, prediction markets, crypto data, X/Twitter intelligence. Paid via x402 micropayments.",
   "type": "module",
@@ -14,7 +14,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts --format esm --dts --clean --external sharp",
     "dev": "tsx watch src/index.ts",
     "start": "node dist/index.js",
     "typecheck": "tsc --noEmit",
@@ -48,6 +48,7 @@
     "@modelcontextprotocol/sdk": "^1.0.0",
     "open": "^11.0.0",
     "qrcode": "^1.5.4",
+    "sharp": "^0.34.5",
     "viem": "^2.21.0",
     "zod": "^4.3.5"
   },