feat(webhooks): prepareSyncDispatch provider hook on the ingest path

Optional provider hook invoked after event filters, the deployment-block
check, and admission — immediately before the execution payload is
assembled — for work that must happen synchronously at ingest (e.g.
opening a Slack loading modal inside the 3-second trigger_id window). The
result rides the payload as syncInteraction (identifiers only, never token
material) and surfaces to formatInput. A hook failure or throw never
blocks dispatch. All three Slack ingest doors converge on this call site;
no route changes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: icecrasher321

apps/sim/lib/webhooks/processor.test.ts

@@ -568,6 +568,80 @@ describe('webhook processor execution identity', () => {
   })
 })
 
+describe('webhook processor prepareSyncDispatch', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockPreprocessExecution.mockResolvedValue({
+      success: true,
+      actorUserId: 'actor-user-1',
+      billingAttribution,
+      executionTimeout: { sync: 0, async: 120_000 },
+    })
+    mockEnqueue.mockResolvedValue('job-1')
+    mockGetInlineJobQueue.mockResolvedValue({ enqueue: mockEnqueue })
+    mockGetJobQueue.mockResolvedValue({ enqueue: mockEnqueue })
+    mockProviderHandler.current = {}
+    mockShouldExecuteInline.mockReturnValue(false)
+    mockGenerateId.mockReturnValue('generated-execution-id')
+    workflowsPersistenceUtilsMockFns.mockBlockExistsInDeployment.mockResolvedValue(true)
+  })
+
+  const dispatch = () =>
+    dispatchResolvedWebhookTarget(
+      makeWebhookRecord({
+        path: 'incoming/slack',
+        provider: 'slack',
+        providerConfig: { openLoadingModal: true },
+      }),
+      makeWorkflowRecord({}),
+      { type: 'block_actions', trigger_id: 'trigger-1' },
+      createMockRequest('POST', { type: 'block_actions' }) as NextRequest,
+      { requestId: 'request-1', path: 'incoming/slack' }
+    )
+
+  it('puts the hook result on the enqueued payload', async () => {
+    const prepareSyncDispatch = vi
+      .fn()
+      .mockResolvedValue({ syncInteraction: { loadingViewId: 'V1' } })
+    mockProviderHandler.current = { prepareSyncDispatch }
+
+    const result = await dispatch()
+
+    expect(result.outcome).toBe('queued')
+    expect(prepareSyncDispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        body: { type: 'block_actions', trigger_id: 'trigger-1' },
+        workflow: expect.objectContaining({ id: 'workflow-1' }),
+        providerConfig: { openLoadingModal: true },
+        requestId: 'request-1',
+      })
+    )
+    expect(mockEnqueue.mock.calls[0]?.[1]).toMatchObject({
+      syncInteraction: { loadingViewId: 'V1' },
+    })
+  })
+
+  it('omits syncInteraction when the hook resolves null', async () => {
+    mockProviderHandler.current = { prepareSyncDispatch: vi.fn().mockResolvedValue(null) }
+
+    const result = await dispatch()
+
+    expect(result.outcome).toBe('queued')
+    expect(mockEnqueue.mock.calls[0]?.[1]).not.toHaveProperty('syncInteraction')
+  })
+
+  it('still queues when the hook throws', async () => {
+    mockProviderHandler.current = {
+      prepareSyncDispatch: vi.fn().mockRejectedValue(new Error('slack down')),
+    }
+
+    const result = await dispatch()
+
+    expect(result.outcome).toBe('queued')
+    expect(mockEnqueue.mock.calls[0]?.[1]).not.toHaveProperty('syncInteraction')
+  })
+})
+
 describe('polled webhook reservation ownership', () => {
   const foundWebhook = {
     id: 'webhook-1',

apps/sim/lib/webhooks/processor.ts

@@ -32,7 +32,7 @@ import {
   requiresPendingWebhookVerification,
 } from '@/lib/webhooks/pending-verification'
 import { getProviderHandler } from '@/lib/webhooks/providers'
-import type { WebhookProviderHandler } from '@/lib/webhooks/providers/types'
+import type { SyncInteractionContext, WebhookProviderHandler } from '@/lib/webhooks/providers/types'
 import { normalizeWebhookRegistrationPath } from '@/lib/webhooks/registration-identity'
 import { blockExistsInDeployment } from '@/lib/workflows/persistence/utils'
 import { SIM_TRIGGER_PROVIDER } from '@/lib/workspace-events/constants'
@@ -723,6 +723,35 @@ async function queueWebhookExecutionWithResult(
         provider: foundWebhook.provider,
         triggerType: 'webhook',
       } satisfies AsyncExecutionCorrelation)
+
+    /**
+     * Runs after event filters, the deployment-block check, and admission — so a
+     * filtered or rejected delivery never produces a side effect — and before the
+     * payload is assembled so the result rides into execution. A hook failure
+     * never blocks dispatch.
+     */
+    let syncInteraction: SyncInteractionContext | undefined
+    if (handler.prepareSyncDispatch) {
+      try {
+        const prepared = await handler.prepareSyncDispatch({
+          webhook: foundWebhook,
+          workflow: {
+            id: foundWorkflow.id,
+            userId: foundWorkflow.userId,
+            workspaceId: foundWorkflow.workspaceId,
+          },
+          body,
+          requestId: options.requestId,
+          providerConfig,
+        })
+        syncInteraction = prepared?.syncInteraction
+      } catch (error) {
+        logger.warn(`[${options.requestId}] prepareSyncDispatch failed; continuing dispatch`, {
+          provider: foundWebhook.provider,
+          error: toError(error).message,
+        })
+      }
+    }
     const payload = {
       webhookId: foundWebhook.id,
       workflowId: foundWorkflow.id,
@@ -750,6 +779,7 @@ async function queueWebhookExecutionWithResult(
       ...(options.executionTimeoutMs !== undefined
         ? { executionTimeoutMs: options.executionTimeoutMs }
         : {}),
+      ...(syncInteraction ? { syncInteraction } : {}),
     } satisfies WebhookExecutionPayload
 
     const shouldUseQueue = shouldUseDurableQueue(payload.provider, handler)

apps/sim/lib/webhooks/providers/types.ts

@@ -44,6 +44,8 @@ export interface FormatInputContext {
    * credential → account → owner chain; absent on paths that never resolved it.
    */
   credentialOwnerUserId?: string
+  /** Interaction context created synchronously at ingest (see {@link SyncInteractionContext}). */
+  syncInteraction?: SyncInteractionContext
 }
 
 /** Result of custom input preparation. */
@@ -52,6 +54,31 @@ export interface FormatInputResult {
   skip?: { message: string }
 }
 
+/**
+ * Interaction context created synchronously at ingest before enqueue, e.g. a
+ * Slack loading modal opened while the interaction's trigger_id was still
+ * fresh. Persisted with the job payload, so it carries identifiers only —
+ * never token material.
+ */
+export interface SyncInteractionContext {
+  /** Slack view id of the loading modal opened via views.open on the ingest path. */
+  loadingViewId: string
+}
+
+/** Context for synchronous pre-enqueue dispatch preparation. */
+export interface PrepareSyncDispatchContext {
+  webhook: Record<string, unknown>
+  workflow: { id: string; userId: string; workspaceId?: string | null }
+  body: unknown
+  requestId: string
+  providerConfig: Record<string, unknown>
+}
+
+/** Result of synchronous pre-enqueue dispatch preparation. */
+export interface PrepareSyncDispatchResult {
+  syncInteraction?: SyncInteractionContext
+}
+
 /** Context for provider-specific file processing before execution. */
 export interface ProcessFilesContext {
   input: Record<string, unknown>
@@ -171,6 +198,15 @@ export interface WebhookProviderHandler {
   /** Custom error response when queuing fails. Return null for default 500. */
   formatQueueErrorResponse?(): NextResponse | null
 
+  /**
+   * Provider work that must run synchronously on the ingest path after admission
+   * and immediately before the execution is enqueued — e.g. opening a Slack
+   * loading modal while the interaction's 3-second trigger_id is still fresh.
+   * Implementations must swallow provider-side failures and return null; the
+   * processor additionally guards the call so a throw can never fail dispatch.
+   */
+  prepareSyncDispatch?(ctx: PrepareSyncDispatchContext): Promise<PrepareSyncDispatchResult | null>
+
   /** Custom input preparation. When defined, replaces the default pass-through of the raw body. */
   formatInput?(ctx: FormatInputContext): Promise<FormatInputResult>