fix(slack): retry failed webhook deliveries

Author: TheodoreSpeaks

apps/sim/app/api/webhooks/slack/custom/[credentialId]/route.ts

@@ -8,6 +8,7 @@ import {
   dispatchSlackCustomBotCredential,
   verifySlackCustomBotCredentialRequest,
 } from '@/lib/webhooks/slack-custom-ingress'
+import { getSlackDispatchResponse } from '@/lib/webhooks/slack-dispatch'
 
 export const dynamic = 'force-dynamic'
 export const runtime = 'nodejs'
@@ -74,13 +75,5 @@ async function handleSlackCustomBotWebhook(
     requestId,
     receivedAt,
   })
-  const acknowledged = dispatchResults.some(
-    (result) => result.outcome !== 'failed' && result.reason !== 'block-missing'
-  )
-  if (!acknowledged) {
-    const failure = dispatchResults.find((result) => result.outcome === 'failed')
-    if (failure) return failure.response
-  }
-
-  return new NextResponse(null, { status: 200 })
+  return getSlackDispatchResponse(dispatchResults)
 }

apps/sim/app/api/webhooks/slack/route.test.ts

@@ -43,7 +43,7 @@ function webhook(id: string) {
 
 async function run(body: Record<string, unknown>) {
   mockParseWebhookBody.mockResolvedValue({ body, rawBody: JSON.stringify(body) })
-  await POST(makeRequest())
+  return POST(makeRequest())
 }
 
 const messageBody = {
@@ -83,6 +83,18 @@ describe('Slack app webhook route', () => {
     expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(1)
   })
 
+  it('returns a retryable failure when no target queues', async () => {
+    mockDispatchResolvedWebhookTarget.mockResolvedValue({
+      outcome: 'failed',
+      response: new Response(null, { status: 500 }),
+      reason: 'queue-failed',
+    })
+
+    const response = await run(messageBody)
+
+    expect(response.status).toBe(500)
+  })
+
   it('routes via Slack Connect authorizations and dedups overlapping webhooks', async () => {
     // Two candidate teams (outer + authorization) that resolve to overlapping webhooks.
     mockFindWebhooksByRoutingKey.mockImplementation(async (teamId: string) =>

apps/sim/app/api/webhooks/slack/route.ts

@@ -6,7 +6,7 @@ import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { findWebhooksByRoutingKey, parseWebhookBody } from '@/lib/webhooks/processor'
 import { handleSlackChallenge, verifySlackRequestSignature } from '@/lib/webhooks/providers/slack'
-import { dispatchSlackWebhooks } from '@/lib/webhooks/slack-dispatch'
+import { dispatchSlackWebhooks, getSlackDispatchResponse } from '@/lib/webhooks/slack-dispatch'
 
 const logger = createLogger('SlackAppWebhookAPI')
 
@@ -106,7 +106,11 @@ async function handleSlackAppWebhook(request: NextRequest): Promise<NextResponse
     return new NextResponse(null, { status: 200 })
   }
 
-  await dispatchSlackWebhooks(webhooks, { body, request, requestId, receivedAt })
-
-  return new NextResponse(null, { status: 200 })
+  const dispatchResults = await dispatchSlackWebhooks(webhooks, {
+    body,
+    request,
+    requestId,
+    receivedAt,
+  })
+  return getSlackDispatchResponse(dispatchResults)
 }

apps/sim/app/api/webhooks/trigger/[path]/route.ts

@@ -27,6 +27,7 @@ import {
   getLegacySlackCustomBotCredentialId,
   verifySlackCustomBotCredentialRequest,
 } from '@/lib/webhooks/slack-custom-ingress'
+import { getSlackDispatchFailureResponse } from '@/lib/webhooks/slack-dispatch'
 
 const logger = createLogger('WebhookTriggerAPI')
 const MAX_LEGACY_SLACK_CREDENTIALS_PER_PATH = 25
@@ -263,7 +264,7 @@ async function handleWebhookDelivery(
   let hasPermanentlyIgnoredLegacyTarget = false
   for (const dispatchResult of legacySlackDispatchResults) {
     if (dispatchResult.outcome === 'failed') {
-      failures.push(dispatchResult.response)
+      failures.push(getSlackDispatchFailureResponse(dispatchResult))
       continue
     }
     if (dispatchResult.reason === 'block-missing') {

apps/sim/lib/webhooks/providers/slack.test.ts

@@ -17,6 +17,12 @@ const ctx = (body: unknown) => ({
 const eventOf = (input: unknown) =>
   (input as { event: Record<string, unknown> }).event as Record<string, unknown>
 
+describe('slackHandler responses', () => {
+  it('returns a retryable failure when queue admission fails', () => {
+    expect(slackHandler.formatQueueErrorResponse!().status).toBe(500)
+  })
+})
+
 describe('slackHandler formatInput - Events API', () => {
   it('maps an app_mention event', async () => {
     const { input } = await slackHandler.formatInput!(

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

@@ -860,7 +860,7 @@ export const slackHandler: WebhookProviderHandler = {
   },
 
   formatQueueErrorResponse() {
-    return new NextResponse(null, { status: 200 })
+    return new NextResponse(null, { status: 500 })
   },
 
   /**

apps/sim/lib/webhooks/slack-dispatch.test.ts

@@ -17,7 +17,11 @@ vi.mock('@/lib/webhooks/providers/slack', () => ({
 }))
 
 import { dispatchResolvedWebhookTarget } from '@/lib/webhooks/processor'
-import { dispatchSlackWebhooks } from '@/lib/webhooks/slack-dispatch'
+import {
+  dispatchSlackWebhooks,
+  getSlackDispatchFailureResponse,
+  getSlackDispatchResponse,
+} from '@/lib/webhooks/slack-dispatch'
 
 describe('dispatchSlackWebhooks', () => {
   it('dispatches at most ten targets concurrently and preserves result order', async () => {
@@ -68,4 +72,43 @@ describe('dispatchSlackWebhooks', () => {
       Array.from({ length: 12 }, (_, index) => 200 + index)
     )
   })
+
+  it('returns the failure when no Slack target is acknowledged', () => {
+    const response = getSlackDispatchResponse([
+      {
+        outcome: 'failed',
+        response: new NextResponse(null, { status: 500 }),
+        reason: 'queue-failed',
+      },
+    ])
+
+    expect(response.status).toBe(500)
+  })
+
+  it('acknowledges a mixed fan-out when at least one Slack target queues', () => {
+    const response = getSlackDispatchResponse([
+      {
+        outcome: 'failed',
+        response: new NextResponse(null, { status: 500 }),
+        reason: 'queue-failed',
+      },
+      {
+        outcome: 'queued',
+        response: new NextResponse(null, { status: 200 }),
+        reason: 'queued',
+      },
+    ])
+
+    expect(response.status).toBe(200)
+  })
+
+  it('fails fast when a failed Slack dispatch carries a successful response', () => {
+    expect(() =>
+      getSlackDispatchFailureResponse({
+        outcome: 'failed',
+        response: new NextResponse(null, { status: 200 }),
+        reason: 'queue-failed',
+      })
+    ).toThrow('Failed Slack dispatch returned successful HTTP status 200')
+  })
 })

apps/sim/lib/webhooks/slack-dispatch.ts

@@ -1,5 +1,5 @@
 import { createLogger } from '@sim/logger'
-import type { NextRequest } from 'next/server'
+import { type NextRequest, NextResponse } from 'next/server'
 import { mapWithConcurrency } from '@/lib/core/utils/concurrency'
 import {
   dispatchResolvedWebhookTarget,
@@ -18,6 +18,36 @@ interface DispatchSlackWebhooksOptions {
   receivedAt: number
 }
 
+/** Returns the non-success response that tells Slack to retry a failed delivery. */
+export function getSlackDispatchFailureResponse(result: WebhookDispatchResult): NextResponse {
+  if (result.outcome !== 'failed') {
+    throw new Error(`Expected failed Slack dispatch, received ${result.outcome}`)
+  }
+  if (result.response.ok) {
+    throw new Error(
+      `Failed Slack dispatch returned successful HTTP status ${result.response.status}`
+    )
+  }
+  return result.response
+}
+
+/** Reduces a Slack fan-out to one provider acknowledgment or retry response. */
+export function getSlackDispatchResponse(results: WebhookDispatchResult[]): NextResponse {
+  const acknowledged = results.some(
+    (result) => result.outcome !== 'failed' && result.reason !== 'block-missing'
+  )
+  if (acknowledged) {
+    return new NextResponse(null, { status: 200 })
+  }
+
+  const failure = results.find((result) => result.outcome === 'failed')
+  if (failure) {
+    return getSlackDispatchFailureResponse(failure)
+  }
+
+  return new NextResponse(null, { status: 200 })
+}
+
 /**
  * Shared fan-out tail for the Slack ingest routes (native team-id route and the
  * custom-bot credential route): run each candidate webhook through the common