@astramindapp/mcp-server 0.22.0 → 0.24.0

package/dist/server.js

@@ -44,11 +44,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMindMcpServer = createMindMcpServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
+const mind_client_js_1 = require("./mind-client.js");
 const integration_guide_js_1 = require("./integration-guide.js");
+// ─── Shared MCP result helpers ──────────────────────────────
+// Prefer these over inline `catch (err) → "mind_x error: ${err}"` in new
+// tools: `ok` pretty-prints the payload, `err` flags isError so the agent
+// knows to recover instead of hallucinating, and `apiDetail` surfaces the
+// backend's human-readable detail sentence instead of a raw JSON body dump.
+const err = (t) => ({
+    content: [{ type: "text", text: t }],
+    isError: true,
+});
+const ok = (result) => ({
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+});
+// Backend detail strings beat raw JSON dumps: FastAPI returns
+// {"detail": "..."} (or {"detail": {"message": "..."}}) — surface the
+// human sentence, never the wire body (CLAUDE.md lesson #6).
+const apiDetail = (e) => {
+    try {
+        const parsed = JSON.parse(e.body);
+        const d = parsed?.detail;
+        if (typeof d === "string")
+            return d;
+        if (d && typeof d === "object") {
+            const msg = d.message;
+            if (typeof msg === "string")
+                return msg;
+        }
+    }
+    catch {
+        // not JSON — fall through to the raw body/status text
+    }
+    return e.body || e.statusText;
+};
 function createMindMcpServer(client) {
     const server = new mcp_js_1.McpServer({
         name: "mind",
-        version: "0.17.0",
+        version: "0.24.0",
     }, {
         // Returned to every client in the MCP `initialize` response — the first
         // thing any connecting agent sees about how to integrate with MIND.
@@ -72,16 +105,21 @@ function createMindMcpServer(client) {
     // ─── mind_query ─────────────────────────────────────────
     // Semantic search across the user's knowledge graph.
     // Replaces flat MEMORY.md — returns only relevant memories.
-    server.tool("mind_query", "Search your MIND knowledge graph. Returns AI-synthesized answer from your stored documents, entries, and feed posts. Use this BEFORE making decisions — MIND is your memory.", {
+    server.tool("mind_query", "Search your MIND knowledge graph. Returns RETRIEVED CONTEXT from the graph — documents, entries, entities and relationships — NOT a finished answer. YOU must read that context and write the answer yourself. Does not use MIND's LLM and costs 0 credits. Use this BEFORE making decisions — MIND is your memory. (Pass retrieve_only=false to have MIND synthesize the answer instead, which spends credits.)", {
         query: zod_1.z.string().describe("What to search for in your knowledge graph"),
         mode: zod_1.z
             .enum(["mix", "hybrid", "global", "local", "naive"])
             .optional()
             .default("hybrid")
             .describe("Search mode: hybrid (default, best results — combines semantic + graph traversal), mix (balanced), global (broad graph search), local (focused graph search), naive (simple vector search)"),
-    }, async ({ query, mode }) => {
+        retrieve_only: zod_1.z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe("Default true: return raw graph context for YOU to synthesize, 0 credits. Set false to have MIND's own LLM write the answer (spends credits)."),
+    }, async ({ query, mode, retrieve_only }) => {
         try {
-            const result = await client.query({ query, mode });
+            const result = await client.query({ query, mode, retrieve_only });
             const text = [
                 result.response,
                 "",
@@ -126,7 +164,7 @@ function createMindMcpServer(client) {
     // ─── mind_remember ──────────────────────────────────────
     // Store/manage content in the knowledge graph. Auto-categorized by type.
     // Enhanced: now supports create, delete, search, get, list actions.
-    server.tool("mind_remember", "Store and manage content in your MIND knowledge graph. Use for facts, decisions, learnings, research, notes — anything worth remembering. Auto-categorized. Always log outcomes here after completing tasks. Supports create (default), delete, search, get, and list.\n\n⚠️ PRIVATE vs PUBLIC: `document` and `entry` are PRIVATE to the user's knowledge graph. `feed_post` is a PUBLIC social-media post that appears on the user's public feed for everyone to see. Default to `entry` for all agent outcomes, logs, decisions, and research. NEVER use `feed_post` unless the user explicitly says \"post\", \"share\", \"tweet\", \"feed\", or \"thought to my feed\" — deploy logs, PR notes, work outcomes, and agent activity belong in `entry`, NOT on the public feed.", {
+    server.tool("mind_remember", "Store and manage content in your MIND knowledge graph. Use for facts, decisions, learnings, research, notes — anything worth remembering. Auto-categorized. Always log outcomes here after completing tasks. Supports create (default), delete, search, get, and list.\n\n⚠️ PRIVATE vs PUBLIC: `document` and `entry` are PRIVATE to the user's knowledge graph. `feed_post` is a PUBLIC social-media post that appears on the user's public feed for everyone to see. Default to `entry` for all agent outcomes, logs, decisions, and research. NEVER use `feed_post` unless the user explicitly says \"post\", \"share\", \"tweet\", \"feed\", or \"thought to my feed\" — deploy logs, PR notes, work outcomes, and agent activity belong in `entry`, NOT on the public feed.\n\nTitle rule: lessons are titled 'Lesson - Failure - <behavior>' / 'Lesson - Behavior - <behavior>' / 'Lesson - Win - <behavior>'; never put '/' or parentheses in a title, the card is derived from it.", {
         action: zod_1.z
             .enum(["create", "delete", "search", "get", "list"])
             .optional()
@@ -612,7 +650,7 @@ function createMindMcpServer(client) {
     // Get structured always-loaded context.
     // Equivalent to OpenClaw's SOUL.md + USER.md + AGENTS.md bootstrap injection,
     // but backed by the knowledge graph.
-    server.tool("mind_context", "Get your persistent context from MIND — identity, preferences, rules, and recent activity. Call this at the start of every session to know who you are, who the user is, and what matters right now.", {
+    server.tool("mind_context", "Get your persistent context from MIND — identity, preferences, rules, and recent activity. Returns RETRIEVED CONTEXT (not a finished briefing). YOU synthesize who you are and what matters. Does not use MIND's LLM and costs 0 credits. Call this at the start of every session.", {
         sections: zod_1.z
             .array(zod_1.z.enum(["soul", "user", "rules", "priorities", "recent"]))
             .optional()
@@ -627,7 +665,7 @@ function createMindMcpServer(client) {
                 priorities: "current priorities, active goals, top tasks, what to focus on right now",
                 recent: "most recent activity, what happened today, latest outcomes and decisions",
             };
-            const responses = await Promise.all(sections.map((section) => client.query({ query: sectionQueries[section], mode: "mix" }).then((r) => ({
+            const responses = await Promise.all(sections.map((section) => client.query({ query: sectionQueries[section], mode: "mix", retrieve_only: true }).then((r) => ({
                 section,
                 text: r.response,
             }))));
@@ -1392,6 +1430,155 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── mind_checklists ────────────────────────────────────
+    // The granular level beneath a Task. Shape: Template → Sections[phase] →
+    // Items. Templates (yours + flagship) instantiate into runs attached to a
+    // task or life item; items are toggled and runs completed (which mirrors the
+    // finished checklist into the knowledge graph).
+    server.tool("mind_checklists", "Manage checklists in MIND — the granular level beneath a Task in the Focus→Project→Outcome→Task→Checklist hierarchy. A checklist attaches to a task (parent_type=task) or a Life item (parent_type=life_item) and groups checkable steps into phase-bucketed sections (pre/run/post). Use list_templates/get_template/create_template for reusable blueprints (including global flagship templates), then create a run from a template_id or inline sections_json, toggle_item to check steps, and complete to finish + mirror it into the knowledge graph.", {
+        action: zod_1.z
+            .enum([
+            "list_templates", "get_template", "create_template",
+            "list", "create", "get", "toggle_item", "complete", "delete",
+        ])
+            .describe("What to do: list_templates/get_template/create_template (blueprints); list/create/get/toggle_item/complete/delete (runs)"),
+        template_id: zod_1.z.string().optional().describe("Template ID — required for get_template; optional on create (instantiate from a template)"),
+        checklist_id: zod_1.z.string().optional().describe("Checklist run ID — required for get/toggle_item/complete/delete"),
+        item_id: zod_1.z.string().optional().describe("Checklist item ID — required for toggle_item"),
+        title: zod_1.z.string().optional().describe("Title (required for create_template; optional for create run)"),
+        description: zod_1.z.string().optional().describe("Template description (create_template)"),
+        parent_type: zod_1.z.string().optional().describe("Attach a run to: task or life_item (required for create + list filter)"),
+        parent_id: zod_1.z.string().optional().describe("ID of the parent task / life item (required for create)"),
+        parent_label: zod_1.z.string().optional().describe("Optional human label for the parent"),
+        sections_json: zod_1.z.string().optional().describe('Inline sections as JSON, e.g. [{"title":"Setup","phase":"pre","items":[{"label":"do x"}]}] — for create_template or an inline create run'),
+    }, async ({ action, template_id, checklist_id, item_id, title, description, parent_type, parent_id, parent_label, sections_json }) => {
+        try {
+            const parseSections = () => {
+                if (!sections_json)
+                    return undefined;
+                const parsed = JSON.parse(sections_json);
+                if (!Array.isArray(parsed))
+                    throw new Error("sections_json must be a JSON array of sections");
+                return parsed;
+            };
+            const fmtTemplate = (t) => {
+                const secCount = (t.sections ?? []).length;
+                const itemCount = (t.sections ?? []).reduce((n, s) => n + (s.items?.length ?? 0), 0);
+                return `• ${t.title}${t.origin === "flagship" ? " ⭐ flagship" : ""} — ${secCount} section(s), ${itemCount} item(s) — id: ${t.template_id}`;
+            };
+            const fmtSections = (sections) => (sections ?? [])
+                .map((s) => {
+                const head = `  [${s.phase}] ${s.title}`;
+                const items = (s.items ?? [])
+                    .map((it) => `    ${it.checked ? "[x]" : "[ ]"} ${it.label} — id: ${it.item_id}`)
+                    .join("\n");
+                return items ? `${head}\n${items}` : head;
+            })
+                .join("\n");
+            const fmtChecklist = (c, withItems = false) => {
+                const p = c.progress ?? { done: 0, total: 0, pct: 0 };
+                const head = `• ${c.title} (${p.done}/${p.total}, ${p.pct}%)` +
+                    `${c.completed_at ? " ✅ complete" : ""}` +
+                    `${c.parent_label ? `, on ${c.parent_label}` : ""} — id: ${c.checklist_id}`;
+                return withItems ? `${head}\n${fmtSections(c.sections ?? [])}` : head;
+            };
+            switch (action) {
+                case "list_templates": {
+                    const result = await client.listChecklistTemplates();
+                    const templates = result.templates ?? [];
+                    if (templates.length === 0) {
+                        return { content: [{ type: "text", text: "No checklist templates found." }] };
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `${result.total} template(s):\n` + templates.map(fmtTemplate).join("\n"),
+                            }],
+                    };
+                }
+                case "get_template": {
+                    if (!template_id) {
+                        return { content: [{ type: "text", text: "Error: template_id is required for get_template" }], isError: true };
+                    }
+                    const t = await client.getChecklistTemplate(template_id);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `${fmtTemplate(t)}${t.description ? `\n${t.description}` : ""}\n${fmtSections(t.sections ?? [])}`,
+                            }],
+                    };
+                }
+                case "create_template": {
+                    if (!title) {
+                        return { content: [{ type: "text", text: "Error: title is required to create a template" }], isError: true };
+                    }
+                    const t = await client.createChecklistTemplate({
+                        title, description, sections: parseSections(),
+                    });
+                    return { content: [{ type: "text", text: `✅ Created template: ${fmtTemplate(t)}` }] };
+                }
+                case "list": {
+                    const result = await client.listChecklists(parent_type, parent_id);
+                    const checklists = result.checklists ?? [];
+                    if (checklists.length === 0) {
+                        return { content: [{ type: "text", text: "No checklists found." }] };
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `${result.total} checklist(s):\n` + checklists.map((c) => fmtChecklist(c)).join("\n"),
+                            }],
+                    };
+                }
+                case "create": {
+                    if (!parent_type || !parent_id) {
+                        return { content: [{ type: "text", text: "Error: parent_type and parent_id are required to create a checklist run" }], isError: true };
+                    }
+                    const c = await client.createChecklist({
+                        parent_type, parent_id, parent_label, title,
+                        template_id, sections: parseSections(),
+                    });
+                    return { content: [{ type: "text", text: `✅ Created checklist:\n${fmtChecklist(c, true)}` }] };
+                }
+                case "get": {
+                    if (!checklist_id) {
+                        return { content: [{ type: "text", text: "Error: checklist_id is required for get" }], isError: true };
+                    }
+                    const c = await client.getChecklist(checklist_id);
+                    return { content: [{ type: "text", text: fmtChecklist(c, true) }] };
+                }
+                case "toggle_item": {
+                    if (!checklist_id || !item_id) {
+                        return { content: [{ type: "text", text: "Error: checklist_id and item_id are required for toggle_item" }], isError: true };
+                    }
+                    const c = await client.toggleChecklistItem(checklist_id, item_id);
+                    return { content: [{ type: "text", text: `✅ Toggled item:\n${fmtChecklist(c, true)}` }] };
+                }
+                case "complete": {
+                    if (!checklist_id) {
+                        return { content: [{ type: "text", text: "Error: checklist_id is required for complete" }], isError: true };
+                    }
+                    const c = await client.completeChecklist(checklist_id);
+                    return { content: [{ type: "text", text: `✅ Completed checklist "${c.title}" — mirrored to the knowledge graph.` }] };
+                }
+                case "delete": {
+                    if (!checklist_id) {
+                        return { content: [{ type: "text", text: "Error: checklist_id is required for delete" }], isError: true };
+                    }
+                    await client.deleteChecklist(checklist_id);
+                    return { content: [{ type: "text", text: `🗑️ Deleted checklist ${checklist_id}` }] };
+                }
+                default:
+                    return { content: [{ type: "text", text: `Unknown action: ${action}` }], isError: true };
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `mind_checklists error: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
     // ─── mind_crm ───────────────────────────────────────────
     // Read/write contacts, interactions, and activities.
     // Enhanced: delete, get, log_activity, list_activities.
@@ -1662,7 +1849,7 @@ function createMindMcpServer(client) {
         preferred_llm_model: zod_1.z
             .union([zod_1.z.string(), zod_1.z.null()])
             .optional()
-            .describe("LLM model id (e.g. 'openai/gpt-4o', 'anthropic/claude-sonnet-4.6'). Used by the public chat at /m/{username}. Pass null to clear and fall back to platform default. Use mind_admin with action=list_featured_minds then get_featured_mind_full to see available_models."),
+            .describe("LLM model id (e.g. 'deepseek/deepseek-v4-flash', 'anthropic/claude-sonnet-4.6'). Used by the public chat at /m/{username}. Pass null to clear and fall back to platform default. Use mind_admin with action=list_featured_minds then get_featured_mind_full to see available_models."),
         public_mind_enabled: zod_1.z.boolean().optional().describe("Whether anonymous visitors can chat with this MIND at /m/{username}"),
         public_mind_prompt: zod_1.z
             .string()
@@ -4505,6 +4692,321 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── mind_trader ────────────────────────────────────────
+    // TraderMIND: any agent can run the trader for you. Read the engine
+    // (live feed, MIND Vision forecasts — latest cone + resolved history +
+    // per-bar scores, candles, cycle summaries, calibration honesty curve,
+    // engine health, the trader's own narrated journal) and act on it as YOU —
+    // save/star/like objects (and undo), leave notes and structured feedback
+    // the engine learns from, read back your notes/interactions/public counts,
+    // keep a full-CRUD trading journal, and pull personalized insights.
+    // 1:1 endpoint map (same MIND base URL, MIND API key auth):
+    //   feed → GET /api/mindtrades/feed · forecast_latest → GET /api/trader/forecasts/latest
+    //   forecasts → GET /api/trader/forecasts · bar_scores → GET /api/trader/forecasts/{id}/bar-scores
+    //   candles → GET /api/trader/candles · cycles → GET /api/trader/cycles
+    //   health → GET /api/trader/health · calibration → GET /api/trader/calibration
+    //   ai_journal → GET /api/trader/ai-journal · save/star/like → POST /api/trader/interact
+    //   unsave → DELETE /api/trader/interact · interactions → GET /api/trader/interactions
+    //   counts → GET /api/trader/counts · note/feedback → POST /api/trader/note
+    //   notes → GET /api/trader/notes · journal_* → GET/POST/PUT/DELETE /api/trader/journal[/{id}]
+    //   saved → GET /api/trader/saved · insights → GET /api/trader/insights
+    server.tool("mind_trader", "Operate TraderMIND — the agentic trading engine. Use whenever the user asks about markets, the trader, a MIND Vision forecast, their trading journal, or wants to react to a trade idea. " +
+        "Read the engine: feed (live trade-idea feed) · forecast_latest (latest MIND Vision cone for a symbol) · forecasts (recent forecast history incl. resolution — every hit and miss) · bar_scores (per-candle predicted-vs-actual for one resolved forecast_id) · candles (OHLCV) · cycles (engine cycle summaries: regime, ideas, lessons) · health (is the engine up) · calibration (published honesty curve) · ai_journal (the trader's own narrated 'what I saw / did / why'). " +
+        "Act as the user: save | star | like an object (object_type forecast|idea|journal_ai + object_id) · unsave (undo one of those — pass undo_action) · note (attach a note) · feedback (agree/disagree/context — reaches the engine's brain and shapes future hypotheses) · interactions (what you already saved/starred on a batch of object_ids — check before writing) · notes (read back your notes) · saved (your saved/starred items, filterable via filter_action). Writes are rate-limited (300 save/star/like per hour, 60 notes/feedback per hour) — batch-check with action=interactions before writing. " +
+        "Your journal: journal_list · journal_create · journal_get · journal_update · journal_delete (entry_id). insights = personalized insights from your activity + the trader brain (cached 15 min). " +
+        "Auth: all engine reads (feed, forecast_latest, forecasts, bar_scores, candles, cycles, health, calibration, ai_journal) plus counts are public — they work even with a missing or invalid key. Only the act-as-you actions (save/star/like/unsave, note/feedback, notes, interactions, saved, journal_*, insights) authenticate as the key's owner. Saves, notes, feedback, and journal entries also land in the owner's MIND knowledge graph.", {
+        action: zod_1.z
+            .enum([
+            "feed",
+            "forecast_latest",
+            "forecasts",
+            "bar_scores",
+            "candles",
+            "cycles",
+            "health",
+            "calibration",
+            "ai_journal",
+            "save",
+            "star",
+            "like",
+            "unsave",
+            "note",
+            "feedback",
+            "notes",
+            "interactions",
+            "counts",
+            "journal_list",
+            "journal_create",
+            "journal_get",
+            "journal_update",
+            "journal_delete",
+            "saved",
+            "insights",
+        ])
+            .describe("The operation to run — see the tool description for the grouped taxonomy and per-action requirements."),
+        symbol: zod_1.z
+            .string()
+            .regex(/^[A-Za-z0-9.\-]{1,12}$/, "symbol must be 1-12 chars of A-Z, 0-9, '.' or '-'")
+            .optional()
+            .describe("Instrument symbol, 1–12 chars of A-Z, 0-9, '.' or '-' (e.g. ES, NQ, SPY, BTC-USD; case-insensitive — normalized to uppercase). Required for forecast_latest and candles; optional filter on forecasts/ai_journal/saved; recommended on save/star/like/note/feedback."),
+        object_type: zod_1.z
+            .enum(["forecast", "idea", "journal_ai"])
+            .optional()
+            .describe("Type of the actable object — required for save/star/like/unsave/note/feedback."),
+        object_id: zod_1.z
+            .string()
+            .max(200)
+            .optional()
+            .describe("Id of the actable object (≤200 chars) — required for save/star/like/unsave/note/feedback; optional filter for notes."),
+        object_ids: zod_1.z
+            .array(zod_1.z.string().max(200))
+            .min(1)
+            .max(200)
+            .optional()
+            .describe("Batch of object ids (1–200, each ≤200 chars) — required for interactions and counts."),
+        undo_action: zod_1.z
+            .enum(["save", "star", "like"])
+            .optional()
+            .describe("Which interaction to undo — required for unsave."),
+        forecast_id: zod_1.z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("Numeric forecast id — required for bar_scores. Get ids from action=forecasts."),
+        text: zod_1.z
+            .string()
+            .max(8000)
+            .optional()
+            .describe("Note or feedback text (≤8000 chars) — required for note/feedback."),
+        tag: zod_1.z
+            .enum(["agree", "disagree", "context"])
+            .optional()
+            .describe("Structured tag stored with the note/feedback (agree | disagree | context). On feedback it reaches the engine's Hypothesizer and shapes future forecasts."),
+        note_kind: zod_1.z
+            .enum(["note", "feedback"])
+            .optional()
+            .describe("action=notes: filter your notes by kind."),
+        filter_action: zod_1.z
+            .enum(["save", "star", "like"])
+            .optional()
+            .describe("action=saved: return only items with this interaction (e.g. only what you starred). Default: saves + stars."),
+        title: zod_1.z
+            .string()
+            .max(300)
+            .optional()
+            .describe("Journal entry title (≤300 chars) — required for journal_create; optional on journal_update."),
+        body: zod_1.z
+            .string()
+            .max(50000)
+            .optional()
+            .describe("Journal entry body (≤50000 chars) — journal_create/journal_update."),
+        symbols: zod_1.z
+            .array(zod_1.z
+            .string()
+            .regex(/^[A-Za-z0-9.\-]{1,12}$/, "each symbol must be 1-12 chars of A-Z, 0-9, '.' or '-'"))
+            .max(20)
+            .optional()
+            .describe("Symbols linked to a journal entry, ≤20 of ≤12 chars each (journal_create/journal_update — update REPLACES the list)."),
+        linked_ids: zod_1.z
+            .array(zod_1.z.string().max(200))
+            .max(50)
+            .optional()
+            .describe("Forecast/idea ids linked to a journal entry, ≤50 (journal_create/journal_update — update REPLACES the list)."),
+        tags: zod_1.z
+            .array(zod_1.z.string().max(50))
+            .max(20)
+            .optional()
+            .describe("Tags for a journal entry, ≤20 (journal_create/journal_update — update REPLACES the list)."),
+        entry_id: zod_1.z
+            .string()
+            .max(200)
+            .optional()
+            .describe("Journal entry id (≤200 chars) — required for journal_get/journal_update/journal_delete."),
+        tf: zod_1.z
+            .enum(["1m", "5m", "15m", "1h", "4h", "1d"])
+            .optional()
+            .describe("Candle timeframe for candles (default 5m)."),
+        limit: zod_1.z
+            .number()
+            .int()
+            .min(1)
+            .max(2000)
+            .optional()
+            .describe("Max items. Per-action bounds/defaults: candles 1–2000 default 300 · forecasts ≤500 default 50 · feed/ai_journal/journal_list ≤200 default 50 · cycles ≤200 default 20 · saved/notes ≤500 default 100. Values above an action's cap are clamped to the cap. Use 'page' to continue past 'limit' on notes/saved/journal_list."),
+        page: zod_1.z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("notes / saved / journal_list: page number (default 1); responses include 'total' and 'page' so you can walk pages."),
+        days: zod_1.z
+            .number()
+            .int()
+            .min(1)
+            .max(365)
+            .optional()
+            .describe("History window in days for calibration (1–365, default 90)."),
+        kind: zod_1.z
+            .enum(["execute", "no_trade", "error", "all"])
+            .optional()
+            .describe("Feed filter for action=feed."),
+        refresh: zod_1.z
+            .boolean()
+            .optional()
+            .describe("action=insights: bypass the 15-minute cache and recompose. A 60-second floor still applies — refresh=true within 60s of the last compose returns the cached result."),
+    }, async ({ action, symbol, object_type, object_id, object_ids, undo_action, forecast_id, text, tag, note_kind, filter_action, title, body, symbols, linked_ids, tags, entry_id, tf, limit, page, days, kind, refresh, }) => {
+        // ok / err / apiDetail are the module-scope shared MCP result helpers.
+        // Clamp limit to each action's backend cap instead of letting the API
+        // 422 — the describe documents these bounds; the clamp enforces them.
+        const LIMIT_CAPS = {
+            feed: 200,
+            forecasts: 500,
+            candles: 2000,
+            cycles: 200,
+            ai_journal: 200,
+            notes: 500,
+            journal_list: 200,
+            saved: 500,
+        };
+        const lim = limit !== undefined ? Math.min(limit, LIMIT_CAPS[action] ?? limit) : undefined;
+        try {
+            switch (action) {
+                case "feed":
+                    return ok(await client.traderFeed({ limit: lim, kind }));
+                case "forecast_latest":
+                    if (!symbol)
+                        return err("Error: 'symbol' is required for forecast_latest.");
+                    return ok(await client.traderForecastLatest(symbol));
+                case "forecasts":
+                    return ok(await client.traderForecasts(symbol, lim));
+                case "bar_scores":
+                    if (forecast_id === undefined)
+                        return err("Error: 'forecast_id' is required for bar_scores. Get ids from action=forecasts.");
+                    return ok(await client.traderBarScores(forecast_id));
+                case "candles":
+                    if (!symbol)
+                        return err("Error: 'symbol' is required for candles.");
+                    return ok(await client.traderCandles(symbol, tf, lim));
+                case "cycles":
+                    return ok(await client.traderCycles(lim));
+                case "health":
+                    return ok(await client.traderHealth());
+                case "calibration":
+                    return ok(await client.traderCalibration(days));
+                case "ai_journal":
+                    return ok(await client.traderAiJournal(symbol, lim));
+                case "save":
+                case "star":
+                case "like": {
+                    if (!object_type || !object_id)
+                        return err(`Error: 'object_type' and 'object_id' are required for ${action}.`);
+                    const r = await client.traderInteract({
+                        object_type,
+                        object_id,
+                        action,
+                        symbol,
+                    });
+                    return ok(r);
+                }
+                case "unsave": {
+                    if (!object_type || !object_id)
+                        return err("Error: 'object_type' and 'object_id' are required for unsave.");
+                    if (!undo_action)
+                        return err("Error: 'undo_action' (save | star | like) is required for unsave.");
+                    const r = (await client.traderUninteract({
+                        object_type,
+                        object_id,
+                        action: undo_action,
+                    }));
+                    if (r && typeof r === "object" && r.deleted === false)
+                        return ok({
+                            ...r,
+                            hint: `Nothing was deleted — you have no existing ${undo_action} on that object. Call action=interactions with its object_id to see what you actually have.`,
+                        });
+                    return ok(r);
+                }
+                case "note":
+                case "feedback": {
+                    if (!object_type || !object_id)
+                        return err(`Error: 'object_type' and 'object_id' are required for ${action}.`);
+                    if (!text)
+                        return err(`Error: 'text' is required for ${action}.`);
+                    const r = await client.traderNote({
+                        object_type,
+                        object_id,
+                        kind: action,
+                        text,
+                        tag,
+                        symbol,
+                    });
+                    return ok(r);
+                }
+                case "notes":
+                    return ok(await client.traderNotes({ object_id, kind: note_kind, limit: lim, page }));
+                case "interactions":
+                    if (!object_ids?.length)
+                        return err("Error: 'object_ids' (1–200 ids) is required for interactions.");
+                    return ok(await client.traderInteractions(object_ids));
+                case "counts":
+                    if (!object_ids?.length)
+                        return err("Error: 'object_ids' (1–200 ids) is required for counts.");
+                    return ok(await client.traderCounts(object_ids));
+                case "journal_list":
+                    return ok(await client.traderJournalList(lim, page));
+                case "journal_create":
+                    if (!title)
+                        return err("Error: 'title' is required for journal_create.");
+                    return ok(await client.traderJournalCreate({ title, body, symbols, linked_ids, tags }));
+                case "journal_get":
+                    if (!entry_id)
+                        return err("Error: 'entry_id' is required for journal_get.");
+                    return ok(await client.traderJournalGet(entry_id));
+                case "journal_update": {
+                    if (!entry_id)
+                        return err("Error: 'entry_id' is required for journal_update.");
+                    if (title === undefined &&
+                        body === undefined &&
+                        symbols === undefined &&
+                        linked_ids === undefined &&
+                        tags === undefined)
+                        return err("Error: journal_update needs at least one of 'title', 'body', 'symbols', 'linked_ids', 'tags'.");
+                    return ok(await client.traderJournalUpdate(entry_id, { title, body, symbols, linked_ids, tags }));
+                }
+                case "journal_delete":
+                    if (!entry_id)
+                        return err("Error: 'entry_id' is required for journal_delete.");
+                    return ok(await client.traderJournalDelete(entry_id));
+                case "saved":
+                    return ok(await client.traderSaved({ action: filter_action, symbol, object_type, limit: lim, page }));
+                case "insights":
+                    return ok(await client.traderInsights(refresh));
+                default: {
+                    const _exhaustive = action;
+                    return err(`Unknown action: ${_exhaustive}`);
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof mind_client_js_1.MindApiError) {
+                if (e.status === 404 && action === "forecast_latest")
+                    return err(`No forecast yet for ${symbol?.trim().toUpperCase() || "that symbol"} — the engine may not cover it. Call action=feed or action=cycles to see the live universe of symbols.`);
+                if (e.status === 404 &&
+                    (action === "journal_get" || action === "journal_update" || action === "journal_delete"))
+                    return err(`No journal entry with entry_id '${entry_id ?? ""}' — it may have been deleted. Call action=journal_list to get valid entry ids.`);
+                if (e.status === 404 && action === "bar_scores")
+                    return err(`No bar scores for forecast_id ${forecast_id ?? ""} — the id is wrong or the forecast hasn't resolved yet. Call action=forecasts (resolution status included) to find resolved ids.`);
+                if (e.status === 401 || e.status === 403)
+                    return err("mind_trader auth error: the MIND API key was rejected (missing/expired or lacks trader access). Re-run setup with a fresh key from m-i-n-d.ai → Settings → Developer → API Keys.");
+                if (e.status === 429)
+                    return err(`mind_trader rate limit (HTTP 429): ${apiDetail(e)} Write ceilings: 300 save/star/like per hour, 60 notes/feedback per hour. counts is IP-rate-limited per minute (default 60/min); other reads are unlimited. Stop writing and retry after the window resets.`);
+                if (e.status === 502 || e.status === 503)
+                    return err("mind_trader: the trading engine is unreachable or not configured right now. Call action=health to check engine status, and retry shortly.");
+                return err(`mind_trader ${action} failed (HTTP ${e.status}): ${apiDetail(e)}`);
+            }
+            return err(`mind_trader error: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    });
     return server;
 }
 //# sourceMappingURL=server.js.map