@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/intercom/intercom-bridge.js

@@ -1,140 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { fileURLToPath } from "node:url";
-import { isRecord } from "../shared/unknown.js";
-import { SUBAGENT_INTERCOM_IDENTITY_REQUEST_EVENT, SUBAGENT_INTERCOM_IDENTITY_RESPONSE_EVENT, } from "../shared/types.js";
-const DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat";
-// Resolve the bundled intercom extension next to this module in both layouts:
-// TypeScript sources (tests, jiti) and compiled dist output.
-const BUNDLED_INTERCOM_EXTENSION_PATH = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "../pi-intercom/index.ts" : "../pi-intercom/index.js", import.meta.url));
-export const INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:";
-const DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the supervisor in normal assistant text.
-
-Use contact_supervisor first. It resolves the supervisor session "{orchestratorTarget}" and run metadata automatically.
-- If you cannot safely continue without one decision, approval, or product/API/scope clarification: contact_supervisor({ reason: "need_decision", message: "<question>" }). It steers the supervisor and keeps this ephemeral child alive for the reply.
-- If you cannot safely continue until the supervisor provides multiple structured answers: contact_supervisor({ reason: "interview_request", message: "<context>", interview: { questions: [{ id: "<id>", type: "text", question: "<question>" }] } }). It also steers and keeps this child alive.
-- After blocking contact_supervisor decisions or interviews, continue only after the reply arrives. Do not finish your final response with a choose-one question.
-- Do not ask for clarification when the only conflict is review-only/no-edit versus progress-writing or artifact-writing instructions. Review-only/no-edit wins; leave files unchanged and mention the conflict in your final result only if it matters.
-- A discovery or change the supervisor needs while working: contact_supervisor({ reason: "progress_update", message: "UPDATE: <finding and consequence>" }). This steers at the next tool boundary without waiting for a reply. Skip starts, redundant status, and routine completion; retain material findings in your final result.
-- Generic intercom is lower-level fallback only; call load_intercom({}) first if intercom is inactive. Use blocking intercom({ action: "ask", to: "{orchestratorTarget}", delivery: "steer", message: "<question>" }) only when this child must remain alive for the answer.
-- Treat a supervisor nudge as supplemental coordination within the active task: incorporate relevant context and continue. Replace the task only when the nudge explicitly says so. If it requests an answer, respond with intercom({ action: "send", to: "{orchestratorTarget}", delivery: "steer", message: "<answer>" }).
-
-Messages explicitly marked “Direct user message to this agent” come from the human through the owning parent's Agents view. Treat them as user direction, not peer advice, and answer in your own conversation; the human sees it without a parent relay. Regular peer messages retain their existing authority boundaries.
-
-Do not use contact_supervisor or intercom for routine completion handoffs. If no coordination is needed, return a focused task result.`;
-export function resolveIntercomSessionTarget(sessionName, sessionId) {
-    const trimmedName = sessionName?.trim();
-    if (trimmedName !== undefined && trimmedName.length > 0) {
-        return trimmedName;
-    }
-    const normalizedSessionId = sessionId.startsWith("session-")
-        ? sessionId.slice("session-".length)
-        : sessionId;
-    return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
-}
-export function resolveOrchestratorIntercomTarget(events, fallback) {
-    if (typeof events.on !== "function" || typeof events.emit !== "function") {
-        return fallback;
-    }
-    const requestId = randomUUID();
-    let exactTarget;
-    let unsubscribe;
-    let failed = false;
-    try {
-        unsubscribe = events.on(SUBAGENT_INTERCOM_IDENTITY_RESPONSE_EVENT, (payload) => {
-            if (!isRecord(payload)) {
-                return;
-            }
-            const response = payload;
-            if (response.requestId === requestId &&
-                typeof response.sessionId === "string" &&
-                response.sessionId.trim().length > 0) {
-                exactTarget = response.sessionId;
-            }
-        });
-        events.emit(SUBAGENT_INTERCOM_IDENTITY_REQUEST_EVENT, { requestId });
-    }
-    catch {
-        failed = true;
-    }
-    finally {
-        try {
-            unsubscribe?.();
-        }
-        catch {
-            failed = true;
-        }
-    }
-    return failed ? fallback : (exactTarget ?? fallback);
-}
-function sanitizeIntercomTargetPart(value) {
-    const normalized = value
-        .trim()
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-    return normalized.length > 0 ? normalized : "agent";
-}
-export function resolveSubagentIntercomTarget(runId, agent, index) {
-    const stepSuffix = index !== undefined ? `-${index + 1}` : "";
-    return `subagent-${sanitizeIntercomTargetPart(agent)}-${sanitizeIntercomTargetPart(runId)}${stepSuffix}`;
-}
-function isIntercomExtensionEntry(entry) {
-    return entry.trim().replaceAll("\\", "/").toLowerCase().split("/").includes("pi-intercom");
-}
-function extensionSandboxAllowsIntercom(extensions) {
-    return extensions === undefined || extensions.some(isIntercomExtensionEntry);
-}
-function resolveBundledIntercomExtensions(extensions) {
-    if (extensions === undefined) {
-        return undefined;
-    }
-    const resolved = [
-        ...new Set(extensions.map((entry) => isIntercomExtensionEntry(entry) ? BUNDLED_INTERCOM_EXTENSION_PATH : entry)),
-    ];
-    return resolved.length === extensions.length &&
-        resolved.every((entry, index) => entry === extensions[index])
-        ? extensions
-        : resolved;
-}
-function buildIntercomBridgeInstruction(orchestratorTarget) {
-    return `${INTERCOM_BRIDGE_MARKER}
-${DEFAULT_INTERCOM_BRIDGE_TEMPLATE.replaceAll("{orchestratorTarget}", orchestratorTarget).trim()}`;
-}
-export function resolveIntercomBridge(orchestratorTarget) {
-    const target = orchestratorTarget.trim();
-    return {
-        orchestratorTarget: target,
-        instruction: buildIntercomBridgeInstruction(target),
-    };
-}
-function appendBridgeInstruction(prompt, instruction) {
-    const trimmed = prompt.trim();
-    if (trimmed.includes(INTERCOM_BRIDGE_MARKER)) {
-        return trimmed;
-    }
-    return trimmed.length > 0 ? `${trimmed}\n\n${instruction}` : instruction;
-}
-export function applyIntercomBridgeToAgent(agent, bridge) {
-    if (!extensionSandboxAllowsIntercom(agent.extensions)) {
-        return agent;
-    }
-    const bridgeTools = ["intercom", "contact_supervisor"];
-    const missingTools = agent.tools
-        ? bridgeTools.filter((tool) => agent.tools?.includes(tool) !== true)
-        : [];
-    const tools = agent.tools && missingTools.length > 0 ? [...agent.tools, ...missingTools] : agent.tools;
-    const extensions = resolveBundledIntercomExtensions(agent.extensions);
-    const instruction = bridge.instruction;
-    const systemPrompt = appendBridgeInstruction(agent.systemPrompt, instruction);
-    if (tools === agent.tools &&
-        systemPrompt === agent.systemPrompt &&
-        extensions === agent.extensions) {
-        return agent;
-    }
-    return {
-        ...agent,
-        tools,
-        systemPrompt,
-        extensions,
-    };
-}

package/dist/intercom/live-intercom.js

@@ -1,151 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { errorMessage, isRecord } from "../shared/unknown.js";
-import { SUBAGENT_INTERCOM_HEALTH_REQUEST_EVENT, SUBAGENT_INTERCOM_HEALTH_RESPONSE_EVENT, SUBAGENT_LIVE_INTERCOM_DELIVERY_EVENT, SUBAGENT_LIVE_INTERCOM_EVENT, } from "../shared/types.js";
-export async function sendLiveSubagentMessage(events, input) {
-    if (typeof events.on !== "function" || typeof events.emit !== "function") {
-        return { delivered: false, reason: "pi-intercom bridge unavailable" };
-    }
-    const requestId = randomUUID();
-    return new Promise((resolve) => {
-        let settled = false;
-        const finish = (result) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            clearTimeout(timer);
-            input.signal?.removeEventListener("abort", abort);
-            unsubscribe();
-            resolve(result);
-        };
-        const abort = () => finish({ delivered: false, reason: "Message view/session closed; delivery not confirmed." });
-        const unsubscribe = events.on(SUBAGENT_LIVE_INTERCOM_DELIVERY_EVENT, (data) => {
-            if (!isRecord(data)) {
-                return;
-            }
-            const payload = data;
-            if (payload.requestId !== requestId) {
-                return;
-            }
-            finish({
-                delivered: payload.delivered === true,
-                ...(typeof payload.accepted === "boolean" ? { accepted: payload.accepted } : {}),
-                ...(typeof payload.queued === "boolean" ? { queued: payload.queued } : {}),
-                ...(typeof payload.messageId === "string" ? { messageId: payload.messageId } : {}),
-                ...(typeof payload.reason === "string" ? { reason: payload.reason } : {}),
-            });
-        });
-        const timer = setTimeout(() => finish({ delivered: false, reason: "pi-intercom bridge unavailable" }), input.timeoutMs ?? 500);
-        if (input.signal?.aborted === true) {
-            abort();
-            return;
-        }
-        input.signal?.addEventListener("abort", abort, { once: true });
-        try {
-            events.emit(SUBAGENT_LIVE_INTERCOM_EVENT, {
-                ...input.extra,
-                requestId,
-                to: input.to,
-                message: input.message,
-                delivery: input.delivery ?? "steer",
-            });
-        }
-        catch (error) {
-            finish({ delivered: false, reason: errorMessage(error) });
-        }
-    });
-}
-function parseConnection(value) {
-    if (!isRecord(value)) {
-        return undefined;
-    }
-    const { status } = value;
-    if (status !== "connected" &&
-        status !== "disconnected" &&
-        status !== "connecting" &&
-        status !== "unknown") {
-        return undefined;
-    }
-    return {
-        status,
-        ...(typeof value.sessionId === "string" ? { sessionId: value.sessionId } : {}),
-        ...(typeof value.reason === "string" ? { reason: value.reason } : {}),
-    };
-}
-function healthMetadata(value) {
-    return {
-        ...(typeof value.sessionId === "string" ? { sessionId: value.sessionId } : {}),
-        ...(typeof value.sessionName === "string" ? { sessionName: value.sessionName } : {}),
-        ...(typeof value.sessionStatus === "string" ? { sessionStatus: value.sessionStatus } : {}),
-        ...(typeof value.acceptsAsks === "boolean" ? { acceptsAsks: value.acceptsAsks } : {}),
-        ...(typeof value.pendingAsks === "number" ? { pendingAsks: value.pendingAsks } : {}),
-    };
-}
-function parseHealth(value) {
-    if (!isRecord(value) || typeof value.target !== "string") {
-        return undefined;
-    }
-    const { status } = value;
-    if (status !== "registered" &&
-        status !== "none" &&
-        status !== "missing" &&
-        status !== "ambiguous" &&
-        status !== "prefix_too_short") {
-        return undefined;
-    }
-    return {
-        target: value.target,
-        status,
-        ...healthMetadata(value),
-    };
-}
-export async function queryLiveIntercomHealth(events, targets, timeoutMs = 300) {
-    if (!targets.some((target) => target.trim().length > 0)) {
-        return new Map();
-    }
-    return (await queryLiveIntercomStatus(events, targets, timeoutMs)).health;
-}
-export async function queryLiveIntercomStatus(events, targets = [], timeoutMs = 300) {
-    const uniqueTargets = [...new Set(targets.map((target) => target.trim()).filter(Boolean))];
-    if (typeof events.on !== "function" || typeof events.emit !== "function") {
-        return { health: new Map() };
-    }
-    const requestId = randomUUID();
-    return new Promise((resolve) => {
-        let settled = false;
-        let unsubscribe;
-        let timer;
-        const finish = (items = [], connection) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            if (timer) {
-                clearTimeout(timer);
-            }
-            unsubscribe?.();
-            resolve({ health: new Map(items.map((item) => [item.target, item])), connection });
-        };
-        try {
-            unsubscribe = events.on(SUBAGENT_INTERCOM_HEALTH_RESPONSE_EVENT, (data) => {
-                if (!isRecord(data)) {
-                    return;
-                }
-                const payload = data;
-                if (payload.requestId !== requestId || !Array.isArray(payload.health)) {
-                    return;
-                }
-                const connection = parseConnection(payload.connection);
-                finish(payload.health.flatMap((item) => {
-                    const health = parseHealth(item);
-                    return health ? [health] : [];
-                }), connection);
-            });
-            timer = setTimeout(() => finish(), timeoutMs);
-            events.emit(SUBAGENT_INTERCOM_HEALTH_REQUEST_EVENT, { requestId, targets: uniqueTargets });
-        }
-        catch {
-            finish();
-        }
-    });
-}

package/dist/intercom/nested-result-tree.js

@@ -1,163 +0,0 @@
-// Project only public metadata, not private tasks, outputs, or native messages.
-function runMetadata(run) {
-    const metadata = {};
-    for (const key of [
-        "parentAgent",
-        "asyncDir",
-        "sessionId",
-        "sessionFile",
-        "intercomTarget",
-        "ownerIntercomTarget",
-        "leafIntercomTarget",
-        "ownerState",
-        "mode",
-        "agent",
-        "activityState",
-        "currentTool",
-        "currentPath",
-        "error",
-    ]) {
-        const value = run[key];
-        if (value !== undefined && value.length > 0) {
-            metadata[key] = value;
-        }
-    }
-    for (const key of [
-        "parentStepIndex",
-        "currentStep",
-        "chainStepCount",
-        "lastActivityAt",
-        "currentToolStartedAt",
-        "turnCount",
-        "toolCount",
-        "startedAt",
-        "endedAt",
-        "lastUpdate",
-    ]) {
-        const value = run[key];
-        if (value !== undefined) {
-            metadata[key] = value;
-        }
-    }
-    return metadata;
-}
-function stepMetadata(step) {
-    const metadata = {};
-    for (const key of [
-        "sessionFile",
-        "activityState",
-        "currentTool",
-        "currentPath",
-        "error",
-    ]) {
-        const value = step[key];
-        if (value !== undefined && value.length > 0) {
-            metadata[key] = value;
-        }
-    }
-    for (const key of [
-        "lastActivityAt",
-        "currentToolStartedAt",
-        "turnCount",
-        "toolCount",
-        "startedAt",
-        "endedAt",
-    ]) {
-        const value = step[key];
-        if (value !== undefined) {
-            metadata[key] = value;
-        }
-    }
-    return metadata;
-}
-function compactStep(step, depth) {
-    const children = depth < 2 ? compactChildren(step.children, 8, depth + 1) : undefined;
-    return {
-        agent: step.agent,
-        status: step.status,
-        ...stepMetadata(step),
-        ...(children ? { children } : {}),
-    };
-}
-function hasItems(values) {
-    return values !== undefined && values.length > 0;
-}
-function compactRunLists(run, depth) {
-    return {
-        ...(hasItems(run.agents) ? { agents: run.agents?.slice(0, 12) } : {}),
-        ...(hasItems(run.parallelGroups) ? { parallelGroups: run.parallelGroups?.slice(0, 8) } : {}),
-        ...(hasItems(run.steps)
-            ? { steps: run.steps?.slice(0, 12).map((step) => compactStep(step, depth)) }
-            : {}),
-    };
-}
-function compactNestedRun(run, depth) {
-    const children = depth < 2 ? compactChildren(run.children, 8, depth + 1) : undefined;
-    return {
-        id: run.id,
-        parentRunId: run.parentRunId,
-        depth: run.depth,
-        state: run.state,
-        path: run.path
-            .slice(0, 4)
-            .map((part) => Object.assign({ runId: part.runId }, part.stepIndex !== undefined ? { stepIndex: part.stepIndex } : {}, part.agent !== undefined && part.agent.length > 0 ? { agent: part.agent } : {})),
-        ...runMetadata(run),
-        ...(run.totalTokens ? { totalTokens: run.totalTokens } : {}),
-        ...compactRunLists(run, depth),
-        ...(children ? { children } : {}),
-    };
-}
-function compactChildren(children, limit, depth) {
-    if (children === undefined || children.length === 0) {
-        return undefined;
-    }
-    return children.slice(0, limit).map((child) => compactNestedRun(child, depth));
-}
-export function compactNestedResultChildren(children) {
-    return compactChildren(children, 16, 0);
-}
-export function attachNestedChildrenToResultChildren(runId, children, nestedChildren) {
-    const compact = compactNestedResultChildren(nestedChildren);
-    return children.map((child, index) => {
-        const alreadyAttached = new Set(child.children?.map((nested) => nested.id) ?? []);
-        const attached = compact?.filter((nested) => {
-            if (nested.parentRunId !== runId || alreadyAttached.has(nested.id)) {
-                return false;
-            }
-            return (nested.parentStepIndex === (child.index ?? index) ||
-                (children.length === 1 && nested.parentStepIndex === undefined));
-        }) ?? [];
-        const merged = compactNestedResultChildren([...(child.children ?? []), ...attached]);
-        return Object.assign({}, child, { children: merged });
-    });
-}
-function hasSessionFile(value) {
-    return value !== undefined && value.length > 0;
-}
-export function formatNestedResultLines(children) {
-    if (children === undefined || children.length === 0) {
-        return [];
-    }
-    const lines = ["Nested subagents:"];
-    let remaining = 10;
-    const append = (runs, indent) => {
-        for (const run of runs ?? []) {
-            if (remaining <= 0) {
-                lines.push(`${indent}↳ +more nested runs; inspect status for full tree`);
-                return;
-            }
-            remaining--;
-            const label = run.agent ?? run.agents?.join("+") ?? run.id;
-            lines.push(`${indent}↳ ${label} — ${run.state} [${run.id}]`);
-            if (hasSessionFile(run.sessionFile)) {
-                lines.push(`${indent}  Session: ${run.sessionFile}`);
-            }
-            append(run.children, `${indent}  `);
-            for (const step of run.steps ?? []) {
-                append(step.children, `${indent}    `);
-            }
-        }
-    };
-    append(children, "");
-    return lines;
-}

package/dist/intercom/result-delivery.js

@@ -1,40 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { isRecord } from "../shared/unknown.js";
-import { SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, SUBAGENT_RESULT_INTERCOM_EVENT, } from "../shared/types.js";
-export async function deliverSubagentResultIntercomEvent(events, payload, timeoutMs = 500) {
-    return deliverSubagentIntercomMessageEvent(events, payload.to, payload.message, timeoutMs, {
-        ...payload,
-    });
-}
-/** Retained positional RPC adapter: correlation is installed before synchronous publication. */
-export async function deliverSubagentIntercomMessageEvent(events, to, message, timeoutMs = 500, extra = {}) {
-    if (typeof events.on !== "function" || typeof events.emit !== "function") {
-        return false;
-    }
-    const requestId = typeof extra.requestId === "string" ? extra.requestId : randomUUID();
-    return new Promise((resolve) => {
-        let settled = false;
-        const finish = (delivered) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            clearTimeout(timer);
-            unsubscribe();
-            resolve(delivered);
-        };
-        const unsubscribe = events.on(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, (data) => {
-            if (!isRecord(data) || data.requestId !== requestId) {
-                return;
-            }
-            finish(data.delivered === true);
-        });
-        const timer = setTimeout(() => finish(false), timeoutMs);
-        try {
-            events.emit(SUBAGENT_RESULT_INTERCOM_EVENT, { ...extra, to, message, requestId });
-        }
-        catch {
-            finish(false);
-        }
-    });
-}