agenthub-multiagent-mcp 1.73.0 → 1.75.0

package/dist/tools/index.js

@@ -23,6 +23,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { describeSendResult } from "../messageIdempotency.js";
 import { readZohoAttachments } from "../zohoAttachments.js";
+import { isUnknownSendOutcome, unknownSendOutcomeError } from "../zohoSendOutcome.js";
 // fix-message-send-idempotency — shared by the four message tools.
 const IDEMPOTENCY_KEY_DESCRIPTION = "Optional. Leave unset: a key derived from the message content is sent, so " +
     "re-issuing this exact call (e.g. after a timeout) never delivers it twice. " +
@@ -1743,7 +1744,22 @@ export function registerTools() {
             inputSchema: {
                 type: "object",
                 properties: {
-                    peer: { type: "string", description: "The peer agent id to brainstorm with (e.g. 'sumit-mobile')." },
+                    peer: { type: "string", description: "The peer agent id to brainstorm with (e.g. 'sumit-mobile'). For a group, use participants instead." },
+                    participants: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Group brainstorm (add-multi-agent-conversations): the agent ids to invite, at most 5 besides you. One id behaves like peer. More than one needs AGENTHUB_GROUP_CONVERSATIONS_ENABLED on the server (else group_conversations_disabled).",
+                    },
+                    turn_policy: {
+                        type: "string",
+                        enum: ["round_robin", "free", "moderated"],
+                        description: "Group only. round_robin (default): the server names next_speaker in order of joining. free: anyone, but not twice in a row. moderated: the moderator speaks and hands the floor with brainstorm_yield.",
+                    },
+                    moderator: { type: "string", description: "moderated only: you (default) or one of the participants." },
+                    mirror_channel: {
+                        type: "string",
+                        description: "Group only: a Goshti channel (e.g. '#winery') to mirror every turn to as one thread; people's replies there become human_note turns.",
+                    },
                     topic: { type: "string", description: "One-line subject of the brainstorm." },
                     escalation: {
                         type: "string",
@@ -1756,7 +1772,7 @@ export function registerTools() {
                         description: "Peer-silence backstop in seconds (default 600).",
                     },
                 },
-                required: ["peer", "topic"],
+                required: ["topic"],
             },
         },
         {
@@ -1783,6 +1799,17 @@ export function registerTools() {
                         enum: ["message", "propose_conclude", "human_note", "system"],
                         description: "Turn kind (default 'message').",
                     },
+                    // add-live-work-graphs: these are what the brainstorm graph is drawn from.
+                    tag: {
+                        type: "string",
+                        enum: ["idea", "question", "objection", "decision", "summary"],
+                        description: "What this turn is for. Tag every turn you can: an untagged turn is drawn as a plain message.",
+                    },
+                    refs: {
+                        type: "array",
+                        items: { type: "integer" },
+                        description: "The seq numbers of earlier turns in this session that this turn answers or objects to (at most 20). A turn not yet written is refused with invalid_ref.",
+                    },
                 },
                 required: ["session_id", "body"],
             },
@@ -1799,6 +1826,18 @@ export function registerTools() {
                 required: ["session_id"],
             },
         },
+        {
+            name: "brainstorm_yield",
+            description: "Moderated group brainstorm only: as the moderator, hand the floor to a joined participant (yield to yourself to take it back). Refusals: not_moderated, not_moderator, yield_target_not_joined. (requires agent_register first)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    session_id: { type: "string", description: "The brainstorm session id." },
+                    to: { type: "string", description: "The agent id that gets the floor." },
+                },
+                required: ["session_id", "to"],
+            },
+        },
         {
             name: "brainstorm_conclude",
             description: "Conclude a brainstorm with a structured outcome (mutual consensus). Succeeds ONLY when the peer's last turn was a propose_conclude — else returns conclusion_not_confirmed. The outcome seeds an OpenSpec change. (requires agent_register first)",
@@ -3083,6 +3122,17 @@ function requireBrainstormProject(context) {
     }
     return agentState.project_id;
 }
+// brainstormTurnAnnotations picks brainstorm_turn's tag and refs out of the
+// tool arguments (add-live-work-graphs). Absent ones are left out of the body;
+// the server validates both and refuses a bad ref with 400 invalid_ref.
+function brainstormTurnAnnotations(args) {
+    const out = {};
+    if (typeof args.tag === "string" && args.tag !== "")
+        out.tag = args.tag;
+    if (Array.isArray(args.refs) && args.refs.length > 0)
+        out.refs = args.refs.map((r) => Number(r));
+    return out;
+}
 // brainstormError formats a structured (non-throwing) failure result for a
 // brainstorm tool, mirroring the ticket_get error shape.
 function brainstormError(tool, result) {
@@ -4514,21 +4564,31 @@ export async function handleToolCall(name, args, client, context) {
         // =============================================================================
         case "brainstorm_open": {
             const projectId = requireBrainstormProject(context);
+            const participants = Array.isArray(args.participants) ? args.participants : undefined;
             const result = await client.brainstormOpen(projectId, {
                 peer: args.peer,
                 topic: args.topic,
                 escalation: args.escalation,
                 max_turns: args.max_turns,
                 silence_deadline_secs: args.silence_deadline_secs,
+                participants,
+                turn_policy: args.turn_policy,
+                moderator: args.moderator,
+                mirror_channel: args.mirror_channel,
             });
             if (!result.ok)
                 return brainstormError("brainstorm_open", result);
+            const invitees = [args.peer, ...(participants ?? [])].filter(Boolean).join(", ");
             return {
                 ok: true,
                 session_id: result.data.session_id,
                 display_number: result.data.display_number,
                 invite_delivered: result.data.invite_delivered ?? true,
-                message: `Brainstorm ${result.data.display_number} opened with ${args.peer}. Invite delivered${result.data.invite_delivered === false ? " FAILED" : ""}.`,
+                turn_policy: result.data.turn_policy,
+                invites: result.data.invites,
+                mirror_thread_id: result.data.mirror_thread_id,
+                mirror_warning: result.data.mirror_warning,
+                message: `Brainstorm ${result.data.display_number} opened with ${invitees}. Invite delivered${result.data.invite_delivered === false ? " FAILED" : ""}.`,
             };
         }
         case "brainstorm_accept": {
@@ -4552,7 +4612,8 @@ export async function handleToolCall(name, args, client, context) {
         }
         case "brainstorm_turn": {
             const projectId = requireBrainstormProject(context);
-            const result = await client.brainstormTurn(projectId, args.session_id, args.body, args.kind);
+            const result = await client.brainstormTurn(projectId, args.session_id, args.body, args.kind, brainstormTurnAnnotations(args) // add-live-work-graphs
+            );
             if (!result.ok)
                 return brainstormError("brainstorm_turn", result);
             return { ok: true, turn: result.data, message: `Turn ${result.data.seq} posted.` };
@@ -4563,12 +4624,32 @@ export async function handleToolCall(name, args, client, context) {
             if (!result.ok)
                 return brainstormError("brainstorm_poll", result);
             const turns = Array.isArray(result.data.turns) ? result.data.turns : [];
+            // add-multi-agent-conversations: a group session names who speaks next;
+            // your_turn is set only when it does (undefined for two-agent and free).
+            const nextSpeaker = result.data.next_speaker || undefined;
             return {
                 ok: true,
                 state: result.data.state,
                 turn_count: result.data.turn_count,
                 turns,
-                message: `${turns.length} new turn(s); state=${result.data.state}.`,
+                next_speaker: nextSpeaker,
+                your_turn: nextSpeaker ? nextSpeaker === agentId : undefined,
+                turn_policy: result.data.turn_policy || undefined,
+                conclusion_pending: result.data.conclusion_pending,
+                participants: result.data.participants,
+                message: `${turns.length} new turn(s); state=${result.data.state}${nextSpeaker ? `; next speaker ${nextSpeaker}` : ""}.`,
+            };
+        }
+        case "brainstorm_yield": {
+            const projectId = requireBrainstormProject(context);
+            const result = await client.brainstormYield(projectId, args.session_id, args.to);
+            if (!result.ok)
+                return brainstormError("brainstorm_yield", result);
+            return {
+                ok: true,
+                floor: result.data.floor,
+                next_speaker: result.data.next_speaker,
+                message: `Floor handed to ${result.data.next_speaker}.`,
             };
         }
         case "brainstorm_conclude": {
@@ -5525,6 +5606,7 @@ export async function handleToolCall(name, args, client, context) {
                 throw new Error("Not registered. Call agent_register first.");
             // Read and check every local file before any request (never a partial send).
             const attachments = readZohoAttachments(args.attachments);
+            const sendMode = args.mode === "send" ? "send" : "draft";
             const res = await client.zohoSend({
                 mailbox: args.mailbox,
                 to: args.to,
@@ -5539,6 +5621,11 @@ export async function handleToolCall(name, args, client, context) {
                 reply_all: args.reply_all,
                 mode: args.mode,
                 dedupe_key: args.dedupe_key,
+            }).catch((err) => {
+                if (isUnknownSendOutcome(err)) {
+                    throw unknownSendOutcomeError(args.mailbox, sendMode, err);
+                }
+                throw err;
             });
             const extras = (res.threaded ? " Threaded as a reply." : "") +
                 (attachments.length > 0 ? ` ${attachments.length} attachment(s).` : "");