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

package/dist/esm/suspension-rebuilder.js

@@ -6,6 +6,7 @@
 import { executeLoop as runLoopExecutor, shouldStopLoop, updateAccumulator, } from './step-executors/loop-executor';
 import { executeParallel as runParallelExecutor } from './step-executors/parallel-executor';
 import { markStepsSkipped } from './step-executors/skip-helpers';
+import { wrapSuspensionContinuation } from './step-executors/suspension-continuation';
 import { StepType, } from './workflow-event-emitter';
 /**
  * Parse a suspended step id into its execution path and iteration stack.
@@ -149,16 +150,7 @@ export function buildSuspensionForPath(deps, steps, state, targetPath, pathPrefi
                     }
                     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 wrapSuspensionContinuation(resumed, () => deps.executeFlow(steps, state, pathPrefix, current + 1));
                     }
                     return deps.executeFlow(steps, state, pathPrefix, current + 1);
                 }
@@ -183,22 +175,19 @@ export function buildSuspensionForPath(deps, steps, state, targetPath, pathPrefi
             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 wrapSuspensionContinuation(childSuspension, async () => {
+            if (step.strategy === 'wait_any') {
+                if (childIndex + 1 < step.steps.length) {
+                    markStepsSkipped(env, step.steps.slice(childIndex + 1), state.iterationStack ?? []);
                 }
-                if (step.strategy === 'wait_any') {
-                    if (childIndex + 1 < step.steps.length) {
-                        markStepsSkipped(env, step.steps.slice(childIndex + 1), state.iterationStack ?? []);
-                    }
-                    return undefined;
-                }
-                return runParallelExecutor(env, step, state, currentPath, childIndex + 1);
-            },
-        };
+                return deps.executeFlow(steps, state, pathPrefix, current + 1);
+            }
+            const next = await runParallelExecutor(env, step, state, currentPath, childIndex + 1);
+            if (next) {
+                return wrapSuspensionContinuation(next, () => deps.executeFlow(steps, state, pathPrefix, current + 1));
+            }
+            return deps.executeFlow(steps, state, pathPrefix, current + 1);
+        });
     }
     if (step.type === StepType.Conditional) {
         if (rest[0] !== 'branch' || typeof rest[1] !== 'number') {
@@ -214,16 +203,7 @@ export function buildSuspensionForPath(deps, steps, state, targetPath, pathPrefi
         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 wrapSuspensionContinuation(branchSuspension, () => deps.executeFlow(steps, state, pathPrefix, current + 1));
     }
     if (step.type === StepType.Loop) {
         if (rest.length < 1 || typeof rest[0] !== 'string') {
@@ -251,46 +231,53 @@ export function buildSuspensionForPath(deps, steps, state, targetPath, pathPrefi
             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 updateAccumulator(step, scope, accumulator);
-                const shouldStop = await 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 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 updateAccumulator(step, scope, accumulator);
+            const shouldStop = await shouldStopLoop(step, scope);
+            state.output = iterationState.output;
+            if (step.accumulate && step.name) {
+                state.output[step.name] = {
+                    [step.accumulate.as]: updatedAccumulator,
                 };
-                return runLoopExecutor(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 runLoopExecutor(env, step, baseState, currentPath, iterationIndex + 1);
+            state.output = baseState.output;
+            if (step.accumulate) {
+                state.accumulator = baseState.accumulator;
+            }
+            if (next) {
+                return 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/esm/workflow-runner.js

@@ -8,6 +8,7 @@ import { RunnerRuntimeControl } from './runner-runtime-control';
 import { executeConditional as runConditionalExecutor } from './step-executors/conditional-executor';
 import { executeLoop as runLoopExecutor } from './step-executors/loop-executor';
 import { executeParallel as runParallelExecutor } from './step-executors/parallel-executor';
+import { wrapSuspensionContinuation } from './step-executors/suspension-continuation';
 import { executeTaskStep as runTaskExecutor } from './step-executors/task-executor';
 import { rebuildSuspension, } from './suspension-rebuilder';
 import { StepType, } from './workflow-event-emitter';
@@ -405,16 +406,7 @@ export 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 wrapSuspensionContinuation(suspension, () => this.executeFlow(steps, state, path, index + 1));
             }
         }
         return undefined;

package/dist/types/step-executors/loop-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop-executor.d.ts","sourceRoot":"","sources":["../../../src/step-executors/loop-executor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EAEd,QAAQ,EACR,UAAU,EAEX,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,KAAK,SAAS,GAAG,eAAe,CAAC;AAEjC;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAC5B,UAAU,SAAI,GACb,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAM5B;AA+LD;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,OAAO,CAAC,CASlB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,OAAO,CAAC,CAQlB"}
+{"version":3,"file":"loop-executor.d.ts","sourceRoot":"","sources":["../../../src/step-executors/loop-executor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EAEd,QAAQ,EACR,UAAU,EAEX,MAAM,mBAAmB,CAAC;AAI3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,KAAK,SAAS,GAAG,eAAe,CAAC;AAEjC;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAC5B,UAAU,SAAI,GACb,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAM5B;AA+KD;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,OAAO,CAAC,CASlB;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,OAAO,CAAC,CAQlB"}

package/dist/types/step-executors/parallel-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parallel-executor.d.ts","sourceRoot":"","sources":["../../../src/step-executors/parallel-executor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,UAAU,EACX,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAC5B,UAAU,SAAI,GACb,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA6C5B"}
+{"version":3,"file":"parallel-executor.d.ts","sourceRoot":"","sources":["../../../src/step-executors/parallel-executor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,UAAU,EACX,MAAM,mBAAmB,CAAC;AAI3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAC5B,UAAU,SAAI,GACb,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAqC5B"}

package/dist/types/step-executors/suspension-continuation.d.ts

@@ -0,0 +1,10 @@
+import type { Suspension } from '../workflow-types';
+/**
+ * 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 declare function wrapSuspensionContinuation(suspension: Suspension, onComplete: () => Promise<Suspension | void>): Suspension;
+//# sourceMappingURL=suspension-continuation.d.ts.map

package/dist/types/step-executors/suspension-continuation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suspension-continuation.d.ts","sourceRoot":"","sources":["../../../src/step-executors/suspension-continuation.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,GAC3C,UAAU,CAYZ"}

package/dist/types/suspension-rebuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suspension-rebuilder.d.ts","sourceRoot":"","sources":["../../src/suspension-rebuilder.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"suspension-rebuilder.d.ts","sourceRoot":"","sources":["../../src/suspension-rebuilder.ts"],"names":[],"mappings":"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"}

package/dist/types/workflow-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-runner.d.ts","sourceRoot":"","sources":["../../src/workflow-runner.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACtB,MAAM,WAAW,CAAC;AAWnB,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAGV,gBAAgB,EAChB,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,WAAW,EAEX,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAG1B;;;GAGG;AACH,qBAAa,cAAc;IAEzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAG5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAS;IAGhC,OAAO,CAAC,MAAM,CAA8C;IAG5D,OAAO,CAAC,SAAS,CAAsC;IAGvD,OAAO,CAAC,OAAO,CAA2C;IAG1D,OAAO,CAAC,UAAU,CAAC,CAAa;IAGhC,OAAO,CAAC,cAAc,CAAC,CAAuB;IAG9C,OAAO,CAAC,WAAW,CAAC,CAAW;IAG/B,OAAO,CAAC,cAAc,CAAC,CAAU;IAGjC,OAAO,CAAC,KAAK,CAAC,CAAiB;IAG/B,OAAO,CAAC,OAAO,CAAC,CAAsB;IAEtC;;;;;OAKG;gBACS,QAAQ,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,kBAAkB;IAKpE;;;;OAIG;IACH,QAAQ,IAAI,cAAc,GAAG,SAAS;IAItC;;;;OAIG;IACH,SAAS,IAAI,iBAAiB;IAI9B;;;;OAIG;IACH,WAAW,IAAI,gBAAgB;IAO/B;;;;OAIG;IACH,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC;IAajD;;;;OAIG;IACH,cAAc,IAAI,QAAQ,GAAG,SAAS;IAItC;;;;OAIG;IACH,iBAAiB,IAAI,OAAO;IAI5B;;;;;;OAMG;IACG,KAAK,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IA6BxD;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC;IAiB3D;;;;;OAKG;YACW,YAAY;IA0D1B;;;;;;OAMG;WACU,kBAAkB,CAC7B,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE;QACP,KAAK,EAAE,cAAc,CAAC;QACtB,OAAO,EAAE,mBAAmB,CAAC;QAC7B,QAAQ,EAAE,gBAAgB,CAAC;QAC3B,UAAU,CAAC,EAAE,mBAAmB,CAAC;QACjC,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B,GACA,OAAO,CAAC,cAAc,CAAC;IAgD1B;;;;;OAKG;IACH,OAAO,CAAC,IAAI;IAOZ;;;;;;OAMG;YACW,uBAAuB;IAYrC;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAc7B;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IASpB;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IA2B3B;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAqDzB;;;;OAIG;IACH,OAAO,CAAC,6BAA6B;IAkBrC;;;;;;;;OAQG;YACW,WAAW;IA8BzB;;;;;;;OAOG;YACW,WAAW;IAkBzB;;;;;;OAMG;YACW,iBAAiB;CAOhC"}
+{"version":3,"file":"workflow-runner.d.ts","sourceRoot":"","sources":["../../src/workflow-runner.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACtB,MAAM,WAAW,CAAC;AAYnB,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAGV,gBAAgB,EAChB,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,WAAW,EAEX,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAG1B;;;GAGG;AACH,qBAAa,cAAc;IAEzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAG5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAS;IAGhC,OAAO,CAAC,MAAM,CAA8C;IAG5D,OAAO,CAAC,SAAS,CAAsC;IAGvD,OAAO,CAAC,OAAO,CAA2C;IAG1D,OAAO,CAAC,UAAU,CAAC,CAAa;IAGhC,OAAO,CAAC,cAAc,CAAC,CAAuB;IAG9C,OAAO,CAAC,WAAW,CAAC,CAAW;IAG/B,OAAO,CAAC,cAAc,CAAC,CAAU;IAGjC,OAAO,CAAC,KAAK,CAAC,CAAiB;IAG/B,OAAO,CAAC,OAAO,CAAC,CAAsB;IAEtC;;;;;OAKG;gBACS,QAAQ,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,kBAAkB;IAKpE;;;;OAIG;IACH,QAAQ,IAAI,cAAc,GAAG,SAAS;IAItC;;;;OAIG;IACH,SAAS,IAAI,iBAAiB;IAI9B;;;;OAIG;IACH,WAAW,IAAI,gBAAgB;IAO/B;;;;OAIG;IACH,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC;IAajD;;;;OAIG;IACH,cAAc,IAAI,QAAQ,GAAG,SAAS;IAItC;;;;OAIG;IACH,iBAAiB,IAAI,OAAO;IAI5B;;;;;;OAMG;IACG,KAAK,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IA6BxD;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC;IAiB3D;;;;;OAKG;YACW,YAAY;IA0D1B;;;;;;OAMG;WACU,kBAAkB,CAC7B,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE;QACP,KAAK,EAAE,cAAc,CAAC;QACtB,OAAO,EAAE,mBAAmB,CAAC;QAC7B,QAAQ,EAAE,gBAAgB,CAAC;QAC3B,UAAU,CAAC,EAAE,mBAAmB,CAAC;QACjC,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B,GACA,OAAO,CAAC,cAAc,CAAC;IAgD1B;;;;;OAKG;IACH,OAAO,CAAC,IAAI;IAOZ;;;;;;OAMG;YACW,uBAAuB;IAYrC;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAc7B;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IASpB;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IA2B3B;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAqDzB;;;;OAIG;IACH,OAAO,CAAC,6BAA6B;IAkBrC;;;;;;;;OAQG;YACW,WAAW;IAsBzB;;;;;;;OAOG;YACW,WAAW;IAkBzB;;;;;;OAMG;YACW,iBAAiB;CAOhC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexabot-ai/agentic",
-  "version": "3.1.2-alpha.1",
+  "version": "3.1.2-alpha.3",
   "description": "Schemas and utilities for the Hexabot agentic workflow DSL.",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -20,7 +20,7 @@
   ],
   "dependencies": {
     "jsonata": "^2.1.0",
-    "yaml": "^2.5.0",
+    "yaml": "^2.8.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/src/__tests__/suspension-rebuilder.test.ts

@@ -308,10 +308,15 @@ describe('rebuildSuspension', () => {
       state,
       stepId: '0.parallel.1:child_b',
     });
-
-    mockedRunParallelExecutor.mockResolvedValue(
-      'next-suspension' as unknown as void,
-    );
+    const nextSuspension = {
+      step: {
+        id: '0.parallel.2:child_c',
+        name: 'child_c',
+        type: StepType.Task,
+      },
+      continue: jest.fn().mockResolvedValue(undefined),
+    };
+    mockedRunParallelExecutor.mockResolvedValue(nextSuspension);
 
     const result = await suspension?.continue({ payload: true });
 
@@ -325,7 +330,17 @@ describe('rebuildSuspension', () => {
       [0],
       2,
     );
-    expect(result).toBe('next-suspension');
+    expect(result?.step.id).toBe(nextSuspension.step.id);
+
+    await result?.continue({ done: true });
+
+    expect(nextSuspension.continue).toHaveBeenCalledWith({ done: true });
+    expect(deps.executeFlow).toHaveBeenLastCalledWith(
+      compiled.flow,
+      state,
+      [],
+      1,
+    );
   });
 
   it('resumes a loop suspension, updating accumulators and continuing execution', async () => {
@@ -367,9 +382,15 @@ describe('rebuildSuspension', () => {
 
     mockedUpdateAccumulator.mockResolvedValue(5);
     mockedShouldStopLoop.mockResolvedValue(false);
-    mockedRunLoopExecutor.mockResolvedValue(
-      'loop-continued' as unknown as void,
-    );
+    const nextSuspension = {
+      step: {
+        id: '0.collector.0:loop_task[2]',
+        name: 'loop_task',
+        type: StepType.Task,
+      },
+      continue: jest.fn().mockResolvedValue(undefined),
+    };
+    mockedRunLoopExecutor.mockResolvedValue(nextSuspension);
 
     const suspension = rebuildSuspension(deps, {
       state,
@@ -404,6 +425,19 @@ describe('rebuildSuspension', () => {
     const loopState = mockedRunLoopExecutor.mock.calls[0]?.[2];
     expect(loopState?.accumulator).toBe(5);
     expect(loopState?.iterationStack).toEqual([]);
-    expect(result).toBe('loop-continued');
+    expect(result?.step.id).toBe(nextSuspension.step.id);
+
+    await result?.continue({ done: true });
+
+    expect(nextSuspension.continue).toHaveBeenCalledWith({ done: true });
+    expect(deps.executeFlow).toHaveBeenLastCalledWith(
+      compiled.flow,
+      expect.objectContaining({
+        accumulator: 5,
+        output: expect.objectContaining({ collector: { sum: 5 } }),
+      }),
+      [],
+      1,
+    );
   });
 });

package/src/__tests__/workflow-runner.test.ts

@@ -588,6 +588,103 @@ describe('WorkflowRunner', () => {
     }
   });
 
+  it('continues following steps after a repeatedly suspended while loop exits', async () => {
+    const suspendAction = defineAction<
+      { prompt: string },
+      { reply: string; done: boolean },
+      TestContext,
+      Settings
+    >({
+      name: 'loop_suspend_action',
+      inputSchema: z.object({ prompt: z.string() }),
+      outputSchema: z.object({ reply: z.string(), done: z.boolean() }),
+      execute: async ({ input, context }) => {
+        const resumeData = (await context.workflow.suspend({
+          reason: 'awaiting_reply',
+          data: { prompt: input.prompt },
+        })) as { reply: string };
+
+        return {
+          reply: resumeData.reply,
+          done: resumeData.reply === 'stop',
+        };
+      },
+    });
+    const afterExecute = jest.fn(async ({ input }) => ({
+      stored: `stored:${input.reply}`,
+    }));
+    const afterAction = defineAction<
+      { reply: string },
+      { stored: string },
+      TestContext,
+      Settings
+    >({
+      name: 'after_loop_action',
+      inputSchema: z.object({ reply: z.string() }),
+      outputSchema: z.object({ stored: z.string() }),
+      execute: afterExecute,
+    });
+    const definition: WorkflowDefinition = {
+      defs: createTaskDefs({
+        wait_step: {
+          action: 'loop_suspend_action',
+          inputs: { prompt: '="Attempt " & $string($iteration.index)' },
+        },
+        after_loop_step: {
+          action: 'after_loop_action',
+          inputs: { reply: '=$output.wait_step.reply' },
+        },
+      }),
+      flow: [
+        {
+          loop: {
+            type: 'while',
+            name: 'wait_until_stop',
+            while:
+              '=$not($exists($output.wait_step.done) and $output.wait_step.done = true)',
+            steps: [{ do: 'wait_step' }],
+          },
+        },
+        { do: 'after_loop_step' },
+      ],
+      outputs: {
+        reply: '=$output.wait_step.reply',
+        stored: '=$output.after_loop_step.stored',
+      },
+    };
+    const compiled = compileWorkflow(definition, {
+      actions: {
+        loop_suspend_action: suspendAction,
+        after_loop_action: afterAction,
+      },
+    });
+    const runner = new WorkflowRunner(compiled, {
+      runId: 'run-while-suspend-after',
+    });
+    const context = new TestContext({});
+    const startResult = await runner.start({ inputData: {}, context });
+
+    expect(startResult.status).toBe('suspended');
+    const firstResume = await runner.resume({
+      resumeData: { reply: 'continue' },
+    });
+
+    expect(firstResume.status).toBe('suspended');
+    const secondResume = await runner.resume({
+      resumeData: { reply: 'stop' },
+    });
+
+    expect(secondResume.status).toBe('finished');
+    if (secondResume.status === 'finished') {
+      expect(secondResume.output.reply).toBe('stop');
+      expect(secondResume.output.stored).toBe('stored:stop');
+    }
+    expect(afterExecute).toHaveBeenCalledTimes(1);
+    expect(afterExecute).toHaveBeenCalledWith(
+      expect.objectContaining({ input: { reply: 'stop' } }),
+    );
+  });
+
   it('handles suspension and resumes with provided data', async () => {
     const suspendAction = defineAction<
       { prompt: string },
@@ -994,12 +1091,27 @@ describe('WorkflowRunner', () => {
         return { reply: `ack:${resumeData.reply}` };
       },
     });
+    const afterAction = defineAction<
+      { reply: string },
+      { summary: string },
+      TestContext,
+      Settings
+    >({
+      name: 'after_loop_action',
+      inputSchema: z.object({ reply: z.string() }),
+      outputSchema: z.object({ summary: z.string() }),
+      execute: async ({ input }) => ({ summary: `after:${input.reply}` }),
+    });
     const definition: WorkflowDefinition = {
       defs: createTaskDefs({
         wait_step: {
           action: 'loop_suspend_action',
           inputs: { prompt: '="Ping"' },
         },
+        after_step: {
+          action: 'after_loop_action',
+          inputs: { reply: '=$output.wait_step.reply' },
+        },
       }),
       flow: [
         {
@@ -1010,8 +1122,12 @@ describe('WorkflowRunner', () => {
             steps: [{ do: 'wait_step' }],
           },
         },
+        { do: 'after_step' },
       ],
-      outputs: { reply: '=$output.wait_step.reply' },
+      outputs: {
+        reply: '=$output.wait_step.reply',
+        summary: '=$output.after_step.summary',
+      },
       inputs: {
         schema: {
           items: { type: 'array', items: { type: 'string' } },
@@ -1021,6 +1137,7 @@ describe('WorkflowRunner', () => {
     const compiled = compileWorkflow(definition, {
       actions: {
         loop_suspend_action: suspendAction,
+        after_loop_action: afterAction,
       },
     });
     const runner = new WorkflowRunner(compiled);
@@ -1061,6 +1178,7 @@ describe('WorkflowRunner', () => {
     expect(resumeResult.status).toBe('finished');
     if (resumeResult.status === 'finished') {
       expect(resumeResult.output.reply).toBe('ack:Pong');
+      expect(resumeResult.output.summary).toBe('after:ack:Pong');
     }
   });
 

package/src/step-executors/loop-executor.ts

@@ -14,6 +14,7 @@ import type {
 } from '../workflow-types';
 import { evaluateValue } from '../workflow-values';
 
+import { wrapSuspensionContinuation } from './suspension-continuation';
 import type { StepExecutorEnv } from './types';
 
 type LoopScope = EvaluationScope;
@@ -74,45 +75,37 @@ async function executeForEachLoop(
     ]);
 
     if (suspension) {
-      return {
-        ...suspension,
-        continue: async (resumeData: unknown) => {
-          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 undefined;
+        }
 
-          return executeForEachLoop(
-            env,
-            step,
-            {
-              ...iterationState,
-              accumulator,
-              iterationStack: state.iterationStack,
-            },
-            path,
-            index + 1,
-          );
-        },
-      };
+        return executeForEachLoop(
+          env,
+          step,
+          {
+            ...iterationState,
+            accumulator,
+            iterationStack: state.iterationStack,
+          },
+          path,
+          index + 1,
+        );
+      });
     }
 
     const postScope = buildScope(
@@ -170,35 +163,27 @@ async function executeWhileLoop(
     ]);
 
     if (suspension) {
-      return {
-        ...suspension,
-        continue: async (resumeData: unknown) => {
-          const next = await suspension.continue(resumeData);
-          if (next) {
-            return next;
-          }
-
-          const postScope = buildScope(
-            env,
-            iterationState,
-            { item: undefined, index },
+      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,
-          );
-          accumulator = await updateAccumulator(step, postScope, accumulator);
-
-          return executeWhileLoop(
-            env,
-            step,
-            {
-              ...iterationState,
-              accumulator,
-              iterationStack: state.iterationStack,
-            },
-            path,
-            index + 1,
-          );
-        },
-      };
+            iterationStack: state.iterationStack,
+          },
+          path,
+          index + 1,
+        );
+      });
     }
 
     const postScope = buildScope(