@blockrun/mcp 0.3.0 → 0.4.2

package/dist/index.js

@@ -4,26 +4,32 @@
 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"],
-  powerful: ["openai/gpt-5.2", "anthropic/claude-opus-4", "openai/o3"],
-  cheap: ["google/gemini-2.5-flash", "deepseek/deepseek-chat", "openai/gpt-4o-mini"],
-  reasoning: ["openai/o3", "openai/o1", "deepseek/deepseek-reasoner"]
+  fast: ["google/gemini-2.5-flash", "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"],
+  powerful: ["openai/gpt-5.4", "anthropic/claude-opus-4.6", "anthropic/claude-opus-4.5", "openai/o3"],
+  cheap: ["nvidia/gpt-oss-120b", "google/gemini-2.5-flash", "deepseek/deepseek-chat", "openai/gpt-5.4-nano"],
+  reasoning: ["openai/o3", "openai/o1", "openai/o3-mini", "deepseek/deepseek-reasoner"]
 };
 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,226 @@ function checkBudget() {
   const remaining = sessionBudget.limit - sessionBudget.spent;
   return { allowed: remaining > 0, remaining };
 }
+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;
+}
 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.
+    description: `Manage your BlockRun wallet - check status, get funding instructions, open QR code, or manage session budget.
 
-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
+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
 
-Use blockrun_models to see all available models with pricing.`,
+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.
+
+Two ways to use:
+1. Specify a model directly: model: "openai/gpt-5.4"
+2. Use smart routing: mode: "fast" | "balanced" | "powerful" | "cheap" | "reasoning"
+
+Popular models:
+- openai/gpt-5.4, openai/gpt-5.4-mini, openai/gpt-5.4-nano
+- anthropic/claude-opus-4.6, anthropic/claude-sonnet-4.6
+- 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-5 Mini (quickest)
+- balanced: GPT-5.4, Claude Sonnet 4.6 (good default)
+- powerful: GPT-5.4, Claude Opus 4.6 (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;
@@ -275,19 +404,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,234 +425,424 @@ 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")
-        );
-      } 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("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(", ");
-      return `- ${m.id}: ${m.name || ""} ${pricing ? `(${pricing})` : ""}`;
+      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}`;
     });
-    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) {
+    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: `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.` }],
+        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
       };
     }
-    if (!response.ok) {
+  }
+);
+server.registerTool(
+  "blockrun_twitter",
+  {
+    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 ({ query, max_results }) => {
+    const budget = checkBudget();
+    if (!budget.allowed) {
       return {
-        content: [{ type: "text", text: formatError(`Image generation failed: ${response.status}`) }],
+        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
       };
     }
-    const data = await response.json();
-    const imageUrl = data.data?.[0]?.url;
-    if (!imageUrl) {
+    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]
+
+${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("No image URL in response") }],
+        content: [{ type: "text", text: formatError(errorMessage) }],
         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_dex",
   {
-    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
-============================
+    description: `Get real-time DEX data from DexScreener. FREE - no payment required.
 
-Address: ${info.address}
-Network: ${info.network} (Chain ID: ${info.chainId})
-Currency: ${info.currency}
+Use for:
+- Token prices and liquidity across chains
+- Trading volume and price changes
+- Finding token pairs and contracts
 
-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
-`;
+Examples:
+  blockrun_dex({ query: "SOL" })           -> Search for SOL pairs
+  blockrun_dex({ token: "So11...xxx" })    -> Get specific token data
+  blockrun_dex({ symbol: "PEPE" })         -> Search by symbol`,
+    inputSchema: {
+      query: z.string().optional().describe("Search query (token name, symbol, or address)"),
+      token: z.string().optional().describe("Token address for direct lookup"),
+      symbol: z.string().optional().describe("Token symbol to search"),
+      chain: z.string().optional().describe("Filter by chain (ethereum, solana, base, etc.)")
     }
-    return {
-      content: [{ type: "text", text }],
-      structuredContent: {
-        address: info.address,
-        network: info.network,
-        chainId: info.chainId,
-        currency: info.currency,
-        isNew: info.isNew,
-        basescanUrl: info.basescanUrl
+  },
+  async ({ query, token, symbol, chain }) => {
+    try {
+      let url;
+      let searchTerm = query || symbol || "";
+      if (token) {
+        url = `https://api.dexscreener.com/latest/dex/tokens/${token}`;
+      } else if (searchTerm) {
+        url = `https://api.dexscreener.com/latest/dex/search?q=${encodeURIComponent(searchTerm)}`;
+      } else {
+        return {
+          content: [{ type: "text", text: "Provide query, token address, or symbol" }],
+          isError: true
+        };
       }
-    };
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`DexScreener API error: ${response.status}`);
+      }
+      const data = await response.json();
+      let pairs = data.pairs || [];
+      if (chain && pairs.length > 0) {
+        const chainLower = chain.toLowerCase();
+        pairs = pairs.filter((p) => p.chainId.toLowerCase().includes(chainLower));
+      }
+      pairs = pairs.sort((a, b) => (b.volume?.h24 || 0) - (a.volume?.h24 || 0)).slice(0, 10);
+      if (pairs.length === 0) {
+        return {
+          content: [{ type: "text", text: `No pairs found for: ${searchTerm || token}` }]
+        };
+      }
+      const lines = pairs.map((p) => {
+        const price = p.priceUsd ? `$${parseFloat(p.priceUsd).toFixed(6)}` : "N/A";
+        const change = p.priceChange?.h24 ? `${p.priceChange.h24 > 0 ? "+" : ""}${p.priceChange.h24.toFixed(2)}%` : "";
+        const vol = p.volume?.h24 ? `$${(p.volume.h24 / 1e6).toFixed(2)}M` : "";
+        const liq = p.liquidity?.usd ? `$${(p.liquidity.usd / 1e6).toFixed(2)}M liq` : "";
+        const buySell = p.txns?.h24 ? `${p.txns.h24.buys}B/${p.txns.h24.sells}S` : "";
+        return `${p.baseToken.symbol}/${p.quoteToken.symbol} (${p.chainId}/${p.dexId})
+  Price: ${price} ${change} | Vol: ${vol} | ${liq} | Txns: ${buySell}
+  Token: ${p.baseToken.address}`;
+      });
+      return {
+        content: [{ type: "text", text: `[DexScreener - FREE]
+
+${lines.join("\n\n")}` }],
+        structuredContent: { pairs, count: pairs.length }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `DexScreener error: ${errorMessage}` }],
+        isError: true
+      };
+    }
   }
 );
+var KNOWN_LABELS = {
+  "0x28c6c06298d514db089934071355e5743bf21d60": "Binance 14",
+  "0x21a31ee1afc51d94c2efccaa2092ad1028285549": "Binance 15",
+  "0xdfd5293d8e347dfe59e90efd55b2956a1343963d": "Binance 16",
+  "0x56eddb7aa87536c09ccc2793473599fd21a8b17f": "Binance 17",
+  "0x9696f59e4d72e237be84ffd425dcad154bf96976": "Binance 18",
+  "0x4976a4a02f38326660d17bf34b431dc6e2eb2327": "Binance 19",
+  "0xf977814e90da44bfa03b6295a0616a897441acec": "Binance 8",
+  "0x5a52e96bacdabb82fd05763e25335261b270efcb": "Binance",
+  "0x3f5ce5fbfe3e9af3971dd833d26ba9b5c936f0be": "Binance",
+  "0xd24400ae8bfebb18ca49be86258a3c749cf46853": "Gemini 2",
+  "0x6fc82a5fe25a5cdb58bc74600a40a69c065263f8": "Gemini 3",
+  "0x61edcdf5bb737adffe5043706e7c5bb1f1a56eea": "Gemini 4",
+  "0x07ee55aa48bb72dcc6e9d78256648910de513eca": "Gemini 5",
+  "0xdc76cd25977e0a5ae17155770273ad58648900d3": "Coinbase Prime",
+  "0xa9d1e08c7793af67e9d92fe308d5697fb81d3e43": "Coinbase 10",
+  "0x503828976d22510aad0201ac7ec88293211d23da": "Coinbase 2",
+  "0xddfabcdc4d8ffc6d5beaf154f18b778f892a0740": "Coinbase 3",
+  "0x3cd751e6b0078be393132286c442345e5dc49699": "Coinbase 4",
+  "0xb5d85cbf7cb3ee0d56b3bb207d5fc4b82f43f511": "Coinbase 5",
+  "0xeb2629a2734e272bcc07bda959863f316f4bd4cf": "Coinbase 6",
+  "0x02466e547bfdab679fc49e96bbfc62b9747d997c": "Coinbase 8",
+  "0xa090e606e30bd747d4e6245a1517ebe430f0057e": "Coinbase",
+  "0x8103683202aa8da10536036edef04cdd865c225e": "Kraken 13",
+  "0x6cc5f688a315f3dc28a7781717a9a798a59fda7b": "OKX 1",
+  "0x236f9f97e0e62388479bf9e5ba4889e46b0273c3": "OKX 2",
+  "0x5041ed759dd4afc3a72b8192c143f72f4724081a": "OKX 4",
+  "0x75e89d5979e4f6fba9f97c104c2f0afb3f1dcb88": "MEXC",
+  "0x0d0707963952f2fba59dd06f2b425ace40b492fe": "Gate.io",
+  "0x1c4b70a3968436b9a0a9cf5205c787eb81bb558c": "Gate.io 3",
+  "0xd793281182a0e3e023116004778f45c29fc14f19": "Gate.io 4",
+  "0x974caa59e49682cda0ad2bbe82983419a2ecc400": "HTX",
+  "0x0211f3cedbef3143223d3acf0e589747933e8527": "HTX 2",
+  "0x1062a747393198f70f71ec65a582423dba7e5ab3": "Bybit",
+  "0xee5b5b923ffce93a870b3104b7ca09c3db80047a": "Bybit 2",
+  "0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503": "Binance: Foundation",
+  "0xbe0eb53f46cd790cd13851d5eff43d12404d33e8": "Binance 7",
+  "0x40ec5b33f54e0e8a33a975908c5ba1c14e5bbbdf": "Polygon Bridge",
+  "0xa3a7b6f88361f48403514059f1f16c8e78d60eec": "Arbitrum Bridge",
+  "0x99c9fc46f92e8a1c0dec1b1747d010903e884be1": "Optimism Bridge",
+  "0x8315177ab297ba92a06054ce80a67ed4dbd7ed3a": "Arbitrum: Delayed Inbox",
+  "0x0000000000000000000000000000000000000000": "Null/Burn Address"
+};
+function getAddressLabel(address) {
+  const lower = address.toLowerCase();
+  return KNOWN_LABELS[lower] || shortenAddress(address);
+}
+function shortenAddress(address) {
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
 server.registerTool(
-  "blockrun_setup",
+  "blockrun_whale",
   {
-    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: {}
+    description: `Track large ETH transfers (whale movements). Uses BigQuery public data.
+
+Shows:
+- Large transfers (100+ ETH)
+- Exchange inflows/outflows
+- Labels for known addresses (Binance, Coinbase, etc.)
+
+Note: Requires GOOGLE_APPLICATION_CREDENTIALS env var for BigQuery auth.
+For MVP/demo: Returns simulated data if BigQuery not configured.`,
+    inputSchema: {
+      hours: z.number().optional().default(24).describe("Hours to look back (default: 24)"),
+      min_eth: z.number().optional().default(100).describe("Minimum ETH amount (default: 100)"),
+      limit: z.number().optional().default(20).describe("Max results (default: 20)")
+    }
   },
-  async () => {
-    getClient();
-    return { content: [{ type: "text", text: getWalletSetupInstructions() }] };
+  async ({ hours, min_eth, limit }) => {
+    const hasGoogleCreds = process.env.GOOGLE_APPLICATION_CREDENTIALS || process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
+    if (!hasGoogleCreds) {
+      const demoData = [
+        { from: "0xf977814e90da44bfa03b6295a0616a897441acec", to: "0x28c6c06298d514db089934071355e5743bf21d60", value: 5e3, time: "2h ago" },
+        { from: "0x503828976d22510aad0201ac7ec88293211d23da", to: "0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503", value: 3200, time: "4h ago" },
+        { from: "0x6cc5f688a315f3dc28a7781717a9a798a59fda7b", to: "0xd24400ae8bfebb18ca49be86258a3c749cf46853", value: 2100, time: "6h ago" },
+        { from: "0x1062a747393198f70f71ec65a582423dba7e5ab3", to: "0x99c9fc46f92e8a1c0dec1b1747d010903e884be1", value: 1800, time: "8h ago" },
+        { from: "0x75e89d5979e4f6fba9f97c104c2f0afb3f1dcb88", to: "0xa3a7b6f88361f48403514059f1f16c8e78d60eec", value: 1500, time: "12h ago" }
+      ];
+      const lines = demoData.map((t) => {
+        const fromLabel = getAddressLabel(t.from);
+        const toLabel = getAddressLabel(t.to);
+        return `${t.value.toLocaleString()} ETH | ${fromLabel} \u2192 ${toLabel} | ${t.time}`;
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `[Whale Tracker - DEMO MODE]
+\u26A0\uFE0F BigQuery not configured. Showing sample data.
+
+To enable real data:
+1. Create GCP project: console.cloud.google.com
+2. Enable BigQuery API
+3. Set GOOGLE_APPLICATION_CREDENTIALS env var
+
+Sample whale movements:
+${lines.join("\n")}
+
+Total: ${demoData.reduce((s, t) => s + t.value, 0).toLocaleString()} ETH across ${demoData.length} transfers`
+        }],
+        structuredContent: { demo: true, transfers: demoData }
+      };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: `[Whale Tracker]
+
+BigQuery credentials detected. Real-time query:
+- Looking back: ${hours}h
+- Min transfer: ${min_eth} ETH
+- Limit: ${limit} results
+
+Query would run:
+SELECT block_timestamp, from_address, to_address, value/1e18 as eth
+FROM \`bigquery-public-data.crypto_ethereum.transactions\`
+WHERE value > ${min_eth} * 1e18
+  AND block_timestamp > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL ${hours} HOUR)
+ORDER BY value DESC
+LIMIT ${limit}
+
+Note: Full BigQuery integration coming soon.`
+      }]
+    };
   }
 );
 server.registerTool(
-  "blockrun_twitter",
+  "blockrun_analyze",
   {
-    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: `Comprehensive trading analysis combining multiple data sources.
+
+Analyzes:
+- DEX data (price, volume, liquidity) via DexScreener
+- Twitter/X sentiment via Grok
+- Whale movements (if BigQuery configured)
+- AI synthesis of all data
+
+Example: blockrun_analyze({ token: "SOL", question: "Should I buy?" })`,
     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()
+      token: z.string().describe("Token symbol or address to analyze"),
+      question: z.string().optional().describe("Specific question (default: general analysis)"),
+      include_twitter: z.boolean().optional().default(true).describe("Include Twitter sentiment"),
+      include_whale: z.boolean().optional().default(false).describe("Include whale tracking")
     }
   },
-  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.` }],
-        isError: true
-      };
+  async ({ token, question, include_twitter, include_whale }) => {
+    const llm = getClient();
+    const analysisPrompt = question || `Provide comprehensive trading analysis for ${token}`;
+    let contextData = "";
+    try {
+      const dexUrl = `https://api.dexscreener.com/latest/dex/search?q=${encodeURIComponent(token)}`;
+      const dexResponse = await fetch(dexUrl);
+      const dexData = await dexResponse.json();
+      if (dexData.pairs && dexData.pairs.length > 0) {
+        const topPair = dexData.pairs[0];
+        contextData += `
+## DEX Data (DexScreener)
+`;
+        contextData += `- Token: ${topPair.baseToken.name} (${topPair.baseToken.symbol})
+`;
+        contextData += `- Price: $${parseFloat(topPair.priceUsd).toFixed(6)}
+`;
+        contextData += `- 24h Change: ${topPair.priceChange?.h24?.toFixed(2) || "N/A"}%
+`;
+        contextData += `- 24h Volume: $${((topPair.volume?.h24 || 0) / 1e6).toFixed(2)}M
+`;
+        contextData += `- Liquidity: $${((topPair.liquidity?.usd || 0) / 1e6).toFixed(2)}M
+`;
+        contextData += `- FDV: $${((topPair.fdv || 0) / 1e9).toFixed(2)}B
+`;
+        contextData += `- Chain: ${topPair.chainId}
+`;
+      }
+    } catch (err) {
+      contextData += `
+## DEX Data: Error fetching
+`;
+    }
+    if (include_twitter) {
+      try {
+        const twitterResponse = await llm.chat("xai/grok-3", `What are people saying about ${token} on Twitter/X right now? Focus on: sentiment, key influencers, trending topics, price predictions.`, {
+          system: "Real-time X/Twitter search. Provide factual summary of recent posts.",
+          search: true
+        });
+        contextData += `
+## Twitter/X Sentiment (via Grok)
+${twitterResponse}
+`;
+      } catch {
+        contextData += `
+## Twitter: Unable to fetch
+`;
+      }
+    }
+    if (include_whale) {
+      contextData += `
+## Whale Movements
+`;
+      contextData += `Note: BigQuery not configured. In production, this would show:
+`;
+      contextData += `- Large transfers to/from exchanges
+`;
+      contextData += `- Smart money wallet movements
+`;
+      contextData += `- Exchange inflow/outflow trends
+`;
     }
+    const synthesisPrompt = `You are a crypto trading analyst. Based on the following data, answer: "${analysisPrompt}"
+
+${contextData}
+
+Provide:
+1. Key findings (bullet points)
+2. Risk assessment (Low/Medium/High)
+3. Trading suggestion (if asked)
+4. What to watch for
+
+Be factual and balanced. Don't give financial advice, but provide analysis based on the data.`;
     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,
-        search: true
+      const analysis = await llm.chat("openai/gpt-4o", synthesisPrompt, {
+        system: "Expert crypto trading analyst. Provide data-driven analysis.",
+        maxTokens: 1500
       });
-      recordSpending(2e-3);
       return {
-        content: [{ type: "text", text: `[X/Twitter Search via Grok]
+        content: [{
+          type: "text",
+          text: `[BlockRun Trading Analysis: ${token}]
 
-${response}` }],
-        structuredContent: { query, model, response }
+${analysis}
+
+---
+Data sources: DexScreener${include_twitter ? ", Twitter/X (Grok)" : ""}${include_whale ? ", Whale Tracker" : ""}`
+        }],
+        structuredContent: { token, question: analysisPrompt, analysis }
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -543,141 +853,272 @@ ${response}` }],
     }
   }
 );
+function calculateEMA(prices, period) {
+  const k = 2 / (period + 1);
+  const ema = [prices[0]];
+  for (let i = 1; i < prices.length; i++) {
+    ema.push(prices[i] * k + ema[i - 1] * (1 - k));
+  }
+  return ema;
+}
+function calculateRSI(prices, period = 14) {
+  if (prices.length < period + 1) return 50;
+  let gains = 0, losses = 0;
+  for (let i = prices.length - period; i < prices.length; i++) {
+    const change = prices[i] - prices[i - 1];
+    if (change > 0) gains += change;
+    else losses -= change;
+  }
+  const avgGain = gains / period;
+  const avgLoss = losses / period;
+  if (avgLoss === 0) return 100;
+  const rs = avgGain / avgLoss;
+  return 100 - 100 / (1 + rs);
+}
+function calculateMACD(prices) {
+  const ema12 = calculateEMA(prices, 12);
+  const ema26 = calculateEMA(prices, 26);
+  const macdLine = ema12.map((v, i) => v - ema26[i]);
+  const signalLine = calculateEMA(macdLine.slice(-9), 9);
+  const macd = macdLine[macdLine.length - 1];
+  const signal = signalLine[signalLine.length - 1];
+  return { macd, signal, histogram: macd - signal };
+}
 server.registerTool(
-  "blockrun_balance",
+  "blockrun_signal",
   {
-    description: `Check your on-chain USDC balance on Base network.
+    description: `Generate trading signals using RSI + MACD + EMA strategy.
+
+Strategy (from freqtrade-strategies):
+- BUY when: RSI < 40 (oversold) + MACD > Signal + Price > EMA200
+- SELL when: RSI > 70 (overbought) or take profit/stop loss
 
-Returns:
-- Current USDC balance
-- Wallet address
-- Link to view on Basescan
+Returns: BUY / SELL / HOLD signal with confidence level.
 
-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()
+Example: blockrun_signal({ symbol: "BTCUSDT" })`,
+    inputSchema: {
+      symbol: z.string().describe("Trading pair (e.g., BTCUSDT, ETHUSDT, SOLUSDT)"),
+      timeframe: z.enum(["5m", "15m", "1h", "4h"]).optional().default("1h").describe("Candle timeframe")
     }
   },
-  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
-=======================
+  async ({ symbol, timeframe }) => {
+    try {
+      const url = `https://api.binance.com/api/v3/klines?symbol=${symbol.toUpperCase()}&interval=${timeframe}&limit=250`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Binance API error: ${response.status}`);
+      }
+      const candles = await response.json();
+      const closes = candles.map((c) => parseFloat(c[4]));
+      const currentPrice = closes[closes.length - 1];
+      const rsi = calculateRSI(closes);
+      const { macd, signal, histogram } = calculateMACD(closes);
+      const ema200 = calculateEMA(closes, 200);
+      const currentEMA200 = ema200[ema200.length - 1];
+      const ema50 = calculateEMA(closes, 50);
+      const currentEMA50 = ema50[ema50.length - 1];
+      let signalType = "HOLD";
+      let confidence = 0;
+      let reasons = [];
+      const rsiOversold = rsi < 40;
+      const macdBullish = macd > signal;
+      const aboveEMA200 = currentPrice > currentEMA200;
+      const aboveEMA50 = currentPrice > currentEMA50;
+      const rsiOverbought = rsi > 70;
+      const macdBearish = macd < signal;
+      const belowEMA200 = currentPrice < currentEMA200;
+      if (rsiOversold && macdBullish && aboveEMA200) {
+        signalType = "BUY";
+        confidence = 80;
+        reasons.push("RSI oversold (<40)");
+        reasons.push("MACD bullish crossover");
+        reasons.push("Price above EMA200 (uptrend)");
+        if (aboveEMA50) {
+          confidence += 10;
+          reasons.push("Price above EMA50 (strong)");
+        }
+      } else if (rsiOverbought || macdBearish && belowEMA200) {
+        signalType = "SELL";
+        confidence = rsiOverbought ? 75 : 60;
+        if (rsiOverbought) reasons.push("RSI overbought (>70)");
+        if (macdBearish) reasons.push("MACD bearish");
+        if (belowEMA200) reasons.push("Price below EMA200 (downtrend)");
+      } else {
+        signalType = "HOLD";
+        confidence = 50;
+        reasons.push("No clear signal");
+        if (rsi < 50 && macdBullish) reasons.push("Slight bullish bias");
+        if (rsi > 50 && macdBearish) reasons.push("Slight bearish bias");
+      }
+      const stopLoss = signalType === "BUY" ? currentPrice * 0.9 : null;
+      const takeProfit = signalType === "BUY" ? currentPrice * 1.2 : null;
+      const result = `[Trading Signal: ${symbol}]
 
-Address: ${address}
-Balance: ${balanceStr}
-Network: Base (Chain ID: 8453)
+Signal: ${signalType} (${confidence}% confidence)
+Price: $${currentPrice.toFixed(2)}
 
-View on Basescan: https://basescan.org/address/${address}
+Indicators:
+- RSI (14): ${rsi.toFixed(1)} ${rsi < 30 ? "\u{1F7E2} Oversold" : rsi > 70 ? "\u{1F534} Overbought" : "\u26AA Neutral"}
+- MACD: ${macd.toFixed(4)} | Signal: ${signal.toFixed(4)} | ${histogram > 0 ? "\u{1F7E2} Bullish" : "\u{1F534} Bearish"}
+- EMA 50: $${currentEMA50.toFixed(2)} ${currentPrice > currentEMA50 ? "\u{1F7E2} Above" : "\u{1F534} Below"}
+- EMA 200: $${currentEMA200.toFixed(2)} ${currentPrice > currentEMA200 ? "\u{1F7E2} Above" : "\u{1F534} Below"}
 
-${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}`
-      }
-    };
+Reasons:
+${reasons.map((r) => `\u2022 ${r}`).join("\n")}
+${signalType === "BUY" ? `
+Suggested:
+\u2022 Stop Loss: $${stopLoss?.toFixed(2)} (-10%)
+\u2022 Take Profit: $${takeProfit?.toFixed(2)} (+20%)` : ""}
+
+Strategy: RSI + MACD + EMA (freqtrade-strategies)
+Timeframe: ${timeframe}`;
+      return {
+        content: [{ type: "text", text: result }],
+        structuredContent: {
+          symbol,
+          signal: signalType,
+          confidence,
+          price: currentPrice,
+          indicators: { rsi, macd, signal, ema50: currentEMA50, ema200: currentEMA200 },
+          stopLoss,
+          takeProfit,
+          reasons
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `Signal error: ${errorMessage}` }],
+        isError: true
+      };
+    }
   }
 );
+var ZERO_X_API = "https://api.0x.org/swap/v1";
+var BASE_CHAIN_ID_NUM = 8453;
+var BASE_TOKENS = {
+  "ETH": "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+  "WETH": "0x4200000000000000000000000000000000000006",
+  "USDC": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  "USDbC": "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA",
+  "DAI": "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+  "cbETH": "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22"
+};
 server.registerTool(
-  "blockrun_budget",
+  "blockrun_swap",
   {
-    description: `Manage your session spending budget.
+    description: `Execute token swaps on Base network using 0x aggregator.
 
-Actions:
-- check: View current spending and budget status
-- set: Set a spending limit (e.g., $1.00)
-- clear: Remove spending limit (unlimited)
+\u26A0\uFE0F REAL MONEY - requires user confirmation before execution.
 
-Use this to control how much you spend per session on BlockRun API calls.`,
+Example: blockrun_swap({ from: "USDC", to: "ETH", amount: 10 })`,
     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()
+      from: z.string().describe("Token to sell (USDC, ETH, WETH, etc.)"),
+      to: z.string().describe("Token to buy"),
+      amount: z.number().describe("Amount in 'from' token"),
+      slippage: z.number().optional().default(0.5).describe("Max slippage % (default 0.5)"),
+      execute: z.boolean().optional().default(false).describe("Set true to execute (requires confirmation)")
     }
   },
-  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
+  async ({ from, to, amount, slippage, execute }) => {
+    const fromUpper = from.toUpperCase();
+    const toUpper = to.toUpperCase();
+    const fromToken = BASE_TOKENS[fromUpper];
+    const toToken = BASE_TOKENS[toUpper];
+    if (!fromToken) {
+      return {
+        content: [{ type: "text", text: `Unknown token: ${from}. Supported: ${Object.keys(BASE_TOKENS).join(", ")}` }],
+        isError: true
+      };
+    }
+    if (!toToken) {
+      return {
+        content: [{ type: "text", text: `Unknown token: ${to}. Supported: ${Object.keys(BASE_TOKENS).join(", ")}` }],
+        isError: true
+      };
+    }
+    const decimals = fromUpper === "USDC" || fromUpper === "USDbC" ? 6 : 18;
+    const amountWei = BigInt(Math.floor(amount * 10 ** decimals));
+    try {
+      const quoteUrl = `${ZERO_X_API}/quote?` + new URLSearchParams({
+        sellToken: fromToken,
+        buyToken: toToken,
+        sellAmount: amountWei.toString(),
+        slippagePercentage: (slippage / 100).toString(),
+        chainId: BASE_CHAIN_ID_NUM.toString()
+      });
+      const estimatedOutput = fromUpper === "USDC" ? amount / 3300 : amount * 3300;
+      const quoteResult = `[Swap Quote: ${fromUpper} \u2192 ${toUpper}]
+
+Sell: ${amount} ${fromUpper}
+Buy (est): ~${estimatedOutput.toFixed(6)} ${toUpper}
+Slippage: ${slippage}%
+Network: Base
+
+${execute ? "\u26A0\uFE0F EXECUTION REQUESTED" : "\u{1F4A1} Set execute: true to swap"}
+
+Note: Full 0x integration requires API key.
+For demo, this shows the quote flow.
+
+To execute:
+1. User confirms the swap
+2. Wallet signs transaction
+3. Swap executes on-chain
+4. Returns tx hash`;
+      if (execute) {
+        return {
+          content: [{
+            type: "text",
+            text: `\u26A0\uFE0F SWAP EXECUTION DISABLED FOR SAFETY
+
+To enable real swaps:
+1. Add 0x API key
+2. Implement transaction signing
+3. Add confirmation flow
+
+This is a demo. The swap would:
+\u2022 Sell ${amount} ${fromUpper}
+\u2022 Buy ~${estimatedOutput.toFixed(6)} ${toUpper}
+\u2022 Gas: ~$0.01 on Base`
+          }]
+        };
       }
-    };
+      return {
+        content: [{ type: "text", text: quoteResult }],
+        structuredContent: {
+          from: fromUpper,
+          to: toUpper,
+          sellAmount: amount,
+          buyAmount: estimatedOutput,
+          slippage,
+          execute: false
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        content: [{ type: "text", text: `Swap error: ${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) {
@@ -695,87 +1136,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);