@assemblyline-agents/runtime 5.0.10 → 6.0.0

package/dist/replay-resume.js

@@ -1,15 +1,8 @@
-import { runtimeToolsForSurface } from "./builtin-tools.js";
-import { connectionAuthorizationPrompt, parseQualifiedName, RuntimeConnectionRegistry } from "./connections.js";
-import { storedHarnessContinuation } from "./harness-continuation.js";
-import { persistConversationTranscriptImpl } from "./conversation-transcript.js";
-import { capabilitySystemPrompt, capabilityPromptKey, capabilityToolNames, replaceCapabilitySet } from "./harness-loop.js";
-import { isJsonObject, redactedToolCallRecord } from "./json-util.js";
-import { prepareToolModelOutput } from "./model-media.js";
-import { crashResumeReport } from "./run-recovery.js";
-import { applyCoreToolPolicy } from "./security.js";
-import { surfaceForRun } from "./agent-surface.js";
-import { runUsesChannelReplyForHumanInput } from "./human-input-routing.js";
-import { normalizeAgentAudience } from "./audience.js";
+import { redactedToolCallRecord } from "./json-util.js";
+export { completeConnectionAuthorizationCallbackImpl } from "./replay-resume-authorization.js";
+export { resumeApprovalNowImpl, resumeInputNowImpl, resumeSuspendedNowImpl } from "./replay-resume-controls.js";
+export { resumeHarnessLoopImpl } from "./replay-resume-harness.js";
+export { resumeRunFromContinuationImpl } from "./replay-resume-recovery.js";
 export async function replayImpl(host, runId) {
     const run = await host.state.getRun(runId);
     if (!run)
@@ -23,707 +16,4 @@ export async function replayImpl(host, runId) {
         usage: await host.state.listUsage(runId)
     };
 }
-/** How long a claimed-but-unprogressed resume must sit before it may be reclaimed. */
-const RESUME_RECLAIM_STALE_MS = 5 * 60_000;
-/**
- * A resume claim was already taken, but resume claims are not leases: if the
- * claimer crashed between the claim and the run's status transition, the pause
- * would be permanently un-resumable. A run that is still parked and has not
- * been touched for RESUME_RECLAIM_STALE_MS has no live resumer (a live one
- * bumps `updatedAt` immediately and heartbeats after), so a retry generation
- * may be claimed. The reclaim bumps `updatedAt` first, keeping later retry
- * generations distinct if this one also dies.
- */
-async function reclaimStaleResume(host, run, baseKey, kind) {
-    const inProgress = new Error(`Run ${run.id} ${kind} resume is already in progress.`);
-    if (Date.parse(run.updatedAt) > Date.now() - RESUME_RECLAIM_STALE_MS)
-        throw inProgress;
-    const reclaimed = await host.state.reserveIdempotencyKey("resume", `${baseKey}:retry:${run.updatedAt}`, run.id);
-    if (!reclaimed)
-        throw inProgress;
-    await host.state.updateRun(run.id, {});
-}
-export async function resumeApprovalNowImpl(host, runId) {
-    host.boot();
-    await host.initializeInstrumentation();
-    let run = await host.state.getRun(runId);
-    if (!run)
-        throw new Error(`Run not found: ${runId}`);
-    if (run.status !== "waiting_for_approval")
-        throw new Error(`Run ${runId} is not waiting for approval.`);
-    const toolCall = (await host.state.listToolCalls(runId)).find((candidate) => candidate.status === "waiting_for_approval");
-    if (!toolCall)
-        throw new Error(`Run ${runId} has no approval-gated tool call to resume.`);
-    // Per-pause-generation claim: a double-clicked approval (or a concurrent
-    // replica) must execute the gated tool exactly once. `updatedAt` changes
-    // on every pause, so later legitimate pauses of the same tool call get a
-    // fresh key.
-    const resumeClaimed = await host.state.reserveIdempotencyKey("resume", `${run.id}:${toolCall.id}:${toolCall.updatedAt}`, run.id);
-    if (!resumeClaimed) {
-        await reclaimStaleResume(host, run, `${run.id}:${toolCall.id}:${toolCall.updatedAt}`, "approval");
-    }
-    if (parseQualifiedName(toolCall.toolName)) {
-        await host.state.appendEvent(run.id, "tool.approval_resumed", { toolCallId: toolCall.id, toolName: toolCall.toolName });
-        return resumeConnectionToolContinuation(host, run, toolCall);
-    }
-    const tool = runtimeToolsForSurface(surfaceForRun(host.manifest, run).tools)
-        .find((candidate) => candidate.name === toolCall.toolName);
-    if (!tool)
-        throw new Error(`Tool not found: ${toolCall.toolName}`);
-    const policyTool = applyCoreToolPolicy(tool, host.coreToolPolicy);
-    if (!policyTool)
-        throw new Error(`Core tool ${tool.name} is disabled by the Assembly Line core tool policy.`);
-    let currentRun = await host.state.updateRun(run.id, { status: "running" });
-    await host.state.appendEvent(currentRun.id, "tool.approval_resumed", { toolCallId: toolCall.id, toolName: policyTool.name });
-    const hookController = await host.ensureAgentHookController(currentRun);
-    const approvalCapabilities = hookController.current.declaration;
-    let bundle = await host.buildContextBundle({
-        message: "approval resume",
-        channel: "local",
-        capabilities: approvalCapabilities,
-        run: currentRun
-    });
-    bundle = {
-        ...bundle,
-        instructions: host.resolvedInstructionsForRun(currentRun, bundle, approvalCapabilities)
-    };
-    const sandboxHandle = host.createSandboxHandle(() => currentRun, (nextRun) => {
-        currentRun = nextRun;
-    }, () => bundle);
-    // The approved tool may run for minutes; without a heartbeat the orphan
-    // sweep would claim this run as crashed mid-execution.
-    const heartbeat = host.startRunHeartbeat(currentRun.id);
-    const outcome = await host
-        .executeToolWithRecord(currentRun, policyTool, toolCall, toolCall.input, sandboxHandle, true)
-        .finally(() => heartbeat.stop());
-    if (outcome.waitingForInput) {
-        return host.result(outcome.run, "Human input required.", false, true);
-    }
-    // Feed the approved tool's result back into the model loop so the agent
-    // can continue reasoning, instead of ending the run with raw tool output.
-    const resumable = await restoreMatchingContinuation(host, run.id, toolCall.toolName);
-    if (resumable) {
-        const toolResult = preparedResumeToolResult(toolCall.toolName, outcome.modelOutput, host.env);
-        return resumeHarnessLoopImpl(host, outcome.run, resumable.harness, resumable.restored, {
-            toolResult
-        });
-    }
-    // No usable continuation (pre-upgrade run or non-resumable harness):
-    // degrade to completing with the tool output, observably.
-    await host.state.appendEvent(run.id, "harness.resume_degraded", {
-        reason: "approval-resume-without-continuation",
-        toolCallId: toolCall.id,
-        toolName: toolCall.toolName
-    });
-    const response = typeof outcome.modelOutput === "string" ? outcome.modelOutput : JSON.stringify(outcome.modelOutput);
-    return host.completeRun(outcome.run, sandboxHandle, response, host.runDeliveryChannel(outcome.run));
-}
-/** Restore the latest continuation checkpoint if it matches the resolved harness. */
-async function restoreMatchingContinuation(host, runId, toolName) {
-    const restored = readHarnessContinuation(undefined, await host.listHydratedCheckpoints(runId), toolName);
-    if (!restored)
-        return undefined;
-    const harness = await host.resolveAgentHarness(restored.runtime.modelSpec);
-    if (restored.continuation.harness !== harness.id || restored.continuation.version !== harness.continuationVersion) {
-        await host.state.appendEvent(runId, "harness.continuation_mismatch", {
-            expectedHarness: harness.id,
-            expectedVersion: harness.continuationVersion,
-            storedHarness: restored.continuation.harness,
-            storedVersion: restored.continuation.version
-        });
-        return undefined;
-    }
-    return { harness, restored };
-}
-export async function completeConnectionAuthorizationCallbackImpl(host, callback) {
-    host.boot();
-    await host.initializeInstrumentation();
-    await host.ensureDynamicConnections();
-    const registry = new RuntimeConnectionRegistry({
-        connections: host.mergedConnections(),
-        config: host.env,
-        credentialBroker: host.credentialBroker,
-        fetch: host.fetch,
-        session: { channel: "authorization" },
-        grantStore: host.connectionGrantStore,
-        authorizationSessionStore: host.connectionAuthorizationSessionStore,
-        ...(host.connectionCallbackBaseUrl ? { callbackBaseUrl: host.connectionCallbackBaseUrl } : {}),
-        loadDefinition: async (connection) => host.loadConnectionDefinition(connection)
-    });
-    const session = await registry.completeAuthorization(callback);
-    if (!session.runId || !session.toolCallId) {
-        return {
-            status: 200,
-            body: {
-                ok: true,
-                connection: session.connectionName,
-                status: session.status
-            }
-        };
-    }
-    const run = await host.state.getRun(session.runId);
-    if (!run)
-        throw new Error(`Run not found for authorization callback: ${session.runId}`);
-    const toolCall = (await host.state.listToolCalls(run.id)).find((candidate) => candidate.id === session.toolCallId);
-    if (!toolCall)
-        throw new Error(`Tool call not found for authorization callback: ${session.toolCallId}`);
-    await host.state.appendEvent(run.id, "authorization.completed", {
-        connectionName: session.connectionName,
-        authorizationSessionId: session.id,
-        toolCallId: toolCall.id
-    });
-    if (runUsesChannelReplyForHumanInput(run)) {
-        if (run.status === "running" || run.status === "created") {
-            await host.state.appendEvent(run.id, "authorization.available_to_active_run", {
-                connectionName: session.connectionName,
-                authorizationSessionId: session.id,
-                toolCallId: toolCall.id
-            });
-            return {
-                status: 200,
-                body: {
-                    ok: true,
-                    connection: session.connectionName,
-                    runId: run.id,
-                    runStatus: run.status,
-                    continuation: "active_run"
-                }
-            };
-        }
-        if (run.status !== "completed" && run.status !== "waiting_for_connection") {
-            return {
-                status: 200,
-                body: {
-                    ok: true,
-                    connection: session.connectionName,
-                    runId: run.id,
-                    runStatus: run.status,
-                    continuation: "not_resumed"
-                }
-            };
-        }
-        const turn = authorizationContinuationTurn(run, session);
-        if (!turn) {
-            return {
-                status: 200,
-                body: {
-                    ok: true,
-                    connection: session.connectionName,
-                    runId: run.id,
-                    runStatus: run.status,
-                    continuation: "unavailable"
-                }
-            };
-        }
-        const queued = await host.enqueueConversationTurn({
-            turn,
-            idempotencyScope: "connection:authorization-continuation",
-            idempotencyKey: session.id
-        });
-        let detachedRun = run;
-        if (run.status === "waiting_for_connection") {
-            detachedRun = await host.state.updateRun(run.id, { status: "completed" });
-            await host.state.appendEvent(run.id, "run.completed", {
-                response: "",
-                detachedAuthorization: true
-            });
-        }
-        await host.state.appendEvent(run.id, "authorization.continuation_queued", {
-            connectionName: session.connectionName,
-            authorizationSessionId: session.id,
-            toolCallId: toolCall.id,
-            inserted: queued.inserted
-        });
-        return {
-            status: 202,
-            body: {
-                ok: true,
-                connection: session.connectionName,
-                runId: detachedRun.id,
-                runStatus: detachedRun.status,
-                continuation: queued.inserted ? "queued" : "already_queued"
-            }
-        };
-    }
-    // Protocol-owned waits resume in place. Claim this pause generation before
-    // executing the gated tool so replayed callbacks cannot repeat side effects.
-    const resumeClaimed = await host.state.reserveIdempotencyKey("resume", `${run.id}:${toolCall.id}:${toolCall.updatedAt}`, run.id);
-    if (!resumeClaimed) {
-        return {
-            status: 200,
-            body: {
-                ok: true,
-                connection: session.connectionName,
-                runId: run.id,
-                runStatus: run.status,
-                response: "Authorization already processed."
-            }
-        };
-    }
-    const runResult = await host.withRunAdmission(() => resumeConnectionToolContinuation(host, run, toolCall, session));
-    return {
-        status: 200,
-        body: {
-            ok: true,
-            connection: session.connectionName,
-            runId: runResult.run.id,
-            runStatus: runResult.run.status,
-            response: runResult.response ?? ""
-        },
-        runResult
-    };
-}
-function authorizationContinuationTurn(run, session) {
-    const channel = typeof run.input.channel === "string" ? run.input.channel : undefined;
-    const conversationId = typeof run.input.conversationId === "string" ? run.input.conversationId : undefined;
-    if (!channel || !conversationId)
-        return undefined;
-    const turn = {
-        eventId: `connection-authorization:${run.id}:${session.toolCallId ?? session.connectionName}`,
-        channel,
-        conversationId,
-        message: [
-            `Authorization for ${session.connectionName} completed.`,
-            `Continue the prior user request from conversation history and retry ${session.toolName ?? "the connection operation"} if it is still appropriate.`,
-            "Do not repeat side effects that already completed."
-        ].join(" ")
-    };
-    if (typeof run.input.userId === "string")
-        turn.userId = run.input.userId;
-    if (isJsonObject(run.input.principal))
-        turn.principal = run.input.principal;
-    if (isJsonObject(run.input.initiator))
-        turn.initiator = run.input.initiator;
-    const audience = normalizeAgentAudience(run.input.audience);
-    if (audience)
-        turn.audience = audience;
-    if (isJsonObject(run.input.delivery))
-        turn.delivery = run.input.delivery;
-    turn.metadata = {
-        ...(isJsonObject(run.input.metadata) ? run.input.metadata : {}),
-        assemblyLine: {
-            kind: "connection_authorization_continuation",
-            sourceRunId: run.id,
-            connectionName: session.connectionName
-        }
-    };
-    return turn;
-}
-export async function resumeInputNowImpl(host, runId, answer) {
-    host.boot();
-    await host.initializeInstrumentation();
-    const run = await host.state.getRun(runId);
-    if (!run)
-        throw new Error(`Run not found: ${runId}`);
-    if (run.status !== "waiting_for_input")
-        throw new Error(`Run ${runId} is not waiting for input.`);
-    // The pending question is the tool call parked by HumanInputRequired.
-    const toolCall = (await host.state.listToolCalls(runId)).find((candidate) => candidate.status === "waiting_for_approval");
-    // Per-pause-generation claim so a double-submitted answer resumes once.
-    const resumeClaimed = await host.state.reserveIdempotencyKey("resume", toolCall ? `${run.id}:${toolCall.id}:${toolCall.updatedAt}` : `${run.id}:input:${run.updatedAt}`, run.id);
-    if (!resumeClaimed) {
-        await reclaimStaleResume(host, run, toolCall ? `${run.id}:${toolCall.id}:${toolCall.updatedAt}` : `${run.id}:input:${run.updatedAt}`, "input");
-    }
-    let running = await host.state.updateRun(run.id, { status: "running" });
-    await host.state.appendEvent(run.id, "human_input.received", { answer });
-    if (toolCall) {
-        await host.state.updateToolCall(toolCall.id, {
-            status: "completed",
-            result: { answer },
-            modelOutput: { answer }
-        });
-    }
-    // Feed the human's answer back into the model loop as the pending tool's
-    // result so the agent that asked actually sees it and continues.
-    const toolName = toolCall?.toolName ?? "human_input";
-    const resumable = await restoreMatchingContinuation(host, run.id, toolName);
-    if (resumable) {
-        return resumeHarnessLoopImpl(host, running, resumable.harness, resumable.restored, {
-            toolResult: { toolName, output: { answer } }
-        });
-    }
-    await host.state.appendEvent(run.id, "harness.resume_degraded", {
-        reason: "input-resume-without-continuation",
-        toolCallId: toolCall?.id ?? null,
-        toolName
-    });
-    const hookController = await host.ensureAgentHookController(running);
-    const inputCapabilities = hookController.current.declaration;
-    let bundle = await host.buildContextBundle({
-        message: answer,
-        channel: "local",
-        capabilities: inputCapabilities,
-        run: running
-    });
-    bundle = {
-        ...bundle,
-        instructions: host.resolvedInstructionsForRun(running, bundle, inputCapabilities)
-    };
-    const sandboxHandle = host.createSandboxHandle(() => running, (nextRun) => {
-        running = nextRun;
-    }, () => bundle);
-    return host.completeRun(running, sandboxHandle, `Received input: ${answer}`, host.runDeliveryChannel(running));
-}
-export async function resumeSuspendedNowImpl(host, runId) {
-    host.boot();
-    await host.initializeInstrumentation();
-    await host.ensureDynamicConnections();
-    const run = await host.state.getRun(runId);
-    if (!run)
-        throw new Error(`Run not found: ${runId}`);
-    if (run.status !== "suspended")
-        throw new Error(`Run ${runId} is not suspended.`);
-    const resumeClaimed = await host.state.reserveIdempotencyKey("resume:suspended", `${run.id}:${run.updatedAt}`, run.id);
-    if (!resumeClaimed)
-        throw new Error(`Run ${runId} suspended resume is already in progress.`);
-    const restored = readHarnessContinuation(undefined, await host.listHydratedCheckpoints(runId));
-    if (!restored)
-        throw new Error(`Run ${runId} has no harness continuation to resume.`);
-    const harness = await host.resolveAgentHarness(restored.runtime.modelSpec);
-    if (restored.continuation.harness !== harness.id || restored.continuation.version !== harness.continuationVersion) {
-        await host.state.appendEvent(run.id, "harness.continuation_mismatch", {
-            expectedHarness: harness.id,
-            expectedVersion: harness.continuationVersion,
-            storedHarness: restored.continuation.harness,
-            storedVersion: restored.continuation.version
-        });
-        throw new Error(`Run ${runId} harness continuation is incompatible with the configured harness.`);
-    }
-    const running = await host.state.updateRun(run.id, { status: "running" });
-    await host.state.appendEvent(run.id, "run.resumed", { from: "suspended" });
-    return resumeHarnessLoopImpl(host, running, harness, restored, {});
-}
-async function resumeConnectionToolContinuation(host, run, toolCall, authorizationSession) {
-    const running = await host.state.updateRun(run.id, { status: "running" });
-    const hookController = await host.ensureAgentHookController(running);
-    const capabilities = hookController.current.declaration;
-    const fallbackChannel = typeof run.input.channel === "string" ? run.input.channel : "local";
-    const parsed = parseQualifiedName(toolCall.toolName);
-    if (parsed && !capabilities.connections.includes(parsed.connectionName)) {
-        throw new Error(`Connection ${parsed.connectionName} is no longer active on the current agent surface.`);
-    }
-    const sandboxCli = parsed
-        ? host.mergedConnections().find((connection) => connection.name === parsed.connectionName)?.protocol === "cli"
-        : false;
-    let sandboxRun = running;
-    let sandboxHandle;
-    if (sandboxCli) {
-        const bundle = await host.buildContextBundle({
-            message: "connection approval resume",
-            channel: fallbackChannel,
-            capabilities,
-            run: sandboxRun
-        });
-        sandboxHandle = host.createSandboxHandle(() => sandboxRun, (nextRun) => {
-            sandboxRun = nextRun;
-        }, () => bundle);
-    }
-    const registry = sandboxHandle
-        ? host.createConnectionRegistryForRun(running, fallbackChannel, sandboxHandle, new Set(capabilities.connections))
-        : authorizationSession
-            ? host.createConnectionRegistryForSession(authorizationSession)
-            : host.createConnectionRegistry(fallbackChannel);
-    // The resumed connection tool may run for minutes; without a heartbeat the
-    // orphan sweep would claim this run as crashed mid-execution.
-    const heartbeat = host.startRunHeartbeat(running.id);
-    const outcome = await host
-        .executeConnectionToolWithRecord(running, registry, toolCall.toolName, toolCall, toolCall.input)
-        .finally(() => heartbeat.stop());
-    sandboxRun = outcome.run;
-    if (outcome.waitingForConnection) {
-        await sandboxHandle?.dispose();
-        return host.result(outcome.run, await connectionAuthorizationPrompt(host.connectionAuthorizationSessionStore, outcome.authorizationSessionId, ""), false, false, true);
-    }
-    let restored = readHarnessContinuation(authorizationSession?.continuation, await host.listHydratedCheckpoints(run.id), toolCall.toolName);
-    const harness = await host.resolveAgentHarness(restored?.runtime.modelSpec);
-    if (restored && (restored.continuation.harness !== harness.id || restored.continuation.version !== harness.continuationVersion)) {
-        await host.state.appendEvent(run.id, "harness.continuation_mismatch", {
-            expectedHarness: harness.id,
-            expectedVersion: harness.continuationVersion,
-            storedHarness: restored.continuation.harness,
-            storedVersion: restored.continuation.version
-        });
-        restored = undefined;
-    }
-    if (!restored) {
-        const response = typeof outcome.modelOutput === "string" ? outcome.modelOutput : JSON.stringify(outcome.modelOutput ?? {});
-        if (sandboxHandle) {
-            return host.completeRun(sandboxRun, sandboxHandle, response, host.runDeliveryChannel(sandboxRun));
-        }
-        let fallbackRun = outcome.run;
-        const bundle = await host.buildContextBundle({
-            message: "connection resume",
-            channel: "local",
-            capabilities,
-            run: fallbackRun
-        });
-        const fallbackSandboxHandle = host.createSandboxHandle(() => fallbackRun, (nextRun) => {
-            fallbackRun = nextRun;
-        }, () => bundle);
-        return host.completeRun(fallbackRun, fallbackSandboxHandle, response, host.runDeliveryChannel(fallbackRun));
-    }
-    const toolResult = preparedResumeToolResult(toolCall.toolName, outcome.modelOutput, host.env);
-    await sandboxHandle?.dispose();
-    return resumeHarnessLoopImpl(host, outcome.run, harness, restored, { toolResult });
-}
-/** Resume an orphaned run in place from its latest persisted continuation checkpoint. */
-export async function resumeRunFromContinuationImpl(host, run, context) {
-    const checkpoints = await host.listHydratedCheckpoints(run.id);
-    let restored;
-    let checkpointCreatedAt;
-    for (let index = checkpoints.length - 1; index >= 0 && !restored; index -= 1) {
-        const checkpoint = checkpoints[index];
-        if (!checkpoint || checkpoint.name !== "harness.continuation")
-            continue;
-        restored = storedHarnessContinuation(checkpoint.data);
-        if (restored)
-            checkpointCreatedAt = checkpoint.createdAt;
-    }
-    if (!restored)
-        return undefined;
-    const harness = await host.resolveAgentHarness(restored.runtime.modelSpec);
-    if (restored.continuation.harness !== harness.id || restored.continuation.version !== harness.continuationVersion) {
-        await host.state.appendEvent(run.id, "harness.continuation_mismatch", {
-            expectedHarness: harness.id,
-            expectedVersion: harness.continuationVersion,
-            storedHarness: restored.continuation.harness,
-            storedVersion: restored.continuation.version
-        });
-        return undefined;
-    }
-    await host.state.appendEvent(run.id, "run.recovery_resume_attempted", { harness: harness.id });
-    const running = await host.state.updateRun(run.id, { status: "running" });
-    // If the continuation is parked on a tool that was mid-execution at crash
-    // time, resume with an explicit interrupted result so the model knows the
-    // side effects are indeterminate instead of silently re-requesting the
-    // tool. Otherwise resume from the iteration boundary as-is.
-    const pendingToolName = restored.runtime.pendingToolName;
-    const interrupted = context?.interruptedTools?.find((tool) => tool.toolName === pendingToolName);
-    const resume = interrupted
-        ? {
-            toolResult: {
-                toolName: interrupted.toolName,
-                output: {
-                    interrupted: true,
-                    error: "This tool execution was interrupted by a runtime restart; its side effects may or may not have happened. Verify before re-running side-effecting operations."
-                }
-            }
-        }
-        : {};
-    // Crash mid-tool-batch: the restored checkpoint predates the batch's tool
-    // calls, so surface their durable outcomes as a follow-up message rather
-    // than letting the model silently re-execute completed side effects.
-    // (The pause path above splices the pending tool directly and needs no report.)
-    if (!interrupted) {
-        const report = crashResumeReport(await host.state.listToolCalls(run.id), checkpointCreatedAt, context?.interruptedTools ?? []);
-        if (report)
-            resume.message = report;
-    }
-    try {
-        const result = await resumeHarnessLoopImpl(host, running, harness, restored, resume);
-        return result.run;
-    }
-    catch (error) {
-        // A continuation parked on a completed assistant turn (or empty context)
-        // has nothing to resume; the harness signals this by refusing to continue.
-        // That is not a resume failure — it means the run already produced its
-        // final response — so degrade to "no usable continuation" and let recovery
-        // deliver the completed response instead of logging a spurious failure.
-        const message = error instanceof Error ? error.message : String(error);
-        if (/continue from message role/iu.test(message) || /no messages in context/iu.test(message)) {
-            await host.state.appendEvent(run.id, "run.recovery_resume_unavailable", { reason: message });
-            return undefined;
-        }
-        throw error;
-    }
-}
-export async function resumeHarnessLoopImpl(host, run, harness, restored, resume) {
-    let currentRun = run;
-    const controller = await host.ensureAgentHookController(currentRun);
-    let appliedSnapshotId = controller.current.id;
-    const capabilities = controller.current.declaration;
-    let appliedPromptKey = capabilityPromptKey(capabilities);
-    harness = await host.resolveAgentHarness(capabilities.model);
-    if (restored.continuation.harness !== harness.id || restored.continuation.version !== harness.continuationVersion) {
-        throw new Error(`Recovered capabilities select harness "${harness.id}" v${harness.continuationVersion}, which cannot read the stored ${restored.continuation.harness} v${restored.continuation.version} continuation.`);
-    }
-    const activeSkills = new Set(capabilities.skills);
-    const rootSurface = currentRun.input.agentSurface === "root";
-    const defaultToolNames = new Set(capabilityToolNames(capabilities, rootSurface));
-    const discoveredConnectionTools = new Map();
-    let pause;
-    let bundle = await host.buildContextBundle({
-        message: "harness resume",
-        channel: restored.runtime.channel,
-        capabilities,
-        run: currentRun
-    });
-    bundle = {
-        ...bundle,
-        instructions: host.resolvedInstructionsForRun(currentRun, bundle, capabilities)
-    };
-    const sandboxHandle = host.createSandboxHandle(() => currentRun, (nextRun) => {
-        currentRun = nextRun;
-    }, () => bundle);
-    const connectionRegistry = host.createConnectionRegistryForRun(run, restored.runtime.channel, sandboxHandle, new Set(capabilities.connections));
-    const session = {
-        modelSpec: capabilities.model,
-        reasoning: capabilities.reasoning,
-        systemPrompt: capabilitySystemPrompt(bundle, capabilities.outputSchema, ""),
-        outputSchema: capabilities.outputSchema,
-        maxIterations: restored.runtime.maxIterations,
-        sessionId: restored.runtime.sessionId,
-        channel: restored.runtime.channel,
-        activeSkills,
-        defaultToolNames,
-        discoveredConnectionTools
-    };
-    if (restored.runtime.conversationId)
-        session.conversationId = restored.runtime.conversationId;
-    const loopState = {
-        run: () => currentRun,
-        setRun: (nextRun) => {
-            currentRun = nextRun;
-        },
-        sandboxHandle,
-        activeSkills,
-        defaultToolNames,
-        connectionRegistry,
-        discoveredConnectionTools,
-        exposedDeferredToolNames: new Set(),
-        setPause: (nextPause) => {
-            // First pause wins: in a tool batch where several calls pause, the
-            // run parks on the first one and later pauses must not repoint the
-            // resume bookkeeping mid-flight.
-            pause ??= nextPause;
-        }
-    };
-    const refreshCapabilities = async () => {
-        const snapshot = await controller.refreshIfDirty();
-        if (snapshot.id !== appliedSnapshotId) {
-            const nextSandbox = snapshot.declaration.sandbox ?? null;
-            const sandboxChanged = (currentRun.input.agentSandbox ?? null) !== nextSandbox;
-            if (sandboxChanged)
-                await sandboxHandle.reset();
-            currentRun = await host.state.updateRun(currentRun.id, {
-                input: {
-                    ...currentRun.input,
-                    model: snapshot.declaration.model,
-                    agentSandbox: nextSandbox,
-                    agentConnections: snapshot.declaration.connections,
-                    agentSubagents: snapshot.declaration.subagents
-                }
-            });
-            loopState.setRun(currentRun);
-            const nextPromptKey = capabilityPromptKey(snapshot.declaration);
-            const promptChanged = nextPromptKey !== appliedPromptKey;
-            if (promptChanged) {
-                bundle = await host.buildContextBundle({
-                    message: "harness resume",
-                    channel: restored.runtime.channel,
-                    capabilities: snapshot.declaration,
-                    run: currentRun
-                });
-                bundle = {
-                    ...bundle,
-                    instructions: host.resolvedInstructionsForRun(currentRun, bundle, snapshot.declaration)
-                };
-                appliedPromptKey = nextPromptKey;
-            }
-            appliedSnapshotId = snapshot.id;
-            replaceCapabilitySet(activeSkills, snapshot.declaration.skills);
-            replaceCapabilitySet(defaultToolNames, capabilityToolNames(snapshot.declaration, rootSurface));
-            loopState.connectionRegistry = host.createConnectionRegistryForRun(currentRun, restored.runtime.channel, sandboxHandle, new Set(snapshot.declaration.connections));
-            discoveredConnectionTools.clear();
-            loopState.exposedDeferredToolNames.clear();
-            session.modelSpec = snapshot.declaration.model;
-            session.reasoning = snapshot.declaration.reasoning;
-            session.outputSchema = snapshot.declaration.outputSchema;
-            if (promptChanged) {
-                session.systemPrompt = capabilitySystemPrompt(bundle, snapshot.declaration.outputSchema, "");
-            }
-        }
-        return {
-            modelSpec: session.modelSpec,
-            systemPrompt: session.systemPrompt,
-            ...(session.reasoning !== undefined ? { reasoning: session.reasoning } : {}),
-            ...(session.outputSchema !== undefined ? { outputSchema: session.outputSchema } : {})
-        };
-    };
-    const heartbeat = host.startRunHeartbeat(run.id);
-    let policy;
-    try {
-        policy = await host.executeHarnessTurn(harness, {
-            kind: "resume",
-            continuation: restored.continuation,
-            ...(resume.toolResult ? { toolResult: resume.toolResult } : {}),
-            ...(resume.message !== undefined ? { message: resume.message } : {})
-        }, session, loopState, true, refreshCapabilities);
-    }
-    finally {
-        heartbeat.stop();
-    }
-    const result = policy.result;
-    if (pause) {
-        await host.persistHarnessContinuation(pause.run.id, session, result.continuation, pause);
-        return host.result(pause.run, result.response, pause.waitingForApproval, pause.waitingForInput, pause.waitingForConnection);
-    }
-    if (policy.failed || policy.controlStopped) {
-        await sandboxHandle.dispose();
-        return host.result(currentRun, result.response, false, false, false);
-    }
-    const completed = await host.completeRun(currentRun, sandboxHandle, result.response, restored.runtime.channel, undefined, restored.runtime.conversationId);
-    if (policy.output !== undefined)
-        completed.output = policy.output;
-    // Keep the conversation's transcript pointer current: a paused turn that
-    // completed here would otherwise leave the pointer at the pre-pause run and
-    // the next conversation turn would resume a transcript missing this one.
-    if (restored.runtime.conversationId && result.continuation && !policy.failed && !policy.controlStopped) {
-        try {
-            await persistConversationTranscriptImpl({
-                state: host.state,
-                createCheckpoint: (input) => host.createCheckpoint(input),
-                hydrateCheckpointData: (data) => host.hydrateCheckpointData(data)
-            }, {
-                runId: run.id,
-                conversationId: restored.runtime.conversationId,
-                session,
-                continuation: result.continuation,
-                ...(session.lastInputTokens !== undefined ? { lastInputTokens: session.lastInputTokens } : {})
-            });
-        }
-        catch {
-            // Best-effort acceleration layer; the durable history is unaffected.
-        }
-    }
-    return completed;
-}
-function preparedResumeToolResult(toolName, output, env) {
-    const prepared = prepareToolModelOutput(output, env);
-    const result = {
-        toolName,
-        output: prepared.output
-    };
-    if (prepared.media.length > 0)
-        result.media = prepared.media;
-    return result;
-}
-function readHarnessContinuation(stored, checkpoints, toolName) {
-    if (stored)
-        return storedHarnessContinuation(stored);
-    for (let index = checkpoints.length - 1; index >= 0; index -= 1) {
-        const checkpoint = checkpoints[index];
-        if (!checkpoint)
-            continue;
-        if (checkpoint.name !== "harness.continuation")
-            continue;
-        const restored = storedHarnessContinuation(checkpoint.data);
-        if (!restored)
-            continue;
-        const pendingToolName = restored.runtime.pendingToolName;
-        if (toolName === undefined || typeof pendingToolName !== "string" || pendingToolName === toolName)
-            return restored;
-    }
-    return undefined;
-}
 //# sourceMappingURL=replay-resume.js.map