@abot-ai/runtime 1.5.0 → 1.7.0

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

@@ -0,0 +1,278 @@
+import { randomUUID } from "node:crypto";
+import { hasToolAbortReceipt } from "../../capabilities/tool-interruption.js";
+import { getRequestFinalState } from "../../sessions/record/projection.js";
+import { createInMemoryLongTermMemoryRepository } from "../adapters/long-term-memory/in-memory-repository.js";
+import { createLongTermMemoryService } from "../long-term-memory/service.js";
+import { handleRunRequestWithOutcome } from "../request/handler.js";
+import { validateJsonSchemaValue } from "../model/json-schema-value.js";
+import { resolveModelSelection } from "../model/model-selection.js";
+import { permitsAutomationOperation, sameOperation } from "./permission-grants.js";
+import { readAutomationCatalog } from "./catalog.js";
+import { remainingAutomationResultBytes } from "./result-capacity.js";
+import { scopeToolRegistry } from "./agent-tool-scope.js";
+import { withAutomationAgentSession } from "./agent-session-lifetime.js";
+import { createAutomationAgentAssignment } from "./agent-assignment.js";
+import { automationAgentRequestFailureCode } from "./agent-request-failure.js";
+import { retainAutomationEffectAdmission } from "./effect-admission-lifetime.js";
+import { publishAutomationResult } from "./result-publication.js";
+const disabledMemory = createLongTermMemoryService({
+    repository: createInMemoryLongTermMemoryRepository(),
+    enabled: false,
+    emitClientEvents: false,
+});
+function parseAgentOutput(node, text) {
+    if (node.result.kind === "text")
+        return { text };
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new Error("automation_agent_output_invalid_json");
+    }
+    if (validateJsonSchemaValue(node.result.schema, data))
+        throw new Error("automation_agent_output_invalid_schema");
+    return { text, data: data };
+}
+function acceptedOutput(node, output) {
+    if (!node.acceptance?.length)
+        return true;
+    if (!output.data || typeof output.data !== "object" || Array.isArray(output.data))
+        return false;
+    const data = output.data;
+    return node.acceptance.every((test) => data[test.field] === test.equals);
+}
+export function createAutomationAgentStepExecutor(options) {
+    async function execute(input) {
+        const { node } = input;
+        if (input.signal.aborted)
+            return { status: "cancelled", errorCode: "automation_run_stopped" };
+        const selection = resolveModelSelection({
+            agentMode: node.agentMode,
+            modelPreference: { profileId: node.modelProfileId, scope: "all" },
+            modelPolicy: options.config.models,
+            modelExecutionPolicies: options.config.modelExecutionPolicies,
+        });
+        if (selection.execution.primaryProfileId !== node.modelProfileId)
+            return { status: "failed", errorCode: "automation_model_unavailable" };
+        const capturedGrant = await options.grants.get(options.automationId);
+        const catalog = await readAutomationCatalog({
+            automationId: options.automationId,
+            environmentId: options.config.runtimeId,
+            config: options.config,
+            tools: options.tools,
+            persistence: options.persistence,
+        });
+        const selected = node.tools.map((item) => item.operation);
+        if (selected.some((operation) => !catalog.operations.some((candidate) => sameOperation(operation, candidate))))
+            return { status: "failed", errorCode: "automation_operation_unavailable" };
+        if (selected.length > 0 && !capturedGrant)
+            return { status: "failed", errorCode: "automation_operation_unavailable" };
+        const effectAdmissions = new WeakMap();
+        const durableAttemptIds = new Map();
+        const admittedOperations = new Map();
+        const observeUnderlying = (invocationId, settled) => options.toolLifetimes.observe(options.runId, invocationId, settled);
+        const invokeTool = (invoke) => options.toolLifetimes.runInvocation(options.runId, input.signal, invoke);
+        const registry = {
+            ...scopeToolRegistry(options.tools, selected, effectAdmissions, admittedOperations, observeUnderlying, invokeTool),
+            prepareRequest: async (context) => {
+                const prepared = await options.tools.prepareRequest?.(context) ?? options.tools;
+                return scopeToolRegistry(prepared, selected, effectAdmissions, admittedOperations, observeUnderlying, invokeTool);
+            },
+        };
+        const sessionId = randomUUID();
+        const requestId = randomUUID();
+        const attemptId = randomUUID();
+        const origin = {
+            kind: "automation_node_v1",
+            automationId: options.automationId,
+            runId: options.runId,
+            nodeId: node.id,
+            attemptId,
+        };
+        const receipts = [];
+        const budgetedModels = {
+            ...options.models,
+            invoke: (params) => options.modelCapacity.withInvocation(params, options.config.models, async () => {
+                await options.transactions.recordModelCall(options.runId, node.id, options.definition.limits.maxModelCallsPerRun);
+                params.abortSignal.throwIfAborted();
+                return options.models.invoke(params);
+            }),
+            invokeRaw: (params) => options.modelCapacity.withInvocation(params, options.config.models, async () => {
+                await options.transactions.recordModelCall(options.runId, node.id, options.definition.limits.maxModelCallsPerRun);
+                params.abortSignal.throwIfAborted();
+                return options.models.invokeRaw(params);
+            }),
+        };
+        const durableEffects = {
+            beforeEffect: async (effect) => {
+                input.signal.throwIfAborted();
+                const allowed = node.tools.some((item) => sameOperation(item.operation, effect.source)) &&
+                    node.tools.some((item) => sameOperation(item.operation, effect.target));
+                const latest = await options.grants.get(options.automationId);
+                const available = await readAutomationCatalog({
+                    automationId: options.automationId,
+                    environmentId: options.config.runtimeId,
+                    config: options.config,
+                    tools: options.tools,
+                    persistence: options.persistence,
+                });
+                const source = available.operations.find((operation) => sameOperation(operation, effect.source));
+                const target = available.operations.find((operation) => sameOperation(operation, effect.target));
+                if (!allowed || !source || !target || !capturedGrant || !latest ||
+                    latest.grantRevision !== capturedGrant.grantRevision ||
+                    !permitsAutomationOperation(latest, options.config.runtimeId, options.automationId, effect.target, target.permissionMode))
+                    throw new Error("automation_operation_unavailable");
+                if (durableAttemptIds.has(effect.executionId))
+                    throw new Error("automation_attempt_duplicate");
+                const durableAttemptId = randomUUID();
+                durableAttemptIds.set(effect.executionId, durableAttemptId);
+                try {
+                    await options.transactions.recordAgentAttempt({
+                        runId: options.runId,
+                        nodeId: node.id,
+                        invocationId: durableAttemptId,
+                        fingerprint: effect.actionFingerprint,
+                        maxToolCalls: options.definition.limits.maxToolCallsPerRun,
+                    });
+                }
+                catch (error) {
+                    durableAttemptIds.delete(effect.executionId);
+                    throw error;
+                }
+                admittedOperations.set(durableAttemptId, effect.target);
+                const admission = Object.freeze({});
+                effectAdmissions.set(admission, durableAttemptId);
+                return admission;
+            },
+            afterEffect: async (effect) => {
+                const durableAttemptId = durableAttemptIds.get(effect.executionId);
+                const operation = durableAttemptId && admittedOperations.get(durableAttemptId);
+                if (!operation)
+                    throw new Error("automation_attempt_mismatch");
+                const state = await options.persistence.read();
+                const used = state.results.filter((item) => item.runId === options.runId)
+                    .reduce((sum, item) => sum + item.sizeBytes, 0);
+                const abortedMutatingEffect = effect.outcome.status === "executed" &&
+                    effect.outcome.effect !== "read_only" &&
+                    hasToolAbortReceipt(effect.outcome.result);
+                const uncertain = effect.outcome.status === "uncertain" || abortedMutatingEffect;
+                const record = await options.results.save({
+                    runId: options.runId,
+                    nodeId: node.id,
+                    kind: "effect_receipt",
+                    value: { operation, outcome: effect.outcome },
+                    maxBytes: Math.min(options.definition.limits.maxStoredArtifactBytes - used, remainingAutomationResultBytes(state)),
+                });
+                await publishAutomationResult({ ...options, record,
+                    publish: () => options.transactions.settleAgentAttempt({
+                        runId: options.runId,
+                        nodeId: node.id,
+                        invocationId: durableAttemptId,
+                        result: record,
+                        uncertain,
+                        // After admission, prepared-execution only rejects on its exact
+                        // aborted-before-dispatch branch; Tool results are "executed".
+                        notDispatched: effect.outcome.status === "rejected",
+                        maxStoredArtifactBytes: options.definition.limits.maxStoredArtifactBytes,
+                    }),
+                });
+                receipts.push({ operation, ok: !uncertain && effect.outcome.status === "executed" &&
+                        effect.outcome.result?.ok === true });
+            },
+        };
+        const effectPersistence = retainAutomationEffectAdmission({
+            runId: options.runId, signal: input.signal, lifetimes: options.toolLifetimes,
+            persistence: durableEffects,
+        });
+        const ws = { send: (_data) => undefined };
+        const prompt = createAutomationAgentAssignment({ definition: options.definition, node, inputs: input.inputs });
+        const scopedConfig = {
+            ...options.config,
+            paths: {
+                ...options.config.paths,
+                agentWorkDir: options.definition.workingDirectory ?? options.config.paths.agentWorkDir,
+            },
+        };
+        const completion = await withAutomationAgentSession({
+            sessions: options.sessions, attachments: options.attachments, sessionId, origin,
+        }, async (sessions) => {
+            await sessions.updateSessionTitle(sessionId, node.title);
+            const outcome = await handleRunRequestWithOutcome(ws, {
+                type: "run_request", requestId, sessionId, text: prompt,
+                agentMode: node.agentMode,
+                modelPreference: { profileId: node.modelProfileId, scope: "all" },
+                toolPermissionMode: capturedGrant?.mode ?? "full_access",
+            }, {
+                runtimeConfig: scopedConfig,
+                modelGatewayClient: budgetedModels,
+                sessionStore: sessions,
+                attachmentStore: options.attachments,
+                automationInputAttachments: input.sourceAttachments,
+                toolRegistry: registry,
+                longTermMemory: disabledMemory,
+                effectPersistence,
+                ...(node.result.kind === "json"
+                    ? { automationOutputContract: node.result.schema }
+                    : {}),
+                abortSignal: input.signal,
+                toolApprovalController: {
+                    requestToolApproval: async () => ({ approved: false,
+                        reason: "automation_approval_required" }),
+                },
+            });
+            const isBlockedRequest = outcome?.kind === "completed" && outcome.disposition === "blocked";
+            if (isBlockedRequest)
+                return { kind: "blocked" };
+            const session = await sessions.getSessionById(sessionId);
+            const request = session?.requests?.find((item) => item.requestId === requestId);
+            const final = request ? getRequestFinalState(request) : null;
+            if (final?.status !== "completed")
+                throw new Error(automationAgentRequestFailureCode(final?.error));
+            const message = session?.messages.find((item) => item.role === "assistant" &&
+                item.requestId === requestId);
+            if (!message)
+                throw new Error("automation_agent_result_missing");
+            for (const required of node.tools.filter((item) => item.usage === "required")) {
+                if (!receipts.some((item) => item.ok && sameOperation(item.operation, required.operation)))
+                    throw new Error("automation_required_operation_missing");
+            }
+            const output = parseAgentOutput(node, message.content);
+            return { kind: "result", output };
+        });
+        const isBlockedStep = completion.kind === "blocked";
+        const rejectedByAcceptance = !isBlockedStep && !acceptedOutput(node, completion.output);
+        const hasUnsettledRejectedEffect = (isBlockedStep || rejectedByAcceptance) &&
+            await options.transactions.hasUnsettledEffect(options.runId, node.id);
+        if (hasUnsettledRejectedEffect)
+            return { status: "failed", errorCode: "automation_effect_uncertain", uncertain: true };
+        if (isBlockedStep)
+            return { status: "failed", errorCode: "automation_agent_blocked" };
+        const output = completion.output;
+        const rejectedStatus = node.onFailure === "skip" ? "skipped" : "failed";
+        const stepCompletion = rejectedByAcceptance
+            ? { status: rejectedStatus, errorCode: "automation_agent_acceptance_failed" }
+            : { status: "succeeded" };
+        const state = await options.persistence.read();
+        const used = state.results.filter((item) => item.runId === options.runId)
+            .reduce((sum, item) => sum + item.sizeBytes, 0);
+        const record = await options.results.save({
+            runId: options.runId,
+            nodeId: node.id,
+            kind: "node_output",
+            value: output,
+            maxBytes: Math.min(options.definition.limits.maxStoredArtifactBytes - used, remainingAutomationResultBytes(state)),
+        });
+        await publishAutomationResult({ ...options, record,
+            publish: () => options.transactions.settleNode({
+                runId: options.runId,
+                nodeId: node.id,
+                ...stepCompletion,
+                result: record,
+                maxStoredArtifactBytes: options.definition.limits.maxStoredArtifactBytes,
+            }),
+        });
+        return stepCompletion;
+    }
+    return { execute };
+}

package/dist/src/runtime/automations/agent-tool-scope.d.ts

@@ -0,0 +1,4 @@
+import type { ToolUnderlyingSettlement } from "../../capabilities/tool-types.js";
+import type { ToolRegistry } from "../ports.js";
+import type { OperationRef } from "./definition-contracts.js";
+export declare function scopeToolRegistry(registry: ToolRegistry, selected: readonly OperationRef[], admissions: WeakMap<object, string>, admittedOperations: ReadonlyMap<string, OperationRef>, observeUnderlying: (invocationId: string, settled: Promise<ToolUnderlyingSettlement>) => void, invokeTool: <T>(invoke: () => Promise<T>) => Promise<T>): ToolRegistry;

package/dist/src/runtime/automations/agent-tool-scope.js

@@ -0,0 +1,73 @@
+import { sameOperation } from "./permission-grants.js";
+function selectedRegistrations(registry, selections) {
+    return (registry.listNormalInvocations?.() ?? []).flatMap((registration) => {
+        const operations = registration.contract.operations.filter((operation) => selections.some((selected) => sameOperation(selected, {
+            toolName: registration.toolName,
+            operationId: operation.operationId,
+            contractVersion: registration.contract.version,
+        })));
+        return operations.length > 0
+            ? [{ ...registration, contract: { ...registration.contract, operations } }]
+            : [];
+    });
+}
+function admittedAttachmentInput(registrations, toolName, admitted) {
+    if (!admitted)
+        return undefined;
+    const registration = registrations.find((item) => item.toolName === toolName);
+    return registration?.contract.operations.find((operation) => sameOperation(admitted, {
+        toolName: registration.toolName,
+        operationId: operation.operationId,
+        contractVersion: registration.contract.version,
+    }))?.attachmentInput;
+}
+/** Node-level admission can accept several MIME types; each operation receives only its own. */
+function scopeOperationAttachments(sharedState, attachmentInput) {
+    if (!sharedState)
+        return undefined;
+    const scoped = { ...sharedState };
+    if (!attachmentInput) {
+        delete scoped.requestAttachments;
+        return scoped;
+    }
+    if (!scoped.requestAttachments)
+        return scoped;
+    scoped.requestAttachments = scoped.requestAttachments.filter((attachment) => attachmentInput.acceptedMimeTypes.includes(attachment.mimeType));
+    return scoped;
+}
+export function scopeToolRegistry(registry, selected, admissions, admittedOperations, observeUnderlying, invokeTool) {
+    const registrations = selectedRegistrations(registry, selected);
+    const names = new Set(registrations.map((item) => item.toolName));
+    const definitions = registry.listDefinitions().filter((item) => names.has(item.name));
+    const implementations = Object.fromEntries(Object.entries(registry.getImplementations())
+        .filter(([name]) => names.has(name)));
+    return {
+        listDefinitions: () => definitions,
+        listNormalInvocations: () => registrations,
+        getDefinition: (name) => names.has(name) ? registry.getDefinition(name) : undefined,
+        ...(registry.getAdapter
+            ? { getAdapter: (name) => names.has(name) ? registry.getAdapter(name) : undefined }
+            : {}),
+        hasToolsAvailable: () => registrations.length > 0,
+        getImplementations: () => implementations,
+        ...(registry.prepareSharedState
+            ? { prepareSharedState: registry.prepareSharedState.bind(registry) }
+            : {}),
+        execute: (call, options) => {
+            const admission = options?.trustedEffectAdmission;
+            const invocationId = admission && admissions.get(admission);
+            const hasScopedAdmission = names.has(call.tool) && admission && invocationId;
+            if (!hasScopedAdmission)
+                return Promise.resolve({
+                    ok: false, tool: call.tool, output: "Operation unavailable to this automation.",
+                    producedNewInformation: false, errorCode: "automation_operation_unavailable",
+                });
+            admissions.delete(admission);
+            const attachmentInput = admittedAttachmentInput(registrations, call.tool, admittedOperations.get(invocationId));
+            const sharedState = scopeOperationAttachments(options?.sharedState, attachmentInput);
+            return invokeTool(() => registry.execute(call, { ...options, ...(sharedState ? { sharedState } : {}),
+                onUnderlyingSettlement: (settled) => observeUnderlying(invocationId, settled),
+            }));
+        },
+    };
+}

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

@@ -0,0 +1,26 @@
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationJournalState } from "./storage-records.js";
+export declare function requireUnarchivedAutomation(state: AutomationJournalState, automationId: string): void;
+export declare function createAutomationArchiveManager(options: {
+    persistence: AutomationPersistence;
+    now?: () => number;
+}): {
+    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;
+    }>>;
+};

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

@@ -0,0 +1,50 @@
+import { hasActiveAutomationRun } from "../scheduler/automation-run-records.js";
+import { isAutomationSchedulerJob } from "../scheduler/scheduler-target.js";
+export function requireUnarchivedAutomation(state, automationId) {
+    if (state.drafts.some((draft) => draft.automationId === automationId && draft.archivedAt !== undefined))
+        throw new Error("automation_archived");
+}
+export function createAutomationArchiveManager(options) {
+    const now = options.now ?? Date.now;
+    async function changeArchiveState(automationId, expectedRevision, archived) {
+        if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 1)
+            throw new Error("automation_revision_conflict");
+        return options.persistence.updateWithScheduler((scheduler, state) => {
+            const index = state.drafts.findIndex((draft) => draft.automationId === automationId);
+            const draft = state.drafts[index];
+            if (!draft)
+                throw new Error("automation_not_found");
+            if (draft.revision !== expectedRevision)
+                throw new Error("automation_revision_conflict");
+            const job = scheduler.jobs.find((candidate) => isAutomationSchedulerJob(candidate) &&
+                candidate.target.automationId === automationId);
+            const published = state.definitions.some((definition) => definition.automationId === automationId);
+            if (!job || !published)
+                throw new Error("automation_not_published");
+            if (hasActiveAutomationRun(scheduler, automationId))
+                throw new Error("automation_run_active");
+            if ((draft.archivedAt !== undefined) === archived)
+                return draft;
+            const at = new Date(now()).toISOString();
+            // Content revisions and published execution definitions remain unchanged.
+            const next = {
+                ...draft, updatedAt: at,
+                storageRevision: (draft.storageRevision ?? draft.revision) + 1,
+            };
+            if (archived)
+                next.archivedAt = at;
+            else
+                delete next.archivedAt;
+            job.state = "paused";
+            job.nextRunAt = null;
+            job.updatedAt = at;
+            job.revision += 1;
+            state.drafts[index] = next;
+            return next;
+        });
+    }
+    return {
+        archive: (automationId, expectedRevision) => changeArchiveState(automationId, expectedRevision, true),
+        restore: (automationId, expectedRevision) => changeArchiveState(automationId, expectedRevision, false),
+    };
+}

package/dist/src/runtime/automations/binding-resolution.d.ts

@@ -0,0 +1,28 @@
+import type { CapabilityJsonValue } from "../orchestration/capability-adapters/result.js";
+import type { SourceFileSnapshot, ValueBinding } from "./definition-contracts.js";
+export type SettledNodeResult = Readonly<{
+    status: "succeeded" | "skipped" | "failed" | "cancelled" | "interrupted";
+    text?: string;
+    data?: CapabilityJsonValue;
+    resultRef?: string;
+}>;
+export type BranchResult = Readonly<{
+    nodeId: string;
+    status: SettledNodeResult["status"];
+    resultRef?: string;
+}>;
+export type AutomationBindingContext = Readonly<{
+    runId?: string;
+    runInputs: Readonly<Record<string, CapabilityJsonValue>>;
+    sourceFiles: readonly SourceFileSnapshot[];
+    nodeResults: ReadonlyMap<string, SettledNodeResult>;
+    branchResults: ReadonlyMap<string, readonly BranchResult[]>;
+}>;
+export type AutomationBindingResolution = Readonly<{
+    ok: true;
+    value: CapabilityJsonValue;
+}> | Readonly<{
+    ok: false;
+    code: "automation_dependency_missing" | "automation_output_pointer_invalid";
+}>;
+export declare function resolveAutomationBinding(binding: ValueBinding, context: AutomationBindingContext): AutomationBindingResolution;

package/dist/src/runtime/automations/binding-resolution.js

@@ -0,0 +1,115 @@
+import { automationRunFilePath } from "./run-file-binding.js";
+const MISSING = Object.freeze({
+    ok: false,
+    code: "automation_dependency_missing",
+});
+function resolvePointer(value, pointer) {
+    if (!pointer.startsWith("/")) {
+        return { ok: false, code: "automation_output_pointer_invalid" };
+    }
+    let selected = value;
+    for (const segment of pointer.slice(1).split("/")) {
+        if (/~(?![01])/u.test(segment)) {
+            return { ok: false, code: "automation_output_pointer_invalid" };
+        }
+        const key = segment.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+            return { ok: false, code: "automation_output_pointer_invalid" };
+        }
+        if (Array.isArray(selected)) {
+            if (!/^(0|[1-9][0-9]*)$/u.test(key))
+                return MISSING;
+            const index = Number(key);
+            if (!Number.isSafeInteger(index) || index >= selected.length)
+                return MISSING;
+            selected = selected[index];
+            continue;
+        }
+        if (typeof selected !== "object" || selected === null || !Object.hasOwn(selected, key)) {
+            return MISSING;
+        }
+        selected = selected[key];
+    }
+    return { ok: true, value: selected };
+}
+function sourceFileValue(file) {
+    return {
+        inputId: file.inputId,
+        sourceId: file.sourceId,
+        originalPath: file.originalPath,
+        snapshotPath: file.snapshotPath,
+        version: file.version,
+        sizeBytes: file.sizeBytes,
+    };
+}
+function selectedSourceField(file, field) {
+    switch (field) {
+        case "snapshot_path": return file.snapshotPath;
+        case "original_path": return file.originalPath;
+        case "version": return file.version;
+    }
+}
+function resolveSettledNodeResult(binding, context) {
+    const result = context.nodeResults.get(binding.nodeId);
+    if (result?.status !== "succeeded")
+        return MISSING;
+    const value = binding.select === "text" ? result.text : result.data;
+    if (value === undefined)
+        return MISSING;
+    if (binding.pointer === undefined)
+        return { ok: true, value };
+    if (binding.select !== "data") {
+        return { ok: false, code: "automation_output_pointer_invalid" };
+    }
+    return resolvePointer(value, binding.pointer);
+}
+function resolveParallelResults(parallelNodeId, context) {
+    const branches = context.branchResults.get(parallelNodeId);
+    if (!branches)
+        return MISSING;
+    const values = [];
+    for (const branch of branches) {
+        if (branch.status !== "succeeded") {
+            values.push({ ...branch });
+            continue;
+        }
+        const result = context.nodeResults.get(branch.nodeId);
+        if (result?.status !== "succeeded")
+            return MISSING;
+        const hasMaterializedOutput = result.text !== undefined || result.data !== undefined;
+        if (!hasMaterializedOutput)
+            return MISSING;
+        values.push({
+            ...branch,
+            ...(result.text !== undefined ? { text: result.text } : {}),
+            ...(result.data !== undefined ? { data: result.data } : {}),
+        });
+    }
+    return { ok: true, value: values };
+}
+export function resolveAutomationBinding(binding, context) {
+    switch (binding.kind) {
+        case "literal":
+            return { ok: true, value: binding.value };
+        case "run_input":
+            return Object.hasOwn(context.runInputs, binding.input)
+                ? { ok: true, value: context.runInputs[binding.input] }
+                : MISSING;
+        case "run_file": {
+            const value = automationRunFilePath(context.runId, binding.fileName);
+            return value === null ? MISSING : { ok: true, value };
+        }
+        case "source_files":
+            return { ok: true, value: context.sourceFiles.map(sourceFileValue) };
+        case "source_file": {
+            const file = context.sourceFiles[binding.index];
+            if (!file)
+                return MISSING;
+            return { ok: true, value: selectedSourceField(file, binding.field) };
+        }
+        case "node_result":
+            return resolveSettledNodeResult(binding, context);
+        case "branch_results":
+            return resolveParallelResults(binding.parallelNodeId, context);
+    }
+}

package/dist/src/runtime/automations/branch-result-projection.d.ts

@@ -0,0 +1,4 @@
+import type { BranchResult, SettledNodeResult } from "./binding-resolution.js";
+import type { CompiledParallelGroup } from "./graph-validation.js";
+/** A join projects only its terminal producers; earlier outputs need explicit bindings. */
+export declare function projectAutomationBranchResults(groups: readonly CompiledParallelGroup[], settled: ReadonlyMap<string, SettledNodeResult>): ReadonlyMap<string, readonly BranchResult[]>;

package/dist/src/runtime/automations/branch-result-projection.js

@@ -0,0 +1,15 @@
+/** A join projects only its terminal producers; earlier outputs need explicit bindings. */
+export function projectAutomationBranchResults(groups, settled) {
+    const projected = new Map();
+    for (const group of groups) {
+        const hasSettledBranchTails = group.tailNodeIds.every((id) => settled.has(id));
+        if (!hasSettledBranchTails)
+            continue;
+        projected.set(group.id, group.tailNodeIds.map((nodeId) => {
+            const result = settled.get(nodeId);
+            return { nodeId, status: result.status,
+                ...(result.resultRef ? { resultRef: result.resultRef } : {}) };
+        }));
+    }
+    return projected;
+}