@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/automations/runtime-executor.js

@@ -0,0 +1,260 @@
+import { deleteSessionAttachmentsIfSupported } from "../session/session-attachment-deletion.js";
+import { traceDebug } from "../observability/debug-logger.js";
+import { isAutomationSchedulerRun } from "../scheduler/scheduler-target.js";
+import { createAutomationOccurrencePreparer } from "./occurrence-preparation.js";
+import { createAutomationReplayPreparer } from "./replay-preparation.js";
+import { holdInterruptedInputs, releaseNeverDispatchedInputs } from "./input-ledger.js";
+import { DEFAULT_AUTOMATION_LIMITS } from "./limits.js";
+import { recordAutomationLateSettlements } from "./late-settlement.js";
+import { maintainAutomationRetention } from "./retention.js";
+import { createAutomationSnapshotStaging } from "./snapshot-staging.js";
+const DERIVED_REPORT = (runId) => `derived:${runId}`;
+function requireExecution(state, runId) {
+    const execution = state.executions.find((item) => item.id === runId);
+    if (!execution)
+        throw new Error("automation_execution_checkpoint_missing");
+    return execution;
+}
+function replaceExecution(state, execution, update) {
+    const index = state.executions.findIndex((item) => item.id === execution.id);
+    if (index < 0)
+        throw new Error("automation_execution_checkpoint_missing");
+    state.executions[index] = { ...execution, ...update, revision: execution.revision + 1 };
+}
+function stoppedNodes(nodes, uncertain) {
+    return nodes.map((node) => {
+        if (node.status === "running")
+            return {
+                ...node,
+                status: "interrupted",
+                errorCode: uncertain ? "automation_effect_uncertain" : "automation_run_stopped",
+            };
+        if (node.status === "pending" || node.status === "ready")
+            return {
+                ...node,
+                status: "cancelled",
+                errorCode: "automation_run_stopped",
+            };
+        return node;
+    });
+}
+function markUnsettledAttempts(state, runId) {
+    let uncertain = false;
+    state.attempts = state.attempts.map((attempt) => {
+        if (attempt.runId !== runId)
+            return attempt;
+        if (attempt.state === "uncertain") {
+            uncertain = true;
+            return attempt;
+        }
+        if (attempt.state !== "started")
+            return attempt;
+        uncertain = true;
+        return { ...attempt, state: "uncertain" };
+    });
+    return uncertain;
+}
+function markInputOutcome(state, runId, reportRef, hold) {
+    state.inputs = state.inputs.map((record) => record.claimRunId !== runId
+        ? record
+        : {
+            ...record,
+            ...(hold ? { eligibility: "held" } : {}),
+            outcomeRef: reportRef,
+        });
+}
+export function createAutomationRuntimeExecutor(options) {
+    const active = new Map();
+    const stopsBeforeStart = new Set();
+    const snapshots = createAutomationSnapshotStaging({
+        runtimeDir: options.config.paths.runtimeDir,
+        persistence: options.persistence, attachments: options.attachments,
+    });
+    const prepare = createAutomationOccurrencePreparer({ ...options, snapshots });
+    const prepareReplay = createAutomationReplayPreparer(options);
+    let lastMaintenanceAt = Number.NEGATIVE_INFINITY;
+    async function reconcileSessions() {
+        const reportFailure = (sessionId, error) => traceDebug("runtime.automations", "agent_session.recovery_failed", {
+            sessionId, error: error instanceof Error ? error.message : String(error),
+        });
+        try {
+            await options.sessions?.reconcileAutomationSessions?.((id) => deleteSessionAttachmentsIfSupported(options.attachments, id), reportFailure);
+        }
+        catch (error) {
+            reportFailure("", error);
+        }
+    }
+    async function maintainRetention(now) {
+        if (now - lastMaintenanceAt < 5 * 60_000)
+            return;
+        lastMaintenanceAt = now;
+        await reconcileSessions();
+        await snapshots.reconcile();
+        await maintainAutomationRetention({
+            persistence: options.persistence,
+            results: options.results,
+            attachments: options.attachments,
+            now,
+        });
+    }
+    function signalStop(runId) {
+        const execution = active.get(runId);
+        if (!execution) {
+            stopsBeforeStart.add(runId);
+            return;
+        }
+        if (execution.stopRequested)
+            return;
+        execution.stopRequested = true;
+        execution.controller.abort(new Error("automation_run_stopped"));
+        if (execution.deadlineMs !== undefined)
+            scheduleDeadline(runId, execution);
+    }
+    function scheduleDeadline(runId, execution) {
+        if (execution.deadlineTimer)
+            return;
+        execution.deadlineTimer = setTimeout(() => execution.publishDeadline({
+            status: "cancelled",
+            error: "automation_stop_deadline_elapsed",
+            reportRef: DERIVED_REPORT(runId),
+        }), execution.deadlineMs ?? DEFAULT_AUTOMATION_LIMITS.stopReportDeadlineMs);
+        execution.deadlineTimer.unref();
+    }
+    function scheduleBudgetDeadline(runId, execution, durationMs) {
+        execution.budgetTimer = setTimeout(() => {
+            execution.controller.abort(new Error("automation_run_duration_exceeded"));
+            execution.publishDeadline({
+                status: execution.stopRequested ? "cancelled" : "failed",
+                error: "automation_run_deadline_elapsed",
+                reportRef: DERIVED_REPORT(runId),
+            });
+        }, durationMs);
+        execution.budgetTimer.unref();
+    }
+    function start(job, run) {
+        let publishDeadline;
+        const deadline = new Promise((resolve) => {
+            publishDeadline = resolve;
+        });
+        const execution = {
+            controller: new AbortController(),
+            stopRequested: false,
+            publishDeadline,
+        };
+        active.set(run.id, execution);
+        if (stopsBeforeStart.delete(run.id))
+            signalStop(run.id);
+        const actual = (async () => {
+            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");
+            execution.deadlineMs = definition.limits.stopReportDeadlineMs;
+            if (execution.stopRequested)
+                scheduleDeadline(run.id, execution);
+            if (execution.controller.signal.aborted)
+                return {
+                    status: "cancelled",
+                    reportRef: DERIVED_REPORT(run.id),
+                };
+            scheduleBudgetDeadline(run.id, execution, definition.limits.maxRunDurationMs + definition.limits.stopReportDeadlineMs);
+            return options.execute(job, run, execution.controller.signal);
+        })().catch((error) => ({
+            status: "failed",
+            error: error instanceof Error ? error.message : String(error),
+            reportRef: DERIVED_REPORT(run.id),
+        }));
+        const outcome = Promise.race([actual, deadline]);
+        // Terminal deadlines detach stalled graph/model work. Tool dispatch is fenced
+        // by the aborted signal, and every admitted Tool promise still drains below.
+        const resourcesSettled = outcome.then(() => undefined).finally(async () => {
+            try {
+                const observed = await options.toolLifetimes.whenSettled(run.id);
+                await recordAutomationLateSettlements({
+                    persistence: options.persistence,
+                    runId: run.id,
+                    observed,
+                    now: options.now,
+                });
+            }
+            finally {
+                cleanup(run.id, execution);
+            }
+        });
+        return { outcome, resourcesSettled };
+    }
+    function cleanup(runId, execution) {
+        if (execution.deadlineTimer)
+            clearTimeout(execution.deadlineTimer);
+        if (execution.budgetTimer)
+            clearTimeout(execution.budgetTimer);
+        if (active.get(runId) === execution)
+            active.delete(runId);
+    }
+    function recover(scheduler, automations, recoveredRunIds) {
+        for (const runId of recoveredRunIds) {
+            const run = scheduler.runs.find((item) => item.id === runId);
+            if (!run || !isAutomationSchedulerRun(run))
+                throw new Error("automation_run_not_found");
+            let execution = automations.executions.find((item) => item.id === runId);
+            if (!execution) {
+                execution = {
+                    id: runId,
+                    automationId: run.target.automationId,
+                    definitionRevision: run.target.definitionRevision,
+                    revision: 1,
+                    inputIds: [],
+                    nodes: [],
+                };
+                automations.executions.push(execution);
+            }
+            const missed = run.status === "missed";
+            if (missed)
+                releaseNeverDispatchedInputs(automations, runId);
+            else
+                holdInterruptedInputs(automations, runId);
+            const uncertain = missed ? false : markUnsettledAttempts(automations, runId);
+            replaceExecution(automations, execution, {
+                nodes: stoppedNodes(execution.nodes, uncertain),
+                reportRef: DERIVED_REPORT(runId),
+                terminalAt: new Date(options.now?.() ?? Date.now()).toISOString(),
+            });
+            run.reportRef = DERIVED_REPORT(runId);
+        }
+    }
+    function settle(run, state, outcome) {
+        const execution = requireExecution(state, run.id);
+        if (!outcome.reportRef)
+            throw new Error("automation_report_missing");
+        const derived = outcome.reportRef === DERIVED_REPORT(run.id);
+        const successful = outcome.status === "succeeded" ||
+            outcome.status === "completed_with_skips";
+        if (derived && successful && (execution.nodes.some((node) => node.status === "pending" || node.status === "ready" || node.status === "running") ||
+            state.attempts.some((item) => item.runId === run.id && item.state !== "settled")))
+            throw new Error("automation_run_not_settled");
+        if (!derived && !state.results.some((item) => item.id === outcome.reportRef &&
+            item.runId === run.id && item.kind === "report"))
+            throw new Error("automation_report_missing");
+        const uncertain = derived ? markUnsettledAttempts(state, run.id) :
+            state.attempts.some((item) => item.runId === run.id &&
+                (item.state === "started" || item.state === "uncertain"));
+        replaceExecution(state, execution, {
+            ...(derived ? { nodes: stoppedNodes(execution.nodes, uncertain) } : {}),
+            reportRef: outcome.reportRef,
+            terminalAt: new Date(options.now?.() ?? Date.now()).toISOString(),
+        });
+        markInputOutcome(state, run.id, outcome.reportRef, uncertain || (derived && !successful));
+    }
+    function cancelPending(run, state) {
+        const execution = requireExecution(state, run.id);
+        releaseNeverDispatchedInputs(state, run.id);
+        replaceExecution(state, execution, {
+            nodes: stoppedNodes(execution.nodes, false),
+            reportRef: DERIVED_REPORT(run.id),
+            terminalAt: new Date(options.now?.() ?? Date.now()).toISOString(),
+        });
+    }
+    return { prepare, prepareReplay, start, stop: signalStop, recover, settle,
+        cancelPending, maintainRetention, reconcileSessions };
+}

package/dist/src/runtime/automations/saved-agent-management.d.ts

@@ -0,0 +1,16 @@
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationSavedAgentRecord } from "./storage-records.js";
+export declare function createAutomationSavedAgentManager(options: {
+    persistence: AutomationPersistence;
+    now?: () => number;
+}): {
+    get: (agentId: string, revision?: number) => Promise<AutomationSavedAgentRecord | null>;
+    list: () => Promise<AutomationSavedAgentRecord[]>;
+    saveFromDraft: (input: {
+        automationId: string;
+        nodeId: string;
+        expectedDraftRevision: number;
+        agentId?: string;
+        expectedAgentRevision?: number;
+    }) => Promise<AutomationSavedAgentRecord>;
+};

package/dist/src/runtime/automations/saved-agent-management.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+function findAgent(node, nodeId) {
+    if (node.id === nodeId)
+        return node.kind === "agent" ? node : undefined;
+    if (node.kind === "sequence") {
+        for (const child of node.children) {
+            const found = findAgent(child, nodeId);
+            if (found)
+                return found;
+        }
+    }
+    if (node.kind === "parallel") {
+        for (const branch of node.branches) {
+            const found = findAgent(branch, nodeId);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+/** A reusable step template. Runtime inputs, prior grants and execution state never enter it. */
+function snapshotAgent(agent, id) {
+    return structuredClone({
+        kind: "agent",
+        id,
+        title: agent.title,
+        onFailure: agent.onFailure,
+        modelProfileId: agent.modelProfileId,
+        agentMode: agent.agentMode,
+        roleInstructions: agent.roleInstructions,
+        prompt: agent.prompt,
+        inputs: {},
+        tools: agent.tools,
+        result: agent.result,
+        ...(agent.acceptance ? { acceptance: agent.acceptance } : {}),
+    });
+}
+export function createAutomationSavedAgentManager(options) {
+    const now = options.now ?? Date.now;
+    async function get(agentId, revision) {
+        const state = await options.persistence.read();
+        return state.savedAgents
+            .filter((record) => record.agentId === agentId &&
+            (revision === undefined || record.revision === revision))
+            .sort((left, right) => right.revision - left.revision)[0] ?? null;
+    }
+    async function list() {
+        const state = await options.persistence.read();
+        const latest = new Map();
+        for (const record of state.savedAgents) {
+            const previous = latest.get(record.agentId);
+            if (!previous || record.revision > previous.revision)
+                latest.set(record.agentId, record);
+        }
+        return [...latest.values()].sort((left, right) => left.agent.title.localeCompare(right.agent.title));
+    }
+    async function saveFromDraft(input) {
+        if (!Number.isSafeInteger(input.expectedDraftRevision) || input.expectedDraftRevision < 1)
+            throw new Error("automation_revision_conflict");
+        if (input.agentId && (!Number.isSafeInteger(input.expectedAgentRevision) ||
+            Number(input.expectedAgentRevision) < 1))
+            throw new Error("automation_revision_conflict");
+        if (!input.agentId && input.expectedAgentRevision !== undefined)
+            throw new Error("automation_revision_conflict");
+        return options.persistence.update((state) => {
+            const draft = state.drafts.find((record) => record.automationId === input.automationId);
+            if (!draft)
+                throw new Error("automation_not_found");
+            if (draft.revision !== input.expectedDraftRevision)
+                throw new Error("automation_revision_conflict");
+            const agent = findAgent(draft.definition.body, input.nodeId);
+            if (!agent)
+                throw new Error("automation_dependency_missing");
+            const prior = input.agentId
+                ? state.savedAgents.filter((record) => record.agentId === input.agentId)
+                    .sort((left, right) => right.revision - left.revision)[0]
+                : undefined;
+            if (input.agentId && (!prior || prior.revision !== input.expectedAgentRevision))
+                throw new Error("automation_revision_conflict");
+            const agentId = input.agentId ?? randomUUID();
+            const revision = (prior?.revision ?? 0) + 1;
+            const saved = {
+                id: `agent:${agentId}:${revision}`,
+                agentId,
+                revision,
+                agent: snapshotAgent(agent, `n_${randomUUID().replaceAll("-", "")}`),
+                updatedAt: new Date(now()).toISOString(),
+            };
+            state.savedAgents.push(saved);
+            return saved;
+        });
+    }
+    return { get, list, saveFromDraft };
+}

package/dist/src/runtime/automations/service.d.ts

@@ -0,0 +1,286 @@
+import type { RuntimeConfig, ToolRegistry } from "../ports.js";
+import type { SchedulerAutomationRun, SchedulerService } from "../scheduler/contracts.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationResultStore } from "./result-store.js";
+/** One management surface shared by ABot Studio and future authoring tools. */
+export declare function createAutomationService(options: {
+    config: RuntimeConfig;
+    scheduler: SchedulerService;
+    persistence: AutomationPersistence;
+    results: AutomationResultStore;
+    tools: ToolRegistry;
+    timeZone?: string;
+}): {
+    list: () => Promise<{
+        latestRunId?: string | undefined;
+        latestRunStatus?: import("../scheduler/contracts.js").SchedulerRunStatus | "stopping" | "completed_with_skips" | undefined;
+        publishedRevision?: number;
+        status: "active" | "paused" | "draft" | "archived";
+        id: string;
+        title: string;
+        draftRevision: number;
+        updatedAt: string;
+    }[]>;
+    create: (title: string, templateId?: string) => Promise<Readonly<{
+        id: string;
+        automationId: string;
+        revision: number;
+        definition: import("./definition-contracts.js").AutomationRevision;
+        updatedAt: string;
+        archivedAt?: string;
+        storageRevision?: number;
+    }>>;
+    getDraft: (automationId: string) => Promise<import("./storage-records.js").AutomationDraftRecord | null>;
+    deleteDraft: (automationId: string, expectedRevision: number) => Promise<void>;
+    archive: (automationId: string, expectedRevision: number) => Promise<Readonly<{
+        id: string;
+        automationId: string;
+        revision: number;
+        definition: import("./definition-contracts.js").AutomationRevision;
+        updatedAt: string;
+        archivedAt?: string;
+        storageRevision?: number;
+    }>>;
+    restore: (automationId: string, expectedRevision: number) => Promise<Readonly<{
+        id: string;
+        automationId: string;
+        revision: number;
+        definition: import("./definition-contracts.js").AutomationRevision;
+        updatedAt: string;
+        archivedAt?: string;
+        storageRevision?: number;
+    }>>;
+    getPublishedDefinition: (automationId: string) => Promise<Readonly<{
+        schemaVersion: 1;
+        automationId: string;
+        revision: number;
+        title: string;
+        objective: string;
+        workingDirectory?: string;
+        trigger: import("./definition-contracts.js").AutomationTrigger;
+        source?: import("./definition-contracts.js").FolderSource;
+        inputs: Readonly<Record<string, import("./definition-contracts.js").AutomationJsonValue>>;
+        body: import("./definition-contracts.js").SequenceNode;
+        limits: import("./limits.js").AutomationLimits;
+    }> | null>;
+    updateDraft: (automationId: string, expectedRevision: number, mutation: unknown) => Promise<import("./storage-records.js").AutomationDraftRecord>;
+    createDraftPlan: (title: string, value: unknown, accept?: import("./draft-management.js").AutomationDraftPlanAcceptance) => Promise<{
+        draft: Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("./definition-contracts.js").AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>;
+        aliases: Readonly<Record<string, string>>;
+    }>;
+    applyDraftPlan: (automationId: string, expectedRevision: number, value: unknown, accept?: import("./draft-management.js").AutomationDraftPlanAcceptance) => Promise<{
+        draft: Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("./definition-contracts.js").AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>;
+        aliases: Readonly<Record<string, string>>;
+    }>;
+    getSavedAgent: (agentId: string, revision?: number) => Promise<import("./storage-records.js").AutomationSavedAgentRecord | null>;
+    listSavedAgents: () => Promise<import("./storage-records.js").AutomationSavedAgentRecord[]>;
+    saveAgentFromDraft: (input: {
+        automationId: string;
+        nodeId: string;
+        expectedDraftRevision: number;
+        agentId?: string;
+        expectedAgentRevision?: number;
+    }) => Promise<import("./storage-records.js").AutomationSavedAgentRecord>;
+    validate: (automationId: string) => Promise<readonly Readonly<{
+        code: string;
+        path: string;
+        message: string;
+    }>[]>;
+    catalog: (automationId: string) => Promise<{
+        templates: {
+            id: string;
+            title: string;
+            category: string;
+            description: string;
+            setup: string;
+            toolNames: string[];
+            stepCount: number;
+            agentCount: number;
+            parallelGroupCount: number;
+            level: string;
+            highlights: readonly string[];
+            outputFiles: string[];
+        }[];
+        operations: Readonly<{
+            toolName: string;
+            operationId: string;
+            contractVersion: number;
+            label: string;
+            pluginName?: string;
+            catalogGroups: readonly import("../../capabilities/tool-types.js").ToolCatalogGroup[];
+            toolDescription?: string;
+            permissionMode: "full_access" | "full_plus";
+            effect: "read_only" | "mutating" | "mixed";
+            approval: "request_policy" | "always";
+            input: import("../../capabilities/tool-types.js").ToolNormalInvocationInput;
+            fixedParams?: import("../../capabilities/tool-types.js").ToolNormalInvocationOperation["fixedParams"];
+            payload?: import("../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+            attachmentInput?: import("../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
+            selectionControlIds?: readonly string[];
+        }>[];
+        grantableOperations: Readonly<{
+            toolName: string;
+            operationId: string;
+            contractVersion: number;
+            label: string;
+            pluginName?: string;
+            catalogGroups: readonly import("../../capabilities/tool-types.js").ToolCatalogGroup[];
+            toolDescription?: string;
+            permissionMode: "full_access" | "full_plus";
+            effect: "read_only" | "mutating" | "mixed";
+            approval: "request_policy" | "always";
+            input: import("../../capabilities/tool-types.js").ToolNormalInvocationInput;
+            fixedParams?: import("../../capabilities/tool-types.js").ToolNormalInvocationOperation["fixedParams"];
+            payload?: import("../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+            attachmentInput?: import("../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
+            selectionControlIds?: readonly string[];
+        }>[];
+        models: {
+            provider?: string | undefined;
+            id: string;
+            label: string;
+        }[];
+        savedAgents: {
+            id: string;
+            revision: number;
+            title: string;
+            modelProfileId: string;
+            agent: import("./definition-contracts.js").AgentNode;
+        }[];
+    }>;
+    getGrant: (automationId: string) => Promise<import("./storage-records.js").AutomationGrantRecord | null>;
+    replaceGrant: (input: {
+        automationId: string;
+        expectedGrantRevision: number;
+        mode: import("../scheduler/tool-permission-mode.js").SchedulerToolPermissionMode;
+        operations: readonly import("./definition-contracts.js").OperationRef[];
+        actionId: string;
+    }) => Promise<import("./storage-records.js").AutomationGrantRecord>;
+    publish: (automationId: string, expectedRevision: number) => Promise<{
+        definition: Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("./definition-contracts.js").AutomationRevision;
+            publishedAt: string;
+            dependencyFingerprint?: string;
+        }>;
+        job: import("../scheduler/contracts.js").SchedulerAutomationJob;
+    }>;
+    activate(automationId: string): Promise<import("../scheduler/contracts.js").SchedulerAutomationJob>;
+    pause(automationId: string): Promise<import("../scheduler/contracts.js").SchedulerAutomationJob>;
+    runNow(automationId: string, idempotencyKey?: string): Promise<SchedulerAutomationRun>;
+    listRuns: (automationId: string, query?: import("../scheduler/contracts.js").SchedulerRunListQuery) => Promise<SchedulerAutomationRun[]>;
+    getRun: (runId: string) => Promise<{
+        reportState?: "expired" | undefined;
+        reportExpiredAt?: string | undefined;
+        detailsExpiredAt?: string | undefined;
+        automationId: string;
+        definition: Readonly<{
+            schemaVersion: 1;
+            automationId: string;
+            revision: number;
+            title: string;
+            objective: string;
+            workingDirectory?: string;
+            trigger: import("./definition-contracts.js").AutomationTrigger;
+            source?: import("./definition-contracts.js").FolderSource;
+            inputs: Readonly<Record<string, import("./definition-contracts.js").AutomationJsonValue>>;
+            body: import("./definition-contracts.js").SequenceNode;
+            limits: import("./limits.js").AutomationLimits;
+        }>;
+        nodes: {
+            errorCode?: string | undefined;
+            nodeId: string;
+            status: "failed" | "pending" | "cancelled" | "succeeded" | "running" | "ready" | "skipped" | "interrupted";
+        }[];
+        report: Readonly<{
+            runId: string;
+            automationId: string;
+            definitionRevision: number;
+            outcome: "succeeded" | "completed_with_skips" | "failed" | "cancelled" | "interrupted" | "missed";
+            startedAt: string | null;
+            finishedAt: string;
+            inputIds: readonly string[];
+            inputVersions: readonly Readonly<{
+                inputId: string;
+                sourceId: string;
+                canonicalPath: string;
+                contentVersion: string;
+            }>[];
+            nodeResults: readonly Readonly<{
+                nodeId: string;
+                title?: string;
+                status: string;
+                errorCode?: string;
+                resultRef?: string;
+            }>[];
+            uncertainEffects: readonly Readonly<{
+                nodeId: string;
+                attemptId: string;
+            }>[];
+            lateEvidence: readonly Readonly<{
+                nodeId: string;
+                attemptId: string;
+                revision: number;
+                observedAt: string;
+                status: "succeeded" | "failed" | "rejected";
+                errorCode?: string;
+            }>[];
+            artifacts: readonly Readonly<{
+                id: string;
+                nodeId?: string;
+                kind: string;
+            }>[];
+            effectSummary?: import("./step-evidence-effects.js").AutomationRunEffectSummary;
+            modelCalls: number | null;
+            toolCalls: number | null;
+            toolAttempts?: number;
+        }> | null;
+        outputSummary: Readonly<{
+            entries: readonly import("./run-output-summary.js").AutomationRunOutputEntry[];
+            omitted: number;
+        }>;
+        id: string;
+        jobId: string;
+        environmentId: string;
+        target: Readonly<{
+            kind: "automation";
+            automationId: string;
+            definitionRevision: number;
+        }>;
+        title: string;
+        timeZone: string;
+        jobRevision: number;
+        scheduledAt: string;
+        admittedAt?: string;
+        startedAt?: string;
+        finishedAt?: string;
+        trigger: "schedule" | "manual";
+        idempotencyKey?: string;
+        replayOf?: string;
+        status: import("../scheduler/contracts.js").SchedulerRunStatus | "stopping" | "completed_with_skips";
+        error?: string;
+        reportRef?: string;
+    }>;
+    getStepEvidence: (runId: string, nodeId: string, full?: boolean) => Promise<import("./step-evidence.js").AutomationStepEvidence>;
+    stopRun: (runId: string) => Promise<SchedulerAutomationRun>;
+    rerun: (runId: string, idempotencyKey: string, confirmed: true) => Promise<SchedulerAutomationRun>;
+};
+export type AutomationService = ReturnType<typeof createAutomationService>;