@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

package/dist/harness/internal/createRun/orchestration/internalPhase.js

@@ -0,0 +1,464 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInternalOrchestrationPhase = runInternalOrchestrationPhase;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const utils_1 = require("../utils");
+const prompts_1 = require("../prompts");
+const constants_1 = require("./constants");
+const effects_1 = require("./effects");
+const internalTools_1 = require("./internalTools");
+const runState_1 = require("../planProcess/runState");
+const resumeState_1 = require("../resumeState");
+const verbose_1 = require("./verbose");
+const tasks_1 = require("../../../../tasks");
+async function runInternalOrchestrationPhase(args) {
+    const state = {
+        runId: args.existingRunId,
+        runDir: args.existingRunDir,
+        sessionBound: args.existingSessionBound,
+        iteration: 0,
+        pendingActions: new Map(),
+        pendingEffectResults: new Map(),
+    };
+    let orchestrationSession = null;
+    const activePiSessions = new Set();
+    const writeVerbose = (message) => {
+        (0, utils_1.writeVerboseLine)(args.verbose, args.json, message, args.outputMode);
+    };
+    const writeVerboseData = (label, value, maxChars) => {
+        (0, utils_1.writeVerboseBlock)(args.verbose, args.json, label, value, maxChars, args.outputMode);
+    };
+    const registerPiSession = (session) => {
+        activePiSessions.add(session);
+        return session;
+    };
+    const shutdownPiSession = async (session) => {
+        if (!session) {
+            return;
+        }
+        activePiSessions.delete(session);
+        const maybeAbort = session;
+        if (typeof maybeAbort.abort === "function") {
+            await maybeAbort.abort().catch(() => undefined);
+        }
+        session.dispose();
+    };
+    const describePendingActions = () => Array.from(state.pendingActions.values()).map((action) => ({
+        effectId: action.effectId,
+        kind: action.kind,
+        title: action.taskDef?.title,
+        harness: (0, utils_1.resolveTaskHarness)(action, args.selectedHarnessName, args.discovered),
+    }));
+    const ensureTerminalResult = () => {
+        if (state.lastIterationResult?.status === "completed")
+            return 0;
+        if (state.lastIterationResult?.status === "failed")
+            return 1;
+        return null;
+    };
+    const captureProgressSnapshot = () => ({
+        runId: state.runId,
+        runDir: state.runDir,
+        sessionBound: Boolean(state.sessionBound),
+        iteration: state.iteration,
+        pendingActionIds: Array.from(state.pendingActions.keys()).sort().join(","),
+        pendingResultIds: Array.from(state.pendingEffectResults.keys()).sort().join(","),
+        lastStatus: state.lastIterationResult?.status,
+        hasAskUserQuestionResponse: Boolean(state.lastAskUserQuestionResponse),
+        finished: Boolean(state.finished),
+        processFileFingerprint: (0, effects_1.readProcessFileFingerprint)(args.processPath),
+    });
+    const orchestrationStateAdvanced = (before) => {
+        const after = captureProgressSnapshot();
+        return Object.keys(after).some((key) => after[key]
+            !== before[key]);
+    };
+    const protectedRunEntries = new Set();
+    const snapshotProtectedRunEntries = async () => {
+        if (!args.runsDir) {
+            return;
+        }
+        let entries = [];
+        try {
+            entries = await node_fs_1.promises.readdir(args.runsDir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            protectedRunEntries.add(entry);
+        }
+    };
+    const cleanupUnexpectedRunSiblings = async () => {
+        if (!args.runsDir || !state.runId) {
+            return;
+        }
+        let entries = [];
+        try {
+            entries = await node_fs_1.promises.readdir(args.runsDir);
+        }
+        catch {
+            return;
+        }
+        const removed = [];
+        for (const entry of entries) {
+            if (entry === state.runId || protectedRunEntries.has(entry)) {
+                continue;
+            }
+            try {
+                const target = path.join(args.runsDir, entry);
+                const stat = await node_fs_1.promises.stat(target);
+                if (!stat.isDirectory()) {
+                    continue;
+                }
+                await node_fs_1.promises.rm(target, { recursive: true, force: true });
+                removed.push(entry);
+            }
+            catch {
+                // Best-effort cleanup only; don't derail the orchestration loop.
+            }
+        }
+        if (removed.length > 0) {
+            writeVerboseData("phaseOrchestration host cleaned stray run dirs", {
+                runId: state.runId,
+                removed,
+            });
+        }
+    };
+    const syncStateFromRunArtifacts = async () => {
+        if (!state.runDir) {
+            return { runStatus: null, synchronized: false };
+        }
+        const before = captureProgressSnapshot();
+        const assessed = await (0, resumeState_1.assessRun)(state.runDir).catch(() => null);
+        if (!assessed) {
+            return { runStatus: null, synchronized: false };
+        }
+        const pendingTasks = await (0, tasks_1.listTasks)(state.runDir, { status: "requested" }).catch(() => []);
+        state.runId = assessed.run.runId;
+        state.pendingActions.clear();
+        for (const task of pendingTasks) {
+            const detail = await (0, tasks_1.readTask)(state.runDir, task.effectId).catch(() => null);
+            if (!detail) {
+                continue;
+            }
+            const definition = detail.definition;
+            const io = typeof definition.io === "object" && definition.io !== null
+                ? definition.io
+                : undefined;
+            const action = {
+                effectId: task.effectId,
+                invocationKey: String(definition.invocationKey ?? task.effectId),
+                kind: task.kind,
+                label: task.title,
+                labels: task.labels,
+                taskDef: detail.definition,
+                taskId: task.taskId,
+                stepId: typeof definition.stepId === "string" ? definition.stepId : undefined,
+                taskDefRef: `tasks/${task.effectId}/task.json`,
+                inputsRef: typeof io?.inputJsonPath === "string" ? String(io.inputJsonPath) : undefined,
+                requestedAt: task.requestedAt,
+            };
+            state.pendingActions.set(task.effectId, action);
+        }
+        if (assessed.run.status === "completed") {
+            state.lastIterationResult = { status: "completed", output: undefined };
+        }
+        else if (assessed.run.status === "failed") {
+            state.lastIterationResult = {
+                status: "failed",
+                error: { message: "Run failed" },
+            };
+        }
+        else if (state.pendingActions.size > 0) {
+            state.lastIterationResult = {
+                status: "waiting",
+                nextActions: Array.from(state.pendingActions.values()),
+            };
+        }
+        const synchronized = orchestrationStateAdvanced(before);
+        if (synchronized) {
+            writeVerboseData("phaseOrchestration synced run state", {
+                runStatus: assessed.run.status,
+                pendingEffects: Array.from(state.pendingActions.keys()),
+                journalLength: assessed.journalLength,
+                lastEvent: assessed.lastEvent,
+            });
+        }
+        return { runStatus: assessed.run.status, synchronized };
+    };
+    const { mergedTools, iterateTool, finishTool, invokeTool } = (0, internalTools_1.createOrchestrationTools)({
+        phaseArgs: args,
+        state,
+        describePendingActions,
+        writeVerbose,
+        writeVerboseData,
+    });
+    const ensureBoundRunContext = async () => {
+        const runState = await (0, runState_1.ensureRunAndMaybeBindFromProcessDefinition)({
+            processPath: args.processPath,
+            prompt: args.prompt ?? "",
+            workspace: args.workspace,
+            runsDir: args.runsDir,
+            selectedHarnessName: args.selectedHarnessName,
+            maxIterations: args.maxIterations,
+            interactive: args.interactive,
+            verbose: args.verbose,
+            json: args.json,
+            phaseSession: orchestrationSession,
+            state,
+        });
+        if (runState.createdRun) {
+            (0, utils_1.emitProgress)({ phase: "2", status: "run-created", runId: runState.runId, runDir: runState.runDir }, args.json, args.verbose, args.outputMode);
+            writeVerboseData("phaseOrchestration host run state", runState);
+        }
+        if (runState.boundSession && runState.sessionBound) {
+            (0, utils_1.emitProgress)({
+                phase: "2",
+                status: "bound",
+                runId: runState.runId,
+                runDir: runState.runDir,
+                harness: runState.sessionBound.harness,
+                sessionId: runState.sessionBound.sessionId,
+                error: runState.sessionBound.error,
+            }, args.json, args.verbose, args.outputMode);
+        }
+    };
+    const promptOrchestrationAgent = async (message, label = "phaseOrchestration") => {
+        if (!orchestrationSession) {
+            throw new utils_1.BabysitterRuntimeError("OrchestrationSessionMissing", "The orchestration PI session has not been created.", { category: utils_1.ErrorCategory.Runtime });
+        }
+        if (!args.json && args.verbose && args.outputMode !== "tui") {
+            process.stderr.write(`\n${utils_1.DIM}[${label}] agent turn\n`);
+        }
+        writeVerboseData(`${label} prompt`, message);
+        const progressSnapshot = captureProgressSnapshot();
+        let result;
+        try {
+            result = await (0, utils_1.promptPiWithRetry)({
+                session: orchestrationSession,
+                message: (0, utils_1.compressInternalHarnessPrompt)(message, args.compressionConfig, "agent"),
+                timeout: utils_1.PI_PARENT_PROMPT_TIMEOUT_MS,
+                label,
+                writeVerbose,
+                writeVerboseData,
+            });
+        }
+        catch (err) {
+            const isTimeout = err instanceof utils_1.BabysitterRuntimeError
+                && (err.name === "PiTimeoutError" || err.message.includes("timed out"));
+            if (!isTimeout) {
+                throw err;
+            }
+            result = {
+                success: false,
+                output: `Pi prompt timed out: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+        if (!result.success) {
+            writeVerboseData(`${label} agent failure output`, result.output);
+            if (!orchestrationStateAdvanced(progressSnapshot)) {
+                throw new utils_1.BabysitterRuntimeError("OrchestrationAgentFailed", result.output, {
+                    category: utils_1.ErrorCategory.External,
+                });
+            }
+            if (state.lastIterationResult?.status !== "process-error" &&
+                !(0, utils_1.isIgnorablePiPromptFailure)(result.output)) {
+                throw new utils_1.BabysitterRuntimeError("OrchestrationAgentFailed", result.output, {
+                    category: utils_1.ErrorCategory.External,
+                });
+            }
+            return;
+        }
+        writeVerbose(`[phaseOrchestration agent] ${summarizeAgentText(result.output)}`);
+    };
+    orchestrationSession = registerPiSession((0, utils_1.createAgentCoreSession)({
+        workspace: args.workspace,
+        model: args.model,
+        backend: (0, utils_1.resolveAgentCoreBackendForHarness)(args.selectedHarnessName),
+        toolsMode: "coding",
+        customTools: mergedTools,
+        uiContext: args.interactive && args.rl
+            ? (0, utils_1.createReadlineAskUserQuestionUiContext)(args.rl)
+            : undefined,
+        appendSystemPrompt: [
+            (0, prompts_1.buildOrchestrationSystemPrompt)(args.selectedHarnessName, args.promptContext, args.interactive, args.invocationCommand === "call"),
+        ],
+        ephemeral: true,
+    }));
+    (0, utils_1.emitProgress)({ phase: "2", status: "started", harness: args.selectedHarnessName }, args.json, args.verbose, args.outputMode);
+    let unsubscribe = null;
+    try {
+        await orchestrationSession.initialize();
+        if (!args.json && args.verbose && args.outputMode !== "tui") {
+            unsubscribe = (0, verbose_1.subscribeVerbosePiEvents)(orchestrationSession, "orchestrator", args);
+        }
+        await ensureBoundRunContext();
+        if (!state.runId || !state.runDir) {
+            throw new utils_1.BabysitterRuntimeError("RunNotCreated", "The orchestration session could not establish a run before iteration.", { category: utils_1.ErrorCategory.Runtime });
+        }
+        await snapshotProtectedRunEntries();
+        let consecutiveTimeouts = 0;
+        let consecutiveStalls = 0;
+        let consecutiveProcessErrorStalls = 0;
+        while (state.iteration < args.maxIterations) {
+            const observed = await syncStateFromRunArtifacts();
+            const terminal = ensureTerminalResult();
+            if (terminal !== null) {
+                break;
+            }
+            if ((state.lastIterationResult?.status === "waiting"
+                && state.pendingActions.size === 0)
+                || observed.runStatus === "created"
+                || observed.runStatus === "in-progress") {
+                writeVerbose(observed.runStatus === "created"
+                    ? "[phaseOrchestration host] bootstrapping the freshly created run"
+                    : "[phaseOrchestration host] all pending effects were posted; auto-advancing the run");
+                await invokeTool(iterateTool, "babysitter_run_iterate");
+                if (ensureTerminalResult() !== null) {
+                    break;
+                }
+                consecutiveTimeouts = 0;
+                consecutiveStalls = 0;
+                consecutiveProcessErrorStalls = 0;
+                continue;
+            }
+            const progressBeforeTurn = captureProgressSnapshot();
+            try {
+                await promptOrchestrationAgent((0, prompts_1.buildOrchestrationTurnPrompt)({
+                    processPath: path.resolve(args.processPath),
+                    userPrompt: args.prompt,
+                    planningConversationSummary: args.planningConversationSummary,
+                    maxIterations: args.maxIterations,
+                    currentIteration: state.iteration,
+                    runId: state.runId,
+                    runDir: state.runDir,
+                    lastStatus: state.lastIterationResult?.status,
+                    lastError: state.lastIterationResult?.status === "process-error"
+                        ? extractIterationError(state.lastIterationResult.error)
+                        : undefined,
+                    pendingEffects: describePendingActions(),
+                }), `phaseOrchestration iteration ${state.iteration + 1}`);
+            }
+            catch (err) {
+                const isTimeoutFailure = err instanceof utils_1.BabysitterRuntimeError
+                    && err.name === "OrchestrationAgentFailed"
+                    && (err.message.includes("timed out") || err.message.includes("PiTimeoutError"));
+                if (!isTimeoutFailure) {
+                    throw err;
+                }
+                consecutiveTimeouts += 1;
+                if (consecutiveTimeouts >= constants_1.MAX_CONSECUTIVE_TIMEOUTS) {
+                    throw new utils_1.BabysitterRuntimeError("OrchestrationAgentTimedOut", `Pi prompt timed out ${consecutiveTimeouts} consecutive times — aborting orchestration.`, { category: utils_1.ErrorCategory.External });
+                }
+                continue;
+            }
+            await cleanupUnexpectedRunSiblings();
+            if (ensureTerminalResult() !== null) {
+                break;
+            }
+            if (!orchestrationStateAdvanced(progressBeforeTurn)) {
+                await syncStateFromRunArtifacts();
+            }
+            if (orchestrationStateAdvanced(progressBeforeTurn)) {
+                consecutiveTimeouts = 0;
+                consecutiveStalls = 0;
+                consecutiveProcessErrorStalls = 0;
+                continue;
+            }
+            if (state.lastIterationResult?.status === "process-error") {
+                consecutiveProcessErrorStalls += 1;
+                if (consecutiveProcessErrorStalls >= constants_1.MAX_CONSECUTIVE_PROCESS_ERROR_STALLS) {
+                    throw new utils_1.BabysitterRuntimeError("OrchestrationAgentStalled", `The orchestration agent did not retry the run or repair the process after ${consecutiveProcessErrorStalls} consecutive recovery prompts.`, { category: utils_1.ErrorCategory.Runtime });
+                }
+                continue;
+            }
+            consecutiveStalls += 1;
+            if (consecutiveStalls >= constants_1.MAX_CONSECUTIVE_STALLS) {
+                throw new utils_1.BabysitterRuntimeError("OrchestrationAgentStalled", `The orchestration agent did not advance the run or resolve pending effects for ${consecutiveStalls} consecutive turns.`, { category: utils_1.ErrorCategory.Runtime });
+            }
+        }
+        if (!state.finished &&
+            (state.lastIterationResult?.status === "completed" || state.lastIterationResult?.status === "failed")) {
+            await invokeTool(finishTool, "babysitter_finish_orchestration", {
+                summary: state.lastIterationResult.status === "completed"
+                    ? `Run ${state.runId} completed after ${state.iteration} iterations.`
+                    : `Run ${state.runId} failed after ${state.iteration} iterations.`,
+            });
+        }
+        return ensureTerminalResult() ?? 1;
+    }
+    catch (error) {
+        writeVerboseData("phaseOrchestration error", error instanceof Error
+            ? {
+                name: error.name,
+                message: error.message,
+                stack: error.stack,
+                runId: state.runId,
+                runDir: state.runDir,
+                iteration: state.iteration,
+                pendingEffects: describePendingActions(),
+                lastIterationResult: state.lastIterationResult,
+            }
+            : error);
+        (0, utils_1.emitProgress)({
+            phase: "2",
+            status: "failed",
+            runId: state.runId,
+            runDir: state.runDir,
+            iteration: state.iteration,
+            error: error instanceof Error ? error.message : String(error),
+        }, args.json, args.verbose, args.outputMode);
+        return 1;
+    }
+    finally {
+        unsubscribe?.();
+        await Promise.allSettled(Array.from(activePiSessions).map((session) => shutdownPiSession(session)));
+    }
+}
+function summarizeAgentText(text) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return "(no summary emitted)";
+    }
+    return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
+}
+function extractIterationError(error) {
+    return typeof error === "object" && error !== null && "message" in error
+        ? String(error.message)
+        : String(error);
+}

package/dist/harness/internal/createRun/orchestration/internalTools.d.ts

@@ -0,0 +1,26 @@
+import { type OrchestrationState, type ToolResultShape } from "../utils";
+import type { OrchestrationWriteVerbose, OrchestrationWriteVerboseData, RunOrchestrationPhaseArgs } from "./types";
+type ToolExecute = (toolCallId: string, params: Record<string, unknown>) => Promise<ToolResultShape> | ToolResultShape;
+export type OrchestrationNamedTool = {
+    name: string;
+    execute?: ToolExecute;
+};
+export declare function createOrchestrationTools(args: {
+    phaseArgs: RunOrchestrationPhaseArgs;
+    state: OrchestrationState;
+    describePendingActions: () => Array<{
+        effectId: string;
+        kind: string;
+        title?: string;
+        harness?: string;
+    }>;
+    writeVerbose: OrchestrationWriteVerbose;
+    writeVerboseData: OrchestrationWriteVerboseData;
+}): {
+    mergedTools: unknown[];
+    iterateTool: OrchestrationNamedTool | undefined;
+    finishTool: OrchestrationNamedTool | undefined;
+    invokeTool: (tool: OrchestrationNamedTool | undefined, name: string, params?: Record<string, unknown>) => Promise<ToolResultShape>;
+};
+export {};
+//# sourceMappingURL=internalTools.d.ts.map

package/dist/harness/internal/createRun/orchestration/internalTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internalTools.d.ts","sourceRoot":"","sources":["../../../../../src/harness/internal/createRun/orchestration/internalTools.ts"],"names":[],"mappings":"AAQA,OAAO,EAML,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACrB,MAAM,UAAU,CAAC;AAKlB,OAAO,KAAK,EACV,yBAAyB,EACzB,6BAA6B,EAC7B,yBAAyB,EAC1B,MAAM,SAAS,CAAC;AAEjB,KAAK,WAAW,GAAG,CACjB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC5B,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,CAAC;AAEhD,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB,CAAC;AAEF,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,SAAS,EAAE,yBAAyB,CAAC;IACrC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,sBAAsB,EAAE,MAAM,KAAK,CAAC;QAClC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;IACH,YAAY,EAAE,yBAAyB,CAAC;IACxC,gBAAgB,EAAE,6BAA6B,CAAC;CACjD,GAAG;IACF,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,WAAW,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAChD,UAAU,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAC/C,UAAU,EAAE,CACV,IAAI,EAAE,sBAAsB,GAAG,SAAS,EACxC,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,OAAO,CAAC,eAAe,CAAC,CAAC;CAC/B,CAkFA"}