@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/pi-intercom/subagent-events.js

@@ -1,238 +0,0 @@
-import { resolveConnectedTarget } from "./connection.js";
-import { isCompletedChild } from "./inbound-record.js";
-import { isRecord, isUnknownArray, errorMessage } from "./validation.js";
-import { registerSubagentLiveEventHandlers } from "./subagent-live-events.js";
-function relayCompletion(payload, source) {
-    const children = isUnknownArray(payload.children)
-        ? payload.children.filter(isCompletedChild)
-        : [];
-    if (source === undefined ||
-        typeof payload.runId !== "string" ||
-        typeof payload.status !== "string" ||
-        children.length === 0) {
-        return;
-    }
-    return {
-        runId: payload.runId,
-        status: payload.status,
-        children,
-        ...(typeof payload.completionId === "string" ? { completionId: payload.completionId } : {}),
-    };
-}
-function parseRelay(payload) {
-    if (!isRecord(payload) || typeof payload.to !== "string" || typeof payload.message !== "string") {
-        return null;
-    }
-    const source = payload.source === "foreground" || payload.source === "async" ? payload.source : undefined;
-    const completion = relayCompletion(payload, source);
-    return {
-        to: payload.to,
-        message: payload.message,
-        requestId: typeof payload.requestId === "string" ? payload.requestId : undefined,
-        source,
-        completion,
-    };
-}
-/** Owns event subscriptions and detached event work; stop prevents new admission. */
-export class SubagentEventBridges {
-    unsubscribes = [];
-    active = false;
-    pending = new Set();
-    lifecycle;
-    connection;
-    delivery;
-    owners;
-    constructor(lifecycle, connection, delivery, owners) {
-        this.lifecycle = lifecycle;
-        this.connection = connection;
-        this.delivery = delivery;
-        this.owners = owners;
-    }
-    own(operation) {
-        const task = operation();
-        this.pending.add(task);
-        task
-            .then(() => {
-            this.pending.delete(task);
-        }, (error) => {
-            this.pending.delete(task);
-            console.error("Intercom event bridge failed:", error);
-        })
-            .catch((error) => {
-            console.error("Intercom event bridge cleanup failed:", error);
-        });
-    }
-    stop() {
-        for (const unsubscribe of this.unsubscribes) {
-            try {
-                unsubscribe();
-            }
-            catch {
-                /* Best-effort cleanup during native reload/replacement. */
-            }
-        }
-        this.unsubscribes = [];
-        this.active = false;
-    }
-    async drain() {
-        await Promise.allSettled(this.pending);
-    }
-    acknowledge(requestId, delivered, error) {
-        if (requestId === undefined || requestId === "") {
-            return;
-        }
-        this.owners.pi.events.emit("subagent:result-intercom-delivery", {
-            requestId,
-            delivered,
-            ...(error !== undefined ? { error: errorMessage(error) } : {}),
-        });
-    }
-    isLive(generation) {
-        return (!this.lifecycle.runtimeStarted ||
-            (this.lifecycle.generation === generation && this.lifecycle.live() !== null));
-    }
-    async remote(parsed, options, generation) {
-        if (this.lifecycle.targetMatches(parsed.to)) {
-            return false;
-        }
-        const client = await this.connection.ensure("background");
-        const target = (await resolveConnectedTarget(client, parsed.to)) ?? parsed.to;
-        if (!this.isLive(generation)) {
-            return true;
-        }
-        if (this.lifecycle.targetMatches(parsed.to, target, client.sessionId)) {
-            return false;
-        }
-        const result = await client.send(target, { text: parsed.message });
-        if (!this.isLive(generation)) {
-            return true;
-        }
-        if (!result.accepted) {
-            throw new Error(result.reason ?? "Session may not exist or has disconnected.");
-        }
-        if (options.acknowledge === true) {
-            this.acknowledge(parsed.requestId, true);
-        }
-        return true;
-    }
-    async relay(payload, options) {
-        const parsed = parseRelay(payload);
-        if (!parsed) {
-            return;
-        }
-        const generation = this.lifecycle.generation;
-        try {
-            const restoring = this.delivery.restoring;
-            if (restoring) {
-                await restoring;
-            }
-            if (!this.isLive(generation) || (await this.remote(parsed, options, generation))) {
-                return;
-            }
-            this.local(parsed, options);
-        }
-        catch (error) {
-            if (!this.isLive(generation)) {
-                return;
-            }
-            this.owners.pi.appendEntry(options.errorEntryType, {
-                to: parsed.to,
-                message: parsed.message,
-                error: errorMessage(error),
-                timestamp: Date.now(),
-            });
-            if (options.acknowledge === true) {
-                this.acknowledge(parsed.requestId, false, error);
-            }
-        }
-    }
-    local(parsed, options) {
-        const ownedControl = options.sender === "subagent-control" &&
-            (parsed.source === "foreground" || parsed.source === "async");
-        if (!ownedControl) {
-            this.delivery.local(options.sender, options.status, {
-                text: parsed.message,
-                completion: parsed.completion,
-            });
-        }
-        if (options.acknowledge === true) {
-            this.acknowledge(parsed.requestId, true);
-        }
-    }
-    registerCoordination() {
-        const { pi, journal, open } = this.owners;
-        return [
-            pi.events.on("subagent:supervisor-question-resolved", (payload) => {
-                if (!isRecord(payload) || typeof payload.questionId !== "string") {
-                    return;
-                }
-                journal.retire(payload.questionId, journal.remove(payload.questionId) ? "discarded" : "reply-retired");
-                this.connection.syncStatus();
-            }),
-            pi.events.on("intercom:open", () => {
-                const ctx = this.lifecycle.live();
-                if (ctx?.mode === "tui") {
-                    // Native custom UI owns this user-lived promise; bounded relay shutdown must not join it.
-                    open(ctx, "all").catch((error) => {
-                        console.error("Intercom overlay failed:", error);
-                    });
-                }
-            }),
-            pi.events.on("subagent:intercom-identity-request", (payload) => {
-                const client = this.connection.active;
-                if (isRecord(payload) &&
-                    typeof payload.requestId === "string" &&
-                    client?.isConnected() === true &&
-                    client.sessionId !== null &&
-                    client.sessionId !== "") {
-                    pi.events.emit("subagent:intercom-identity-response", {
-                        requestId: payload.requestId,
-                        sessionId: client.sessionId,
-                    });
-                }
-            }),
-            pi.events.on("subagent:control-intercom", (payload) => {
-                this.own(() => this.relay(payload, {
-                    sender: "subagent-control",
-                    status: "needs_attention",
-                    errorEntryType: "intercom_control_error",
-                }));
-            }),
-            pi.events.on("subagent:result-intercom", (payload) => {
-                this.own(() => this.relay(payload, {
-                    sender: "subagent-result",
-                    status: "result",
-                    errorEntryType: "intercom_result_error",
-                    acknowledge: true,
-                }));
-            }),
-        ];
-    }
-    start() {
-        if (this.active) {
-            return;
-        }
-        this.active = true;
-        this.unsubscribes = [
-            ...registerSubagentLiveEventHandlers({
-                events: this.owners.pi.events,
-                ensureConnected: () => this.connection.ensure("background"),
-                getConnection: () => ({
-                    client: this.connection.active,
-                    connecting: this.connection.isConnecting,
-                    started: this.lifecycle.runtimeStarted,
-                }),
-                resolveSessionTarget: resolveConnectedTarget,
-                currentSessionTargetMatches: (to, resolved, client) => this.lifecycle.targetMatches(to, resolved, client?.sessionId),
-                getLivenessCheck: () => {
-                    const generation = this.lifecycle.generation;
-                    return () => this.isLive(generation);
-                },
-                own: (operation) => {
-                    this.own(operation);
-                },
-            }),
-            ...this.registerCoordination(),
-        ];
-    }
-}

package/dist/pi-intercom/subagent-live-events.js

@@ -1,175 +0,0 @@
-import { formatSessionTarget, resolveSessionTarget } from "./session-targets.js";
-import { isAttachment, isHumanMessageOrigin, } from "./types.js";
-import { errorMessage, isRecord, isUnknownArray } from "./validation.js";
-function emitDelivery(events, requestId, delivered, result = {}) {
-    if (requestId === undefined || requestId === "") {
-        return;
-    }
-    const { reason, receipt } = result;
-    events.emit("subagent:live-intercom-delivery", {
-        requestId,
-        delivered,
-        ...(receipt
-            ? { messageId: receipt.id, accepted: receipt.accepted, queued: receipt.queued }
-            : {}),
-        ...(reason !== undefined && reason !== "" ? { reason } : {}),
-    });
-}
-function parseLivePayload(payload) {
-    if (!isRecord(payload) ||
-        typeof payload.requestId !== "string" ||
-        typeof payload.to !== "string" ||
-        typeof payload.message !== "string") {
-        return;
-    }
-    const attachments = payload.attachments;
-    return {
-        requestId: payload.requestId,
-        to: payload.to,
-        message: payload.message,
-        delivery: payload.delivery === "queue" ? "queue" : "steer",
-        ...(typeof payload.messageId === "string" ? { messageId: payload.messageId } : {}),
-        ...(isHumanMessageOrigin(payload.human) ? { human: payload.human } : {}),
-        ...(isUnknownArray(attachments) && attachments.every(isAttachment) ? { attachments } : {}),
-    };
-}
-async function relayLive(payload, deps) {
-    const parsed = parseLivePayload(payload);
-    if (!parsed) {
-        return;
-    }
-    const live = deps.getLivenessCheck();
-    if (!live()) {
-        return;
-    }
-    try {
-        const client = await deps.ensureConnected();
-        const target = (await deps.resolveSessionTarget(client, parsed.to)) ?? parsed.to;
-        if (!live()) {
-            return;
-        }
-        if (deps.currentSessionTargetMatches(parsed.to, target, client)) {
-            emitDelivery(deps.events, parsed.requestId, false, {
-                reason: "Cannot message the current session",
-            });
-            return;
-        }
-        const result = await client.send(target, {
-            text: parsed.message,
-            delivery: parsed.delivery,
-            messageId: parsed.messageId,
-            human: parsed.human,
-            attachments: parsed.attachments,
-        });
-        if (live()) {
-            emitDelivery(deps.events, parsed.requestId, result.delivered, {
-                reason: result.reason,
-                receipt: result,
-            });
-        }
-    }
-    catch (error) {
-        if (live()) {
-            emitDelivery(deps.events, parsed.requestId, false, { reason: errorMessage(error) });
-        }
-    }
-}
-function parseHealth(payload) {
-    if (!isRecord(payload) ||
-        typeof payload.requestId !== "string" ||
-        !isUnknownArray(payload.targets)) {
-        return;
-    }
-    return {
-        requestId: payload.requestId,
-        targets: payload.targets.filter((target) => typeof target === "string" && target.trim().length > 0),
-    };
-}
-function connectionSnapshot(deps) {
-    const { client, connecting, started } = deps.getConnection();
-    let status = "unknown";
-    if (started) {
-        if (connecting) {
-            status = "connecting";
-        }
-        else if (client?.isConnected() !== true) {
-            status = "disconnected";
-        }
-    }
-    const id = client?.sessionId;
-    return { status, ...(id !== undefined && id !== null && id !== "" ? { sessionId: id } : {}) };
-}
-function sessionNames(session) {
-    return {
-        ...(session.name !== undefined && session.name !== "" ? { sessionName: session.name } : {}),
-        ...(session.status !== undefined && session.status !== ""
-            ? { sessionStatus: session.status }
-            : {}),
-    };
-}
-async function answerHealth(payload, deps) {
-    const parsed = parseHealth(payload);
-    if (!parsed) {
-        return;
-    }
-    const live = deps.getLivenessCheck();
-    const respond = (health, connection) => {
-        if (live()) {
-            deps.events.emit("subagent:intercom-health-response", {
-                requestId: parsed.requestId,
-                health,
-                connection,
-            });
-        }
-    };
-    if (!live()) {
-        return;
-    }
-    try {
-        // Empty targets observe the bridge without reconnecting.
-        const client = parsed.targets.length > 0 ? await deps.ensureConnected() : deps.getConnection().client;
-        if (client?.isConnected() !== true) {
-            respond([], connectionSnapshot(deps));
-            return;
-        }
-        const sessions = await client.listSessions();
-        const health = parsed.targets.map((target) => {
-            const resolution = resolveSessionTarget(sessions, target);
-            const session = resolution.target;
-            if (resolution.status !== "found" || !session) {
-                return { target, status: resolution.status };
-            }
-            return {
-                target,
-                status: "registered",
-                resolvedTarget: formatSessionTarget(session, sessions),
-                sessionId: session.id,
-                ...sessionNames(session),
-                ...(session.acceptsAsks !== undefined ? { acceptsAsks: session.acceptsAsks } : {}),
-                ...(session.pendingAsks !== undefined ? { pendingAsks: session.pendingAsks } : {}),
-                ...(session.lastSeen !== undefined ? { lastSeen: session.lastSeen } : {}),
-                ...(session.lastIntercomActivity !== undefined
-                    ? { lastIntercomActivity: session.lastIntercomActivity }
-                    : {}),
-            };
-        });
-        const id = client.sessionId;
-        const registered = client.isConnected() && sessions.some((session) => session.id === id);
-        respond(health, registered && id !== null
-            ? { status: "connected", sessionId: id }
-            : { ...connectionSnapshot(deps), reason: "Current broker registration was not confirmed." });
-    }
-    catch (error) {
-        respond(parsed.targets.map((target) => ({ target, status: "missing" })), { ...connectionSnapshot(deps), reason: errorMessage(error) });
-    }
-}
-export function registerSubagentLiveEventHandlers(deps) {
-    return [
-        deps.events.on("subagent:live-intercom", (payload) => {
-            deps.own(() => relayLive(payload, deps));
-        }),
-        deps.events.on("subagent:intercom-health-request", (payload) => {
-            deps.own(() => answerHealth(payload, deps));
-        }),
-    ];
-}

package/dist/pi-intercom/supervisor.js

@@ -1,282 +0,0 @@
-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,
-        });
-    }
-}