@blockrun/mcp 0.2.2 → 0.4.1

package/README.md

@@ -122,11 +122,34 @@ blockrun list models
 blockrun show OpenAI models with pricing
 ```
 
-### Wallet Management
+### Real-Time X/Twitter Search
+
+Get live data from X/Twitter using Grok's real-time search:
+
+```
+blockrun twitter: what is @elonmusk posting about today
+
+blockrun twitter: trending AI news
+
+blockrun twitter: reactions to [recent event]
+```
+
+### Wallet & Balance
 
 ```
 blockrun setup          # First-time setup instructions
 blockrun wallet         # Check your wallet address
+blockrun balance        # Check on-chain USDC balance
+```
+
+### Budget Management
+
+Control your session spending:
+
+```
+blockrun budget check              # View current spending
+blockrun budget set $1.00          # Set $1.00 limit
+blockrun budget clear              # Remove limit
 ```
 
 ## Supported Models & Pricing
@@ -259,7 +282,10 @@ The MCP couldn't find or create a wallet. Check that `~/.blockrun/` directory is
 Some models have rate limits. Try `blockrun smart cheap` or `blockrun smart fast` to use alternative models.
 
 ### Check wallet balance
-Say `blockrun wallet` or visit: `https://basescan.org/address/YOUR_ADDRESS`
+Say `blockrun balance` to check your on-chain USDC balance, or visit: `https://basescan.org/address/YOUR_ADDRESS`
+
+### Budget limit reached
+If you've set a session budget and hit the limit, use `blockrun budget clear` to remove it or `blockrun budget set $X` to increase it.
 
 ## Configuration
 

package/dist/index.js

@@ -4,13 +4,19 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { LLMClient } from "@blockrun/llm";
+import { LLMClient, ImageClient } from "@blockrun/llm";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import QRCode from "qrcode";
+import { Jimp } from "jimp";
+import open from "open";
 var WALLET_DIR = path.join(os.homedir(), ".blockrun");
 var WALLET_FILE = path.join(WALLET_DIR, ".session");
+var QR_FILE = path.join(WALLET_DIR, "qr.png");
+var USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var BASE_CHAIN_ID = "8453";
 var MODEL_TIERS = {
   fast: ["google/gemini-2.5-flash", "openai/gpt-4o-mini", "deepseek/deepseek-chat"],
   balanced: ["openai/gpt-4o", "anthropic/claude-sonnet-4", "google/gemini-2.5-pro"],
@@ -21,7 +27,14 @@ var MODEL_TIERS = {
 var walletWasCreated = false;
 var walletAddress = null;
 var client = null;
+var imageClient = null;
 var cachedModels = null;
+var sessionBudget = { limit: null, spent: 0, calls: 0 };
+var BASE_RPC_URLS = [
+  "https://mainnet.base.org",
+  "https://base.llamarpc.com",
+  "https://1rpc.io/base"
+];
 function getOrCreateWalletKey() {
   const envKey = process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY;
   if (envKey) {
@@ -62,6 +75,13 @@ function getClient() {
   }
   return client;
 }
+function getImageClient() {
+  if (!imageClient) {
+    const privateKey = getOrCreateWalletKey();
+    imageClient = new ImageClient({ privateKey });
+  }
+  return imageClient;
+}
 function getWalletInfo() {
   const llm = getClient();
   const address = llm.getWalletAddress();
@@ -71,149 +91,296 @@ function getWalletInfo() {
     chainId: 8453,
     currency: "USDC",
     isNew: walletWasCreated,
-    basescanUrl: `https://basescan.org/address/${address}`,
-    fundingOptions: {
-      coinbase: "Send USDC, select 'Base' network",
-      bridge: "https://bridge.base.org",
-      buy: "https://www.coinbase.com/onramp"
-    }
+    basescanUrl: `https://basescan.org/address/${address}`
   };
 }
-function getWalletSetupInstructions() {
-  if (!walletAddress) {
-    getClient();
+async function getUsdcBalance(address) {
+  const data = {
+    jsonrpc: "2.0",
+    method: "eth_call",
+    params: [{
+      to: USDC_ADDRESS,
+      data: `0x70a08231000000000000000000000000${address.slice(2)}`
+    }, "latest"],
+    id: 1
+  };
+  for (const rpcUrl of BASE_RPC_URLS) {
+    try {
+      const response = await fetch(rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data)
+      });
+      const result = await response.json();
+      if (result.result) {
+        return parseInt(result.result, 16) / 1e6;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function getEip681Uri(address, amountUsdc = 1) {
+  const amountWei = Math.floor(amountUsdc * 1e6);
+  return `ethereum:${USDC_ADDRESS}@${BASE_CHAIN_ID}/transfer?address=${address}&uint256=${amountWei}`;
+}
+async function generateQrPng(address) {
+  const eip681Uri = getEip681Uri(address);
+  const qrBuffer = await QRCode.toBuffer(eip681Uri, {
+    type: "png",
+    width: 400,
+    margin: 2,
+    errorCorrectionLevel: "H",
+    color: { dark: "#000000", light: "#FFFFFF" }
+  });
+  const qrImage = await Jimp.read(qrBuffer);
+  try {
+    const logoUrl = "https://avatars.githubusercontent.com/u/108554348?s=200&v=4";
+    const logo = await Jimp.read(logoUrl);
+    const logoSize = Math.floor(qrImage.width * 0.2);
+    logo.resize({ w: logoSize, h: logoSize });
+    const x = Math.floor((qrImage.width - logoSize) / 2);
+    const y = Math.floor((qrImage.height - logoSize) / 2);
+    qrImage.composite(logo, x, y);
+  } catch {
+  }
+  if (!fs.existsSync(WALLET_DIR)) {
+    fs.mkdirSync(WALLET_DIR, { recursive: true, mode: 448 });
   }
-  return `
+  await qrImage.write(QR_FILE);
+  return QR_FILE;
+}
+async function openQrInViewer(qrPath) {
+  try {
+    await open(qrPath);
+  } catch {
+  }
+}
+function recordSpending(cost) {
+  sessionBudget.spent += cost;
+  sessionBudget.calls += 1;
+}
+function checkBudget() {
+  if (sessionBudget.limit === null) {
+    return { allowed: true, remaining: null };
+  }
+  const remaining = sessionBudget.limit - sessionBudget.spent;
+  return { allowed: remaining > 0, remaining };
+}
+function formatError(message) {
+  const isPaymentError = message.toLowerCase().includes("payment") || message.toLowerCase().includes("402") || message.toLowerCase().includes("balance") || message.toLowerCase().includes("insufficient");
+  let errorText = `Error: ${message}`;
+  if (isPaymentError) {
+    errorText += `
+
+This error usually means your wallet needs funding.
+Run blockrun_wallet with action: "setup" to get funding instructions.
+
+Quick fix: Send USDC to your wallet on Base network.`;
+  }
+  return errorText;
+}
+var server = new McpServer({
+  name: "blockrun-mcp",
+  version: "0.4.0"
+});
+server.registerTool(
+  "blockrun_wallet",
+  {
+    description: `Manage your BlockRun wallet - check status, get funding instructions, open QR code, or manage session budget.
+
+Actions:
+- status: Show wallet address, balance, and basescan link (default)
+- setup: Full funding instructions with QR code
+- qr: Generate and open QR code for easy funding
+- budget: Manage session spending limit
+
+Examples:
+  blockrun_wallet()                                    -> status + balance
+  blockrun_wallet({ action: "setup" })                 -> funding instructions + QR
+  blockrun_wallet({ action: "qr" })                    -> open QR code
+  blockrun_wallet({ action: "budget", budget_action: "set", budget_amount: 1.00 })`,
+    inputSchema: {
+      action: z.enum(["status", "setup", "qr", "budget"]).optional().default("status").describe("What to do"),
+      budget_action: z.enum(["set", "check", "clear"]).optional().describe("Budget action (for action='budget')"),
+      budget_amount: z.number().optional().describe("Budget limit in USD (for budget_action='set')")
+    }
+  },
+  async ({ action, budget_action, budget_amount }) => {
+    const info = getWalletInfo();
+    const address = info.address;
+    if (action === "budget") {
+      const budgetAct = budget_action || "check";
+      if (budgetAct === "set") {
+        if (budget_amount === void 0 || budget_amount <= 0) {
+          return {
+            content: [{ type: "text", text: "Error: Provide a positive budget_amount (e.g., 1.00 for $1.00)" }],
+            isError: true
+          };
+        }
+        sessionBudget.limit = budget_amount;
+      } else if (budgetAct === "clear") {
+        sessionBudget.limit = null;
+      }
+      const remaining = sessionBudget.limit !== null ? sessionBudget.limit - sessionBudget.spent : null;
+      const limitStr = sessionBudget.limit !== null ? `$${sessionBudget.limit.toFixed(2)}` : "Unlimited";
+      const remainingStr = remaining !== null ? `$${remaining.toFixed(4)}` : "N/A";
+      return {
+        content: [{ type: "text", text: `Session Budget: ${limitStr} | Spent: $${sessionBudget.spent.toFixed(4)} | Calls: ${sessionBudget.calls} | Remaining: ${remainingStr}${budgetAct === "set" ? ` | Set to $${budget_amount?.toFixed(2)}` : ""}${budgetAct === "clear" ? " | Limit removed" : ""}` }],
+        structuredContent: {
+          limit: sessionBudget.limit,
+          spent: sessionBudget.spent,
+          calls: sessionBudget.calls,
+          remaining
+        }
+      };
+    }
+    if (action === "qr") {
+      try {
+        const qrPath = await generateQrPng(address);
+        await openQrInViewer(qrPath);
+        return {
+          content: [{ type: "text", text: `QR code opened! Scan with MetaMask to send USDC on Base.
+
+Address: ${address}
+QR saved: ${qrPath}` }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Failed to generate QR: ${err}` }],
+          isError: true
+        };
+      }
+    }
+    if (action === "setup") {
+      let qrMessage = "";
+      try {
+        const qrPath = await generateQrPng(address);
+        await openQrInViewer(qrPath);
+        qrMessage = `
+QR code opened for scanning! (${qrPath})`;
+      } catch {
+        qrMessage = "\n(QR generation failed - use address above)";
+      }
+      const text2 = `
 ================================================================================
                         BLOCKRUN WALLET SETUP
 ================================================================================
 
-Your wallet address: ${walletAddress}
-
-To use BlockRun AI models, you need USDC on Base network.
+Your wallet address: ${address}
+${qrMessage}
 
 HOW TO FUND YOUR WALLET:
 ------------------------
 
 Option 1: Transfer from Coinbase
   1. Open Coinbase app or website
-  2. Go to Send/Receive
-  3. Select USDC
-  4. Choose "Base" network (important!)
-  5. Paste address: ${walletAddress}
-  6. Send any amount ($5 is enough to start)
+  2. Go to Send/Receive -> Select USDC
+  3. Choose "Base" network (important!)
+  4. Paste: ${address}
+  5. Send $1-5 to start
 
 Option 2: Bridge from other chains
-  1. Go to https://bridge.base.org
-  2. Connect your existing wallet
-  3. Bridge USDC to Base
-  4. Send to: ${walletAddress}
+  https://bridge.base.org -> Bridge USDC to Base -> Send to address above
 
 Option 3: Buy directly
-  1. Go to https://www.coinbase.com/onramp
-  2. Buy USDC on Base network
-  3. Send to: ${walletAddress}
-
-VERIFY YOUR BALANCE:
-  https://basescan.org/address/${walletAddress}
+  https://www.coinbase.com/onramp -> Buy USDC on Base -> Send to address above
 
-PRICING (pay only for what you use):
-  - GPT-4o: ~$0.005 per request
-  - Claude Sonnet: ~$0.003 per request
-  - Gemini Flash: ~$0.0001 per request
-  - Full pricing: https://blockrun.ai/pricing
-
-SECURITY NOTE:
-  Your private key is stored at: ~/.blockrun/.session
-  This key NEVER leaves your machine - only used for signing payments locally.
-
-================================================================================
-`;
-}
-var server = new McpServer({
-  name: "blockrun-mcp",
-  version: "0.2.0"
-});
-server.registerTool(
-  "blockrun_chat",
-  {
-    description: `Chat with any AI model via BlockRun. Supports 30+ models including GPT-5, Claude Opus 4, Gemini 3, and more.
-Pay-per-request with x402 micropayments - no API keys needed.
+VERIFY BALANCE: https://basescan.org/address/${address}
 
-Popular models:
-- openai/gpt-5.2: Most capable OpenAI model
-- anthropic/claude-opus-4: Best for complex reasoning
-- anthropic/claude-sonnet-4: Fast & capable (recommended)
-- google/gemini-2.5-pro: Great for long context
-- deepseek/deepseek-chat: Very affordable
+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
 
-Use blockrun_models to see all available models with pricing.`,
-    inputSchema: {
-      model: z.string().describe("Model ID (e.g., 'anthropic/claude-sonnet-4', 'openai/gpt-4o'). Use blockrun_models to list all."),
-      message: z.string().describe("Your message to the AI"),
-      system: z.string().optional().describe("Optional system prompt to set context/behavior"),
-      max_tokens: z.number().optional().default(1024).describe("Maximum tokens in response"),
-      temperature: z.number().optional().default(1).describe("Creativity level 0-2")
-    }
-  },
-  async ({ model, message, system, max_tokens, temperature }) => {
-    try {
-      const llm = getClient();
-      const response = await llm.chat(model, message, {
-        system,
-        maxTokens: max_tokens,
-        temperature
-      });
-      return { content: [{ type: "text", text: response }] };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return {
-        content: [{ type: "text", text: formatError(errorMessage) }],
-        isError: true
-      };
+SECURITY: Private key stored at ~/.blockrun/.session (never leaves your machine)
+================================================================================`;
+      return { content: [{ type: "text", text: text2 }] };
     }
+    const balance = await getUsdcBalance(address);
+    const balanceStr = balance !== null ? `$${balance.toFixed(6)} USDC` : "Unable to fetch";
+    const lowBalance = balance !== null && balance < 1;
+    const text = `Wallet: ${address}
+Balance: ${balanceStr}${lowBalance ? " (low - add funds)" : ""}
+Network: Base | View: ${info.basescanUrl}
+${info.isNew ? "\nNEW WALLET - Run with action: 'setup' for funding instructions" : ""}`;
+    return {
+      content: [{ type: "text", text }],
+      structuredContent: {
+        address: info.address,
+        balance,
+        network: info.network,
+        chainId: info.chainId,
+        isNew: info.isNew,
+        basescanUrl: info.basescanUrl
+      }
+    };
   }
 );
 server.registerTool(
-  "blockrun_smart",
+  "blockrun_chat",
   {
-    description: `Smart model routing - automatically picks the best model based on your needs.
+    description: `Chat with AI models via BlockRun. Supports 30+ models with pay-per-request micropayments.
+
+Two ways to use:
+1. Specify a model directly: model: "openai/gpt-4o"
+2. Use smart routing: mode: "fast" | "balanced" | "powerful" | "cheap" | "reasoning"
+
+Popular models:
+- openai/gpt-5.2, openai/gpt-4o, openai/gpt-4o-mini
+- anthropic/claude-opus-4, anthropic/claude-sonnet-4
+- google/gemini-2.5-pro, google/gemini-2.5-flash
+- deepseek/deepseek-chat (very affordable)
 
-Modes:
-- fast: Quickest response (Gemini Flash, GPT-4o-mini)
-- balanced: Good quality & speed (GPT-4o, Claude Sonnet)
-- powerful: Best quality (GPT-5.2, Claude Opus 4, o3)
-- cheap: Lowest cost (Gemini Flash, DeepSeek)
-- reasoning: Complex logic (o3, o1, DeepSeek Reasoner)
+Smart routing modes:
+- fast: Gemini Flash, GPT-4o-mini (quickest)
+- balanced: GPT-4o, Claude Sonnet (good default)
+- powerful: GPT-5.2, Claude Opus 4 (best quality)
+- cheap: DeepSeek, Gemini Flash (lowest cost)
+- reasoning: o3, o1 (complex logic)
 
-Example: blockrun_smart({ mode: "fast", message: "Hello" })`,
+Use blockrun_models to see all available models with pricing.`,
     inputSchema: {
-      mode: z.enum(["fast", "balanced", "powerful", "cheap", "reasoning"]).describe("Routing mode"),
       message: z.string().describe("Your message to the AI"),
+      model: z.string().optional().describe("Specific model ID (e.g., 'openai/gpt-4o')"),
+      mode: z.enum(["fast", "balanced", "powerful", "cheap", "reasoning"]).optional().describe("Smart routing mode (ignored if model specified)"),
       system: z.string().optional().describe("Optional system prompt"),
-      max_tokens: z.number().optional().default(1024).describe("Maximum tokens in response")
-    },
-    outputSchema: {
-      model_used: z.string().describe("The model that was used"),
-      response: z.string().describe("The AI response")
+      max_tokens: z.number().optional().default(1024).describe("Max tokens in response"),
+      temperature: z.number().optional().default(1).describe("Creativity 0-2")
     }
   },
-  async ({ mode, message, system, max_tokens }) => {
-    const models = MODEL_TIERS[mode];
-    let lastError = null;
-    for (const model of models) {
+  async ({ message, model, mode, system, max_tokens, temperature }) => {
+    const llm = getClient();
+    if (model) {
       try {
-        const llm = getClient();
         const response = await llm.chat(model, message, {
+          system,
+          maxTokens: max_tokens,
+          temperature
+        });
+        return { content: [{ type: "text", text: response }] };
+      } catch (error) {
+        const errorMessage2 = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: formatError(errorMessage2) }],
+          isError: true
+        };
+      }
+    }
+    const routingMode = mode || "balanced";
+    const models = MODEL_TIERS[routingMode];
+    let lastError = null;
+    for (const m of models) {
+      try {
+        const response = await llm.chat(m, message, {
           system,
           maxTokens: max_tokens
         });
-        const result = { model_used: model, response };
         return {
-          content: [{ type: "text", text: `[Used: ${model}]
+          content: [{ type: "text", text: `[${m}]
 
 ${response}` }],
-          structuredContent: result
+          structuredContent: { model_used: m, response }
         };
       } catch (error) {
         lastError = error;
@@ -230,19 +397,10 @@ ${response}` }],
 server.registerTool(
   "blockrun_models",
   {
-    description: "List all available AI models with pricing. Use this to discover models and compare costs.",
+    description: "List available AI models with pricing. Use to discover models and compare costs.",
     inputSchema: {
       category: z.enum(["all", "chat", "reasoning", "image", "embedding"]).optional().default("all").describe("Filter by category"),
-      provider: z.string().optional().describe("Filter by provider (e.g., 'openai', 'anthropic', 'google')")
-    },
-    outputSchema: {
-      count: z.number().describe("Number of models returned"),
-      models: z.array(z.object({
-        id: z.string(),
-        name: z.string().optional(),
-        inputPrice: z.number().optional(),
-        outputPrice: z.number().optional()
-      })).describe("List of available models")
+      provider: z.string().optional().describe("Filter by provider (e.g., 'openai', 'anthropic')")
     }
   },
   async ({ category, provider }) => {
@@ -260,13 +418,9 @@ 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")
-        );
+        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")
-        );
+        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"));
       }
@@ -275,189 +429,118 @@ server.registerTool(
       const input = m.inputPrice ? `$${m.inputPrice}/M in` : "";
       const output = m.outputPrice ? `$${m.outputPrice}/M out` : "";
       const pricing = [input, output].filter(Boolean).join(", ");
-      return `- ${m.id}: ${m.name || ""} ${pricing ? `(${pricing})` : ""}`;
+      return `- ${m.id}${pricing ? ` (${pricing})` : ""}`;
     });
-    const structuredModels = models.map((m) => ({
-      id: m.id,
-      name: m.name,
-      inputPrice: m.inputPrice,
-      outputPrice: m.outputPrice
-    }));
     return {
-      content: [{ type: "text", text: `Available models (${models.length}):
-
+      content: [{ type: "text", text: `Models (${models.length}):
 ${lines.join("\n")}` }],
-      structuredContent: { count: models.length, models: structuredModels }
+      structuredContent: { count: models.length, models }
     };
   }
 );
 server.registerTool(
   "blockrun_image",
   {
-    description: `Generate images using AI models. Supports DALL-E 3, Flux, and Nano Banana.
-
-Models:
-- openai/dall-e-3: High quality, creative ($0.04-0.08/image)
-- together/flux-schnell: Fast generation ($0.02/image)
-- google/nano-banana: Experimental Google model`,
+    description: `Generate images. Models: openai/dall-e-3 ($0.04-0.08), together/flux-schnell ($0.02), google/nano-banana`,
     inputSchema: {
-      prompt: z.string().describe("Description of the image to generate"),
-      model: z.enum(["openai/dall-e-3", "together/flux-schnell", "google/nano-banana"]).optional().default("openai/dall-e-3").describe("Image model"),
-      size: z.enum(["1024x1024", "1792x1024", "1024x1792"]).optional().default("1024x1024").describe("Image size"),
-      quality: z.enum(["standard", "hd"]).optional().default("standard").describe("Quality level for DALL-E 3")
-    },
-    outputSchema: {
-      url: z.string().describe("URL of the generated image"),
-      prompt: z.string().describe("The prompt used"),
-      model: z.string().describe("The model used")
+      prompt: z.string().describe("Image description"),
+      model: z.enum(["openai/dall-e-3", "together/flux-schnell", "google/nano-banana"]).optional().default("openai/dall-e-3"),
+      size: z.enum(["1024x1024", "1792x1024", "1024x1792"]).optional().default("1024x1024"),
+      quality: z.enum(["standard", "hd"]).optional().default("standard")
     }
   },
   async ({ prompt, model, size, quality }) => {
-    const apiUrl = "https://blockrun.ai/api/v1/images/generations";
-    const body = {
-      model,
-      prompt,
-      size,
-      quality,
-      n: 1
-    };
-    const response = await fetch(apiUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (response.status === 402) {
-      return {
-        content: [{ type: "text", text: `Image generation requires payment. Please ensure your wallet has USDC on Base.
-
-To generate "${prompt}" with ${model}, the approximate cost is $0.04-0.08 per image.` }],
-        isError: true
-      };
-    }
-    if (!response.ok) {
+    try {
+      const imgClient = getImageClient();
+      const response = await imgClient.generate(prompt, {
+        model,
+        size,
+        quality
+      });
+      const imageUrl = response.data?.[0]?.url;
+      if (!imageUrl) {
+        return {
+          content: [{ type: "text", text: formatError("No image URL in response") }],
+          isError: true
+        };
+      }
       return {
-        content: [{ type: "text", text: formatError(`Image generation failed: ${response.status}`) }],
-        isError: true
+        content: [{ type: "text", text: `Image: ${imageUrl}
+Prompt: ${prompt}
+Model: ${model}` }],
+        structuredContent: { url: imageUrl, prompt, model }
       };
-    }
-    const data = await response.json();
-    const imageUrl = data.data?.[0]?.url;
-    if (!imageUrl) {
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      if (errMsg.includes("balance") || errMsg.includes("payment") || errMsg.includes("402")) {
+        return {
+          content: [{ type: "text", text: `Image generation requires payment. Run blockrun_wallet with action: "setup" for funding instructions.
+Error: ${errMsg}` }],
+          isError: true
+        };
+      }
       return {
-        content: [{ type: "text", text: formatError("No image URL in response") }],
+        content: [{ type: "text", text: formatError(`Image generation failed: ${errMsg}`) }],
         isError: true
       };
     }
-    return {
-      content: [{ type: "text", text: `Image generated successfully!
-
-URL: ${imageUrl}
-
-Prompt: ${prompt}
-Model: ${model}` }],
-      structuredContent: { url: imageUrl, prompt, model }
-    };
   }
 );
 server.registerTool(
-  "blockrun_wallet",
+  "blockrun_twitter",
   {
-    description: "Get information about your BlockRun wallet address. Shows address, network, and quick funding options.",
-    inputSchema: {},
-    outputSchema: {
-      address: z.string().describe("Wallet address"),
-      network: z.string().describe("Network name"),
-      chainId: z.number().describe("Chain ID"),
-      currency: z.string().describe("Currency"),
-      isNew: z.boolean().describe("Whether this is a newly created wallet"),
-      basescanUrl: z.string().describe("Link to view on Basescan")
+    description: `Search real-time X/Twitter via Grok. Use for trending topics, @handles, breaking news.`,
+    inputSchema: {
+      query: z.string().describe("Search query (can include @handles, topics)"),
+      max_results: z.number().optional().default(10).describe("Max results (1-25)")
     }
   },
-  async () => {
-    const info = getWalletInfo();
-    const isNewWallet = info.isNew;
-    let text = `BlockRun Wallet Information
-============================
-
-Address: ${info.address}
-Network: ${info.network} (Chain ID: ${info.chainId})
-Currency: ${info.currency}
-
-View on Basescan: ${info.basescanUrl}
-`;
-    if (isNewWallet) {
-      text += `
-STATUS: NEW WALLET - NEEDS FUNDING
-${getWalletSetupInstructions()}`;
-    } else {
-      text += `
-HOW TO ADD FUNDS:
------------------
-Send USDC to the address above on Base network.
-
-Quick options:
-1. From Coinbase: ${info.fundingOptions.coinbase}
-2. Bridge: ${info.fundingOptions.bridge}
-3. Buy: ${info.fundingOptions.buy}
-
-Full instructions: Run blockrun_setup tool
-`;
+  async ({ query, max_results }) => {
+    const budget = checkBudget();
+    if (!budget.allowed) {
+      return {
+        content: [{ type: "text", text: `Budget limit reached ($${sessionBudget.spent.toFixed(4)} of $${sessionBudget.limit?.toFixed(2)}). Use blockrun_wallet with action: "budget" to adjust.` }],
+        isError: true
+      };
     }
-    return {
-      content: [{ type: "text", text }],
-      structuredContent: {
-        address: info.address,
-        network: info.network,
-        chainId: info.chainId,
-        currency: info.currency,
-        isNew: info.isNew,
-        basescanUrl: info.basescanUrl
-      }
-    };
-  }
-);
-server.registerTool(
-  "blockrun_setup",
-  {
-    description: `Get detailed wallet setup and funding instructions. Use this for first-time setup or if you need help adding funds to your wallet.
+    try {
+      const llm = getClient();
+      const response = await llm.chat("xai/grok-3", query, {
+        system: `Real-time X/Twitter search. Focus on recent posts, key accounts, engagement. Max results: ${max_results}`,
+        search: true
+      });
+      recordSpending(2e-3);
+      return {
+        content: [{ type: "text", text: `[X/Twitter via Grok]
 
-Returns:
-- Your wallet address
-- Step-by-step funding instructions (Coinbase, bridge, direct purchase)
-- Pricing information
-- Security details`,
-    inputSchema: {}
-  },
-  async () => {
-    getClient();
-    return { content: [{ type: "text", text: getWalletSetupInstructions() }] };
+${response}` }],
+        structuredContent: { query, model: "xai/grok-3", response }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: formatError(errorMessage) }],
+        isError: true
+      };
+    }
   }
 );
 server.registerResource(
   "wallet",
   "blockrun://wallet",
-  {
-    description: "Your BlockRun wallet address and status",
-    mimeType: "application/json"
-  },
-  async () => {
-    const info = getWalletInfo();
-    return {
-      contents: [{
-        uri: "blockrun://wallet",
-        mimeType: "application/json",
-        text: JSON.stringify(info, null, 2)
-      }]
-    };
-  }
+  { description: "Wallet address and status", mimeType: "application/json" },
+  async () => ({
+    contents: [{
+      uri: "blockrun://wallet",
+      mimeType: "application/json",
+      text: JSON.stringify(getWalletInfo(), null, 2)
+    }]
+  })
 );
 server.registerResource(
   "models",
   "blockrun://models",
-  {
-    description: "List of all available AI models with pricing",
-    mimeType: "application/json"
-  },
+  { description: "Available AI models with pricing", mimeType: "application/json" },
   async () => {
     const llm = getClient();
     if (!cachedModels) {
@@ -475,87 +558,10 @@ server.registerResource(
     };
   }
 );
-server.registerPrompt(
-  "quick_chat",
-  {
-    description: "Start a quick chat with a recommended model",
-    argsSchema: {
-      message: z.string().describe("Your message"),
-      style: z.enum(["concise", "detailed", "creative"]).optional().default("concise").describe("Response style")
-    }
-  },
-  async ({ message, style }) => {
-    const systemPrompts = {
-      concise: "Be concise and direct. Give short, focused answers.",
-      detailed: "Provide thorough, comprehensive answers with examples.",
-      creative: "Be creative and imaginative in your responses."
-    };
-    return {
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: `[System: ${systemPrompts[style || "concise"]}]
-
-${message}`
-          }
-        }
-      ]
-    };
-  }
-);
-server.registerPrompt(
-  "code_review",
-  {
-    description: "Get a code review from a powerful model",
-    argsSchema: {
-      code: z.string().describe("The code to review"),
-      language: z.string().optional().describe("Programming language"),
-      focus: z.enum(["bugs", "performance", "style", "all"]).optional().default("all").describe("What to focus on")
-    }
-  },
-  async ({ code, language, focus }) => {
-    const focusInstructions = {
-      bugs: "Focus on potential bugs, errors, and edge cases.",
-      performance: "Focus on performance issues and optimization opportunities.",
-      style: "Focus on code style, readability, and best practices.",
-      all: "Review for bugs, performance, and style."
-    };
-    return {
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: `Please review this ${language || ""} code. ${focusInstructions[focus || "all"]}
-
-\`\`\`${language || ""}
-${code}
-\`\`\``
-          }
-        }
-      ]
-    };
-  }
-);
-function formatError(message) {
-  const isPaymentError = message.toLowerCase().includes("payment") || message.toLowerCase().includes("402") || message.toLowerCase().includes("balance") || message.toLowerCase().includes("insufficient");
-  let errorText = `Error: ${message}`;
-  if (isPaymentError) {
-    errorText += `
-
-This error usually means your wallet needs funding.
-Run the blockrun_setup tool to get your wallet address and funding instructions.
-
-Quick fix: Send USDC to your wallet on Base network.`;
-  }
-  return errorText;
-}
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("BlockRun MCP Server started (v0.1.0)");
+  console.error("BlockRun MCP Server started (v0.4.0)");
 }
 main().catch((error) => {
   console.error("Fatal error:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/mcp",
-  "version": "0.2.2",
+  "version": "0.4.1",
   "mcpName": "io.github.BlockRunAI/blockrun-mcp",
   "description": "BlockRun MCP Server - Access 30+ AI models via x402 micropayments. No API keys needed.",
   "type": "module",
@@ -44,13 +44,17 @@
     "url": "https://github.com/blockrunai/blockrun-mcp/issues"
   },
   "dependencies": {
-    "@blockrun/llm": "^0.1.1",
+    "@blockrun/llm": "^0.2.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "jimp": "^1.6.0",
+    "open": "^11.0.0",
+    "qrcode": "^1.5.4",
     "viem": "^2.21.0",
     "zod": "^4.3.5"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "@types/qrcode": "^1.5.6",
     "tsup": "^8.0.0",
     "tsx": "^4.0.0",
     "typescript": "^5.0.0"