agenthub-multiagent-mcp 1.30.0 → 1.32.0

package/dist/tools/index.js

@@ -239,6 +239,14 @@ export function registerTools() {
                 properties: {},
             },
         },
+        {
+            name: "brain_flush_session",
+            description: "Flush this session's accumulated activity into the local searchable brain (.mv2) and the server brain_sessions table WITHOUT disconnecting the agent. Call this at session close (e.g. from /close-session) so the brain is current even where the on-process-exit flush is unreliable (notably Windows, where SIGTERM never fires). Idempotent and best-effort.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
         // Time orientation (add-time-aware-agents §1.3)
         {
             name: "now",
@@ -715,6 +723,64 @@ export function registerTools() {
                 required: ["id"],
             },
         },
+        {
+            name: "calendar_schedule_meeting",
+            description: "Schedule a Google Calendar meeting with an auto-generated Google Meet link. Idempotent on dedupe_key (same key returns the same event). Requires the calendar capability to be enabled on the server.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    title: { type: "string", description: "Meeting title" },
+                    start: { type: "string", description: "Start time (RFC3339, e.g. 2026-06-02T10:00:00Z)" },
+                    end: { type: "string", description: "End time (RFC3339); must be after start" },
+                    attendee_emails: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Invitee email addresses",
+                    },
+                    description: { type: "string", description: "Optional meeting description" },
+                    timezone: { type: "string", description: "Optional IANA timezone; defaults to the server default (UTC)" },
+                    recurrence: { type: "string", description: "Optional RRULE, e.g. RRULE:FREQ=WEEKLY;BYDAY=MO" },
+                    dedupe_key: { type: "string", description: "Idempotency key; same key returns the same event" },
+                    source: {
+                        type: "object",
+                        description: "Optional linkage to a blocker/task; a task source resolves the assignee as an attendee",
+                        properties: {
+                            kind: { type: "string", enum: ["blocker", "task", "manual"] },
+                            id: { type: "string" },
+                        },
+                    },
+                },
+                required: ["title", "start", "end", "dedupe_key"],
+            },
+        },
+        {
+            name: "email_send",
+            description: "Send an email via Gmail to an allowlisted recipient (external partners not in Slack). Recipient must pass the allowlist; per-org daily cap applies. Supports templates (onboarding_invite, task_assignment, digest) or raw body_text/body_html.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    to: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Recipient email addresses (each must pass the allowlist)",
+                    },
+                    subject: { type: "string", description: "Email subject (required for ad-hoc sends)" },
+                    body_text: { type: "string", description: "Plain-text body (required for ad-hoc sends)" },
+                    body_html: { type: "string", description: "Optional HTML body" },
+                    template: {
+                        type: "string",
+                        enum: ["onboarding_invite", "task_assignment", "digest"],
+                        description: "Optional template; when set, body_* are derived from template_vars",
+                    },
+                    template_vars: {
+                        type: "object",
+                        description: "Variables for the chosen template (e.g. {name, login_url})",
+                    },
+                    dedupe_key: { type: "string", description: "Optional idempotency key; a repeat is a no-op" },
+                },
+                required: ["to"],
+            },
+        },
         {
             name: "list_channels",
             description: "List all available channels",
@@ -736,6 +802,143 @@ export function registerTools() {
                 },
             },
         },
+        {
+            name: "api_search",
+            description: "Search the API knowledge graph — endpoints (REST/MCP/GraphQL/gRPC) extracted from indexed repos across the org. Use this BEFORE building a new endpoint to check if it already exists or to match a sibling project's contract. Org-wide read.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Free-text match over endpoint identity + description" },
+                    project_id: { type: "string", description: "Filter to one project (optional)" },
+                    surface: { type: "string", description: "Filter by surface: rest | mcp | graphql | grpc (optional)" },
+                },
+            },
+        },
+        {
+            name: "api_get_endpoint",
+            description: "Get one API endpoint's full contract (handler ref, schemas, auth, description) plus its edges, by identity (e.g. \"POST /api/x\").",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    identity: { type: "string", description: "Endpoint identity, e.g. \"POST /api/x\" (REST) or a tool name (MCP)" },
+                    project_id: { type: "string", description: "Project to look in (optional; org-wide if omitted)" },
+                },
+                required: ["identity"],
+            },
+        },
+        {
+            name: "api_endpoint_impact",
+            description: "Show an endpoint's blast radius before you change it: the consumers, models, and database tables it touches (plus linked openspec changes / feature-graph nodes).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    identity: { type: "string", description: "Endpoint identity, e.g. \"POST /api/x\"" },
+                    project_id: { type: "string", description: "Project to look in (optional)" },
+                },
+                required: ["identity"],
+            },
+        },
+        {
+            name: "api_graph",
+            description: "Return a project's API endpoint subgraph (endpoints with their edges) — for an overview of what a project exposes.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_id: { type: "string", description: "Project to render (optional; org-wide if omitted)" },
+                    surface: { type: "string", description: "Filter by surface: rest | mcp | graphql | grpc (optional)" },
+                },
+            },
+        },
+        {
+            name: "action_item_create",
+            description: "Create a lightweight action item — a tracked to-do assigned to a person (e.g. a task captured from chat). Distinct from the openspec-linked ticket hierarchy; promote to a ticket task when it becomes real dev work. Requires the deployment to have action items enabled.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    title: { type: "string", description: "Short description of the action item" },
+                    assignee_user_id: {
+                        type: "string",
+                        description: "AgentHub user id to assign to (optional; created unassigned if omitted)",
+                    },
+                    details: { type: "string", description: "Optional longer details" },
+                    due_at: { type: "string", description: "Optional due timestamp (RFC3339)" },
+                    source_kind: {
+                        type: "string",
+                        description: "Origin: manual | slack_mention | slack_command | slack_shortcut | slack_reaction | slack_autoparse (default manual)",
+                    },
+                    source_ref: { type: "string", description: "Optional provenance link (e.g. a Slack permalink)" },
+                },
+                required: ["title"],
+            },
+        },
+        {
+            name: "action_item_list",
+            description: "List action items in your org, optionally filtered by assignee user id and/or status (open | snoozed | done | cancelled).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    assignee: { type: "string", description: "Filter by assignee AgentHub user id" },
+                    status: {
+                        type: "string",
+                        description: "Filter by status: open | snoozed | done | cancelled",
+                    },
+                },
+            },
+        },
+        {
+            name: "action_item_complete",
+            description: "Mark an action item done.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: { type: "string", description: "Action item id" },
+                },
+                required: ["id"],
+            },
+        },
+        {
+            name: "action_item_snooze",
+            description: "Snooze an action item until a given time (RFC3339).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: { type: "string", description: "Action item id" },
+                    until: { type: "string", description: "RFC3339 timestamp to snooze until" },
+                },
+                required: ["id", "until"],
+            },
+        },
+        {
+            name: "action_item_promote",
+            description: "Promote an action item into a tracked ticket task under a story (when an ad-hoc item turns out to be real dev work). Links the two; completing the ticket later marks the action item done.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    id: { type: "string", description: "Action item id to promote" },
+                    story_id: { type: "string", description: "Target story id the new task will live under" },
+                },
+                required: ["id", "story_id"],
+            },
+        },
+        {
+            name: "notify_prefs_set",
+            description: "Set your action-item digest + reminder preferences (the authenticated user's). Controls which channel the daily digest is delivered on and whether overdue reminders are sent.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    digest_channel: {
+                        type: "string",
+                        description: "Where to deliver the digest: auto (Slack DM if linked, else email) | slack | email | both",
+                    },
+                    digest_hour_local: {
+                        type: "number",
+                        description: "Hour of day (0-23, local to tz) to send the daily digest",
+                    },
+                    tz: { type: "string", description: "IANA timezone name (e.g. Asia/Kolkata); default UTC" },
+                    reminders_enabled: { type: "boolean", description: "Whether to send overdue reminders" },
+                },
+            },
+        },
         {
             name: "join_channel",
             description: "Subscribe to a channel to receive its messages",
@@ -1683,7 +1886,29 @@ export function registerTools() {
             description: "Get the TOON-encoded org brain context package for this agent. Includes own session history, blockers, org decisions, and alerts.",
             inputSchema: {
                 type: "object",
-                properties: {},
+                properties: {
+                    include_code: {
+                        type: "boolean",
+                        description: "add-code-brain: when true, append a code_index section with top org-wide code/doc matches relevant to recent sessions. Default false — behaviour is byte-identical to pre-change when omitted.",
+                    },
+                },
+            },
+        },
+        {
+            name: "brain_code_recall",
+            description: "add-code-brain: search the org-wide indexed code + docs (Markdown / RST / OpenAPI / HTML / Jupyter / PDF + tree-sitter symbols). Use when org_search returns nothing for a code or architecture question, or when you need to discover files/symbols that no agent has written down. Read-only.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Free-text query — symbol name, doc title fragment, or natural-language phrase" },
+                    k: { type: "number", description: "Max hits per kind (default 5, max 50)" },
+                    kinds: {
+                        type: "array",
+                        items: { type: "string", enum: ["docs", "symbols"] },
+                        description: "Restrict to docs and/or symbols. Default both.",
+                    },
+                },
+                required: ["query"],
             },
         },
         {
@@ -2222,24 +2447,32 @@ export async function handleToolCall(name, args, client, context) {
                     try {
                         // Use provided name, or fall back to stored name
                         const reconnectName = args.name || existingState.name;
-                        const reconnectResult = await client.reconnectAgent(existingState.agent_id, existingState.token, owner, args.model, reconnectName);
+                        // fix-agent-register-project-binding §3 — pass the tool's `project`
+                        // arg so reconnect binds project_id. The reconnect path previously
+                        // ignored it, leaving local state.project_id empty and
+                        // create_epic/create_task unusable despite a healthy session.
+                        const reconnectResult = await client.reconnectAgent(existingState.agent_id, existingState.token, owner, args.model, reconnectName, projectKey);
                         context.setCurrentAgentId(existingState.agent_id);
                         // Set connect token on client for org operations
                         client.setConnectToken(existingState.token);
                         // Store working_dir in context for other tools to use
                         context.setWorkingDir(workingDir);
-                        // Update state with returned name from server
+                        // Persist the server-returned project binding, falling back to the
+                        // existing values when the server did not resolve a project.
                         state.saveState(workingDir, {
                             ...existingState,
                             name: reconnectResult.name,
+                            project_id: reconnectResult.project_id || existingState.project_id,
+                            project_key: reconnectResult.project_key || existingState.project_key,
                             last_task: undefined, // Cleared on reconnect
                         });
+                        const unresolvedNote = projectKey && !reconnectResult.project_resolved
+                            ? ` (note: project "${projectKey}" could not be resolved; project not bound)`
+                            : "";
                         return {
                             ...reconnectResult,
                             mode: "reconnected",
-                            message: reconnectResult.was_offline
-                                ? `Reconnected as ${reconnectResult.name || existingState.agent_id}. You have ${reconnectResult.pending_tasks_count} pending tasks and ${reconnectResult.unread_messages_count} unread messages.`
-                                : `Reconnected as ${reconnectResult.name || existingState.agent_id}. You have ${reconnectResult.pending_tasks_count} pending tasks and ${reconnectResult.unread_messages_count} unread messages.`,
+                            message: `Reconnected as ${reconnectResult.name || existingState.agent_id}. You have ${reconnectResult.pending_tasks_count} pending tasks and ${reconnectResult.unread_messages_count} unread messages.${unresolvedNote}`,
                         };
                     }
                     catch (error) {
@@ -2595,6 +2828,19 @@ export async function handleToolCall(name, args, client, context) {
                 } : null,
             };
         }
+        case "brain_flush_session": {
+            // Flush the current session to the local .mv2 + server WITHOUT
+            // disconnecting. Mirrors gracefulShutdown's agent-id resolution so it
+            // works even if agent_register was never called this process. The agent
+            // stays registered for the next reconnect.
+            const workingDir = context.getWorkingDir();
+            const flushAgentId = agentId || (workingDir ? state.readHookAgentId(workingDir) : null);
+            if (!flushAgentId) {
+                return { flushed: false, reason: "no agent id resolved" };
+            }
+            const { mv2Written } = await brainCapture.flushSessionToBrain(client, flushAgentId);
+            return { flushed: true, agent_id: flushAgentId, mv2_written: mv2Written };
+        }
         case "now": {
             // No wrapping — server_time would otherwise overshadow the explicit
             // tool result. Force-refresh past the cache so the agent gets a fresh
@@ -2818,6 +3064,32 @@ export async function handleToolCall(name, args, client, context) {
             const result = await client.getAgent(args.id);
             return wrapWithPendingItems(client, agentId, result, context);
         }
+        case "calendar_schedule_meeting": {
+            const result = await client.scheduleMeeting({
+                title: args.title,
+                start: args.start,
+                end: args.end,
+                attendee_emails: args.attendee_emails,
+                description: args.description,
+                timezone: args.timezone,
+                recurrence: args.recurrence,
+                dedupe_key: args.dedupe_key,
+                source: args.source,
+            });
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        case "email_send": {
+            const result = await client.sendEmail({
+                to: args.to,
+                subject: args.subject,
+                body_text: args.body_text,
+                body_html: args.body_html,
+                template: args.template,
+                template_vars: args.template_vars,
+                dedupe_key: args.dedupe_key,
+            });
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
         case "list_channels": {
             const result = await client.listChannels();
             return wrapWithPendingItems(client, agentId, result, context);
@@ -2828,6 +3100,71 @@ export async function handleToolCall(name, args, client, context) {
             const result = await client.listProjects(args.include_archived);
             return wrapWithPendingItems(client, agentId, result, context);
         }
+        // add-api-knowledge-graph §3 — org-wide read of the API graph.
+        case "api_search": {
+            const result = await client.apiSearch({
+                query: args.query,
+                project_id: args.project_id,
+                surface: args.surface,
+            });
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        case "api_get_endpoint": {
+            const result = await client.apiGetEndpoint(args.identity, args.project_id);
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        case "api_endpoint_impact": {
+            const result = await client.apiEndpointImpact(args.identity, args.project_id);
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        case "api_graph": {
+            const result = await client.apiGraph({
+                project_id: args.project_id,
+                surface: args.surface,
+            });
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        // add-action-items Phase 1 — org-scoped (auth via the agent's connect
+        // token); no agentId guard, mirroring list_projects.
+        case "action_item_create": {
+            const result = await client.createActionItem({
+                title: args.title,
+                assignee_user_id: args.assignee_user_id,
+                details: args.details,
+                due_at: args.due_at,
+                source_kind: args.source_kind,
+                source_ref: args.source_ref,
+            });
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        case "action_item_list": {
+            const result = await client.listActionItems({
+                assignee: args.assignee,
+                status: args.status,
+            });
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        case "action_item_complete": {
+            const result = await client.completeActionItem(args.id);
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        case "action_item_snooze": {
+            const result = await client.snoozeActionItem(args.id, args.until);
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        case "action_item_promote": {
+            const result = await client.promoteActionItem(args.id, args.story_id);
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
+        case "notify_prefs_set": {
+            const result = await client.setNotifyPrefs({
+                digest_channel: args.digest_channel,
+                digest_hour_local: args.digest_hour_local,
+                tz: args.tz,
+                reminders_enabled: args.reminders_enabled,
+            });
+            return wrapWithPendingItems(client, agentId, result, context);
+        }
         case "join_channel": {
             if (!agentId)
                 throw new Error("Not registered. Call agent_register first.");
@@ -3708,7 +4045,35 @@ export async function handleToolCall(name, args, client, context) {
         case "brain_get_context": {
             if (!agentId)
                 throw new Error("Not registered. Call agent_register first.");
-            return client.getBrainContext(agentId);
+            const includeCode = Boolean(args.include_code);
+            const qs = includeCode ? "?include_code=true" : "";
+            // Use raw GET so the include_code flag round-trips without a typed
+            // client helper. Server-side decides whether to append code_index.
+            return client.get(`/brain/context/${encodeURIComponent(agentId)}${qs}`);
+        }
+        case "brain_code_recall": {
+            const query = args.query || "";
+            if (!query)
+                throw new Error("query is required");
+            const k = args.k || 5;
+            const kindsArr = args.kinds || ["docs", "symbols"];
+            const params = new URLSearchParams();
+            params.set("q", query);
+            params.set("k", String(k));
+            params.set("kinds", kindsArr.join(","));
+            try {
+                return await client.get(`/brain/code/search?${params.toString()}`);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (msg.includes("code_brain_disabled")) {
+                    return {
+                        error: "code_brain_disabled",
+                        message: "The code brain is disabled on this server. It defaults to enabled — ask the operator to unset AGENTHUB_CODE_BRAIN_ENABLED (or set it back to true) and restart.",
+                    };
+                }
+                throw e;
+            }
         }
         case "brain_list_sessions": {
             const targetAgent = args.agent_id || agentId;