@pikku/core 0.11.1 → 0.12.0

package/dist/wirings/workflow/pikku-workflow-service.js

@@ -1,7 +1,69 @@
 import { runPikkuFunc } from '../../function/function-runner.js';
 import { pikkuState } from '../../pikku-state.js';
 import { getDurationInMilliseconds } from '../../time-utils.js';
-import { WorkflowAsyncException, WorkflowCancelledException, WorkflowNotFoundError, WorkflowRunNotFound, } from './workflow-runner.js';
+import { continueGraph, executeGraphStep, runWorkflowGraph, runFromMeta, } from './graph/graph-runner.js';
+import { PikkuError, addError } from '../../errors/error-handler.js';
+import { RPCNotFoundError } from '../rpc/rpc-runner.js';
+/**
+ * Exception thrown when workflow needs to pause for async step
+ */
+export class WorkflowAsyncException extends Error {
+    runId;
+    stepName;
+    constructor(runId, stepName) {
+        super(`Workflow paused at step: ${stepName}`);
+        this.runId = runId;
+        this.stepName = stepName;
+        this.name = 'WorkflowAsyncException';
+    }
+}
+/**
+ * Exception thrown when workflow is cancelled
+ */
+export class WorkflowCancelledException extends Error {
+    runId;
+    reason;
+    constructor(runId, reason) {
+        super(reason || 'Workflow cancelled');
+        this.runId = runId;
+        this.reason = reason;
+        this.name = 'WorkflowCancelledException';
+    }
+}
+/**
+ * Exception thrown when workflow is suspended
+ */
+export class WorkflowSuspendedException extends Error {
+    runId;
+    reason;
+    constructor(runId, reason) {
+        super(reason || 'Workflow suspended');
+        this.runId = runId;
+        this.reason = reason;
+        this.name = 'WorkflowSuspendedException';
+    }
+}
+/**
+ * Error class for workflow not found
+ */
+export class WorkflowNotFoundError extends PikkuError {
+    constructor(name) {
+        super(`Workflow not found: ${name}`);
+    }
+}
+addError(WorkflowNotFoundError, {
+    status: 404,
+    message: 'Workflow not found.',
+});
+export class WorkflowRunNotFoundError extends PikkuError {
+    constructor(runId) {
+        super(`Workflow run not found: ${runId}`);
+    }
+}
+addError(WorkflowRunNotFoundError, {
+    status: 404,
+    message: 'Workflow run not found.',
+});
 export class WorkflowServiceNotInitialized extends Error {
 }
 export class WorkflowStepNameNotString extends Error {
@@ -9,6 +71,12 @@ export class WorkflowStepNameNotString extends Error {
         super(`Workflow step name must be a string. Received: ${typeof stepName}`);
     }
 }
+const WORKFLOW_END_STATES = new Set([
+    'completed',
+    'failed',
+    'cancelled',
+    'suspended',
+]);
 /**
  * Abstract workflow state service
  * Implementations provide pluggable storage backends (SQLite, PostgreSQL, etc.)
@@ -18,7 +86,26 @@ export class PikkuWorkflowService {
     config;
     singletonServices;
     createWireServices;
+    inlineRuns = new Set();
     constructor() { }
+    /**
+     * Check if a run is executing inline (without queues)
+     */
+    isInline(runId) {
+        return this.inlineRuns.has(runId);
+    }
+    /**
+     * Register a run as inline (for graph-runner to use)
+     */
+    registerInlineRun(runId) {
+        this.inlineRuns.add(runId);
+    }
+    /**
+     * Unregister a run from inline tracking
+     */
+    unregisterInlineRun(runId) {
+        this.inlineRuns.delete(runId);
+    }
     setServices(singletonServices, createWireServices, { workflow }) {
         this.singletonServices = singletonServices;
         this.createWireServices = createWireServices;
@@ -27,9 +114,17 @@ export class PikkuWorkflowService {
             retryDelay: workflow?.retryDelay ?? 0,
             orchestratorQueueName: workflow?.orchestratorQueueName ?? 'pikku-workflow-orchestrator',
             stepWorkerQueueName: workflow?.stepWorkerQueueName ?? 'pikku-workflow-step-worker',
-            sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowStepSleeper',
+            sleeperRPCName: workflow?.sleeperRPCName ?? 'pikkuWorkflowSleeper',
         };
     }
+    async registerWorkflowVersions() {
+        const allMeta = pikkuState(null, 'workflows', 'meta');
+        for (const [name, meta] of Object.entries(allMeta)) {
+            if (!meta.graphHash)
+                continue;
+            await this.upsertWorkflowVersion(name, meta.graphHash, meta, meta.source);
+        }
+    }
     // ============================================================================
     // Workflow Lifecycle Methods
     // ============================================================================
@@ -41,12 +136,21 @@ export class PikkuWorkflowService {
         const queueService = this.verifyQueueService();
         await queueService.add(this.getConfig().orchestratorQueueName, { runId });
     }
+    async queueStepWorker(runId, stepName, rpcName, data) {
+        const queueService = this.verifyQueueService();
+        await queueService.add(this.getConfig().stepWorkerQueueName, {
+            runId,
+            stepName,
+            rpcName,
+            data,
+        });
+    }
     /**
      * Execute a workflow sleep step completion
      * Sets the step result to null and resumes the workflow
      * @param data - Sleeper input data
      */
-    async executeWorkflowSleep(runId, stepId) {
+    async executeWorkflowSleepCompleted(runId, stepId) {
         await this.setStepResult(stepId, null);
         await this.resumeWorkflow(runId);
     }
@@ -61,44 +165,96 @@ export class PikkuWorkflowService {
     }
     /**
      * Start a new workflow run
+     * Automatically detects workflow type (DSL or graph) from meta and executes accordingly
+     * @param options.inline - If true, execute workflow directly without queue service
+     * @param options.startNode - Starting node ID for graph workflows (from wire config)
      */
-    async startWorkflow(name, input, rpcService) {
-        const registrations = pikkuState('workflows', 'registrations');
+    async startWorkflow(name, input, wire, rpcService, options) {
+        // Check meta to determine workflow type
+        const meta = pikkuState(null, 'workflows', 'meta');
+        const workflowMeta = meta[name];
+        if (!workflowMeta) {
+            throw new WorkflowNotFoundError(name);
+        }
+        // Check if this is a graph workflow (source === 'graph')
+        if (workflowMeta.source === 'graph') {
+            const shouldInline = options?.inline || !this.singletonServices?.queueService;
+            return runWorkflowGraph(this, name, input, rpcService, shouldInline, options?.startNode, wire);
+        }
+        // DSL workflow - check registration exists
+        const registrations = pikkuState(null, 'workflows', 'registrations');
         const workflow = registrations.get(name);
         if (!workflow) {
             throw new WorkflowNotFoundError(name);
         }
-        // Create workflow run in state
-        const runId = await this.createRun(name, input);
-        // If queue service is available, use remote execution (queue-based)
-        // Otherwise, execute directly (inline/synchronous)
-        if (this.singletonServices?.queueService) {
-            // Queue orchestrator to start the workflow
-            await this.resumeWorkflow(runId);
+        if (!workflowMeta.graphHash) {
+            throw new Error(`Missing workflow graphHash for '${name}'`);
+        }
+        const runId = await this.createRun(name, input, options?.inline ?? false, workflowMeta.graphHash, wire);
+        if (options?.inline) {
+            this.inlineRuns.add(runId);
+        }
+        if (options?.inline || !this.singletonServices?.queueService) {
+            this.runWorkflowJob(runId, rpcService)
+                .catch(() => { })
+                .finally(() => {
+                if (options?.inline) {
+                    this.inlineRuns.delete(runId);
+                }
+            });
         }
         else {
-            // No queue service - execute directly via runWorkflowJob
-            await this.runWorkflowJob(runId, rpcService);
+            await this.resumeWorkflow(runId);
         }
         return { runId };
     }
+    async runToCompletion(name, input, rpcService, options) {
+        const pollInterval = options?.pollIntervalMs ?? 1000;
+        const { runId } = await this.startWorkflow(name, input, options?.wire ?? { type: 'internal' }, rpcService, { inline: true });
+        while (true) {
+            const run = await this.getRun(runId);
+            if (!run) {
+                throw new WorkflowRunNotFoundError(runId);
+            }
+            if (WORKFLOW_END_STATES.has(run.status)) {
+                if (run.status === 'failed') {
+                    throw new Error(run.error?.message || 'Workflow failed');
+                }
+                if (run.status === 'cancelled') {
+                    throw new Error('Workflow was cancelled');
+                }
+                return run.output;
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+    }
     async runWorkflowJob(runId, rpcService) {
         const run = await this.getRun(runId);
         if (!run) {
-            throw new WorkflowRunNotFound(runId);
+            throw new WorkflowRunNotFoundError(runId);
+        }
+        const meta = pikkuState(null, 'workflows', 'meta');
+        const workflowMeta = meta[run.workflow];
+        if (run.graphHash &&
+            workflowMeta?.graphHash &&
+            run.graphHash !== workflowMeta.graphHash) {
+            await this.runVersionMismatchFallback(run, workflowMeta, rpcService);
+            return;
         }
-        const registrations = pikkuState('workflows', 'registrations');
+        if (workflowMeta?.source === 'graph') {
+            await continueGraph(this, runId, run.workflow);
+            return;
+        }
+        const registrations = pikkuState(null, 'workflows', 'registrations');
         const workflow = registrations.get(run.workflow);
         if (!workflow) {
             throw new WorkflowNotFoundError(run.workflow);
         }
         await this.withRunLock(runId, async () => {
-            const meta = pikkuState('workflows', 'meta');
-            const workflowMeta = meta[run.workflow];
             const workflowWire = this.createWorkflowWire(run.workflow, runId, rpcService);
             const wire = { workflow: workflowWire };
             try {
-                const result = await runPikkuFunc('workflow', workflowMeta.workflowName, workflowMeta.pikkuFuncName, {
+                const result = await runPikkuFunc('workflow', workflowMeta.name, workflowMeta.pikkuFuncId, {
                     singletonServices: this.singletonServices,
                     wire,
                     createWireServices: this.createWireServices,
@@ -108,12 +264,22 @@ export class PikkuWorkflowService {
             }
             catch (error) {
                 if (error instanceof WorkflowAsyncException) {
-                    // Normal - workflow paused for step execution
                     throw error;
                 }
-                // Check if it's a WorkflowCancelledException
                 if (error instanceof WorkflowCancelledException) {
-                    // Workflow was cancelled - status already updated, just rethrow
+                    await this.updateRunStatus(runId, 'cancelled', undefined, {
+                        message: error.message || 'Workflow cancelled',
+                        stack: '',
+                        code: 'WORKFLOW_CANCELLED',
+                    });
+                    throw error;
+                }
+                if (error instanceof WorkflowSuspendedException) {
+                    await this.updateRunStatus(runId, 'suspended', undefined, {
+                        message: error.message || 'Workflow suspended',
+                        stack: '',
+                        code: 'WORKFLOW_SUSPENDED',
+                    });
                     throw error;
                 }
                 await this.updateRunStatus(runId, 'failed', undefined, {
@@ -125,6 +291,27 @@ export class PikkuWorkflowService {
             }
         });
     }
+    async runVersionMismatchFallback(run, currentMeta, rpcService) {
+        const source = currentMeta.source;
+        if (source === 'complex') {
+            await this.updateRunStatus(run.id, 'failed', undefined, {
+                message: `Workflow '${run.workflow}' definition changed. Complex workflows with inline steps cannot be migrated.`,
+                stack: '',
+                code: 'VERSION_CONFLICT',
+            });
+            return;
+        }
+        const version = await this.getWorkflowVersion(run.workflow, run.graphHash);
+        if (!version) {
+            await this.updateRunStatus(run.id, 'failed', undefined, {
+                message: `Workflow '${run.workflow}' version '${run.graphHash}' not found. Cannot resume with changed definition.`,
+                stack: '',
+                code: 'VERSION_NOT_FOUND',
+            });
+            return;
+        }
+        await runFromMeta(this, run.id, version.graph, rpcService);
+    }
     /**
      * Execute a single workflow step (called by worker)
      * Handles idempotency, RPC execution, result storage, retry logic, and orchestrator triggering
@@ -147,30 +334,44 @@ export class PikkuWorkflowService {
             if (stepState.status === 'failed') {
                 stepState = await this.createRetryAttempt(stepState.stepId, 'running');
             }
-            if (stepState.status !== 'pending') {
-                // Mark step as running (pending or failed status)
+            if (stepState.status === 'pending') {
+                // Mark pending step as running before execution
                 await this.setStepRunning(stepState.stepId);
             }
             try {
-                // Execute RPC with workflow step context
-                const result = await rpcService.rpcWithWire(rpcName, data, {
-                    workflowStep: {
-                        runId,
-                        stepId: stepState.stepId,
-                        attemptCount: stepState.attemptCount,
-                    },
-                });
+                let result;
+                const run = await this.getRun(runId);
+                if (!run) {
+                    throw new Error(`Workflow run not found: ${runId}`);
+                }
+                const meta = pikkuState(null, 'workflows', 'meta');
+                const workflowMeta = meta[run.workflow];
+                if (workflowMeta?.nodes && stepName in workflowMeta.nodes) {
+                    result = await executeGraphStep(this, rpcService, runId, stepState.stepId, stepName, rpcName, data, run.workflow);
+                }
+                else {
+                    result = await rpcService.rpcWithWire(rpcName, data, {
+                        workflowStep: {
+                            runId,
+                            stepId: stepState.stepId,
+                            attemptCount: stepState.attemptCount,
+                        },
+                    });
+                }
                 // Store result and mark succeeded
                 await this.setStepResult(stepState.stepId, result);
                 // Resume orchestrator to continue workflow
-                try {
-                    await this.resumeWorkflow(runId);
-                }
-                catch (resumeError) {
-                    throw resumeError;
-                }
+                await this.resumeWorkflow(runId);
             }
             catch (error) {
+                if (error instanceof RPCNotFoundError) {
+                    await this.setStepError(stepState.stepId, error);
+                    await this.updateRunStatus(runId, 'suspended', undefined, {
+                        message: `RPC '${rpcName}' not found. Deploy the missing function and resume.`,
+                        code: 'RPC_NOT_FOUND',
+                    });
+                    return;
+                }
                 // Store error and mark failed
                 await this.setStepError(stepState.stepId, error);
                 const maxAttempts = (stepState.retries ?? 0) + 1;
@@ -195,7 +396,8 @@ export class PikkuWorkflowService {
         }
         catch (error) {
             if (error.name === 'WorkflowAsyncException' ||
-                error.name === 'WorkflowCancelledException') {
+                error.name === 'WorkflowCancelledException' ||
+                error.name === 'WorkflowSuspendedException') {
                 return;
             }
             await this.updateRunStatus(runId, 'failed', undefined, {
@@ -218,7 +420,7 @@ export class PikkuWorkflowService {
         try {
             stepState = await this.getStepState(runId, stepName);
         }
-        catch (error) {
+        catch {
             // Step doesn't exist - create it
             stepState = await this.insertStepState(runId, stepName, rpcName, data, stepOptions);
         }
@@ -242,8 +444,8 @@ export class PikkuWorkflowService {
         }
         // Step is pending - schedule it
         await this.setStepScheduled(stepState.stepId);
-        // Enqueue step worker
-        if (this.singletonServices.queueService) {
+        // Enqueue step worker (unless inline mode)
+        if (!this.isInline(runId) && this.singletonServices.queueService) {
             // Map step retry options to queue job options
             const retries = stepOptions?.retries ?? 0;
             const retryDelay = stepOptions?.retryDelay;
@@ -262,41 +464,54 @@ export class PikkuWorkflowService {
                         ? 'exponential'
                         : undefined,
             });
+            // Pause workflow - step will callback when done
+            throw new WorkflowAsyncException(runId, stepName);
         }
         else {
-            // No queue service - execute locally
+            // Inline or no queue service - execute locally with retry loop
             const retries = stepOptions?.retries ?? 0;
             const retryDelay = stepOptions?.retryDelay;
-            const attemptCount = stepState.attemptCount;
-            try {
-                const result = await rpcService.rpcWithWire(rpcName, data, {
-                    workflowStep: {
-                        runId,
-                        stepId: stepState.stepId,
-                        attemptCount: stepState.attemptCount,
-                    },
-                });
-                await this.setStepResult(stepState.stepId, result);
-                return result;
-            }
-            catch (error) {
-                // Record the error (marks step as failed)
-                await this.setStepError(stepState.stepId, error);
-                // Check if we should retry
-                if (attemptCount < retries) {
-                    // Create a new pending retry attempt (copies metadata from failed step)
-                    await this.createRetryAttempt(stepState.stepId, 'pending');
-                    // Schedule orchestrator to retry after delay
-                    await this.scheduleOrchestratorRetry(runId, retryDelay);
-                    // Pause workflow - orchestrator will replay and pick up new attempt
-                    throw new WorkflowAsyncException(runId, stepName);
+            let currentStepState = stepState;
+            while (true) {
+                try {
+                    await this.setStepRunning(currentStepState.stepId);
+                    const result = await rpcService.rpcWithWire(rpcName, data, {
+                        workflowStep: {
+                            runId,
+                            stepId: currentStepState.stepId,
+                            attemptCount: currentStepState.attemptCount,
+                        },
+                    });
+                    await this.setStepResult(currentStepState.stepId, result);
+                    return result;
+                }
+                catch (error) {
+                    if (error instanceof RPCNotFoundError) {
+                        await this.updateRunStatus(runId, 'suspended', undefined, {
+                            message: `RPC '${rpcName}' not found. Deploy the missing function and resume.`,
+                            code: 'RPC_NOT_FOUND',
+                        });
+                        throw error;
+                    }
+                    // Record the error (marks step as failed)
+                    await this.setStepError(currentStepState.stepId, error);
+                    // Check if we should retry
+                    if (currentStepState.attemptCount < retries) {
+                        // Create a new pending retry attempt
+                        currentStepState = await this.createRetryAttempt(currentStepState.stepId, 'pending');
+                        // Wait for retry delay if specified
+                        if (retryDelay) {
+                            await new Promise((resolve) => setTimeout(resolve, getDurationInMilliseconds(retryDelay)));
+                        }
+                        // Continue loop to retry
+                    }
+                    else {
+                        // No more retries, fail the workflow
+                        throw error;
+                    }
                 }
-                // No more retries, fail the workflow
-                throw error;
             }
         }
-        // Pause workflow - step will callback when done
-        throw new WorkflowAsyncException(runId, stepName);
     }
     async inlineStep(runId, stepName, fn, stepOptions) {
         // Check if step already exists
@@ -304,11 +519,9 @@ export class PikkuWorkflowService {
         try {
             stepState = await this.getStepState(runId, stepName);
         }
-        catch (error) {
+        catch {
             // Step doesn't exist - create it (inline, no RPC)
-            stepState = await this.insertStepState(runId, stepName, null, // No RPC for inline steps
-            null, // No data for inline steps
-            stepOptions);
+            stepState = await this.insertStepState(runId, stepName, null, null, stepOptions);
         }
         if (stepState.status === 'succeeded') {
             // Return cached result
@@ -317,26 +530,60 @@ export class PikkuWorkflowService {
         // Execute inline function
         const retries = stepOptions?.retries ?? this.getConfig().retries;
         const retryDelay = stepOptions?.retryDelay ?? this.getConfig().retryDelay;
-        const attemptCount = stepState.attemptCount;
-        try {
-            const result = await fn();
-            await this.setStepResult(stepState.stepId, result);
-            return result;
+        let currentStepState = stepState;
+        // Check if we're running inline (in-memory) or remote (queue-based)
+        if (this.isInline(runId)) {
+            // Inline mode - execute with retry loop
+            while (true) {
+                try {
+                    await this.setStepRunning(currentStepState.stepId);
+                    const result = await fn();
+                    await this.setStepResult(currentStepState.stepId, result);
+                    return result;
+                }
+                catch (error) {
+                    // Record the error (marks step as failed)
+                    await this.setStepError(currentStepState.stepId, error);
+                    // Check if we should retry
+                    if (currentStepState.attemptCount < retries) {
+                        // Create a new pending retry attempt
+                        currentStepState = await this.createRetryAttempt(currentStepState.stepId, 'pending');
+                        // Wait for retry delay if specified
+                        if (retryDelay) {
+                            await new Promise((resolve) => setTimeout(resolve, getDurationInMilliseconds(retryDelay)));
+                        }
+                        // Continue loop to retry
+                    }
+                    else {
+                        // No more retries, fail the workflow
+                        throw error;
+                    }
+                }
+            }
         }
-        catch (error) {
-            // Record the error (marks step as failed)
-            await this.setStepError(stepState.stepId, error);
-            // Check if we should retry
-            if (attemptCount < retries) {
-                // Create a new pending retry attempt (copies metadata from failed step)
-                await this.createRetryAttempt(stepState.stepId, 'pending');
-                // Schedule orchestrator to retry after delay
-                await this.scheduleOrchestratorRetry(runId, retryDelay);
-                // Pause workflow - orchestrator will replay and pick up new attempt
-                throw new WorkflowAsyncException(runId, stepName);
+        else {
+            // Remote mode - use queue-based retry
+            try {
+                await this.setStepRunning(currentStepState.stepId);
+                const result = await fn();
+                await this.setStepResult(currentStepState.stepId, result);
+                return result;
+            }
+            catch (error) {
+                // Record the error (marks step as failed)
+                await this.setStepError(currentStepState.stepId, error);
+                // Check if we should retry
+                if (currentStepState.attemptCount < retries) {
+                    // Create a new pending retry attempt (copies metadata from failed step)
+                    await this.createRetryAttempt(currentStepState.stepId, 'pending');
+                    // Schedule orchestrator to retry after delay
+                    await this.scheduleOrchestratorRetry(runId, retryDelay);
+                    // Pause workflow - orchestrator will replay and pick up new attempt
+                    throw new WorkflowAsyncException(runId, stepName);
+                }
+                // No more retries, fail the workflow
+                throw error;
             }
-            // No more retries, fail the workflow
-            throw error;
         }
     }
     async sleepStep(runId, stepName, duration) {
@@ -345,12 +592,11 @@ export class PikkuWorkflowService {
         try {
             stepState = await this.getStepState(runId, stepName);
         }
-        catch (error) {
+        catch {
             // Step doesn't exist - create it (sleep step, no RPC)
-            stepState = await this.insertStepState(runId, stepName, null, // No RPC for sleep steps
-            { duration }, // Store duration as data
-            undefined // No retry options for sleep
-            );
+            stepState = await this.insertStepState(runId, stepName, null, {
+                duration,
+            });
         }
         if (stepState.status === 'succeeded') {
             // Sleep already completed, return immediately
@@ -362,13 +608,15 @@ export class PikkuWorkflowService {
         }
         // Step is pending - schedule it
         await this.setStepScheduled(stepState.stepId);
-        // Check if we have queue service (remote mode) or inline mode
-        if (this.singletonServices.schedulerService) {
-            // Remote mode - enqueue sleep worker with delay
+        // Check if inline mode or no scheduler service
+        if (!this.isInline(runId) && this.singletonServices.schedulerService) {
+            // Remote mode - schedule sleep via scheduler service
             await this.singletonServices.schedulerService.scheduleRPC(duration, this.getConfig().sleeperRPCName, {
                 runId,
                 stepId: stepState.stepId,
             });
+            // Pause workflow - sleep will callback when done
+            throw new WorkflowAsyncException(runId, stepName);
         }
         else {
             // Inline mode - use setTimeout with actual duration
@@ -376,22 +624,46 @@ export class PikkuWorkflowService {
             await this.setStepResult(stepState.stepId, null);
             return;
         }
-        // Pause workflow - sleep will callback when done
-        throw new WorkflowAsyncException(runId, stepName);
     }
-    async cancelWorkflow(runId, reason) {
-        // Update workflow run status to cancelled
-        await this.updateRunStatus(runId, 'cancelled', undefined, {
-            message: reason || 'Workflow cancelled by user',
-            stack: '',
-            code: 'WORKFLOW_CANCELLED',
+    getSuspendStepName(reason) {
+        if (!reason) {
+            return '__workflow_suspend';
+        }
+        return '__workflow_suspend';
+    }
+    async suspendStep(runId, reason) {
+        const stepName = this.getSuspendStepName(reason);
+        await this.withStepLock(runId, stepName, async () => {
+            let stepState;
+            try {
+                stepState = await this.getStepState(runId, stepName);
+            }
+            catch {
+                stepState = await this.insertStepState(runId, stepName, 'pikkuWorkflowSuspend', {
+                    reason,
+                });
+            }
+            if (!stepState.stepId) {
+                stepState = await this.insertStepState(runId, stepName, 'pikkuWorkflowSuspend', {
+                    reason,
+                });
+            }
+            if (stepState.status === 'succeeded') {
+                return;
+            }
+            if (stepState.status === 'pending') {
+                await this.setStepRunning(stepState.stepId);
+            }
+            await this.setStepResult(stepState.stepId, {
+                reason,
+                suspendedAt: new Date().toISOString(),
+            });
+            throw new WorkflowSuspendedException(runId, reason);
         });
-        // Throw cancellation exception to stop workflow execution
-        throw new WorkflowCancelledException(runId, reason);
     }
-    createWorkflowWire(workflowName, runId, rpcService) {
+    createWorkflowWire(name, runId, rpcService) {
         const workflowWire = {
-            workflowName,
+            name,
             runId,
             getRun: async () => (await this.getRun(runId)),
             // Implement workflow.do() - RPC form
@@ -409,9 +681,8 @@ export class PikkuWorkflowService {
                 this.verifyStepName(stepName);
                 await this.sleepStep(runId, stepName, getDurationInMilliseconds(duration));
             },
-            // Implement workflow.cancel()
-            cancel: async (reason) => {
-                await this.cancelWorkflow(runId, reason);
+            suspend: async (reason) => {
+                await this.suspendStep(runId, reason || 'Workflow suspended');
             },
         };
         return workflowWire;