fix(slack): acknowledge permanently ignored deliveries

Author: TheodoreSpeaks

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

@@ -147,6 +147,40 @@ describe('Slack custom-bot webhook route', () => {
     expect(res.status).toBe(200)
   })
 
+  it('returns 200 when every target permanently lacks its deployed trigger block', async () => {
+    mockDispatchResolvedWebhookTarget.mockResolvedValue({
+      outcome: 'ignored',
+      response: new Response('Trigger block not found in deployment', { status: 404 }),
+      reason: 'block-missing',
+    })
+
+    const res = await POST(makeRequest(), context)
+
+    expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(1)
+    expect(res.status).toBe(200)
+  })
+
+  it('returns a retryable failure when another target fails beside a missing block', async () => {
+    mockFindWebhooksByRoutingKey.mockResolvedValue([webhook('wh1'), webhook('wh2')])
+    mockDispatchResolvedWebhookTarget
+      .mockResolvedValueOnce({
+        outcome: 'ignored',
+        response: new Response('Trigger block not found in deployment', { status: 404 }),
+        reason: 'block-missing',
+      })
+      .mockResolvedValueOnce({
+        outcome: 'failed',
+        response: new Response('Queue failed', { status: 500 }),
+        reason: 'queue-failed',
+      })
+
+    const res = await POST(makeRequest(), context)
+
+    expect(mockDispatchResolvedWebhookTarget).toHaveBeenCalledTimes(2)
+    expect(res.status).toBe(500)
+    await expect(res.text()).resolves.toBe('Queue failed')
+  })
+
   it('returns the dispatch failure when no target is acknowledged', async () => {
     mockDispatchResolvedWebhookTarget.mockResolvedValue({
       outcome: 'failed',

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

@@ -78,9 +78,7 @@ async function handleSlackCustomBotWebhook(
     (result) => result.outcome !== 'failed' && result.reason !== 'block-missing'
   )
   if (!acknowledged) {
-    const failure = dispatchResults.find(
-      (result) => result.outcome === 'failed' || result.reason === 'block-missing'
-    )
+    const failure = dispatchResults.find((result) => result.outcome === 'failed')
     if (failure) return failure.response
   }
 

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

@@ -1178,6 +1178,36 @@ describe('Webhook Trigger API Route', () => {
       await expect(response.json()).resolves.toEqual({ message: 'Webhook event ignored' })
       expect(dispatchResolvedWebhookTargetMock).not.toHaveBeenCalled()
     })
+
+    it('acknowledges a legacy fan-out when every target permanently lacks its trigger block', async () => {
+      testData.webhooks.push({
+        id: 'legacy-slack-webhook',
+        provider: 'slack',
+        path: 'legacy-slack-path',
+        routingKey: 'credential-1',
+        isActive: true,
+        providerConfig: {
+          triggerId: 'slack_webhook',
+          credentialId: 'credential-1',
+          ingressMode: 'legacy_custom_bot',
+        },
+        workflowId: 'test-workflow-id',
+      })
+      dispatchSlackCustomBotCredentialMock.mockResolvedValueOnce([
+        {
+          outcome: 'ignored',
+          reason: 'block-missing',
+          response: new NextResponse('Trigger block not found in deployment', { status: 404 }),
+        },
+      ])
+
+      const response = await POST(createMockRequest('POST', { type: 'event_callback' }), {
+        params: Promise.resolve({ path: 'legacy-slack-path' }),
+      })
+
+      expect(response.status).toBe(200)
+      expect(dispatchResolvedWebhookTargetMock).not.toHaveBeenCalled()
+    })
   })
 
   describe('Reservation-free filtering', () => {

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

@@ -260,11 +260,16 @@ async function handleWebhookDelivery(
    */
   const responses: NextResponse[] = []
   const failures: NextResponse[] = []
+  let hasPermanentlyIgnoredLegacyTarget = false
   for (const dispatchResult of legacySlackDispatchResults) {
-    if (dispatchResult.outcome === 'failed' || dispatchResult.reason === 'block-missing') {
+    if (dispatchResult.outcome === 'failed') {
       failures.push(dispatchResult.response)
       continue
     }
+    if (dispatchResult.reason === 'block-missing') {
+      hasPermanentlyIgnoredLegacyTarget = true
+      continue
+    }
     responses.push(dispatchResult.response)
   }
   const dispatchTargetCount = directWebhooksForPath.length + legacySlackDispatchResults.length
@@ -341,6 +346,9 @@ async function handleWebhookDelivery(
     if (failures.length > 0) {
       return failures[0]
     }
+    if (hasPermanentlyIgnoredLegacyTarget) {
+      return new NextResponse(null, { status: 200 })
+    }
     return new NextResponse('No webhooks processed successfully', { status: 500 })
   }
 

apps/sim/lib/copilot/tools/server/blocks/get-blocks-metadata-projection.test.ts

@@ -50,12 +50,12 @@ describe('get_blocks_metadata against the real registries', () => {
 
   it('resolves an integration block’s operations and their tool-derived inputs', async () => {
     const result = await getBlocksMetadataServerTool.execute(
-      { blockIds: ['slack'] },
+      { blockIds: ['slack_v2'] },
       { userId: 'user-1', workspaceId: 'workspace-1' }
     )
 
-    const slack = result.metadata.slack as AgentBlockMetadata
-    expect(slack.blockType).toBe('slack')
+    const slack = result.metadata.slack_v2 as AgentBlockMetadata
+    expect(slack.blockType).toBe('slack_v2')
     expect(slack.name).toBe('Slack')
 
     const operations = slack.operations ?? {}