@noelclaw/mcp 1.5.6 → 2.1.0

package/dist/tools/coder.js

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODER_TOOLS = void 0;
+exports.handleCoderTool = handleCoderTool;
+const zod_1 = require("zod");
+const BANKR_LLM_URL = "https://llm.bankr.bot/v1/chat/completions";
+const BANKR_MODEL = process.env.BANKR_MODEL ?? "grok-3";
+const CODER_SYSTEM = `You are Noel Coder — an expert software engineer embedded in the Noelclaw AI OS on Base chain.
+You specialize in:
+- Solidity smart contracts (ERC-20, ERC-721, DeFi hooks, Uniswap v3/v4 integrations)
+- TypeScript / React / Next.js frontend development
+- Convex backend (functions, schema, mutations, queries)
+- MCP (Model Context Protocol) server tools in TypeScript
+- Base chain ecosystem: 0x Protocol, Uniswap v3, ethers v6, wagmi v2
+
+Rules:
+- Output clean, production-ready code. No placeholders.
+- Add brief inline comments only where logic is non-obvious.
+- For smart contracts: always include NatSpec, SPDX license, pragma.
+- For React: use TypeScript, functional components, Tailwind CSS.
+- For MCP tools: follow the Noelclaw pattern (Zod schema, handler returns ToolResult | null).
+- Never include secrets or private keys in output.`;
+async function callLLM(systemPrompt, userPrompt, maxTokens = 4096) {
+    const key = process.env.BANKR_API_KEY;
+    if (!key)
+        throw new Error("BANKR_API_KEY not set — add it to your .env");
+    const res = await fetch(BANKR_LLM_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-API-Key": key },
+        body: JSON.stringify({
+            model: BANKR_MODEL,
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: userPrompt },
+            ],
+            max_tokens: maxTokens,
+        }),
+        signal: AbortSignal.timeout(90000),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`LLM error ${res.status}: ${body.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return data.choices?.[0]?.message?.content ?? "";
+}
+function ok(text) {
+    return { content: [{ type: "text", text }] };
+}
+function err(text) {
+    return { content: [{ type: "text", text }], isError: true };
+}
+// ── Tool definitions ──────────────────────────────────────────────────────────
+exports.CODER_TOOLS = [
+    {
+        name: "scaffold_project",
+        description: "Generate a complete project scaffold for a described idea — file tree + key file contents. " +
+            "Supports: Solidity contract projects, MCP skill packages, React/Next.js dApps, Convex backends, CLI tools.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "What to build — be specific: tech stack, purpose, target chain, key features",
+                },
+                stack: {
+                    type: "string",
+                    enum: ["solidity", "mcp-skill", "react-dapp", "convex-backend", "node-cli", "auto"],
+                    description: "Tech stack. Use 'auto' to let Noel decide based on description.",
+                },
+                extras: {
+                    type: "string",
+                    description: "Optional: extra requirements, constraints, or preferred libraries",
+                },
+            },
+            required: ["description"],
+        },
+    },
+    {
+        name: "generate_component",
+        description: "Generate a production-ready React/TypeScript component. Returns the full .tsx file content. " +
+            "Includes props typing, Tailwind styling, and any hooks needed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "What the component does, what it shows, and how it should behave",
+                },
+                name: {
+                    type: "string",
+                    description: "Component name in PascalCase, e.g. 'TokenPriceCard'",
+                },
+                context: {
+                    type: "string",
+                    description: "Optional: existing imports, store usage, or API calls the component should use",
+                },
+            },
+            required: ["description", "name"],
+        },
+    },
+    {
+        name: "generate_contract",
+        description: "Generate a Solidity smart contract from a description. Returns the full .sol file. " +
+            "Follows OpenZeppelin patterns, includes NatSpec, and is Base/EVM compatible.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "What the contract does — token type, mechanics, access control, any special logic",
+                },
+                name: {
+                    type: "string",
+                    description: "Contract name in PascalCase, e.g. 'NoelRewards'",
+                },
+                features: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: specific features to include, e.g. ['ERC-20', 'burnable', 'pausable', 'ownable']",
+                },
+            },
+            required: ["description", "name"],
+        },
+    },
+    {
+        name: "audit_contract",
+        description: "Audit a Solidity smart contract for security vulnerabilities, gas inefficiencies, and logic bugs. " +
+            "Returns a structured report with severity ratings and fix recommendations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The full Solidity contract source code to audit",
+                },
+                focus: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: specific areas to focus on, e.g. ['reentrancy', 'access control', 'overflow']",
+                },
+            },
+            required: ["code"],
+        },
+    },
+    {
+        name: "explain_code",
+        description: "Explain what a piece of code does in plain language. Works with Solidity, TypeScript, JavaScript, Python, and more. " +
+            "Breaks down logic, highlights key patterns, and explains the 'why' behind decisions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The code to explain",
+                },
+                depth: {
+                    type: "string",
+                    enum: ["overview", "detailed", "line-by-line"],
+                    description: "How detailed the explanation should be. Default: 'detailed'",
+                },
+            },
+            required: ["code"],
+        },
+    },
+    {
+        name: "review_code",
+        description: "Review and improve a piece of code. Returns the improved version with a summary of changes. " +
+            "Fixes bugs, improves readability, adds types, optimizes gas (for Solidity), and removes anti-patterns.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The code to review and improve",
+                },
+                language: {
+                    type: "string",
+                    description: "Language/framework, e.g. 'solidity', 'typescript', 'react', 'python'. Auto-detected if omitted.",
+                },
+                goals: {
+                    type: "string",
+                    description: "Optional: specific improvement goals, e.g. 'reduce gas costs', 'improve readability', 'add error handling'",
+                },
+            },
+            required: ["code"],
+        },
+    },
+];
+// ── Handlers ──────────────────────────────────────────────────────────────────
+const ScaffoldSchema = zod_1.z.object({
+    description: zod_1.z.string().min(10),
+    stack: zod_1.z.enum(["solidity", "mcp-skill", "react-dapp", "convex-backend", "node-cli", "auto"]).optional(),
+    extras: zod_1.z.string().optional(),
+});
+const ComponentSchema = zod_1.z.object({
+    description: zod_1.z.string().min(5),
+    name: zod_1.z.string().min(1),
+    context: zod_1.z.string().optional(),
+});
+const ContractSchema = zod_1.z.object({
+    description: zod_1.z.string().min(5),
+    name: zod_1.z.string().min(1),
+    features: zod_1.z.array(zod_1.z.string()).optional(),
+});
+const AuditSchema = zod_1.z.object({
+    code: zod_1.z.string().min(10),
+    focus: zod_1.z.array(zod_1.z.string()).optional(),
+});
+const ExplainSchema = zod_1.z.object({
+    code: zod_1.z.string().min(1),
+    depth: zod_1.z.enum(["overview", "detailed", "line-by-line"]).optional(),
+});
+const ReviewSchema = zod_1.z.object({
+    code: zod_1.z.string().min(1),
+    language: zod_1.z.string().optional(),
+    goals: zod_1.z.string().optional(),
+});
+async function handleCoderTool(name, args) {
+    switch (name) {
+        case "scaffold_project": {
+            const p = ScaffoldSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { description, stack = "auto", extras } = p.data;
+            const prompt = `Generate a complete project scaffold for the following:\n\n` +
+                `Description: ${description}\n` +
+                `Stack: ${stack}\n` +
+                (extras ? `Extra requirements: ${extras}\n` : "") +
+                `\nOutput format:\n` +
+                `1. Brief overview (2-3 sentences)\n` +
+                `2. Full file tree with all files listed\n` +
+                `3. Full content of each key file (package.json, main entry, config, one core module)\n` +
+                `4. Setup instructions (3-5 steps)\n\n` +
+                `Use real, runnable code. No TODO placeholders.`;
+            try {
+                const response = await callLLM(CODER_SYSTEM, prompt, 4096);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`scaffold_project failed: ${e.message}`);
+            }
+        }
+        case "generate_component": {
+            const p = ComponentSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { description, name: componentName, context } = p.data;
+            const prompt = `Generate a production-ready React TypeScript component.\n\n` +
+                `Component name: ${componentName}\n` +
+                `Description: ${description}\n` +
+                (context ? `Context / existing code to integrate with:\n${context}\n` : "") +
+                `\nRequirements:\n` +
+                `- Full .tsx file, no omissions\n` +
+                `- TypeScript props interface\n` +
+                `- Tailwind CSS for styling\n` +
+                `- Use lucide-react for icons if needed\n` +
+                `- Framer Motion for animations if the component is interactive\n` +
+                `- Named export (not default)\n` +
+                `Output only the .tsx file content, no prose before or after.`;
+            try {
+                const response = await callLLM(CODER_SYSTEM, prompt, 3000);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`generate_component failed: ${e.message}`);
+            }
+        }
+        case "generate_contract": {
+            const p = ContractSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { description, name: contractName, features = [] } = p.data;
+            const prompt = `Generate a production-ready Solidity smart contract.\n\n` +
+                `Contract name: ${contractName}\n` +
+                `Description: ${description}\n` +
+                (features.length ? `Required features: ${features.join(", ")}\n` : "") +
+                `\nRequirements:\n` +
+                `- Solidity ^0.8.20\n` +
+                `- SPDX-License-Identifier: MIT\n` +
+                `- Use OpenZeppelin contracts where appropriate (import paths: @openzeppelin/contracts/...)\n` +
+                `- Full NatSpec comments on all public functions\n` +
+                `- Optimized for Base chain (EVM compatible)\n` +
+                `- Include events for all state changes\n` +
+                `- Include a basic test outline as a comment at the bottom\n` +
+                `Output only the .sol file content.`;
+            try {
+                const response = await callLLM(CODER_SYSTEM, prompt, 3500);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`generate_contract failed: ${e.message}`);
+            }
+        }
+        case "audit_contract": {
+            const p = AuditSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { code, focus = [] } = p.data;
+            const prompt = `Audit the following Solidity smart contract for security vulnerabilities, gas issues, and logic bugs.\n` +
+                (focus.length ? `Focus areas: ${focus.join(", ")}\n` : "") +
+                `\nContract:\n\`\`\`solidity\n${code}\n\`\`\`\n\n` +
+                `Output a structured audit report with these sections:\n` +
+                `## Summary\n` +
+                `(overall risk rating: Critical/High/Medium/Low/Informational, brief overview)\n\n` +
+                `## Findings\n` +
+                `For each issue:\n` +
+                `- **[SEVERITY]** Title\n` +
+                `  - Location: (function/line)\n` +
+                `  - Description: (what's wrong and why)\n` +
+                `  - Recommendation: (exact fix or mitigation)\n\n` +
+                `## Gas Optimizations\n` +
+                `(list 2-5 concrete gas savings with estimated impact)\n\n` +
+                `## Positive Patterns\n` +
+                `(what the contract does well)`;
+            try {
+                const response = await callLLM(CODER_SYSTEM, prompt, 3000);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`audit_contract failed: ${e.message}`);
+            }
+        }
+        case "explain_code": {
+            const p = ExplainSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { code, depth = "detailed" } = p.data;
+            const depthInstructions = {
+                overview: "Give a high-level explanation in 3-5 sentences. What does it do, what problem does it solve, what are the main moving parts.",
+                detailed: "Explain the purpose, break down each major section, explain key patterns and design decisions, and note any non-obvious logic.",
+                "line-by-line": "Go through the code line by line (or block by block for repetitive parts), explaining exactly what each part does and why.",
+            };
+            const prompt = `Explain the following code.\n\nDepth: ${depth}\n${depthInstructions[depth]}\n\n` +
+                `Code:\n\`\`\`\n${code}\n\`\`\`\n\n` +
+                `Write in plain language. Assume the reader understands programming but may not know this specific codebase or language.`;
+            try {
+                const response = await callLLM(CODER_SYSTEM, prompt, 2000);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`explain_code failed: ${e.message}`);
+            }
+        }
+        case "review_code": {
+            const p = ReviewSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { code, language, goals } = p.data;
+            const prompt = `Review and improve the following code.\n` +
+                (language ? `Language/framework: ${language}\n` : "") +
+                (goals ? `Improvement goals: ${goals}\n` : "") +
+                `\nOriginal code:\n\`\`\`\n${code}\n\`\`\`\n\n` +
+                `Output:\n` +
+                `## What I changed\n` +
+                `(bullet list: each change and why)\n\n` +
+                `## Improved code\n` +
+                `\`\`\`\n(full improved code — no omissions, no "rest of code unchanged")\n\`\`\`\n\n` +
+                `## Further recommendations\n` +
+                `(optional: things to consider beyond this snippet)`;
+            try {
+                const response = await callLLM(CODER_SYSTEM, prompt, 3500);
+                return ok(response);
+            }
+            catch (e) {
+                return err(`review_code failed: ${e.message}`);
+            }
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/defi.js

@@ -6,6 +6,24 @@ const zod_1 = require("zod");
 const convex_js_1 = require("../convex.js");
 const wallet_js_1 = require("../wallet.js");
 exports.DEFI_TOOLS = [
+    {
+        name: "get_portfolio",
+        description: "Get current token balances and total portfolio value for your MCP wallet on Base. Always call this before swapping to confirm available balance.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "estimate_swap",
+        description: "Preview a swap — get the expected output amount and price impact without executing. Use this before swap_tokens to confirm the rate is acceptable.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                fromToken: { type: "string", description: "Token to sell: ETH, USDC, USDT, DAI, WETH" },
+                toToken: { type: "string", description: "Token to buy: ETH, USDC, USDT, DAI, WETH" },
+                amount: { type: "string", description: "Amount to swap (e.g. '0.01', '50', '100%')" },
+            },
+            required: ["fromToken", "toToken", "amount"],
+        },
+    },
     {
         name: "swap_tokens",
         description: "Swap tokens on Base mainnet via 0x Permit2. Supported: ETH, USDC, USDT, DAI, WETH. Amount is human-readable. Signed and broadcast locally from your wallet.",
@@ -32,11 +50,65 @@ exports.DEFI_TOOLS = [
             required: ["token", "toAddress", "amount"],
         },
     },
+    {
+        name: "scan_wallet",
+        description: "AI-powered portfolio scan — concentration risk, volatility exposure, Base ecosystem opportunities, and a concrete 3-step action plan based on your actual holdings. Requires wallet auth.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
 ];
 const SwapSchema = zod_1.z.object({ fromToken: zod_1.z.string().min(1), toToken: zod_1.z.string().min(1), amount: zod_1.z.string().min(1) });
 const SendSchema = zod_1.z.object({ token: zod_1.z.string().min(1), toAddress: zod_1.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a valid 0x address"), amount: zod_1.z.string().min(1) });
+const BUY_DECIMALS = { USDC: 6, USDT: 6, DAI: 18, ETH: 18, WETH: 18 };
+function formatTokenAmount(raw, token) {
+    const dec = BUY_DECIMALS[token.toUpperCase()] ?? 18;
+    return (parseInt(raw) / Math.pow(10, dec)).toFixed(dec === 6 ? 2 : 6);
+}
 async function handleDefiTool(name, args) {
     switch (name) {
+        case "get_portfolio": {
+            const result = await (0, convex_js_1.callConvex)("/mcp/defi/portfolio", "GET", undefined, "get_portfolio");
+            if (result.error)
+                return { content: [{ type: "text", text: `Portfolio fetch failed: ${result.error}` }], isError: true };
+            const balances = result.balances ?? [];
+            const totalUsd = result.totalUsd ?? balances.reduce((s, b) => s + (b.valueUsd ?? 0), 0);
+            if (!balances.length) {
+                return { content: [{ type: "text", text: "Your wallet has no tokens yet. Send ETH or USDC on Base to get started." }] };
+            }
+            const lines = [`**Portfolio** — Total: $${totalUsd.toFixed(2)}`, ""];
+            for (const b of balances) {
+                const value = b.valueUsd != null ? ` ($${Number(b.valueUsd).toFixed(2)})` : "";
+                lines.push(`• **${b.token ?? b.symbol}**: ${Number(b.balance ?? b.amount).toLocaleString(undefined, { maximumFractionDigits: 6 })}${value}`);
+            }
+            lines.push("", `Wallet: \`${result.address ?? "unknown"}\``);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "estimate_swap": {
+            const parsed = SwapSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${String(parsed.error.issues[0].path[0])} ${parsed.error.issues[0].message}` }], isError: true };
+            const { fromToken, toToken, amount } = parsed.data;
+            const result = await (0, convex_js_1.callConvex)("/mcp/defi/swap", "POST", { fromToken, toToken, amount }, "estimate_swap");
+            if (!result.success)
+                return { content: [{ type: "text", text: `Estimate failed: ${result.error}` }], isError: true };
+            const q = result.quote;
+            const buyHuman = formatTokenAmount(q.buyAmount, q.buyToken ?? toToken);
+            const sellHuman = formatTokenAmount(q.sellAmount ?? "0", q.sellToken ?? fromToken);
+            const priceImpact = q.estimatedPriceImpact != null ? `${Number(q.estimatedPriceImpact).toFixed(3)}%` : "< 0.01%";
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `**Swap Estimate** (not executed)`,
+                            ``,
+                            `You sell: **${sellHuman} ${(q.sellToken ?? fromToken).toUpperCase()}**`,
+                            `You get:  **~${buyHuman} ${(q.buyToken ?? toToken).toUpperCase()}**`,
+                            `Price impact: ${priceImpact}`,
+                            ``,
+                            `Run \`swap_tokens\` with the same params to execute.`,
+                        ].join("\n"),
+                    }],
+            };
+        }
         case "swap_tokens": {
             const parsed = SwapSchema.safeParse(args);
             if (!parsed.success)
@@ -47,7 +119,7 @@ async function handleDefiTool(name, args) {
             if (!result.success)
                 return { content: [{ type: "text", text: `Swap failed: ${result.error}` }], isError: true };
             const txHash = await (0, wallet_js_1.signAndBroadcast)(wallet, result.quote);
-            const buyAmountHuman = (parseInt(result.quote.buyAmount) / 1e6).toFixed(4);
+            const buyAmountHuman = formatTokenAmount(result.quote.buyAmount, result.quote.buyToken ?? toToken);
             return {
                 content: [{
                         type: "text",
@@ -78,6 +150,39 @@ async function handleDefiTool(name, args) {
                     }],
             };
         }
+        case "scan_wallet": {
+            const data = await (0, convex_js_1.callConvex)("/wallet/scan", "GET", undefined, "scan_wallet");
+            if (data.error) {
+                return { content: [{ type: "text", text: `Scan failed: ${data.error}` }], isError: true };
+            }
+            const total = (data.totalUsd ?? 0).toFixed(2);
+            const topHoldings = (data.holdings ?? [])
+                .slice(0, 5)
+                .map((h) => `• **${h.token}**: $${(h.valueUsd ?? 0).toFixed(2)}${h.pct != null ? ` (${h.pct}%)` : ""}`)
+                .join("\n");
+            const header = [
+                `**Portfolio Scan** — Total: $${total}`,
+                `Wallet: \`${data.address ?? "unknown"}\``,
+                ``,
+                `**Holdings:**`,
+                topHoldings,
+                ``,
+            ].join("\n");
+            let body;
+            if (data.analysis) {
+                body = data.analysis;
+            }
+            else if (data.analysisError) {
+                body = `*AI analysis unavailable: ${data.analysisError}*`;
+            }
+            else {
+                body = "*AI analysis not available*";
+            }
+            const footer = data.tokensUsed
+                ? `\n\n*Tokens used: ${data.tokensUsed} · Scanned: ${data.scannedAt ?? ""}*`
+                : "";
+            return { content: [{ type: "text", text: header + body + footer }] };
+        }
         default:
             return null;
     }

package/dist/tools/humanizer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HUMANIZER_TOOLS = void 0;
 exports.handleHumanizerTool = handleHumanizerTool;
+const zod_1 = require("zod");
 exports.HUMANIZER_TOOLS = [
     {
         name: "humanize_text",
@@ -25,6 +26,12 @@ exports.HUMANIZER_TOOLS = [
         },
     },
 ];
+const HumanizerSchema = zod_1.z.object({
+    text: zod_1.z.string().min(1),
+    voice_sample: zod_1.z.string().optional(),
+});
+const BANKR_LLM_URL = "https://llm.bankr.bot/v1/chat/completions";
+const BANKR_MODEL = process.env.BANKR_MODEL ?? "grok-3";
 const HUMANIZER_SYSTEM = `You are a text editor that removes signs of AI-generated writing.
 
 Your job: rewrite the input so it sounds natural, direct, and human — without changing the meaning.
@@ -75,26 +82,27 @@ If a voice sample is provided, match its tone, rhythm, and vocabulary. Otherwise
 async function handleHumanizerTool(name, args) {
     if (name !== "humanize_text")
         return null;
-    const a = (args ?? {});
-    if (!a.text?.trim()) {
-        return { content: [{ type: "text", text: "text is required" }], isError: true };
+    const parsed = HumanizerSchema.safeParse(args);
+    if (!parsed.success) {
+        return { content: [{ type: "text", text: `Invalid input: text ${parsed.error.issues[0].message}` }], isError: true };
     }
-    const apiKey = process.env.MINIMAX_API_KEY;
+    const { text, voice_sample } = parsed.data;
+    const apiKey = process.env.BANKR_API_KEY;
     if (!apiKey) {
-        return { content: [{ type: "text", text: "MINIMAX_API_KEY not set — humanizer requires MiniMax API access" }], isError: true };
+        return { content: [{ type: "text", text: "BANKR_API_KEY not set — add it to your MCP env config." }], isError: true };
     }
-    const userMsg = a.voice_sample
-        ? `VOICE SAMPLE (match this style):\n${a.voice_sample}\n\n---\n\nTEXT TO HUMANIZE:\n${a.text}`
-        : a.text;
+    const userMsg = voice_sample
+        ? `VOICE SAMPLE (match this style):\n${voice_sample}\n\n---\n\nTEXT TO HUMANIZE:\n${text}`
+        : text;
     try {
-        const res = await fetch("https://api.minimaxi.chat/v1/chat/completions", {
+        const res = await fetch(BANKR_LLM_URL, {
             method: "POST",
             headers: {
+                "X-API-Key": apiKey,
                 "Content-Type": "application/json",
-                "Authorization": `Bearer ${apiKey}`,
             },
             body: JSON.stringify({
-                model: "MiniMax-M2.7",
+                model: BANKR_MODEL,
                 messages: [
                     { role: "system", content: HUMANIZER_SYSTEM },
                     { role: "user", content: userMsg },
@@ -105,12 +113,11 @@ async function handleHumanizerTool(name, args) {
             signal: AbortSignal.timeout(30000),
         });
         if (!res.ok) {
-            const err = await res.text();
-            return { content: [{ type: "text", text: `API error: ${res.status} ${err.slice(0, 200)}` }], isError: true };
+            const err = await res.text().catch(() => res.statusText);
+            return { content: [{ type: "text", text: `Bankr LLM error ${res.status}: ${err.slice(0, 200)}` }], isError: true };
         }
         const data = await res.json();
-        const raw = data?.choices?.[0]?.message?.content ?? "";
-        const output = raw.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+        const output = data.choices?.[0]?.message?.content?.trim() ?? "";
         if (!output)
             return { content: [{ type: "text", text: "Empty response from model" }], isError: true };
         return { content: [{ type: "text", text: output }] };

package/dist/tools/insight.js

@@ -30,16 +30,57 @@ const AskNoelSchema = zod_1.z.object({
     question: zod_1.z.string().min(1),
     messages: zod_1.z.array(zod_1.z.object({ role: zod_1.z.enum(["user", "assistant"]), content: zod_1.z.string() })).optional(),
 });
+const BANKR_LLM_URL = "https://llm.bankr.bot/v1/chat/completions";
+const BANKR_MODEL = process.env.BANKR_MODEL ?? "grok-3";
+const NOEL_SYSTEM_PROMPT = `You are Noel, a crypto AI analyst with deep expertise in DeFi, on-chain data, market structure, and trading psychology. You provide sharp, direct analysis — no fluff, no disclaimers. You understand narratives, liquidity flows, whale behavior, and how sentiment drives price. When asked about a token or market, give your honest read with supporting reasoning.`;
+async function askViaBankr(question, messages) {
+    const res = await fetch(BANKR_LLM_URL, {
+        method: "POST",
+        headers: {
+            "X-API-Key": process.env.BANKR_API_KEY,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            model: BANKR_MODEL,
+            messages: [
+                { role: "system", content: NOEL_SYSTEM_PROMPT },
+                ...messages,
+                { role: "user", content: question },
+            ],
+            max_tokens: 1024,
+        }),
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!res.ok) {
+        const err = await res.text().catch(() => res.statusText);
+        throw new Error(`Bankr LLM error ${res.status}: ${err.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return data.choices?.[0]?.message?.content ?? "No response from model";
+}
 async function handleInsightTool(name, args) {
     if (name !== "ask_noel")
         return null;
     const parsed = AskNoelSchema.safeParse(args);
     if (!parsed.success)
         return { content: [{ type: "text", text: `Invalid input: question ${parsed.error.issues[0].message}` }], isError: true };
+    const { question, messages = [] } = parsed.data;
+    // If BANKR_API_KEY is set, call Bankr LLM directly — faster, no Convex hop
+    if (process.env.BANKR_API_KEY) {
+        try {
+            const answer = await askViaBankr(question, messages);
+            return { content: [{ type: "text", text: answer }] };
+        }
+        catch (err) {
+            // Fall through to Convex if Bankr call fails
+            console.error(`Bankr LLM failed, falling back to Convex: ${err.message}`);
+        }
+    }
+    // Fallback: route through Convex backend
     const data = await (0, convex_js_1.callConvex)("/mcp/chat", "POST", {
-        question: parsed.data.question,
+        question,
         agentId: "noel-default",
-        messages: parsed.data.messages ?? [],
+        messages,
     }, "ask_noel");
     return { content: [{ type: "text", text: data.answer ?? JSON.stringify(data) }] };
 }