@noelclaw/mcp 1.0.0

package/dist/tools/insight.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSIGHT_TOOLS = void 0;
+exports.handleInsightTool = handleInsightTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+exports.INSIGHT_TOOLS = [
+    {
+        name: "get_insight",
+        description: "Get Noel's daily crypto + macro insight. Covers Bitcoin/ETH price action, macro events, trending narratives on X/Twitter, and one actionable takeaway.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "ask_noel",
+        description: "Ask Noel AI for DeFi analysis, trade ideas, market outlook, and crypto research. Noel has live market context.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                question: { type: "string", description: "Your question or request for Noel" },
+                messages: {
+                    type: "array",
+                    description: "Previous conversation messages for context (optional)",
+                    items: {
+                        type: "object",
+                        properties: { role: { type: "string", enum: ["user", "assistant"] }, content: { type: "string" } },
+                        required: ["role", "content"],
+                    },
+                },
+            },
+            required: ["question"],
+        },
+    },
+];
+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(),
+});
+async function handleInsightTool(name, args) {
+    switch (name) {
+        case "get_insight": {
+            const data = await (0, convex_js_1.callConvex)("/insights/now", "GET", undefined, "get_insight");
+            const insight = data.insight ?? data.text ?? data.choices?.[0]?.message?.content ?? "Failed to get insight";
+            return { content: [{ type: "text", text: insight }] };
+        }
+        case "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 data = await (0, convex_js_1.callConvex)("/mcp/chat", "POST", {
+                question: parsed.data.question,
+                agentId: "noel-default",
+                messages: parsed.data.messages ?? [],
+            }, "ask_noel");
+            return { content: [{ type: "text", text: data.answer ?? JSON.stringify(data) }] };
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/market.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKET_TOOLS = void 0;
+exports.handleMarketTool = handleMarketTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+exports.MARKET_TOOLS = [
+    {
+        name: "get_market_data",
+        description: "Get live crypto market data: top 20 coins by market cap, trending coins, and key prices for BTC/ETH/SOL. Results are also sent to your Telegram if configured.",
+        inputSchema: {
+            type: "object",
+            properties: { token: { type: "string", description: "Optional: specific token to focus on, e.g. 'BTC', 'ETH'" } },
+            required: [],
+        },
+    },
+    {
+        name: "get_token_data",
+        description: "Get market data for specific tokens. Returns price, 24h change, market cap, and volume. Results are sent to your Telegram if configured.",
+        inputSchema: {
+            type: "object",
+            properties: { question: { type: "string", description: "Describe which tokens to look up" } },
+            required: ["question"],
+        },
+    },
+    {
+        name: "get_latest_signal",
+        description: "Get the latest BTC and/or ETH 1H trading signals from Noel. Includes entry price, take profit targets, stop loss, confidence score, and reasoning. Generated daily at 08:00 UTC.",
+        inputSchema: {
+            type: "object",
+            properties: { token: { type: "string", description: "Token to get signal for: 'BTC', 'ETH', or omit for both" } },
+            required: [],
+        },
+    },
+    {
+        name: "get_signal_history",
+        description: "Get signal history with win/loss record and winrate statistics.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: { type: "string", description: "BTC or ETH" },
+                days: { type: "number", description: "Number of days to look back (default: 7)" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "get_smart_money_alerts",
+        description: "Get smart money and insider wallet movements for micro-cap tokens.",
+        inputSchema: {
+            type: "object",
+            properties: { hours: { type: "number", description: "How many hours back to look (default: 24)" } },
+            required: [],
+        },
+    },
+    {
+        name: "get_daily_recap",
+        description: "Get today's trading performance recap with winrate, PnL stats, and AI review.",
+        inputSchema: {
+            type: "object",
+            properties: { date: { type: "string", description: "Date in YYYY-MM-DD format (default: today UTC)" } },
+            required: [],
+        },
+    },
+];
+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 GetLatestSignalSchema = zod_1.z.object({ token: zod_1.z.string().optional() });
+const GetSignalHistorySchema = zod_1.z.object({ token: zod_1.z.string().optional(), days: zod_1.z.number().optional() });
+const GetSmartMoneyAlertsSchema = zod_1.z.object({ hours: zod_1.z.number().optional() });
+const GetDailyRecapSchema = zod_1.z.object({ date: zod_1.z.string().optional() });
+async function handleMarketTool(name, args) {
+    switch (name) {
+        case "get_market_data": {
+            const parsed = GetMarketDataSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: token ${parsed.error.issues[0].message}` }], isError: true };
+            const { token } = parsed.data;
+            const tokenQ = token ? `?token=${encodeURIComponent(token)}` : "";
+            const data = await (0, convex_js_1.callConvex)(`/mcp/market${tokenQ}`, "GET", undefined, "get_market_data");
+            const lines = [`**Market Data** — ${data.fetchedAt ?? new Date().toISOString()}`, ""];
+            if (data.keyPrices) {
+                lines.push("**Key Prices**");
+                for (const [coin, info] of Object.entries(data.keyPrices)) {
+                    const price = info.usd?.toLocaleString("en-US", { style: "currency", currency: "USD" });
+                    const change = info.usd_24h_change?.toFixed(2);
+                    const sign = (info.usd_24h_change ?? 0) >= 0 ? "+" : "";
+                    lines.push(`• ${coin.toUpperCase()}: ${price} (${sign}${change}%)`);
+                }
+                lines.push("");
+            }
+            if (data.trending?.length) {
+                lines.push("**Trending** (top 10)");
+                for (const c of data.trending) {
+                    const ch = c.change24h?.toFixed(2);
+                    const sign = (c.change24h ?? 0) >= 0 ? "+" : "";
+                    lines.push(`• ${c.name} (${c.symbol?.toUpperCase()}) — rank #${c.rank ?? "?"} ${ch != null ? `${sign}${ch}%` : ""}`);
+                }
+                lines.push("");
+            }
+            if (data.top20?.length) {
+                lines.push("**Top 20 by Market Cap**");
+                lines.push("| # | Name | Price | 24h% |");
+                lines.push("|---|------|-------|------|");
+                for (const c of data.top20) {
+                    const price = c.price?.toLocaleString("en-US", { style: "currency", currency: "USD", maximumFractionDigits: 4 });
+                    const ch = c.change24h?.toFixed(2);
+                    const sign = (c.change24h ?? 0) >= 0 ? "+" : "";
+                    lines.push(`| ${c.rank} | ${c.name} (${c.symbol?.toUpperCase()}) | ${price} | ${sign}${ch}% |`);
+                }
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "get_token_data": {
+            const parsed = GetTokenDataSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: question ${parsed.error.issues[0].message}` }], isError: true };
+            // Extract token symbol from natural-language question
+            const q = parsed.data.question.toUpperCase();
+            const KNOWN = ["BTC", "ETH", "SOL", "BNB", "USDT", "USDC", "XRP", "DOGE", "ADA", "AVAX", "DOT", "LINK", "UNI", "OP", "ARB", "HYPE", "PEPE", "SUI", "APT", "NEAR", "INJ", "TIA", "MATIC", "TON", "SHIB", "WIF", "BONK"];
+            const found = KNOWN.find((t) => new RegExp(`\\b${t}\\b`).test(q));
+            const tokenQ = found ? `?token=${found}` : "";
+            const data = await (0, convex_js_1.callConvex)(`/mcp/market${tokenQ}`, "GET", undefined, "get_token_data");
+            const lines = [`**Token Data** — ${data.fetchedAt ?? new Date().toISOString()}`, ""];
+            if (data.keyPrices) {
+                lines.push("**Prices**");
+                for (const [coin, info] of Object.entries(data.keyPrices)) {
+                    const price = info.usd?.toLocaleString("en-US", { style: "currency", currency: "USD" });
+                    const ch = (info.usd_24h_change ?? 0).toFixed(2);
+                    const sign = (info.usd_24h_change ?? 0) >= 0 ? "+" : "";
+                    lines.push(`• ${coin.toUpperCase()}: ${price} (${sign}${ch}%)`);
+                }
+            }
+            if (data.trending?.length) {
+                lines.push("", "**Trending**");
+                for (const c of data.trending.slice(0, 5)) {
+                    const ch = c.change24h?.toFixed(2);
+                    const sign = (c.change24h ?? 0) >= 0 ? "+" : "";
+                    lines.push(`• ${c.symbol?.toUpperCase()} — #${c.rank ?? "?"} ${ch != null ? `${sign}${ch}%` : ""}`);
+                }
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "get_latest_signal": {
+            const parsed = GetLatestSignalSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: token ${parsed.error.issues[0].message}` }], isError: true };
+            const tokenParam = parsed.data.token?.toUpperCase() ?? "both";
+            const data = await (0, convex_js_1.callConvex)(`/signals/latest${tokenParam !== "BOTH" && tokenParam !== "both" ? `?token=${encodeURIComponent(tokenParam)}` : ""}`, "GET", undefined, "get_latest_signal");
+            const lines = ["**Latest Noel Signals**", ""];
+            for (const [tok, sig] of Object.entries(data)) {
+                if (!sig) {
+                    lines.push(`**${tok}:** No signal available`, "");
+                    continue;
+                }
+                const emoji = sig.signalType === "BUY" ? "🟢" : sig.signalType === "SELL" ? "🔴" : "🟡";
+                lines.push(`${emoji} **${tok}/USD — ${sig.signalType}**`, `Entry: $${sig.entryPrice?.toLocaleString()} | TP1: $${sig.target1?.toLocaleString()}${sig.target2 ? ` | TP2: $${sig.target2?.toLocaleString()}` : ""} | SL: $${sig.stopLoss?.toLocaleString()}`, `Confidence: ${sig.confidence}% | Status: ${sig.status}`, `📝 ${sig.reasoning}`, "");
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "get_signal_history": {
+            const parsed = GetSignalHistorySchema.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 token = parsed.data.token?.toUpperCase() ?? "BTC";
+            const days = parsed.data.days ?? 7;
+            const [hist, wr] = await Promise.all([
+                (0, convex_js_1.callConvex)(`/signals/history?token=${token}&days=${days}`, "GET", undefined, "get_signal_history"),
+                (0, convex_js_1.callConvex)(`/signals/winrate?token=${token}&days=${days}`, "GET", undefined, "get_signal_history"),
+            ]);
+            const lines = [
+                `**${token} Signal History — Last ${days} days**`,
+                `Total: ${wr.total} resolved | Wins: ${wr.wins} | Losses: ${wr.losses}`,
+                `Winrate: ${wr.winrate}% | Avg PnL: ${Number(wr.avgPnl) >= 0 ? "+" : ""}${wr.avgPnl}%`,
+                `Best: +${wr.bestPnl}% | Worst: ${wr.worstPnl}%`,
+                "", "**Recent Signals:**",
+            ];
+            for (const sig of (hist.signals ?? []).slice(0, 5)) {
+                const emoji = sig.signalType === "BUY" ? "🟢" : sig.signalType === "SELL" ? "🔴" : "🟡";
+                const outcome = sig.isWin === true ? "✅" : sig.isWin === false ? "❌" : "⏳";
+                const pnl = sig.pnlPercent != null ? ` (${sig.pnlPercent >= 0 ? "+" : ""}${sig.pnlPercent.toFixed(2)}%)` : "";
+                lines.push(`${emoji} ${sig.token} ${sig.signalType} @ $${sig.entryPrice?.toLocaleString()} — ${outcome} ${sig.status}${pnl}`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "get_smart_money_alerts": {
+            const parsed = GetSmartMoneyAlertsSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: hours ${parsed.error.issues[0].message}` }], isError: true };
+            const hours = parsed.data.hours ?? 24;
+            const data = await (0, convex_js_1.callConvex)(`/whales/latest?hours=${hours}`, "GET", undefined, "get_smart_money_alerts");
+            if (!data.count)
+                return { content: [{ type: "text", text: `No whale alerts in the last ${hours}h.` }] };
+            const lines = [`**Whale Alerts — Last ${hours}h** (${data.count} total)`, ""];
+            for (const alert of (data.alerts ?? []).slice(0, 5)) {
+                const sig = alert.significance === "HIGH" ? "🔴" : "🟡";
+                lines.push(`${sig} **${alert.token} | ${alert.direction}**`, `${alert.description}`, `💡 ${alert.implication}`, "");
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "get_daily_recap": {
+            const parsed = GetDailyRecapSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: date ${parsed.error.issues[0].message}` }], isError: true };
+            const date = parsed.data.date ?? new Date().toISOString().slice(0, 10);
+            let data;
+            try {
+                data = await (0, convex_js_1.callConvex)("/recap/today", "GET", undefined, "get_daily_recap");
+            }
+            catch {
+                return { content: [{ type: "text", text: `No recap available for ${date}` }] };
+            }
+            if (data.error)
+                return { content: [{ type: "text", text: data.error }] };
+            const lines = [
+                `**Noel Daily Recap — ${data.date ?? date}**`, "",
+                `₿ **BTC** — ${data.btcWins}W / ${data.btcLosses}L | Winrate: ${data.btcWinrate?.toFixed(1)}%`,
+                `Best: +${data.btcBestPnl?.toFixed(2)}% | Worst: ${data.btcWorstPnl?.toFixed(2)}%`, "",
+                `Ξ **ETH** — ${data.ethWins}W / ${data.ethLosses}L | Winrate: ${data.ethWinrate?.toFixed(1)}%`,
+                `Best: +${data.ethBestPnl?.toFixed(2)}% | Worst: ${data.ethWorstPnl?.toFixed(2)}%`, "",
+                `**Overall:** ${data.totalWinrate?.toFixed(1)}% winrate | Avg PnL: ${Number(data.avgPnl) >= 0 ? "+" : ""}${data.avgPnl?.toFixed(2)}% per signal`, "",
+                `🤖 AI Review:`, data.aiReview ?? "No review",
+            ];
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/miroshark.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIROSHARK_TOOLS = void 0;
+exports.handleMirosharkTool = handleMirosharkTool;
+exports.MIROSHARK_TOOLS = [
+    {
+        name: "miroshark_simulate",
+        description: "Run a MiroShark multi-agent simulation. Describe a scenario in plain English and get back strategic insights from a network of AI agents (market actors, risk managers, analysts). " +
+            "Returns a simulation ID you can poll with miroshark_status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                scenario: {
+                    type: "string",
+                    description: "Plain-English description of the scenario to simulate. E.g. 'What happens if ETH drops 20% and whale wallets start selling?'",
+                },
+                agents: {
+                    type: "number",
+                    description: "Number of agents in the simulation (default: 10, max: 50)",
+                },
+                steps: {
+                    type: "number",
+                    description: "Number of simulation steps to run (default: 5)",
+                },
+            },
+            required: ["scenario"],
+        },
+    },
+    {
+        name: "miroshark_status",
+        description: "Poll the status and results of a MiroShark simulation by ID. Returns agent outputs, consensus findings, and final strategic insights when complete.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                simulation_id: {
+                    type: "string",
+                    description: "Simulation ID returned by miroshark_simulate",
+                },
+            },
+            required: ["simulation_id"],
+        },
+    },
+];
+function getConfig() {
+    const url = process.env.MIROSHARK_URL?.replace(/\/$/, "");
+    const token = process.env.MIROSHARK_ADMIN_TOKEN;
+    return { url, token };
+}
+async function mirofetch(path, method, body) {
+    const { url, token } = getConfig();
+    if (!url)
+        throw new Error("MIROSHARK_URL not set");
+    if (!token)
+        throw new Error("MIROSHARK_ADMIN_TOKEN not set");
+    const res = await fetch(`${url}${path}`, {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`,
+        },
+        ...(body ? { body: JSON.stringify(body) } : {}),
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!res.ok) {
+        const err = await res.text();
+        throw new Error(`MiroShark ${res.status}: ${err.slice(0, 200)}`);
+    }
+    return res.json();
+}
+async function handleMirosharkTool(name, args) {
+    const a = (args ?? {});
+    if (name === "miroshark_simulate") {
+        if (!a.scenario?.trim()) {
+            return { content: [{ type: "text", text: "scenario is required" }], isError: true };
+        }
+        const { url, token } = getConfig();
+        if (!url || !token) {
+            return {
+                content: [{ type: "text", text: "MiroShark not configured — set MIROSHARK_URL and MIROSHARK_ADMIN_TOKEN" }],
+                isError: true,
+            };
+        }
+        try {
+            // Step 1: ask (parse scenario into simulation params)
+            const asked = await mirofetch("/api/simulation/ask", "POST", { question: a.scenario });
+            // Step 2: create simulation
+            const created = await mirofetch("/api/simulation/create", "POST", {
+                ...asked,
+                num_agents: Math.min(a.agents ?? 10, 50),
+                num_steps: a.steps ?? 5,
+            });
+            const simId = created.simulation_id ?? created.id;
+            if (!simId)
+                throw new Error("No simulation ID in create response");
+            // Step 3: prepare
+            await mirofetch(`/api/simulation/${simId}/prepare`, "POST", {});
+            // Step 4: start
+            await mirofetch(`/api/simulation/${simId}/start`, "POST", {});
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `🦈 **MiroShark simulation started**`,
+                            `Scenario: ${a.scenario}`,
+                            `Simulation ID: \`${simId}\``,
+                            `Agents: ${a.agents ?? 10} · Steps: ${a.steps ?? 5}`,
+                            ``,
+                            `Poll results with: \`miroshark_status simulation_id="${simId}"\``,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `MiroShark error: ${err.message}` }], isError: true };
+        }
+    }
+    if (name === "miroshark_status") {
+        if (!a.simulation_id?.trim()) {
+            return { content: [{ type: "text", text: "simulation_id is required" }], isError: true };
+        }
+        try {
+            const data = await mirofetch(`/api/simulation/${a.simulation_id}/status`, "GET");
+            const status = data.status ?? "unknown";
+            const lines = [
+                `🦈 **MiroShark Simulation \`${a.simulation_id}\`**`,
+                `Status: **${status}**`,
+            ];
+            if (data.progress != null)
+                lines.push(`Progress: ${data.progress}%`);
+            if (status === "completed" && data.results) {
+                lines.push("", "**Results**");
+                if (data.results.summary)
+                    lines.push(data.results.summary);
+                if (Array.isArray(data.results.insights)) {
+                    for (const insight of data.results.insights.slice(0, 5)) {
+                        lines.push(`• ${typeof insight === "string" ? insight : JSON.stringify(insight)}`);
+                    }
+                }
+                if (data.results.consensus)
+                    lines.push("", `**Consensus:** ${data.results.consensus}`);
+            }
+            else if (status === "failed") {
+                lines.push("", `Error: ${data.error ?? "unknown"}`);
+            }
+            else {
+                lines.push("", "Simulation still running — poll again in a few seconds.");
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `MiroShark error: ${err.message}` }], isError: true };
+        }
+    }
+    return null;
+}

package/dist/tools/news.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEWS_TOOLS = void 0;
+exports.handleNewsTool = handleNewsTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+exports.NEWS_TOOLS = [
+    {
+        name: "get_news",
+        description: "Get the latest crypto news digest — top stories, market-moving events, " +
+            "regulatory updates, and AI-generated sentiment summary. Updated every 12 hours.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Number of news items to return (default: 10, max: 30)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "generate_signal",
+        description: "Manually trigger a fresh BTC and/or ETH trading signal right now — " +
+            "instead of waiting for the 08:00 UTC daily cron. " +
+            "Uses live market data, RSI, volume, and sentiment.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: {
+                    type: "string",
+                    description: "Token to generate signal for: 'BTC', 'ETH', or omit for both.",
+                },
+            },
+            required: [],
+        },
+    },
+];
+const GetNewsSchema = zod_1.z.object({ limit: zod_1.z.number().min(1).max(30).optional() });
+const GenerateSignalSchema = zod_1.z.object({ token: zod_1.z.string().optional() });
+async function handleNewsTool(name, args) {
+    switch (name) {
+        case "get_news": {
+            const parsed = GetNewsSchema.safeParse(args ?? {});
+            if (!parsed.success) {
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            }
+            const limit = parsed.data.limit ?? 10;
+            const data = await (0, convex_js_1.callConvex)(`/news/latest?limit=${limit}`, "GET", undefined, "get_news");
+            const articles = data.articles ?? data.news ?? data.items ?? [];
+            if (!articles.length) {
+                return { content: [{ type: "text", text: "No recent news available. Try again shortly." }] };
+            }
+            const lines = [
+                `**Crypto News Digest** — ${data.fetchedAt ?? data.date ?? new Date().toISOString().slice(0, 10)}`,
+                ``,
+            ];
+            if (data.summary) {
+                lines.push(`📊 **Summary:** ${data.summary}`, ``);
+            }
+            for (const a of articles.slice(0, limit)) {
+                const sentiment = a.sentiment === "bullish" ? "🟢" : a.sentiment === "bearish" ? "🔴" : "⚪";
+                lines.push(`${sentiment} **${a.title ?? a.headline ?? "Untitled"}**`);
+                if (a.source)
+                    lines.push(`   _${a.source}${a.publishedAt ? ` · ${a.publishedAt}` : ""}_`);
+                if (a.summary ?? a.description)
+                    lines.push(`   ${(a.summary ?? a.description ?? "").slice(0, 140)}…`);
+                if (a.affectedTokens?.length)
+                    lines.push(`   Tokens: ${a.affectedTokens.join(", ")}`);
+                lines.push(``);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "generate_signal": {
+            const parsed = GenerateSignalSchema.safeParse(args ?? {});
+            if (!parsed.success) {
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            }
+            const token = parsed.data.token?.toUpperCase();
+            const data = await (0, convex_js_1.callConvex)("/signals/generate", "POST", { token }, "generate_signal");
+            if (data.error) {
+                return { content: [{ type: "text", text: `Signal generation failed: ${data.error}` }], isError: true };
+            }
+            const signals = data.signals ?? (data.signal ? [data.signal] : []);
+            if (!signals.length) {
+                return { content: [{ type: "text", text: "Signal generated. Use get_latest_signal to retrieve it." }] };
+            }
+            const lines = [`**Fresh Signals Generated**`, ``];
+            for (const sig of signals) {
+                const emoji = sig.signalType === "BUY" ? "🟢" : sig.signalType === "SELL" ? "🔴" : "🟡";
+                lines.push(`${emoji} **${sig.token}/USD — ${sig.signalType}**`, `Entry: $${sig.entryPrice?.toLocaleString()} | TP1: $${sig.target1?.toLocaleString()}${sig.target2 ? ` | TP2: $${sig.target2?.toLocaleString()}` : ""} | SL: $${sig.stopLoss?.toLocaleString()}`, `Confidence: ${sig.confidence}% | Timeframe: 1H`, `📝 ${sig.reasoning}`, ``);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/research.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESEARCH_TOOLS = void 0;
+exports.handleResearchTool = handleResearchTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+exports.RESEARCH_TOOLS = [
+    {
+        name: "research",
+        description: "Research any crypto topic on demand — like Perplexity but for crypto. Ask about a token, protocol, market event, or trend. Noel searches the web and returns a structured analysis.",
+        inputSchema: {
+            type: "object",
+            properties: { query: { type: "string", description: "Topic to research" } },
+            required: ["query"],
+        },
+    },
+];
+const ResearchSchema = zod_1.z.object({ query: zod_1.z.string().min(1) });
+async function handleResearchTool(name, args) {
+    if (name !== "research")
+        return null;
+    const parsed = ResearchSchema.safeParse(args);
+    if (!parsed.success)
+        return { content: [{ type: "text", text: `Invalid input: query ${parsed.error.issues[0].message}` }], isError: true };
+    const data = await (0, convex_js_1.callConvex)("/mcp/research", "POST", { query: parsed.data.query }, "research");
+    if (!data.success)
+        return { content: [{ type: "text", text: `Research failed: ${data.error ?? "unknown error"}` }] };
+    return { content: [{ type: "text", text: data.text ?? "No results returned." }] };
+}