@blockrun/mcp 0.6.8 → 0.7.0

package/dist/index.js

@@ -105,10 +105,11 @@ 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"],
+  cheap: ["zai/glm-5", "zai/glm-5-turbo", "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"]
+  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", "nvidia/glm-4.7"],
+  coding: ["zai/glm-5", "openai/gpt-5.3-codex", "nvidia/qwen3-coder-480b", "nvidia/devstral-2-123b", "anthropic/claude-sonnet-4.6", "openai/gpt-5.4"],
+  glm: ["zai/glm-5", "zai/glm-5-turbo", "nvidia/glm-4.7"]
 };
 
 // src/utils/qr.ts
@@ -398,17 +399,23 @@ function registerChatTool(server, budget) {
   server.registerTool(
     "blockrun_chat",
     {
-      description: `Get a second opinion from another AI model, or use a specialized model for a specific task. Useful when you want to cross-check analysis, use a reasoning model (o3, DeepSeek Reasoner) for hard problems, or use a free NVIDIA model for bulk tasks.
+      description: `Get a second opinion from another AI model, or use a specialized model for a specific task.
 
-Use routing:"smart" to auto-select the best model, or pick directly: model:"openai/o3", model:"deepseek/deepseek-reasoner", model:"nvidia/deepseek-v3.2" (free).
+Notable modes:
+- mode:"glm" \u2192 Zhipu GLM-5 / GLM-5-Turbo ($0.001/call, excellent for coding tasks, pays via USDC on BlockRun)
+- mode:"coding" \u2192 GLM-5 first, then code-specialized models
+- mode:"cheap" \u2192 GLM-5, NVIDIA free, DeepSeek
+- mode:"reasoning" \u2192 o3, o1, DeepSeek-R1
+- mode:"free" \u2192 NVIDIA models (no cost)
+- routing:"smart" \u2192 auto-select via ClawRouter
 
-Prefer blockrun_search or blockrun_exa for research \u2014 they're purpose-built for that.
+Pick directly: model:"zai/glm-5", model:"openai/o3", model:"nvidia/deepseek-v3.2" (free).
 
-Run blockrun_models to see all available models with pricing.`,
+Run blockrun_models to see all 41+ models with 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)"),
+        model: z2.string().optional().describe("Specific model ID (e.g., 'zai/glm-5', 'openai/o3')"),
+        mode: z2.enum(["fast", "balanced", "powerful", "cheap", "reasoning", "free", "coding", "glm"]).optional().describe("Routing mode: glm = Zhipu GLM-5/GLM-5-Turbo ($0.001/call, great for coding), coding = GLM-5 + code models, cheap = GLM-5 + budget, free = NVIDIA only (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"),
@@ -653,8 +660,148 @@ Error: ${errMsg}` }],
   );
 }
 
-// src/tools/search.ts
+// src/tools/music.ts
 import { z as z5 } from "zod";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  createPaymentPayload,
+  parsePaymentRequired,
+  extractPaymentDetails
+} from "@blockrun/llm";
+var BLOCKRUN_API = "https://blockrun.ai/api";
+var MUSIC_TIMEOUT = 2e5;
+function registerMusicTool(server) {
+  server.registerTool(
+    "blockrun_music",
+    {
+      description: `Generate music tracks via BlockRun x402.
+
+Generates a full-length ~3 minute MP3 track. Takes 1-3 minutes to complete.
+
+Models: minimax/music-2.5+ ($0.1575), minimax/music-2.5 ($0.1575)
+
+Returns a time-limited CDN URL \u2014 download immediately if you need to keep the file.`,
+      inputSchema: {
+        prompt: z5.string().describe("Music style, mood, or description. E.g. 'upbeat synthwave with neon pads', 'chill lo-fi beats', 'epic orchestral film score'"),
+        instrumental: z5.boolean().optional().default(true).describe("Generate without vocals (default: true)"),
+        lyrics: z5.string().optional().describe("Custom lyrics. Cannot be used with instrumental: true"),
+        model: z5.enum(["minimax/music-2.5+", "minimax/music-2.5"]).optional().default("minimax/music-2.5+").describe("Music model to use")
+      }
+    },
+    async ({ prompt, instrumental, lyrics, model }) => {
+      try {
+        if (instrumental && lyrics?.trim()) {
+          return {
+            content: [{ type: "text", text: formatError("Cannot specify lyrics when instrumental is true") }],
+            isError: true
+          };
+        }
+        const privateKey = getOrCreateWalletKey();
+        const account = privateKeyToAccount(privateKey);
+        const url = `${BLOCKRUN_API}/v1/audio/generations`;
+        const body = { model, prompt, instrumental };
+        if (lyrics?.trim()) body.lyrics = lyrics.trim();
+        const resp402 = await fetchWithTimeout(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        }, 15e3);
+        if (resp402.status !== 402) {
+          const data2 = await resp402.json();
+          throw new Error(`Expected 402, got ${resp402.status}: ${JSON.stringify(data2)}`);
+        }
+        const prHeader = resp402.headers.get("payment-required") || resp402.headers.get("PAYMENT-REQUIRED");
+        if (!prHeader) throw new Error("No PAYMENT-REQUIRED header in 402 response");
+        const paymentRequired = parsePaymentRequired(prHeader);
+        const details = extractPaymentDetails(paymentRequired);
+        const paymentPayload = await createPaymentPayload(
+          privateKey,
+          account.address,
+          details.recipient,
+          details.amount,
+          details.network || "eip155:8453",
+          {
+            resourceUrl: details.resource?.url || url,
+            resourceDescription: details.resource?.description || "BlockRun Music Generation",
+            maxTimeoutSeconds: details.maxTimeoutSeconds || 300,
+            extra: details.extra
+          }
+        );
+        const resp = await fetchWithTimeout(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "PAYMENT-SIGNATURE": paymentPayload
+          },
+          body: JSON.stringify(body)
+        }, MUSIC_TIMEOUT);
+        if (resp.status === 402) {
+          throw new Error("Payment rejected. Check your wallet balance.");
+        }
+        if (!resp.ok) {
+          const errBody = await resp.json().catch(() => ({ error: "Request failed" }));
+          throw new Error(`API error ${resp.status}: ${JSON.stringify(errBody)}`);
+        }
+        const data = await resp.json();
+        const track = data.data?.[0];
+        if (!track?.url) throw new Error("No track URL in response");
+        const txHash = resp.headers.get("X-Payment-Receipt") || resp.headers.get("x-payment-receipt");
+        const lines = [
+          `\u{1F3B5} Track ready!`,
+          `URL: ${track.url}`,
+          `Duration: ${track.duration_seconds ? `${track.duration_seconds}s` : "~3 min"}`,
+          `Model: ${data.model || model}`,
+          ...track.lyrics ? [`Lyrics: ${track.lyrics.slice(0, 200)}${track.lyrics.length > 200 ? "..." : ""}`] : [],
+          ...txHash ? [`Tx: ${txHash}`] : [],
+          ``,
+          `Note: This URL expires in ~24h. Download it now if you need to keep the file.`
+        ];
+        return {
+          content: [{ type: "text", text: lines.join("\n") }],
+          structuredContent: {
+            url: track.url,
+            duration_seconds: track.duration_seconds,
+            model: data.model || model,
+            ...track.lyrics ? { lyrics: track.lyrics } : {},
+            ...txHash ? { txHash } : {}
+          }
+        };
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        if (errMsg.includes("balance") || errMsg.includes("payment") || errMsg.includes("402") || errMsg.includes("rejected")) {
+          return {
+            content: [{ type: "text", text: `Music generation requires payment. Run blockrun_wallet with action: "setup" for funding instructions.
+Error: ${errMsg}` }],
+            isError: true
+          };
+        }
+        if (errMsg.includes("abort") || errMsg.includes("timeout") || errMsg.includes("Timeout")) {
+          return {
+            content: [{ type: "text", text: `Music generation timed out. This can happen during peak load \u2014 please try again.
+Error: ${errMsg}` }],
+            isError: true
+          };
+        }
+        return {
+          content: [{ type: "text", text: formatError(`Music generation failed: ${errMsg}`) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+async function fetchWithTimeout(url, options, timeoutMs) {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } finally {
+    clearTimeout(id);
+  }
+}
+
+// src/tools/search.ts
+import { z as z6 } from "zod";
 function registerSearchTool(server) {
   server.registerTool(
     "blockrun_search",
@@ -666,11 +813,11 @@ Pricing: ~$0.01/search
 
 Returns a summary with cited sources.`,
       inputSchema: {
-        query: z5.string().describe("Search query"),
-        sources: z5.array(z5.enum(["web", "x", "news"])).optional().describe("Sources to search (default: web + x + news)"),
-        max_results: z5.number().optional().default(10).describe("Max results per source (1-20)"),
-        from_date: z5.string().optional().describe("Start date filter (YYYY-MM-DD)"),
-        to_date: z5.string().optional().describe("End date filter (YYYY-MM-DD)")
+        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 }) => {
@@ -698,7 +845,7 @@ Returns a summary with cited sources.`,
 }
 
 // src/tools/exa.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function registerExaTool(server) {
   server.registerTool(
     "blockrun_exa",
@@ -711,14 +858,14 @@ Actions:
 - 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: z6.enum(["search", "answer", "contents", "similar"]).describe("Action to perform"),
-        query: z6.string().optional().describe("Natural language query (for search/answer)"),
-        url: z6.string().optional().describe("Reference URL to find similar pages (for similar action)"),
-        urls: z6.array(z6.string()).optional().describe("URLs to fetch content from (for contents action, up to 100)"),
-        num_results: z6.number().optional().describe("Number of results to return (default: 10)"),
-        category: z6.string().optional().describe("Category filter: 'news', 'research paper', 'company', 'tweet', 'github', 'pdf'"),
-        include_domains: z6.array(z6.string()).optional().describe("Only search within these domains"),
-        exclude_domains: z6.array(z6.string()).optional().describe("Exclude these domains from results")
+        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 }) => {
@@ -771,7 +918,7 @@ Actions:
 }
 
 // src/tools/markets.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function registerMarketsTool(server) {
   server.registerTool(
     "blockrun_markets",
@@ -786,9 +933,9 @@ Example paths:
 
 $0.001/call.`,
       inputSchema: {
-        path: z7.string().describe("Endpoint path, e.g. 'polymarket/events', 'kalshi/markets/KXBTC-25MAR14'"),
-        params: z7.record(z7.string(), z7.string()).optional().describe("Query parameters for GET requests"),
-        body: z7.any().optional().describe("JSON body for POST queries (triggers pmQuery)")
+        path: z8.string().describe("Endpoint path, e.g. 'polymarket/events', 'kalshi/markets/KXBTC-25MAR14'"),
+        params: z8.record(z8.string(), z8.string()).optional().describe("Query parameters for GET requests"),
+        body: z8.any().optional().describe("JSON body for POST queries (triggers pmQuery)")
       }
     },
     async ({ path: path2, params, body }) => {
@@ -811,7 +958,7 @@ $0.001/call.`,
 }
 
 // src/tools/dex.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function registerDexTool(server) {
   server.registerTool(
     "blockrun_dex",
@@ -828,10 +975,10 @@ Examples:
   blockrun_dex({ token: "So11...xxx" })    -> Get specific token data
   blockrun_dex({ symbol: "PEPE" })         -> Search by symbol`,
       inputSchema: {
-        query: z8.string().optional().describe("Search query (token name, symbol, or address)"),
-        token: z8.string().optional().describe("Token address for direct lookup"),
-        symbol: z8.string().optional().describe("Token symbol to search"),
-        chain: z8.string().optional().describe("Filter by chain (ethereum, solana, base, etc.)")
+        query: z9.string().optional().describe("Search query (token name, symbol, or address)"),
+        token: z9.string().optional().describe("Token address for direct lookup"),
+        symbol: z9.string().optional().describe("Token symbol to search"),
+        chain: z9.string().optional().describe("Filter by chain (ethereum, solana, base, etc.)")
       }
     },
     async ({ query, token, symbol, chain }) => {
@@ -891,6 +1038,175 @@ ${lines.join("\n\n")}` }],
   );
 }
 
+// src/tools/glm-vision.ts
+import { z as z10 } from "zod";
+var ZHIPU_BASE_URL = "https://open.bigmodel.cn/api/paas/v4";
+async function callGLMVision(model, prompt, imageUrl, thinking = false) {
+  const apiKey = process.env.ZHIPU_API_KEY;
+  if (!apiKey) throw new Error("ZHIPU_API_KEY environment variable is required for GLM Vision");
+  const payload = {
+    model,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "image_url", image_url: { url: imageUrl } },
+          { type: "text", text: prompt }
+        ]
+      }
+    ],
+    temperature: 0.8,
+    top_p: 0.6,
+    max_tokens: 16384,
+    stream: false
+  };
+  if (thinking || model.includes("thinking")) {
+    payload["thinking"] = { type: "enabled" };
+  }
+  const res = await fetch(`${ZHIPU_BASE_URL}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => res.statusText);
+    throw new Error(`GLM Vision API error ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  const choice = data.choices?.[0];
+  if (!choice) throw new Error("No response from GLM Vision");
+  if (choice.finish_reason === "sensitive") throw new Error("Content blocked by safety filter");
+  return choice.message.content;
+}
+async function callGLMOCR(fileUrl, startPage = 1, endPage) {
+  const apiKey = process.env.ZHIPU_API_KEY;
+  if (!apiKey) throw new Error("ZHIPU_API_KEY environment variable is required for GLM OCR");
+  const payload = {
+    model: "glm-ocr",
+    file: fileUrl,
+    return_crop_images: false,
+    need_layout_visualization: false,
+    start_page_id: startPage
+  };
+  if (endPage) payload["end_page_id"] = endPage;
+  const res = await fetch(`${ZHIPU_BASE_URL}/layout_parsing`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => res.statusText);
+    throw new Error(`GLM OCR API error ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  return data.markdown_result || data.choices?.[0]?.message?.content || JSON.stringify(data);
+}
+async function callGLMImageGen(prompt, size, quality) {
+  const apiKey = process.env.ZHIPU_API_KEY;
+  if (!apiKey) throw new Error("ZHIPU_API_KEY environment variable is required for GLM Image Gen");
+  const res = await fetch(`${ZHIPU_BASE_URL}/images/generations`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: "cogview-4-250304",
+      prompt,
+      size,
+      quality,
+      watermark_enabled: false
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => res.statusText);
+    throw new Error(`GLM Image API error ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  const url = data.data?.[0]?.url;
+  if (!url) throw new Error("No image URL in GLM response");
+  return url;
+}
+function registerGLMVisionTool(server) {
+  server.registerTool(
+    "blockrun_glm_vision",
+    {
+      description: `Analyze images and documents using Zhipu AI's GLM vision models.
+
+Requires ZHIPU_API_KEY environment variable.
+
+Actions:
+- caption: Describe what's in an image
+- analyze: Deep analysis of an image (objects, layout, text, colors)
+- grounding: Locate specific elements in an image (returns bounding boxes)
+- code: Generate code from a UI screenshot or mockup
+- ocr: Extract text from a document/PDF (use file URL)
+- imagegen: Generate an image using CogView-4
+
+Models:
+- glm-4.6v (default): Best quality vision model
+- glm-4.6v-flash: Faster, cheaper
+- glm-4.1v-thinking-flash: With reasoning/thinking
+
+Cost: Zhipu AI pricing (separate from BlockRun x402 \u2014 uses ZHIPU_API_KEY)`,
+      inputSchema: {
+        action: z10.enum(["caption", "analyze", "grounding", "code", "ocr", "imagegen"]).describe("Task to perform"),
+        image: z10.string().optional().describe("Image URL or base64 data URI (for vision actions)"),
+        prompt: z10.string().optional().describe("Custom prompt or question about the image. For imagegen: the image description"),
+        model: z10.enum(["glm-4.6v", "glm-4.6v-flash", "glm-4.1v-thinking-flash"]).optional().default("glm-4.6v").describe("Vision model to use"),
+        size: z10.enum(["1280x1280", "1280x720", "720x1280", "1024x1024"]).optional().default("1280x1280").describe("Image size (for imagegen)"),
+        quality: z10.enum(["hd", "standard"]).optional().default("hd").describe("Image quality (for imagegen)"),
+        start_page: z10.number().optional().default(1).describe("Start page for OCR (PDF)"),
+        end_page: z10.number().optional().describe("End page for OCR (PDF)")
+      }
+    },
+    async ({ action, image, prompt, model, size, quality, start_page, end_page }) => {
+      try {
+        if (action === "imagegen") {
+          const imagePrompt = prompt || image || "";
+          if (!imagePrompt) {
+            return { content: [{ type: "text", text: formatError("prompt is required for imagegen action") }], isError: true };
+          }
+          const url = await callGLMImageGen(imagePrompt, size ?? "1280x1280", quality ?? "hd");
+          return {
+            content: [{ type: "text", text: `Generated image: ${url}` }],
+            structuredContent: { url }
+          };
+        }
+        if (action === "ocr") {
+          const fileUrl = image || prompt;
+          if (!fileUrl) {
+            return { content: [{ type: "text", text: formatError("image (PDF URL) is required for OCR") }], isError: true };
+          }
+          const result2 = await callGLMOCR(fileUrl, start_page ?? 1, end_page);
+          return { content: [{ type: "text", text: result2 }] };
+        }
+        if (!image) {
+          return { content: [{ type: "text", text: formatError("image is required for vision actions") }], isError: true };
+        }
+        const actionPrompts = {
+          caption: "Describe this image concisely and accurately.",
+          analyze: "Analyze this image in detail: describe all visible objects, layout, colors, text, and any notable features.",
+          grounding: `Locate the following elements in the image and return their bounding boxes in [x1,y1,x2,y2] format (0-1000 normalized): ${prompt || "all interactive UI elements"}`,
+          code: "Generate complete, working code to replicate this UI. Use React + TypeScript + Tailwind CSS. Include all components, styling, and mock data visible in the screenshot."
+        };
+        const visionPrompt = actionPrompts[action] || prompt || actionPrompts.caption;
+        const result = await callGLMVision(model ?? "glm-4.6v", visionPrompt, image);
+        return { content: [{ type: "text", text: 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() };
@@ -899,10 +1215,14 @@ function initializeMcpServer(server) {
   registerChatTool(server, budget);
   registerModelsTool(server, modelCache);
   registerImageTool(server);
+  registerMusicTool(server);
   registerSearchTool(server);
   registerExaTool(server);
   registerMarketsTool(server);
   registerDexTool(server);
+  if (process.env.ZHIPU_API_KEY) {
+    registerGLMVisionTool(server);
+  }
   server.registerResource(
     "wallet",
     "blockrun://wallet",
@@ -939,7 +1259,7 @@ function initializeMcpServer(server) {
 }
 
 // src/index.ts
-var VERSION = "0.6.7";
+var VERSION = "0.6.8";
 async function checkForUpdate() {
   try {
     const resp = await fetch("https://registry.npmjs.org/@blockrun/mcp/latest", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockrun/mcp",
-  "version": "0.6.8",
+  "version": "0.7.0",
   "mcpName": "io.github.BlockRunAI/blockrun-mcp",
   "description": "BlockRun MCP Server - Give your AI agent web search, deep research, prediction markets, crypto data, X/Twitter intelligence. Paid via x402 micropayments.",
   "type": "module",