@blockrun/mcp 0.4.2 → 0.5.2

package/dist/chunk-H2DXT5AJ.js

@@ -0,0 +1,961 @@
+// src/utils/wallet.ts
+import { LLMClient, ImageClient } from "@blockrun/llm";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import * as fs from "fs";
+
+// 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");
+var USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var BASE_CHAIN_ID = "8453";
+var BASE_RPC_URLS = [
+  "https://mainnet.base.org",
+  "https://base.llamarpc.com",
+  "https://1rpc.io/base"
+];
+var MODEL_TIERS = {
+  fast: ["google/gemini-2.5-flash", "google/gemini-3.1-flash-lite", "openai/gpt-5-mini", "deepseek/deepseek-chat", "google/gemini-3-flash-preview"],
+  balanced: ["openai/gpt-5.4", "anthropic/claude-sonnet-4.6", "google/gemini-2.5-pro", "openai/gpt-5.3", "google/gemini-3.1-pro"],
+  powerful: ["openai/gpt-5.4-pro", "anthropic/claude-opus-4.6", "anthropic/claude-opus-4.5", "openai/o3", "openai/gpt-5.4"],
+  cheap: ["nvidia/gpt-oss-120b", "nvidia/deepseek-v3.2", "google/gemini-2.5-flash", "deepseek/deepseek-chat", "openai/gpt-5.4-nano"],
+  reasoning: ["openai/o3", "openai/o1", "openai/o3-mini", "deepseek/deepseek-reasoner", "openai/gpt-5.3-codex"],
+  free: ["nvidia/gpt-oss-120b", "nvidia/deepseek-v3.2", "nvidia/nemotron-ultra-253b", "nvidia/nemotron-super-49b", "nvidia/qwen3-coder-480b", "nvidia/llama-4-maverick", "nvidia/gpt-oss-20b"],
+  coding: ["openai/gpt-5.3-codex", "nvidia/qwen3-coder-480b", "nvidia/devstral-2-123b", "anthropic/claude-sonnet-4.6", "openai/gpt-5.4"]
+};
+
+// src/utils/wallet.ts
+var _walletWasCreated = false;
+var _walletAddress = null;
+var _client = null;
+var _imageClient = null;
+function getOrCreateWalletKey() {
+  const envKey = process.env.BLOCKRUN_WALLET_KEY || process.env.BASE_CHAIN_WALLET_KEY;
+  if (envKey) {
+    const account2 = privateKeyToAccount(envKey);
+    _walletAddress = account2.address;
+    return envKey;
+  }
+  if (fs.existsSync(WALLET_FILE)) {
+    try {
+      const savedKey = fs.readFileSync(WALLET_FILE, "utf-8").trim();
+      if (savedKey.startsWith("0x") && savedKey.length === 66) {
+        const account2 = privateKeyToAccount(savedKey);
+        _walletAddress = account2.address;
+        return savedKey;
+      }
+    } catch {
+    }
+  }
+  const newKey = generatePrivateKey();
+  const account = privateKeyToAccount(newKey);
+  _walletAddress = account.address;
+  _walletWasCreated = true;
+  try {
+    if (!fs.existsSync(WALLET_DIR)) {
+      fs.mkdirSync(WALLET_DIR, { recursive: true, mode: 448 });
+    }
+    fs.writeFileSync(WALLET_FILE, newKey, { mode: 384 });
+    console.error(`[BlockRun] New wallet created and saved to ${WALLET_FILE}`);
+  } catch (err) {
+    console.error(`[BlockRun] Warning: Could not save wallet to file: ${err}`);
+  }
+  return newKey;
+}
+function getClient() {
+  if (!_client) {
+    const privateKey = getOrCreateWalletKey();
+    _client = new LLMClient({ privateKey });
+  }
+  return _client;
+}
+function getImageClient() {
+  if (!_imageClient) {
+    const privateKey = getOrCreateWalletKey();
+    _imageClient = new ImageClient({ privateKey });
+  }
+  return _imageClient;
+}
+function getWalletInfo() {
+  const llm = getClient();
+  const address = llm.getWalletAddress();
+  return {
+    address,
+    network: "Base",
+    chainId: 8453,
+    currency: "USDC",
+    isNew: _walletWasCreated,
+    basescanUrl: `https://basescan.org/address/${address}`
+  };
+}
+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;
+}
+
+// src/tools/wallet.ts
+import { z } from "zod";
+
+// src/utils/qr.ts
+import QRCode from "qrcode";
+import { Jimp } from "jimp";
+import open from "open";
+import * as fs2 from "fs";
+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 (!fs2.existsSync(WALLET_DIR)) {
+    fs2.mkdirSync(WALLET_DIR, { recursive: true, mode: 448 });
+  }
+  await qrImage.write(QR_FILE);
+  return QR_FILE;
+}
+async function openQrInViewer(qrPath) {
+  try {
+    await open(qrPath);
+  } catch {
+  }
+}
+
+// src/utils/errors.ts
+function formatError(message) {
+  const msgLower = message.toLowerCase();
+  const isPaymentError = msgLower.includes("402") || msgLower.includes("balance") || msgLower.includes("insufficient") || msgLower.includes("payment") && !msgLower.includes("500");
+  const isServerError = msgLower.includes("500") || msgLower.includes("api error after payment");
+  let errorText = `Error: ${message}`;
+  if (isServerError) {
+    errorText += `
+
+This is a temporary API issue. The xAI/Grok API may be experiencing problems.
+Try again in a few minutes, or use a different model (e.g., openai/gpt-4o).`;
+  } else if (isPaymentError) {
+    errorText += `
+
+This error usually means your wallet needs funding.
+Run blockrun_wallet with action: "setup" to get funding instructions.
+
+Quick fix: Send USDC to your wallet on Base network.`;
+  }
+  return errorText;
+}
+
+// src/tools/wallet.ts
+function registerWalletTool(server, budget) {
+  server.registerTool(
+    "blockrun_wallet",
+    {
+      description: `Call this tool to manage the BlockRun payment wallet and control agent spending budgets.
+
+Call this FIRST if any other blockrun_* tool returns a payment/balance error.
+Call this to check your current USDC balance before expensive operations.
+Call this to set spending limits before spawning child agents.
+
+Actions:
+- status (default): Current wallet address, USDC balance, total session spending
+- setup: Get funding instructions + QR code (call this when balance is 0)
+- qr: Open QR code in system viewer
+
+Budget controls:
+- budget + budget_action:"set" + budget_amount:1.00 \u2192 Set global spend cap
+- budget + budget_action:"clear" \u2192 Remove global spend cap
+
+Multi-agent orchestration:
+- delegate + agent_id:"research" + agent_limit:2.00 \u2192 Allocate $2 to a child agent
+- revoke + agent_id:"research" \u2192 Remove a child agent's budget
+- report \u2192 See per-agent spending breakdown
+
+Usage pattern for multi-agent systems:
+  1. blockrun_wallet action:"delegate" agent_id:"worker-1" agent_limit:1.00
+  2. Pass agent_id:"worker-1" to all blockrun_chat/search/etc calls for that agent
+  3. blockrun_wallet action:"report" to audit spending
+
+Do NOT call this for actual AI queries \u2014 use blockrun_chat for that.`,
+      inputSchema: {
+        action: z.enum(["status", "setup", "qr", "budget", "delegate", "revoke", "report"]).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')"),
+        agent_id: z.string().optional().describe("Agent identifier for delegate/revoke/report actions"),
+        agent_limit: z.number().optional().describe("Budget limit in USD for this agent (required for delegate action)")
+      }
+    },
+    async ({ action, budget_action, budget_amount, agent_id, agent_limit }) => {
+      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
+            };
+          }
+          budget.limit = budget_amount;
+        } else if (budgetAct === "clear") {
+          budget.limit = null;
+        }
+        const remaining = budget.limit !== null ? budget.limit - budget.spent : null;
+        const limitStr = budget.limit !== null ? `$${budget.limit.toFixed(2)}` : "Unlimited";
+        const remainingStr = remaining !== null ? `$${remaining.toFixed(4)}` : "N/A";
+        return {
+          content: [{ type: "text", text: `Session Budget: ${limitStr} | Spent: $${budget.spent.toFixed(4)} | Calls: ${budget.calls} | Remaining: ${remainingStr}${budgetAct === "set" ? ` | Set to $${budget_amount?.toFixed(2)}` : ""}${budgetAct === "clear" ? " | Limit removed" : ""}` }],
+          structuredContent: {
+            limit: budget.limit,
+            spent: budget.spent,
+            calls: budget.calls,
+            remaining
+          }
+        };
+      }
+      if (action === "delegate") {
+        if (!agent_id) {
+          return { content: [{ type: "text", text: formatError("agent_id required for delegate action") }], isError: true };
+        }
+        if (!agent_limit || agent_limit <= 0) {
+          return { content: [{ type: "text", text: formatError("agent_limit (USD > 0) required for delegate action") }], isError: true };
+        }
+        budget.agents.set(agent_id, { limit: agent_limit, spent: 0, calls: 0 });
+        return {
+          content: [{ type: "text", text: `Agent "${agent_id}" allocated $${agent_limit.toFixed(2)} budget.
+Pass agent_id: "${agent_id}" in any blockrun_* tool call to track and enforce this limit.` }],
+          structuredContent: { agent_id, limit: agent_limit, spent: 0, calls: 0 }
+        };
+      }
+      if (action === "revoke") {
+        if (!agent_id) {
+          return { content: [{ type: "text", text: formatError("agent_id required for revoke action") }], isError: true };
+        }
+        const existed = budget.agents.has(agent_id);
+        budget.agents.delete(agent_id);
+        return {
+          content: [{ type: "text", text: existed ? `Agent "${agent_id}" budget revoked.` : `Agent "${agent_id}" had no budget entry.` }],
+          structuredContent: { agent_id, revoked: existed }
+        };
+      }
+      if (action === "report") {
+        const agentRows = {};
+        for (const [id, ab] of budget.agents.entries()) {
+          agentRows[id] = {
+            limit: ab.limit,
+            spent: ab.spent,
+            calls: ab.calls,
+            remaining: Math.max(0, ab.limit - ab.spent)
+          };
+        }
+        const agentLines = Object.entries(agentRows).map(
+          ([id, ab]) => `  ${id}: $${ab.spent.toFixed(4)}/$${ab.limit.toFixed(2)} (${ab.calls} calls, $${ab.remaining.toFixed(4)} remaining)`
+        );
+        const lines = [
+          `Global: $${budget.spent.toFixed(4)} spent${budget.limit ? ` / $${budget.limit.toFixed(2)} limit` : " (no limit)"} \u2014 ${budget.calls} calls`,
+          ``,
+          `Per-agent budgets (${budget.agents.size} active):`,
+          ...agentLines.length > 0 ? agentLines : ["  (none delegated)"]
+        ];
+        return {
+          content: [{ type: "text", text: lines.join("\n") }],
+          structuredContent: { global: { limit: budget.limit, spent: budget.spent, calls: budget.calls }, agents: agentRows }
+        };
+      }
+      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
+        }
+      };
+    }
+  );
+}
+
+// src/tools/chat.ts
+import { z as z2 } from "zod";
+
+// src/utils/budget.ts
+function checkBudget(budget, agentId) {
+  if (budget.limit !== null && budget.spent >= budget.limit) {
+    return {
+      allowed: false,
+      reason: `Global budget limit $${budget.limit.toFixed(2)} reached ($${budget.spent.toFixed(4)} spent)`
+    };
+  }
+  if (agentId) {
+    const agentBudget = budget.agents.get(agentId);
+    if (agentBudget && agentBudget.spent >= agentBudget.limit) {
+      return {
+        allowed: false,
+        reason: `Agent "${agentId}" budget $${agentBudget.limit.toFixed(2)} exhausted ($${agentBudget.spent.toFixed(4)} spent in ${agentBudget.calls} calls)`
+      };
+    }
+  }
+  return { allowed: true };
+}
+function recordSpending(budget, cost, agentId) {
+  budget.spent += cost;
+  budget.calls += 1;
+  if (agentId) {
+    const agentBudget = budget.agents.get(agentId);
+    if (agentBudget) {
+      agentBudget.spent += cost;
+      agentBudget.calls += 1;
+    }
+  }
+}
+
+// src/tools/chat.ts
+function registerChatTool(server, budget) {
+  server.registerTool(
+    "blockrun_chat",
+    {
+      description: `Chat with 41 AI models from 7 providers via BlockRun micropayments. No API keys needed.
+Recommended for agents: use routing: "smart" to auto-select the optimal model via ClawRouter.
+routing_profile: "free" (zero cost NVIDIA), "eco" (budget), "auto" (balanced, default), "premium" (best quality)
+
+Three ways to use:
+1. ClawRouter (recommended): routing: "smart" \u2014 auto-selects optimal model via 14-dimension AI routing
+2. Direct model: model: "openai/gpt-5.4"
+3. Smart routing: mode: "fast"|"balanced"|"powerful"|"cheap"|"reasoning"|"free"|"coding"
+4. Multi-turn: pass messages[] array (conversation history) \u2014 "message" is appended as the final user turn
+
+All providers (format: provider/model-id):
+\u2022 OpenAI (13): gpt-5.4, gpt-5.4-pro, gpt-5.3, gpt-5.2, gpt-5.4-mini, gpt-5-mini, gpt-5.4-nano, gpt-5.2-pro, gpt-5.3-codex, o1, o1-mini, o3, o3-mini
+\u2022 Anthropic (4): claude-haiku-4.5, claude-sonnet-4.6, claude-opus-4.5, claude-opus-4.6
+\u2022 Google (7): gemini-3.1-pro, gemini-3-pro-preview, gemini-3-flash-preview, gemini-2.5-pro, gemini-2.5-flash, gemini-3.1-flash-lite, gemini-2.5-flash-lite
+\u2022 DeepSeek (2): deepseek-chat, deepseek-reasoner
+\u2022 NVIDIA (12, most FREE*): gpt-oss-120b*, gpt-oss-20b*, kimi-k2.5, nemotron-ultra-253b*, nemotron-3-super-120b*, nemotron-super-49b*, deepseek-v3.2*, mistral-large-3-675b*, qwen3-coder-480b*, devstral-2-123b*, glm-4.7*, llama-4-maverick*
+\u2022 ZAI (2): glm-5, glm-5-turbo
+\u2022 MiniMax (1): minimax-m2.7
+
+Smart routing modes:
+- fast: Gemini Flash, GPT-5 Mini (lowest latency)
+- balanced: GPT-5.4, Claude Sonnet 4.6, Gemini Pro (best default)
+- powerful: GPT-5.4-Pro, Claude Opus 4.6 (highest quality)
+- cheap: NVIDIA free + DeepSeek (lowest cost)
+- reasoning: o3, o1, DeepSeek Reasoner (complex logic)
+- free: All free NVIDIA models (zero cost)
+- coding: GPT-5.3-Codex, Qwen3-Coder, Devstral (code tasks)
+
+Run blockrun_models for live pricing.`,
+      inputSchema: {
+        message: z2.string().describe("Your message to the AI"),
+        model: z2.string().optional().describe("Specific model ID (e.g., 'openai/gpt-4o')"),
+        mode: z2.enum(["fast", "balanced", "powerful", "cheap", "reasoning", "free", "coding"]).optional().describe("Smart routing mode (ignored if model specified)"),
+        routing: z2.enum(["smart"]).optional().describe('Set to "smart" to auto-select the optimal model via ClawRouter (14-dimension AI routing)'),
+        routing_profile: z2.enum(["free", "eco", "auto", "premium"]).optional().default("auto").describe('Cost/quality profile for ClawRouter: "free" (zero cost NVIDIA), "eco" (budget), "auto" (balanced, default), "premium" (best quality) (only applies when routing: "smart")'),
+        system: z2.string().optional().describe("Optional system prompt"),
+        max_tokens: z2.number().optional().default(1024).describe("Max tokens in response"),
+        temperature: z2.number().optional().default(1).describe("Creativity 0-2"),
+        agent_id: z2.string().optional().describe("Agent identifier. If a budget was delegated for this agent_id via blockrun_wallet action:'delegate', spending is tracked and enforced. The agent is hard-stopped when its budget is exhausted."),
+        messages: z2.array(z2.object({
+          role: z2.enum(["user", "assistant", "system"]),
+          content: z2.string()
+        })).optional().describe("Conversation history for multi-turn context. When provided, 'message' is appended as the final user turn. Use with explicit 'model' param (defaults to 'openai/gpt-5.4' if not specified). Note: if you include a role:'system' entry in messages[], do not also pass the system param to avoid duplicate system messages.")
+      }
+    },
+    async ({ message, model, mode, routing, routing_profile, system, max_tokens, temperature, agent_id, messages }) => {
+      const llm = getClient();
+      const budgetCheck = checkBudget(budget, agent_id);
+      if (!budgetCheck.allowed) {
+        return {
+          content: [{ type: "text", text: `${budgetCheck.reason}. Use blockrun_wallet with action: "report" to see usage, or action: "delegate" to increase agent budget.` }],
+          isError: true
+        };
+      }
+      if (routing === "smart") {
+        try {
+          const result = await llm.smartChat(message, {
+            system,
+            maxTokens: max_tokens,
+            temperature,
+            routingProfile: routing_profile
+          });
+          recordSpending(budget, result.routing.costEstimate || 1e-3, agent_id);
+          return {
+            content: [{ type: "text", text: `[${result.model} | ${result.routing.tier} | $${result.routing.costEstimate.toFixed(4)} | ${Math.round((result.routing.savings ?? 0) * 100)}% savings]
+
+${result.response}` }],
+            structuredContent: {
+              model_used: result.model,
+              response: result.response,
+              routing: result.routing
+            }
+          };
+        } catch (error) {
+          const errorMessage2 = error instanceof Error ? error.message : String(error);
+          return { content: [{ type: "text", text: formatError(errorMessage2) }], isError: true };
+        }
+      }
+      if (messages && messages.length > 0) {
+        const targetModel = model || MODEL_TIERS[mode ?? "balanced"]?.[0] || "openai/gpt-5.4";
+        const fullMessages = [
+          ...system ? [{ role: "system", content: system }] : [],
+          ...messages,
+          { role: "user", content: message }
+        ];
+        try {
+          const result = await llm.chatCompletion(targetModel, fullMessages, {
+            maxTokens: max_tokens,
+            temperature
+          });
+          const reply = result.choices?.[0]?.message?.content || "";
+          recordSpending(budget, 1e-3, agent_id);
+          return {
+            content: [{ type: "text", text: `[${targetModel} | ${fullMessages.length} msgs]
+
+${reply}` }],
+            structuredContent: { model_used: targetModel, response: reply, message_count: fullMessages.length }
+          };
+        } catch (error) {
+          const errorMessage2 = error instanceof Error ? error.message : String(error);
+          return { content: [{ type: "text", text: formatError(errorMessage2) }], isError: true };
+        }
+      }
+      if (model) {
+        try {
+          const response = await llm.chat(model, message, {
+            system,
+            maxTokens: max_tokens,
+            temperature
+          });
+          recordSpending(budget, 1e-3, agent_id);
+          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
+          });
+          recordSpending(budget, 1e-3, agent_id);
+          return {
+            content: [{ type: "text", text: `[${m}]
+
+${response}` }],
+            structuredContent: { model_used: m, response }
+          };
+        } catch (error) {
+          lastError = error;
+          continue;
+        }
+      }
+      const errorMessage = lastError?.message || "All models failed";
+      return {
+        content: [{ type: "text", text: formatError(errorMessage) }],
+        isError: true
+      };
+    }
+  );
+}
+
+// src/tools/models.ts
+import { z as z3 } from "zod";
+function registerModelsTool(server, modelCache) {
+  server.registerTool(
+    "blockrun_models",
+    {
+      description: "List available AI models with pricing. Use to discover models and compare costs.",
+      inputSchema: {
+        category: z3.enum(["all", "chat", "reasoning", "image", "embedding"]).optional().default("all").describe("Filter by category"),
+        provider: z3.string().optional().describe("Filter by provider (e.g., 'openai', 'anthropic')")
+      }
+    },
+    async ({ category, provider }) => {
+      const llm = getClient();
+      if (!modelCache.models) {
+        modelCache.models = await llm.listModels();
+        setTimeout(() => {
+          modelCache.models = null;
+        }, 5 * 60 * 1e3);
+      }
+      let models = modelCache.models;
+      if (provider) {
+        const p = provider.toLowerCase();
+        models = models.filter((m) => m.id.toLowerCase().startsWith(p + "/"));
+      }
+      if (category && category !== "all") {
+        if (category === "image") {
+          models = models.filter((m) => m.id.includes("dall-e") || m.id.includes("flux") || m.id.includes("banana"));
+        } else if (category === "embedding") {
+          models = models.filter((m) => m.id.includes("embed"));
+        } else {
+          models = models.filter((m) => m.categories?.includes(category));
+        }
+      }
+      const lines = models.map((m) => {
+        const input = m.inputPrice ? `$${m.inputPrice}/M in` : "";
+        const output = m.outputPrice ? `$${m.outputPrice}/M out` : "";
+        const pricing = [input, output].filter(Boolean).join(", ");
+        const ctx = m.contextWindow ? ` | ${Math.round(m.contextWindow / 1e3)}K ctx` : "";
+        const cats = m.categories?.length ? ` [${m.categories.join(", ")}]` : "";
+        return `- ${m.id}${pricing ? ` (${pricing})` : ""}${ctx}${cats}`;
+      });
+      return {
+        content: [{ type: "text", text: `Models (${models.length}):
+${lines.join("\n")}` }],
+        structuredContent: { count: models.length, models }
+      };
+    }
+  );
+}
+
+// src/tools/image.ts
+import { z as z4 } from "zod";
+function registerImageTool(server) {
+  server.registerTool(
+    "blockrun_image",
+    {
+      description: `Generate or edit images via BlockRun.
+
+Actions:
+- generate (default): Create image from text prompt
+- edit: Transform an existing image using img2img
+
+Generation models: openai/dall-e-3 ($0.04-0.08), together/flux-schnell ($0.02), google/nano-banana
+Edit models: openai/gpt-image-1 (default for edits)`,
+      inputSchema: {
+        prompt: z4.string().describe("Image description or edit instructions"),
+        action: z4.enum(["generate", "edit"]).optional().default("generate").describe("generate: create from text; edit: transform existing image"),
+        model: z4.enum(["openai/dall-e-3", "together/flux-schnell", "google/nano-banana", "openai/gpt-image-1"]).optional().describe("Model to use (default: dall-e-3 for generate, gpt-image-1 for edit)"),
+        image: z4.string().optional().describe("Source image for edit action: base64-encoded image or URL"),
+        size: z4.enum(["1024x1024", "1792x1024", "1024x1792"]).optional().default("1024x1024"),
+        quality: z4.enum(["standard", "hd"]).optional().default("standard")
+      }
+    },
+    async ({ prompt, action, model, image, size, quality }) => {
+      try {
+        const imgClient = getImageClient();
+        let response;
+        if (action === "edit") {
+          if (!image) {
+            return {
+              content: [{ type: "text", text: formatError("image parameter required for edit action (base64 or URL)") }],
+              isError: true
+            };
+          }
+          response = await imgClient.edit(prompt, image, {
+            model: model || "openai/gpt-image-1",
+            size
+          });
+        } else {
+          response = await imgClient.generate(prompt, {
+            model: model || "openai/dall-e-3",
+            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: `Image: ${imageUrl}
+Prompt: ${prompt}
+Model: ${model}` }],
+          structuredContent: { url: imageUrl, prompt, model }
+        };
+      } 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(`Image generation failed: ${errMsg}`) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/twitter.ts
+import { z as z5 } from "zod";
+function registerTwitterTool(server, budget) {
+  server.registerTool(
+    "blockrun_twitter",
+    {
+      description: `Search real-time X/Twitter via Grok. Use for trending topics, @handles, breaking news.`,
+      inputSchema: {
+        query: z5.string().describe("Search query (can include @handles, topics)"),
+        max_results: z5.number().optional().default(10).describe("Max results (1-25)")
+      }
+    },
+    async ({ query, max_results }) => {
+      const budgetCheck = checkBudget(budget);
+      if (!budgetCheck.allowed) {
+        return {
+          content: [{ type: "text", text: `Budget limit reached ($${budget.spent.toFixed(4)} of $${budget.limit?.toFixed(2)}). Use blockrun_wallet with action: "budget" to adjust.` }],
+          isError: true
+        };
+      }
+      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(budget, 2e-3);
+        return {
+          content: [{ type: "text", text: `[X/Twitter via Grok]
+
+${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
+        };
+      }
+    }
+  );
+}
+
+// src/tools/search.ts
+import { z as z6 } from "zod";
+function registerSearchTool(server) {
+  server.registerTool(
+    "blockrun_search",
+    {
+      description: `Real-time web, X/Twitter, and news search with AI-summarized results and citations.
+
+Sources: web, x (X/Twitter), news \u2014 defaults to all three.
+Pricing: ~$0.01/search
+
+Returns a summary with cited sources.`,
+      inputSchema: {
+        query: z6.string().describe("Search query"),
+        sources: z6.array(z6.enum(["web", "x", "news"])).optional().describe("Sources to search (default: web + x + news)"),
+        max_results: z6.number().optional().default(10).describe("Max results per source (1-20)"),
+        from_date: z6.string().optional().describe("Start date filter (YYYY-MM-DD)"),
+        to_date: z6.string().optional().describe("End date filter (YYYY-MM-DD)")
+      }
+    },
+    async ({ query, sources, max_results, from_date, to_date }) => {
+      try {
+        const llm = getClient();
+        const result = await llm.search(query, {
+          sources,
+          maxResults: max_results,
+          fromDate: from_date,
+          toDate: to_date
+        });
+        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
+        };
+      }
+    }
+  );
+}
+
+// src/tools/exa.ts
+import { z as z7 } from "zod";
+function registerExaTool(server) {
+  server.registerTool(
+    "blockrun_exa",
+    {
+      description: `Neural web search via Exa. 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)`,
+      inputSchema: {
+        action: z7.enum(["search", "answer", "contents", "similar"]).describe("Action to perform"),
+        query: z7.string().optional().describe("Natural language query (for search/answer)"),
+        url: z7.string().optional().describe("Reference URL to find similar pages (for similar action)"),
+        urls: z7.array(z7.string()).optional().describe("URLs to fetch content from (for contents action, up to 100)"),
+        num_results: z7.number().optional().describe("Number of results to return (default: 10)"),
+        category: z7.string().optional().describe("Category filter: 'news', 'research paper', 'company', 'tweet', 'github', 'pdf'"),
+        include_domains: z7.array(z7.string()).optional().describe("Only search within these domains"),
+        exclude_domains: z7.array(z7.string()).optional().describe("Exclude these domains from results")
+      }
+    },
+    async ({ action, query, url, urls, num_results, category, include_domains, exclude_domains }) => {
+      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}`);
+        }
+        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
+        };
+      }
+    }
+  );
+}
+
+// src/tools/markets.ts
+import { z as z8 } from "zod";
+function registerMarketsTool(server) {
+  server.registerTool(
+    "blockrun_markets",
+    {
+      description: `Prediction market data via Predexon. Real-time data from Polymarket, Kalshi, dFlow, and Binance Futures.
+
+Usage:
+- GET: blockrun_markets with path + optional params
+- POST: blockrun_markets with path + body
+
+Example paths:
+- "polymarket/events" \u2014 list active events
+- "polymarket/search" + params: { q: "bitcoin" } \u2014 search events
+- "kalshi/markets/KXBTC-25MAR14" \u2014 specific market
+- "polymarket/query" + body: { filter: "active", limit: 10 } \u2014 structured query
+
+Pricing: $0.001/GET, $0.005/POST`,
+      inputSchema: {
+        path: z8.string().describe("Endpoint path, e.g. 'polymarket/events', 'kalshi/markets/KXBTC-25MAR14'"),
+        params: z8.record(z8.string()).optional().describe("Query parameters for GET requests"),
+        body: z8.record(z8.unknown()).optional().describe("JSON body for POST queries (triggers pmQuery)")
+      }
+    },
+    async ({ path: path2, params, body }) => {
+      try {
+        const llm = getClient();
+        const result = body ? await llm.pmQuery(path2, body) : await llm.pm(path2, params);
+        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
+        };
+      }
+    }
+  );
+}
+
+// src/mcp-handler.ts
+function initializeMcpServer(server) {
+  const budget = { limit: null, spent: 0, calls: 0, agents: /* @__PURE__ */ new Map() };
+  const modelCache = { models: null };
+  registerWalletTool(server, budget);
+  registerChatTool(server, budget);
+  registerModelsTool(server, modelCache);
+  registerImageTool(server);
+  registerTwitterTool(server, budget);
+  registerSearchTool(server);
+  registerExaTool(server);
+  registerMarketsTool(server);
+  server.registerResource(
+    "wallet",
+    "blockrun://wallet",
+    { description: "Wallet address and status", mimeType: "application/json" },
+    async () => ({
+      contents: [{
+        uri: "blockrun://wallet",
+        mimeType: "application/json",
+        text: JSON.stringify(getWalletInfo(), null, 2)
+      }]
+    })
+  );
+  server.registerResource(
+    "models",
+    "blockrun://models",
+    { description: "Available AI models with pricing", mimeType: "application/json" },
+    async () => {
+      const llm = getClient();
+      if (!modelCache.models) {
+        modelCache.models = await llm.listModels();
+        setTimeout(() => {
+          modelCache.models = null;
+        }, 5 * 60 * 1e3);
+      }
+      return {
+        contents: [{
+          uri: "blockrun://models",
+          mimeType: "application/json",
+          text: JSON.stringify(modelCache.models, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+export {
+  initializeMcpServer
+};