fix(custom-blocks): surface a cancelled child as cancelled, not a generic failure

Author: TheodoreSpeaks

apps/sim/executor/errors/boundary.ts

@@ -14,6 +14,8 @@ export type CustomBlockErrorType =
    * the exhausted limit is their org's, not a foreign publisher's.
    */
   | 'usage_limit'
+  /** The child run was cancelled (the invoking run aborted or was cancelled). */
+  | 'cancelled'
   | 'execution_failed'
 
 /** What a failed custom block tells its consumer. Leaks nothing about the source run. */

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

@@ -1160,17 +1160,35 @@ describe('WorkflowBlockHandler', () => {
     })
 
     it('records a cancelled child through the cancellation path', async () => {
-      // Cancellation is reported on `ExecutionResult.status`, not on metadata.
+      // Production shape: the engine reports cancellation as `success: false`
+      // plus `status: 'cancelled'` on the ExecutionResult (never on metadata).
       mockExecutorExecute.mockResolvedValue({
-        success: true,
+        success: false,
         output: {},
         status: 'cancelled',
       })
 
-      await handler.execute(customBlockContext(), customBlock(), {})
+      await handler.execute(customBlockContext(), customBlock(), {}).catch(() => {})
 
       expect(mockSafeCompleteWithCancellation).toHaveBeenCalledTimes(1)
       expect(mockSafeComplete).not.toHaveBeenCalled()
+      // Already finalized as cancelled — must not be re-completed as an error.
+      expect(mockSafeCompleteWithError).not.toHaveBeenCalled()
+    })
+
+    it('tells the consumer a cancellation was a cancellation, not a generic failure', async () => {
+      mockExecutorExecute.mockResolvedValue({
+        success: false,
+        output: {},
+        status: 'cancelled',
+      })
+
+      const error = await handler
+        .execute(customBlockContext(), customBlock(), {})
+        .catch((e: any) => e)
+
+      expect(error.consumerFacing.errorType).toBe('cancelled')
+      expect(error.message).toBe('Custom block execution was cancelled')
     })
 
     it('records the real failure on the child log and hides it from the consumer', async () => {

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

@@ -253,6 +253,8 @@ export class WorkflowBlockHandler implements BlockHandler {
     let childExecutionId: string | undefined
     let childSession: LoggingSession | undefined
     let childSessionStarted = false
+    /** Set once the child's session reached a terminal state, so the catch doesn't re-complete it. */
+    let childSessionFinalized = false
     let childCancellation: { signal: AbortSignal; dispose: () => void } | undefined
     try {
       // A custom block runs the source's latest deployment; if the source has been
@@ -599,13 +601,25 @@ export class WorkflowBlockHandler implements BlockHandler {
 
       if (childSession && childSessionStarted) {
         await this.finalizeChildSession(childSession, executionResult, duration, childWorkflowInput)
+        childSessionFinalized = true
       }
 
       logger.info(`Child workflow ${childWorkflowName} completed in ${Math.round(duration)}ms`, {
         success: executionResult.success,
         hasLogs: (executionResult.logs?.length ?? 0) > 0,
       })
 
+      // A cancelled run comes back as `success: false`, so without this it would
+      // fall through to `mapChildOutputToParent` and reach the consumer as a
+      // generic `execution_failed`. Classify it instead — the message names
+      // nothing about the source, so it crosses the boundary verbatim.
+      if (isCustomBlock && executionResult.status === 'cancelled') {
+        throw new BoundarySafeError({
+          errorType: 'cancelled',
+          message: 'Custom block execution was cancelled',
+        })
+      }
+
       // A custom block's spans never reach the parent — they belong to the child's
       // own log row in the source workspace — so don't build them here at all.
       const childTraceSpans = isCustomBlock
@@ -636,7 +650,7 @@ export class WorkflowBlockHandler implements BlockHandler {
 
       // The child's own log row records the real failure in the source workspace,
       // so the publisher sees what the consumer deliberately cannot.
-      if (childSession && childSessionStarted) {
+      if (childSession && childSessionStarted && !childSessionFinalized) {
         await this.failChildSession(childSession, error)
       }