@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/automations/limits.js

@@ -0,0 +1,41 @@
+export const AUTOMATION_GRAPH_LIMITS = Object.freeze({
+    executableNodes: 64,
+    branchesPerGroup: 8,
+    nestingDepth: 4,
+    sourceFilesPerBatch: 100,
+    sourceBatchBytes: 32 * 1024 * 1024,
+    eligibleInputRecords: 1_000,
+    inputMetadataBytes: 32 * 1024 * 1024,
+});
+export const AUTOMATION_OUTPUT_SCHEMA_LIMITS = Object.freeze({
+    maxProperties: 16,
+    maxStringLength: 4_096,
+    maxArrayItems: 64,
+});
+export const DEFAULT_AUTOMATION_LIMITS = Object.freeze({
+    maxConcurrentNodes: 2,
+    maxModelCallsPerRun: 24,
+    maxToolCallsPerRun: 64,
+    maxRunDurationMs: 30 * 60 * 1_000,
+    maxRunsPerDay: 24,
+    maxStoredArtifactBytes: 256 * 1024 * 1024,
+    stopReportDeadlineMs: 30 * 1_000,
+});
+export function validateAutomationLimits(limits) {
+    const issues = [];
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            issues.push(`${name} must be a positive safe integer`);
+        }
+    }
+    if (limits.maxConcurrentNodes > AUTOMATION_GRAPH_LIMITS.executableNodes) {
+        issues.push("maxConcurrentNodes exceeds the graph node ceiling");
+    }
+    if (limits.stopReportDeadlineMs > limits.maxRunDurationMs) {
+        issues.push("stopReportDeadlineMs exceeds maxRunDurationMs");
+    }
+    if (limits.maxRunDurationMs + limits.stopReportDeadlineMs > 2_147_483_647) {
+        issues.push("The run and stop deadlines exceed the supported timer range");
+    }
+    return issues;
+}

package/dist/src/runtime/automations/model-capacity.d.ts

@@ -0,0 +1,9 @@
+import type { ModelGatewayPolicyConfig } from "../../model-gateway/types.js";
+import type { ModelGatewayInvokeParams, ModelGatewayRawInvokeParams } from "../ports.js";
+type Invocation = ModelGatewayInvokeParams | ModelGatewayRawInvokeParams;
+export type AutomationModelCapacity = Readonly<{
+    withInvocation: <T>(params: Invocation, fallbackPolicy: ModelGatewayPolicyConfig | undefined, invoke: () => Promise<T>) => Promise<T>;
+}>;
+/** Capacity is scoped to one Runtime environment, never to a single Agent node. */
+export declare function createAutomationModelCapacity(): AutomationModelCapacity;
+export {};

package/dist/src/runtime/automations/model-capacity.js

@@ -0,0 +1,67 @@
+import { resolveModelInvocation } from "../../model-gateway/invocation-policy.js";
+/** Capacity is scoped to one Runtime environment, never to a single Agent node. */
+export function createAutomationModelCapacity() {
+    const slots = new Map();
+    function lease(key, slot) {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const next = slot.waiting.shift();
+            if (next) {
+                next.signal.removeEventListener("abort", next.onAbort);
+                next.grant(lease(key, slot));
+            }
+            else {
+                slot.active = false;
+                slots.delete(key);
+            }
+        };
+    }
+    function acquire(key, signal) {
+        signal.throwIfAborted();
+        const slot = slots.get(key) ?? { active: false, waiting: [] };
+        slots.set(key, slot);
+        if (!slot.active) {
+            slot.active = true;
+            return Promise.resolve(lease(key, slot));
+        }
+        return new Promise((grant, reject) => {
+            const waiter = {
+                signal, grant, reject,
+                onAbort: () => {
+                    const index = slot.waiting.indexOf(waiter);
+                    if (index < 0)
+                        return;
+                    slot.waiting.splice(index, 1);
+                    signal.removeEventListener("abort", waiter.onAbort);
+                    reject(signal.reason);
+                },
+            };
+            slot.waiting.push(waiter);
+            signal.addEventListener("abort", waiter.onAbort, { once: true });
+            if (signal.aborted)
+                waiter.onAbort();
+        });
+    }
+    return {
+        async withInvocation(params, fallbackPolicy, invoke) {
+            params.abortSignal.throwIfAborted();
+            const profile = resolveModelInvocation({
+                ...params,
+                modelPolicy: params.modelPolicy ?? fallbackPolicy,
+            }).profile;
+            if (profile.provider !== "ollama")
+                return invoke();
+            const release = await acquire(profile.providerId, params.abortSignal);
+            try {
+                params.abortSignal.throwIfAborted();
+                return await invoke();
+            }
+            finally {
+                release();
+            }
+        },
+    };
+}

package/dist/src/runtime/automations/model-dependency-projection.d.ts

@@ -0,0 +1,58 @@
+import type { RuntimeConfig } from "../ports.js";
+import type { AgentNode } from "./definition-contracts.js";
+import type { RequestExecutionPolicyId } from "../config/model-execution-policy.js";
+/** Projects canonical routing outcomes, never an unrelated model catalog. */
+export declare function projectAutomationModelDependencies(config: RuntimeConfig, nodes: readonly AgentNode[]): {
+    modelGatewayUrl: string;
+    contextBudget: import("../config/runner/contracts.js").RequestContextConfig | undefined;
+    agents: {
+        key: string;
+        admission: Readonly<{
+            policy: RequestExecutionPolicyId;
+            primaryProfileId?: string;
+            plugins?: import("../config/model-plugin-config.js").RuntimeModelPluginConfig;
+            source: "model_profile" | "default";
+        }>;
+        execution: Readonly<{
+            policy: RequestExecutionPolicyId;
+            primaryProfileId?: string;
+            plugins?: import("../config/model-plugin-config.js").RuntimeModelPluginConfig;
+            source: "model_profile" | "default";
+        }>;
+        invocations: ({
+            profile: {
+                id: string;
+                providerId: string;
+                provider: import("../../model-gateway/types.js").ModelProvider;
+                providerConfig?: import("../../model-gateway/types.js").ModelGatewayProviderConfig;
+                model: string;
+                contextWindowTokens: number;
+                supportsThinking: boolean;
+                capabilities: Required<import("../../model-gateway/types.js").ModelGatewayProfileCapabilities>;
+                options: Record<string, unknown>;
+                generation: import("../../model-gateway/types.js").ModelGenerationConfig;
+                context: import("../../model-gateway/types.js").ModelContextConfig;
+            };
+            timeoutMs: number;
+            model: string;
+            think?: import("../../shared/types.js").ModelReasoningLevel;
+            format?: import("../../model-gateway/types.js").ModelGatewayFormat;
+            instructions: string[] | Readonly<{
+                blockCount: number;
+                characterCount: number;
+                refs: readonly string[];
+                contentHashes: readonly string[];
+            }> | undefined;
+            modelStep: "learning.batch" | "supervisor.decision" | "supervisor.response" | "worker.decision" | "worker.result" | "capability.controls" | "planner.decision" | "planner.graph" | "reviewer.decision" | "degraded.finalization" | "execution.decision" | "execution.response" | "auditor.decision" | "context.compact" | "tool_payload.raw";
+        } | {
+            unavailable: import("../../model-gateway/invocation-policy.js").ModelInvocationResolutionErrorCode;
+            modelStep: "learning.batch" | "supervisor.decision" | "supervisor.response" | "worker.decision" | "worker.result" | "capability.controls" | "planner.decision" | "planner.graph" | "reviewer.decision" | "degraded.finalization" | "execution.decision" | "execution.response" | "auditor.decision" | "context.compact" | "tool_payload.raw";
+            instructions: Readonly<{
+                blockCount: number;
+                characterCount: number;
+                refs: readonly string[];
+                contentHashes: readonly string[];
+            }> | undefined;
+        })[];
+    }[];
+} | undefined;

package/dist/src/runtime/automations/model-dependency-projection.js

@@ -0,0 +1,88 @@
+import { ModelInvocationResolutionError, resolveModelInvocation, } from "../../model-gateway/invocation-policy.js";
+import { MODEL_STEPS } from "../../shared/model-steps.js";
+import { loadRequestRunnerConfig } from "../config/runner/loader.js";
+import { createRequestModelPolicy } from "../config/runner/model-policy.js";
+import { resolveConfiguredStepInstructionMetadata } from "../config/runner/step-instructions.js";
+import { resolveModelSelection } from "../model/model-selection.js";
+import { resolveModelStepTimeout } from "../model/model-step-timeout-policy.js";
+// Root and delegated contracts in request/role-executor-composition.ts own these paths.
+// The delegated Planner also invokes planner.graph; the direct Planner invokes only that step.
+const POLICY_MODEL_STEPS = {
+    "supervisor-worker-v1": [MODEL_STEPS.SUPERVISOR_DECISION, MODEL_STEPS.SUPERVISOR_RESPONSE,
+        MODEL_STEPS.PLANNER_DECISION, MODEL_STEPS.PLANNER_GRAPH, MODEL_STEPS.WORKER_DECISION,
+        MODEL_STEPS.WORKER_RESULT, MODEL_STEPS.REVIEWER_DECISION],
+    "execution-agent-v1": [MODEL_STEPS.EXECUTION_DECISION, MODEL_STEPS.EXECUTION_RESPONSE,
+        MODEL_STEPS.PLANNER_GRAPH, MODEL_STEPS.AUDITOR_DECISION],
+};
+function reachableModelSteps(policy, hasTools) {
+    // Both policies can compact or finalize a failed request. Tool helpers need an allowed operation.
+    // Passive learning is a separate background request, never part of an automation agent attempt.
+    return [...POLICY_MODEL_STEPS[policy], MODEL_STEPS.CONTEXT_COMPACTION, MODEL_STEPS.DEGRADED_FINALIZATION,
+        ...(hasTools ? [MODEL_STEPS.CAPABILITY_CONTROLS, MODEL_STEPS.TOOL_PAYLOAD_RAW] : [])];
+}
+function configuredInstructionDependency(runnerConfig, modelStep) {
+    if (!runnerConfig)
+        return undefined;
+    const metadata = resolveConfiguredStepInstructionMetadata({ runnerConfig, modelStep });
+    if (metadata.blockCount === 0)
+        return undefined;
+    return metadata;
+}
+function invocationDependency(input) {
+    const modelPreference = { profileId: input.node.modelProfileId, scope: "all" };
+    const dependency = { modelStep: input.modelStep,
+        instructions: configuredInstructionDependency(input.runnerConfig, input.modelStep) };
+    try {
+        const invocation = resolveModelInvocation({
+            agentMode: input.node.agentMode, modelPreference,
+            modelStep: input.modelStep, modelPolicy: input.modelPolicy,
+        });
+        // Unused calibration slots and display labels are not execution dependencies.
+        const { label: _label, calibration: _calibration, ...profile } = invocation.profile;
+        const timeout = resolveModelStepTimeout({
+            modelStep: input.modelStep, modelPreference, modelPolicy: input.modelPolicy,
+            fallbackTimeoutMs: input.runnerConfig?.steps[input.modelStep]?.timeoutMs ?? 0,
+        });
+        return { ...dependency, ...invocation, profile, timeoutMs: timeout.timeoutMs };
+    }
+    catch (error) {
+        if (!(error instanceof ModelInvocationResolutionError))
+            throw error;
+        return { ...dependency, unavailable: error.code };
+    }
+}
+/** Projects canonical routing outcomes, never an unrelated model catalog. */
+export function projectAutomationModelDependencies(config, nodes) {
+    if (nodes.length === 0)
+        return undefined;
+    const configPath = config.requestRunner?.configPath;
+    const runner = configPath ? loadRequestRunnerConfig({ configPath }) : undefined;
+    const modelPolicy = runner
+        ? createRequestModelPolicy({ platformPolicy: config.models, runnerConfig: runner })
+        : config.models;
+    const selected = new Map();
+    for (const node of nodes) {
+        const key = JSON.stringify([node.modelProfileId, node.agentMode]);
+        const hasTools = node.tools.length > 0 || selected.get(key)?.hasTools === true;
+        selected.set(key, { node, hasTools });
+    }
+    return {
+        modelGatewayUrl: config.modelGatewayUrl,
+        // Every Agent invocation uses these canonical admission/compaction reserves.
+        contextBudget: runner?.context,
+        agents: [...selected.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([key, { node, hasTools }]) => {
+            const request = { agentMode: node.agentMode,
+                modelPreference: { profileId: node.modelProfileId, scope: "all" },
+                modelExecutionPolicies: config.modelExecutionPolicies };
+            const execution = resolveModelSelection({ ...request, modelPolicy }).execution;
+            return {
+                key,
+                admission: resolveModelSelection({ ...request, modelPolicy: config.models }).execution,
+                execution,
+                invocations: reachableModelSteps(execution.policy, hasTools).map((modelStep) => invocationDependency({
+                    node, modelStep, modelPolicy, runnerConfig: runner,
+                })),
+            };
+        }),
+    };
+}

package/dist/src/runtime/automations/node-transactions.d.ts

@@ -0,0 +1,57 @@
+import type { CompiledAutomationGraph } from "./graph-validation.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationAttemptRecord, AutomationExecutionRecord, AutomationNodeStateRecord, AutomationResultRecord } from "./storage-records.js";
+type TerminalNodeStatus = Extract<AutomationNodeStateRecord["status"], "succeeded" | "skipped" | "failed" | "cancelled" | "interrupted">;
+export declare function createAutomationNodeTransactions(options: {
+    persistence: AutomationPersistence;
+    now?: () => number;
+}): {
+    begin: (input: {
+        runId: string;
+        automationId: string;
+        definitionRevision: number;
+        inputIds: readonly string[];
+        graph: CompiledAutomationGraph;
+    }) => Promise<AutomationExecutionRecord>;
+    startNode: (runId: string, nodeId: string) => Promise<void>;
+    recordAttempt: (input: {
+        runId: string;
+        nodeId: string;
+        invocationId: string;
+        fingerprint: string;
+        maxToolCalls?: number;
+    }) => Promise<AutomationAttemptRecord>;
+    recordAgentAttempt: (input: {
+        runId: string;
+        nodeId: string;
+        invocationId: string;
+        fingerprint: string;
+        maxToolCalls: number;
+    }) => Promise<AutomationAttemptRecord>;
+    recordModelCall: (runId: string, nodeId: string, maxModelCalls: number) => Promise<number>;
+    settleAgentAttempt: (input: {
+        runId: string;
+        nodeId: string;
+        invocationId: string;
+        result: AutomationResultRecord;
+        uncertain: boolean;
+        notDispatched?: boolean;
+        maxStoredArtifactBytes: number;
+    }) => Promise<void>;
+    hasUnsettledEffect: (runId: string, nodeId: string) => Promise<boolean>;
+    settleNode: (input: {
+        runId: string;
+        nodeId: string;
+        status: TerminalNodeStatus;
+        attemptId?: string;
+        result?: AutomationResultRecord;
+        maxStoredArtifactBytes?: number;
+        errorCode?: string;
+        uncertain?: boolean;
+        notDispatched?: boolean;
+    }) => Promise<void>;
+    requestStop: (runId: string) => Promise<void>;
+    get: (runId: string) => Promise<AutomationExecutionRecord | null>;
+};
+export type AutomationNodeTransactions = ReturnType<typeof createAutomationNodeTransactions>;
+export {};

package/dist/src/runtime/automations/node-transactions.js

@@ -0,0 +1,223 @@
+import { requireAutomationResultCapacity } from "./result-capacity.js";
+import { settleTerminalUndispatchedAdmission } from "./terminal-admission-receipt.js";
+function requireExecution(state, runId) {
+    const execution = state.executions.find((item) => item.id === runId);
+    if (!execution)
+        throw new Error("automation_run_not_found");
+    return execution;
+}
+function requireNode(execution, nodeId) {
+    const node = execution.nodes.find((item) => item.nodeId === nodeId);
+    if (!node)
+        throw new Error("automation_node_not_found");
+    return node;
+}
+function replaceExecution(state, current, patch) {
+    const next = { ...current, ...patch, revision: current.revision + 1 };
+    const index = state.executions.findIndex((item) => item.id === current.id);
+    state.executions[index] = next;
+    return next;
+}
+function replaceNode(execution, nodeId, patch) {
+    return execution.nodes.map((node) => node.nodeId === nodeId ? { ...node, ...patch } : node);
+}
+export function createAutomationNodeTransactions(options) {
+    const now = options.now ?? Date.now;
+    async function begin(input) {
+        return options.persistence.update((state) => {
+            const claimed = state.executions.find((item) => item.id === input.runId);
+            if (claimed && (claimed.automationId !== input.automationId ||
+                claimed.definitionRevision !== input.definitionRevision ||
+                claimed.stopRequestedAt || claimed.reportRef || claimed.nodes.length > 0 ||
+                claimed.inputIds.length !== input.inputIds.length ||
+                claimed.inputIds.some((id, index) => id !== input.inputIds[index])))
+                throw new Error("automation_run_already_started");
+            const execution = {
+                id: input.runId,
+                automationId: input.automationId,
+                definitionRevision: input.definitionRevision,
+                revision: claimed ? claimed.revision + 1 : 1,
+                inputIds: [...input.inputIds],
+                nodes: input.graph.steps.map((step) => ({ nodeId: step.id, status: "pending" })),
+            };
+            if (claimed) {
+                state.executions[state.executions.indexOf(claimed)] = execution;
+            }
+            else {
+                state.executions.push(execution);
+            }
+            return execution;
+        });
+    }
+    async function startNode(runId, nodeId) {
+        await options.persistence.update((state) => {
+            const execution = requireExecution(state, runId);
+            const node = requireNode(execution, nodeId);
+            if (execution.stopRequestedAt || execution.reportRef || node.status !== "pending")
+                throw new Error("automation_run_locked");
+            replaceExecution(state, execution, {
+                nodes: replaceNode(execution, nodeId, { status: "running" }),
+            });
+        });
+    }
+    async function recordAttempt(input) {
+        return options.persistence.update((state) => {
+            const execution = requireExecution(state, input.runId);
+            const node = requireNode(execution, input.nodeId);
+            if (execution.stopRequestedAt || execution.reportRef || node.status !== "running" || node.attemptId)
+                throw new Error("automation_run_locked");
+            if (state.attempts.some((item) => item.invocationId === input.invocationId))
+                throw new Error("automation_attempt_duplicate");
+            if (input.maxToolCalls !== undefined &&
+                state.attempts.filter((item) => item.runId === input.runId).length >= input.maxToolCalls)
+                throw new Error("automation_tool_call_limit_reached");
+            const attempt = {
+                id: input.invocationId,
+                runId: input.runId,
+                nodeId: input.nodeId,
+                invocationId: input.invocationId,
+                fingerprint: input.fingerprint,
+                state: "started",
+                startedAt: new Date(now()).toISOString(),
+            };
+            state.attempts.push(attempt);
+            replaceExecution(state, execution, {
+                nodes: replaceNode(execution, input.nodeId, { attemptId: attempt.id }),
+            });
+            return attempt;
+        });
+    }
+    async function recordAgentAttempt(input) {
+        return options.persistence.update((state) => {
+            const execution = requireExecution(state, input.runId);
+            const node = requireNode(execution, input.nodeId);
+            if (execution.stopRequestedAt || execution.reportRef || node.status !== "running")
+                throw new Error("automation_run_locked");
+            if (state.attempts.some((item) => item.invocationId === input.invocationId))
+                throw new Error("automation_attempt_duplicate");
+            if (state.attempts.filter((item) => item.runId === input.runId).length >= input.maxToolCalls)
+                throw new Error("automation_tool_call_limit_reached");
+            const attempt = {
+                id: input.invocationId,
+                runId: input.runId,
+                nodeId: input.nodeId,
+                invocationId: input.invocationId,
+                fingerprint: input.fingerprint,
+                state: "started",
+                startedAt: new Date(now()).toISOString(),
+            };
+            state.attempts.push(attempt);
+            replaceExecution(state, execution, {});
+            return attempt;
+        });
+    }
+    async function recordModelCall(runId, nodeId, maxModelCalls) {
+        return options.persistence.update((state) => {
+            const execution = requireExecution(state, runId);
+            const node = requireNode(execution, nodeId);
+            if (execution.stopRequestedAt || execution.reportRef || node.status !== "running")
+                throw new Error("automation_run_locked");
+            const count = execution.modelCalls ?? 0;
+            if (count >= maxModelCalls)
+                throw new Error("automation_model_call_limit_reached");
+            replaceExecution(state, execution, { modelCalls: count + 1 });
+            return count + 1;
+        });
+    }
+    async function settleAgentAttempt(input) {
+        await options.persistence.update((state) => {
+            const execution = requireExecution(state, input.runId);
+            requireNode(execution, input.nodeId);
+            const isTerminalUndispatchedAdmission = Boolean(execution.reportRef) && input.notDispatched === true;
+            if (isTerminalUndispatchedAdmission)
+                return settleTerminalUndispatchedAdmission({
+                    ...input, state, execution, resultKind: "effect_receipt", now: now(),
+                });
+            const index = state.attempts.findIndex((item) => item.id === input.invocationId && item.runId === input.runId && item.nodeId === input.nodeId);
+            if (index < 0 || state.attempts[index].state !== "started")
+                throw new Error("automation_attempt_mismatch");
+            if (input.result.runId !== input.runId || input.result.nodeId !== input.nodeId ||
+                input.result.kind !== "effect_receipt")
+                throw new Error("automation_result_ref_invalid");
+            const used = state.results.filter((item) => item.runId === input.runId)
+                .reduce((total, item) => total + item.sizeBytes, input.result.sizeBytes);
+            if (used > input.maxStoredArtifactBytes)
+                throw new Error("automation_artifact_budget_exhausted");
+            requireAutomationResultCapacity(state, input.result.sizeBytes);
+            state.results.push(input.result);
+            state.attempts[index] = {
+                ...state.attempts[index],
+                state: input.uncertain ? "uncertain" : "settled",
+                settledAt: new Date(now()).toISOString(),
+                settlementRef: input.result.id,
+            };
+            replaceExecution(state, execution, {});
+        });
+    }
+    async function hasUnsettledEffect(runId, nodeId) {
+        const state = await options.persistence.read();
+        return state.attempts.some((item) => item.runId === runId && item.nodeId === nodeId &&
+            (item.state === "started" || item.state === "uncertain"));
+    }
+    async function settleNode(input) {
+        await options.persistence.update((state) => {
+            const execution = requireExecution(state, input.runId);
+            const node = requireNode(execution, input.nodeId);
+            const isTerminalUndispatchedAdmission = Boolean(execution.reportRef) && input.notDispatched === true;
+            if (isTerminalUndispatchedAdmission)
+                return settleTerminalUndispatchedAdmission({
+                    ...input, state, execution, invocationId: input.attemptId, result: input.result,
+                    maxStoredArtifactBytes: input.maxStoredArtifactBytes, resultKind: "node_output", now: now(),
+                });
+            if (execution.reportRef)
+                throw new Error("automation_run_locked");
+            if (node.status !== "running" && node.status !== "pending")
+                throw new Error("automation_node_already_settled");
+            if (node.attemptId !== input.attemptId)
+                throw new Error("automation_attempt_mismatch");
+            if (input.result) {
+                if (input.result.runId !== input.runId || input.result.nodeId !== input.nodeId)
+                    throw new Error("automation_result_ref_invalid");
+                if (input.maxStoredArtifactBytes !== undefined &&
+                    state.results.filter((item) => item.runId === input.runId)
+                        .reduce((total, item) => total + item.sizeBytes, input.result.sizeBytes) >
+                        input.maxStoredArtifactBytes)
+                    throw new Error("automation_artifact_budget_exhausted");
+                requireAutomationResultCapacity(state, input.result.sizeBytes);
+                state.results.push(input.result);
+            }
+            if (input.attemptId) {
+                const index = state.attempts.findIndex((item) => item.id === input.attemptId);
+                if (index < 0 || state.attempts[index].state !== "started")
+                    throw new Error("automation_attempt_mismatch");
+                state.attempts[index] = {
+                    ...state.attempts[index],
+                    state: input.uncertain ? "uncertain" : "settled",
+                    settledAt: new Date(now()).toISOString(),
+                    ...(input.result ? { settlementRef: input.result.id } : {}),
+                };
+            }
+            replaceExecution(state, execution, {
+                nodes: replaceNode(execution, input.nodeId, {
+                    status: input.status,
+                    ...(input.result ? { resultRef: input.result.id } : {}),
+                    ...(input.errorCode ? { errorCode: input.errorCode } : {}),
+                }),
+            });
+        });
+    }
+    async function requestStop(runId) {
+        await options.persistence.update((state) => {
+            const execution = requireExecution(state, runId);
+            if (execution.stopRequestedAt)
+                return;
+            replaceExecution(state, execution, { stopRequestedAt: new Date(now()).toISOString() });
+        });
+    }
+    async function get(runId) {
+        const state = await options.persistence.read();
+        return state.executions.find((item) => item.id === runId) ?? null;
+    }
+    return { begin, startNode, recordAttempt, recordAgentAttempt,
+        recordModelCall, settleAgentAttempt, hasUnsettledEffect, settleNode, requestStop, get };
+}

package/dist/src/runtime/automations/occurrence-preparation.d.ts

@@ -0,0 +1,12 @@
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+import type { RuntimeConfig } from "../ports.js";
+import type { SchedulerAutomationExecutor } from "../scheduler/contracts.js";
+import { type AutomationSnapshotStaging } from "./snapshot-staging.js";
+import type { AutomationPersistence } from "./persistence.js";
+export declare function createAutomationOccurrencePreparer(options: {
+    config: RuntimeConfig;
+    persistence: AutomationPersistence;
+    attachments: RuntimeAttachmentStore;
+    snapshots?: AutomationSnapshotStaging;
+    now?: () => number;
+}): SchedulerAutomationExecutor["prepare"];