@fitchmultz/pi-subagents 0.44.7 → 0.45.0

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

@@ -0,0 +1,238 @@
+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,132 +1,175 @@
-import { formatSessionTarget, resolveSessionTarget as resolveSessionTargetValue } from "./session-targets.js";
-import { isAttachment, isHumanMessageOrigin } from "./types.js";
-const SUBAGENT_LIVE_INTERCOM_EVENT = "subagent:live-intercom";
-const SUBAGENT_LIVE_INTERCOM_DELIVERY_EVENT = "subagent:live-intercom-delivery";
-const SUBAGENT_INTERCOM_HEALTH_REQUEST_EVENT = "subagent:intercom-health-request";
-const SUBAGENT_INTERCOM_HEALTH_RESPONSE_EVENT = "subagent:intercom-health-response";
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function emitLiveDelivery(events, requestId, delivered, reason, receipt) {
-    if (!requestId)
+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;
-    events.emit(SUBAGENT_LIVE_INTERCOM_DELIVERY_EVENT, {
+    }
+    const { reason, receipt } = result;
+    events.emit("subagent:live-intercom-delivery", {
         requestId,
         delivered,
-        ...(receipt ? { messageId: receipt.id, accepted: receipt.accepted, queued: receipt.queued } : {}),
-        ...(reason ? { reason } : {}),
+        ...(receipt
+            ? { messageId: receipt.id, accepted: receipt.accepted, queued: receipt.queued }
+            : {}),
+        ...(reason !== undefined && reason !== "" ? { reason } : {}),
     });
 }
-function parseLiveMessagePayload(payload) {
-    if (!payload || typeof payload !== "object")
-        return undefined;
-    const parsed = payload;
-    if (typeof parsed.requestId !== "string" || typeof parsed.to !== "string" || typeof parsed.message !== "string")
-        return undefined;
+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: parsed.requestId,
-        to: parsed.to,
-        message: parsed.message,
-        delivery: parsed.delivery === "queue" ? "queue" : "steer",
-        ...(typeof parsed.messageId === "string" ? { messageId: parsed.messageId } : {}),
-        ...(isHumanMessageOrigin(parsed.human) ? { human: parsed.human } : {}),
-        ...(Array.isArray(parsed.attachments) && parsed.attachments.every(isAttachment) ? { attachments: parsed.attachments } : {}),
+        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 relayLiveSubagentMessage(payload, deps) {
-    const parsed = parseLiveMessagePayload(payload);
-    if (!parsed)
+async function relayLive(payload, deps) {
+    const parsed = parseLivePayload(payload);
+    if (!parsed) {
         return;
-    const isLive = deps.getLivenessCheck();
-    if (!isLive())
+    }
+    const live = deps.getLivenessCheck();
+    if (!live()) {
         return;
-    let activeClient;
-    let target;
+    }
     try {
-        activeClient = await deps.ensureConnected();
-        target = await deps.resolveSessionTarget(activeClient, parsed.to) ?? parsed.to;
+        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 (isLive())
-            emitLiveDelivery(deps.events, parsed.requestId, false, getErrorMessage(error));
-        return;
+        if (live()) {
+            emitDelivery(deps.events, parsed.requestId, false, { reason: errorMessage(error) });
+        }
     }
-    if (!isLive())
-        return;
-    if (deps.currentSessionTargetMatches(parsed.to, target, activeClient)) {
-        emitLiveDelivery(deps.events, parsed.requestId, false, "Cannot message the current session");
+}
+function parseHealth(payload) {
+    if (!isRecord(payload) ||
+        typeof payload.requestId !== "string" ||
+        !isUnknownArray(payload.targets)) {
         return;
     }
-    try {
-        const result = await activeClient.send(target, { text: parsed.message, delivery: parsed.delivery, messageId: parsed.messageId, human: parsed.human, attachments: parsed.attachments });
-        if (isLive())
-            emitLiveDelivery(deps.events, parsed.requestId, result.delivered, result.reason, result);
-    }
-    catch (error) {
-        if (isLive())
-            emitLiveDelivery(deps.events, parsed.requestId, false, getErrorMessage(error));
+    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 parseHealthPayload(payload) {
-    if (!payload || typeof payload !== "object")
-        return undefined;
-    const parsed = payload;
-    if (typeof parsed.requestId !== "string" || !Array.isArray(parsed.targets))
-        return undefined;
-    const targets = parsed.targets.filter((target) => typeof target === "string" && target.trim().length > 0);
-    return { requestId: parsed.requestId, targets };
+function sessionNames(session) {
+    return {
+        ...(session.name !== undefined && session.name !== "" ? { sessionName: session.name } : {}),
+        ...(session.status !== undefined && session.status !== ""
+            ? { sessionStatus: session.status }
+            : {}),
+    };
 }
-async function answerLiveIntercomHealth(payload, deps) {
-    const parsed = parseHealthPayload(payload);
-    if (!parsed)
+async function answerHealth(payload, deps) {
+    const parsed = parseHealth(payload);
+    if (!parsed) {
         return;
-    const isLive = deps.getLivenessCheck();
-    const connectionSnapshot = () => {
-        const { client, connecting, started } = deps.getConnection();
-        return { status: !started ? "unknown" : connecting ? "connecting" : client?.isConnected() ? "unknown" : "disconnected", ...(client?.sessionId ? { sessionId: client.sessionId } : {}) };
-    };
+    }
+    const live = deps.getLivenessCheck();
     const respond = (health, connection) => {
-        if (isLive())
-            deps.events.emit(SUBAGENT_INTERCOM_HEALTH_RESPONSE_EVENT, { requestId: parsed.requestId, health, connection });
+        if (live()) {
+            deps.events.emit("subagent:intercom-health-response", {
+                requestId: parsed.requestId,
+                health,
+                connection,
+            });
+        }
     };
-    if (!isLive())
+    if (!live()) {
         return;
+    }
     try {
-        // An empty target list is a read-only check of this bridge, not a reconnect request.
-        const activeClient = parsed.targets.length ? await deps.ensureConnected() : deps.getConnection().client;
-        if (!activeClient?.isConnected()) {
-            respond([], connectionSnapshot());
+        // 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 activeClient.listSessions();
+        const sessions = await client.listSessions();
         const health = parsed.targets.map((target) => {
-            const resolution = resolveSessionTargetValue(sessions, target);
-            if (resolution.status !== "found")
-                return { target, status: resolution.status };
+            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,
-                ...(session.name ? { sessionName: session.name } : {}),
-                ...(session.status ? { sessionStatus: session.status } : {}),
+                ...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 } : {}),
+                ...(session.lastIntercomActivity !== undefined
+                    ? { lastIntercomActivity: session.lastIntercomActivity }
+                    : {}),
             };
         });
-        const registered = activeClient.isConnected() && sessions.some((session) => session.id === activeClient.sessionId);
-        respond(health, registered ? { status: "connected", sessionId: activeClient.sessionId } : { ...connectionSnapshot(), reason: "Current broker registration was not confirmed." });
+        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(), reason: getErrorMessage(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_EVENT, (payload) => relayLiveSubagentMessage(payload, deps)),
-        deps.events.on(SUBAGENT_INTERCOM_HEALTH_REQUEST_EVENT, (payload) => answerLiveIntercomHealth(payload, deps)),
+        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));
+        }),
     ];
 }