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

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

@@ -11,6 +11,7 @@ import type {
 } from '../workflow-types';
 
 import { markStepsSkipped } from './skip-helpers';
+import { wrapSuspensionContinuation } from './suspension-continuation';
 import type { StepExecutorEnv } from './types';
 
 /**
@@ -35,29 +36,21 @@ export async function executeParallel(
     const childPath = [...path, 'parallel', index];
     const suspension = await env.executeStep(child, state, childPath);
     if (suspension) {
-      return {
-        ...suspension,
-        continue: async (resumeData: unknown) => {
-          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 undefined;
-          }
-
-          return executeParallel(env, step, state, path, index + 1);
-        },
-      };
+        return executeParallel(env, step, state, path, index + 1);
+      });
     }
 
     if (step.strategy === 'wait_any') {

package/src/step-executors/suspension-continuation.ts

@@ -0,0 +1,31 @@
+/*
+ * Hexabot — Fair Core License (FCL-1.0-ALv2)
+ * Copyright (c) 2025 Hexastack.
+ * Full terms: see LICENSE.md.
+ */
+
+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 function wrapSuspensionContinuation(
+  suspension: Suspension,
+  onComplete: () => Promise<Suspension | void>,
+): Suspension {
+  return {
+    ...suspension,
+    continue: async (resumeData: unknown) => {
+      const next = await suspension.continue(resumeData);
+      if (next) {
+        return wrapSuspensionContinuation(next, onComplete);
+      }
+
+      return onComplete();
+    },
+  };
+}

package/src/suspension-rebuilder.ts

@@ -12,6 +12,7 @@ import {
 } 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 type { StepExecutorEnv } from './step-executors/types';
 import {
   StepType,
@@ -272,17 +273,9 @@ export function buildSuspensionForPath(
 
           const resumed = await executeStep(step, state, currentPath);
           if (resumed) {
-            return {
-              ...resumed,
-              continue: async (nextResumeData: unknown) => {
-                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);
@@ -324,35 +317,35 @@ export function buildSuspensionForPath(
     const childIndex =
       typeof childPath[0] === 'number' ? (childPath[0] as number) : 0;
 
-    return {
-      ...childSuspension,
-      continue: async (resumeData: unknown) => {
-        const next = await childSuspension.continue(resumeData);
-        if (next) {
-          return next;
-        }
-
-        if (step.strategy === 'wait_any') {
-          if (childIndex + 1 < step.steps.length) {
-            markStepsSkipped(
-              env,
-              step.steps.slice(childIndex + 1),
-              state.iterationStack ?? [],
-            );
-          }
-
-          return undefined;
+    return wrapSuspensionContinuation(childSuspension, async () => {
+      if (step.strategy === 'wait_any') {
+        if (childIndex + 1 < step.steps.length) {
+          markStepsSkipped(
+            env,
+            step.steps.slice(childIndex + 1),
+            state.iterationStack ?? [],
+          );
         }
 
-        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) {
@@ -382,17 +375,9 @@ export function buildSuspensionForPath(
       return null;
     }
 
-    return {
-      ...branchSuspension,
-      continue: async (resumeData: unknown) => {
-        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) {
@@ -441,63 +426,72 @@ export function buildSuspensionForPath(
     const accumulator =
       iterationState.accumulator ?? state.accumulator ?? undefined;
 
-    return {
-      ...childSuspension,
-      continue: async (resumeData: unknown) => {
-        const next = await childSuspension.continue(resumeData);
-        if (next) {
-          return next;
-        }
-
-        const scope: EvaluationScope = {
-          input: iterationState.input,
-          context: env.context.state,
-          output: iterationState.output,
-          iteration: iterationState.iteration ?? {
-            item: undefined,
-            index: iterationIndex,
-          },
-          accumulator,
+    return wrapSuspensionContinuation(childSuspension, async () => {
+      const scope: EvaluationScope = {
+        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,
         };
-        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 (step.accumulate) {
+        state.accumulator = updatedAccumulator;
+      }
 
-        if (shouldStop) {
-          return undefined;
-        }
+      if (shouldStop) {
+        return deps.executeFlow(steps, state, pathPrefix, current + 1);
+      }
+
+      const baseState: ExecutionState = {
+        ...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;
+          }
 
-        const baseState: ExecutionState = {
-          ...iterationState,
-          iterationStack: ancestorIterationStack,
-          accumulator: updatedAccumulator,
-          output: state.output,
-        };
+          return deps.executeFlow(steps, state, pathPrefix, current + 1);
+        });
+      }
 
-        return runLoopExecutor(
-          env,
-          step,
-          baseState,
-          currentPath,
-          iterationIndex + 1,
-        );
-      },
-    };
+      return deps.executeFlow(steps, state, pathPrefix, current + 1);
+    });
   }
 
   return null;

package/src/workflow-runner.ts

@@ -17,6 +17,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 type { StepExecutorEnv } from './step-executors/types';
 import {
@@ -552,17 +553,9 @@ export class WorkflowRunner {
       const suspension = await this.executeStep(step, state, stepPath);
 
       if (suspension) {
-        return {
-          ...suspension,
-          continue: async (resumeData: unknown) => {
-            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),
+        );
       }
     }