@abot-ai/runtime 1.5.0 → 1.6.0

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 } : {}),
+        },
+    };
+}

package/dist/src/runtime/automations/storage-records.d.ts

@@ -0,0 +1,133 @@
+import type { RuntimeAttachmentReference } from "../../shared/attachments.js";
+import type { SchedulerToolPermissionMode } from "../scheduler/tool-permission-mode.js";
+import type { AgentNode, AutomationRevision, OperationRef } from "./definition-contracts.js";
+export type AutomationDraftRecord = Readonly<{
+    id: string;
+    automationId: string;
+    revision: number;
+    definition: AutomationRevision;
+    updatedAt: string;
+    archivedAt?: string;
+    storageRevision?: number;
+}>;
+export type AutomationDefinitionRecord = Readonly<{
+    id: string;
+    automationId: string;
+    revision: number;
+    definition: AutomationRevision;
+    publishedAt: string;
+    /** Hash of selected tool contracts and applicable model configuration. */
+    dependencyFingerprint?: string;
+}>;
+export type AutomationSavedAgentRecord = Readonly<{
+    id: string;
+    agentId: string;
+    revision: number;
+    agent: AgentNode;
+    updatedAt: string;
+}>;
+export type AutomationGrantRecord = Readonly<{
+    id: string;
+    automationId: string;
+    environmentId: string;
+    grantRevision: number;
+    mode: SchedulerToolPermissionMode;
+    operations: readonly OperationRef[];
+    evidence: Readonly<{
+        kind: "authenticated_user_action";
+        actionId: string;
+        at: string;
+    }>;
+}>;
+export type AutomationInputRecord = Readonly<{
+    id: string;
+    automationId: string;
+    sourceId: string;
+    canonicalPath: string;
+    contentVersion: string;
+    observedAt: string;
+    observedSizeBytes?: number;
+    observedMtimeMs?: number;
+    observedCtimeMs?: number;
+    eligibility: "baseline" | "eligible" | "held";
+    /** One marker per source records that first activation was scanned, even if empty. */
+    baselineMarker?: true;
+    /** Existing retained versions excluded when this canonical root was first scanned. */
+    excludedInputIds?: readonly string[];
+    snapshot?: Readonly<{
+        attachment: RuntimeAttachmentReference;
+        contentVersion: string;
+        sizeBytes: number;
+    }>;
+    /** Durable cleanup marker; snapshot bytes are deleted before clearing this field. */
+    snapshotRetiredAt?: string;
+    claimRunId?: string;
+    outcomeRef?: string;
+}>;
+export type AutomationNodeStateRecord = Readonly<{
+    nodeId: string;
+    status: "pending" | "ready" | "running" | "succeeded" | "skipped" | "failed" | "cancelled" | "interrupted";
+    attemptId?: string;
+    resultRef?: string;
+    errorCode?: string;
+}>;
+export type AutomationExecutionRecord = Readonly<{
+    id: string;
+    automationId: string;
+    definitionRevision: number;
+    revision: number;
+    inputIds: readonly string[];
+    nodes: readonly AutomationNodeStateRecord[];
+    /** Counts every admitted model invocation, including failed calls. */
+    modelCalls?: number;
+    stopRequestedAt?: string;
+    reportRef?: string;
+    terminalAt?: string;
+    detailsExpiredAt?: string;
+    reportExpiredAt?: string;
+}>;
+export type AutomationAttemptRecord = Readonly<{
+    id: string;
+    runId: string;
+    nodeId: string;
+    invocationId: string;
+    fingerprint: string;
+    state: "started" | "settled" | "uncertain";
+    startedAt: string;
+    settledAt?: string;
+    settlementRef?: string;
+    /** Versioned evidence received after the original attempt became uncertain. */
+    lateSettlement?: Readonly<{
+        revision: number;
+        observedAt: string;
+        status: "succeeded" | "failed" | "rejected";
+        errorCode?: string;
+    }>;
+}>;
+export type AutomationResultRecord = Readonly<{
+    id: string;
+    runId: string;
+    nodeId?: string;
+    kind: "node_output" | "effect_receipt" | "report" | "artifact";
+    storageRef: string;
+    digest: string;
+    sizeBytes: number;
+    createdAt: string;
+}>;
+export type AutomationJournalState = {
+    schemaVersion: 1;
+    drafts: AutomationDraftRecord[];
+    definitions: AutomationDefinitionRecord[];
+    savedAgents: AutomationSavedAgentRecord[];
+    grants: AutomationGrantRecord[];
+    inputs: AutomationInputRecord[];
+    executions: AutomationExecutionRecord[];
+    attempts: AutomationAttemptRecord[];
+    results: AutomationResultRecord[];
+};
+export type AutomationCollection = Exclude<keyof AutomationJournalState, "schemaVersion">;
+export type AutomationStoredRecord = AutomationDraftRecord | AutomationDefinitionRecord | AutomationSavedAgentRecord | AutomationGrantRecord | AutomationInputRecord | AutomationExecutionRecord | AutomationAttemptRecord | AutomationResultRecord;
+export declare const AUTOMATION_COLLECTIONS: readonly ["drafts", "definitions", "savedAgents", "grants", "inputs", "executions", "attempts", "results"];
+export declare function emptyAutomationJournalState(): AutomationJournalState;
+export declare function parseAutomationStoredRecord(collection: AutomationCollection, value: unknown): AutomationStoredRecord;
+export declare function parseAutomationJournalState(value: unknown): AutomationJournalState;