@noelclaw/mcp 2.3.1 → 3.0.0

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);

package/dist/tools/insight.js

@@ -5,6 +5,7 @@ exports.handleInsightTool = handleInsightTool;
 const zod_1 = require("zod");
 const convex_js_1 = require("../convex.js");
 const llm_js_1 = require("../llm.js");
+const memory_js_1 = require("./memory.js");
 exports.INSIGHT_TOOLS = [
     {
         name: "ask_noel",
@@ -26,35 +27,212 @@ exports.INSIGHT_TOOLS = [
             required: ["question"],
         },
     },
+    {
+        name: "market_thesis",
+        description: "Generate a structured bull vs bear thesis for any token or market topic. " +
+            "Noel fetches live price/market data then writes a sharp, two-sided analysis: " +
+            "bull case (catalysts, narratives, technicals), bear case (risks, headwinds, red flags), " +
+            "and a net verdict with conviction score 0–10. " +
+            "Use before opening a position or for research on a token you're watching.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: { type: "string", description: "Token symbol or CoinGecko ID, e.g. 'ETH', 'bitcoin', 'AERO'" },
+                context: { type: "string", description: "Optional: extra context — your time horizon, thesis seed, or specific concerns" },
+            },
+            required: ["token"],
+        },
+    },
+    {
+        name: "trade_plan",
+        description: "Build a structured trade plan for any token: entry zone, stop loss, take profit levels, " +
+            "position size recommendation (as % of portfolio), and risk/reward ratio. " +
+            "Based on live price data + Noel's market reading. Returns a ready-to-act plan, not vague advice.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: { type: "string", description: "Token symbol or CoinGecko ID" },
+                side: { type: "string", enum: ["long", "short"], description: "Trade direction (default: long)" },
+                portfolioSize: { type: "number", description: "Optional: your portfolio size in USD (for position sizing)" },
+                riskTolerance: { type: "string", enum: ["conservative", "moderate", "aggressive"], description: "Risk profile (default: moderate)" },
+                timeframe: { type: "string", description: "Optional: trade timeframe, e.g. 'intraday', 'swing', 'weeks'" },
+            },
+            required: ["token"],
+        },
+    },
 ];
 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 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 handleInsightTool(name, args) {
-    if (name !== "ask_noel")
+const MarketThesisSchema = zod_1.z.object({
+    token: zod_1.z.string().min(1),
+    context: zod_1.z.string().optional(),
+});
+const TradePlanSchema = zod_1.z.object({
+    token: zod_1.z.string().min(1),
+    side: zod_1.z.enum(["long", "short"]).optional(),
+    portfolioSize: zod_1.z.number().positive().optional(),
+    riskTolerance: zod_1.z.enum(["conservative", "moderate", "aggressive"]).optional(),
+    timeframe: zod_1.z.string().optional(),
+});
+const NOEL_BASE_PROMPT = `You are Noel, a crypto AI analyst and the core intelligence of the Noelclaw AI Operating System. You have 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 buildSystemPrompt(question) {
+    const memories = await (0, memory_js_1.searchSupermemory)(question, 5);
+    if (!memories.length)
+        return NOEL_BASE_PROMPT;
+    const memBlock = memories
+        .map(r => {
+        const title = r.metadata?.title ? `[${r.metadata.title}] ` : "";
+        return `- ${title}${r.content.slice(0, 250).replace(/\n/g, " ")}`;
+    })
+        .join("\n");
+    return `${NOEL_BASE_PROMPT}\n\n<user_memory>\nThe following is stored knowledge about this user — use it to personalize your response:\n${memBlock}\n</user_memory>`;
+}
+async function fetchCgPrice(token) {
+    try {
+        const id = token.toLowerCase().replace(/ /g, "-");
+        const res = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&ids=${id}&order=market_cap_desc&per_page=1&page=1`, { signal: AbortSignal.timeout(8000) });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        const coin = data[0];
+        if (!coin)
+            return null;
+        return {
+            price: coin.current_price ?? 0,
+            change24h: coin.price_change_percentage_24h ?? 0,
+            mcap: coin.market_cap ?? 0,
+            symbol: coin.symbol?.toUpperCase() ?? token.toUpperCase(),
+        };
+    }
+    catch {
         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;
-    // Try local LLM first (Anthropic from Claude Desktop, or Bankr if configured)
-    if (process.env.ANTHROPIC_API_KEY || process.env.BANKR_API_KEY) {
+    }
+}
+async function handleInsightTool(name, args) {
+    if (name === "ask_noel") {
+        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;
+        const systemPrompt = await buildSystemPrompt(question);
+        if (process.env.ANTHROPIC_API_KEY || process.env.BANKR_API_KEY) {
+            try {
+                const history = messages.map(m => ({ role: m.role, content: m.content }));
+                const answer = await (0, llm_js_1.callLLM)(systemPrompt, question, 1024, history);
+                return { content: [{ type: "text", text: answer }] };
+            }
+            catch (err) {
+                // fall through to Convex
+            }
+        }
+        const data = await (0, convex_js_1.callConvex)("/mcp/chat", "POST", {
+            question,
+            agentId: "noel-default",
+            messages,
+            systemPrompt,
+        }, "ask_noel");
+        return { content: [{ type: "text", text: data.answer ?? JSON.stringify(data) }] };
+    }
+    if (name === "market_thesis") {
+        const parsed = MarketThesisSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const { token, context } = parsed.data;
+        const priceData = await fetchCgPrice(token);
+        const dataCtx = priceData
+            ? `Current price: $${priceData.price.toLocaleString()} | 24h: ${priceData.change24h.toFixed(1)}% | Mcap: $${(priceData.mcap / 1000000).toFixed(0)}M`
+            : `(live price data unavailable — use general knowledge)`;
+        const prompt = [
+            `Write a structured bull vs bear thesis for ${token.toUpperCase()}.`,
+            ``,
+            `Live market data: ${dataCtx}`,
+            context ? `User context: ${context}` : "",
+            ``,
+            `Output format (use exactly these headers):`,
+            `## ${token.toUpperCase()} Thesis`,
+            `**Current price:** [price] | **24h:** [change]`,
+            ``,
+            `### Bull Case`,
+            `(3-5 specific catalysts, narratives, or technical factors that support upside. Be concrete — no vague "adoption" claims.)`,
+            ``,
+            `### Bear Case`,
+            `(3-5 specific risks, headwinds, or red flags. Include on-chain, macro, and competitive risks if applicable.)`,
+            ``,
+            `### Net Verdict`,
+            `**Conviction:** X/10`,
+            `(2-3 sentences: the deciding factor, the key risk to watch, and your net lean.)`,
+        ].filter(Boolean).join("\n");
+        try {
+            const systemPrompt = await buildSystemPrompt(`${token} ${context ?? ""}`);
+            const answer = await (0, llm_js_1.callLLM)(systemPrompt, prompt, 1200);
+            return { content: [{ type: "text", text: answer }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `market_thesis error: ${err.message}` }], isError: true };
+        }
+    }
+    if (name === "trade_plan") {
+        const parsed = TradePlanSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const { token, side = "long", portfolioSize, riskTolerance = "moderate", timeframe } = parsed.data;
+        const priceData = await fetchCgPrice(token);
+        const dataCtx = priceData
+            ? `Current price: $${priceData.price.toLocaleString()} | 24h: ${priceData.change24h.toFixed(1)}% | Mcap: $${(priceData.mcap / 1000000).toFixed(0)}M`
+            : `(live price data unavailable)`;
+        const riskPcts = {
+            conservative: "1-2% of portfolio",
+            moderate: "2-5% of portfolio",
+            aggressive: "5-10% of portfolio",
+        };
+        const prompt = [
+            `Build a structured ${side.toUpperCase()} trade plan for ${token.toUpperCase()}.`,
+            ``,
+            `Live data: ${dataCtx}`,
+            `Risk tolerance: ${riskTolerance} (max position size: ${riskPcts[riskTolerance]})`,
+            portfolioSize ? `Portfolio size: $${portfolioSize.toLocaleString()}` : "",
+            timeframe ? `Timeframe: ${timeframe}` : "",
+            ``,
+            `Output exactly this format:`,
+            `## Trade Plan: ${token.toUpperCase()} ${side.toUpperCase()}`,
+            ``,
+            `**Direction:** ${side.toUpperCase()}`,
+            `**Timeframe:** [fill]`,
+            ``,
+            `### Entry`,
+            `- Ideal entry: $[price or range]`,
+            `- Entry condition: [what must happen / trigger]`,
+            ``,
+            `### Risk Management`,
+            `- Stop loss: $[price] ([%] below/above entry)`,
+            `- Position size: [% of portfolio]${portfolioSize ? ` = $[USD amount]` : ""}`,
+            `- Max loss: [% of portfolio]`,
+            ``,
+            `### Targets`,
+            `- TP1: $[price] ([%] gain) — partial exit [%]`,
+            `- TP2: $[price] ([%] gain) — partial exit [%]`,
+            `- TP3: $[price] ([%] gain) — final exit`,
+            ``,
+            `### Risk/Reward`,
+            `- RR ratio: [X:1]`,
+            `- Expected value: [+/- %]`,
+            ``,
+            `### Thesis in One Sentence`,
+            `[Why this trade makes sense right now]`,
+            ``,
+            `### Invalidation`,
+            `[Exactly what would make you exit early / kill the thesis]`,
+        ].filter(Boolean).join("\n");
         try {
-            const history = messages.map(m => ({ role: m.role, content: m.content }));
-            const answer = await (0, llm_js_1.callLLM)(NOEL_SYSTEM_PROMPT, question, 1024, history);
+            const systemPrompt = await buildSystemPrompt(`${token} trade ${riskTolerance} ${timeframe ?? ""}`);
+            const answer = await (0, llm_js_1.callLLM)(systemPrompt, prompt, 1200);
             return { content: [{ type: "text", text: answer }] };
         }
         catch (err) {
-            console.error(`Local LLM failed, falling back to Convex: ${err.message}`);
+            return { content: [{ type: "text", text: `trade_plan error: ${err.message}` }], isError: true };
         }
     }
-    // Fallback: route through Convex backend (uses server's configured key)
-    const data = await (0, convex_js_1.callConvex)("/mcp/chat", "POST", {
-        question,
-        agentId: "noel-default",
-        messages,
-    }, "ask_noel");
-    return { content: [{ type: "text", text: data.answer ?? JSON.stringify(data) }] };
+    return null;
 }

package/dist/tools/market.js

@@ -23,6 +23,20 @@ async function cgFetch(path) {
         throw new Error(`CoinGecko ${res.status}`);
     return res.json();
 }
+async function resolveTokenId(query) {
+    const upper = query.trim().toUpperCase();
+    if (SYMBOL_TO_ID[upper])
+        return { id: SYMBOL_TO_ID[upper], symbol: upper };
+    // Fallback: search CoinGecko — handles any token not in the static map
+    try {
+        const res = await cgFetch(`/search?query=${encodeURIComponent(query)}`);
+        const coin = res.coins?.[0];
+        if (coin?.id)
+            return { id: coin.id, symbol: coin.symbol?.toUpperCase() ?? upper };
+    }
+    catch { }
+    return null;
+}
 function fmt(n, decimals = 2) {
     if (n == null)
         return "—";
@@ -63,9 +77,55 @@ exports.MARKET_TOOLS = [
             required: ["question"],
         },
     },
+    {
+        name: "compare_tokens",
+        description: "Compare 2–5 tokens side by side — price, 24h/7d change, market cap, volume, and ATH drawdown. " +
+            "Ideal for deciding between assets or tracking a portfolio watchlist.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tokens: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "2–5 token symbols to compare, e.g. ['BTC', 'ETH', 'SOL']",
+                    minItems: 2,
+                    maxItems: 5,
+                },
+            },
+            required: ["tokens"],
+        },
+    },
+    {
+        name: "market_overview",
+        description: "Global crypto market snapshot: Fear & Greed Index, BTC dominance, total market cap, DeFi TVL, " +
+            "ETH gas, trending tokens, and top sector leaders. Use for a full market briefing.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "token_history",
+        description: "Get historical price data for a token. Returns OHLC candles for the requested timeframe. " +
+            "Use to understand price trends, identify support/resistance levels, or calculate % changes over time.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: { type: "string", description: "Token symbol, e.g. 'BTC', 'ETH', 'SOL'" },
+                days: {
+                    type: "number",
+                    description: "Number of days of history (1=24h, 7=7d, 30=30d, 90=90d, 365=1y). Default: 7",
+                },
+            },
+            required: ["token"],
+        },
+    },
 ];
 const GetMarketDataSchema = zod_1.z.object({ token: zod_1.z.string().optional() });
 const GetTokenDataSchema = zod_1.z.object({ question: zod_1.z.string().min(1) });
+const CompareTokensSchema = zod_1.z.object({ tokens: zod_1.z.array(zod_1.z.string()).min(2).max(5) });
+const TokenHistorySchema = zod_1.z.object({ token: zod_1.z.string().min(1), days: zod_1.z.number().positive().optional() });
 async function fetchMarketSnapshot() {
     try {
         const data = await cgFetch("/coins/markets?vs_currency=usd&ids=bitcoin,ethereum,solana&sparkline=false&price_change_percentage=24h");
@@ -91,10 +151,10 @@ async function handleMarketTool(name, args) {
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
             const { token } = parsed.data;
             if (token) {
-                const sym = token.toUpperCase();
-                const id = SYMBOL_TO_ID[sym];
-                if (!id)
-                    return { content: [{ type: "text", text: `Unknown token: ${sym}. Try get_token_data for specific lookup.` }], isError: true };
+                const resolved = await resolveTokenId(token);
+                if (!resolved)
+                    return { content: [{ type: "text", text: `Token not found: "${token}". Try a full name like "pepe" or a known symbol.` }], isError: true };
+                const { id, symbol: sym } = resolved;
                 const [data, trending] = await Promise.all([
                     cgFetch(`/coins/markets?vs_currency=usd&ids=${id}&sparkline=false&price_change_percentage=24h`),
                     cgFetch("/search/trending"),
@@ -148,9 +208,14 @@ async function handleMarketTool(name, args) {
             const parsed = GetTokenDataSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            const q = parsed.data.question.toUpperCase();
-            const sym = Object.keys(SYMBOL_TO_ID).find((s) => new RegExp(`\\b${s}\\b`).test(q)) ?? "BTC";
-            const id = SYMBOL_TO_ID[sym];
+            const q = parsed.data.question;
+            // Try to extract a known symbol first, then fall back to search
+            const upperQ = q.toUpperCase();
+            const knownSym = Object.keys(SYMBOL_TO_ID).find((s) => new RegExp(`\\b${s}\\b`).test(upperQ));
+            const resolved = await resolveTokenId(knownSym ?? q);
+            if (!resolved)
+                return { content: [{ type: "text", text: `Token not found: "${q}". Try a symbol like "ETH" or a full name.` }], isError: true };
+            const { id, symbol: sym } = resolved;
             const data = await cgFetch(`/coins/markets?vs_currency=usd&ids=${id}&sparkline=false&price_change_percentage=24h`);
             const c = data[0];
             if (!c)
@@ -168,6 +233,116 @@ async function handleMarketTool(name, args) {
             ];
             return { content: [{ type: "text", text: lines.join("\n") }] };
         }
+        case "compare_tokens": {
+            const parsed = CompareTokensSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const syms = parsed.data.tokens.map(t => t.toUpperCase());
+            const ids = syms.map(s => SYMBOL_TO_ID[s]).filter(Boolean);
+            const unknown = syms.filter(s => !SYMBOL_TO_ID[s]);
+            if (!ids.length)
+                return { content: [{ type: "text", text: `Unknown tokens: ${unknown.join(", ")}` }], isError: true };
+            const data = await cgFetch(`/coins/markets?vs_currency=usd&ids=${ids.join(",")}&sparkline=false&price_change_percentage=24h,7d`);
+            const header = [
+                `**Token Comparison** — ${new Date().toUTCString()}`,
+                unknown.length ? `\n⚠️ Unknown: ${unknown.join(", ")}` : "",
+                ``,
+                `| Token | Price | 24h | 7d | Mcap | Vol 24h | ATH% |`,
+                `|-------|-------|-----|----|------|---------|------|`,
+            ].filter(Boolean);
+            const rows = data.map((c) => {
+                const sym = c.symbol?.toUpperCase();
+                const ch24 = c.price_change_percentage_24h ?? 0;
+                const ch7d = c.price_change_percentage_7d_in_currency ?? 0;
+                const athPct = c.ath_change_percentage ?? 0;
+                const s = (n) => `${n >= 0 ? "+" : ""}${fmt(n)}%`;
+                return `| **${sym}** | ${fmtPrice(c.current_price)} | ${s(ch24)} | ${s(ch7d)} | ${fmtB(c.market_cap)} | ${fmtB(c.total_volume)} | ${fmt(athPct)}% |`;
+            });
+            return { content: [{ type: "text", text: [...header, ...rows].join("\n") }] };
+        }
+        case "market_overview": {
+            const [globalData, fearGreed, trending] = await Promise.allSettled([
+                cgFetch("/global"),
+                fetch("https://api.alternative.me/fng/", { signal: AbortSignal.timeout(8000) }).then(r => r.json()),
+                cgFetch("/search/trending"),
+            ]);
+            const global = globalData.status === "fulfilled" ? globalData.value.data : null;
+            const fg = fearGreed.status === "fulfilled" ? fearGreed.value?.data?.[0] : null;
+            const trendCoins = trending.status === "fulfilled" ? (trending.value?.coins ?? []) : [];
+            const totalMcap = global?.total_market_cap?.usd;
+            const defiTvl = global?.total_value_locked?.usd;
+            const btcDom = global?.market_cap_percentage?.btc;
+            const ethDom = global?.market_cap_percentage?.eth;
+            const mcap24hChange = global?.market_cap_change_percentage_24h_usd;
+            const fgLabel = fg ? `${fg.value}/100 — ${fg.value_classification}` : "unavailable";
+            const fgEmoji = fg ? (Number(fg.value) >= 75 ? "🟢 Extreme Greed" : Number(fg.value) >= 55 ? "🟢 Greed" : Number(fg.value) >= 45 ? "🟡 Neutral" : Number(fg.value) >= 25 ? "🔴 Fear" : "🔴 Extreme Fear") : "";
+            const lines = [
+                `## 🌍 Global Crypto Market`,
+                `_${new Date().toUTCString()}_`,
+                ``,
+                `**Fear & Greed:** ${fgEmoji} ${fg?.value ?? "—"}/100 (${fg?.value_classification ?? "—"})`,
+                totalMcap ? `**Total Market Cap:** ${fmtB(totalMcap)} (${mcap24hChange != null ? `${mcap24hChange >= 0 ? "+" : ""}${fmt(mcap24hChange)}% 24h` : ""})` : "",
+                btcDom != null ? `**BTC Dominance:** ${fmt(btcDom)}%  |  **ETH:** ${fmt(ethDom ?? 0)}%` : "",
+                defiTvl ? `**DeFi TVL:** ${fmtB(defiTvl)}` : "",
+                global?.active_cryptocurrencies ? `**Active Coins:** ${global.active_cryptocurrencies.toLocaleString()}` : "",
+                ``,
+            ].filter(l => l !== "");
+            if (trendCoins.length > 0) {
+                lines.push(`**🔥 Trending Now**`);
+                for (const t of trendCoins.slice(0, 7)) {
+                    const item = t.item;
+                    const rank = item.market_cap_rank ? `#${item.market_cap_rank}` : "unranked";
+                    lines.push(`• **${item.symbol}** (${rank}) — ${item.name}`);
+                }
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "token_history": {
+            const parsed = TokenHistorySchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const days = parsed.data.days ?? 7;
+            const resolved = await resolveTokenId(parsed.data.token);
+            if (!resolved)
+                return { content: [{ type: "text", text: `Token not found: "${parsed.data.token}". Try a symbol like "ETH" or a full name.` }], isError: true };
+            const { id, symbol: sym } = resolved;
+            const [ohlc, current] = await Promise.all([
+                cgFetch(`/coins/${id}/ohlc?vs_currency=usd&days=${days}`),
+                cgFetch(`/coins/markets?vs_currency=usd&ids=${id}&sparkline=false&price_change_percentage=24h`),
+            ]);
+            const c = current[0];
+            const candles = ohlc ?? [];
+            if (!candles.length)
+                return { content: [{ type: "text", text: `No history data for ${sym}` }], isError: true };
+            const first = candles[0];
+            const last = candles[candles.length - 1];
+            const openPrice = first[1];
+            const closePrice = last[4];
+            const periodChange = ((closePrice - openPrice) / openPrice) * 100;
+            const highs = candles.map(c => c[2]);
+            const lows = candles.map(c => c[3]);
+            const periodHigh = Math.max(...highs);
+            const periodLow = Math.min(...lows);
+            const lines = [
+                `## ${sym} — ${days}d History`,
+                ``,
+                `**Current:** ${fmtPrice(c?.current_price)} (${(c?.price_change_percentage_24h ?? 0) >= 0 ? "+" : ""}${fmt(c?.price_change_percentage_24h)}% 24h)`,
+                `**Period open:** ${fmtPrice(openPrice)}`,
+                `**Period close:** ${fmtPrice(closePrice)} (${periodChange >= 0 ? "+" : ""}${fmt(periodChange)}% over ${days}d)`,
+                `**${days}d High:** ${fmtPrice(periodHigh)}`,
+                `**${days}d Low:** ${fmtPrice(periodLow)}`,
+                `**Range:** ${fmt((periodHigh - periodLow) / periodLow * 100)}% spread`,
+                ``,
+                `**Last 10 candles (OHLC):**`,
+                `| Date | Open | High | Low | Close |`,
+                `|------|------|------|-----|-------|`,
+                ...candles.slice(-10).map(([ts, o, h, l, cl]) => {
+                    const d = new Date(ts).toISOString().slice(0, 10);
+                    return `| ${d} | ${fmtPrice(o)} | ${fmtPrice(h)} | ${fmtPrice(l)} | ${fmtPrice(cl)} |`;
+                }),
+            ];
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
         default:
             return null;
     }