@blockrun/mcp 0.14.0 → 0.14.2

package/README.md

@@ -144,7 +144,6 @@ $5 covers ~5,000 market queries, ~500 Exa searches, ~250 image generations, or ~
 | `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_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_x` | X/Twitter — profiles, tweets, followers, mentions, search (AttentionVC) | per 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 |
@@ -186,7 +185,7 @@ What kinds of questions can Claude (or any LLM agent) answer once BlockRun MCP i
    > *"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` action:`voice_call`, then poll `voice_status`
+   > *"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`
@@ -203,8 +202,7 @@ What kinds of questions can Claude (or any LLM agent) answer once BlockRun MCP i
 | Exa | Sign up, $20/mo minimum | $0.01/call, no subscription |
 | Polymarket | Undocumented, rate-limited | $0.001/call, clean JSON |
 | Surf (asksurf.ai) | Account + monthly plan | $0.001/call, no Surf account, 84 endpoints |
-| Twitter/X API | $100–$5000/month | $0.03/page, no approval |
-| Multiple sources | 4 accounts, 4 API keys, 4 billing pages | 1 wallet |
+| Multiple sources | 3 accounts, 3 API keys, 3 billing pages | 1 wallet |
 
 One wallet. All sources. No dashboards.
 

package/dist/index.js

@@ -7,6 +7,8 @@ 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,
@@ -19,12 +21,30 @@ import {
   formatNeedsFundingMessage,
   SOLANA_WALLET_FILE_PATH
 } from "@blockrun/llm";
+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 _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 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";
@@ -146,11 +166,11 @@ 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 = {
@@ -222,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");
@@ -1124,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 };
       }
     }
   );
@@ -1168,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 };
       }
     }
   );
@@ -1298,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
@@ -1420,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",
@@ -1562,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 }) => {
@@ -1626,235 +1506,91 @@ ${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(errMsg) }],
-          isError: true
-        };
+        return { content: [{ type: "text", text: formatError(extractErrorMessage(err)) }], isError: true };
       }
     }
   );
 }
 
 // src/tools/phone.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 function registerPhoneTool(server) {
   server.registerTool(
     "blockrun_phone",
     {
-      description: `Phone number intelligence, provisioning, and outbound AI voice calls via BlockRun x402.
+      description: `Phone-number intelligence, US/CA number provisioning, and outbound AI voice calls.
 
-Pricing:
-- lookup: $0.01 \u2014 carrier + line type for any number
-- lookup_fraud: $0.05 \u2014 + SIM swap / call forwarding signals
-- numbers_buy: $5.00 \u2014 provision a US/CA number for 30 days
-- numbers_renew: $5.00 \u2014 extend lease 30 days
-- numbers_list: $0.001 \u2014 list your wallet-owned numbers
-- numbers_release: free \u2014 release number back to pool
-- voice_call: $0.54 flat \u2014 outbound AI voice call via Bland.ai (up to 5 min default)
-- voice_status: free \u2014 poll call status + transcript
-
-Voice call flow:
-  1. blockrun_phone action:"voice_call" to:"+1..." task:"Confirm appointment for..."
-  2. Returns call_id immediately (call runs async)
-  3. blockrun_phone action:"voice_status" call_id:"..." to poll until completed
-
-Voice presets: nat, josh, maya, june, paige, derek, florian
-Phone numbers use E.164 format: +14155552671`,
+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 format (e.g. +1 followed by 10 US digits, or +<country-code><number>).
+
+Voice call flow + voice preset details + full body shapes in the \`phone\` skill.`,
       inputSchema: {
-        action: z14.enum([
-          "lookup",
-          "lookup_fraud",
-          "numbers_buy",
-          "numbers_renew",
-          "numbers_list",
-          "numbers_release",
-          "voice_call",
-          "voice_status"
-        ]).describe("Action to perform"),
-        phone_number: z14.string().optional().describe("E.164 phone number, e.g. +14155552671 (required for lookup, lookup_fraud, numbers_renew, numbers_release)"),
-        country: z14.string().optional().describe("Country for numbers_buy: US or CA (default: US)"),
-        area_code: z14.string().optional().describe("Preferred 3-digit area code for numbers_buy (best effort)"),
-        to: z14.string().optional().describe("Destination E.164 number (required for voice_call)"),
-        task: z14.string().optional().describe("What the AI should do on the call, 10\u20134000 chars (required for voice_call)"),
-        from: z14.string().optional().describe("Your provisioned BlockRun caller ID number (optional for voice_call)"),
-        voice: z14.enum(["nat", "josh", "maya", "june", "paige", "derek", "florian"]).optional().describe("AI voice preset"),
-        max_duration: z14.number().min(1).max(30).optional().describe("Max call duration in minutes (1\u201330, default: 5)"),
-        language: z14.string().optional().describe("Language code, e.g. en-US (default: en-US)"),
-        first_sentence: z14.string().optional().describe("Custom opening line for the AI agent"),
-        wait_for_greeting: z14.boolean().optional().describe("Wait for recipient to speak before AI starts"),
-        call_id: z14.string().optional().describe("Call ID from voice_call response (required for voice_status)")
+        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 ({
-      action,
-      phone_number,
-      country,
-      area_code,
-      to,
-      task,
-      from,
-      voice,
-      max_duration,
-      language,
-      first_sentence,
-      wait_for_greeting,
-      call_id
-    }) => {
-      const client = getClient();
-      const req = client;
-      const chain = getChain();
+    async ({ path: path4, body }) => {
       try {
-        let result;
-        switch (action) {
-          case "lookup": {
-            if (!phone_number) return { content: [{ type: "text", text: "phone_number required (E.164)" }], isError: true };
-            result = await req.requestWithPaymentRaw("/v1/phone/lookup", { phoneNumber: phone_number });
-            break;
-          }
-          case "lookup_fraud": {
-            if (!phone_number) return { content: [{ type: "text", text: "phone_number required (E.164)" }], isError: true };
-            result = await req.requestWithPaymentRaw("/v1/phone/lookup/fraud", { phoneNumber: phone_number });
-            break;
-          }
-          case "numbers_buy": {
-            const body = {};
-            if (country) body.country = country;
-            if (area_code) body.areaCode = area_code;
-            result = await req.requestWithPaymentRaw("/v1/phone/numbers/buy", body);
-            break;
-          }
-          case "numbers_renew": {
-            if (!phone_number) return { content: [{ type: "text", text: "phone_number required (E.164)" }], isError: true };
-            result = await req.requestWithPaymentRaw("/v1/phone/numbers/renew", { phoneNumber: phone_number });
-            break;
-          }
-          case "numbers_list": {
-            result = await req.requestWithPaymentRaw("/v1/phone/numbers/list", {});
-            break;
-          }
-          case "numbers_release": {
-            if (!phone_number) return { content: [{ type: "text", text: "phone_number required (E.164)" }], isError: true };
-            result = await req.requestWithPaymentRaw("/v1/phone/numbers/release", { phoneNumber: phone_number });
-            break;
-          }
-          case "voice_call": {
-            if (!to) return { content: [{ type: "text", text: "to (destination phone number) required" }], isError: true };
-            if (!task) return { content: [{ type: "text", text: "task required (what the AI should do on the call)" }], isError: true };
-            const body = { to, task };
-            if (from) body.from = from;
-            if (voice) body.voice = voice;
-            if (max_duration !== void 0) body.max_duration = max_duration;
-            if (language) body.language = language;
-            if (first_sentence) body.first_sentence = first_sentence;
-            if (wait_for_greeting !== void 0) body.wait_for_greeting = wait_for_greeting;
-            result = await req.requestWithPaymentRaw("/v1/voice/call", body);
-            break;
-          }
-          case "voice_status": {
-            if (!call_id) return { content: [{ type: "text", text: "call_id required" }], isError: true };
-            const apiBase = chain === "solana" ? "https://sol.blockrun.ai/api" : "https://blockrun.ai/api";
-            const resp = await fetch(`${apiBase}/v1/voice/call/${encodeURIComponent(call_id)}`, {
-              signal: AbortSignal.timeout(15e3)
-            });
-            if (!resp.ok) {
-              const err = await resp.text().catch(() => resp.statusText);
-              return { content: [{ type: "text", text: formatError(`voice_status ${resp.status}: ${err}`) }], isError: true };
-            }
-            result = await resp.json();
-            break;
-          }
-        }
-        const text = typeof result === "object" ? JSON.stringify(result, null, 2) : String(result);
+        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 }],
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
           structuredContent: result
         };
       } catch (err) {
-        return { content: [{ type: "text", text: formatError(err instanceof Error ? err.message : String(err)) }], isError: true };
+        return { content: [{ type: "text", text: formatError(extractErrorMessage(err)) }], isError: true };
       }
     }
   );
 }
 
 // src/tools/surf.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 function registerSurfTool(server) {
   server.registerTool(
     "blockrun_surf",
@@ -1881,15 +1617,15 @@ Common paths (full 84-endpoint catalog in the surf skill):
 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: z15.string().describe("Endpoint path under /v1/surf/, e.g. 'market/price', 'prediction-market/polymarket/ranking', 'wallet/detail', 'onchain/sql', 'chat/completions'"),
-        params: z15.record(z15.string(), z15.string()).optional().describe("Query parameters for GET endpoints, e.g. { symbol: 'BTC' } or { address: '0x...', chain: 'ethereum' }"),
-        body: z15.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.")
+        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: path3, params, body }) => {
+    async ({ path: path4, params, body }) => {
       try {
         const client = getClient();
-        const cleanPath = path3.replace(/^\/+/, "").replace(/^v1\/surf\//, "").replace(/^api\/v1\/surf\//, "");
+        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 {
@@ -1897,9 +1633,8 @@ Each Surf endpoint pre-validates required params before settling \u2014 you get
           structuredContent: result
         };
       } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
         return {
-          content: [{ type: "text", text: formatError(errMsg) }],
+          content: [{ type: "text", text: formatError(extractErrorMessage(err)) }],
           isError: true
         };
       }
@@ -1921,7 +1656,6 @@ function initializeMcpServer(server) {
   registerExaTool(server);
   registerMarketsTool(server);
   registerPriceTool(server);
-  registerTwitterTool(server);
   registerDexTool(server);
   registerModalTool(server);
   registerPhoneTool(server);
@@ -1966,8 +1700,8 @@ function initializeMcpServer(server) {
 
 // src/utils/key-leak-scanner.ts
 import fs3 from "fs";
-import path2 from "path";
-import os2 from "os";
+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;
@@ -2003,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.14.0",
+  "version": "0.14.2",
   "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",