@hexabot-ai/agentic 3.1.2-alpha.8 → 3.1.2-beta.0

package/README.md

@@ -6,8 +6,8 @@ Typed runtime and YAML DSL for orchestrating multi-step AI/automation workflows.
 - Declarative workflow DSL in YAML or JS objects with JSONata expressions (prefixed by `=`) and clear scopes (`$input`, `$context`, `$output`, `$iteration`, `$accumulator`).
 - Type-safe actions built with `defineAction`, Zod-validated IO, and merged settings (timeouts, retries, plus action-specific options) inherited from workflow defaults.
 - Resumable execution via `WorkflowRunner` and `context.workflow.suspend`, plus snapshots for persistence and replay.
-- Flow primitives: sequential `do`, `parallel` blocks (`wait_all`/`wait_any`), `conditional` branches, and two loop variants: `loop.type: for_each` (iterables) and `loop.type: while` (pre-check condition).
-- Event emitter hooks for observability (`hook:workflow:start|finish|failure|suspended`, `hook:step:start|success|error|suspended|skipped`).
+- Flow primitives: sequential `do`, truly concurrent `parallel` blocks (`wait_all`/`wait_any`), `conditional` branches, and two loop variants: `loop.type: for_each` (iterables) and `loop.type: while` (pre-check condition).
+- Event emitter hooks for observability (`hook:workflow:start|finish|failure|suspended`, `hook:step:start|success|error|cancelled|suspended|skipped`).
 
 ## Installation
 
@@ -89,7 +89,11 @@ export const call_api = defineAction<
   description: 'Fetches data from an API',
   inputSchema: z.object({ id: z.string() }),
   outputSchema: z.object({ body: z.string() }),
-  execute: async ({ input, context, settings, bindings }) => {
+  execute: async ({ input, context, settings, bindings, signal }) => {
+    if (signal.aborted) {
+      throw signal.reason;
+    }
+
     context.log('calling api', {
       id: input.id,
       timeout: settings.timeout_ms,
@@ -100,7 +104,9 @@ export const call_api = defineAction<
 });
 ```
 
-Settings are parsed and merged with workflow defaults before `execute` runs; retries and timeout wrappers are applied automatically. Awaiting `context.workflow.suspend(...)` pauses the workflow until `resume` is called.
+Settings are parsed and merged with workflow defaults before `execute` runs; retries and timeout wrappers are applied automatically. Each action receives an `AbortSignal` as `signal`; long-running actions should stop promptly when it is aborted. Awaiting `context.workflow.suspend(...)` pauses the workflow until `resume` is called, except inside `parallel` branches where suspension fails with `ParallelSuspensionError`.
+
+Parallel branches start concurrently with isolated `$output`, `$iteration`, `$accumulator`, and context state from the parallel entry point. `wait_all` merges successful branch output deltas in child order. `wait_any` advances with the first successful branch, aborts losing branches, and discards loser outputs.
 
 ## Running a workflow from YAML
 
@@ -203,12 +209,14 @@ export const await_user = defineAction<unknown, { reply?: string }, AppContext,
 
 `Workflow.run` throws an error with suspension details (`stepId`, `reason`, `data`) when this happens; `WorkflowRunner.start` instead returns `{ status: 'suspended', ... }` so hosts can persist state and resume later with `runner.resume`.
 
+Suspending actions must not be placed inside `parallel` blocks.
+
 ## Events and observability
 
 `WorkflowRunner` can publish lifecycle hooks to any emitter-like object with `emit`/`on` (`WorkflowEventEmitterLike`); `WorkflowEventEmitter` is the built-in helper and mirrors these events:
 
 - `hook:workflow:start | finish | failure | suspended`
-- `hook:step:start | success | error | suspended | skipped`
+- `hook:step:start | success | error | cancelled | suspended | skipped`
 
 Attach listeners to stream logs, emit metrics, or capture snapshots for debugging.
 

package/dist/cjs/action/abstract-action.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractAction = void 0;
 const zod_1 = require("zod");
 const dsl_types_1 = require("../dsl.types");
+const errors_1 = require("../errors");
 const naming_1 = require("../utils/naming");
 const timeout_1 = require("../utils/timeout");
 const BASE_SETTINGS_KEYS = Object.keys(dsl_types_1.BaseSettingsSchema.shape);
@@ -67,7 +68,7 @@ class AbstractAction {
             .parse(payload ?? {});
         return (settings ?? {});
     }
-    async run(payload, context, settings, bindings) {
+    async run(payload, context, settings, bindings, signal) {
         const input = this.parseInput(payload);
         const parsedSettings = this.parseSettings(settings);
         const parsedBindings = (bindings ?? {});
@@ -89,13 +90,17 @@ class AbstractAction {
         const jitter = retrySettings.jitter;
         const multiplier = retrySettings.multiplier;
         while (attempt < maxAttempts) {
+            if (signal) {
+                (0, errors_1.throwIfAborted)(signal);
+            }
             try {
                 const result = await (0, timeout_1.withTimeout)(this.execute({
                     input,
                     context,
                     settings: parsedSettings,
                     bindings: parsedBindings,
-                }), timeoutMs);
+                    signal: signal ?? new AbortController().signal,
+                }), timeoutMs, signal);
                 return this.parseOutput(result);
             }
             catch (error) {
@@ -111,7 +116,7 @@ class AbstractAction {
                     const jitterFactor = jitter > 0 ? 1 + (Math.random() * 2 - 1) * jitter : 1;
                     const jitteredDelay = Math.max(0, Math.round(delay * jitterFactor));
                     if (jitteredDelay > 0) {
-                        await (0, timeout_1.sleep)(jitteredDelay);
+                        await (0, timeout_1.sleep)(jitteredDelay, signal);
                     }
                 }
                 const nextDelay = currentDelay * multiplier;

package/dist/cjs/errors.js

@@ -0,0 +1,41 @@
+"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.throwIfAborted = exports.getAbortReason = exports.isWorkflowCancellationError = exports.ParallelSuspensionError = exports.WorkflowCancellationError = void 0;
+class WorkflowCancellationError extends Error {
+    constructor(message = 'Workflow execution was cancelled.') {
+        super(message);
+        this.name = 'WorkflowCancellationError';
+    }
+}
+exports.WorkflowCancellationError = WorkflowCancellationError;
+class ParallelSuspensionError extends Error {
+    constructor() {
+        super('workflow.suspend() is not supported inside a parallel block.');
+        this.name = 'ParallelSuspensionError';
+    }
+}
+exports.ParallelSuspensionError = ParallelSuspensionError;
+const isWorkflowCancellationError = (error) => error instanceof WorkflowCancellationError ||
+    (error instanceof Error && error.name === 'WorkflowCancellationError');
+exports.isWorkflowCancellationError = isWorkflowCancellationError;
+const getAbortReason = (signal) => {
+    if (signal.reason instanceof Error) {
+        return signal.reason;
+    }
+    if (signal.reason !== undefined) {
+        return new WorkflowCancellationError(String(signal.reason));
+    }
+    return new WorkflowCancellationError();
+};
+exports.getAbortReason = getAbortReason;
+const throwIfAborted = (signal) => {
+    if (signal.aborted) {
+        throw (0, exports.getAbortReason)(signal);
+    }
+};
+exports.throwIfAborted = throwIfAborted;

package/dist/cjs/index.js

@@ -19,7 +19,7 @@ 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.WORKFLOW_RUN_STATUSES = exports.EWorkflowRunStatus = exports.BaseWorkflowContext = exports.defineAction = exports.AbstractAction = void 0;
+exports.remapWorkflowDefinitionResourceRefs = exports.collectWorkflowDefinitionResourceRefs = exports.withTimeout = exports.sleep = exports.toSnakeCase = exports.isSnakeCaseName = exports.assertSnakeCaseName = exports.createDeferred = exports.mergeSettings = exports.evaluateValue = exports.evaluateMapping = exports.compileValue = exports.WorkflowCancellationError = exports.ParallelSuspensionError = exports.NonDeterministicWorkflowError = exports.StepType = exports.WorkflowRunner = exports.WorkflowEventEmitter = exports.Workflow = exports.compileWorkflow = exports.WORKFLOW_RUN_STATUSES = exports.EWorkflowRunStatus = 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");
@@ -38,6 +38,9 @@ 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 errors_1 = require("./errors");
+Object.defineProperty(exports, "ParallelSuspensionError", { enumerable: true, get: function () { return errors_1.ParallelSuspensionError; } });
+Object.defineProperty(exports, "WorkflowCancellationError", { enumerable: true, get: function () { return errors_1.WorkflowCancellationError; } });
 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; } });
@@ -52,3 +55,6 @@ Object.defineProperty(exports, "toSnakeCase", { enumerable: true, get: function
 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; } });
+var workflow_definition_resources_1 = require("./utils/workflow-definition-resources");
+Object.defineProperty(exports, "collectWorkflowDefinitionResourceRefs", { enumerable: true, get: function () { return workflow_definition_resources_1.collectWorkflowDefinitionResourceRefs; } });
+Object.defineProperty(exports, "remapWorkflowDefinitionResourceRefs", { enumerable: true, get: function () { return workflow_definition_resources_1.remapWorkflowDefinitionResourceRefs; } });

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

@@ -6,40 +6,254 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeParallel = executeParallel;
+const errors_1 = require("../errors");
 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.
+ * Execute a set of child steps concurrently and resolve according to the configured strategy.
  *
  * @param env Executor environment providing helpers and workflow context.
  * @param step The parallel step definition including strategy and children.
  * @param state Mutable workflow execution state.
  * @param path Path tokens locating this parallel block in the workflow.
- * @param startIndex Index to resume execution from when continuing.
- * @returns A suspension if a child pauses execution, otherwise void.
+ * @returns Always undefined; suspensions are rejected inside parallel blocks.
  */
-async function executeParallel(env, step, state, path, startIndex = 0) {
-    for (let index = startIndex; index < step.steps.length; index += 1) {
-        const child = step.steps[index];
-        const childPath = [...path, 'parallel', index];
-        const suspension = await env.executeStep(child, state, childPath);
+async function executeParallel(env, step, state, path) {
+    if (step.steps.length === 0) {
+        return undefined;
+    }
+    (0, errors_1.throwIfAborted)(env.signal);
+    const baseOutput = cloneRecord(state.output);
+    const baseContextState = cloneRecord(env.context.state);
+    const branches = step.steps.map((child, index) => launchBranch({
+        env,
+        child,
+        index,
+        path,
+        parentState: state,
+        baseOutput,
+        baseContextState,
+    }));
+    if (step.strategy === 'wait_any') {
+        return executeWaitAny(env, branches, state);
+    }
+    return executeWaitAll(env, branches, state);
+}
+async function executeWaitAll(env, branches, state) {
+    const pending = new Set(branches);
+    const outcomes = new Map();
+    while (pending.size > 0) {
+        const { branch, result } = await raceNext(pending);
+        pending.delete(branch);
+        outcomes.set(result.index, result);
+        if (result.status === 'failed' || result.status === 'cancelled') {
+            cancelBranches(env, pending, result.error, 'Parallel branch execution was cancelled.');
+            await settleBranches(branches);
+            throw result.error;
+        }
+    }
+    mergeBranchOutputs(state, outcomes);
+}
+async function executeWaitAny(env, branches, state) {
+    const pending = new Set(branches);
+    const outcomes = new Map();
+    while (pending.size > 0) {
+        const { branch, result } = await raceNext(pending);
+        pending.delete(branch);
+        outcomes.set(result.index, result);
+        if (result.status === 'fulfilled') {
+            cancelBranches(env, pending, new errors_1.WorkflowCancellationError('Parallel wait_any winner selected.'), 'Parallel wait_any branch lost the race.');
+            await settleBranches(branches);
+            mergeBranchOutputs(state, new Map([[result.index, result]]));
+            return;
+        }
+        cancelBranches(env, pending, result.error, 'Parallel branch execution was cancelled.');
+        await settleBranches(branches);
+        throw result.error;
+    }
+}
+function launchBranch({ env, child, index, path, parentState, baseOutput, baseContextState, }) {
+    const controller = createBranchController(env.signal);
+    const trackedOutput = createTrackedOutput(baseOutput);
+    const branchState = {
+        input: parentState.input,
+        output: trackedOutput.output,
+        iteration: parentState.iteration ? { ...parentState.iteration } : undefined,
+        accumulator: cloneValue(parentState.accumulator),
+        iterationStack: [...parentState.iterationStack],
+    };
+    const branchContext = createParallelBranchContext(env.context, cloneRecord(baseContextState));
+    const branchEnv = env.fork({
+        context: branchContext,
+        signal: controller.signal,
+        setCurrentStep: () => undefined,
+    });
+    const childPath = [...path, 'parallel', index];
+    const promise = runBranch(branchEnv, child, branchState, childPath, trackedOutput, index);
+    return {
+        index,
+        step: child,
+        iterationStack: [...parentState.iterationStack],
+        controller,
+        promise,
+    };
+}
+async function runBranch(env, child, branchState, childPath, trackedOutput, index) {
+    try {
+        (0, errors_1.throwIfAborted)(env.signal);
+        const suspension = await env.executeStep(child, branchState, childPath);
         if (suspension) {
-            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);
-                    }
-                    return undefined;
-                }
-                return executeParallel(env, step, state, path, index + 1);
-            });
-        }
-        if (step.strategy === 'wait_any') {
-            if (index + 1 < step.steps.length) {
-                (0, skip_helpers_1.markStepsSkipped)(env, step.steps.slice(index + 1), state.iterationStack);
+            throw new errors_1.ParallelSuspensionError();
+        }
+        (0, errors_1.throwIfAborted)(env.signal);
+        return {
+            status: 'fulfilled',
+            index,
+            outputDelta: trackedOutput.getDelta(),
+        };
+    }
+    catch (error) {
+        if (env.signal.aborted) {
+            return { status: 'cancelled', index, error: (0, errors_1.getAbortReason)(env.signal) };
+        }
+        return { status: 'failed', index, error };
+    }
+}
+async function raceNext(pending) {
+    return Promise.race([...pending].map((branch) => branch.promise.then((result) => ({ branch, result }))));
+}
+async function settleBranches(branches) {
+    await Promise.all(branches.map((branch) => branch.promise.catch(() => null)));
+}
+function cancelBranches(env, branches, reason, snapshotReason) {
+    for (const branch of branches) {
+        if (!branch.controller.signal.aborted) {
+            branch.controller.abort(reason instanceof Error
+                ? reason
+                : new errors_1.WorkflowCancellationError(String(reason)));
+        }
+        (0, skip_helpers_1.markStepsCancelled)(env, [branch.step], branch.iterationStack, reason instanceof Error ? reason.message : snapshotReason);
+    }
+}
+function mergeBranchOutputs(state, outcomes) {
+    const ordered = [...outcomes.values()].sort((left, right) => {
+        return left.index - right.index;
+    });
+    for (const outcome of ordered) {
+        if (outcome.status !== 'fulfilled') {
+            continue;
+        }
+        Object.assign(state.output, outcome.outputDelta);
+    }
+}
+function createBranchController(parentSignal) {
+    const controller = new AbortController();
+    if (parentSignal.aborted) {
+        controller.abort((0, errors_1.getAbortReason)(parentSignal));
+        return controller;
+    }
+    parentSignal.addEventListener('abort', () => controller.abort((0, errors_1.getAbortReason)(parentSignal)), { once: true });
+    return controller;
+}
+function createTrackedOutput(baseOutput) {
+    const writtenKeys = new Set();
+    const target = cloneRecord(baseOutput);
+    const output = new Proxy(target, {
+        set(record, property, value) {
+            if (typeof property === 'string') {
+                writtenKeys.add(property);
+            }
+            return Reflect.set(record, property, value);
+        },
+        deleteProperty(record, property) {
+            if (typeof property === 'string') {
+                writtenKeys.add(property);
+            }
+            return Reflect.deleteProperty(record, property);
+        },
+    });
+    return {
+        output,
+        getDelta: () => Object.fromEntries([...writtenKeys]
+            .filter((key) => Object.prototype.hasOwnProperty.call(target, key))
+            .map((key) => [key, target[key]])),
+    };
+}
+class ParallelWorkflowRuntimeControl {
+    constructor(getParent) {
+        this.getParent = getParent;
+    }
+    get status() {
+        return this.getParent().status;
+    }
+    get resumeData() {
+        return this.getParent().resumeData;
+    }
+    suspend() {
+        return Promise.reject(new errors_1.ParallelSuspensionError());
+    }
+    resume(data) {
+        this.getParent().resume(data);
+    }
+    getSnapshot() {
+        return this.getParent().getSnapshot();
+    }
+}
+function createParallelBranchContext(context, branchState) {
+    let state = branchState;
+    const workflow = new ParallelWorkflowRuntimeControl(() => context.workflow);
+    return new Proxy(context, {
+        get(target, property, receiver) {
+            if (property === 'state') {
+                return state;
+            }
+            if (property === 'workflow') {
+                return workflow;
             }
-            return undefined;
+            if (property === 'snapshot') {
+                return () => cloneRecord(state);
+            }
+            if (property === 'attachWorkflowRuntime') {
+                return () => undefined;
+            }
+            return Reflect.get(target, property, receiver);
+        },
+        set(target, property, value, receiver) {
+            if (property === 'state') {
+                state = isRecord(value) ? value : {};
+                return true;
+            }
+            return Reflect.set(target, property, value, receiver);
+        },
+    });
+}
+function cloneRecord(value) {
+    return cloneValue(value);
+}
+function cloneValue(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (typeof structuredClone === 'function') {
+        try {
+            return structuredClone(value);
         }
+        catch {
+            // Fall through to JSON clone below.
+        }
+    }
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        if (Array.isArray(value)) {
+            return [...value];
+        }
+        if (isRecord(value)) {
+            return { ...value };
+        }
+        return value;
     }
-    return undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }

package/dist/cjs/step-executors/skip-helpers.js

@@ -5,7 +5,7 @@
  * Full terms: see LICENSE.md.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.markStepsSkipped = void 0;
+exports.markStepsCancelled = exports.markStepsSkipped = void 0;
 const workflow_event_emitter_1 = require("../workflow-event-emitter");
 const markStepSkipped = (env, step, iterationStack, reason) => {
     const stepInfo = env.buildInstanceStepInfo(step, iterationStack);
@@ -23,7 +23,31 @@ const markStepSkipped = (env, step, iterationStack, reason) => {
             break;
     }
 };
+const markStepCancelled = (env, step, iterationStack, reason) => {
+    const stepInfo = env.buildInstanceStepInfo(step, iterationStack);
+    env.markSnapshot(stepInfo, 'cancelled', reason);
+    env.emit('hook:step:cancelled', {
+        runId: env.runId,
+        step: stepInfo,
+        error: new Error(reason ?? 'Step execution was cancelled.'),
+    });
+    switch (step.type) {
+        case workflow_event_emitter_1.StepType.Parallel:
+            step.steps.forEach((child) => markStepCancelled(env, child, iterationStack, reason));
+            break;
+        case workflow_event_emitter_1.StepType.Conditional:
+            step.branches.forEach((branch) => branch.steps.forEach((child) => markStepCancelled(env, child, iterationStack, reason)));
+            break;
+        case workflow_event_emitter_1.StepType.Loop:
+        case workflow_event_emitter_1.StepType.Task:
+            break;
+    }
+};
 const markStepsSkipped = (env, steps, iterationStack, reason) => {
     steps.forEach((step) => markStepSkipped(env, step, iterationStack, reason));
 };
 exports.markStepsSkipped = markStepsSkipped;
+const markStepsCancelled = (env, steps, iterationStack, reason) => {
+    steps.forEach((step) => markStepCancelled(env, step, iterationStack, reason));
+};
+exports.markStepsCancelled = markStepsCancelled;

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

@@ -6,6 +6,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeTaskStep = executeTaskStep;
+const errors_1 = require("../errors");
 const workflow_values_1 = require("../workflow-values");
 /**
  * Execute a task step by running its task and handling suspension or output mapping.
@@ -23,6 +24,11 @@ async function executeTaskStep(env, step, state, _path) {
         throw new Error(`Task "${step.taskName}" is not defined.`);
     }
     const stepInfo = env.buildInstanceStepInfo(step, state.iterationStack);
+    if (env.signal.aborted) {
+        const error = (0, errors_1.getAbortReason)(env.signal);
+        recordTaskCancellation(env, stepInfo, error);
+        throw error;
+    }
     const scope = {
         input: state.input,
         context: env.context.state,
@@ -31,7 +37,12 @@ async function executeTaskStep(env, step, state, _path) {
         accumulator: state.accumulator,
     };
     const inputs = await (0, workflow_values_1.evaluateMapping)(task.inputs, scope);
-    env.recordStepExecution(stepInfo, {
+    if (env.signal.aborted) {
+        const error = (0, errors_1.getAbortReason)(env.signal);
+        recordTaskCancellation(env, stepInfo, error);
+        throw error;
+    }
+    const stepExecution = env.recordStepExecution(stepInfo, {
         action: task.actionName,
         status: 'running',
         startedAt: Date.now(),
@@ -41,9 +52,14 @@ async function executeTaskStep(env, step, state, _path) {
     env.beginStepExecution?.(stepInfo.id);
     env.setCurrentStep(stepInfo);
     env.markSnapshot(stepInfo, 'running');
-    env.emit('hook:step:start', { runId: env.runId, step: stepInfo });
+    env.emit('hook:step:start', {
+        runId: env.runId,
+        step: stepInfo,
+        stepExecution,
+    });
     try {
-        const actionPromise = Promise.resolve().then(() => task.action.run(inputs, env.context, task.settings, task.bindings));
+        (0, errors_1.throwIfAborted)(env.signal);
+        const actionPromise = Promise.resolve().then(() => task.action.run(inputs, env.context, task.settings, task.bindings, env.signal));
         const outcome = await waitForTaskProgress(env, stepInfo.id, actionPromise);
         if (outcome.type === 'completed') {
             await completeTask(env, stepInfo.id, stepInfo, task, state, outcome.value);
@@ -54,6 +70,11 @@ async function executeTaskStep(env, step, state, _path) {
             recordTaskFailure(env, stepInfo, outcome.error);
             throw outcome.error;
         }
+        if (outcome.type === 'cancelled') {
+            env.clearStepSuspensions(stepInfo.id, outcome.error);
+            recordTaskCancellation(env, stepInfo, outcome.error);
+            throw outcome.error;
+        }
         return buildSuspensionContinuation(env, stepInfo.id, stepInfo, task, state, actionPromise, outcome.request);
     }
     finally {
@@ -65,22 +86,45 @@ const waitForTaskProgress = async (env, stepId, actionPromise) => {
     const suspension = env
         .waitForStepSuspension(stepId)
         .then((request) => ({ type: 'suspended', request }));
-    return Promise.race([completion, suspension]);
+    let cleanupCancellation = () => undefined;
+    const cancellation = new Promise((resolve) => {
+        if (env.signal.aborted) {
+            resolve({ type: 'cancelled', error: (0, errors_1.getAbortReason)(env.signal) });
+            return;
+        }
+        const onAbort = () => {
+            resolve({ type: 'cancelled', error: (0, errors_1.getAbortReason)(env.signal) });
+        };
+        env.signal.addEventListener('abort', onAbort, { once: true });
+        cleanupCancellation = () => {
+            env.signal.removeEventListener('abort', onAbort);
+        };
+    });
+    try {
+        return await Promise.race([completion, suspension, cancellation]);
+    }
+    finally {
+        cleanupCancellation();
+    }
 };
 const completeTask = async (env, stepId, stepInfo, task, state, result) => {
     await env.captureTaskOutput(task, state, result);
-    env.recordStepExecution(stepInfo, {
+    const stepExecution = env.recordStepExecution(stepInfo, {
         status: 'completed',
         endedAt: Date.now(),
         output: result,
         context: { after: env.context.snapshot() },
     });
     env.markSnapshot(stepInfo, 'completed');
-    env.emit('hook:step:success', { runId: env.runId, step: stepInfo });
+    env.emit('hook:step:success', {
+        runId: env.runId,
+        step: stepInfo,
+        stepExecution,
+    });
     env.clearStepSuspensions(stepId);
 };
 const recordSuspension = (env, stepInfo, reason, data) => {
-    env.recordStepExecution(stepInfo, {
+    const stepExecution = env.recordStepExecution(stepInfo, {
         status: 'suspended',
         endedAt: Date.now(),
         reason,
@@ -90,6 +134,7 @@ const recordSuspension = (env, stepInfo, reason, data) => {
     env.emit('hook:step:suspended', {
         runId: env.runId,
         step: stepInfo,
+        stepExecution,
         reason,
         data,
     });
@@ -140,14 +185,36 @@ const buildSuspensionContinuation = (env, stepId, stepInfo, task, state, actionP
     };
 };
 const recordTaskFailure = (env, stepInfo, error) => {
-    env.recordStepExecution(stepInfo, {
+    const normalizedError = normalizeError(error);
+    const stepExecution = env.recordStepExecution(stepInfo, {
         status: 'failed',
         endedAt: Date.now(),
-        error: normalizeError(error),
+        error: normalizedError,
         context: { after: env.context.snapshot() },
     });
     env.markSnapshot(stepInfo, 'failed', normalizeErrorMessage(error));
-    env.emit('hook:step:error', { runId: env.runId, step: stepInfo, error });
+    env.emit('hook:step:error', {
+        runId: env.runId,
+        step: stepInfo,
+        stepExecution,
+        error,
+    });
+};
+const recordTaskCancellation = (env, stepInfo, error) => {
+    const normalizedError = normalizeError(error);
+    const stepExecution = env.recordStepExecution(stepInfo, {
+        status: 'cancelled',
+        endedAt: Date.now(),
+        error: normalizedError,
+        context: { after: env.context.snapshot() },
+    });
+    env.markSnapshot(stepInfo, 'cancelled', normalizeErrorMessage(error));
+    env.emit('hook:step:cancelled', {
+        runId: env.runId,
+        step: stepInfo,
+        stepExecution,
+        error,
+    });
 };
 const normalizeError = (error) => error instanceof Error
     ? { message: error.message, stack: error.stack }