Filter out waits from hitl endpoints

Author: TheodoreSpeaks

apps/sim/app/api/resume/[workflowId]/[executionId]/[contextId]/route.ts

@@ -140,6 +140,7 @@ export const POST = withRouteHandler(
         contextId,
         resumeInput,
         userId,
+        allowedPauseKinds: ['human'],
       })
 
       if (enqueueResult.status === 'queued') {

apps/sim/app/api/resume/poll/route.ts

@@ -128,6 +128,9 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
         }
       }
 
+      // We never auto-retry a failed dispatch: workflow blocks aren't idempotent, and an
+      // operator must investigate stranded rows by hand. Setting nextResumeAt to the next
+      // future pause (or null) drops the row out of the poll, surfacing the failure.
       await db
         .update(pausedExecutions)
         .set({ nextResumeAt: nextRemaining })

apps/sim/app/resume/[workflowId]/[executionId]/resume-page-client.tsx

@@ -222,9 +222,7 @@ export default function ResumeExecutionPage({
   const [executionDetail, setExecutionDetail] = useState<PausedExecutionDetail | null>(
     initialExecutionDetail
   )
-  const pausePoints = (executionDetail?.pausePoints ?? []).filter(
-    (point) => point.pauseKind !== 'time'
-  )
+  const pausePoints = executionDetail?.pausePoints ?? []
 
   const defaultContextId = useMemo(() => {
     if (initialContextId) return initialContextId

apps/sim/lib/workflows/executor/human-in-the-loop-manager.ts

@@ -19,6 +19,7 @@ import type {
 } from '@/executor/execution/types'
 import type {
   ExecutionResult,
+  PauseKind,
   PausePoint,
   SerializedSnapshot,
   StreamingExecution,
@@ -87,6 +88,8 @@ interface EnqueueResumeArgs {
   contextId: string
   resumeInput: unknown
   userId: string
+  /** Restrict which `pauseKind`s are eligible to resume. Defaults to allowing any. */
+  allowedPauseKinds?: PauseKind[]
 }
 
 type EnqueueResumeResult =
@@ -191,7 +194,7 @@ export class PauseResumeManager {
   }
 
   static async enqueueOrStartResume(args: EnqueueResumeArgs): Promise<EnqueueResumeResult> {
-    const { executionId, contextId, resumeInput, userId } = args
+    const { executionId, contextId, resumeInput, userId, allowedPauseKinds } = args
 
     return await db.transaction(async (tx) => {
       const pausedExecution = await tx
@@ -222,6 +225,11 @@ export class PauseResumeManager {
         throw new Error('Snapshot not ready; execution still finalizing pause')
       }
 
+      const pauseKind: PauseKind = pausePoint.pauseKind ?? 'human'
+      if (allowedPauseKinds && !allowedPauseKinds.includes(pauseKind)) {
+        throw new Error(`Pause point cannot be resumed manually (pauseKind=${pauseKind})`)
+      }
+
       const activeResume = await tx
         .select({ id: resumeQueue.id })
         .from(resumeQueue)
@@ -1334,12 +1342,13 @@ export class PauseResumeManager {
       .where(whereClause)
       .orderBy(desc(pausedExecutions.pausedAt))
 
-    return rows.map((row) =>
-      PauseResumeManager.normalizePausedExecution(
-        row,
-        PauseResumeManager.mapPausePoints(row.pausePoints)
+    return rows.flatMap((row) => {
+      const humanPoints = PauseResumeManager.mapPausePoints(row.pausePoints).filter(
+        (point) => point.pauseKind !== 'time'
       )
-    )
+      if (humanPoints.length === 0) return []
+      return [PauseResumeManager.normalizePausedExecution(row, humanPoints)]
+    })
   }
 
   static async getPausedExecutionById(
@@ -1391,7 +1400,11 @@ export class PauseResumeManager {
       row.pausePoints,
       queuePositions,
       latestEntries
-    )
+    ).filter((point) => point.pauseKind !== 'time')
+
+    if (pausePoints.length === 0) {
+      return null
+    }
 
     const executionSummary = PauseResumeManager.normalizePausedExecution(row, pausePoints)