@aria-cli/cli 1.0.51 → 1.0.54

package/dist/headless/run-orchestrator.js

@@ -1,703 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { isDeepStrictEqual } from "node:util";
-import { setStallPhase, clearStallPhase } from "../event-loop-watchdog.js";
-import { resolveTrustedRuntimeErrorMessage } from "@aria-cli/tools";
-import { fromModelMessages } from "../history/conversation-message.js";
-const SESSION_LEASE_MS = 30_000;
-const SESSION_LEASE_RENEW_INTERVAL_MS = 10_000;
-function initialRunSynthesisState() {
-    return {
-        output: "",
-        messages: [],
-        toolCalls: [],
-        usage: undefined,
-        turnCount: 0,
-        thinking: [],
-        nativeToolResults: [],
-        pipelineTiming: undefined,
-        guardrailEvents: [],
-        handoffs: [],
-        pausedState: null,
-    };
-}
-function synthesizeRunResult(state) {
-    return {
-        success: !state.pausedState,
-        ...(state.output ? { output: state.output } : {}),
-        ...(state.messages.length > 0 ? { messages: state.messages } : {}),
-        ...(state.toolCalls.length > 0 ? { toolCalls: state.toolCalls } : {}),
-        ...(state.usage !== undefined ? { usage: state.usage } : {}),
-        ...(state.turnCount > 0 ? { turnCount: state.turnCount } : {}),
-        ...(state.thinking.length > 0 ? { thinking: state.thinking } : {}),
-        ...(state.nativeToolResults.length > 0 ? { nativeToolResults: state.nativeToolResults } : {}),
-        ...(state.pipelineTiming !== undefined ? { pipelineTiming: state.pipelineTiming } : {}),
-        ...(state.guardrailEvents.length > 0 ? { guardrailEvents: state.guardrailEvents } : {}),
-        ...(state.handoffs.length > 0 ? { handoffs: state.handoffs } : {}),
-        ...(state.pausedState ? { state: state.pausedState } : {}),
-    };
-}
-function toHeadlessError(code, message, details) {
-    return {
-        code,
-        message,
-        ...(details ? { details } : {}),
-    };
-}
-function toFailureResult(requestId, op, code, message, details) {
-    return {
-        kind: "result",
-        requestId,
-        op,
-        ok: false,
-        error: toHeadlessError(code, message, details),
-    };
-}
-function toSuccessResult(requestId, op, result) {
-    return {
-        kind: "result",
-        requestId,
-        op,
-        ok: true,
-        result,
-    };
-}
-function buildPolicySnapshot(request) {
-    return {
-        ...(request.arion ? { arion: request.arion } : {}),
-        ...(request.cwd ? { cwd: request.cwd } : {}),
-        ...(request.requestedModel ? { requestedModel: request.requestedModel } : {}),
-        ...(request.preferredTier ? { preferredTier: request.preferredTier } : {}),
-        ...(typeof request.budget === "number" ? { budget: request.budget } : {}),
-        ...(typeof request.maxTurns === "number" ? { maxTurns: request.maxTurns } : {}),
-        ...(request.autonomy ? { autonomy: request.autonomy } : {}),
-        ...(request.allowedTools ? { allowedTools: request.allowedTools } : {}),
-        ...(request.deniedTools ? { deniedTools: request.deniedTools } : {}),
-        ...(typeof request.noMemory === "boolean" ? { noMemory: request.noMemory } : {}),
-        ...(request.systemPrompt ? { systemPrompt: request.systemPrompt } : {}),
-    };
-}
-function applySessionArionToRunRequest(request, sessionArion) {
-    if (request.arion || !sessionArion) {
-        return request;
-    }
-    return {
-        ...request,
-        arion: sessionArion,
-    };
-}
-function toRuntimeRunRequest(request) {
-    const { sessionId: _sessionId, ...runtimeRequest } = request;
-    return runtimeRequest;
-}
-function toRuntimeResumeRequest(request) {
-    const { sessionId: _sessionId, ...runtimeRequest } = request;
-    return runtimeRequest;
-}
-function applySessionModelToRunRequest(request, sessionModel) {
-    if (request.requestedModel || !sessionModel) {
-        return request;
-    }
-    return {
-        ...request,
-        requestedModel: sessionModel,
-    };
-}
-function persistTranscript(sessionLedger, sessionId, messages) {
-    if (!Array.isArray(messages) || messages.length === 0) {
-        return;
-    }
-    sessionLedger.replaceConversationMessages(sessionId, fromModelMessages(messages));
-}
-function buildInteractionRequest(requestId, sessionId, pausedState) {
-    if ((pausedState.pendingUserQuestions?.length ?? 0) > 0) {
-        const interactionId = `${sessionId}:questionnaire:${randomUUID()}`;
-        const interaction = {
-            kind: "questionnaire",
-            questions: pausedState.pendingUserQuestions ?? [],
-        };
-        return {
-            record: {
-                interactionId,
-                requestId,
-                source: "run",
-                kind: interaction.kind,
-                prompt: interaction,
-            },
-            frame: {
-                kind: "interaction.required",
-                requestId,
-                interactionId,
-                source: "run",
-                interaction,
-            },
-        };
-    }
-    if ((pausedState.pendingToolCalls?.length ?? 0) > 0) {
-        const pendingTool = pausedState.pendingToolCalls[0];
-        const interactionId = `${sessionId}:tool-approval:${randomUUID()}`;
-        const interaction = {
-            kind: "tool_approval",
-            toolName: pendingTool.name,
-            toolInput: pendingTool.arguments,
-            prompt: `Approval required for ${pendingTool.name}`,
-        };
-        return {
-            record: {
-                interactionId,
-                requestId,
-                source: "run",
-                kind: interaction.kind,
-                prompt: interaction,
-            },
-            frame: {
-                kind: "interaction.required",
-                requestId,
-                interactionId,
-                source: "run",
-                interaction,
-            },
-        };
-    }
-    return null;
-}
-function buildResumeRequestFromInteraction(pausedState, interaction, response, runtimeStateRevision, runtimeStatePolicySnapshot) {
-    const baseRequest = {
-        state: pausedState,
-        ...(runtimeStatePolicySnapshot ?? {}),
-    };
-    if (interaction.kind === "tool_approval") {
-        if (response.response.kind !== "confirm") {
-            throw new Error(`Interaction ${interaction.interactionId} requires a confirm response`);
-        }
-        return {
-            ...baseRequest,
-            approvalMode: response.response.approved ? "approve" : "deny",
-            // Preserve a revision breadcrumb for diagnostics only; ignored by schema consumers.
-            ...(runtimeStateRevision >= 0 ? {} : {}),
-        };
-    }
-    if (interaction.kind === "questionnaire") {
-        if (response.response.kind !== "questionnaire") {
-            throw new Error(`Interaction ${interaction.interactionId} requires a questionnaire response`);
-        }
-        return {
-            ...baseRequest,
-            askUserAnswers: response.response.answers,
-        };
-    }
-    throw new Error(`Unsupported run interaction kind ${interaction.kind}`);
-}
-export class HeadlessRunOrchestrator {
-    ctx;
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    renewSessionLease(sessionId, ownerId) {
-        const ledger = this.ctx.sessionLedger;
-        if (typeof ledger.renewSessionClaim === "function") {
-            return ledger.renewSessionClaim(sessionId, ownerId, SESSION_LEASE_MS);
-        }
-        return ledger.claimSessionForMutation(sessionId, ownerId, SESSION_LEASE_MS);
-    }
-    clearRunningSession(sessionId, ownerId, expectedRevision) {
-        const ledger = this.ctx.sessionLedger;
-        if (typeof ledger.clearActiveRun === "function") {
-            return ledger.clearActiveRun(sessionId, { ownerId, expectedRevision });
-        }
-        return ledger.completeRun(sessionId, {}, { ownerId, expectedRevision });
-    }
-    releaseClaimOnce(sessionId, ownerId) {
-        let released = false;
-        return () => {
-            if (released) {
-                return;
-            }
-            released = true;
-            this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
-        };
-    }
-    static isAbortError(error) {
-        return (error instanceof Error &&
-            (error.name === "AbortError" ||
-                error.message === "The operation was aborted" ||
-                error.message === "This operation was aborted"));
-    }
-    static createAbortReason(code, message) {
-        const error = new Error(message);
-        error.name = "AbortError";
-        error.code = code;
-        return error;
-    }
-    static getAbortCode(signal, error) {
-        const candidate = signal?.aborted ? signal.reason : error;
-        if (candidate &&
-            typeof candidate === "object" &&
-            "code" in candidate &&
-            typeof candidate.code === "string") {
-            return candidate.code;
-        }
-        return signal?.aborted || HeadlessRunOrchestrator.isAbortError(error) ? "RUN_ABORTED" : null;
-    }
-    static getAbortMessage(signal, error) {
-        const candidate = signal?.aborted ? signal.reason : error;
-        if (candidate instanceof Error && candidate.message) {
-            return candidate.message;
-        }
-        return "Run aborted before completion.";
-    }
-    async *start(requestId, request, signal) {
-        const sessionId = request.sessionId?.trim() || requestId;
-        const ownerId = `headless:${requestId}`;
-        const sessionModel = this.ctx.getSessionModel?.();
-        const sessionArion = this.ctx.getSessionArion?.();
-        const effectiveRequest = applySessionModelToRunRequest(applySessionArionToRunRequest(request, sessionArion), sessionModel);
-        const arionName = effectiveRequest.arion ?? this.ctx.getSessionArion?.() ?? "ARIA";
-        const model = effectiveRequest.requestedModel ?? effectiveRequest.preferredTier ?? "balanced";
-        const policySnapshot = buildPolicySnapshot(effectiveRequest);
-        if (!this.ctx.sessionLedger.loadSession(sessionId)) {
-            this.ctx.sessionLedger.createSession(arionName, model, sessionId);
-        }
-        let claimed = this.ctx.sessionLedger.claimSessionForMutation(sessionId, ownerId, 30_000);
-        const releaseClaim = this.releaseClaimOnce(sessionId, ownerId);
-        const state = initialRunSynthesisState();
-        const controller = new AbortController();
-        let releaseExternalAbort = null;
-        let renewalTimer = null;
-        // Deferred persistence closure — captured in the success path, executed
-        // from the finally block via setTimeout(0). This architectural boundary
-        // ensures persistence (DELETE+INSERT of entire transcript) NEVER blocks
-        // the consumer from receiving the result frame and updating the UI.
-        let deferredPersistence = null;
-        if (signal) {
-            const onAbort = () => {
-                controller.abort(HeadlessRunOrchestrator.createAbortReason("CONNECTION_CLOSED", "Connection closed before request completed"));
-            };
-            if (signal.aborted) {
-                onAbort();
-            }
-            else {
-                signal.addEventListener("abort", onAbort, { once: true });
-                releaseExternalAbort = () => signal.removeEventListener("abort", onAbort);
-            }
-        }
-        renewalTimer = setInterval(() => {
-            try {
-                claimed = this.renewSessionLease(sessionId, ownerId);
-            }
-            catch (error) {
-                controller.abort(HeadlessRunOrchestrator.createAbortReason("SESSION_LEASE_LOST", error instanceof Error ? error.message : String(error)));
-            }
-        }, SESSION_LEASE_RENEW_INTERVAL_MS);
-        try {
-            for await (const event of this.ctx.localControl.streamRun(toRuntimeRunRequest(effectiveRequest), controller.signal)) {
-                if (controller.signal.aborted) {
-                    releaseClaim();
-                    return;
-                }
-                this.consumeRunEvent(state, event);
-                yield {
-                    kind: "event",
-                    requestId,
-                    seq: state.turnCount + state.toolCalls.length + state.thinking.length,
-                    op: "run.start",
-                    event,
-                };
-            }
-            if (controller.signal.aborted) {
-                persistTranscript(this.ctx.sessionLedger, sessionId, state.messages);
-                this.clearRunningSession(sessionId, ownerId, claimed.revision);
-                releaseClaim();
-                const abortCode = HeadlessRunOrchestrator.getAbortCode(controller.signal);
-                if (abortCode !== "CONNECTION_CLOSED") {
-                    yield toFailureResult(requestId, "run.start", abortCode ?? "RUN_ABORTED", HeadlessRunOrchestrator.getAbortMessage(controller.signal), { sessionId, runId: `run:${sessionId}` });
-                }
-                return;
-            }
-            if (state.pausedState) {
-                persistTranscript(this.ctx.sessionLedger, sessionId, state.pausedState.messages);
-                const interaction = buildInteractionRequest(requestId, sessionId, state.pausedState);
-                this.ctx.sessionLedger.recordPausedRun(sessionId, `run:${sessionId}`, state.pausedState, policySnapshot, interaction?.record, {
-                    ownerId,
-                    expectedRevision: claimed.revision,
-                });
-                releaseClaim();
-                if (interaction) {
-                    yield interaction.frame;
-                }
-                yield toFailureResult(requestId, "run.start", "INTERACTION_REQUIRED", "Run paused and requires interaction before it can continue.", {
-                    sessionId,
-                    ...(interaction
-                        ? {
-                            interactionId: interaction.frame.interactionId,
-                            source: interaction.frame.source,
-                            interaction: interaction.frame.interaction,
-                        }
-                        : {}),
-                });
-                return;
-            }
-            const result = synthesizeRunResult(state);
-            // Yield result BEFORE persistence — the consumer must receive the result
-            // frame without waiting for SQLite writes. persistTranscript does
-            // DELETE + INSERT for the entire conversation transcript, which blocks
-            // the event loop for 100-500ms on long conversations. Deferring it to
-            // the finally block (via setTimeout) ensures the consumer's for-await
-            // loop exits immediately after this yield.
-            deferredPersistence = () => {
-                const msgCount = Array.isArray(result.messages) ? result.messages.length : 0;
-                setStallPhase(`orchestrator:persistTranscript(${msgCount} msgs)`);
-                const _pt0 = performance.now();
-                persistTranscript(this.ctx.sessionLedger, sessionId, result.messages);
-                const _pt1 = performance.now();
-                setStallPhase("orchestrator:completeRun");
-                this.ctx.sessionLedger.completeRun(sessionId, result, {
-                    ownerId,
-                    expectedRevision: claimed.revision,
-                });
-                const _pt2 = performance.now();
-                clearStallPhase();
-                releaseClaim();
-                const _total = _pt2 - _pt0;
-                if (_total > 100) {
-                    try {
-                        process.stderr.write(`[Orchestrator][DIAG] deferredPersistence: ` +
-                            `total=${_total.toFixed(0)}ms transcript=${(_pt1 - _pt0).toFixed(0)}ms ` +
-                            `completeRun=${(_pt2 - _pt1).toFixed(0)}ms msgs=${msgCount}\n`);
-                    }
-                    catch {
-                        /* best effort */
-                    }
-                }
-            };
-            yield toSuccessResult(requestId, "run.start", result);
-        }
-        catch (error) {
-            try {
-                if (controller.signal.aborted || HeadlessRunOrchestrator.isAbortError(error)) {
-                    persistTranscript(this.ctx.sessionLedger, sessionId, state.messages);
-                    this.clearRunningSession(sessionId, ownerId, claimed.revision);
-                }
-                releaseClaim();
-            }
-            catch {
-                // Best effort cleanup on failure.
-            }
-            if (controller.signal.aborted || HeadlessRunOrchestrator.isAbortError(error)) {
-                const abortCode = HeadlessRunOrchestrator.getAbortCode(controller.signal, error);
-                if (abortCode !== "CONNECTION_CLOSED") {
-                    yield toFailureResult(requestId, "run.start", abortCode ?? "RUN_ABORTED", HeadlessRunOrchestrator.getAbortMessage(controller.signal, error), { sessionId, runId: `run:${sessionId}` });
-                }
-                return;
-            }
-            yield toFailureResult(requestId, "run.start", "RUN_START_FAILED", error instanceof Error ? error.message : String(error));
-        }
-        finally {
-            if (renewalTimer) {
-                clearInterval(renewalTimer);
-            }
-            releaseExternalAbort?.();
-            // Execute deferred persistence from the success path. Scheduled via
-            // setTimeout(0) so it runs AFTER React's microtask render cycle —
-            // the consumer sets isStreaming=false and yields, React renders the
-            // input area, THEN persistence runs. This makes it structurally
-            // impossible for transcript persistence to block the UI transition.
-            if (deferredPersistence) {
-                const persist = deferredPersistence;
-                deferredPersistence = null;
-                setTimeout(() => {
-                    try {
-                        setStallPhase("orchestrator:deferredPersistence");
-                        const dpT0 = performance.now();
-                        persist();
-                        const dpElapsed = performance.now() - dpT0;
-                        clearStallPhase();
-                        if (dpElapsed > 200) {
-                            try {
-                                process.stderr.write(`[Orchestrator][DIAG] deferredPersistence blocked ${dpElapsed.toFixed(0)}ms\n`);
-                            }
-                            catch {
-                                /* best effort */
-                            }
-                        }
-                    }
-                    catch {
-                        clearStallPhase();
-                        // Non-fatal: consumer already has the result frame.
-                        // Crash recovery handles stale session state on next startup.
-                        releaseClaim();
-                    }
-                }, 0);
-            }
-        }
-    }
-    async *resume(requestId, request, signal) {
-        const sessionId = request.sessionId?.trim();
-        const ownerId = `headless:${requestId}`;
-        const sessionModel = this.ctx.getSessionModel?.();
-        const sessionArion = this.ctx.getSessionArion?.();
-        const effectiveRequest = applySessionModelToRunRequest(applySessionArionToRunRequest(request, sessionArion), sessionModel);
-        const runtimeRequest = toRuntimeResumeRequest(effectiveRequest);
-        const policySnapshot = buildPolicySnapshot(runtimeRequest);
-        let createdSession = false;
-        let claimed = null;
-        try {
-            if (signal?.aborted) {
-                return;
-            }
-            if (sessionId) {
-                if (!this.ctx.sessionLedger.loadSession(sessionId)) {
-                    this.ctx.sessionLedger.createSession(effectiveRequest.arion ?? this.ctx.getSessionArion?.() ?? "ARIA", effectiveRequest.requestedModel ?? effectiveRequest.preferredTier ?? "balanced", sessionId);
-                    createdSession = true;
-                }
-                claimed = this.ctx.sessionLedger.claimSessionForMutation(sessionId, ownerId, 30_000);
-            }
-            const result = await this.ctx.localControl.resumeRun(runtimeRequest);
-            if (signal?.aborted) {
-                if (sessionId && claimed) {
-                    this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
-                    if (createdSession) {
-                        this.ctx.sessionLedger.deleteSession(sessionId);
-                    }
-                }
-                return;
-            }
-            if (sessionId && claimed) {
-                if (result.state) {
-                    const pausedState = result.state;
-                    persistTranscript(this.ctx.sessionLedger, sessionId, pausedState.messages);
-                    const nextInteraction = buildInteractionRequest(requestId, sessionId, pausedState);
-                    this.ctx.sessionLedger.recordPausedRun(sessionId, `run:${sessionId}`, pausedState, policySnapshot, nextInteraction?.record, {
-                        ownerId,
-                        expectedRevision: claimed.revision,
-                    });
-                    this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
-                    if (nextInteraction) {
-                        yield nextInteraction.frame;
-                    }
-                    yield toFailureResult(requestId, "run.resume", "INTERACTION_REQUIRED", "Run paused and requires interaction before it can continue.", {
-                        sessionId,
-                        ...(nextInteraction
-                            ? {
-                                interactionId: nextInteraction.frame.interactionId,
-                                source: nextInteraction.frame.source,
-                                interaction: nextInteraction.frame.interaction,
-                            }
-                            : {}),
-                    });
-                    return;
-                }
-                persistTranscript(this.ctx.sessionLedger, sessionId, result.messages);
-                this.ctx.sessionLedger.completeRun(sessionId, result, {
-                    ownerId,
-                    expectedRevision: claimed.revision,
-                });
-                this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
-            }
-            yield toSuccessResult(requestId, "run.resume", result);
-        }
-        catch (error) {
-            if (sessionId && claimed) {
-                try {
-                    this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
-                    if (createdSession) {
-                        this.ctx.sessionLedger.deleteSession(sessionId);
-                    }
-                }
-                catch {
-                    // Best effort cleanup.
-                }
-            }
-            if (signal?.aborted || HeadlessRunOrchestrator.isAbortError(error)) {
-                return;
-            }
-            yield toFailureResult(requestId, "run.resume", "RUN_RESUME_FAILED", error instanceof Error ? error.message : String(error));
-        }
-    }
-    async *abort(requestId, input, activeRunController) {
-        const aborted = await (activeRunController ?? this.ctx.activeRunController)?.abort(input);
-        if (aborted) {
-            yield {
-                kind: "result",
-                requestId,
-                op: "run.abort",
-                ok: true,
-                result: {
-                    aborted: true,
-                    ...(input.runId ? { runId: input.runId } : {}),
-                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-                },
-            };
-            return;
-        }
-        yield toFailureResult(requestId, "run.abort", "RUN_NOT_FOUND", "No active run matched the requested runId or sessionId.", {
-            ...(input.runId ? { runId: input.runId } : {}),
-            ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-        });
-    }
-    async *respond(response, signal) {
-        const interaction = this.ctx.sessionLedger.getInteraction(response.interactionId);
-        if (!interaction) {
-            yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_NOT_FOUND", `Unknown interaction ${response.interactionId}`);
-            return;
-        }
-        if (interaction.source !== "run") {
-            yield toFailureResult(response.requestId, "interaction.respond", "UNSUPPORTED_INTERACTION_SOURCE", `Interaction source ${interaction.source} is not handled by the run orchestrator`);
-            return;
-        }
-        const runtimeState = this.ctx.sessionLedger.getSessionRuntimeState(interaction.sessionId);
-        if (!runtimeState?.pausedState) {
-            yield toFailureResult(response.requestId, "interaction.respond", "SESSION_NOT_PAUSED", `Session ${interaction.sessionId} is not paused`);
-            return;
-        }
-        const ownerId = `headless:${response.requestId}`;
-        try {
-            if (signal?.aborted) {
-                return;
-            }
-            const claimed = this.ctx.sessionLedger.claimSessionForMutation(interaction.sessionId, ownerId, 30_000);
-            let effectiveResponse = response.response;
-            let responseRevision = claimed.revision;
-            if (interaction.status === "pending") {
-                this.ctx.sessionLedger.recordInteractionResponse(interaction.sessionId, interaction.interactionId, effectiveResponse, {
-                    ownerId,
-                    expectedRevision: claimed.revision,
-                });
-                responseRevision += 1;
-            }
-            else if (interaction.status === "answered") {
-                if (!interaction.response) {
-                    this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
-                    yield toFailureResult(response.requestId, "interaction.respond", "INVALID_INTERACTION_STATE", `Interaction ${interaction.interactionId} is missing its recorded response`);
-                    return;
-                }
-                if (!isDeepStrictEqual(interaction.response, effectiveResponse)) {
-                    this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
-                    yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_ALREADY_ANSWERED", `Interaction ${interaction.interactionId} was already answered with a different response`);
-                    return;
-                }
-                effectiveResponse = interaction.response;
-            }
-            else {
-                this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
-                yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_NOT_PENDING", `Interaction ${interaction.interactionId} is not resumable in state ${interaction.status}`);
-                return;
-            }
-            const resumeRequest = buildResumeRequestFromInteraction(runtimeState.pausedState, interaction, {
-                ...response,
-                response: effectiveResponse,
-            }, runtimeState.revision, runtimeState.policySnapshot);
-            const result = await this.ctx.localControl.resumeRun(resumeRequest);
-            if (signal?.aborted) {
-                this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
-                return;
-            }
-            if (result.state) {
-                const pausedState = result.state;
-                persistTranscript(this.ctx.sessionLedger, interaction.sessionId, pausedState.messages);
-                const nextInteraction = buildInteractionRequest(response.requestId, interaction.sessionId, pausedState);
-                this.ctx.sessionLedger.recordPausedRun(interaction.sessionId, runtimeState.activeRunId ?? `run:${interaction.sessionId}`, pausedState, runtimeState.policySnapshot ?? {}, nextInteraction?.record, {
-                    ownerId,
-                    expectedRevision: responseRevision,
-                });
-                this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
-                if (nextInteraction) {
-                    yield nextInteraction.frame;
-                }
-                yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_REQUIRED", "Run paused again and requires another interaction.", {
-                    sessionId: interaction.sessionId,
-                    ...(nextInteraction
-                        ? {
-                            interactionId: nextInteraction.frame.interactionId,
-                            source: nextInteraction.frame.source,
-                            interaction: nextInteraction.frame.interaction,
-                        }
-                        : {}),
-                });
-                return;
-            }
-            persistTranscript(this.ctx.sessionLedger, interaction.sessionId, result.messages);
-            this.ctx.sessionLedger.completeRun(interaction.sessionId, result, {
-                ownerId,
-                expectedRevision: responseRevision,
-            });
-            this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
-            yield toSuccessResult(response.requestId, "interaction.respond", result);
-        }
-        catch (error) {
-            try {
-                this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
-            }
-            catch {
-                // Best effort.
-            }
-            if (signal?.aborted || HeadlessRunOrchestrator.isAbortError(error)) {
-                return;
-            }
-            yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_RESPONSE_FAILED", error instanceof Error ? error.message : String(error));
-        }
-    }
-    consumeRunEvent(state, event) {
-        switch (event.type) {
-            case "text_delta":
-                state.output += event.content;
-                break;
-            case "tool_result":
-                state.toolCalls.push({
-                    id: event.id,
-                    name: event.name,
-                    input: event.input,
-                    result: event.result,
-                    durationMs: event.durationMs,
-                });
-                break;
-            case "usage_update":
-                state.usage = event.usage;
-                break;
-            case "turn_complete":
-                state.turnCount = event.turnNumber;
-                break;
-            case "guardrail_rejected":
-                state.guardrailEvents.push({
-                    stage: event.stage,
-                    message: event.message,
-                });
-                break;
-            case "pipeline_timing":
-                state.pipelineTiming = event.report;
-                break;
-            case "messages_snapshot":
-                state.messages = Array.isArray(event.messages) ? event.messages : [];
-                break;
-            case "thinking_end":
-                if (event.blocks)
-                    state.thinking.push(...event.blocks);
-                break;
-            case "native_tool_result":
-                state.nativeToolResults.push(event.metadata);
-                break;
-            case "handoff_start":
-                state.handoffs.push({
-                    type: "start",
-                    target: event.target,
-                    id: event.id,
-                });
-                break;
-            case "handoff_result":
-                state.handoffs.push({
-                    type: "result",
-                    target: event.target,
-                    id: event.id,
-                    result: event.result,
-                });
-                break;
-            case "paused":
-                state.pausedState = event.state;
-                break;
-            case "error":
-                throw new Error(resolveTrustedRuntimeErrorMessage(event.error.message, "diagnostic" in event.error ? event.error.diagnostic : undefined) ?? event.error.message);
-            default:
-                break;
-        }
-    }
-}
-//# sourceMappingURL=run-orchestrator.js.map