@finchagentic/mcp 4.0.0

package/dist/tools/miroshark.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIROSHARK_TOOLS = void 0;
+exports.handleMirosharkTool = handleMirosharkTool;
+const CONVEX_SITE = process.env.FINCH_CONVEX_URL ?? "https://befitting-porcupine-276.convex.site";
+exports.MIROSHARK_TOOLS = [
+    {
+        name: "miroshark_simulate",
+        description: "Simulate any scenario using MiroShark multi-agent AI. Use this when the user asks to simulate, model, or explore 'what happens if' - market crashes, regulations, social events, macro changes. " +
+            "AI agents act as traders, analysts, journalists, and social actors. Returns a simulation_id to track progress.",
+        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?'",
+                },
+            },
+            required: ["scenario"],
+        },
+    },
+    {
+        name: "miroshark_status",
+        description: "Poll the status of a MiroShark simulation. Returns preparation progress, running progress, or - when finished - the full agent action feed with a per-type breakdown for YOU to read the run from. Automatically starts the simulation when agent preparation completes. No API key needed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                simulation_id: {
+                    type: "string",
+                    description: "Simulation ID returned by miroshark_simulate",
+                },
+            },
+            required: ["simulation_id"],
+        },
+    },
+    {
+        name: "miroshark_stop",
+        description: "Stop a running MiroShark simulation.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                simulation_id: {
+                    type: "string",
+                    description: "Simulation ID to stop",
+                },
+            },
+            required: ["simulation_id"],
+        },
+    },
+];
+// ── HTTP helpers ──────────────────────────────────────────────────────────────
+function authHeaders() {
+    const key = process.env.FINCH_API_KEY ?? process.env.FINCH_SESSION_TOKEN;
+    return key ? { Authorization: `Bearer ${key}` } : {};
+}
+async function miroJson(path, method, body, timeoutMs = 90000) {
+    const res = await fetch(`${CONVEX_SITE}${path}`, {
+        method,
+        headers: { ...authHeaders(), "Content-Type": "application/json" },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`MiroShark ${method} ${path} [${res.status}]: ${text.slice(0, 300)}`);
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`MiroShark non-JSON response: ${text.slice(0, 200)}`);
+    }
+    if (json.success === false)
+        throw new Error(`MiroShark error: ${json.error ?? JSON.stringify(json).slice(0, 300)}`);
+    return json.data ?? json;
+}
+async function miroForm(path, form, timeoutMs = 120000) {
+    // No Content-Type header - browser/fetch sets multipart boundary automatically
+    const res = await fetch(`${CONVEX_SITE}${path}`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: form,
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const text = await res.text();
+    if (!res.ok)
+        throw new Error(`MiroShark POST ${path} [${res.status}]: ${text.slice(0, 300)}`);
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`MiroShark non-JSON response: ${text.slice(0, 200)}`);
+    }
+    if (json.success === false)
+        throw new Error(`MiroShark error: ${json.error ?? JSON.stringify(json).slice(0, 300)}`);
+    return json.data ?? json;
+}
+async function pollUntilDone(taskPath, pollIntervalMs = 8000, maxWaitMs = 180000) {
+    const deadline = Date.now() + maxWaitMs;
+    while (Date.now() < deadline) {
+        await new Promise(r => setTimeout(r, pollIntervalMs));
+        const task = await miroJson(taskPath, "GET");
+        const s = (task.status ?? "").toLowerCase();
+        if (s === "completed" || s === "success")
+            return task;
+        if (s === "failed" || s === "error") {
+            throw new Error(`Task failed: ${task.error ?? task.message ?? s}`);
+        }
+    }
+    throw new Error("Task timed out after 3 minutes");
+}
+// ── Tool handler ──────────────────────────────────────────────────────────────
+async function handleMirosharkTool(name, args) {
+    const a = (args ?? {});
+    // ── miroshark_simulate ────────────────────────────────────────────────────
+    if (name === "miroshark_simulate") {
+        if (!a.scenario?.trim()) {
+            return { content: [{ type: "text", text: "scenario is required" }], isError: true };
+        }
+        try {
+            // Step 1: convert plain-English question into a structured seed document
+            let asked;
+            try {
+                asked = await miroJson("/miroshark/api/simulation/ask", "POST", { question: a.scenario });
+            }
+            catch (err) {
+                const msg = err.message ?? "";
+                if (msg.includes("[404]") || msg.includes("[503]") || msg.includes("Upstream unreachable") || msg.includes("[502]")) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: "MiroShark simulation service is currently unavailable. The backend may be redeploying — try again in a few minutes. If this persists, the MIROSHARK_URL Cloudflare secret may need to be updated (`wrangler secret put MIROSHARK_URL`).",
+                            }],
+                        isError: true,
+                    };
+                }
+                throw err;
+            }
+            const { title, seed_document, simulation_requirement } = asked;
+            // Step 2: generate knowledge-graph ontology from the seed document
+            const form = new FormData();
+            form.append("simulation_requirement", simulation_requirement ?? a.scenario);
+            form.append("project_name", (title ?? a.scenario).slice(0, 100));
+            form.append("url_docs", JSON.stringify([{
+                    title: title ?? "Simulation Context",
+                    url: "",
+                    text: seed_document ?? a.scenario,
+                }]));
+            const ontology = await miroForm("/miroshark/api/graph/ontology/generate", form);
+            const projectId = ontology.project_id;
+            if (!projectId)
+                throw new Error("No project_id in ontology response");
+            // Step 3: kick off the async graph build
+            const built = await miroJson("/miroshark/api/graph/build", "POST", { project_id: projectId });
+            const graphTaskId = built.task_id;
+            if (!graphTaskId)
+                throw new Error("No task_id in graph build response");
+            // Step 4: wait for graph to finish (up to 3 min)
+            await pollUntilDone(`/miroshark/api/graph/task/${graphTaskId}`);
+            // Step 5: create simulation from the built graph
+            const created = await miroJson("/miroshark/api/simulation/create", "POST", { project_id: projectId });
+            const simId = created.simulation_id ?? created.id;
+            if (!simId)
+                throw new Error("No simulation_id in create response");
+            // Step 6: kick off agent preparation (async - don't block)
+            const prepared = await miroJson("/miroshark/api/simulation/prepare", "POST", { simulation_id: simId, parallel_profile_count: 10 });
+            const prepTaskId = prepared.task_id;
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `**MiroShark simulation queued** ✓`,
+                            ``,
+                            `Scenario: ${a.scenario}`,
+                            `Project: \`${projectId}\``,
+                            `Simulation ID: \`${simId}\``,
+                            `Status: preparing agents${prepTaskId ? ` (task: ${prepTaskId})` : ""}`,
+                            ``,
+                            `Agent preparation runs in the background. Poll progress with:`,
+                            `\`miroshark_status simulation_id="${simId}"\``,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `MiroShark error: ${err.message}` }], isError: true };
+        }
+    }
+    // ── miroshark_status ──────────────────────────────────────────────────────
+    if (name === "miroshark_status") {
+        if (!a.simulation_id?.trim()) {
+            return { content: [{ type: "text", text: "simulation_id is required" }], isError: true };
+        }
+        const simId = a.simulation_id.trim();
+        if (!/^[a-zA-Z0-9_-]{5,100}$/.test(simId)) {
+            return { content: [{ type: "text", text: "Invalid simulation_id format." }], isError: true };
+        }
+        try {
+            // Check run status first
+            const runStatus = await miroJson(`/miroshark/api/simulation/${simId}/run-status`, "GET").catch(() => ({ runner_status: "idle" }));
+            const runnerStatus = (runStatus?.runner_status ?? "idle").toLowerCase();
+            // If not yet running, check whether agents are prepared by probing /config
+            // (config only exists after /prepare completes)
+            if (runnerStatus === "idle") {
+                const config = await miroJson(`/miroshark/api/simulation/${simId}/config`, "GET").catch(() => null);
+                if (!config) {
+                    // Preparation still in progress - check profiles for real-time progress
+                    const profiles = await miroJson(`/miroshark/api/simulation/${simId}/profiles/realtime`, "GET").catch(() => null);
+                    const total = profiles?.total_expected ?? "?";
+                    const ready = profiles?.profiles_ready ?? 0;
+                    return {
+                        content: [{
+                                type: "text",
+                                text: [
+                                    `**MiroShark \`${simId}\`** - preparing agents`,
+                                    total !== "?" ? `Profiles: ${ready} / ${total} ready` : `Profiles generating...`,
+                                    ``,
+                                    `Poll again in ~10 seconds.`,
+                                ].join("\n"),
+                            }],
+                    };
+                }
+                // Config exists → agents prepared → auto-start
+                await miroJson("/miroshark/api/simulation/start", "POST", {
+                    simulation_id: simId,
+                    platform: "parallel",
+                });
+                return {
+                    content: [{
+                            type: "text",
+                            text: [
+                                `**MiroShark \`${simId}\`** - simulation started`,
+                                ``,
+                                `Agents are now active. Poll again in ~15 seconds for progress.`,
+                                `\`miroshark_status simulation_id="${simId}"\``,
+                            ].join("\n"),
+                        }],
+                };
+            }
+            if (runnerStatus === "running") {
+                const round = runStatus.current_round ?? 0;
+                const total = runStatus.total_rounds ?? "?";
+                const pct = runStatus.progress_percent?.toFixed(1) ?? "0";
+                const twitterActs = runStatus.twitter_actions_count ?? 0;
+                const redditActs = runStatus.reddit_actions_count ?? 0;
+                return {
+                    content: [{
+                            type: "text",
+                            text: [
+                                `**MiroShark \`${simId}\`** - running`,
+                                `Round: ${round} / ${total} (${pct}%)`,
+                                `Actions: ${twitterActs} Twitter · ${redditActs} Reddit`,
+                                ``,
+                                `Simulation in progress - poll again in ~15 seconds.`,
+                            ].join("\n"),
+                        }],
+                };
+            }
+            if (runnerStatus === "completed" || runnerStatus === "stopped") {
+                const actionsData = await miroJson(`/miroshark/api/simulation/${simId}/actions?limit=100`, "GET").catch(() => ({ actions: [] }));
+                const actions = actionsData?.actions ?? [];
+                const totalActions = runStatus.total_actions_count ?? actions.length;
+                const rounds = runStatus.current_round ?? "?";
+                const ACTION_EMOJI = {
+                    tweet: "🐦", post: "📝", sell: "📉", buy: "📈",
+                    article: "📰", comment: "💬", alert: "🚨", analyze: "🔍",
+                };
+                // The tool's job is polling the external simulation and returning what
+                // the agents actually did. Reading sentiment off that log is model work
+                // - and the caller can weigh it against the user's actual question,
+                // which a fixed server-side summariser prompt never could. The feed is
+                // returned in full (was: 20 of 50 shown, the rest silently dropped).
+                const feed = actions.map((act) => {
+                    const who = act.agent_name ?? act.agent_id ?? "agent";
+                    const what = (act.action_type ?? act.type ?? "action").toLowerCase();
+                    const emoji = ACTION_EMOJI[what] ?? "•";
+                    const content = act.content ?? act.text ?? "";
+                    return `${emoji} **${who}** [${what}]${content ? `: ${String(content).slice(0, 200)}` : ""}`;
+                });
+                // Counts per action type - mechanical, and it tells the caller at a
+                // glance whether the run was trade-heavy or chatter-heavy.
+                const byType = new Map();
+                for (const act of actions) {
+                    const what = String(act.action_type ?? act.type ?? "action").toLowerCase();
+                    byType.set(what, (byType.get(what) ?? 0) + 1);
+                }
+                const typeLine = [...byType.entries()]
+                    .sort((x, y) => y[1] - x[1])
+                    .map(([t, n]) => `${t} ×${n}`)
+                    .join(" · ");
+                const lines = [
+                    `**MiroShark \`${simId}\`** - ${runnerStatus}`,
+                    `Rounds: ${rounds} · Actions: ${totalActions}`,
+                    ...(typeLine ? [`Breakdown: ${typeLine}`] : []),
+                    "",
+                ];
+                if (feed.length > 0) {
+                    lines.push(`**Agent Feed** (${feed.length}${totalActions > feed.length ? ` of ${totalActions} — API caps the page at 100` : ""}):`);
+                    lines.push(...feed);
+                    lines.push("", "---", "", "## Read the run from this", "", "- **Market sentiment** — net direction across the agents, not the loudest one.", "- **Dominant narrative** — what most agents converged on, and who dissented.", "- **Top 3 agent behaviours** — name the agents and quote what they did.", "- **Outlook** — what the run implies, and what it can't tell you.", "", "This is simulated agent behaviour, not market data. Say so if you carry any of it into a " +
+                        "real position. Worth keeping? Save it with `vault_save` " +
+                        `(type: research, key: \`miroshark-${simId.slice(0, 8)}\`).`);
+                }
+                if (feed.length === 0)
+                    lines.push("_No agent actions recorded for this run._");
+                return { content: [{ type: "text", text: lines.join("\n") }] };
+            }
+            // Fallback: unknown state
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `**MiroShark \`${simId}\`** - status: ${runnerStatus || "unknown"}`,
+                            ``,
+                            `If agents are still preparing, poll again shortly.`,
+                        ].filter(Boolean).join("\n"),
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `MiroShark error: ${err.message}` }], isError: true };
+        }
+    }
+    // ── miroshark_stop ────────────────────────────────────────────────────────
+    if (name === "miroshark_stop") {
+        if (!a.simulation_id?.trim()) {
+            return { content: [{ type: "text", text: "simulation_id is required" }], isError: true };
+        }
+        const simId = a.simulation_id.trim();
+        if (!/^[a-zA-Z0-9_-]{5,100}$/.test(simId)) {
+            return { content: [{ type: "text", text: "Invalid simulation_id format." }], isError: true };
+        }
+        try {
+            await miroJson(`/miroshark/api/simulation/${simId}/stop`, "POST", {});
+            return { content: [{ type: "text", text: `⏹️ Simulation \`${simId}\` stopped.` }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `MiroShark error: ${err.message}` }], isError: true };
+        }
+    }
+    return null;
+}

package/dist/tools/monitor.js

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MONITOR_TOOLS = void 0;
+exports.buildMonitorList = buildMonitorList;
+exports.handleMonitorTool = handleMonitorTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+const TRIGGER_BASE = "https://api.trigger.dev/api/v1";
+const MONITOR_TASK_ID = "finch-monitor";
+const MONITOR_INPUT_SCHEMA = {
+    type: "object",
+    properties: {
+        topic: { type: "string", description: "What to research - topic, keyword, or question" },
+        schedule: {
+            type: "string",
+            description: "Cron expression or preset. Presets: 'daily-8am', 'daily-6pm', 'weekly-monday', 'hourly'. Or raw cron: '0 8 * * *'",
+        },
+        label: { type: "string", description: "Short label to identify this schedule (e.g. 'morning brief', 'competitor watch')" },
+    },
+    required: ["topic", "schedule"],
+};
+exports.MONITOR_TOOLS = [
+    {
+        name: "schedule_research",
+        description: "Schedule recurring autonomous research on any topic - runs on a cron schedule, saves findings to vault, " +
+            "and sends a Telegram notification. The agent runs completely on its own with no prompting needed. " +
+            "Requires TRIGGER_SECRET_KEY env var (trigger.dev). " +
+            "Examples: daily morning briefing, weekly competitor analysis, hourly price alerts, monthly industry report.",
+        inputSchema: MONITOR_INPUT_SCHEMA,
+    },
+    {
+        name: "list_monitors",
+        description: "List all active scheduled research monitors - shows topic, schedule, next run, and monitor ID.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "cancel_monitor",
+        description: "PERMANENT. Cancel and delete a scheduled research monitor — the schedule is removed and " +
+            "cannot be restored. Requires confirm: true. Run list_monitors first and show the user which " +
+            "monitor (id + topic) you are about to delete.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Monitor ID (from list_monitors)" },
+                confirm: { type: "boolean", description: "Must be true to delete. Guards against removing the wrong monitor." },
+            },
+            required: ["id", "confirm"],
+        },
+    },
+];
+const CRON_PRESETS = {
+    "daily-8am": "0 8 * * *",
+    "daily-6pm": "0 18 * * *",
+    "weekly-monday": "0 8 * * 1",
+    "hourly": "0 * * * *",
+};
+const CreateSchema = zod_1.z.object({
+    topic: zod_1.z.string().min(1).max(200),
+    schedule: zod_1.z.string().min(1),
+    label: zod_1.z.string().max(80).optional(),
+});
+const CancelSchema = zod_1.z.object({ id: zod_1.z.string().min(1) });
+function getKey() {
+    return process.env.TRIGGER_SECRET_KEY ?? null;
+}
+function noKeyMsg() {
+    return {
+        content: [{
+                type: "text",
+                text: [
+                    `⚠️ **TRIGGER_SECRET_KEY not set.**`,
+                    ``,
+                    `To enable autonomous monitors:`,
+                    `1. Sign up at trigger.dev (free tier available)`,
+                    `2. Create a project, go to API Keys → copy your Secret Key`,
+                    `3. Add to your MCP config env block: \`"TRIGGER_SECRET_KEY": "tr_prod_..."\``,
+                    `4. In the finch worker directory, run: \`npx trigger.dev@latest deploy\``,
+                    ``,
+                    `Then monitors will run autonomously - no chat needed.`,
+                ].join("\n"),
+            }],
+        isError: true,
+    };
+}
+function resolveCron(input) {
+    return CRON_PRESETS[input] ?? input;
+}
+// Structured output builder for list_monitors (schema in output-schemas.ts).
+function buildMonitorList(schedules, configs = {}) {
+    return {
+        count: schedules.length,
+        monitors: schedules.map((s) => {
+            const cfg = s.externalId ? configs[s.externalId] : undefined;
+            return {
+                id: s.id ?? null,
+                externalId: s.externalId ?? null,
+                label: cfg?.label ?? s.externalId ?? s.id ?? null,
+                topic: cfg?.topic ?? null,
+                cron: s.cron ?? null,
+                nextRun: s.nextRun ?? null,
+            };
+        }),
+    };
+}
+async function handleMonitorTool(name, args) {
+    if (name === "schedule_research" || name === "create_monitor") {
+        const parsed = CreateSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        const key = getKey();
+        if (!key)
+            return noKeyMsg();
+        const { topic, schedule, label } = parsed.data;
+        const cron = resolveCron(schedule);
+        // Dedup gate - reject if the user already has a monitor with the exact
+        // same topic + schedule combo. Stops "track AI news daily" from being
+        // created 4× by an over-eager agent loop, which is what produced the
+        // duplicate Telegram briefings users complained about.
+        try {
+            const existingMonitors = await (0, convex_js_1.callConvex)("/vault/list", "POST", { type: "workflow", tags: ["monitor-config"] }, "list_monitors_for_dedup");
+            const duplicates = (existingMonitors?.entries ?? []).filter((e) => {
+                try {
+                    const cfg = JSON.parse(e.content ?? "{}");
+                    const sameTopic = (cfg.topic ?? "").toLowerCase().trim() === topic.toLowerCase().trim();
+                    const sameCron = (cfg.cron ?? "") === cron;
+                    return sameTopic && sameCron;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (duplicates.length > 0) {
+                const existingIds = duplicates
+                    .map((d) => {
+                    try {
+                        return JSON.parse(d.content ?? "{}").scheduleId;
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter(Boolean);
+                return {
+                    content: [{
+                            type: "text",
+                            text: [
+                                `⚠️ **Duplicate monitor blocked**`,
+                                ``,
+                                `You already have ${duplicates.length} active monitor${duplicates.length > 1 ? "s" : ""} for the exact topic + schedule:`,
+                                `  • Topic:    ${topic}`,
+                                `  • Schedule: ${schedule}`,
+                                ``,
+                                existingIds.length > 0
+                                    ? `Existing schedule ID${existingIds.length > 1 ? "s" : ""}: ${existingIds.map((id) => `\`${id}\``).join(", ")}`
+                                    : "",
+                                ``,
+                                `Cancel the old one first if you want to recreate:`,
+                                `  \`cancel_monitor id: "<schedule_id>"\``,
+                                ``,
+                                `Or use a more specific topic to make this a distinct monitor.`,
+                            ].filter(Boolean).join("\n"),
+                        }],
+                };
+            }
+        }
+        catch {
+            // Dedup check failed (auth or network) - continue, better to allow than
+            // block on infrastructure errors.
+        }
+        // Unique stable ID - worker reads config from vault using this as key
+        const externalId = `monitor-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+        try {
+            const res = await fetch(`${TRIGGER_BASE}/schedules`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", "Authorization": `Bearer ${key}` },
+                body: JSON.stringify({ task: MONITOR_TASK_ID, cron, externalId, deduplicationKey: externalId }),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                return { content: [{ type: "text", text: `Failed to create monitor: ${err}` }], isError: true };
+            }
+            const data = await res.json();
+            const scheduleId = data.id ?? externalId;
+            // Save config to vault so the worker can retrieve topic + metadata
+            let configSaved = true;
+            try {
+                await (0, convex_js_1.callConvex)("/vault/save", "POST", {
+                    type: "workflow",
+                    title: `Monitor: ${label ?? topic}`,
+                    content: JSON.stringify({ topic, label: label ?? topic, cron, scheduleId, externalId }),
+                    key: `monitor-config/${externalId}`,
+                    agentId: "os",
+                    tags: ["monitor-config"],
+                    commitMsg: "create_monitor config",
+                }, "vault_save");
+            }
+            catch {
+                configSaved = false;
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `✅ **Monitor created**`,
+                            ``,
+                            `📌 Topic:    ${topic}`,
+                            `🕐 Schedule: ${cron}${CRON_PRESETS[schedule] ? ` (${schedule})` : ""}`,
+                            `🆔 ID:       ${scheduleId}`,
+                            data.nextRun ? `⏭️ Next run: ${new Date(data.nextRun).toUTCString()}` : "",
+                            ``,
+                            configSaved
+                                ? `The agent will research "${topic}" on schedule, save findings to vault, and send a Telegram notification if configured.`
+                                : `⚠️ Monitor schedule created but config save failed - the agent may use a default topic on first run. Try \`cancel_monitor\` and recreate.`,
+                            `Use \`list_monitors\` to see all active monitors.`,
+                        ].filter(Boolean).join("\n"),
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Monitor error: ${err.message}` }], isError: true };
+        }
+    }
+    if (name === "list_monitors") {
+        const key = getKey();
+        if (!key)
+            return noKeyMsg();
+        try {
+            const res = await fetch(`${TRIGGER_BASE}/schedules`, {
+                headers: { "Authorization": `Bearer ${key}` },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                return { content: [{ type: "text", text: `Failed to list monitors: ${err}` }], isError: true };
+            }
+            const data = await res.json();
+            const schedules = (data.data ?? []).filter((s) => (s.task ?? s.taskIdentifier) === MONITOR_TASK_ID);
+            if (!schedules.length) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `No active monitors.\n\nUse \`create_monitor\` to set up an autonomous agent that runs on a schedule.`,
+                        }],
+                    structuredContent: buildMonitorList([]),
+                };
+            }
+            // Load topic labels from vault for each schedule
+            const configMap = new Map();
+            await Promise.allSettled(schedules
+                .filter(s => s.externalId)
+                .map(async (s) => {
+                try {
+                    // `/vault/entry`, not `/vault/read` — the latter 404s, which this
+                    // catch used to hide, leaving every monitor listed by raw id.
+                    const cfg = await (0, convex_js_1.callConvex)(`/vault/entry?key=monitor-config/${s.externalId}`, "GET", undefined, "vault_read");
+                    if (cfg?.content) {
+                        const parsed = JSON.parse(cfg.content);
+                        configMap.set(s.externalId, { topic: parsed.topic, label: parsed.label ?? parsed.topic });
+                    }
+                }
+                catch { /* skip - show raw externalId */ }
+            }));
+            const lines = [`📋 **Active Monitors** - ${schedules.length} running\n`];
+            for (const s of schedules) {
+                const cfg = s.externalId ? configMap.get(s.externalId) : undefined;
+                const label = cfg?.label ?? s.externalId ?? s.id;
+                const topic = cfg?.topic ? ` - ${cfg.topic}` : "";
+                const next = s.nextRun ? new Date(s.nextRun).toUTCString() : "unknown";
+                lines.push(`**${label}**${topic}`);
+                lines.push(`  ID: \`${s.id}\` · Cron: \`${s.cron}\` · Next: ${next}`);
+                lines.push("");
+            }
+            lines.push(`Use \`cancel_monitor id: "<id>"\` to stop a monitor.`);
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+                structuredContent: buildMonitorList(schedules, Object.fromEntries(configMap)),
+            };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `List error: ${err.message}` }], isError: true };
+        }
+    }
+    if (name === "cancel_monitor") {
+        const parsed = CancelSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+        if (args?.confirm !== true) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "Refusing to cancel: this deletes the monitor's schedule permanently. Show the user " +
+                            "which monitor it is (run `list_monitors`), then pass `confirm: true`.",
+                    }],
+                isError: true,
+            };
+        }
+        const key = getKey();
+        if (!key)
+            return noKeyMsg();
+        const { id } = parsed.data;
+        try {
+            const res = await fetch(`${TRIGGER_BASE}/schedules/${id}`, {
+                method: "DELETE",
+                headers: { "Authorization": `Bearer ${key}` },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                return { content: [{ type: "text", text: `Failed to cancel monitor: ${err}` }], isError: true };
+            }
+            return { content: [{ type: "text", text: `✅ Monitor \`${id}\` cancelled.` }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Cancel error: ${err.message}` }], isError: true };
+        }
+    }
+    return null;
+}