@blockrun/mcp 0.3.0 → 0.4.1

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,9 +27,9 @@ 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 USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
 var BASE_RPC_URLS = [
   "https://mainnet.base.org",
   "https://base.llamarpc.com",
@@ -69,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();
@@ -78,65 +91,9 @@ 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();
-  }
-  return `
-================================================================================
-                        BLOCKRUN WALLET SETUP
-================================================================================
-
-Your wallet address: ${walletAddress}
-
-To use BlockRun AI models, you need USDC on Base network.
-
-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)
-
-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}
-
-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}
-
-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.
-
-================================================================================
-`;
-}
 async function getUsdcBalance(address) {
   const data = {
     jsonrpc: "2.0",
@@ -164,6 +121,42 @@ async function getUsdcBalance(address) {
   }
   return null;
 }
+function getEip681Uri(address, amountUsdc = 1) {
+  const amountWei = Math.floor(amountUsdc * 1e6);
+  return `ethereum:${USDC_ADDRESS}@${BASE_CHAIN_ID}/transfer?address=${address}&uint256=${amountWei}`;
+}
+async function generateQrPng(address) {
+  const eip681Uri = getEip681Uri(address);
+  const qrBuffer = await QRCode.toBuffer(eip681Uri, {
+    type: "png",
+    width: 400,
+    margin: 2,
+    errorCorrectionLevel: "H",
+    color: { dark: "#000000", light: "#FFFFFF" }
+  });
+  const qrImage = await Jimp.read(qrBuffer);
+  try {
+    const logoUrl = "https://avatars.githubusercontent.com/u/108554348?s=200&v=4";
+    const logo = await Jimp.read(logoUrl);
+    const logoSize = Math.floor(qrImage.width * 0.2);
+    logo.resize({ w: logoSize, h: logoSize });
+    const x = Math.floor((qrImage.width - logoSize) / 2);
+    const y = Math.floor((qrImage.height - logoSize) / 2);
+    qrImage.composite(logo, x, y);
+  } catch {
+  }
+  if (!fs.existsSync(WALLET_DIR)) {
+    fs.mkdirSync(WALLET_DIR, { recursive: true, mode: 448 });
+  }
+  await qrImage.write(QR_FILE);
+  return QR_FILE;
+}
+async function openQrInViewer(qrPath) {
+  try {
+    await open(qrPath);
+  } catch {
+  }
+}
 function recordSpending(cost) {
   sessionBudget.spent += cost;
   sessionBudget.calls += 1;
@@ -175,90 +168,219 @@ function checkBudget() {
   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.3.0"
+  version: "0.4.0"
 });
 server.registerTool(
-  "blockrun_chat",
+  "blockrun_wallet",
   {
-    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.
-
-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
+    description: `Manage your BlockRun wallet - check status, get funding instructions, open QR code, or manage session budget.
 
-Use blockrun_models to see all available models with pricing.`,
+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: {
-      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")
+      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 ({ 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);
+  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: formatError(errorMessage) }],
-        isError: true
+        content: [{ type: "text", text: `Session Budget: ${limitStr} | Spent: $${sessionBudget.spent.toFixed(4)} | Calls: ${sessionBudget.calls} | Remaining: ${remainingStr}${budgetAct === "set" ? ` | Set to $${budget_amount?.toFixed(2)}` : ""}${budgetAct === "clear" ? " | Limit removed" : ""}` }],
+        structuredContent: {
+          limit: sessionBudget.limit,
+          spent: sessionBudget.spent,
+          calls: sessionBudget.calls,
+          remaining
+        }
       };
     }
+    if (action === "qr") {
+      try {
+        const qrPath = await generateQrPng(address);
+        await openQrInViewer(qrPath);
+        return {
+          content: [{ type: "text", text: `QR code opened! Scan with MetaMask to send USDC on Base.
+
+Address: ${address}
+QR saved: ${qrPath}` }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Failed to generate QR: ${err}` }],
+          isError: true
+        };
+      }
+    }
+    if (action === "setup") {
+      let qrMessage = "";
+      try {
+        const qrPath = await generateQrPng(address);
+        await openQrInViewer(qrPath);
+        qrMessage = `
+QR code opened for scanning! (${qrPath})`;
+      } catch {
+        qrMessage = "\n(QR generation failed - use address above)";
+      }
+      const text2 = `
+================================================================================
+                        BLOCKRUN WALLET SETUP
+================================================================================
+
+Your wallet address: ${address}
+${qrMessage}
+
+HOW TO FUND YOUR WALLET:
+------------------------
+
+Option 1: Transfer from Coinbase
+  1. Open Coinbase app or website
+  2. Go to Send/Receive -> Select USDC
+  3. Choose "Base" network (important!)
+  4. Paste: ${address}
+  5. Send $1-5 to start
+
+Option 2: Bridge from other chains
+  https://bridge.base.org -> Bridge USDC to Base -> Send to address above
+
+Option 3: Buy directly
+  https://www.coinbase.com/onramp -> Buy USDC on Base -> Send to address above
+
+VERIFY BALANCE: https://basescan.org/address/${address}
+
+PRICING (pay per use):
+  - GPT-4o: ~$0.005/request | Claude Sonnet: ~$0.003/request
+  - Gemini Flash: ~$0.0001/request | Full pricing: https://blockrun.ai/pricing
+
+SECURITY: Private key stored at ~/.blockrun/.session (never leaves your machine)
+================================================================================`;
+      return { content: [{ type: "text", text: text2 }] };
+    }
+    const balance = await getUsdcBalance(address);
+    const balanceStr = balance !== null ? `$${balance.toFixed(6)} USDC` : "Unable to fetch";
+    const lowBalance = balance !== null && balance < 1;
+    const text = `Wallet: ${address}
+Balance: ${balanceStr}${lowBalance ? " (low - add funds)" : ""}
+Network: Base | View: ${info.basescanUrl}
+${info.isNew ? "\nNEW WALLET - Run with action: 'setup' for funding instructions" : ""}`;
+    return {
+      content: [{ type: "text", text }],
+      structuredContent: {
+        address: info.address,
+        balance,
+        network: info.network,
+        chainId: info.chainId,
+        isNew: info.isNew,
+        basescanUrl: info.basescanUrl
+      }
+    };
   }
 );
 server.registerTool(
-  "blockrun_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.
 
-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)
+Two ways to use:
+1. Specify a model directly: model: "openai/gpt-4o"
+2. Use smart routing: mode: "fast" | "balanced" | "powerful" | "cheap" | "reasoning"
 
-Example: blockrun_smart({ mode: "fast", message: "Hello" })`,
+Popular models:
+- openai/gpt-5.2, openai/gpt-4o, openai/gpt-4o-mini
+- anthropic/claude-opus-4, anthropic/claude-sonnet-4
+- google/gemini-2.5-pro, google/gemini-2.5-flash
+- deepseek/deepseek-chat (very affordable)
+
+Smart routing modes:
+- fast: Gemini Flash, GPT-4o-mini (quickest)
+- balanced: GPT-4o, Claude Sonnet (good default)
+- powerful: GPT-5.2, Claude Opus 4 (best quality)
+- cheap: DeepSeek, Gemini Flash (lowest cost)
+- reasoning: o3, o1 (complex logic)
+
+Use blockrun_models to see all available models with pricing.`,
     inputSchema: {
-      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;
@@ -275,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 }) => {
@@ -305,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"));
       }
@@ -320,219 +429,92 @@ 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",
-  {
-    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")
-    }
-  },
-  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
-`;
-    }
-    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.
-
-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() }] };
   }
 );
 server.registerTool(
   "blockrun_twitter",
   {
-    description: `Search real-time X/Twitter data using Grok's live search.
-
-Use this tool for:
-- Checking what people are saying about a topic
-- Finding recent tweets from specific accounts
-- Getting trending discussions
-- Real-time news and events
-
-Example queries:
-- "what is @elonmusk posting about today"
-- "trending AI news"
-- "reactions to [event]"`,
+    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, or natural language questions"),
-      max_results: z.number().optional().default(10).describe("Maximum number of results to return (1-25)")
-    },
-    outputSchema: {
-      query: z.string(),
-      model: z.string(),
-      response: z.string()
+      query: z.string().describe("Search query (can include @handles, topics)"),
+      max_results: z.number().optional().default(10).describe("Max results (1-25)")
     }
   },
   async ({ query, max_results }) => {
     const budget = checkBudget();
     if (!budget.allowed) {
       return {
-        content: [{ type: "text", text: `Budget limit reached. Spent $${sessionBudget.spent.toFixed(4)} of $${sessionBudget.limit?.toFixed(2)} limit.
-
-Use blockrun_budget to check or adjust your budget.` }],
+        content: [{ type: "text", text: `Budget limit reached ($${sessionBudget.spent.toFixed(4)} of $${sessionBudget.limit?.toFixed(2)}). Use blockrun_wallet with action: "budget" to adjust.` }],
         isError: true
       };
     }
     try {
       const llm = getClient();
-      const model = "xai/grok-3";
-      const system = `You are a real-time X/Twitter search assistant.
-When searching, focus on:
-- Recent and relevant posts
-- Key accounts and verified sources
-- Engagement metrics when relevant
-Format your response clearly with sources when available.
-Max results requested: ${max_results}`;
-      const response = await llm.chat(model, query, {
-        system,
+      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 Search via Grok]
+        content: [{ type: "text", text: `[X/Twitter via Grok]
 
 ${response}` }],
-        structuredContent: { query, model, response }
+        structuredContent: { query, model: "xai/grok-3", response }
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -543,141 +525,22 @@ ${response}` }],
     }
   }
 );
-server.registerTool(
-  "blockrun_balance",
-  {
-    description: `Check your on-chain USDC balance on Base network.
-
-Returns:
-- Current USDC balance
-- Wallet address
-- Link to view on Basescan
-
-Use this to see how much funding you have available for BlockRun API calls.`,
-    inputSchema: {},
-    outputSchema: {
-      address: z.string(),
-      balance: z.number().nullable(),
-      network: z.string(),
-      basescanUrl: z.string()
-    }
-  },
-  async () => {
-    const llm = getClient();
-    const address = llm.getWalletAddress();
-    const balance = await getUsdcBalance(address);
-    const balanceStr = balance !== null ? `$${balance.toFixed(6)} USDC` : "Unable to fetch (try again)";
-    const text = `BlockRun Wallet Balance
-=======================
-
-Address: ${address}
-Balance: ${balanceStr}
-Network: Base (Chain ID: 8453)
-
-View on Basescan: https://basescan.org/address/${address}
-
-${balance !== null && balance < 1 ? "\u26A0\uFE0F  Low balance. Consider adding funds to continue using BlockRun." : ""}`;
-    return {
-      content: [{ type: "text", text }],
-      structuredContent: {
-        address,
-        balance,
-        network: "Base",
-        basescanUrl: `https://basescan.org/address/${address}`
-      }
-    };
-  }
-);
-server.registerTool(
-  "blockrun_budget",
-  {
-    description: `Manage your session spending budget.
-
-Actions:
-- check: View current spending and budget status
-- set: Set a spending limit (e.g., $1.00)
-- clear: Remove spending limit (unlimited)
-
-Use this to control how much you spend per session on BlockRun API calls.`,
-    inputSchema: {
-      action: z.enum(["check", "set", "clear"]).describe("Budget action to perform"),
-      amount: z.number().optional().describe("Budget limit in USD (required for 'set' action)")
-    },
-    outputSchema: {
-      limit: z.number().nullable(),
-      spent: z.number(),
-      calls: z.number(),
-      remaining: z.number().nullable()
-    }
-  },
-  async ({ action, amount }) => {
-    switch (action) {
-      case "set":
-        if (amount === void 0 || amount <= 0) {
-          return {
-            content: [{ type: "text", text: "Error: Please provide a positive amount for the budget limit (e.g., amount: 1.00 for $1.00)" }],
-            isError: true
-          };
-        }
-        sessionBudget.limit = amount;
-        break;
-      case "clear":
-        sessionBudget.limit = null;
-        break;
-      case "check":
-      default:
-        break;
-    }
-    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";
-    const text = `BlockRun Session Budget
-=======================
-
-Limit: ${limitStr}
-Spent: $${sessionBudget.spent.toFixed(4)}
-Calls: ${sessionBudget.calls}
-Remaining: ${remainingStr}
-
-${action === "set" ? `\u2705 Budget set to $${amount?.toFixed(2)}` : ""}
-${action === "clear" ? "\u2705 Budget limit removed (unlimited spending)" : ""}
-${remaining !== null && remaining < 0.01 ? "\u26A0\uFE0F  Budget nearly exhausted!" : ""}`;
-    return {
-      content: [{ type: "text", text }],
-      structuredContent: {
-        limit: sessionBudget.limit,
-        spent: sessionBudget.spent,
-        calls: sessionBudget.calls,
-        remaining
-      }
-    };
-  }
-);
 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) {
@@ -695,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.3.0",
+  "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"