refactor(wait): rename Suspend Workflow toggle to Async

Author: TheodoreSpeaks

apps/sim/blocks/blocks/wait.ts

@@ -10,11 +10,11 @@ export const WaitBlock: BlockConfig = {
   name: 'Wait',
   description: 'Pause workflow execution for a time interval',
   longDescription:
-    'Pauses workflow execution for a specified time interval. By default the wait runs in-process for up to 5 minutes. Enable Suspend Workflow to pause the run on disk and resume automatically for waits up to 30 days.',
+    'Pauses workflow execution for a specified time interval. By default the wait runs in-process for up to 5 minutes. Enable Async to pause the run on disk and resume automatically for waits up to 30 days.',
   bestPractices: `
   - Configure the wait amount and unit
   - Default mode runs in-process and caps at 5 minutes
-  - Enable Suspend Workflow for longer waits (up to 30 days); seconds are not available in this mode
+  - Enable Async for longer waits (up to 30 days); seconds are not available in this mode
   - Enter a positive number for the wait amount
   `,
   category: 'blocks',
@@ -26,7 +26,7 @@ export const WaitBlock: BlockConfig = {
       id: 'timeValue',
       title: 'Wait Amount',
       type: 'short-input',
-      description: 'Max 5 minutes (300 seconds). Enable Suspend Workflow for up to 30 days.',
+      description: 'Max 5 minutes (300 seconds). Enable Async for up to 30 days.',
       placeholder: '10',
       value: () => '10',
       required: true,
@@ -41,7 +41,7 @@ export const WaitBlock: BlockConfig = {
       ],
       value: () => 'seconds',
       required: true,
-      condition: { field: 'suspend', value: true, not: true },
+      condition: { field: 'async', value: true, not: true },
     },
     {
       id: 'timeUnitLong',
@@ -54,35 +54,35 @@ export const WaitBlock: BlockConfig = {
       ],
       value: () => 'minutes',
       required: true,
-      condition: { field: 'suspend', value: true },
+      condition: { field: 'async', value: true },
     },
     {
-      id: 'suspend',
-      title: 'Suspend Workflow',
+      id: 'async',
+      title: 'Async',
       type: 'switch',
       tooltip:
-        'By default, the workflow pauses in memory and can wait up to 5 minutes. Turn this on to suspend the run to disk so it can wait much longer (up to 30 days) — execution resumes automatically when the timer fires. Seconds aren’t available while suspended.',
+        'By default, the workflow pauses in memory and can wait up to 5 minutes. Turn this on to run asynchronously — the workflow is saved to disk and resumed automatically when the timer fires, allowing waits up to 30 days. Seconds aren’t available in async mode.',
     },
   ],
   tools: {
     access: [],
   },
   inputs: {
-    suspend: {
+    async: {
       type: 'boolean',
-      description: 'Suspend the workflow to allow waits up to 30 days',
+      description: 'Run the wait asynchronously to allow durations up to 30 days',
     },
     timeValue: {
       type: 'string',
       description: 'Wait duration value',
     },
     timeUnit: {
       type: 'string',
-      description: 'Wait duration unit when suspend is off (seconds or minutes)',
+      description: 'Wait duration unit when async is off (seconds or minutes)',
     },
     timeUnitLong: {
       type: 'string',
-      description: 'Wait duration unit when suspend is on (minutes, hours, or days)',
+      description: 'Wait duration unit when async is on (minutes, hours, or days)',
     },
   },
   outputs: {

apps/sim/executor/handlers/wait/wait-handler.test.ts

@@ -120,27 +120,27 @@ describe('WaitBlockHandler', () => {
     ).rejects.toThrow('Unknown wait unit: fortnights')
   })
 
-  it('should reject suspending waits longer than the 30-day ceiling', async () => {
+  it('should reject async waits longer than the 30-day ceiling', async () => {
     await expect(
       handler.execute(mockContext, mockBlock, {
-        suspend: true,
+        async: true,
         timeValue: '31',
         timeUnitLong: 'days',
       })
     ).rejects.toThrow('Wait time exceeds maximum of 30 days')
   })
 
-  it('should reject non-suspending waits longer than 5 minutes', async () => {
+  it('should reject synchronous waits longer than 5 minutes', async () => {
     await expect(
       handler.execute(mockContext, mockBlock, { timeValue: '10', timeUnit: 'minutes' })
     ).rejects.toThrow('Wait time exceeds maximum of 5 minutes')
   })
 
-  it('should default the suspend unit to minutes when timeUnitLong is missing', async () => {
+  it('should default the async unit to minutes when timeUnitLong is missing', async () => {
     vi.setSystemTime(new Date('2026-04-28T00:00:00.000Z'))
 
     const result = (await handler.execute(mockContext, mockBlock, {
-      suspend: true,
+      async: true,
       timeValue: '3',
     })) as Record<string, any>
 
@@ -149,14 +149,14 @@ describe('WaitBlockHandler', () => {
     expect(result.status).toBe('waiting')
   })
 
-  it('should reject seconds as a unit when Suspend Workflow is enabled', async () => {
+  it('should reject seconds as a unit when Async is enabled', async () => {
     await expect(
       handler.execute(mockContext, mockBlock, {
-        suspend: true,
+        async: true,
         timeValue: '30',
         timeUnitLong: 'seconds',
       })
-    ).rejects.toThrow('Seconds are not allowed when Suspend Workflow is enabled')
+    ).rejects.toThrow('Seconds are not allowed when Async is enabled')
   })
 
   it('should still execute in-process at the 5-minute boundary', async () => {
@@ -177,7 +177,7 @@ describe('WaitBlockHandler', () => {
   it('should suspend the workflow when wait exceeds the in-process threshold', async () => {
     vi.setSystemTime(new Date('2026-04-28T00:00:00.000Z'))
 
-    const inputs = { suspend: true, timeValue: '10', timeUnitLong: 'minutes' }
+    const inputs = { async: true, timeValue: '10', timeUnitLong: 'minutes' }
 
     const result = (await handler.execute(mockContext, mockBlock, inputs)) as Record<string, any>
 
@@ -200,7 +200,7 @@ describe('WaitBlockHandler', () => {
   it('should suspend the workflow for multi-day waits', async () => {
     vi.setSystemTime(new Date('2026-04-28T00:00:00.000Z'))
 
-    const inputs = { suspend: true, timeValue: '2', timeUnitLong: 'days' }
+    const inputs = { async: true, timeValue: '2', timeUnitLong: 'days' }
 
     const result = (await handler.execute(mockContext, mockBlock, inputs)) as Record<string, any>
 
@@ -218,7 +218,7 @@ describe('WaitBlockHandler', () => {
     vi.setSystemTime(new Date('2026-04-28T00:00:00.000Z'))
 
     const result = (await handler.execute(mockContext, mockBlock, {
-      suspend: true,
+      async: true,
       timeValue: '3',
       timeUnitLong: 'hours',
     })) as Record<string, any>
@@ -271,7 +271,7 @@ describe('WaitBlockHandler', () => {
     mockContext.abortSignal = abortController.signal
 
     const result = (await handler.execute(mockContext, mockBlock, {
-      suspend: true,
+      async: true,
       timeValue: '1',
       timeUnitLong: 'hours',
     })) as Record<string, any>
@@ -299,7 +299,7 @@ describe('WaitBlockHandler', () => {
     vi.setSystemTime(new Date('2026-04-28T00:00:00.000Z'))
 
     const result = (await handler.execute(mockContext, mockBlock, {
-      suspend: true,
+      async: true,
       timeValue: '1.5',
       timeUnitLong: 'days',
     })) as Record<string, any>
@@ -310,11 +310,11 @@ describe('WaitBlockHandler', () => {
     expect(result._pauseMetadata.pauseKind).toBe('time')
   })
 
-  it('should always suspend when suspend is enabled, even for short waits', async () => {
+  it('should always suspend when async is enabled, even for short waits', async () => {
     vi.setSystemTime(new Date('2026-04-28T00:00:00.000Z'))
 
     const result = (await handler.execute(mockContext, mockBlock, {
-      suspend: true,
+      async: true,
       timeValue: '2',
       timeUnitLong: 'minutes',
     })) as Record<string, any>

apps/sim/executor/handlers/wait/wait-handler.ts

@@ -10,11 +10,11 @@ import type { SerializedBlock } from '@/serializer/types'
 
 const CANCELLATION_CHECK_INTERVAL_MS = 500
 
-/** Hard ceiling for in-process (non-suspending) waits. */
+/** Hard ceiling for in-process (synchronous) waits. */
 const MAX_INPROCESS_WAIT_MS = 5 * 60 * 1000
 
-/** Hard ceiling for suspending waits. */
-const MAX_SUSPEND_WAIT_MS = 30 * 24 * 60 * 60 * 1000
+/** Hard ceiling for async waits. */
+const MAX_ASYNC_WAIT_MS = 30 * 24 * 60 * 60 * 1000
 
 interface SleepOptions {
   signal?: AbortSignal
@@ -91,10 +91,10 @@ function isWaitUnit(value: string): value is WaitUnit {
 /**
  * Handler for Wait blocks that pause workflow execution for a time delay.
  *
- * Default (suspend=false) waits are held in-process via an interruptible sleep and capped at 5 minutes.
- * When suspend=true is set, the workflow is always suspended by returning {@link PauseMetadata} with
+ * Default (async=false) waits are held in-process via an interruptible sleep and capped at 5 minutes.
+ * When async=true is set, the workflow is always suspended by returning {@link PauseMetadata} with
  * `pauseKind: 'time'`; the cron-driven resume poller (see `/api/resume/poll`) picks the execution back
- * up once `resumeAt` is reached. Suspend caps at 30 days.
+ * up once `resumeAt` is reached. Async caps at 30 days.
  */
 export class WaitBlockHandler implements BlockHandler {
   canHandle(block: SerializedBlock): boolean {
@@ -124,9 +124,9 @@ export class WaitBlockHandler implements BlockHandler {
       executionOrder?: number
     }
   ): Promise<BlockOutput> {
-    const suspend = inputs.suspend === true || inputs.suspend === 'true'
+    const isAsync = inputs.async === true || inputs.async === 'true'
     const timeValue = Number.parseFloat(inputs.timeValue || '10')
-    const timeUnit = suspend ? inputs.timeUnitLong || 'minutes' : inputs.timeUnit || 'seconds'
+    const timeUnit = isAsync ? inputs.timeUnitLong || 'minutes' : inputs.timeUnit || 'seconds'
 
     if (!Number.isFinite(timeValue) || timeValue <= 0) {
       throw new Error('Wait amount must be a positive number')
@@ -136,23 +136,21 @@ export class WaitBlockHandler implements BlockHandler {
       throw new Error(`Unknown wait unit: ${timeUnit}`)
     }
 
-    if (suspend && timeUnit === 'seconds') {
-      throw new Error('Seconds are not allowed when Suspend Workflow is enabled')
+    if (isAsync && timeUnit === 'seconds') {
+      throw new Error('Seconds are not allowed when Async is enabled')
     }
 
     const waitMs = Math.round(timeValue * UNIT_TO_MS[timeUnit])
 
-    if (suspend) {
-      if (waitMs > MAX_SUSPEND_WAIT_MS) {
+    if (isAsync) {
+      if (waitMs > MAX_ASYNC_WAIT_MS) {
         throw new Error('Wait time exceeds maximum of 30 days')
       }
     } else if (waitMs > MAX_INPROCESS_WAIT_MS) {
-      throw new Error(
-        'Wait time exceeds maximum of 5 minutes; enable Suspend Workflow to wait up to 30 days'
-      )
+      throw new Error('Wait time exceeds maximum of 5 minutes; enable Async to wait up to 30 days')
     }
 
-    if (!suspend) {
+    if (!isAsync) {
       const completed = await sleep(waitMs, {
         signal: ctx.abortSignal,
         executionId: ctx.executionId,