@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/dist/pi-intercom/supervisor.js

@@ -0,0 +1,282 @@
+import { resolveConnectedTarget } from "./connection.js";
+import { formatChildOrchestratorMessage } from "./identity.js";
+import { formatSupervisorInterviewRequest, parseStructuredSupervisorReply, validateSupervisorInterviewRequest, } from "./interview.js";
+import { errorMessage } from "./validation.js";
+import { formatAttachments } from "./message-format.js";
+import { toolError, toolText } from "./tool-arguments.js";
+import { createSupervisorQuestion, readQuestionState, recordQuestionDelivery, } from "../runs/shared/supervisor-questions.js";
+import { formatRunAction } from "../shared/status-format.js";
+function validateContact(params) {
+    const { reason, message } = params;
+    if (!["need_decision", "progress_update", "interview_request"].includes(reason)) {
+        return toolError("Invalid reason. Use 'need_decision', 'interview_request', or 'progress_update'.");
+    }
+    if ((reason === "need_decision" || reason === "progress_update") && typeof message !== "string") {
+        return toolError(`Missing 'message' parameter for reason '${reason}'.`);
+    }
+    return;
+}
+function replyDetails(questionId, text, interview) {
+    const structured = interview ? parseStructuredSupervisorReply(text, interview) : undefined;
+    if (structured?.value) {
+        return { questionId, structuredReply: structured.value };
+    }
+    if (structured?.error !== undefined && structured.error !== "") {
+        return { questionId, structuredReplyParseError: structured.error };
+    }
+    return { questionId };
+}
+/** Owns durable supervisor questions and every wake-notification attempt. */
+export class IntercomSupervisor {
+    owners;
+    metadata;
+    notifications = new Set();
+    constructor(owners, metadata) {
+        this.owners = owners;
+        this.metadata = metadata;
+    }
+    async drain() {
+        await Promise.allSettled(this.notifications);
+    }
+    createQuestion(request) {
+        const { reason, interview, ctx } = request;
+        const body = interview
+            ? formatSupervisorInterviewRequest(interview, request.message)
+            : (request.message ?? "");
+        const metadata = this.metadata;
+        const question = createSupervisorQuestion({
+            runId: metadata.runId,
+            ownerTarget: metadata.orchestratorTarget,
+            agent: metadata.agent,
+            index: Number(metadata.index),
+            childSessionId: ctx.sessionManager.getSessionId(),
+            childTarget: metadata.sessionName ??
+                this.owners.lifecycle.identity(ctx.sessionManager.getSessionId()).name,
+            sessionFile: ctx.sessionManager.getSessionFile() ?? "",
+            cwd: ctx.cwd,
+            pid: process.pid,
+            reason,
+            message: body,
+            ...(interview ? { interview } : {}),
+        });
+        const text = formatChildOrchestratorMessage(interview ? "interview" : "ask", metadata, [
+            `Question ID: ${question.questionId}`,
+            `Answer after reconnect/reload: ${formatRunAction("answer", question.runId, { questionId: question.questionId, message: "..." }, Number(process.env.PI_SUBAGENT_DEPTH) > 1)}`,
+            body,
+        ].join("\n"));
+        return { question, text };
+    }
+    ownNotification(operation) {
+        const task = Promise.resolve().then(operation);
+        this.notifications.add(task);
+        task
+            .then(() => {
+            this.notifications.delete(task);
+        }, (error) => {
+            this.notifications.delete(task);
+            console.error("Intercom supervisor notification failed:", error);
+        })
+            .catch((error) => {
+            console.error("Intercom supervisor notification cleanup failed:", error);
+        });
+    }
+    scheduleNotification(notification) {
+        let retryAfter = 0;
+        let failureLogged = false;
+        const { question, text, reason } = notification;
+        const active = () => this.owners.wait.isWaitingFor(question.questionId);
+        const logFailure = (error) => {
+            if (active() && !failureLogged) {
+                this.owners.pi.appendEntry("intercom_question_notification_error", {
+                    questionId: question.questionId,
+                    error: errorMessage(error),
+                });
+                failureLogged = true;
+            }
+        };
+        const recordNotification = (to, sent) => {
+            if (sent.accepted || !failureLogged) {
+                this.owners.pi.appendEntry("intercom_sent", {
+                    to,
+                    messageId: question.questionId,
+                    message: { text, reason },
+                    accepted: sent.accepted,
+                    timestamp: Date.now(),
+                });
+            }
+            failureLogged ||= !sent.accepted;
+        };
+        const notify = async () => {
+            if (!active() || Date.now() < retryAfter) {
+                return;
+            }
+            this.owners.wait.clearRetry(question.questionId);
+            let retry = true;
+            try {
+                const client = await this.owners.connection.ensure("tool");
+                if (!active()) {
+                    return;
+                }
+                const to = (await resolveConnectedTarget(client, this.metadata.orchestratorTarget)) ??
+                    this.metadata.orchestratorTarget;
+                if (!active()) {
+                    return;
+                }
+                this.owners.wait.retarget(question.questionId, to);
+                // A thrown send may have lost only its acknowledgement; replay only explicit rejection.
+                retry = false;
+                const sent = await client.send(to, {
+                    text,
+                    messageId: question.questionId,
+                    expectsReply: true,
+                    delivery: "steer",
+                });
+                if (!active()) {
+                    return;
+                }
+                retry = !sent.accepted;
+                recordNotification(to, sent);
+            }
+            catch (error) {
+                logFailure(error);
+            }
+            finally {
+                if (retry && active()) {
+                    retryAfter = Date.now() + 1000;
+                    this.owners.wait.retry(question.questionId, () => {
+                        this.ownNotification(notify);
+                    });
+                }
+            }
+        };
+        this.ownNotification(notify);
+    }
+    async decision(request) {
+        if (this.owners.wait.waiting) {
+            throw new Error("Already waiting for a reply");
+        }
+        if (request.signal?.aborted === true) {
+            throw new Error("Cancelled");
+        }
+        const { question, text } = this.createQuestion(request);
+        const reply = this.owners.wait.wait({
+            from: this.metadata.orchestratorTarget,
+            replyTo: question.questionId,
+            signal: request.signal,
+            question,
+        });
+        this.scheduleNotification({ question, text, reason: request.reason });
+        const message = await reply;
+        return this.answer(question, message, request.interview);
+    }
+    answer(question, message, interview) {
+        this.owners.pi.appendEntry("intercom_received", {
+            from: this.metadata.orchestratorTarget,
+            questionId: question.questionId,
+            message: message.content,
+            messageId: message.id,
+            timestamp: message.timestamp,
+        });
+        recordQuestionDelivery(question, {
+            kind: "live",
+            runId: question.runId,
+            deliveredAt: Date.now(),
+        });
+        const details = replyDetails(question.questionId, message.content.text, interview);
+        const origin = readQuestionState(question).answer?.origin;
+        return toolText(`**${origin === "human" ? "Direct user answer (human origin)" : "Reply from supervisor"}:**\n${message.content.text}${formatAttachments(message.content.attachments ?? [])}`, details);
+    }
+    async progress(message, signal, ctx) {
+        let client;
+        try {
+            client = await this.owners.connection.ensure("tool");
+        }
+        catch (error) {
+            return toolError(`Intercom not connected: ${errorMessage(error)}`);
+        }
+        this.owners.connection.syncIdentity(ctx.sessionManager.getSessionId());
+        if (signal?.aborted === true) {
+            return toolError("Cancelled");
+        }
+        let to;
+        try {
+            to =
+                (await resolveConnectedTarget(client, this.metadata.orchestratorTarget)) ??
+                    this.metadata.orchestratorTarget;
+        }
+        catch (error) {
+            return toolError(`Failed to resolve supervisor target: ${errorMessage(error)}`);
+        }
+        if (this.cancelled(signal)) {
+            return toolError("Cancelled");
+        }
+        if (to === client.sessionId) {
+            return toolError("Cannot message the current session");
+        }
+        try {
+            const result = await client.send(to, {
+                text: formatChildOrchestratorMessage("update", this.metadata, message),
+                delivery: "steer",
+            });
+            return this.progressReceipt(message, result);
+        }
+        catch (error) {
+            return toolError(`Failed to send progress update: ${errorMessage(error)}`);
+        }
+    }
+    progressReceipt(message, result) {
+        if (!result.accepted) {
+            return toolError(`Message to "${this.metadata.orchestratorTarget}" was not delivered: ${result.reason ?? "Session may not exist or has disconnected."}`, {
+                messageId: result.id,
+                accepted: result.accepted,
+                delivered: false,
+                reason: result.reason,
+            });
+        }
+        this.owners.lifecycle.markActivity();
+        this.owners.connection.syncStatus();
+        this.owners.pi.appendEntry("intercom_sent", {
+            to: this.metadata.orchestratorTarget,
+            message: { text: message, reason: "progress_update" },
+            messageId: result.id,
+            timestamp: Date.now(),
+            subagent: {
+                runId: this.metadata.runId,
+                agent: this.metadata.agent,
+                index: this.metadata.index,
+            },
+        });
+        return toolText(`Progress update accepted for supervisor ${this.metadata.orchestratorTarget}. Queued for the next tool boundary; broker acceptance does not confirm the supervisor has read or acted on it.`, {
+            messageId: result.id,
+            accepted: result.accepted,
+            delivered: result.delivered,
+            queued: result.queued === true,
+        });
+    }
+    cancelled(signal) {
+        return signal?.aborted === true;
+    }
+    async execute(params, signal, ctx) {
+        const { reason, message } = params;
+        const invalid = validateContact(params);
+        if (invalid) {
+            return invalid;
+        }
+        if (reason === "progress_update") {
+            return await this.progress(message ?? "", signal, ctx);
+        }
+        const validation = reason === "interview_request"
+            ? validateSupervisorInterviewRequest(params.interview)
+            : undefined;
+        if (validation?.ok === false) {
+            return toolError(`Invalid interview request: ${validation.error}`);
+        }
+        return await this.decision({
+            reason,
+            message,
+            interview: validation?.ok === true ? validation.interview : undefined,
+            signal,
+            ctx,
+        });
+    }
+}

package/dist/pi-intercom/tool-arguments.js

@@ -0,0 +1,74 @@
+import { failureDetails } from "./tool-results.js";
+export function toolError(text, details = { error: true }) {
+    return { content: [{ type: "text", text }], isError: true, details };
+}
+export function toolText(text, details = {}) {
+    return { content: [{ type: "text", text }], isError: false, details };
+}
+function deliveryError(params) {
+    const { action, delivery, passive } = params;
+    if (passive !== undefined && action !== "send") {
+        return toolError("'passive' is only valid for action='send'");
+    }
+    if (delivery === "passive" && action !== "send") {
+        return toolError("delivery='passive' is only valid for action='send'. Passive delivery is for human-visible breadcrumbs and is discouraged for agent-to-agent coordination; normal send defaults to steer. Use ask with delivery='steer' only when the sender must stay alive and cannot safely continue without the reply.");
+    }
+    const actionError = deliveryActionError(params);
+    if (actionError) {
+        return actionError;
+    }
+    if (passive === true && delivery !== undefined && delivery !== "passive") {
+        return toolError("'passive' cannot be combined with a non-passive delivery mode");
+    }
+    return;
+}
+function deliveryActionError(params) {
+    const { action, delivery, queueMode, threadId } = params;
+    if ((delivery !== undefined || queueMode !== undefined || threadId !== undefined) &&
+        action !== "send" &&
+        action !== "ask") {
+        const queue = queueMode !== undefined || delivery === "queue" || threadId !== undefined;
+        return toolError("'delivery', 'queueMode', and 'threadId' are only valid for action='send' or action='ask'", failureDetails(queue ? "invalid_queue_arguments" : "invalid_delivery_arguments", [{ action: "send", guidance: "Use delivery options only with send or ask." }], { error: true }));
+    }
+    return;
+}
+function queueError(params) {
+    const { threadId, queueMode } = params;
+    if (threadId !== undefined && queueMode !== "replace") {
+        return toolError("'threadId' is only valid with queueMode='replace'", failureDetails("invalid_queue_arguments", [
+            {
+                action: "send",
+                guidance: "Use threadId only with delivery='queue' and queueMode='replace'.",
+            },
+        ], { error: true }));
+    }
+    if (queueMode === "replace" && (threadId === undefined || threadId.trim() === "")) {
+        return toolError("queueMode='replace' requires a non-empty threadId", failureDetails("invalid_queue_arguments", [
+            {
+                action: "send",
+                guidance: "Provide a non-empty threadId with delivery='queue' and queueMode='replace'.",
+            },
+        ], { error: true }));
+    }
+    const delivery = params.passive === true ? "passive" : params.delivery;
+    if (queueMode !== undefined && delivery !== "queue") {
+        return toolError("'queueMode' is only valid with delivery='queue'. Use queue only for intentionally deferred work; otherwise omit queueMode and use default-steered send for live agent coordination. Avoid passive for agent-to-agent coordination.", failureDetails("invalid_queue_arguments", [{ action: "send", guidance: "Set delivery='queue', or omit queueMode and threadId." }], { error: true }));
+    }
+    return;
+}
+export function validateIntercomArguments(params) {
+    if (params.scope !== undefined && params.action !== "list" && params.action !== "status") {
+        return toolError("'scope' is only valid for action='list' or action='status'");
+    }
+    return deliveryError(params) ?? queueError(params);
+}
+export function sendOptions(params) {
+    return {
+        text: params.message ?? "",
+        attachments: params.attachments,
+        replyTo: params.replyTo,
+        delivery: params.passive === true ? "passive" : params.delivery,
+        queueMode: params.queueMode,
+        threadId: params.threadId?.trim(),
+    };
+}

package/dist/pi-intercom/tool-registration.js

@@ -0,0 +1,95 @@
+import { Type } from "../shared/native-typebox.js";
+import { activateTools } from "../shared/lazy-tools.js";
+import { throwIfToolError } from "./tool-results.js";
+import { intercomSchema, contactSupervisorSchema } from "./tool-schemas.js";
+import { renderContactCall, renderContactResult, renderIntercomCall, renderIntercomResult, } from "./ui/tool-renderers.js";
+function nativeResult(result) {
+    const success = throwIfToolError(result);
+    return { content: [...success.content], details: success.details, isError: false };
+}
+function registerContact(pi, supervisor) {
+    pi.registerTool({
+        name: "contact_supervisor",
+        label: "Contact Supervisor",
+        description: "Subagent-only tool for contacting the supervisor agent that delegated this task. Use need_decision only when this child cannot safely continue without a decision, approval, or product/API/scope clarification; this steers the supervisor at its next tool boundary and keeps the child alive for the reply. Use interview_request only when multiple structured answers are all required before safe progress; this also steers and waits. Use progress_update only for a discovery or change the supervisor needs while working; it steers at the next tool boundary without waiting for a reply. Skip starts, redundant status, and routine completion; retain material findings in the final result.",
+        promptSnippet: "Subagent-only: steer the supervisor for required decisions, structured interviews, or material discoveries needed during active work. Skip routine status and completion messages.",
+        promptGuidelines: [
+            "Use contact_supervisor with reason='need_decision' when a subagent cannot safely continue without a decision, approval, or product/API/scope clarification; it steers the supervisor and waits for the reply.",
+            "Use contact_supervisor with reason='interview_request' only when the child cannot safely continue until it receives multiple structured answers in one blocking steered exchange.",
+            "Use contact_supervisor with reason='progress_update' only for a discovery or change the supervisor needs while working. It steers at the next tool boundary without waiting. Skip starts, redundant narration, and routine completion; keep material findings in the final result.",
+            "Do not use contact_supervisor for routine completion handoffs; return the final subagent result normally.",
+        ],
+        parameters: contactSupervisorSchema,
+        async execute(_id, params, signal, _update, ctx) {
+            return nativeResult(await supervisor.execute(params, signal, ctx));
+        },
+        renderCall: renderContactCall,
+        renderResult: renderContactResult,
+    });
+}
+function registerLoader(pi) {
+    pi.registerTool({
+        name: "load_intercom",
+        label: "Load Intercom",
+        description: "Enable local peer coordination: list/check sessions before shared-state work, send or reply to messages, and inspect/publish topics. Does not send a message or check peers itself.",
+        parameters: Type.Object({}),
+        async execute() {
+            if (!pi.getAllTools().some((tool) => tool.name === "intercom" && tool.namespace === undefined)) {
+                throw new Error("Intercom is excluded from this session.");
+            }
+            activateTools(pi, ["intercom"]);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Intercom enabled. Use intercom({action:'list'}) to check peers, or status, pending, reply, send, ask and topics for coordination.",
+                    },
+                ],
+                details: {},
+            };
+        },
+    });
+}
+function registerMessaging(pi, tools) {
+    pi.registerTool({
+        name: "intercom",
+        defaultActive: false,
+        label: "Intercom",
+        description: `Send a message to another pi session running on this machine.
+Use this to communicate findings, request help, or coordinate work with other sessions.
+Non-blocking send defaults to steer for guidance, answers, corrections, or blockers that may affect active work. Use queue only when delay is intentional; use ask only when this process must remain alive waiting for the reply.
+
+Usage:
+  intercom({ action: "list" })                    → List sessions in this repository and its worktrees
+  intercom({ action: "list", scope: "all" })      → List connected sessions across every project
+  intercom({ action: "send", to: "session-name", message: "..." })  → Send live coordination (defaults to steer)
+  intercom({ action: "ask", to: "session-name", delivery: "steer", message: "..." })   → Blocking wait only when sender must stay alive
+  intercom({ action: "reply", message: "..." })                      → Reply to the active/single pending ask
+  intercom({ action: "pending" })                                      → List unresolved inbound asks
+  intercom({ action: "status" })                  → Show connection status
+  intercom({ action: "subscribe", topic: "project/work", awaitRelease: true }) → Opt into a topic
+  intercom({ action: "publish", topic: "project/work", message: "Current self-contained state" }) → Quiet latest state
+  intercom({ action: "topics" }) → Inspect topics and current resource owners`,
+        promptSnippet: "Coordinate with local Pi sessions. Non-blocking send defaults to steer for live agent guidance; queue only for intentional delay and ask only for a required blocking reply.",
+        promptGuidelines: [
+            "Intercom list/status defaults to the current Git repository and its worktrees. Use scope='all' only when intentionally discovering sessions in other projects.",
+            "Action='send' defaults to delivery='steer' for agent-to-agent guidance, answers, corrections, blockers, or other context that may affect active work.",
+            "Use delivery='queue' only when delay is intentional. For routine status, explicitly subscribe/publish topics: updates replace quiet inspectable state outside model context, not passive conversation messages. Topic blockers/decisions and awaited ownership releases interrupt; direct messages always bypass subscriptions.",
+            "Treat inbound steered messages as supplemental coordination within the active task: incorporate relevant context and continue; replace the task only when the message explicitly says so.",
+            "Use action='reply' for an active inbound ask. Otherwise respond with send plus steer; use blocking ask only when this process must stay alive and cannot safely continue without the answer.",
+        ],
+        parameters: intercomSchema,
+        async execute(_id, params, signal, _update, ctx) {
+            return nativeResult(await tools.execute(params, signal, ctx));
+        },
+        renderCall: renderIntercomCall,
+        renderResult: renderIntercomResult,
+    });
+}
+export function registerIntercomTools(pi, tools, supervisor) {
+    if (supervisor) {
+        registerContact(pi, supervisor);
+    }
+    registerLoader(pi);
+    registerMessaging(pi, tools);
+}

package/dist/pi-intercom/tool-results.js

@@ -0,0 +1,38 @@
+export function failureDetails(reasonCode, nextActions, details = {}) {
+    return { ...details, reasonCode, nextActions };
+}
+export function replyFailureReason(message) {
+    if (message.startsWith("No active intercom context") || message.startsWith("No pending ask")) {
+        return "no_pending_reply";
+    }
+    if (message.startsWith("Multiple pending asks") || message.includes("too short")) {
+        return "ambiguous_reply_target";
+    }
+    return "reply_failed";
+}
+export function firstTextContent(result) {
+    return (result.content
+        ?.find((item) => item.type === "text" && typeof item.text === "string")
+        ?.text?.replace(/\*\*/g, "") ?? "");
+}
+export class ToolExecutionFailure extends Error {
+    details;
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+    }
+}
+export class AskDeliveryError extends Error {
+    result;
+    constructor(result) {
+        super(result.reason ?? "Session may not exist or has disconnected.");
+        this.result = result;
+    }
+}
+export function throwIfToolError(result) {
+    if (result.isError !== true) {
+        return result;
+    }
+    const text = firstTextContent(result);
+    throw new ToolExecutionFailure(text === "" ? "Tool failed" : text, result.details);
+}

package/dist/pi-intercom/tool-schemas.js

@@ -0,0 +1,82 @@
+import { StringEnum } from "@earendil-works/pi-ai";
+import { Type } from "../shared/native-typebox.js";
+export const contactSupervisorSchema = Type.Object({
+    reason: StringEnum(["need_decision", "progress_update", "interview_request"], {
+        description: "Contact reason: 'need_decision' and 'interview_request' steer the supervisor and wait for a reply; 'progress_update' steers a material discovery without waiting for a reply",
+    }),
+    message: Type.Optional(Type.String({
+        description: "Decision request, optional interview note, or meaningful progress update for the supervisor",
+    })),
+    interview: Type.Optional(Type.Object({
+        title: Type.Optional(Type.String()),
+        description: Type.Optional(Type.String()),
+        questions: Type.Array(Type.Object({
+            id: Type.String(),
+            type: StringEnum(["single", "multi", "text", "image", "info"], {
+                description: "Question type: single, multi, text, image, or info",
+            }),
+            question: Type.String(),
+            options: Type.Optional(Type.Array(Type.Unknown())),
+            context: Type.Optional(Type.String()),
+        })),
+    }, { description: "Structured interview request for reason='interview_request'" })),
+});
+export const intercomSchema = Type.Object({
+    action: StringEnum([
+        "list",
+        "send",
+        "ask",
+        "reply",
+        "pending",
+        "status",
+        "subscribe",
+        "unsubscribe",
+        "publish",
+        "topics",
+    ], {
+        description: "Direct messages: list/send/ask/reply/pending/status. Quiet state: subscribe/unsubscribe/publish/topics.",
+    }),
+    scope: Type.Optional(StringEnum(["project", "all"], {
+        description: "For list/status: 'project' (default) shows this Git repository and its worktrees; 'all' includes sessions in other projects.",
+    })),
+    to: Type.Optional(Type.String({
+        description: "Target session name or ID (for 'send', 'ask', or disambiguating 'reply')",
+    })),
+    topic: Type.Optional(Type.String({
+        description: "Exact opt-in topic for subscribe/unsubscribe/publish/topics; no automatic subscriptions.",
+    })),
+    event: Type.Optional(StringEnum(["update", "blocker", "decision", "release"], {
+        description: "Publish: update is quiet current state. Blockers/decisions interrupt subscribers; release interrupts only those awaiting release.",
+    })),
+    resource: Type.Optional(Type.String({
+        description: "Publish: resource this session is using (advisory ownership, not a lock).",
+    })),
+    ownership: Type.Optional(StringEnum(["held", "released"], {
+        description: "Publish: this session's declared resource state. Disconnect never implies released.",
+    })),
+    awaitRelease: Type.Optional(Type.Boolean({
+        description: "Subscribe: interrupt when this topic explicitly releases ownership.",
+    })),
+    message: Type.Optional(Type.String({
+        description: "Message for send/ask/reply, or self-contained latest state for publish",
+    })),
+    attachments: Type.Optional(Type.Array(Type.Object({
+        type: StringEnum(["file", "snippet", "context"]),
+        name: Type.String(),
+        content: Type.String(),
+        language: Type.Optional(Type.String()),
+    }))),
+    replyTo: Type.Optional(Type.String({
+        description: "Message ID to reply to (for threading or responding to an 'ask')",
+    })),
+    delivery: Type.Optional(StringEnum(["queue", "steer", "passive"], {
+        description: "Delivery mode. Omitted send delivery defaults to 'steer', which injects after the current tool call. Use 'queue' only to intentionally wait behind active work; 'passive' does not wake the recipient model.",
+    })),
+    queueMode: Type.Optional(StringEnum(["stack", "replace"], {
+        description: "For delivery='queue': 'stack' keeps all messages; 'replace' keeps only the latest undelivered message for the same threadId.",
+    })),
+    threadId: Type.Optional(Type.String({ description: "Stable topic key for queueMode='replace'." })),
+    passive: Type.Optional(Type.Boolean({
+        description: "For action='send' only: legacy alias for delivery='passive'. Discouraged for agent-to-agent messages.",
+    })),
+});

package/dist/pi-intercom/tools.js

@@ -0,0 +1,51 @@
+import { validateIntercomArguments, toolError, toolText } from "./tool-arguments.js";
+import { errorMessage } from "./validation.js";
+export class IntercomTools {
+    owners;
+    constructor(owners) {
+        this.owners = owners;
+    }
+    async dispatch(active, params, signal, ctx) {
+        const scope = params.scope ?? "project";
+        switch (params.action) {
+            case "subscribe":
+            case "unsubscribe":
+            case "publish":
+            case "topics":
+                return await this.owners.topicActions.execute(active, params, ctx);
+            case "list":
+                return await this.owners.inspection.list(active, scope);
+            case "status":
+                return await this.owners.inspection.status(active, scope, ctx);
+            case "pending":
+                return this.owners.inspection.pending();
+            case "send":
+                return await this.owners.outbound.send(active, params, ctx);
+            case "ask":
+                return await this.owners.outbound.ask(active, params, signal);
+            case "reply":
+                return await this.owners.outbound.reply(active, params);
+        }
+    }
+    async execute(params, signal, ctx) {
+        let active;
+        try {
+            active = await this.owners.connection.ensure("tool");
+        }
+        catch (error) {
+            if (params.action === "topics") {
+                this.owners.topics.disconnected();
+                return toolText(`Broker unavailable; last saved records follow.\n${this.owners.topics.inspect(params.topic)}`, { connection: "disconnected" });
+            }
+            return toolError(`Intercom not connected: ${errorMessage(error)}`);
+        }
+        this.owners.connection.syncIdentity(ctx.sessionManager.getSessionId());
+        if (!["subscribe", "unsubscribe", "publish", "topics"].includes(params.action)) {
+            const invalid = validateIntercomArguments(params);
+            if (invalid) {
+                return invalid;
+            }
+        }
+        return await this.dispatch(active, params, signal, ctx);
+    }
+}