@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/automations/draft-management.d.ts

@@ -0,0 +1,53 @@
+import type { AutomationRevision } from "./definition-contracts.js";
+import type { AutomationDraftRecord } from "./storage-records.js";
+import type { AutomationPersistence } from "./persistence.js";
+export type AutomationDraftSummary = Readonly<{
+    id: string;
+    title: string;
+    draftRevision: number;
+    updatedAt: string;
+    publishedRevision?: number;
+    status: "draft" | "paused" | "active" | "archived";
+}>;
+export type AutomationDraftPlanResult = Readonly<{
+    draft: AutomationDraftRecord;
+    aliases: Readonly<Record<string, string>>;
+}>;
+/** Owner-local synchronous admission only; remote service calls omit this callback. */
+export type AutomationDraftPlanAcceptance = (result: AutomationDraftPlanResult) => true;
+export declare function createAutomationDraftManager(options: {
+    persistence: AutomationPersistence;
+    now?: () => number;
+}): {
+    list: () => Promise<AutomationDraftSummary[]>;
+    create: (title: string, buildDefinition?: (empty: AutomationRevision) => AutomationRevision) => Promise<AutomationDraftRecord>;
+    createPlan: (title: string, value: unknown, accept?: AutomationDraftPlanAcceptance) => Promise<{
+        draft: Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>;
+        aliases: Readonly<Record<string, string>>;
+    }>;
+    applyPlan: (automationId: string, expectedRevision: number, value: unknown, accept?: AutomationDraftPlanAcceptance) => Promise<{
+        draft: Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>;
+        aliases: Readonly<Record<string, string>>;
+    }>;
+    get: (automationId: string) => Promise<AutomationDraftRecord | null>;
+    deleteUnpublishedDraft: (automationId: string, expectedRevision: number) => Promise<void>;
+    update: (automationId: string, expectedRevision: number, mutation: unknown) => Promise<AutomationDraftRecord>;
+    validate: (automationId: string) => Promise<import("./graph-validation.js").AutomationGraphCompilation>;
+};
+export type AutomationDraftManager = ReturnType<typeof createAutomationDraftManager>;

package/dist/src/runtime/automations/draft-management.js

@@ -0,0 +1,164 @@
+import { randomUUID } from "node:crypto";
+import { requireUnarchivedAutomation } from "./archive-management.js";
+import { createEmptyAutomationDefinition, applyDraftMutation, parseDraftMutation } from "./draft-mutations.js";
+import { compileAutomationGraph } from "./graph-validation.js";
+import { applyAutomationDraftBatch, parseAutomationDraftBatch } from "./draft-batch.js";
+import { readPublishedDraftRestoration, restorePublishedAutomationDraft } from "./draft-restoration.js";
+function isSupportedDraftPlanAcceptance(value) {
+    if (value === undefined)
+        return true;
+    return typeof value === "function";
+}
+function requireDraftPlanAcceptance(result, accept) {
+    if (accept === undefined)
+        return;
+    if (accept(result) !== true)
+        throw new Error("automation_draft_plan_acceptance_invalid");
+}
+function draftStatus(draft, publishedRevision) {
+    if (draft.archivedAt)
+        return "archived";
+    return publishedRevision > 0 ? "paused" : "draft";
+}
+function hasPublishedAutomation(scheduler, state, automationId) {
+    if (state.definitions.some((item) => item.automationId === automationId))
+        return true;
+    return scheduler.jobs.some((job) => job.target?.kind === "automation" &&
+        job.target.automationId === automationId);
+}
+export function createAutomationDraftManager(options) {
+    const now = options.now ?? Date.now;
+    async function list() {
+        const state = await options.persistence.read();
+        return state.drafts
+            .map((draft) => {
+            const publishedRevision = state.definitions
+                .filter((item) => item.automationId === draft.automationId)
+                .reduce((latest, item) => Math.max(latest, item.revision), 0);
+            return {
+                id: draft.automationId,
+                title: draft.definition.title,
+                draftRevision: draft.revision,
+                updatedAt: draft.updatedAt,
+                ...(publishedRevision > 0 ? { publishedRevision } : {}),
+                status: draftStatus(draft, publishedRevision),
+            };
+        })
+            .sort((left, right) => left.title.localeCompare(right.title));
+    }
+    async function create(title, buildDefinition) {
+        return createWithAcceptance(title, buildDefinition);
+    }
+    async function createWithAcceptance(title, buildDefinition, acceptDraft) {
+        const cleanTitle = title.trim();
+        if (!cleanTitle || cleanTitle.length > 160)
+            throw new Error("automation_title_invalid");
+        const automationId = randomUUID();
+        const empty = createEmptyAutomationDefinition(automationId, cleanTitle);
+        const draft = {
+            id: `draft:${automationId}`,
+            automationId,
+            revision: 1,
+            definition: buildDefinition ? buildDefinition(empty) : empty,
+            updatedAt: new Date(now()).toISOString(),
+        };
+        return options.persistence.update((state) => {
+            acceptDraft?.(draft);
+            state.drafts.push(draft);
+            return draft;
+        });
+    }
+    async function get(automationId) {
+        const state = await options.persistence.read();
+        return state.drafts.find((item) => item.automationId === automationId) ?? null;
+    }
+    async function createPlan(title, value, accept) {
+        if (!isSupportedDraftPlanAcceptance(accept))
+            throw new Error("automation_draft_plan_acceptance_invalid");
+        const plan = parseAutomationDraftBatch(value);
+        let aliases = {};
+        const draft = await createWithAcceptance(title, (empty) => {
+            const built = applyAutomationDraftBatch(empty, plan, 1);
+            aliases = built.aliases;
+            return built.definition;
+        }, (candidate) => requireDraftPlanAcceptance({ draft: candidate, aliases }, accept));
+        return { draft, aliases };
+    }
+    async function applyPlan(automationId, expectedRevision, value, accept) {
+        if (!isSupportedDraftPlanAcceptance(accept))
+            throw new Error("automation_draft_plan_acceptance_invalid");
+        if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 1)
+            throw new Error("automation_revision_conflict");
+        const plan = parseAutomationDraftBatch(value);
+        return options.persistence.update((state) => {
+            const index = state.drafts.findIndex((item) => item.automationId === automationId);
+            if (index < 0)
+                throw new Error("automation_not_found");
+            const current = state.drafts[index];
+            requireUnarchivedAutomation(state, automationId);
+            if (current.revision !== expectedRevision)
+                throw new Error("automation_revision_conflict");
+            const built = applyAutomationDraftBatch(current.definition, plan, current.revision + 1);
+            const draft = {
+                ...current, definition: built.definition, revision: built.definition.revision,
+                storageRevision: (current.storageRevision ?? current.revision) + 1,
+                updatedAt: new Date(now()).toISOString(),
+            };
+            const result = { draft, aliases: built.aliases };
+            requireDraftPlanAcceptance(result, accept);
+            state.drafts[index] = draft;
+            return result;
+        });
+    }
+    async function deleteUnpublishedDraft(automationId, expectedRevision) {
+        if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 1)
+            throw new Error("automation_revision_conflict");
+        await options.persistence.updateWithScheduler((scheduler, state) => {
+            const index = state.drafts.findIndex((item) => item.automationId === automationId);
+            if (index < 0)
+                throw new Error("automation_not_found");
+            if (state.drafts[index].revision !== expectedRevision)
+                throw new Error("automation_revision_conflict");
+            if (hasPublishedAutomation(scheduler, state, automationId))
+                throw new Error("automation_draft_published");
+            state.drafts.splice(index, 1);
+            state.grants = state.grants.filter((item) => item.automationId !== automationId);
+        });
+    }
+    async function update(automationId, expectedRevision, mutation) {
+        if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 1)
+            throw new Error("automation_revision_conflict");
+        const publishedRevision = readPublishedDraftRestoration(mutation);
+        if (publishedRevision !== null)
+            return restorePublishedAutomationDraft({
+                persistence: options.persistence, automationId, expectedRevision, publishedRevision, now,
+            });
+        const parsed = parseDraftMutation(mutation);
+        return options.persistence.update((state) => {
+            const index = state.drafts.findIndex((item) => item.automationId === automationId);
+            if (index < 0)
+                throw new Error("automation_not_found");
+            const current = state.drafts[index];
+            requireUnarchivedAutomation(state, automationId);
+            if (current.revision !== expectedRevision)
+                throw new Error("automation_revision_conflict");
+            const definition = applyDraftMutation(current.definition, parsed);
+            const next = {
+                ...current,
+                revision: definition.revision,
+                storageRevision: (current.storageRevision ?? current.revision) + 1,
+                definition,
+                updatedAt: new Date(now()).toISOString(),
+            };
+            state.drafts[index] = next;
+            return next;
+        });
+    }
+    async function validate(automationId) {
+        const draft = await get(automationId);
+        if (!draft)
+            throw new Error("automation_not_found");
+        return compileAutomationGraph(draft.definition);
+    }
+    return { list, create, createPlan, applyPlan, get, deleteUnpublishedDraft, update, validate };
+}

package/dist/src/runtime/automations/draft-mutations.d.ts

@@ -0,0 +1,29 @@
+import type { AutomationRevision } from "./definition-contracts.js";
+export type DraftMutation = Readonly<{
+    kind: "add_node";
+    parentSequenceId: string;
+    index: number;
+    nodeWithoutId: Record<string, unknown>;
+}> | Readonly<{
+    kind: "update_node";
+    nodeId: string;
+    patch: Record<string, unknown>;
+}> | Readonly<{
+    kind: "remove_node";
+    nodeId: string;
+}> | Readonly<{
+    kind: "move_node";
+    nodeId: string;
+    parentSequenceId: string;
+    index: number;
+}> | Readonly<{
+    kind: "wrap_parallel";
+    nodeIds: readonly string[];
+}> | Readonly<{
+    kind: "update_definition";
+    patch: Record<string, unknown>;
+}>;
+export declare function parseDraftMutation(value: unknown): DraftMutation;
+/** A single structural mutation path for manual edits and model-authored edits. */
+export declare function applyDraftMutation(current: AutomationRevision, mutation: DraftMutation): AutomationRevision;
+export declare function createEmptyAutomationDefinition(automationId: string, title: string): AutomationRevision;

package/dist/src/runtime/automations/draft-mutations.js

@@ -0,0 +1,219 @@
+import { randomUUID } from "node:crypto";
+import { parseAutomationDefinition } from "./definition-input.js";
+import { DEFAULT_AUTOMATION_LIMITS } from "./limits.js";
+const DEFINITION_EDITABLE = new Set([
+    "title", "objective", "workingDirectory", "trigger", "source", "inputs", "limits",
+]);
+const NODE_EDITABLE = new Set([
+    "title", "onFailure", "operation", "controls", "payload", "modelProfileId",
+    "agentMode", "roleInstructions", "prompt", "inputs", "tools", "result",
+    "acceptance", "savedAgentOrigin",
+]);
+function error(code) {
+    throw new Error(code);
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requireRecord(value, code) {
+    if (!isRecord(value))
+        error(code);
+    return value;
+}
+function requireIndex(index, length) {
+    if (!Number.isSafeInteger(index) || Number(index) < 0 || Number(index) > length)
+        error("automation_graph_invalid");
+    return Number(index);
+}
+function requireMutationId(value) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 128)
+        error("automation_graph_invalid");
+    return value;
+}
+export function parseDraftMutation(value) {
+    const input = requireRecord(value, "automation_graph_invalid");
+    switch (input.kind) {
+        case "add_node":
+            return {
+                kind: "add_node",
+                parentSequenceId: requireMutationId(input.parentSequenceId),
+                index: Number(input.index),
+                nodeWithoutId: requireRecord(input.nodeWithoutId, "automation_graph_invalid"),
+            };
+        case "update_node":
+            return {
+                kind: "update_node",
+                nodeId: requireMutationId(input.nodeId),
+                patch: requireRecord(input.patch, "automation_graph_invalid"),
+            };
+        case "remove_node":
+            return { kind: "remove_node", nodeId: requireMutationId(input.nodeId) };
+        case "move_node":
+            return {
+                kind: "move_node",
+                nodeId: requireMutationId(input.nodeId),
+                parentSequenceId: requireMutationId(input.parentSequenceId),
+                index: Number(input.index),
+            };
+        case "wrap_parallel":
+            if (!Array.isArray(input.nodeIds) || !input.nodeIds.every((id) => typeof id === "string"))
+                error("automation_graph_invalid");
+            return { kind: "wrap_parallel", nodeIds: input.nodeIds };
+        case "update_definition":
+            return { kind: "update_definition", patch: requireRecord(input.patch, "automation_graph_invalid") };
+        default:
+            error("automation_graph_invalid");
+    }
+}
+function createNodeId() {
+    return `n_${randomUUID().replaceAll("-", "")}`;
+}
+function descendantsOf(node) {
+    if (node.kind === "sequence")
+        return node.children;
+    if (node.kind === "parallel")
+        return node.branches;
+    return [];
+}
+function findSequence(node, id) {
+    if (node.kind === "sequence" && node.id === id)
+        return node;
+    for (const child of descendantsOf(node)) {
+        const found = findSequence(child, id);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+function findNodeAndParent(node, id) {
+    if (node.kind === "sequence") {
+        const sequence = node;
+        const index = sequence.children.findIndex((child) => child.id === id);
+        if (index >= 0)
+            return { node: sequence.children[index], parent: sequence, index };
+    }
+    for (const child of descendantsOf(node)) {
+        const found = findNodeAndParent(child, id);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+function containsNode(node, id) {
+    if (node.id === id)
+        return true;
+    return descendantsOf(node).some((child) => containsNode(child, id));
+}
+function mutateNode(root, mutation) {
+    switch (mutation.kind) {
+        case "add_node": {
+            const parent = findSequence(root, mutation.parentSequenceId);
+            if (!parent)
+                error("automation_dependency_missing");
+            const supplied = requireRecord(mutation.nodeWithoutId, "automation_graph_invalid");
+            if ("id" in supplied || !["agent", "tool"].includes(String(supplied.kind)))
+                error("automation_graph_invalid");
+            const node = { ...supplied, id: createNodeId() };
+            parent.children.splice(requireIndex(mutation.index, parent.children.length), 0, node);
+            return;
+        }
+        case "update_node": {
+            const found = findNodeAndParent(root, mutation.nodeId);
+            if (!found)
+                error("automation_dependency_missing");
+            const patch = requireRecord(mutation.patch, "automation_graph_invalid");
+            if (Object.keys(patch).some((key) => !NODE_EDITABLE.has(key)))
+                error("automation_graph_invalid");
+            const normalized = { ...patch };
+            if (normalized.payload === null) {
+                if (found.node.kind !== "tool")
+                    error("automation_graph_invalid");
+                delete found.node.payload;
+                delete normalized.payload;
+            }
+            Object.assign(found.node, normalized);
+            return;
+        }
+        case "remove_node": {
+            const found = findNodeAndParent(root, mutation.nodeId);
+            if (!found)
+                error("automation_dependency_missing");
+            found.parent.children.splice(found.index, 1);
+            return;
+        }
+        case "move_node": {
+            const found = findNodeAndParent(root, mutation.nodeId);
+            const parent = findSequence(root, mutation.parentSequenceId);
+            if (!found || !parent)
+                error("automation_dependency_missing");
+            if (containsNode(found.node, parent.id))
+                error("automation_graph_invalid");
+            const sameParent = found.parent === parent;
+            const targetIndex = requireIndex(mutation.index, parent.children.length);
+            found.parent.children.splice(found.index, 1);
+            parent.children.splice(sameParent && targetIndex > found.index ? targetIndex - 1 : targetIndex, 0, found.node);
+            return;
+        }
+        case "wrap_parallel": {
+            const ids = mutation.nodeIds;
+            if (!Array.isArray(ids) || ids.length < 2 || ids.length > 8 || new Set(ids).size !== ids.length)
+                error("automation_graph_invalid");
+            const found = ids.map((id) => findNodeAndParent(root, id));
+            if (found.some((item) => !item))
+                error("automation_dependency_missing");
+            const siblings = found;
+            const parent = siblings[0].parent;
+            if (siblings.some((item) => item.parent !== parent || !["agent", "tool"].includes(item.node.kind)))
+                error("automation_graph_invalid");
+            const indices = siblings.map((item) => item.index).sort((left, right) => left - right);
+            if (indices.some((value, index) => value !== indices[0] + index))
+                error("automation_graph_invalid");
+            const selected = parent.children.splice(indices[0], ids.length);
+            const branches = selected.map((child) => ({ kind: "sequence", id: createNodeId(), children: [child] }));
+            parent.children.splice(indices[0], 0, { kind: "parallel", id: createNodeId(), branches });
+            return;
+        }
+        case "update_definition":
+            return;
+    }
+}
+/** A single structural mutation path for manual edits and model-authored edits. */
+export function applyDraftMutation(current, mutation) {
+    const changed = structuredClone(current);
+    if (mutation.kind === "update_definition") {
+        const patch = requireRecord(mutation.patch, "automation_graph_invalid");
+        if (Object.keys(patch).some((key) => !DEFINITION_EDITABLE.has(key)))
+            error("automation_graph_invalid");
+        const normalized = { ...patch };
+        if (normalized.source === null) {
+            delete changed.source;
+            delete normalized.source;
+        }
+        else if (isRecord(normalized.source) && normalized.source.sourceId === "") {
+            normalized.source = { ...normalized.source, sourceId: createNodeId() };
+        }
+        if (normalized.workingDirectory === null) {
+            delete changed.workingDirectory;
+            delete normalized.workingDirectory;
+        }
+        Object.assign(changed, normalized);
+    }
+    else {
+        mutateNode(changed.body, mutation);
+    }
+    changed.revision = current.revision + 1;
+    return parseAutomationDefinition(changed);
+}
+export function createEmptyAutomationDefinition(automationId, title) {
+    return {
+        schemaVersion: 1,
+        automationId,
+        revision: 1,
+        title,
+        objective: "",
+        trigger: { kind: "manual" },
+        inputs: {},
+        body: { kind: "sequence", id: createNodeId(), children: [] },
+        limits: { ...DEFAULT_AUTOMATION_LIMITS },
+    };
+}

package/dist/src/runtime/automations/draft-restoration.d.ts

@@ -0,0 +1,11 @@
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationDraftRecord } from "./storage-records.js";
+/** Publication restoration is a persisted command, not a pure graph mutation. */
+export declare function readPublishedDraftRestoration(value: unknown): number | null;
+export declare function restorePublishedAutomationDraft(options: {
+    persistence: AutomationPersistence;
+    automationId: string;
+    expectedRevision: number;
+    publishedRevision: number;
+    now: () => number;
+}): Promise<AutomationDraftRecord>;

package/dist/src/runtime/automations/draft-restoration.js

@@ -0,0 +1,44 @@
+import { requireUnarchivedAutomation } from "./archive-management.js";
+import { parseAutomationDefinition } from "./definition-input.js";
+import { isAutomationSchedulerJob } from "../scheduler/scheduler-target.js";
+/** Publication restoration is a persisted command, not a pure graph mutation. */
+export function readPublishedDraftRestoration(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const input = value;
+    if (input.kind !== "restore_published")
+        return null;
+    const keys = Object.keys(input);
+    const validKeys = keys.length === 2 && keys.every((key) => ["kind", "publishedRevision"].includes(key));
+    if (!validKeys || !Number.isSafeInteger(input.publishedRevision) || Number(input.publishedRevision) < 1)
+        throw new Error("automation_graph_invalid");
+    return Number(input.publishedRevision);
+}
+export function restorePublishedAutomationDraft(options) {
+    return options.persistence.updateWithScheduler((scheduler, state) => {
+        const index = state.drafts.findIndex((draft) => draft.automationId === options.automationId);
+        const current = state.drafts[index];
+        if (!current)
+            throw new Error("automation_not_found");
+        requireUnarchivedAutomation(state, options.automationId);
+        if (current.revision !== options.expectedRevision)
+            throw new Error("automation_revision_conflict");
+        const job = scheduler.jobs.find((candidate) => isAutomationSchedulerJob(candidate) &&
+            candidate.target.automationId === options.automationId);
+        if (!job || !isAutomationSchedulerJob(job))
+            throw new Error("automation_not_published");
+        if (job.target.definitionRevision !== options.publishedRevision)
+            throw new Error("automation_revision_conflict");
+        const published = state.definitions.find((definition) => definition.automationId === options.automationId && definition.revision === options.publishedRevision);
+        if (!published)
+            throw new Error("automation_not_published");
+        const definition = parseAutomationDefinition({ ...published.definition, revision: current.revision + 1 });
+        const restored = {
+            ...current, definition, revision: definition.revision,
+            storageRevision: (current.storageRevision ?? current.revision) + 1,
+            updatedAt: new Date(options.now()).toISOString(),
+        };
+        state.drafts[index] = restored;
+        return restored;
+    });
+}

package/dist/src/runtime/automations/effect-admission-lifetime.d.ts

@@ -0,0 +1,9 @@
+import type { RegisteredToolEffectPersistence } from "../adapters/registered-tool-normal-invocations/shared/contracts.js";
+import type { AutomationToolLifetimes } from "./tool-lifetimes.js";
+/** Holds only the admitted effect boundary, never the surrounding model request. */
+export declare function retainAutomationEffectAdmission(input: {
+    runId: string;
+    signal: AbortSignal;
+    lifetimes: AutomationToolLifetimes;
+    persistence: RegisteredToolEffectPersistence;
+}): RegisteredToolEffectPersistence;

package/dist/src/runtime/automations/effect-admission-lifetime.js

@@ -0,0 +1,31 @@
+/** Holds only the admitted effect boundary, never the surrounding model request. */
+export function retainAutomationEffectAdmission(input) {
+    const releases = new Map();
+    const releaseAdmission = (executionId) => {
+        releases.get(executionId)?.();
+        releases.delete(executionId);
+    };
+    return {
+        async beforeEffect(effect) {
+            if (releases.has(effect.executionId))
+                throw new Error("automation_attempt_duplicate");
+            const release = input.lifetimes.holdEffectAdmission(input.runId, input.signal);
+            releases.set(effect.executionId, release);
+            try {
+                return await input.persistence.beforeEffect(effect);
+            }
+            catch (error) {
+                releaseAdmission(effect.executionId);
+                throw error;
+            }
+        },
+        async afterEffect(effect) {
+            try {
+                await input.persistence.afterEffect(effect);
+            }
+            finally {
+                releaseAdmission(effect.executionId);
+            }
+        },
+    };
+}

package/dist/src/runtime/automations/failure-policy.d.ts

@@ -0,0 +1,8 @@
+export type AutomationFailureDisposition = Readonly<{
+    kind: "skip";
+    reason: "definite_failure";
+}> | Readonly<{
+    kind: "stop";
+    reason: "definite_failure" | "effect_uncertain";
+}>;
+export declare function decideAutomationFailureDisposition(configured: "stop" | "skip", settlement: "definite_failure" | "effect_uncertain"): AutomationFailureDisposition;

package/dist/src/runtime/automations/failure-policy.js

@@ -0,0 +1,9 @@
+export function decideAutomationFailureDisposition(configured, settlement) {
+    if (settlement === "effect_uncertain") {
+        return { kind: "stop", reason: "effect_uncertain" };
+    }
+    if (configured === "skip") {
+        return { kind: "skip", reason: "definite_failure" };
+    }
+    return { kind: "stop", reason: "definite_failure" };
+}

package/dist/src/runtime/automations/graph-executor.d.ts

@@ -0,0 +1,23 @@
+import type { AutomationRevision } from "./definition-contracts.js";
+import type { CompiledAutomationGraph, CompiledAutomationStep } from "./graph-validation.js";
+import type { AutomationNodeTransactions } from "./node-transactions.js";
+export type AutomationStepCompletion = Readonly<{
+    status: "succeeded" | "skipped" | "failed" | "cancelled" | "interrupted";
+    errorCode?: string;
+    uncertain?: boolean;
+}>;
+export type AutomationGraphOutcome = Readonly<{
+    status: "succeeded" | "completed_with_skips" | "failed" | "cancelled";
+    errorCode?: string;
+    nodeResults: ReadonlyMap<string, AutomationStepCompletion>;
+}>;
+export declare function executeAutomationGraph(input: {
+    runId: string;
+    automationId: string;
+    definition: AutomationRevision;
+    inputIds: readonly string[];
+    graph: CompiledAutomationGraph;
+    transactions: AutomationNodeTransactions;
+    abortSignal?: AbortSignal;
+    executeStep(step: CompiledAutomationStep, signal: AbortSignal): Promise<AutomationStepCompletion>;
+}): Promise<AutomationGraphOutcome>;