@hexabot-ai/agentic 3.0.1-alpha.0

package/dist/cjs/index.js

@@ -0,0 +1,52 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = exports.sleep = exports.toSnakeCase = exports.isSnakeCaseName = exports.assertSnakeCaseName = exports.createDeferred = exports.mergeSettings = exports.evaluateValue = exports.evaluateMapping = exports.compileValue = exports.NonDeterministicWorkflowError = exports.StepType = exports.WorkflowRunner = exports.WorkflowEventEmitter = exports.Workflow = exports.compileWorkflow = exports.BaseWorkflowContext = exports.defineAction = exports.AbstractAction = void 0;
+var abstract_action_1 = require("./action/abstract-action");
+Object.defineProperty(exports, "AbstractAction", { enumerable: true, get: function () { return abstract_action_1.AbstractAction; } });
+var action_1 = require("./action/action");
+Object.defineProperty(exports, "defineAction", { enumerable: true, get: function () { return action_1.defineAction; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "BaseWorkflowContext", { enumerable: true, get: function () { return context_1.BaseWorkflowContext; } });
+__exportStar(require("./dsl.types"), exports);
+var workflow_1 = require("./workflow");
+Object.defineProperty(exports, "compileWorkflow", { enumerable: true, get: function () { return workflow_1.compileWorkflow; } });
+Object.defineProperty(exports, "Workflow", { enumerable: true, get: function () { return workflow_1.Workflow; } });
+Object.defineProperty(exports, "WorkflowEventEmitter", { enumerable: true, get: function () { return workflow_1.WorkflowEventEmitter; } });
+Object.defineProperty(exports, "WorkflowRunner", { enumerable: true, get: function () { return workflow_1.WorkflowRunner; } });
+var workflow_event_emitter_1 = require("./workflow-event-emitter");
+Object.defineProperty(exports, "StepType", { enumerable: true, get: function () { return workflow_event_emitter_1.StepType; } });
+var runner_runtime_control_1 = require("./runner-runtime-control");
+Object.defineProperty(exports, "NonDeterministicWorkflowError", { enumerable: true, get: function () { return runner_runtime_control_1.NonDeterministicWorkflowError; } });
+var workflow_values_1 = require("./workflow-values");
+Object.defineProperty(exports, "compileValue", { enumerable: true, get: function () { return workflow_values_1.compileValue; } });
+Object.defineProperty(exports, "evaluateMapping", { enumerable: true, get: function () { return workflow_values_1.evaluateMapping; } });
+Object.defineProperty(exports, "evaluateValue", { enumerable: true, get: function () { return workflow_values_1.evaluateValue; } });
+Object.defineProperty(exports, "mergeSettings", { enumerable: true, get: function () { return workflow_values_1.mergeSettings; } });
+var deferred_1 = require("./utils/deferred");
+Object.defineProperty(exports, "createDeferred", { enumerable: true, get: function () { return deferred_1.createDeferred; } });
+var naming_1 = require("./utils/naming");
+Object.defineProperty(exports, "assertSnakeCaseName", { enumerable: true, get: function () { return naming_1.assertSnakeCaseName; } });
+Object.defineProperty(exports, "isSnakeCaseName", { enumerable: true, get: function () { return naming_1.isSnakeCaseName; } });
+Object.defineProperty(exports, "toSnakeCase", { enumerable: true, get: function () { return naming_1.toSnakeCase; } });
+var timeout_1 = require("./utils/timeout");
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return timeout_1.sleep; } });
+Object.defineProperty(exports, "withTimeout", { enumerable: true, get: function () { return timeout_1.withTimeout; } });

package/dist/cjs/runner-runtime-control.js

@@ -0,0 +1,343 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerRuntimeControl = exports.NonDeterministicWorkflowError = void 0;
+const deferred_1 = require("./utils/deferred");
+const INDEX_KEY_PREFIX = 'index:';
+const USER_KEY_PREFIX = 'key:';
+class NonDeterministicWorkflowError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NonDeterministicWorkflowError';
+    }
+}
+exports.NonDeterministicWorkflowError = NonDeterministicWorkflowError;
+/** Minimal wrapper that exposes runner controls to actions via the context. */
+class RunnerRuntimeControl {
+    constructor(runner) {
+        this.pendingSuspensions = new Map();
+        this.suspensionWaiters = new Map();
+        this.primedResumeData = new Map();
+        this.stepAttempts = new Map();
+        this.activeStepExecutions = new Map();
+        this.replaySeeds = new Map();
+        this.runner = runner;
+    }
+    get status() {
+        return this.runner.getStatus();
+    }
+    get resumeData() {
+        return this.runner.getLastResumeData();
+    }
+    suspend(options) {
+        const currentStep = this.runner.getCurrentStep();
+        if (!currentStep) {
+            throw new Error('workflow.suspend() can only be called while a workflow step is running.');
+        }
+        const execution = this.ensureStepExecution(currentStep.id);
+        execution.suspendCursor += 1;
+        const suspendIndex = execution.suspendCursor;
+        const suspendKey = buildSuspendKey(suspendIndex, options?.key);
+        this.assertReplayExpectation(execution, {
+            suspendIndex,
+            suspendKey,
+            reason: options?.reason,
+        });
+        if (execution.awaitResults.has(suspendKey)) {
+            return Promise.resolve(execution.awaitResults.get(suspendKey));
+        }
+        const primed = this.dequeuePrimedResumeData(currentStep.id);
+        if (primed.found) {
+            return Promise.resolve(primed.value);
+        }
+        const request = {
+            stepId: currentStep.id,
+            stepExecId: execution.stepExecId,
+            suspendIndex,
+            suspendKey,
+            reason: options?.reason,
+            data: options?.data,
+            awaitResults: this.serializeAwaitResults(execution.awaitResults),
+            resume: (0, deferred_1.createDeferred)(),
+        };
+        this.enqueueSuspension(request);
+        return request.resume.promise;
+    }
+    resume(data) {
+        void this.runner.resume({ resumeData: data });
+    }
+    waitForStepSuspension(stepId) {
+        const queued = this.dequeueStepSuspension(stepId);
+        if (queued) {
+            return Promise.resolve(queued);
+        }
+        return new Promise((resolve) => {
+            const waiters = this.suspensionWaiters.get(stepId) ?? [];
+            waiters.push(resolve);
+            this.suspensionWaiters.set(stepId, waiters);
+        });
+    }
+    beginStepExecution(stepId) {
+        const existing = this.activeStepExecutions.get(stepId);
+        if (existing) {
+            return existing.stepExecId;
+        }
+        const seeded = this.replaySeeds.get(stepId);
+        if (seeded) {
+            const execution = {
+                stepId,
+                stepExecId: seeded.stepExecId,
+                suspendCursor: 0,
+                awaitResults: this.normalizeAwaitResults(seeded.awaitResults),
+                replayExpectation: seeded.activeSuspension
+                    ? {
+                        suspendIndex: seeded.activeSuspension.suspendIndex,
+                        suspendKey: normalizeSuspendKey(seeded.activeSuspension.suspendIndex, seeded.activeSuspension.suspendKey) ?? buildSuspendKey(seeded.activeSuspension.suspendIndex ?? 1),
+                        reason: seeded.activeSuspension.reason,
+                        matched: false,
+                    }
+                    : undefined,
+            };
+            this.activeStepExecutions.set(stepId, execution);
+            this.replaySeeds.delete(stepId);
+            this.bumpStepAttemptCounter(stepId, execution.stepExecId);
+            return execution.stepExecId;
+        }
+        const attempt = (this.stepAttempts.get(stepId) ?? 0) + 1;
+        const stepExecId = `${stepId}#${attempt}`;
+        this.stepAttempts.set(stepId, attempt);
+        this.activeStepExecutions.set(stepId, {
+            stepId,
+            stepExecId,
+            suspendCursor: 0,
+            awaitResults: new Map(),
+        });
+        return stepExecId;
+    }
+    prepareStepReplay(seed) {
+        const normalizedAwaitResults = this.serializeAwaitResults(this.normalizeAwaitResults(seed.awaitResults ?? {}));
+        this.replaySeeds.set(seed.stepId, {
+            stepExecId: seed.stepExecId,
+            awaitResults: normalizedAwaitResults,
+            activeSuspension: seed.activeSuspension
+                ? {
+                    suspendIndex: seed.activeSuspension.suspendIndex,
+                    suspendKey: normalizeSuspendKey(seed.activeSuspension.suspendIndex, seed.activeSuspension.suspendKey),
+                    reason: seed.activeSuspension.reason,
+                }
+                : undefined,
+        });
+        this.bumpStepAttemptCounter(seed.stepId, seed.stepExecId);
+    }
+    recordStepSuspendResult(params) {
+        const suspendKey = normalizeSuspendKey(params.suspendIndex, params.suspendKey);
+        if (!suspendKey) {
+            this.primeStepResumeData(params.stepId, params.resumeData);
+            return;
+        }
+        const activeExecution = this.activeStepExecutions.get(params.stepId);
+        if (activeExecution &&
+            (!params.stepExecId || params.stepExecId === activeExecution.stepExecId)) {
+            if (!activeExecution.awaitResults.has(suspendKey)) {
+                activeExecution.awaitResults.set(suspendKey, params.resumeData);
+            }
+            return;
+        }
+        const replaySeed = this.replaySeeds.get(params.stepId);
+        if (replaySeed) {
+            if (params.stepExecId && replaySeed.stepExecId !== params.stepExecId) {
+                return;
+            }
+            replaySeed.awaitResults[suspendKey] =
+                replaySeed.awaitResults[suspendKey] ?? params.resumeData;
+            this.replaySeeds.set(params.stepId, replaySeed);
+            return;
+        }
+        const fallbackExecId = params.stepExecId ?? `${params.stepId}#1`;
+        this.replaySeeds.set(params.stepId, {
+            stepExecId: fallbackExecId,
+            awaitResults: { [suspendKey]: params.resumeData },
+        });
+        this.bumpStepAttemptCounter(params.stepId, fallbackExecId);
+    }
+    clearStepSuspensions(stepId, error) {
+        const queued = this.pendingSuspensions.get(stepId);
+        if (queued) {
+            for (const request of queued) {
+                request.resume.reject(error ?? new Error(`Suspension for step "${stepId}" was cancelled.`));
+            }
+        }
+        const execution = this.activeStepExecutions.get(stepId);
+        this.pendingSuspensions.delete(stepId);
+        this.suspensionWaiters.delete(stepId);
+        this.primedResumeData.delete(stepId);
+        this.activeStepExecutions.delete(stepId);
+        if (!error &&
+            execution?.replayExpectation &&
+            !execution.replayExpectation.matched) {
+            throw new NonDeterministicWorkflowError(`Replay for step "${stepId}" did not reach expected suspension ` +
+                `"${execution.replayExpectation.suspendKey}".`);
+        }
+    }
+    primeStepResumeData(stepId, resumeData) {
+        const queued = this.primedResumeData.get(stepId) ?? [];
+        queued.push(resumeData);
+        this.primedResumeData.set(stepId, queued);
+    }
+    getSnapshot() {
+        return this.runner.getSnapshot();
+    }
+    enqueueSuspension(request) {
+        const waiters = this.suspensionWaiters.get(request.stepId);
+        if (waiters && waiters.length > 0) {
+            const resolve = waiters.shift();
+            if (!resolve) {
+                return;
+            }
+            if (waiters.length === 0) {
+                this.suspensionWaiters.delete(request.stepId);
+            }
+            else {
+                this.suspensionWaiters.set(request.stepId, waiters);
+            }
+            resolve(request);
+            return;
+        }
+        const queued = this.pendingSuspensions.get(request.stepId) ?? [];
+        queued.push(request);
+        this.pendingSuspensions.set(request.stepId, queued);
+    }
+    dequeueStepSuspension(stepId) {
+        const queued = this.pendingSuspensions.get(stepId);
+        if (!queued || queued.length === 0) {
+            return undefined;
+        }
+        const request = queued.shift();
+        if (queued.length === 0) {
+            this.pendingSuspensions.delete(stepId);
+        }
+        else {
+            this.pendingSuspensions.set(stepId, queued);
+        }
+        return request;
+    }
+    dequeuePrimedResumeData(stepId) {
+        const queued = this.primedResumeData.get(stepId);
+        if (!queued || queued.length === 0) {
+            return { found: false };
+        }
+        const value = queued.shift();
+        if (queued.length === 0) {
+            this.primedResumeData.delete(stepId);
+        }
+        else {
+            this.primedResumeData.set(stepId, queued);
+        }
+        return { found: true, value };
+    }
+    ensureStepExecution(stepId) {
+        const existing = this.activeStepExecutions.get(stepId);
+        if (existing) {
+            return existing;
+        }
+        this.beginStepExecution(stepId);
+        const created = this.activeStepExecutions.get(stepId);
+        if (!created) {
+            throw new Error(`Unable to create runtime state for step "${stepId}".`);
+        }
+        return created;
+    }
+    assertReplayExpectation(execution, encountered) {
+        const expectation = execution.replayExpectation;
+        if (!expectation || expectation.matched) {
+            return;
+        }
+        if (encountered.suspendKey === expectation.suspendKey) {
+            if (expectation.reason !== undefined &&
+                encountered.reason !== expectation.reason) {
+                throw new NonDeterministicWorkflowError(`Replay for step "${execution.stepId}" reached suspend ` +
+                    `"${encountered.suspendKey}" with reason "${encountered.reason ?? ''}", ` +
+                    `expected reason "${expectation.reason}".`);
+            }
+            expectation.matched = true;
+            return;
+        }
+        if (execution.awaitResults.has(encountered.suspendKey)) {
+            return;
+        }
+        throw new NonDeterministicWorkflowError(`Replay for step "${execution.stepId}" reached unexpected suspend ` +
+            `"${encountered.suspendKey}" before expected ` +
+            `"${expectation.suspendKey}".`);
+    }
+    normalizeAwaitResults(awaitResults) {
+        const normalized = new Map();
+        for (const [rawKey, value] of Object.entries(awaitResults)) {
+            const normalizedKey = normalizeStoredSuspendKey(rawKey);
+            normalized.set(normalizedKey, value);
+        }
+        return normalized;
+    }
+    serializeAwaitResults(awaitResults) {
+        return Object.fromEntries(awaitResults.entries());
+    }
+    bumpStepAttemptCounter(stepId, stepExecId) {
+        const parsedAttempt = parseStepExecAttempt(stepId, stepExecId);
+        if (parsedAttempt === null) {
+            return;
+        }
+        const previous = this.stepAttempts.get(stepId) ?? 0;
+        if (parsedAttempt > previous) {
+            this.stepAttempts.set(stepId, parsedAttempt);
+        }
+    }
+}
+exports.RunnerRuntimeControl = RunnerRuntimeControl;
+const buildSuspendKey = (suspendIndex, key) => {
+    if (key) {
+        return `${USER_KEY_PREFIX}${key}`;
+    }
+    return `${INDEX_KEY_PREFIX}${suspendIndex}`;
+};
+const normalizeSuspendKey = (suspendIndex, suspendKey) => {
+    if (typeof suspendKey === 'string' && suspendKey.length > 0) {
+        if (suspendKey.startsWith(INDEX_KEY_PREFIX) ||
+            suspendKey.startsWith(USER_KEY_PREFIX)) {
+            return suspendKey;
+        }
+        if (/^\d+$/.test(suspendKey)) {
+            return `${INDEX_KEY_PREFIX}${suspendKey}`;
+        }
+        return `${USER_KEY_PREFIX}${suspendKey}`;
+    }
+    if (typeof suspendIndex === 'number' &&
+        Number.isInteger(suspendIndex) &&
+        suspendIndex > 0) {
+        return `${INDEX_KEY_PREFIX}${suspendIndex}`;
+    }
+    return undefined;
+};
+const normalizeStoredSuspendKey = (rawKey) => {
+    if (rawKey.startsWith(INDEX_KEY_PREFIX) ||
+        rawKey.startsWith(USER_KEY_PREFIX)) {
+        return rawKey;
+    }
+    if (/^\d+$/.test(rawKey)) {
+        return `${INDEX_KEY_PREFIX}${rawKey}`;
+    }
+    return `${USER_KEY_PREFIX}${rawKey}`;
+};
+const parseStepExecAttempt = (stepId, stepExecId) => {
+    const prefix = `${stepId}#`;
+    if (!stepExecId.startsWith(prefix)) {
+        return null;
+    }
+    const numeric = Number.parseInt(stepExecId.slice(prefix.length), 10);
+    if (Number.isNaN(numeric) || numeric < 1) {
+        return null;
+    }
+    return numeric;
+};

package/dist/cjs/step-executors/conditional-executor.js

@@ -0,0 +1,63 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeConditional = executeConditional;
+const workflow_values_1 = require("../workflow-values");
+const skip_helpers_1 = require("./skip-helpers");
+/**
+ * Evaluate a conditional step by checking branches in order and executing the first match.
+ *
+ * @param env Executor environment providing helpers and workflow context.
+ * @param step The conditional step definition.
+ * @param state Mutable workflow execution state.
+ * @param path Path tokens locating this step within the workflow tree.
+ * @returns A suspension if a branch pauses execution, otherwise void.
+ */
+async function executeConditional(env, step, state, path) {
+    for (let index = 0; index < step.branches.length; index += 1) {
+        const branch = step.branches[index];
+        const scope = {
+            input: state.input,
+            context: env.context.state,
+            output: state.output,
+            iteration: state.iteration,
+            accumulator: state.accumulator,
+        };
+        const conditionResult = branch.condition !== undefined
+            ? await (0, workflow_values_1.evaluateValue)(branch.condition, scope)
+            : true;
+        if (conditionResult) {
+            step.branches.forEach((candidate, candidateIndex) => {
+                if (candidateIndex !== index) {
+                    (0, skip_helpers_1.markStepsSkipped)(env, candidate.steps, state.iterationStack);
+                }
+            });
+            const suspension = await env.executeFlow(branch.steps, state, [
+                ...path,
+                'branch',
+                index,
+            ]);
+            if (suspension) {
+                return {
+                    ...suspension,
+                    continue: async (resumeData) => {
+                        const next = await suspension.continue(resumeData);
+                        if (next) {
+                            return next;
+                        }
+                        return undefined;
+                    },
+                };
+            }
+            return undefined;
+        }
+    }
+    if (step.branches.length > 0) {
+        step.branches.forEach((branch) => (0, skip_helpers_1.markStepsSkipped)(env, branch.steps, state.iterationStack));
+    }
+    return undefined;
+}

package/dist/cjs/step-executors/loop-executor.js

@@ -0,0 +1,187 @@
+"use strict";
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeLoop = executeLoop;
+exports.updateAccumulator = updateAccumulator;
+exports.shouldStopLoop = shouldStopLoop;
+const workflow_values_1 = require("../workflow-values");
+/**
+ * Execute a loop step by iterating over input items and executing child steps.
+ *
+ * @param env Executor environment with helpers and workflow context.
+ * @param step The loop step configuration.
+ * @param state Mutable workflow execution state.
+ * @param path Path tokens locating this loop within the workflow.
+ * @param startIndex Index to resume iteration from when continuing.
+ * @returns A suspension if a child step pauses execution, otherwise void.
+ */
+async function executeLoop(env, step, state, path, startIndex = 0) {
+    if (step.loopType === 'for_each') {
+        return executeForEachLoop(env, step, state, path, startIndex);
+    }
+    return executeWhileLoop(env, step, state, path, startIndex);
+}
+async function executeForEachLoop(env, step, state, path, startIndex) {
+    const scope = {
+        input: state.input,
+        context: env.context.state,
+        output: state.output,
+        iteration: state.iteration,
+        accumulator: state.accumulator,
+    };
+    const items = await (0, workflow_values_1.evaluateValue)(step.forEach.in, scope);
+    const iterable = Array.isArray(items) ? items : [];
+    let accumulator = step.accumulate?.initial ?? state.accumulator;
+    for (let index = startIndex; index < iterable.length; index += 1) {
+        const item = iterable[index];
+        const iterationState = {
+            ...state,
+            iteration: { item, index },
+            accumulator,
+            iterationStack: [...state.iterationStack, index],
+        };
+        const suspension = await env.executeFlow(step.steps, iterationState, [
+            ...path,
+            index,
+        ]);
+        if (suspension) {
+            return {
+                ...suspension,
+                continue: async (resumeData) => {
+                    const next = await suspension.continue(resumeData);
+                    if (next) {
+                        return next;
+                    }
+                    const postScope = buildScope(env, iterationState, { item, index }, accumulator);
+                    accumulator = await updateAccumulator(step, postScope, accumulator);
+                    const shouldStop = await shouldStopLoop(step, postScope);
+                    if (shouldStop) {
+                        state.accumulator = accumulator;
+                        if (step.accumulate && step.name) {
+                            state.output[step.name] = { [step.accumulate.as]: accumulator };
+                        }
+                        return undefined;
+                    }
+                    return executeForEachLoop(env, step, {
+                        ...iterationState,
+                        accumulator,
+                        iterationStack: state.iterationStack,
+                    }, path, index + 1);
+                },
+            };
+        }
+        const postScope = buildScope(env, iterationState, { item, index }, accumulator);
+        accumulator = await updateAccumulator(step, postScope, accumulator);
+        const shouldStop = await shouldStopLoop(step, postScope);
+        if (shouldStop) {
+            break;
+        }
+        state.output = iterationState.output;
+    }
+    finalizeAccumulatorState(step, state, accumulator);
+    return undefined;
+}
+async function executeWhileLoop(env, step, state, path, startIndex) {
+    let accumulator = step.accumulate?.initial ?? state.accumulator;
+    for (let index = startIndex;; index += 1) {
+        const conditionScope = buildScope(env, state, { item: undefined, index }, accumulator);
+        const shouldContinue = await (0, workflow_values_1.evaluateValue)(step.while, conditionScope);
+        if (!Boolean(shouldContinue)) {
+            break;
+        }
+        const iterationState = {
+            ...state,
+            iteration: { item: undefined, index },
+            accumulator,
+            iterationStack: [...state.iterationStack, index],
+        };
+        const suspension = await env.executeFlow(step.steps, iterationState, [
+            ...path,
+            index,
+        ]);
+        if (suspension) {
+            return {
+                ...suspension,
+                continue: async (resumeData) => {
+                    const next = await suspension.continue(resumeData);
+                    if (next) {
+                        return next;
+                    }
+                    const postScope = buildScope(env, iterationState, { item: undefined, index }, accumulator);
+                    accumulator = await updateAccumulator(step, postScope, accumulator);
+                    return executeWhileLoop(env, step, {
+                        ...iterationState,
+                        accumulator,
+                        iterationStack: state.iterationStack,
+                    }, path, index + 1);
+                },
+            };
+        }
+        const postScope = buildScope(env, iterationState, { item: undefined, index }, accumulator);
+        accumulator = await updateAccumulator(step, postScope, accumulator);
+        state.output = iterationState.output;
+    }
+    finalizeAccumulatorState(step, state, accumulator);
+    return undefined;
+}
+function finalizeAccumulatorState(step, state, accumulator) {
+    if (step.accumulate && step.name) {
+        state.output[step.name] = { [step.accumulate.as]: accumulator };
+    }
+    if (step.accumulate) {
+        state.accumulator = accumulator;
+    }
+}
+/**
+ * Update the loop accumulator using the configured merge expression.
+ *
+ * @param step The loop step containing accumulation settings.
+ * @param scope Current evaluation scope for expressions.
+ * @param previous Previous accumulator value to merge with.
+ * @returns The updated accumulator value.
+ */
+async function updateAccumulator(step, scope, previous) {
+    if (!step.accumulate) {
+        return previous;
+    }
+    return (0, workflow_values_1.evaluateValue)(step.accumulate.merge, {
+        ...scope,
+        accumulator: previous,
+    });
+}
+/**
+ * Determine whether loop execution should stop based on the `until` condition.
+ *
+ * @param step The loop step configuration.
+ * @param scope Current evaluation scope for expressions.
+ * @returns True if the loop should stop, otherwise false.
+ */
+async function shouldStopLoop(step, scope) {
+    if (step.loopType !== 'for_each' || !step.until) {
+        return false;
+    }
+    const result = await (0, workflow_values_1.evaluateValue)(step.until, scope);
+    return Boolean(result);
+}
+/**
+ * Build the evaluation scope for loop iteration and accumulator updates.
+ *
+ * @param env Executor environment with workflow context.
+ * @param state Execution state for the current iteration.
+ * @param iteration The current iteration item and index.
+ * @param accumulator Accumulator value to expose to expressions.
+ * @returns An evaluation scope object.
+ */
+function buildScope(env, state, iteration, accumulator) {
+    return {
+        input: state.input,
+        context: env.context.state,
+        output: state.output,
+        iteration,
+        accumulator,
+    };
+}