@astramindapp/mcp-server 0.7.0 → 0.8.2

package/dist/server.js

@@ -5,7 +5,7 @@
  * Exposes the MIND knowledge graph as MCP tools that any LLM agent can use.
  * This is the universal AI memory layer.
  *
- * Tools (16):
+ * Tools (17):
  *   mind_query     — Semantic search across the knowledge graph
  *   mind_remember  — Store/manage content in the graph (auto-categorized)
  *   mind_context   — Get structured always-loaded context (soul/user/rules)
@@ -23,6 +23,8 @@
  *   mind_notify    — Notifications management
  *   mind_agents    — Admin-only Agent Command Center (registry, heartbeat,
  *                    probe, status — for Anthony's agent fleet)
+ *   mind_accounts  — Multi-MIND accounts: discover/create MINDs, manage
+ *                    owners and viewers, send invitations
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMindMcpServer = createMindMcpServer;
@@ -292,11 +294,11 @@ function createMindMcpServer(client) {
     server.tool("mind_life", "Manage goals, projects, tasks, and calendar events in MIND Life. Use for tracking work, creating action items, updating progress, completing tasks, managing calendar, and viewing stats.", {
         action: zod_1.z
             .enum([
-            "list", "create", "update", "complete", "delete", "move", "get",
+            "list", "create", "update", "complete", "delete", "bulk_delete", "move", "get",
             "calendar_list", "calendar_create", "calendar_update", "calendar_delete",
             "stats",
         ])
-            .describe("What to do: list/create/update/complete/delete/move/get items, calendar_list/calendar_create/calendar_update/calendar_delete events, stats (productivity overview)"),
+            .describe("What to do: list/create/update/complete/delete/bulk_delete/move/get items, calendar_list/calendar_create/calendar_update/calendar_delete events, stats (productivity overview)"),
         title: zod_1.z.string().optional().describe("Title for new items or calendar events"),
         description: zod_1.z.string().optional().describe("Description for new items"),
         status: zod_1.z
@@ -309,11 +311,12 @@ function createMindMcpServer(client) {
             .describe("Priority: low, medium, high, urgent"),
         due_date: zod_1.z.string().optional().describe("Due date in YYYY-MM-DD format"),
         item_id: zod_1.z.string().optional().describe("Item ID for update/complete/delete/move/get actions"),
+        item_ids: zod_1.z.array(zod_1.z.string()).optional().describe("Item IDs for bulk_delete (1–200 IDs deleted in one call)"),
         start_time: zod_1.z.string().optional().describe("Start time for calendar events (ISO 8601)"),
         end_time: zod_1.z.string().optional().describe("End time for calendar events (ISO 8601)"),
         event_id: zod_1.z.string().optional().describe("Event ID for calendar_update/calendar_delete"),
         all_day: zod_1.z.boolean().optional().describe("Whether the calendar event is all-day"),
-    }, async ({ action, title, description, status, priority, due_date, item_id, start_time, end_time, event_id, all_day }) => {
+    }, async ({ action, title, description, status, priority, due_date, item_id, item_ids, start_time, end_time, event_id, all_day }) => {
         try {
             switch (action) {
                 case "list": {
@@ -395,6 +398,22 @@ function createMindMcpServer(client) {
                         content: [{ type: "text", text: `✅ Deleted life item ${item_id}` }],
                     };
                 }
+                case "bulk_delete": {
+                    if (!item_ids || item_ids.length === 0) {
+                        return {
+                            content: [{ type: "text", text: "Error: item_ids (a non-empty array of IDs) is required for bulk_delete" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await client.bulkDeleteLifeItems(item_ids);
+                    const lines = [
+                        `✅ Bulk delete complete — ${result.deleted_count} life item(s) deleted.`,
+                    ];
+                    if (result.not_found.length > 0) {
+                        lines.push(`⚠️ ${result.not_found.length} id(s) skipped (not found / not yours): ${result.not_found.join(", ")}`);
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
                 case "move": {
                     if (!item_id || !status) {
                         return {
@@ -512,6 +531,212 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── mind_tasks ─────────────────────────────────────────
+    // Site-wide tasks: assignable, completable work items that attach to a
+    // Life project, a CRM contact, an agent, or stand alone.
+    server.tool("mind_tasks", "Manage site-wide tasks in MIND — assignable, completable, reportable work items. A task can attach to a Life project (parent_type=life_item), a CRM contact (parent_type=contact), an agent (parent_type=agent), or stand alone. Assign tasks to a MIND member, an agent, or an external email. Use action=reports for completion analytics.", {
+        action: zod_1.z
+            .enum([
+            "list", "create", "get", "update", "complete", "reopen",
+            "assign", "delete", "reports",
+        ])
+            .describe("What to do: list/create/get/update/complete/reopen/assign/delete tasks, or reports (completion analytics)"),
+        task_id: zod_1.z.string().optional().describe("Task ID — required for get/update/complete/reopen/assign/delete"),
+        title: zod_1.z.string().optional().describe("Task title (required for create)"),
+        description: zod_1.z.string().optional().describe("Task description"),
+        status: zod_1.z.string().optional().describe("Filter (list) or new status: open, in_progress, blocked, done"),
+        priority: zod_1.z.string().optional().describe("Priority: none, low, medium, high, urgent"),
+        due_date: zod_1.z.string().optional().describe("Due date YYYY-MM-DD"),
+        parent_type: zod_1.z.string().optional().describe("Attach to: life_item, contact, agent, or none"),
+        parent_id: zod_1.z.string().optional().describe("ID of the parent project / contact / agent"),
+        assignee_type: zod_1.z.string().optional().describe("Assignee: user, agent, external, or unassigned"),
+        assignee_id: zod_1.z.string().optional().describe("Username, agent slug, or email of the assignee"),
+        dispatch_agent: zod_1.z.boolean().optional().describe("When assigning to an agent, also fire it now"),
+        note: zod_1.z.string().optional().describe("Completion note (for complete)"),
+        overdue: zod_1.z.boolean().optional().describe("List only overdue tasks"),
+    }, async ({ action, task_id, title, description, status, priority, due_date, parent_type, parent_id, assignee_type, assignee_id, dispatch_agent, note, overdue }) => {
+        try {
+            const fmt = (t) => `• [${t.status}] ${t.title}${t.priority && t.priority !== "none" ? ` (${t.priority})` : ""}` +
+                `${t.due_date ? `, due ${t.due_date}` : ""}${t.is_overdue ? " ⚠️ OVERDUE" : ""}` +
+                `${t.assignee_label ? `, → ${t.assignee_label}` : ""}` +
+                `${t.parent_label ? `, on ${t.parent_label}` : ""} — id: ${t.task_id}`;
+            switch (action) {
+                case "list": {
+                    const params = {};
+                    if (status)
+                        params.status = status;
+                    if (priority)
+                        params.priority = priority;
+                    if (parent_type)
+                        params.parent_type = parent_type;
+                    if (parent_id)
+                        params.parent_id = parent_id;
+                    if (assignee_type)
+                        params.assignee_type = assignee_type;
+                    if (assignee_id)
+                        params.assignee_id = assignee_id;
+                    if (overdue)
+                        params.overdue = "true";
+                    const result = await client.listTasks(params);
+                    const tasks = result.tasks ?? [];
+                    if (tasks.length === 0) {
+                        return { content: [{ type: "text", text: "No tasks found." }] };
+                    }
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `${result.total} task(s):\n` + tasks.map(fmt).join("\n"),
+                            }],
+                    };
+                }
+                case "create": {
+                    if (!title) {
+                        return {
+                            content: [{ type: "text", text: "Error: title is required to create a task" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.createTask({
+                        title, description, status, priority, due_date,
+                        parent_type, parent_id, assignee_type, assignee_id,
+                        dispatch_agent,
+                    });
+                    return {
+                        content: [{ type: "text", text: `✅ Created task: ${fmt(t)}` }],
+                    };
+                }
+                case "get": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for get" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.getTask(task_id);
+                    const extra = t.agent_run_status ? `\nAgent run: ${t.agent_run_status}` : "";
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `${fmt(t)}${t.description ? `\n${t.description}` : ""}${extra}`,
+                            }],
+                    };
+                }
+                case "update": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for update" }],
+                            isError: true,
+                        };
+                    }
+                    const patch = {};
+                    if (title !== undefined)
+                        patch.title = title;
+                    if (description !== undefined)
+                        patch.description = description;
+                    if (status !== undefined)
+                        patch.status = status;
+                    if (priority !== undefined)
+                        patch.priority = priority;
+                    if (due_date !== undefined)
+                        patch.due_date = due_date;
+                    if (parent_type !== undefined)
+                        patch.parent_type = parent_type;
+                    if (parent_id !== undefined)
+                        patch.parent_id = parent_id;
+                    const t = await client.updateTask(task_id, patch);
+                    return {
+                        content: [{ type: "text", text: `✅ Updated task: ${fmt(t)}` }],
+                    };
+                }
+                case "complete": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for complete" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.completeTask(task_id, true, note);
+                    return {
+                        content: [{ type: "text", text: `✅ Completed task: "${t.title}"` }],
+                    };
+                }
+                case "reopen": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for reopen" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.completeTask(task_id, false);
+                    return {
+                        content: [{ type: "text", text: `↩️ Reopened task: "${t.title}"` }],
+                    };
+                }
+                case "assign": {
+                    if (!task_id || !assignee_type) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id and assignee_type are required for assign" }],
+                            isError: true,
+                        };
+                    }
+                    const t = await client.assignTask(task_id, {
+                        assignee_type, assignee_id, dispatch_agent: dispatch_agent ?? false,
+                    });
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `✅ Assigned "${t.title}" → ${t.assignee_label ?? t.assignee_id ?? "unassigned"}`,
+                            }],
+                    };
+                }
+                case "delete": {
+                    if (!task_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: task_id is required for delete" }],
+                            isError: true,
+                        };
+                    }
+                    await client.deleteTask(task_id);
+                    return {
+                        content: [{ type: "text", text: `🗑️ Deleted task ${task_id}` }],
+                    };
+                }
+                case "reports": {
+                    const params = {};
+                    if (parent_type)
+                        params.parent_type = parent_type;
+                    if (parent_id)
+                        params.parent_id = parent_id;
+                    const r = await client.taskReports(params);
+                    const lines = [
+                        `📊 Task report (${r.total} total)`,
+                        `  open ${r.open} · in progress ${r.in_progress} · blocked ${r.blocked} · done ${r.done}`,
+                        `  completion rate: ${r.completion_rate}%`,
+                        `  overdue: ${r.overdue} · due soon: ${r.due_soon} · unassigned: ${r.unassigned}`,
+                        `  avg completion: ${r.avg_completion_days} days`,
+                    ];
+                    if (r.by_assignee && r.by_assignee.length) {
+                        lines.push("  By assignee:");
+                        for (const a of r.by_assignee.slice(0, 10)) {
+                            lines.push(`    ${a.assignee_label ?? a.assignee_id ?? "unassigned"}: ${a.done}/${a.total} done (${a.completion_rate}%)`);
+                        }
+                    }
+                    return { content: [{ type: "text", text: lines.join("\n") }] };
+                }
+                default:
+                    return {
+                        content: [{ type: "text", text: `Unknown action: ${action}` }],
+                        isError: true,
+                    };
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `mind_tasks 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.
@@ -1936,8 +2161,12 @@ function createMindMcpServer(client) {
             "seed_known",
             "set_status",
             "set_current_job",
+            "list_invoices",
+            "link_invoice",
+            "unlink_invoice",
+            "create_invoice",
         ])
-            .describe("Action: list (filter+stats), get (detail+recent activities), create, update (partial), delete (soft archive; pass hard=true to remove), heartbeat (push from agent runtime), probe (HTTP/OpenClaw liveness probe), log_activity (manual note), list_activities, import_from_mind (enrich from agent-identity docs), seed_known (idempotent upsert of canonical seed), set_status (shortcut update), set_current_job (shortcut update)"),
+            .describe("Action: list (filter+stats), get (detail+recent activities), create, update (partial), delete (soft archive; pass hard=true to remove), heartbeat (push from agent runtime), probe (HTTP/OpenClaw liveness probe), log_activity (manual note), list_activities, import_from_mind (enrich from agent-identity docs), seed_known (idempotent upsert of canonical seed), set_status (shortcut update), set_current_job (shortcut update), list_invoices (invoices linked to an agent), link_invoice (attach an existing invoice id), unlink_invoice (detach an invoice id), create_invoice (create a new Invoice Agent draft + link it)"),
         slug: zod_1.z.string().optional().describe("Agent slug (lowercase, dashes). Required for get/update/delete/heartbeat/probe/activities/set_*."),
         // create / update fields
         name: zod_1.z.string().optional().describe("Display name."),
@@ -1988,8 +2217,18 @@ function createMindMcpServer(client) {
         limit: zod_1.z.number().optional().describe("Max activities to return for list_activities (default 50)."),
         // seed_known
         overwrite: zod_1.z.boolean().optional().describe("If true with action=seed_known, reset existing records to seed defaults."),
+        // invoice linking
+        invoice_id: zod_1.z.string().optional().describe("Invoice id — required for link_invoice / unlink_invoice."),
+        bill_to_name: zod_1.z.string().optional().describe("Recipient name for create_invoice (required)."),
+        bill_to_company: zod_1.z.string().optional().describe("Recipient company for create_invoice."),
+        bill_to_email: zod_1.z.string().optional().describe("Recipient email for create_invoice."),
+        line_item_description: zod_1.z.string().optional().describe("Single line-item description for create_invoice."),
+        quantity: zod_1.z.number().optional().describe("Line-item quantity for create_invoice (default 1)."),
+        unit_price: zod_1.z.number().optional().describe("Line-item unit price for create_invoice (default 0)."),
+        currency: zod_1.z.string().optional().describe("Invoice currency for create_invoice (default USD)."),
+        invoice_notes: zod_1.z.string().optional().describe("Notes shown on the invoice for create_invoice."),
     }, async (args) => {
-        const { action, slug, name, description, status, cadence, host, host_address, port, health_url, source_path, source_repo, mind_identity_doc_id, responsibilities, triggers, tags, owner_email, expected_interval_seconds, authority_can_autonomous, authority_requires_approval, hard, current_job, metrics, note, source, activity_type, activity_payload, list_status, list_host, list_tag, include_archived, limit, overwrite, } = args;
+        const { action, slug, name, description, status, cadence, host, host_address, port, health_url, source_path, source_repo, mind_identity_doc_id, responsibilities, triggers, tags, owner_email, expected_interval_seconds, authority_can_autonomous, authority_requires_approval, hard, current_job, metrics, note, source, activity_type, activity_payload, list_status, list_host, list_tag, include_archived, limit, overwrite, invoice_id, bill_to_name, bill_to_company, bill_to_email, line_item_description, quantity, unit_price, currency, invoice_notes, } = args;
         const requireSlug = (label) => {
             if (!slug) {
                 return `Error: 'slug' is required for action=${label}.`;
@@ -2250,6 +2489,109 @@ function createMindMcpServer(client) {
                         ],
                     };
                 }
+                case "list_invoices": {
+                    const err = requireSlug("list_invoices");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    const result = await client.listAgentInvoices(slug);
+                    if (!result.invoices.length) {
+                        return { content: [{ type: "text", text: `No invoices linked to ${slug}.` }] };
+                    }
+                    const lines = result.invoices.map((i) => `  ${i.invoice_number.padEnd(10)} ${i.status.padEnd(8)} ${i.currency} ${i.total
+                        .toFixed(2)
+                        .padStart(10)} — ${i.bill_to_company ?? i.bill_to_name ?? "—"}`);
+                    return {
+                        content: [
+                            { type: "text", text: `Invoices linked to ${slug}:\n${lines.join("\n")}` },
+                        ],
+                    };
+                }
+                case "link_invoice": {
+                    const err = requireSlug("link_invoice");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (!invoice_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: 'invoice_id' is required for link_invoice." }],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.linkAgentInvoice(slug, invoice_id);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `🔗 Linked invoice ${invoice_id} to ${updated.slug} (${updated.linked_invoices.length} total).`,
+                            },
+                        ],
+                    };
+                }
+                case "unlink_invoice": {
+                    const err = requireSlug("unlink_invoice");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (!invoice_id) {
+                        return {
+                            content: [{ type: "text", text: "Error: 'invoice_id' is required for unlink_invoice." }],
+                            isError: true,
+                        };
+                    }
+                    const updated = await client.unlinkAgentInvoice(slug, invoice_id);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✂️ Unlinked invoice ${invoice_id} from ${updated.slug} (${updated.linked_invoices.length} remain).`,
+                            },
+                        ],
+                    };
+                }
+                case "create_invoice": {
+                    const err = requireSlug("create_invoice");
+                    if (err)
+                        return { content: [{ type: "text", text: err }], isError: true };
+                    if (!bill_to_name) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: 'bill_to_name' is required for create_invoice." },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const invoicePayload = {
+                        bill_from: {
+                            name: "Anthony Conti",
+                            company: "Astra AI, Inc.",
+                            email: "anthony@theastraway.com",
+                        },
+                        bill_to: {
+                            name: bill_to_name,
+                            company: bill_to_company ?? null,
+                            email: bill_to_email ?? null,
+                        },
+                        line_items: line_item_description
+                            ? [
+                                {
+                                    description: line_item_description,
+                                    quantity: quantity ?? 1,
+                                    unit_price: unit_price ?? 0,
+                                },
+                            ]
+                            : [],
+                        currency: currency ?? "USD",
+                    };
+                    if (invoice_notes)
+                        invoicePayload.notes = invoice_notes;
+                    const res = await client.createAgentInvoice(slug, invoicePayload);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `🧾 Created invoice ${res.invoice.invoice_number} (${res.invoice.currency} ${res.invoice.total.toFixed(2)}) and linked it to ${slug}.`,
+                            },
+                        ],
+                    };
+                }
             }
         }
         catch (err) {
@@ -2259,6 +2601,171 @@ function createMindMcpServer(client) {
             };
         }
     });
+    // ─── mind_accounts ──────────────────────────────────────
+    // Multi-MIND accounts: discover the MINDs this key's owner can access,
+    // create new ones, and manage owners / viewers. Requires the server to
+    // have MULTI_MIND_ACCOUNTS_ENABLED set.
+    server.tool("mind_accounts", "Manage multi-MIND accounts. A 'MIND' is a knowledge-graph account; one person can own or be granted access to many. Use to discover every MIND you can access (list), spin up a new one (create), permanently delete one (delete), see who can access a MIND (members), grant an existing user access (grant), or email an invitation (invite).", {
+        action: zod_1.z
+            .enum(["list", "create", "delete", "members", "grant", "invite"])
+            .describe("list (every MIND you can access), create (a new MIND you own), delete (permanently delete a MIND you own), members (owners/viewers of a MIND), grant (give an existing user access), invite (email an invitation)"),
+        label: zod_1.z
+            .string()
+            .optional()
+            .describe("Display name for the new MIND (required for create)"),
+        mind_username: zod_1.z
+            .string()
+            .optional()
+            .describe("Username of the MIND to manage (required for delete/members/grant/invite)"),
+        grantee_username: zod_1.z
+            .string()
+            .optional()
+            .describe("Existing MINDapp username to grant access to (required for grant)"),
+        email: zod_1.z
+            .string()
+            .optional()
+            .describe("Email address to send an invitation to (required for invite)"),
+        role: zod_1.z
+            .enum(["owner", "viewer"])
+            .optional()
+            .default("owner")
+            .describe("Access level: owner (full access) or viewer (read-only)"),
+    }, async ({ action, label, mind_username, grantee_username, email, role }) => {
+        try {
+            switch (action) {
+                case "list": {
+                    const res = await client.listMinds();
+                    if (!res.enabled) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Multi-MIND accounts are not enabled for this MIND.",
+                                },
+                            ],
+                        };
+                    }
+                    const lines = res.accounts.map((a) => `${a.is_active ? "▸" : " "} ${a.label} (@${a.username}) — ${a.role}${a.is_self ? " · you" : ""}`);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `MINDs you can access (${res.accounts.length}):\n${lines.join("\n")}`,
+                            },
+                        ],
+                    };
+                }
+                case "create": {
+                    if (!label) {
+                        return {
+                            content: [{ type: "text", text: "Error: label is required for create" }],
+                            isError: true,
+                        };
+                    }
+                    const res = await client.createMind(label);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Created MIND "${res.label}" (@${res.username}).`,
+                            },
+                        ],
+                    };
+                }
+                case "delete": {
+                    if (!mind_username) {
+                        return {
+                            content: [{ type: "text", text: "Error: mind_username is required for delete" }],
+                            isError: true,
+                        };
+                    }
+                    await client.deleteMind(mind_username);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Permanently deleted MIND @${mind_username}.`,
+                            },
+                        ],
+                    };
+                }
+                case "members": {
+                    if (!mind_username) {
+                        return {
+                            content: [{ type: "text", text: "Error: mind_username is required for members" }],
+                            isError: true,
+                        };
+                    }
+                    const res = await client.listMindMembers(mind_username);
+                    const members = res.members
+                        .map((m) => `• @${m.username} — ${m.role}${m.is_primary ? " (primary)" : ""}`)
+                        .join("\n");
+                    const invites = res.pending_invites.length
+                        ? "\nPending invites:\n" +
+                            res.pending_invites.map((i) => `• ${i.email} — ${i.role}`).join("\n")
+                        : "";
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Members of @${res.mind_username}:\n${members}${invites}`,
+                            },
+                        ],
+                    };
+                }
+                case "grant": {
+                    if (!mind_username || !grantee_username) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: mind_username and grantee_username are required for grant",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    await client.grantMindMember(mind_username, grantee_username, role);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Granted @${grantee_username} ${role} access to @${mind_username}.`,
+                            },
+                        ],
+                    };
+                }
+                case "invite": {
+                    if (!mind_username || !email) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: mind_username and email are required for invite",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const res = await client.createMindInvite(mind_username, email, role);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Invitation sent to ${res.email} (${res.role}) for @${mind_username}.`,
+                            },
+                        ],
+                    };
+                }
+            }
+        }
+        catch (err) {
+            return {
+                content: [{ type: "text", text: `mind_accounts error: ${err}` }],
+                isError: true,
+            };
+        }
+    });
     return server;
 }
 //# sourceMappingURL=server.js.map