@hexabot-ai/agentic 3.1.2-alpha.1 → 3.1.2-alpha.3

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

@@ -9,6 +9,7 @@ exports.executeLoop = executeLoop;
 exports.updateAccumulator = updateAccumulator;
 exports.shouldStopLoop = shouldStopLoop;
 const workflow_values_1 = require("../workflow-values");
+const suspension_continuation_1 = require("./suspension-continuation");
 /**
  * Execute a loop step by iterating over input items and executing child steps.
  *
@@ -49,30 +50,23 @@ async function executeForEachLoop(env, step, state, path, startIndex) {
             index,
         ]);
         if (suspension) {
-            return {
-                ...suspension,
-                continue: async (resumeData) => {
-                    const next = await suspension.continue(resumeData);
-                    if (next) {
-                        return next;
+            return (0, suspension_continuation_1.wrapSuspensionContinuation)(suspension, async () => {
+                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 };
                     }
-                    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);
-                },
-            };
+                    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);
@@ -104,22 +98,15 @@ async function executeWhileLoop(env, step, state, path, startIndex) {
             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);
-                },
-            };
+            return (0, suspension_continuation_1.wrapSuspensionContinuation)(suspension, async () => {
+                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);

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

@@ -7,6 +7,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeParallel = executeParallel;
 const skip_helpers_1 = require("./skip-helpers");
+const suspension_continuation_1 = require("./suspension-continuation");
 /**
  * Execute a set of steps in parallel order, respecting the configured strategy.
  *
@@ -23,22 +24,15 @@ async function executeParallel(env, step, state, path, startIndex = 0) {
         const childPath = [...path, 'parallel', index];
         const suspension = await env.executeStep(child, state, childPath);
         if (suspension) {
-            return {
-                ...suspension,
-                continue: async (resumeData) => {
-                    const next = await suspension.continue(resumeData);
-                    if (next) {
-                        return next;
+            return (0, suspension_continuation_1.wrapSuspensionContinuation)(suspension, async () => {
+                if (step.strategy === 'wait_any') {
+                    if (index + 1 < step.steps.length) {
+                        (0, skip_helpers_1.markStepsSkipped)(env, step.steps.slice(index + 1), state.iterationStack);
                     }
-                    if (step.strategy === 'wait_any') {
-                        if (index + 1 < step.steps.length) {
-                            (0, skip_helpers_1.markStepsSkipped)(env, step.steps.slice(index + 1), state.iterationStack);
-                        }
-                        return undefined;
-                    }
-                    return executeParallel(env, step, state, path, index + 1);
-                },
-            };
+                    return undefined;
+                }
+                return executeParallel(env, step, state, path, index + 1);
+            });
         }
         if (step.strategy === 'wait_any') {
             if (index + 1 < step.steps.length) {

package/dist/cjs/step-executors/suspension-continuation.js

@@ -0,0 +1,27 @@
+"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.wrapSuspensionContinuation = wrapSuspensionContinuation;
+/**
+ * Compose a suspension with the continuation that should run once it completes.
+ *
+ * When resuming a suspension yields another suspension from the same logical
+ * step, the follow-up suspension still needs to remember how to continue the
+ * surrounding flow after that step eventually finishes.
+ */
+function wrapSuspensionContinuation(suspension, onComplete) {
+    return {
+        ...suspension,
+        continue: async (resumeData) => {
+            const next = await suspension.continue(resumeData);
+            if (next) {
+                return wrapSuspensionContinuation(next, onComplete);
+            }
+            return onComplete();
+        },
+    };
+}

package/dist/cjs/suspension-rebuilder.js

@@ -11,6 +11,7 @@ exports.buildSuspensionForPath = buildSuspensionForPath;
 const loop_executor_1 = require("./step-executors/loop-executor");
 const parallel_executor_1 = require("./step-executors/parallel-executor");
 const skip_helpers_1 = require("./step-executors/skip-helpers");
+const suspension_continuation_1 = require("./step-executors/suspension-continuation");
 const workflow_event_emitter_1 = require("./workflow-event-emitter");
 /**
  * Parse a suspended step id into its execution path and iteration stack.
@@ -154,16 +155,7 @@ function buildSuspensionForPath(deps, steps, state, targetPath, pathPrefix, iter
                     }
                     const resumed = await executeStep(step, state, currentPath);
                     if (resumed) {
-                        return {
-                            ...resumed,
-                            continue: async (nextResumeData) => {
-                                const next = await resumed.continue(nextResumeData);
-                                if (next) {
-                                    return next;
-                                }
-                                return deps.executeFlow(steps, state, pathPrefix, current + 1);
-                            },
-                        };
+                        return (0, suspension_continuation_1.wrapSuspensionContinuation)(resumed, () => deps.executeFlow(steps, state, pathPrefix, current + 1));
                     }
                     return deps.executeFlow(steps, state, pathPrefix, current + 1);
                 }
@@ -188,22 +180,19 @@ function buildSuspensionForPath(deps, steps, state, targetPath, pathPrefix, iter
             return null;
         }
         const childIndex = typeof childPath[0] === 'number' ? childPath[0] : 0;
-        return {
-            ...childSuspension,
-            continue: async (resumeData) => {
-                const next = await childSuspension.continue(resumeData);
-                if (next) {
-                    return next;
+        return (0, suspension_continuation_1.wrapSuspensionContinuation)(childSuspension, async () => {
+            if (step.strategy === 'wait_any') {
+                if (childIndex + 1 < step.steps.length) {
+                    (0, skip_helpers_1.markStepsSkipped)(env, step.steps.slice(childIndex + 1), state.iterationStack ?? []);
                 }
-                if (step.strategy === 'wait_any') {
-                    if (childIndex + 1 < step.steps.length) {
-                        (0, skip_helpers_1.markStepsSkipped)(env, step.steps.slice(childIndex + 1), state.iterationStack ?? []);
-                    }
-                    return undefined;
-                }
-                return (0, parallel_executor_1.executeParallel)(env, step, state, currentPath, childIndex + 1);
-            },
-        };
+                return deps.executeFlow(steps, state, pathPrefix, current + 1);
+            }
+            const next = await (0, parallel_executor_1.executeParallel)(env, step, state, currentPath, childIndex + 1);
+            if (next) {
+                return (0, suspension_continuation_1.wrapSuspensionContinuation)(next, () => deps.executeFlow(steps, state, pathPrefix, current + 1));
+            }
+            return deps.executeFlow(steps, state, pathPrefix, current + 1);
+        });
     }
     if (step.type === workflow_event_emitter_1.StepType.Conditional) {
         if (rest[0] !== 'branch' || typeof rest[1] !== 'number') {
@@ -219,16 +208,7 @@ function buildSuspensionForPath(deps, steps, state, targetPath, pathPrefix, iter
         if (!branchSuspension) {
             return null;
         }
-        return {
-            ...branchSuspension,
-            continue: async (resumeData) => {
-                const next = await branchSuspension.continue(resumeData);
-                if (next) {
-                    return next;
-                }
-                return deps.executeFlow(steps, state, pathPrefix, current + 1);
-            },
-        };
+        return (0, suspension_continuation_1.wrapSuspensionContinuation)(branchSuspension, () => deps.executeFlow(steps, state, pathPrefix, current + 1));
     }
     if (step.type === workflow_event_emitter_1.StepType.Loop) {
         if (rest.length < 1 || typeof rest[0] !== 'string') {
@@ -256,46 +236,53 @@ function buildSuspensionForPath(deps, steps, state, targetPath, pathPrefix, iter
             return null;
         }
         const accumulator = iterationState.accumulator ?? state.accumulator ?? undefined;
-        return {
-            ...childSuspension,
-            continue: async (resumeData) => {
-                const next = await childSuspension.continue(resumeData);
-                if (next) {
-                    return next;
-                }
-                const scope = {
-                    input: iterationState.input,
-                    context: env.context.state,
-                    output: iterationState.output,
-                    iteration: iterationState.iteration ?? {
-                        item: undefined,
-                        index: iterationIndex,
-                    },
-                    accumulator,
-                };
-                const updatedAccumulator = await (0, loop_executor_1.updateAccumulator)(step, scope, accumulator);
-                const shouldStop = await (0, loop_executor_1.shouldStopLoop)(step, scope);
-                state.output = iterationState.output;
-                if (step.accumulate && step.name) {
-                    state.output[step.name] = {
-                        [step.accumulate.as]: updatedAccumulator,
-                    };
-                }
-                if (step.accumulate) {
-                    state.accumulator = updatedAccumulator;
-                }
-                if (shouldStop) {
-                    return undefined;
-                }
-                const baseState = {
-                    ...iterationState,
-                    iterationStack: ancestorIterationStack,
-                    accumulator: updatedAccumulator,
-                    output: state.output,
+        return (0, suspension_continuation_1.wrapSuspensionContinuation)(childSuspension, async () => {
+            const scope = {
+                input: iterationState.input,
+                context: env.context.state,
+                output: iterationState.output,
+                iteration: iterationState.iteration ?? {
+                    item: undefined,
+                    index: iterationIndex,
+                },
+                accumulator,
+            };
+            const updatedAccumulator = await (0, loop_executor_1.updateAccumulator)(step, scope, accumulator);
+            const shouldStop = await (0, loop_executor_1.shouldStopLoop)(step, scope);
+            state.output = iterationState.output;
+            if (step.accumulate && step.name) {
+                state.output[step.name] = {
+                    [step.accumulate.as]: updatedAccumulator,
                 };
-                return (0, loop_executor_1.executeLoop)(env, step, baseState, currentPath, iterationIndex + 1);
-            },
-        };
+            }
+            if (step.accumulate) {
+                state.accumulator = updatedAccumulator;
+            }
+            if (shouldStop) {
+                return deps.executeFlow(steps, state, pathPrefix, current + 1);
+            }
+            const baseState = {
+                ...iterationState,
+                iterationStack: ancestorIterationStack,
+                accumulator: updatedAccumulator,
+                output: state.output,
+            };
+            const next = await (0, loop_executor_1.executeLoop)(env, step, baseState, currentPath, iterationIndex + 1);
+            state.output = baseState.output;
+            if (step.accumulate) {
+                state.accumulator = baseState.accumulator;
+            }
+            if (next) {
+                return (0, suspension_continuation_1.wrapSuspensionContinuation)(next, async () => {
+                    state.output = baseState.output;
+                    if (step.accumulate) {
+                        state.accumulator = baseState.accumulator;
+                    }
+                    return deps.executeFlow(steps, state, pathPrefix, current + 1);
+                });
+            }
+            return deps.executeFlow(steps, state, pathPrefix, current + 1);
+        });
     }
     return null;
 }

package/dist/cjs/workflow-runner.js

@@ -11,6 +11,7 @@ const runner_runtime_control_1 = require("./runner-runtime-control");
 const conditional_executor_1 = require("./step-executors/conditional-executor");
 const loop_executor_1 = require("./step-executors/loop-executor");
 const parallel_executor_1 = require("./step-executors/parallel-executor");
+const suspension_continuation_1 = require("./step-executors/suspension-continuation");
 const task_executor_1 = require("./step-executors/task-executor");
 const suspension_rebuilder_1 = require("./suspension-rebuilder");
 const workflow_event_emitter_1 = require("./workflow-event-emitter");
@@ -408,16 +409,7 @@ class WorkflowRunner {
             const stepPath = [...path, index];
             const suspension = await this.executeStep(step, state, stepPath);
             if (suspension) {
-                return {
-                    ...suspension,
-                    continue: async (resumeData) => {
-                        const next = await suspension.continue(resumeData);
-                        if (next) {
-                            return next;
-                        }
-                        return this.executeFlow(steps, state, path, index + 1);
-                    },
-                };
+                return (0, suspension_continuation_1.wrapSuspensionContinuation)(suspension, () => this.executeFlow(steps, state, path, index + 1));
             }
         }
         return undefined;

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

@@ -4,6 +4,7 @@
  * Full terms: see LICENSE.md.
  */
 import { evaluateValue } from '../workflow-values';
+import { wrapSuspensionContinuation } from './suspension-continuation';
 /**
  * Execute a loop step by iterating over input items and executing child steps.
  *
@@ -44,30 +45,23 @@ async function executeForEachLoop(env, step, state, path, startIndex) {
             index,
         ]);
         if (suspension) {
-            return {
-                ...suspension,
-                continue: async (resumeData) => {
-                    const next = await suspension.continue(resumeData);
-                    if (next) {
-                        return next;
+            return wrapSuspensionContinuation(suspension, async () => {
+                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 };
                     }
-                    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);
-                },
-            };
+                    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);
@@ -99,22 +93,15 @@ async function executeWhileLoop(env, step, state, path, startIndex) {
             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);
-                },
-            };
+            return wrapSuspensionContinuation(suspension, async () => {
+                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);

package/dist/esm/step-executors/parallel-executor.js

@@ -4,6 +4,7 @@
  * Full terms: see LICENSE.md.
  */
 import { markStepsSkipped } from './skip-helpers';
+import { wrapSuspensionContinuation } from './suspension-continuation';
 /**
  * Execute a set of steps in parallel order, respecting the configured strategy.
  *
@@ -20,22 +21,15 @@ export async function executeParallel(env, step, state, path, startIndex = 0) {
         const childPath = [...path, 'parallel', index];
         const suspension = await env.executeStep(child, state, childPath);
         if (suspension) {
-            return {
-                ...suspension,
-                continue: async (resumeData) => {
-                    const next = await suspension.continue(resumeData);
-                    if (next) {
-                        return next;
+            return wrapSuspensionContinuation(suspension, async () => {
+                if (step.strategy === 'wait_any') {
+                    if (index + 1 < step.steps.length) {
+                        markStepsSkipped(env, step.steps.slice(index + 1), state.iterationStack);
                     }
-                    if (step.strategy === 'wait_any') {
-                        if (index + 1 < step.steps.length) {
-                            markStepsSkipped(env, step.steps.slice(index + 1), state.iterationStack);
-                        }
-                        return undefined;
-                    }
-                    return executeParallel(env, step, state, path, index + 1);
-                },
-            };
+                    return undefined;
+                }
+                return executeParallel(env, step, state, path, index + 1);
+            });
         }
         if (step.strategy === 'wait_any') {
             if (index + 1 < step.steps.length) {

package/dist/esm/step-executors/suspension-continuation.js

@@ -0,0 +1,24 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+/**
+ * Compose a suspension with the continuation that should run once it completes.
+ *
+ * When resuming a suspension yields another suspension from the same logical
+ * step, the follow-up suspension still needs to remember how to continue the
+ * surrounding flow after that step eventually finishes.
+ */
+export function wrapSuspensionContinuation(suspension, onComplete) {
+    return {
+        ...suspension,
+        continue: async (resumeData) => {
+            const next = await suspension.continue(resumeData);
+            if (next) {
+                return wrapSuspensionContinuation(next, onComplete);
+            }
+            return onComplete();
+        },
+    };
+}