@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/runtime/automations/step-evidence-inputs.d.ts

@@ -0,0 +1,22 @@
+import type { AutomationRevision } from "./definition-contracts.js";
+import type { AutomationResultStore } from "./result-store.js";
+import type { AutomationExecutionRecord, AutomationJournalState } from "./storage-records.js";
+import { type AutomationStepNode } from "./step-evidence-effects.js";
+export type AutomationStepInputEvidence = Readonly<{
+    name: string;
+    source: string;
+    status: "reconstructed" | "metadata" | "unavailable";
+    preview?: Readonly<{
+        value: string;
+        truncated: boolean;
+        totalCharacters: number;
+    }>;
+}>;
+export declare function readAutomationStepInputs(input: {
+    state: AutomationJournalState;
+    results: AutomationResultStore;
+    runId: string;
+    definition: AutomationRevision;
+    execution: AutomationExecutionRecord | undefined;
+    node: AutomationStepNode;
+}): Promise<AutomationStepInputEvidence[]>;

package/dist/src/runtime/automations/step-evidence-inputs.js

@@ -0,0 +1,105 @@
+import { resolveAutomationBinding } from "./binding-resolution.js";
+import { findAutomationStep } from "./step-evidence-effects.js";
+import { compileAutomationGraph } from "./graph-validation.js";
+import { projectAutomationBranchResults } from "./branch-result-projection.js";
+const INPUT_PREVIEW_CHARACTERS = 2_000;
+function preview(value) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+    return { value: serialized.slice(0, INPUT_PREVIEW_CHARACTERS),
+        truncated: serialized.length > INPUT_PREVIEW_CHARACTERS,
+        totalCharacters: serialized.length };
+}
+function sourceLabel(binding, definition) {
+    switch (binding.kind) {
+        case "literal": return "Configured value";
+        case "run_input": return `Run input · ${binding.input}`;
+        case "run_file": return `Run output file · ${binding.fileName}`;
+        case "source_files": return "Selected source files";
+        case "source_file": return `Selected file ${binding.index + 1} · ${binding.field.replaceAll("_", " ")}`;
+        case "node_result": {
+            const source = findAutomationStep(definition.body, binding.nodeId);
+            return `${source?.title || "Earlier step"} · ${binding.select}${binding.pointer || ""}`;
+        }
+        case "branch_results": return "Parallel branch results";
+    }
+}
+function bindingsFor(node) {
+    if (node.kind === "agent")
+        return Object.entries(node.inputs)
+            .map(([name, binding]) => [`Input · ${name}`, binding]);
+    return [
+        ...Object.entries(node.controls).map(([name, binding]) => [`Control · ${name}`, binding]),
+        ...(node.payload ? [["Payload", node.payload]] : []),
+    ];
+}
+function selectedInputMetadata(state, execution) {
+    return (execution?.inputIds ?? []).flatMap((id) => {
+        const record = state.inputs.find((item) => item.id === id &&
+            item.automationId === execution?.automationId);
+        if (!record)
+            return [];
+        return [{ originalPath: record.canonicalPath, version: record.contentVersion,
+                sizeBytes: record.snapshot?.sizeBytes ?? null }];
+    });
+}
+async function settledOutputs(input) {
+    const values = new Map();
+    for (const step of input.execution?.nodes ?? []) {
+        if (!input.neededIds.has(step.nodeId))
+            continue;
+        if (step.status === "pending" || step.status === "ready" || step.status === "running")
+            continue;
+        const record = input.state.results.find((item) => item.id === step.resultRef &&
+            item.runId === input.runId && item.nodeId === step.nodeId && item.kind === "node_output");
+        const saved = record ? await input.results.read(record) : null;
+        if (saved !== null && (typeof saved !== "object" || Array.isArray(saved)))
+            throw new Error("automation_result_invalid");
+        const value = saved;
+        values.set(step.nodeId, {
+            status: step.status,
+            ...(typeof value?.text === "string" ? { text: value.text } : {}),
+            ...(value?.data !== undefined ? { data: value.data } : {}),
+            ...(record ? { resultRef: record.id } : {}),
+        });
+    }
+    return values;
+}
+function sourceFileEvidence(binding, metadata) {
+    if (binding.kind === "source_files")
+        return { status: "metadata", preview: preview(metadata) };
+    const selected = metadata[binding.index];
+    if (!selected || binding.field === "snapshot_path")
+        return { status: "unavailable" };
+    return { status: "metadata", preview: preview(binding.field === "original_path"
+            ? selected.originalPath : selected.version) };
+}
+export async function readAutomationStepInputs(input) {
+    const bindings = bindingsFor(input.node);
+    if (bindings.length === 0)
+        return [];
+    const compiled = compileAutomationGraph(input.definition);
+    const groups = compiled.ok ? compiled.graph.parallelGroups : [];
+    const neededIds = new Set();
+    for (const [, binding] of bindings) {
+        if (binding.kind === "node_result")
+            neededIds.add(binding.nodeId);
+        if (binding.kind === "branch_results")
+            groups.find((group) => group.id === binding.parallelNodeId)?.tailNodeIds
+                .forEach((id) => neededIds.add(id));
+    }
+    const nodeResults = await settledOutputs({ ...input, neededIds });
+    const branchResults = projectAutomationBranchResults(groups, nodeResults);
+    const metadata = selectedInputMetadata(input.state, input.execution);
+    return bindings.map(([name, binding]) => {
+        const source = sourceLabel(binding, input.definition);
+        if (binding.kind === "source_file" || binding.kind === "source_files")
+            return { name, source, ...sourceFileEvidence(binding, metadata) };
+        const resolved = resolveAutomationBinding(binding, {
+            runId: input.runId, runInputs: input.definition.inputs,
+            sourceFiles: [], nodeResults, branchResults,
+        });
+        if (!resolved.ok)
+            return { name, source, status: "unavailable" };
+        return { name, source, status: "reconstructed", preview: preview(resolved.value) };
+    });
+}

package/dist/src/runtime/automations/step-evidence-output.d.ts

@@ -0,0 +1,17 @@
+export type AutomationOutputPart = Readonly<{
+    value: string;
+    truncated: boolean;
+    totalCharacters: number;
+}>;
+export type AutomationSavedOutput = Readonly<{
+    text?: AutomationOutputPart;
+    data?: AutomationOutputPart;
+    full: boolean;
+}>;
+export type AutomationSavedOutcome = Readonly<{
+    kind: "rejected" | "uncertain";
+    errorCode?: string;
+}>;
+/** Direct-tool rejections and uncertain results intentionally have no output text. */
+export declare function projectAutomationSavedOutput(value: unknown, full: boolean): AutomationSavedOutput | null;
+export declare function projectAutomationSavedOutcome(value: unknown): AutomationSavedOutcome | undefined;

package/dist/src/runtime/automations/step-evidence-output.js

@@ -0,0 +1,43 @@
+const OUTPUT_PREVIEW_CHARACTERS = 4_000;
+function projectPart(value, full) {
+    return {
+        value: full ? value : value.slice(0, OUTPUT_PREVIEW_CHARACTERS),
+        truncated: !full && value.length > OUTPUT_PREVIEW_CHARACTERS,
+        totalCharacters: value.length,
+    };
+}
+/** Direct-tool rejections and uncertain results intentionally have no output text. */
+export function projectAutomationSavedOutput(value, full) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("automation_result_invalid");
+    const saved = value;
+    if (saved.text === undefined && saved.data === undefined)
+        return null;
+    if (saved.text !== undefined && typeof saved.text !== "string")
+        throw new Error("automation_result_invalid");
+    let structured;
+    if (saved.data !== undefined) {
+        try {
+            structured = JSON.stringify(saved.data, null, 2);
+        }
+        catch {
+            throw new Error("automation_result_invalid");
+        }
+        if (typeof structured !== "string")
+            throw new Error("automation_result_invalid");
+    }
+    return {
+        ...(typeof saved.text === "string" ? { text: projectPart(saved.text, full) } : {}),
+        ...(structured !== undefined ? { data: projectPart(structured, full) } : {}),
+        full,
+    };
+}
+export function projectAutomationSavedOutcome(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const saved = value;
+    if (saved.kind !== "rejected" && saved.kind !== "uncertain")
+        return undefined;
+    return { kind: saved.kind,
+        ...(typeof saved.code === "string" ? { errorCode: saved.code } : {}) };
+}

package/dist/src/runtime/automations/step-evidence.d.ts

@@ -0,0 +1,24 @@
+import type { SchedulerService } from "../scheduler/contracts.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationResultStore } from "./result-store.js";
+import { type AutomationEffectEvidence } from "./step-evidence-effects.js";
+import { type AutomationSavedOutcome, type AutomationSavedOutput } from "./step-evidence-output.js";
+import { type AutomationStepInputEvidence } from "./step-evidence-inputs.js";
+export type AutomationStepEvidence = Readonly<{
+    runId: string;
+    nodeId: string;
+    title: string;
+    availability: "available" | "expired";
+    stepStatus: string;
+    output: AutomationSavedOutput | null;
+    savedOutcome?: AutomationSavedOutcome;
+    inputs: readonly AutomationStepInputEvidence[];
+    effects: readonly AutomationEffectEvidence[];
+}>;
+export declare function createAutomationStepEvidenceReader(options: {
+    scheduler: Pick<SchedulerService, "getAutomationRun">;
+    persistence: AutomationPersistence;
+    results: AutomationResultStore;
+}): {
+    get: (runId: string, nodeId: string, full?: boolean) => Promise<AutomationStepEvidence>;
+};

package/dist/src/runtime/automations/step-evidence.js

@@ -0,0 +1,53 @@
+import { findAutomationStep, readAutomationStepEffects, } from "./step-evidence-effects.js";
+import { projectAutomationSavedOutcome, projectAutomationSavedOutput, } from "./step-evidence-output.js";
+import { readAutomationStepInputs } from "./step-evidence-inputs.js";
+function requireOutput(state, runId, nodeId, resultId) {
+    const record = state.results.find((item) => item.id === resultId && item.runId === runId &&
+        item.nodeId === nodeId && item.kind === "node_output");
+    if (!record)
+        throw new Error("automation_result_ref_invalid");
+    return record;
+}
+export function createAutomationStepEvidenceReader(options) {
+    async function get(runId, nodeId, full = false) {
+        const run = await options.scheduler.getAutomationRun(runId);
+        if (!run)
+            throw new Error("automation_run_not_found");
+        const state = await options.persistence.read();
+        const definition = state.definitions.find((item) => item.automationId === run.target.automationId &&
+            item.revision === run.target.definitionRevision)?.definition;
+        if (!definition)
+            throw new Error("automation_definition_not_found");
+        const node = findAutomationStep(definition.body, nodeId);
+        if (!node)
+            throw new Error("automation_node_not_found");
+        const execution = state.executions.find((item) => item.id === runId &&
+            item.automationId === run.target.automationId &&
+            item.definitionRevision === run.target.definitionRevision);
+        const step = execution?.nodes.find((item) => item.nodeId === nodeId);
+        const base = { runId, nodeId, title: node.title, stepStatus: step?.status ?? "pending" };
+        if (execution?.detailsExpiredAt)
+            return { ...base, availability: "expired", output: null, inputs: [], effects: [] };
+        try {
+            const saved = step?.resultRef
+                ? await options.results.read(requireOutput(state, runId, nodeId, step.resultRef)) : null;
+            const output = saved === null ? null : projectAutomationSavedOutput(saved, full);
+            const savedOutcome = node.kind === "tool" ? projectAutomationSavedOutcome(saved) : undefined;
+            const [effects, inputs] = await Promise.all([
+                readAutomationStepEffects({ state, results: options.results, runId, node }),
+                readAutomationStepInputs({ state, results: options.results, runId, definition, execution,
+                    node }),
+            ]);
+            return { ...base, availability: "available", output, inputs, effects,
+                ...(savedOutcome ? { savedOutcome } : {}) };
+        }
+        catch (error) {
+            // Retention marks expiry before deleting the corresponding bytes.
+            const latest = await options.persistence.read();
+            if (latest.executions.some((item) => item.id === runId && item.detailsExpiredAt))
+                return { ...base, availability: "expired", output: null, inputs: [], effects: [] };
+            throw error;
+        }
+    }
+    return { get };
+}

package/dist/src/runtime/automations/step-interruption.d.ts

@@ -0,0 +1,3 @@
+import type { AutomationStepCompletion } from "./graph-executor.js";
+/** Normalize definite abort receipts before their durable node settlement. */
+export declare function normalizeAutomationStepInterruption(completion: AutomationStepCompletion, signal: AbortSignal): AutomationStepCompletion;

package/dist/src/runtime/automations/step-interruption.js

@@ -0,0 +1,26 @@
+/** Normalize definite abort receipts before their durable node settlement. */
+export function normalizeAutomationStepInterruption(completion, signal) {
+    if (completion.uncertain)
+        return completion;
+    if (!signal.aborted)
+        return completion;
+    const durationFailureCode = automationDurationFailureCode(signal.reason);
+    if (durationFailureCode && completion.status === "cancelled")
+        return { status: "failed", errorCode: durationFailureCode };
+    if (durationFailureCode)
+        return completion;
+    if (completion.status !== "failed" && completion.status !== "skipped")
+        return completion;
+    if (completion.errorCode !== "request_aborted")
+        return completion;
+    return { status: "cancelled", errorCode: "automation_run_stopped" };
+}
+function automationDurationFailureCode(reason) {
+    if (!(reason instanceof Error))
+        return undefined;
+    if (reason.message === "automation_run_duration_exceeded")
+        return reason.message;
+    if (reason.message === "automation_budget_exhausted")
+        return reason.message;
+    return undefined;
+}

package/dist/src/runtime/automations/step-runner.d.ts

@@ -0,0 +1,57 @@
+import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
+import type { ToolRegistry, RuntimeConfig } from "../ports.js";
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+import type { CapabilityJsonValue } from "../orchestration/capability-adapters/result.js";
+import type { CompiledAutomationGraph, CompiledAutomationStep } from "./graph-validation.js";
+import type { AutomationRevision, SourceFileSnapshot } from "./definition-contracts.js";
+import type { AutomationStepCompletion } from "./graph-executor.js";
+import type { AutomationNodeTransactions } from "./node-transactions.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationGrantManager } from "./permission-grants.js";
+import type { AutomationResultStore } from "./result-store.js";
+import type { AutomationJournalState } from "./storage-records.js";
+import type { AutomationToolLifetimes } from "./tool-lifetimes.js";
+type SourceManifest = Readonly<{
+    files: readonly SourceFileSnapshot[];
+    attachments: readonly ToolRequestAttachment[];
+}>;
+export declare function resolveAutomationSourceManifest(input: {
+    inputIds: readonly string[];
+    state: AutomationJournalState;
+    definition: AutomationRevision;
+    attachments: RuntimeAttachmentStore;
+}): Promise<SourceManifest>;
+/** Resolves only committed producer outputs and runs one selected step. */
+export declare function createAutomationStepRunner(options: {
+    runId: string;
+    automationId: string;
+    definition: AutomationRevision;
+    graph: CompiledAutomationGraph;
+    config: RuntimeConfig;
+    tools: ToolRegistry;
+    attachments: RuntimeAttachmentStore;
+    persistence: AutomationPersistence;
+    results: AutomationResultStore;
+    transactions: AutomationNodeTransactions;
+    toolLifetimes: AutomationToolLifetimes;
+    grants: Pick<AutomationGrantManager, "get">;
+    executeAgent?(input: {
+        step: CompiledAutomationStep;
+        inputs: Readonly<Record<string, CapabilityJsonValue>>;
+        sourceAttachments: readonly ToolRequestAttachment[];
+        signal: AbortSignal;
+    }): Promise<AutomationStepCompletion>;
+}): {
+    run: (step: CompiledAutomationStep, signal: AbortSignal) => Promise<AutomationStepCompletion>;
+    saveNodeOutput: (nodeId: string, value: unknown) => Promise<Readonly<{
+        id: string;
+        runId: string;
+        nodeId?: string;
+        kind: "node_output" | "effect_receipt" | "report" | "artifact";
+        storageRef: string;
+        digest: string;
+        sizeBytes: number;
+        createdAt: string;
+    }>>;
+};
+export {};

package/dist/src/runtime/automations/step-runner.js

@@ -0,0 +1,278 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { hasToolAbortReceipt } from "../../capabilities/tool-interruption.js";
+import { resolveAutomationBinding } from "./binding-resolution.js";
+import { executeAutomationToolStep } from "./tool-step-executor.js";
+import { remainingAutomationResultBytes } from "./result-capacity.js";
+import { normalizeAutomationStepInterruption } from "./step-interruption.js";
+import { sourceAttachmentsForNode } from "./source-attachment-access.js";
+import { projectAutomationBranchResults } from "./branch-result-projection.js";
+import { publishAutomationResult } from "./result-publication.js";
+function stepFailure(step, code, uncertain = false) {
+    return {
+        status: uncertain || step.node.onFailure === "stop" ? "failed" : "skipped",
+        errorCode: code,
+        ...(uncertain ? { uncertain: true } : {}),
+    };
+}
+export async function resolveAutomationSourceManifest(input) {
+    const source = input.definition.source;
+    if (input.inputIds.length > (source?.maxBatchFiles ?? 0) ||
+        (source?.mode === "per_file" && input.inputIds.length > 1))
+        throw new Error("automation_source_unavailable");
+    const files = [];
+    const attachments = [];
+    const seen = new Set();
+    for (const id of input.inputIds) {
+        if (seen.has(id))
+            throw new Error("automation_source_unavailable");
+        seen.add(id);
+        const item = input.state.inputs.find((candidate) => candidate.id === id);
+        if (!item?.snapshot || item.automationId !== input.definition.automationId ||
+            item.sourceId !== source?.sourceId ||
+            item.contentVersion !== item.snapshot.contentVersion)
+            throw new Error("automation_source_unavailable");
+        let resolved;
+        let bytes;
+        try {
+            resolved = await input.attachments.resolveAttachment(item.snapshot.attachment);
+            bytes = await readFile(resolved.absolutePath);
+        }
+        catch {
+            throw new Error("automation_source_unavailable");
+        }
+        if (bytes.byteLength !== item.snapshot.sizeBytes ||
+            createHash("sha256").update(bytes).digest("hex") !== item.contentVersion)
+            throw new Error("automation_source_changed");
+        files.push({
+            inputId: item.id,
+            sourceId: item.sourceId,
+            originalPath: item.canonicalPath,
+            snapshotPath: resolved.absolutePath,
+            version: item.contentVersion,
+            sizeBytes: item.snapshot.sizeBytes,
+        });
+        attachments.push({
+            id: item.id,
+            kind: resolved.metadata.kind,
+            mimeType: resolved.metadata.mimeType,
+            absolutePath: resolved.absolutePath,
+            ...(resolved.metadata.name ? { name: resolved.metadata.name } : {}),
+            size: item.snapshot.sizeBytes,
+        });
+    }
+    return { files, attachments };
+}
+async function bindingContext(input) {
+    const state = await input.persistence.read();
+    const execution = state.executions.find((candidate) => candidate.id === input.runId);
+    if (!execution)
+        throw new Error("automation_run_not_found");
+    if (execution.automationId !== input.definition.automationId ||
+        execution.definitionRevision !== input.definition.revision)
+        throw new Error("automation_source_unavailable");
+    const settled = new Map();
+    for (const node of execution.nodes) {
+        if (node.status === "pending" || node.status === "ready" || node.status === "running")
+            continue;
+        const record = state.results.find((candidate) => candidate.id === node.resultRef &&
+            candidate.runId === input.runId && candidate.nodeId === node.nodeId);
+        const value = record ? await input.results.read(record) : null;
+        const projected = value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : {};
+        settled.set(node.nodeId, {
+            status: node.status,
+            ...(typeof projected.text === "string" ? { text: projected.text } : {}),
+            ...(projected.data !== undefined ? { data: projected.data } : {}),
+            ...(record ? { resultRef: record.id } : {}),
+        });
+    }
+    const branchResults = projectAutomationBranchResults(input.graph.parallelGroups, settled);
+    const manifest = await input.sourceManifest();
+    return {
+        runId: input.runId,
+        runInputs: input.definition.inputs,
+        sourceFiles: manifest.files,
+        sourceAttachments: manifest.attachments,
+        nodeResults: settled,
+        branchResults,
+    };
+}
+function resolveValue(binding, context) {
+    const value = resolveAutomationBinding(binding, context);
+    if (!value.ok)
+        throw new Error(value.code);
+    return value.value;
+}
+function resolveValues(bindings, context) {
+    return Object.fromEntries(Object.entries(bindings).map(([key, value]) => [key, resolveValue(value, context)]));
+}
+/** Resolves only committed producer outputs and runs one selected step. */
+export function createAutomationStepRunner(options) {
+    let sourceManifest;
+    let attachmentOperations;
+    const loadAttachmentOperations = () => {
+        if (!attachmentOperations)
+            attachmentOperations = (async () => {
+                const registry = await options.tools.prepareRequest?.() ?? options.tools;
+                return (registry.listNormalInvocations?.() ?? []).flatMap((registration) => registration.contract.operations.map((operation) => ({
+                    toolName: registration.toolName,
+                    operationId: operation.operationId,
+                    contractVersion: registration.contract.version,
+                    ...(operation.attachmentInput ? { attachmentInput: operation.attachmentInput } : {}),
+                })));
+            })();
+        return attachmentOperations;
+    };
+    const loadSourceManifest = () => {
+        if (!sourceManifest)
+            sourceManifest = options.persistence.read().then((state) => {
+                const execution = state.executions.find((candidate) => candidate.id === options.runId);
+                if (!execution || execution.automationId !== options.automationId ||
+                    execution.definitionRevision !== options.definition.revision)
+                    throw new Error("automation_source_unavailable");
+                return resolveAutomationSourceManifest({
+                    inputIds: execution.inputIds, state, definition: options.definition,
+                    attachments: options.attachments,
+                });
+            });
+        return sourceManifest;
+    };
+    async function saveNodeOutput(nodeId, value) {
+        const state = await options.persistence.read();
+        const used = state.results.filter((item) => item.runId === options.runId)
+            .reduce((sum, item) => sum + item.sizeBytes, 0);
+        return options.results.save({
+            runId: options.runId,
+            nodeId,
+            kind: "node_output",
+            value,
+            maxBytes: Math.min(options.definition.limits.maxStoredArtifactBytes - used, remainingAutomationResultBytes(state)),
+        });
+    }
+    async function runTool(step, signal, context) {
+        if (step.node.kind !== "tool")
+            throw new Error("automation_node_kind_invalid");
+        const grant = await options.grants.get(options.automationId);
+        if (!grant)
+            return stepFailure(step, "automation_operation_unavailable");
+        let controls;
+        let payload;
+        let sourceAttachments;
+        try {
+            controls = resolveValues(step.node.controls, context);
+            sourceAttachments = sourceAttachmentsForNode({ node: step.node, ...context,
+                operations: await loadAttachmentOperations() });
+            if (step.node.payload) {
+                const value = resolveValue(step.node.payload, context);
+                payload = typeof value === "string" ? value : JSON.stringify(value);
+            }
+        }
+        catch (error) {
+            return stepFailure(step, error instanceof Error ? error.message : "automation_dependency_missing");
+        }
+        let completion;
+        const result = await executeAutomationToolStep({
+            node: step.node,
+            controls,
+            sourceAttachments,
+            ...(payload !== undefined ? { payload } : {}),
+            registry: options.tools,
+            environmentId: options.config.runtimeId,
+            automationId: options.automationId,
+            capturedGrant: grant,
+            currentGrant: () => options.grants.get(options.automationId),
+            workingDirectory: options.definition.workingDirectory ?? options.config.paths.agentWorkDir,
+            requestId: `automation:${options.runId}:${step.id}`,
+            abortSignal: signal,
+            onUnderlyingSettlement: (invocationId, settled) => options.toolLifetimes.observe(options.runId, invocationId, settled),
+            invokeTool: (invoke) => options.toolLifetimes.runInvocation(options.runId, signal, invoke),
+            holdEffectAdmission: () => options.toolLifetimes.holdEffectAdmission(options.runId, signal),
+            beforeEffect: async (attempt) => {
+                await options.transactions.recordAttempt({
+                    runId: options.runId,
+                    nodeId: step.id,
+                    invocationId: attempt.invocationId,
+                    fingerprint: attempt.fingerprint,
+                    maxToolCalls: options.definition.limits.maxToolCallsPerRun,
+                });
+            },
+            afterEffect: async (attempt, outcome, notDispatched) => {
+                const settledCompletion = normalizeAutomationStepInterruption(toolCompletion(step, outcome), signal);
+                completion = settledCompletion;
+                const stored = await saveNodeOutput(step.id, toolResultValue(outcome));
+                await publishAutomationResult({ ...options, record: stored,
+                    publish: () => options.transactions.settleNode({
+                        runId: options.runId,
+                        nodeId: step.id,
+                        status: settledCompletion.status,
+                        attemptId: attempt.invocationId,
+                        notDispatched,
+                        result: stored,
+                        maxStoredArtifactBytes: options.definition.limits.maxStoredArtifactBytes,
+                        ...(settledCompletion.errorCode ? { errorCode: settledCompletion.errorCode } : {}),
+                        ...(settledCompletion.uncertain ? { uncertain: true } : {}),
+                    }),
+                });
+            },
+        });
+        return completion ?? normalizeAutomationStepInterruption(toolCompletion(step, result), signal);
+    }
+    async function run(step, signal) {
+        let context;
+        try {
+            context = await bindingContext({
+                runId: options.runId, definition: options.definition, graph: options.graph,
+                persistence: options.persistence, results: options.results,
+                attachments: options.attachments,
+                sourceManifest: loadSourceManifest,
+            });
+        }
+        catch (error) {
+            return stepFailure(step, error instanceof Error ? error.message : "automation_source_unavailable");
+        }
+        if (step.node.kind === "tool")
+            return runTool(step, signal, context);
+        if (!options.executeAgent)
+            return stepFailure(step, "automation_agent_unavailable");
+        let inputs;
+        let sourceAttachments;
+        try {
+            inputs = resolveValues(step.node.inputs, context);
+            sourceAttachments = sourceAttachmentsForNode({ node: step.node, ...context,
+                operations: await loadAttachmentOperations() });
+        }
+        catch (error) {
+            return stepFailure(step, error instanceof Error ? error.message : "automation_dependency_missing");
+        }
+        return options.executeAgent({ step, inputs, sourceAttachments, signal });
+    }
+    return { run, saveNodeOutput };
+}
+function toolCompletion(step, result) {
+    if (result.kind === "uncertain")
+        return stepFailure(step, result.code, true);
+    if (result.kind === "rejected")
+        return stepFailure(step, result.code);
+    if (hasToolAbortReceipt(result.result))
+        return stepFailure(step, "request_aborted");
+    return result.ok ? { status: "succeeded" } :
+        stepFailure(step, result.errorCode ?? result.result.errorCode ?? "automation_tool_failed");
+}
+function toolResultValue(result) {
+    if (result.kind !== "settled")
+        return { kind: result.kind, code: result.code, message: result.message };
+    return {
+        text: result.result.output,
+        ...(result.result.data !== undefined ? { data: result.result.data } : {}),
+        receipt: {
+            ok: result.ok,
+            effect: result.effect,
+            ...(result.result.interruption ? { interruption: result.result.interruption } : {}),
+            completionActions: result.completionActions,
+            ...((result.errorCode ?? result.result.errorCode)
+                ? { errorCode: result.errorCode ?? result.result.errorCode } : {}),
+        },
+    };
+}