@noelclaw/mcp 2.3.0 → 2.4.0

package/dist/index.js

@@ -33,25 +33,26 @@ async function main() {
     process.stderr.write(BANNER);
     // ── Tool category counts ──────────────────────────────────────────────────
     const categories = [
-        { label: "Market", count: 3, tools: "get_market_data · get_token_data · ask_noel" },
-        { label: "DeFi", count: 5, tools: "portfolio · swap · send · scan_wallet · estimate" },
+        { label: "Market", count: 5, tools: "get_market_data · get_token_data · compare_tokens · market_overview · token_history" },
+        { label: "Insight", count: 3, tools: "ask_noel · market_thesis · trade_plan" },
+        { label: "DeFi", count: 6, tools: "portfolio · swap · send · scan_wallet · estimate · get_defi_yields" },
         { label: "Automation", count: 5, tools: "create · list · pause · delete · runs" },
-        { label: "Scanner", count: 3, tools: "scan_dips · score_token · check_token" },
+        { label: "Scanner", count: 4, tools: "scan_dips · scan_momentum · score_token · check_token" },
         { label: "Agents", count: 2, tools: "list_agents · hire_agent" },
-        { label: "Swarm", count: 6, tools: "start · stop · status · read_memory · write_memory · scores" },
+        { label: "Swarm", count: 11, tools: "start · stop · status · memory · scores · research · trigger · brief · broadcast · pulse" },
         { label: "Framework", count: 6, tools: "create_task · list_tasks · list_playbooks · run_playbook · ledger · sentinel" },
-        { label: "Vault", count: 8, tools: "save · read · list · search · history · diff · export · connect" },
-        { label: "Memory", count: 5, tools: "add · search · context · profile · connect" },
+        { label: "Vault", count: 18, tools: "save · read · list · search · history · diff · export · remember · context · credential · publish · explore · connect · pin · delete · link · tag" },
+        { label: "Memory", count: 8, tools: "add · search · context · profile · connect · list · delete · update" },
         { label: "MiroShark", count: 3, tools: "simulate · status · stop" },
         { label: "Wallet", count: 2, tools: "get_wallet_address · set_telegram" },
-        { label: "Social", count: 1, tools: "humanize_text" },
-        { label: "Coder", count: 6, tools: "scaffold_project · generate_component · generate_contract · audit_contract · explain_code · review_code" },
+        { label: "Social", count: 3, tools: "humanize_text · write_thread · write_post" },
+        { label: "Coder", count: 7, tools: "scaffold_project · generate_component · generate_contract · audit_contract · explain_code · review_code · generate_mcp_skill" },
         { label: "Base", count: 4, tools: "query_vaults · list_markets · prepare_deposit · chain_stats" },
     ];
     const total = server_js_1.ALL_TOOLS.length;
     divider();
     process.stderr.write(`\n`);
-    line("version", `v2.3.0  ${C.dim}MCP protocol 2.1.0${C.reset}`);
+    line("version", `v2.4.0  ${C.dim}MCP protocol 2.1.0${C.reset}`);
     line("network", `Base mainnet  ${C.dim}via 0x Protocol · ethers v6${C.reset}`);
     line("ai", `Bankr LLM  ${C.dim}grok-3 · llm.bankr.bot${C.reset}`);
     line("tools", `${C.white}${C.bold}${total} tools loaded${C.reset}  ${C.dim}across ${categories.length} categories${C.reset}`);

package/dist/server.js

@@ -21,6 +21,7 @@ const scanner_js_1 = require("./tools/scanner.js");
 const coder_js_1 = require("./tools/coder.js");
 const base_js_1 = require("./tools/base.js");
 const memory_js_1 = require("./tools/memory.js");
+const os_js_1 = require("./tools/os.js");
 const PRIVATE_KEY_RESPONSE = {
     content: [{
             type: "text",
@@ -35,45 +36,54 @@ function containsSensitiveRequest(args) {
         text.includes("privatekey"));
 }
 exports.ALL_TOOLS = [
-    ...market_js_1.MARKET_TOOLS, // 2 — get_market_data, get_token_data
-    ...insight_js_1.INSIGHT_TOOLS, // 1 — ask_noel
-    ...defi_js_1.DEFI_TOOLS, // 5 — get_portfolio, estimate_swap, swap_tokens, send_token, scan_wallet
-    ...automation_js_1.AUTOMATION_TOOLS, // 5 — create, list, pause, delete, get_runs
-    ...swarm_js_1.SWARM_TOOLS, // 9 — start, stop, status, read/write memory, scores, research, brief, trigger_agent
+    ...market_js_1.MARKET_TOOLS, // 5 — get_market_data, get_token_data, compare_tokens, market_overview, token_history
+    ...insight_js_1.INSIGHT_TOOLS, // 3 — ask_noel, market_thesis, trade_plan
+    ...defi_js_1.DEFI_TOOLS, // 7 — get_portfolio, estimate_swap, swap_tokens, send_token, scan_wallet, analyze_wallet, get_defi_yields
+    ...automation_js_1.AUTOMATION_TOOLS, // 6 — create, list, pause, delete, get_runs, run
+    ...swarm_js_1.SWARM_TOOLS, // 13 — start, stop, status, read/write memory, scores, research, brief, trigger_agent, broadcast, pulse, reflect, watch
     ...framework_js_1.FRAMEWORK_TOOLS, // 6 — task packets, playbooks, sentinel, ledger
-    ...vault_js_1.VAULT_TOOLS, // 14 — save, read, list, search, history, diff, export, remember, context, store_credential, get_credential, publish, explore, connect
+    ...vault_js_1.VAULT_TOOLS, // 15 — save, read, list, search, history, diff, export, store_credential, get_credential, publish, explore, pin, delete, link, tag
     ...wallet_js_1.WALLET_TOOLS, // 2 — get_wallet_address, set_telegram
     ...miroshark_js_1.MIROSHARK_TOOLS, // 3 — simulate, status, stop
-    ...humanizer_js_1.HUMANIZER_TOOLS, // 1 — humanize_text
+    ...humanizer_js_1.HUMANIZER_TOOLS, // 3 — humanize_text, write_thread, write_post
     ...agents_js_1.AGENT_TOOLS, // 2 — list_agents, hire_agent
-    ...scanner_js_1.SCANNER_TOOLS, // 3 — score_token, check_token, scan_dips
-    ...coder_js_1.CODER_TOOLS, // 6 — scaffold_project, generate_component, generate_contract, audit_contract, explain_code, review_code
+    ...scanner_js_1.SCANNER_TOOLS, // 4 — score_token, check_token, scan_dips, scan_momentum
+    ...coder_js_1.CODER_TOOLS, // 7 — scaffold_project, generate_component, generate_contract, audit_contract, explain_code, review_code, generate_mcp_skill
     ...base_js_1.BASE_TOOLS, // 4 — query_vaults, list_markets, prepare_deposit, chain_stats
-    ...memory_js_1.MEMORY_TOOLS, // 5 — memory_add, memory_search, memory_context, memory_profile, memory_connect
-    // total: 67
+    ...memory_js_1.MEMORY_TOOLS, // 7 — memory_add, memory_search, memory_context, memory_profile, memory_list, memory_delete, memory_insight
+    ...os_js_1.OS_TOOLS, // 3 — noel_status, noel_boot, noel_shutdown
+    // total: 90
 ];
-exports.server = new index_js_1.Server({ name: "noelclaw", version: "2.3.0" }, { capabilities: { tools: {} } });
+const HANDLER_MAP = new Map([
+    ...market_js_1.MARKET_TOOLS.map(t => [t.name, market_js_1.handleMarketTool]),
+    ...defi_js_1.DEFI_TOOLS.map(t => [t.name, defi_js_1.handleDefiTool]),
+    ...automation_js_1.AUTOMATION_TOOLS.map(t => [t.name, automation_js_1.handleAutomationTool]),
+    ...swarm_js_1.SWARM_TOOLS.map(t => [t.name, swarm_js_1.handleSwarmTool]),
+    ...framework_js_1.FRAMEWORK_TOOLS.map(t => [t.name, framework_js_1.handleFrameworkTool]),
+    ...vault_js_1.VAULT_TOOLS.map(t => [t.name, vault_js_1.handleVaultTool]),
+    ...wallet_js_1.WALLET_TOOLS.map(t => [t.name, wallet_js_1.handleWalletTool]),
+    ...insight_js_1.INSIGHT_TOOLS.map(t => [t.name, insight_js_1.handleInsightTool]),
+    ...miroshark_js_1.MIROSHARK_TOOLS.map(t => [t.name, miroshark_js_1.handleMirosharkTool]),
+    ...humanizer_js_1.HUMANIZER_TOOLS.map(t => [t.name, humanizer_js_1.handleHumanizerTool]),
+    ...agents_js_1.AGENT_TOOLS.map(t => [t.name, agents_js_1.handleAgentTool]),
+    ...scanner_js_1.SCANNER_TOOLS.map(t => [t.name, scanner_js_1.handleScannerTool]),
+    ...coder_js_1.CODER_TOOLS.map(t => [t.name, coder_js_1.handleCoderTool]),
+    ...base_js_1.BASE_TOOLS.map(t => [t.name, base_js_1.handleBaseTool]),
+    ...memory_js_1.MEMORY_TOOLS.map(t => [t.name, memory_js_1.handleMemoryTool]),
+    ...os_js_1.OS_TOOLS.map(t => [t.name, os_js_1.handleOsTool]),
+]);
+exports.server = new index_js_1.Server({ name: "noelclaw", version: "2.4.0" }, { capabilities: { tools: {} } });
 exports.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({ tools: exports.ALL_TOOLS }));
 exports.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     if (containsSensitiveRequest(args))
         return PRIVATE_KEY_RESPONSE;
+    const handler = HANDLER_MAP.get(name);
+    if (!handler) {
+        return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
+    }
     try {
-        const result = await (0, market_js_1.handleMarketTool)(name, args) ??
-            await (0, defi_js_1.handleDefiTool)(name, args) ??
-            await (0, automation_js_1.handleAutomationTool)(name, args) ??
-            await (0, swarm_js_1.handleSwarmTool)(name, args) ??
-            await (0, framework_js_1.handleFrameworkTool)(name, args) ??
-            await (0, vault_js_1.handleVaultTool)(name, args) ??
-            await (0, wallet_js_1.handleWalletTool)(name, args) ??
-            await (0, insight_js_1.handleInsightTool)(name, args) ??
-            await (0, miroshark_js_1.handleMirosharkTool)(name, args) ??
-            await (0, humanizer_js_1.handleHumanizerTool)(name, args) ??
-            await (0, agents_js_1.handleAgentTool)(name, args) ??
-            await (0, scanner_js_1.handleScannerTool)(name, args) ??
-            await (0, coder_js_1.handleCoderTool)(name, args) ??
-            await (0, base_js_1.handleBaseTool)(name, args) ??
-            await (0, memory_js_1.handleMemoryTool)(name, args);
+        const result = await handler(name, args);
         if (result)
             return result;
         return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
@@ -93,7 +103,7 @@ exports.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (reques
                     `   (replace \`<txHash>\` with the actual transaction hash)`,
                     `4. Retry the tool call`, ``,
                     "**Or bypass with a session token:**",
-                    "Set `NOELCLAW_SESSION_TOKEN` with your Noelclaw session token from noelclaw.xyz",
+                    "Set `NOELCLAW_SESSION_TOKEN` with your Noelclaw session token from noelclaw.com",
                 ] : []),
             ];
             return { content: [{ type: "text", text: lines.join("\n") }], isError: true };

package/dist/tools/automation.js

@@ -49,6 +49,20 @@ exports.AUTOMATION_TOOLS = [
             required: ["automationId"],
         },
     },
+    {
+        name: "run_automation",
+        description: "Trigger an automation immediately — regardless of its schedule or trigger condition. " +
+            "Use to test an automation after creating it, or to run a one-off DCA/swap/alert right now. " +
+            "The automation must be active (not paused or deleted). " +
+            "Get the ID from list_automations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                automationId: { type: "string", description: "Automation ID to run now (from list_automations)" },
+            },
+            required: ["automationId"],
+        },
+    },
 ];
 const CreateAutomationSchema = zod_1.z.object({ rawInput: zod_1.z.string().min(1) });
 const AutomationIdSchema = zod_1.z.object({ automationId: zod_1.z.string().min(1) });
@@ -148,6 +162,30 @@ async function handleAutomationTool(name, args) {
             }
             return { content: [{ type: "text", text: lines.join("\n") }] };
         }
+        case "run_automation": {
+            const parsed = AutomationIdSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: automationId ${parsed.error.issues[0].message}` }], isError: true };
+            const data = await (0, convex_js_1.callConvex)("/automations/run", "POST", { automationId: parsed.data.automationId }, "run_automation");
+            if (data.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const statusIcon = { success: "✅", failed: "❌", skipped: "⏭️" };
+            const icon = statusIcon[data.status] ?? "⚡";
+            const spent = data.amountUsd != null ? ` · $${Number(data.amountUsd).toFixed(2)} spent` : "";
+            const txLine = data.txHash ? `\nTx: https://basescan.org/tx/${data.txHash}` : "";
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `${icon} **Automation triggered: ${data.status ?? "executed"}**${spent}`,
+                            data.message ?? "",
+                            txLine,
+                            ``,
+                            `Use \`get_automation_runs automationId: "${parsed.data.automationId}"\` to see full history.`,
+                        ].filter(Boolean).join("\n"),
+                    }],
+            };
+        }
         default:
             return null;
     }

package/dist/tools/coder.js

@@ -138,6 +138,33 @@ exports.CODER_TOOLS = [
             required: ["code"],
         },
     },
+    {
+        name: "generate_mcp_skill",
+        description: "Generate a complete Claude Code skill (.md file) from a description. " +
+            "Skills are slash-command workflows that run inside Claude Code — they can call tools, " +
+            "loop, delegate to subagents, and have persistent behavior. " +
+            "Returns a ready-to-use .md file you can drop into your .claude/skills/ directory. " +
+            "Use this to automate repetitive Claude Code workflows without writing TypeScript.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "What the skill should do — be specific about inputs, outputs, and any tools it should use",
+                },
+                name: {
+                    type: "string",
+                    description: "Skill name in kebab-case, e.g. 'daily-standup', 'code-review', 'deploy-check'",
+                },
+                tools: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: list of Claude Code tools or MCP tools the skill should use, e.g. ['Bash', 'Read', 'memory_search']",
+                },
+            },
+            required: ["description", "name"],
+        },
+    },
     {
         name: "review_code",
         description: "Review and improve a piece of code. Returns the improved version with a summary of changes. " +
@@ -191,6 +218,11 @@ const ReviewSchema = zod_1.z.object({
     language: zod_1.z.string().optional(),
     goals: zod_1.z.string().optional(),
 });
+const McpSkillSchema = zod_1.z.object({
+    description: zod_1.z.string().min(10),
+    name: zod_1.z.string().min(1).regex(/^[a-z0-9-]+$/, "must be kebab-case"),
+    tools: zod_1.z.array(zod_1.z.string()).optional(),
+});
 async function handleCoderTool(name, args) {
     switch (name) {
         case "scaffold_project": {
@@ -341,6 +373,36 @@ async function handleCoderTool(name, args) {
                 return err(`review_code failed: ${e.message}`);
             }
         }
+        case "generate_mcp_skill": {
+            const p = McpSkillSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { description, name: skillName, tools = [] } = p.data;
+            const prompt = `Generate a complete Claude Code skill (.md file) for the following workflow:\n\n` +
+                `Skill name: /${skillName}\n` +
+                `Description: ${description}\n` +
+                (tools.length ? `Tools to use: ${tools.join(", ")}\n` : "") +
+                `\n` +
+                `Claude Code skill format rules:\n` +
+                `- The file is a markdown document that serves as a system prompt for a Claude Code slash command\n` +
+                `- It should start with a brief description of what the skill does\n` +
+                `- Include an "## Input" section explaining what arguments the skill accepts (if any)\n` +
+                `- Include a "## Steps" section with numbered, concrete steps\n` +
+                `- Include a "## Output" section describing what the skill produces\n` +
+                `- Steps can reference tool calls like "Use the Bash tool to run X" or "Use memory_search to find Y"\n` +
+                `- Steps can reference conditional logic and loops\n` +
+                `- Keep it under 200 lines — skills should be focused, not monolithic\n` +
+                `- Write in imperative second person ("Run...", "Check...", "If X, then...")\n` +
+                `- Do NOT include markdown fences around the output — output the raw .md content directly\n\n` +
+                `Output only the .md file content, ready to save as .claude/skills/${skillName}.md`;
+            try {
+                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 2000);
+                return ok(`# /${skillName} skill — save to .claude/skills/${skillName}.md\n\n---\n\n${response}`);
+            }
+            catch (e) {
+                return err(`generate_mcp_skill failed: ${e.message}`);
+            }
+        }
         default:
             return null;
     }

package/dist/tools/defi.js

@@ -55,9 +55,45 @@ exports.DEFI_TOOLS = [
         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: [] },
     },
+    {
+        name: "analyze_wallet",
+        description: "AI-powered analysis of any public wallet on Base — not just your own. " +
+            "Enter any 0x address: see token holdings, portfolio value, concentration risk, " +
+            "DeFi positions, and a behavioral profile (whale, degen, LP provider, etc.). " +
+            "Use to track smart money, research whales, or audit any wallet before copying trades.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                address: { type: "string", description: "Wallet address to analyze (0x...)" },
+                label: { type: "string", description: "Optional label for this wallet (e.g. 'whale from Twitter')" },
+            },
+            required: ["address"],
+        },
+    },
+    {
+        name: "get_defi_yields",
+        description: "Fetch top DeFi yield opportunities on Base — Morpho, Moonwell, Aerodrome, Uniswap, and more. " +
+            "Returns live APY, TVL, and pool info from DeFiLlama (no API key required). " +
+            "Filter by token or minimum APY. Use before depositing to find the best rates.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: { type: "string", description: "Optional: filter by token symbol, e.g. 'USDC', 'ETH', 'WETH'" },
+                minApy: { type: "number", description: "Optional: minimum APY % to show (default 1)" },
+                limit: { type: "number", description: "Max results to return (default 20)" },
+            },
+            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 AnalyzeWalletSchema = zod_1.z.object({ address: zod_1.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a valid 0x address"), label: zod_1.z.string().optional() });
+const DefiYieldsSchema = zod_1.z.object({
+    token: zod_1.z.string().optional(),
+    minApy: zod_1.z.number().optional(),
+    limit: zod_1.z.number().int().min(1).max(100).optional(),
+}).default({});
 const BUY_DECIMALS = { USDC: 6, USDT: 6, DAI: 18, ETH: 18, WETH: 18 };
 function formatTokenAmount(raw, token) {
     const dec = BUY_DECIMALS[token.toUpperCase()] ?? 18;
@@ -183,6 +219,97 @@ async function handleDefiTool(name, args) {
                 : "";
             return { content: [{ type: "text", text: header + body + footer }] };
         }
+        case "analyze_wallet": {
+            const parsed = AnalyzeWalletSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { address, label } = parsed.data;
+            const data = await (0, convex_js_1.callConvex)("/wallet/analyze", "POST", { address, label }, "analyze_wallet");
+            if (data.error)
+                return { content: [{ type: "text", text: `Wallet analysis failed: ${data.error}` }], isError: true };
+            const total = (data.totalUsd ?? 0).toFixed(2);
+            const walletLabel = label ? ` — ${label}` : "";
+            const topHoldings = (data.holdings ?? [])
+                .slice(0, 8)
+                .map(h => `• **${h.token}**: $${(h.valueUsd ?? 0).toFixed(2)}${h.pct != null ? ` (${h.pct}%)` : ""}`)
+                .join("\n");
+            const profileLine = data.profile ? `**Profile:** ${data.profile}\n` : "";
+            const header = [
+                `**Wallet Analysis**${walletLabel}`,
+                `\`${address}\``,
+                `**Portfolio value:** $${total}`,
+                ``,
+                profileLine,
+                `**Holdings:**`,
+                topHoldings || "No token holdings found.",
+                ``,
+            ].join("\n");
+            const body = data.analysis ?? (data.analysisError ? `*AI analysis unavailable: ${data.analysisError}*` : "*AI analysis not available*");
+            return { content: [{ type: "text", text: header + body }] };
+        }
+        case "get_defi_yields": {
+            const parsed = DefiYieldsSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { token, minApy = 1, limit = 20 } = parsed.data;
+            let pools;
+            try {
+                const res = await fetch("https://yields.llama.fi/pools", { signal: AbortSignal.timeout(15000) });
+                if (!res.ok)
+                    throw new Error(`HTTP ${res.status}`);
+                const data = await res.json();
+                pools = data.data ?? [];
+            }
+            catch (e) {
+                return { content: [{ type: "text", text: `DeFiLlama fetch failed: ${e.message}` }], isError: true };
+            }
+            // Filter to Base chain
+            let filtered = pools.filter((p) => p.chain === "Base");
+            // Filter by token if specified
+            if (token) {
+                const upper = token.toUpperCase();
+                filtered = filtered.filter((p) => (p.symbol ?? "").toUpperCase().includes(upper) ||
+                    (p.underlyingTokens ?? []).some((t) => t.toUpperCase().includes(upper)));
+            }
+            // Filter by minimum APY and remove outliers (>10000% are usually broken)
+            filtered = filtered
+                .filter((p) => (p.apy ?? 0) >= minApy && (p.apy ?? 0) <= 10000)
+                .sort((a, b) => (b.apy ?? 0) - (a.apy ?? 0))
+                .slice(0, limit);
+            if (!filtered.length) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: [
+                                `## DeFi Yields on Base`,
+                                `No pools found${token ? ` for ${token.toUpperCase()}` : ""} with APY ≥ ${minApy}%.`,
+                                ``,
+                                `Try lowering \`minApy\` or removing the token filter.`,
+                            ].join("\n"),
+                        }],
+                };
+            }
+            const fmt = (n) => n >= 1000000000 ? `$${(n / 1000000000).toFixed(1)}B`
+                : n >= 1000000 ? `$${(n / 1000000).toFixed(1)}M`
+                    : n >= 1000 ? `$${(n / 1000).toFixed(0)}K`
+                        : `$${n.toFixed(0)}`;
+            const lines = [
+                `## DeFi Yields on Base${token ? ` — ${token.toUpperCase()}` : ""}`,
+                `Top ${filtered.length} pools · APY ≥ ${minApy}% · Source: DeFiLlama`,
+                ``,
+                `| # | Pool | Protocol | APY | TVL |`,
+                `|---|------|----------|-----|-----|`,
+            ];
+            filtered.forEach((p, i) => {
+                const apy = (p.apy ?? 0).toFixed(1);
+                const tvl = fmt(p.tvlUsd ?? 0);
+                const name = (p.symbol ?? p.pool ?? "—").replace(/-/g, " ");
+                const proj = p.project ?? "—";
+                lines.push(`| ${i + 1} | ${name} | ${proj} | **${apy}%** | ${tvl} |`);
+            });
+            lines.push(``, `Use \`swap_tokens\` to position, then deposit via the protocol's UI. Always check smart contract risk before depositing.`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
         default:
             return null;
     }

package/dist/tools/humanizer.js

@@ -5,6 +5,66 @@ exports.handleHumanizerTool = handleHumanizerTool;
 const zod_1 = require("zod");
 const llm_js_1 = require("../llm.js");
 exports.HUMANIZER_TOOLS = [
+    {
+        name: "write_thread",
+        description: "Write a viral Twitter/X thread on any crypto or tech topic. " +
+            "Returns a numbered thread (1/, 2/, ...) with a hook tweet, " +
+            "3-7 content tweets, and a strong closer with CTA. " +
+            "Written in a direct, punchy voice — no fluff, no AI tells. " +
+            "Optionally provide your own voice sample to match your style.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: {
+                    type: "string",
+                    description: "The topic or angle for the thread, e.g. 'why Base is winning', 'how I use MCP agents for DeFi research'",
+                },
+                tone: {
+                    type: "string",
+                    enum: ["alpha", "educational", "opinion", "story"],
+                    description: "Thread tone: 'alpha' (edge/insight), 'educational' (explainer), 'opinion' (hot take), 'story' (personal narrative). Default: opinion.",
+                },
+                tweets: {
+                    type: "number",
+                    description: "Number of tweets in the thread, 4–12 (default: 7)",
+                },
+                voice_sample: {
+                    type: "string",
+                    description: "Optional: paste 1-3 of your existing tweets to match your voice",
+                },
+            },
+            required: ["topic"],
+        },
+    },
+    {
+        name: "write_post",
+        description: "Write a single viral-style crypto/tech post for Twitter/X. " +
+            "Returns one punchy post under 280 characters (or up to 500 with long-form enabled). " +
+            "Hooks in the first line, delivers the insight, ends with impact. No AI fluff.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: {
+                    type: "string",
+                    description: "What to post about — a thought, observation, alpha, or hot take",
+                },
+                style: {
+                    type: "string",
+                    enum: ["hook", "hot-take", "alpha", "question", "observation"],
+                    description: "Post style. Default: hook.",
+                },
+                long: {
+                    type: "boolean",
+                    description: "Allow up to 500 chars (long-form post). Default: false (280 chars max)",
+                },
+                voice_sample: {
+                    type: "string",
+                    description: "Optional: a sample of your writing to match your voice",
+                },
+            },
+            required: ["topic"],
+        },
+    },
     {
         name: "humanize_text",
         description: "Remove AI writing patterns from text — makes it sound natural, direct, and human. " +
@@ -28,8 +88,20 @@ exports.HUMANIZER_TOOLS = [
     },
 ];
 const HumanizerSchema = zod_1.z.object({
-    text: zod_1.z.string().min(1),
-    voice_sample: zod_1.z.string().optional(),
+    text: zod_1.z.string().min(1).max(20000),
+    voice_sample: zod_1.z.string().max(5000).optional(),
+});
+const WriteThreadSchema = zod_1.z.object({
+    topic: zod_1.z.string().min(3).max(500),
+    tone: zod_1.z.enum(["alpha", "educational", "opinion", "story"]).optional(),
+    tweets: zod_1.z.number().int().min(4).max(12).optional(),
+    voice_sample: zod_1.z.string().max(5000).optional(),
+});
+const WritePostSchema = zod_1.z.object({
+    topic: zod_1.z.string().min(3).max(500),
+    style: zod_1.z.enum(["hook", "hot-take", "alpha", "question", "observation"]).optional(),
+    long: zod_1.z.boolean().optional(),
+    voice_sample: zod_1.z.string().max(5000).optional(),
 });
 const HUMANIZER_SYSTEM = `You are a text editor that removes signs of AI-generated writing.
 
@@ -78,7 +150,76 @@ PROCESS:
 6. Output ONLY the final humanized text — no commentary, no explanation, no "Here is your text:"
 
 If a voice sample is provided, match its tone, rhythm, and vocabulary. Otherwise use direct, opinionated, natural prose.`;
+const THREAD_SYSTEM = `You are a crypto Twitter ghostwriter who writes threads that go viral. Your style: direct, no fluff, confident without being cringe. You understand DeFi, on-chain data, narratives, and market structure. You write like a smart practitioner, not a content creator.
+
+Rules:
+- First tweet is the hook — bold claim or surprising insight. Must make people stop scrolling.
+- Middle tweets: each one standalone insight. No "in this thread I'll explain" filler.
+- Last tweet: the payoff. Strong closer, optional CTA (follow, RT, reply) — one CTA max.
+- Number format: 1/ 2/ 3/ etc. Each tweet on its own line, separated by blank line.
+- Under 280 chars per tweet unless it genuinely needs more (max 500).
+- No em dashes, no "delve", no "landscape", no "it's worth noting".
+- No hashtags unless they're actually used. No emojis unless they add meaning.
+- Write in the user's voice if a sample is provided.`;
+const POST_SYSTEM = `You are a crypto Twitter ghostwriter. Write one punchy, high-impact post. Direct. No fluff. Hook in the first line. No em dashes, no AI vocabulary. Write like a smart practitioner with an edge.`;
 async function handleHumanizerTool(name, args) {
+    if (name === "write_thread") {
+        const parsed = WriteThreadSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const { topic, tone = "opinion", tweets = 7, voice_sample } = parsed.data;
+        const toneGuides = {
+            alpha: "Share non-obvious insights or edge. Act like you have information most people don't.",
+            educational: "Explain a concept clearly. Assume smart but non-expert reader.",
+            opinion: "Take a clear position. Defend it with reasoning. Don't hedge.",
+            story: "Tell a real story with a beginning, conflict, and lesson. Make it personal and specific.",
+        };
+        const prompt = [
+            `Write a ${tweets}-tweet Twitter/X thread on: ${topic}`,
+            ``,
+            `Tone: ${tone} — ${toneGuides[tone]}`,
+            voice_sample ? `Voice sample (match this style):\n${voice_sample}` : "",
+            ``,
+            `Format: number each tweet as 1/ 2/ 3/ etc., separated by blank lines.`,
+            `First tweet = hook. Last tweet = strong closer.`,
+            `Output only the tweets — no intro, no explanation.`,
+        ].filter(Boolean).join("\n");
+        try {
+            const output = await (0, llm_js_1.callLLM)(THREAD_SYSTEM, prompt, 2000);
+            return { content: [{ type: "text", text: output.trim() }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `write_thread error: ${err.message}` }], isError: true };
+        }
+    }
+    if (name === "write_post") {
+        const parsed = WritePostSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const { topic, style = "hook", long = false, voice_sample } = parsed.data;
+        const styleGuides = {
+            hook: "Strong first line that stops the scroll. Deliver the insight after.",
+            "hot-take": "Controversial opinion stated plainly. Don't soften it.",
+            alpha: "Non-obvious market insight written like you're sharing it with one smart friend.",
+            question: "Ask a sharp, thought-provoking question. Don't answer it.",
+            observation: "One specific thing you noticed that most people missed.",
+        };
+        const charLimit = long ? 500 : 280;
+        const prompt = [
+            `Write one ${style} post about: ${topic}`,
+            `Style: ${styleGuides[style]}`,
+            `Max length: ${charLimit} characters.`,
+            voice_sample ? `Voice sample:\n${voice_sample}` : "",
+            `Output only the post text — nothing else.`,
+        ].filter(Boolean).join("\n");
+        try {
+            const output = await (0, llm_js_1.callLLM)(POST_SYSTEM, prompt, 300);
+            return { content: [{ type: "text", text: output.trim() }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `write_post error: ${err.message}` }], isError: true };
+        }
+    }
     if (name !== "humanize_text")
         return null;
     const parsed = HumanizerSchema.safeParse(args);