feat(wait): add Suspend Workflow toggle, restore 5-min in-process default

Author: TheodoreSpeaks

apps/sim/blocks/blocks/wait.ts

@@ -8,14 +8,13 @@ const WaitIcon = (props: SVGProps<SVGSVGElement>) => createElement(PauseCircle,
 export const WaitBlock: BlockConfig = {
   type: 'wait',
   name: 'Wait',
-  description: 'Pause workflow execution for up to 30 days',
+  description: 'Pause workflow execution for a time interval',
   longDescription:
-    'Pauses workflow execution for a specified time interval. Waits up to five minutes are held in-process; longer waits suspend the workflow and resume automatically once the configured duration elapses.',
+    '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.',
   bestPractices: `
-  - Configure the wait amount and unit (seconds, minutes, hours, or days)
-  - Maximum wait duration is 30 days
-  - Waits up to 5 minutes execute in-process and are interruptible via workflow cancellation
-  - Longer waits suspend the workflow; the execution resumes automatically when the timer fires
+  - 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
   - Enter a positive number for the wait amount
   `,
   category: 'blocks',
@@ -27,7 +26,6 @@ export const WaitBlock: BlockConfig = {
       id: 'timeValue',
       title: 'Wait Amount',
       type: 'short-input',
-      description: 'Max: 30 days',
       placeholder: '10',
       value: () => '10',
       required: true,
@@ -39,24 +37,51 @@ export const WaitBlock: BlockConfig = {
       options: [
         { label: 'Seconds', id: 'seconds' },
         { label: 'Minutes', id: 'minutes' },
+      ],
+      value: () => 'seconds',
+      required: true,
+      condition: { field: 'suspend', value: true, not: true },
+    },
+    {
+      id: 'timeUnitLong',
+      title: 'Unit',
+      type: 'dropdown',
+      options: [
+        { label: 'Minutes', id: 'minutes' },
         { label: 'Hours', id: 'hours' },
         { label: 'Days', id: 'days' },
       ],
-      value: () => 'seconds',
+      value: () => 'minutes',
       required: true,
+      condition: { field: 'suspend', value: true },
+    },
+    {
+      id: 'suspend',
+      title: 'Suspend Workflow',
+      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.',
     },
   ],
   tools: {
     access: [],
   },
   inputs: {
+    suspend: {
+      type: 'boolean',
+      description: 'Suspend the workflow to allow waits up to 30 days',
+    },
     timeValue: {
       type: 'string',
       description: 'Wait duration value',
     },
     timeUnit: {
       type: 'string',
-      description: 'Wait duration unit (seconds, minutes, hours, or days)',
+      description: 'Wait duration unit when suspend is off (seconds or minutes)',
+    },
+    timeUnitLong: {
+      type: 'string',
+      description: 'Wait duration unit when suspend is on (minutes, hours, or days)',
     },
   },
   outputs: {

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

@@ -120,12 +120,32 @@ describe('WaitBlockHandler', () => {
     ).rejects.toThrow('Unknown wait unit: fortnights')
   })
 
-  it('should reject waits longer than the 30-day ceiling', async () => {
+  it('should reject suspending waits longer than the 30-day ceiling', async () => {
     await expect(
-      handler.execute(mockContext, mockBlock, { timeValue: '31', timeUnit: 'days' })
+      handler.execute(mockContext, mockBlock, {
+        suspend: 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 () => {
+    await expect(
+      handler.execute(mockContext, mockBlock, { timeValue: '10', timeUnit: 'minutes' })
+    ).rejects.toThrow('Wait time exceeds maximum of 5 minutes')
+  })
+
+  it('should reject seconds as a unit when Suspend Workflow is enabled', async () => {
+    await expect(
+      handler.execute(mockContext, mockBlock, {
+        suspend: true,
+        timeValue: '30',
+        timeUnitLong: 'seconds',
+      })
+    ).rejects.toThrow('Seconds are not allowed when Suspend Workflow is enabled')
+  })
+
   it('should still execute in-process at the 5-minute boundary', async () => {
     const inputs = { timeValue: '5', timeUnit: 'minutes' }
 
@@ -144,7 +164,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 = { timeValue: '10', timeUnit: 'minutes' }
+    const inputs = { suspend: true, timeValue: '10', timeUnitLong: 'minutes' }
 
     const result = (await handler.execute(mockContext, mockBlock, inputs)) as Record<string, any>
 
@@ -167,7 +187,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 = { timeValue: '2', timeUnit: 'days' }
+    const inputs = { suspend: true, timeValue: '2', timeUnitLong: 'days' }
 
     const result = (await handler.execute(mockContext, mockBlock, inputs)) as Record<string, any>
 
@@ -185,8 +205,9 @@ describe('WaitBlockHandler', () => {
     vi.setSystemTime(new Date('2026-04-28T00:00:00.000Z'))
 
     const result = (await handler.execute(mockContext, mockBlock, {
+      suspend: true,
       timeValue: '3',
-      timeUnit: 'hours',
+      timeUnitLong: 'hours',
     })) as Record<string, any>
 
     const waitMs = 3 * 60 * 60 * 1000
@@ -237,8 +258,9 @@ describe('WaitBlockHandler', () => {
     mockContext.abortSignal = abortController.signal
 
     const result = (await handler.execute(mockContext, mockBlock, {
+      suspend: true,
       timeValue: '1',
-      timeUnit: 'hours',
+      timeUnitLong: 'hours',
     })) as Record<string, any>
 
     expect(result.status).toBe('waiting')
@@ -264,13 +286,33 @@ describe('WaitBlockHandler', () => {
     vi.setSystemTime(new Date('2026-04-28T00:00:00.000Z'))
 
     const result = (await handler.execute(mockContext, mockBlock, {
+      suspend: true,
       timeValue: '1.5',
-      timeUnit: 'days',
+      timeUnitLong: 'days',
     })) as Record<string, any>
 
     const waitMs = 1.5 * 24 * 60 * 60 * 1000
     expect(result.waitDuration).toBe(waitMs)
     expect(result.status).toBe('waiting')
     expect(result._pauseMetadata.pauseKind).toBe('time')
   })
+
+  it('should always suspend when suspend 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,
+      timeValue: '2',
+      timeUnitLong: 'minutes',
+    })) as Record<string, any>
+
+    const waitMs = 2 * 60 * 1000
+    const expectedResumeAt = new Date(Date.now() + waitMs).toISOString()
+
+    expect(result.status).toBe('waiting')
+    expect(result.waitDuration).toBe(waitMs)
+    expect(result.resumeAt).toBe(expectedResumeAt)
+    expect(result._pauseMetadata.pauseKind).toBe('time')
+    expect(result._pauseMetadata.resumeAt).toBe(expectedResumeAt)
+  })
 })

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

@@ -1,4 +1,3 @@
-import { env, envNumber } from '@/lib/core/config/env'
 import { isExecutionCancelled, isRedisCancellationEnabled } from '@/lib/execution/cancellation'
 import type { BlockOutput } from '@/blocks/types'
 import { BlockType } from '@/executor/constants'
@@ -11,11 +10,11 @@ import type { SerializedBlock } from '@/serializer/types'
 
 const CANCELLATION_CHECK_INTERVAL_MS = 500
 
-/** Threshold below which we hold the wait in-process; above, we suspend via PauseMetadata. */
-const inprocessMaxMs = (): number => envNumber(env.WAIT_INPROCESS_MAX_MS, 5 * 60 * 1000)
+/** Hard ceiling for in-process (non-suspending) waits. */
+const MAX_INPROCESS_WAIT_MS = 5 * 60 * 1000
 
-/** Hard ceiling on configurable wait duration. */
-const MAX_WAIT_MS = 30 * 24 * 60 * 60 * 1000
+/** Hard ceiling for suspending waits. */
+const MAX_SUSPEND_WAIT_MS = 30 * 24 * 60 * 60 * 1000
 
 interface SleepOptions {
   signal?: AbortSignal
@@ -92,10 +91,10 @@ function isWaitUnit(value: string): value is WaitUnit {
 /**
  * Handler for Wait blocks that pause workflow execution for a time delay.
  *
- * Waits up to `WAIT_INPROCESS_MAX_MS` (default 5 minutes) are held in-process via an interruptible sleep.
- * Longer waits suspend the workflow 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.
+ * 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
+ * `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.
  */
 export class WaitBlockHandler implements BlockHandler {
   canHandle(block: SerializedBlock): boolean {
@@ -125,8 +124,9 @@ export class WaitBlockHandler implements BlockHandler {
       executionOrder?: number
     }
   ): Promise<BlockOutput> {
+    const suspend = inputs.suspend === true || inputs.suspend === 'true'
     const timeValue = Number.parseFloat(inputs.timeValue || '10')
-    const timeUnit = inputs.timeUnit || 'seconds'
+    const timeUnit = (suspend ? inputs.timeUnitLong : inputs.timeUnit) || 'seconds'
 
     if (!Number.isFinite(timeValue) || timeValue <= 0) {
       throw new Error('Wait amount must be a positive number')
@@ -135,13 +135,24 @@ export class WaitBlockHandler implements BlockHandler {
     if (!isWaitUnit(timeUnit)) {
       throw new Error(`Unknown wait unit: ${timeUnit}`)
     }
+
+    if (suspend && timeUnit === 'seconds') {
+      throw new Error('Seconds are not allowed when Suspend Workflow is enabled')
+    }
+
     const waitMs = Math.round(timeValue * UNIT_TO_MS[timeUnit])
 
-    if (waitMs > MAX_WAIT_MS) {
-      throw new Error('Wait time exceeds maximum of 30 days')
+    if (suspend) {
+      if (waitMs > MAX_SUSPEND_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'
+      )
     }
 
-    if (waitMs <= inprocessMaxMs()) {
+    if (!suspend) {
       const completed = await sleep(waitMs, {
         signal: ctx.abortSignal,
         executionId: ctx.executionId,

apps/sim/lib/core/config/env.ts

@@ -231,9 +231,6 @@ export const env = createEnv({
     EXECUTION_TIMEOUT_ASYNC_TEAM:          z.string().optional().default('5400'),  // 90 minutes
     EXECUTION_TIMEOUT_ASYNC_ENTERPRISE:    z.string().optional().default('5400'),  // 90 minutes
 
-    // Wait block configuration
-    WAIT_INPROCESS_MAX_MS:                 z.string().optional().default('300000'), // Threshold below which a wait runs in-process; above it, the wait suspends and the cron poller resumes. Default 5 min. Lower this locally (e.g. '5000' = 5s) to test the suspend path with short waits.
-
     // Isolated-VM Worker Pool Configuration
     IVM_POOL_SIZE:                         z.string().optional().default('4'),      // Max worker processes in pool
     IVM_MAX_CONCURRENT:                    z.string().optional().default('10000'),  // Max concurrent executions globally