fix(brightdata): handle async Discover API with polling

The Bright Data Discover API is asynchronous — POST /discover returns
a task_id, and results must be polled via GET /discover?task_id=...
The previous implementation incorrectly treated it as synchronous,
always returning empty results.

Uses postProcess (matching Firecrawl crawl pattern) to poll every 3s
with a 120s timeout until status is "done".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/tools/brightdata/discover.ts

@@ -1,6 +1,12 @@
+import { createLogger } from '@sim/logger'
 import type { BrightDataDiscoverParams, BrightDataDiscoverResponse } from '@/tools/brightdata/types'
 import type { ToolConfig } from '@/tools/types'
 
+const logger = createLogger('tools:brightdata:discover')
+
+const POLL_INTERVAL_MS = 3000
+const MAX_POLL_TIME_MS = 120000
+
 export const brightDataDiscoverTool: ToolConfig<
   BrightDataDiscoverParams,
   BrightDataDiscoverResponse
@@ -92,35 +98,79 @@ export const brightDataDiscoverTool: ToolConfig<
 
     const data = await response.json()
 
-    let results: Array<{
-      url: string | null
-      title: string | null
-      description: string | null
-      relevanceScore: number | null
-      content: string | null
-    }> = []
-
-    const items = Array.isArray(data) ? data : (data?.results ?? data?.data ?? [])
-
-    if (Array.isArray(items)) {
-      results = items.map((item: Record<string, unknown>) => ({
-        url: (item.link as string) ?? (item.url as string) ?? null,
-        title: (item.title as string) ?? null,
-        description: (item.description as string) ?? (item.snippet as string) ?? null,
-        relevanceScore: (item.relevance_score as number) ?? null,
-        content:
-          (item.content as string) ?? (item.text as string) ?? (item.markdown as string) ?? null,
-      }))
-    }
-
     return {
       success: true,
       output: {
-        results,
+        results: [],
         query: params?.query ?? null,
-        totalResults: results.length,
+        totalResults: 0,
+        taskId: data.task_id ?? null,
       },
+    } as BrightDataDiscoverResponse
+  },
+
+  postProcess: async (result, params) => {
+    if (!result.success) return result
+
+    const taskId = (result.output as Record<string, unknown>).taskId as string | null
+    if (!taskId) {
+      throw new Error('Discover API did not return a task_id. Cannot poll for results.')
+    }
+
+    logger.info(`Bright Data Discover task ${taskId} created, polling for results...`)
+
+    let elapsedTime = 0
+
+    while (elapsedTime < MAX_POLL_TIME_MS) {
+      const pollResponse = await fetch(
+        `https://api.brightdata.com/discover?task_id=${encodeURIComponent(taskId)}`,
+        {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${params.apiKey}`,
+          },
+        }
+      )
+
+      if (!pollResponse.ok) {
+        throw new Error(`Failed to poll discover results: ${pollResponse.statusText}`)
+      }
+
+      const data = await pollResponse.json()
+      logger.info(`Bright Data Discover task ${taskId} status: ${data.status}`)
+
+      if (data.status === 'done') {
+        const items = Array.isArray(data.results) ? data.results : []
+
+        const results = items.map((item: Record<string, unknown>) => ({
+          url: (item.link as string) ?? (item.url as string) ?? null,
+          title: (item.title as string) ?? null,
+          description: (item.description as string) ?? (item.snippet as string) ?? null,
+          relevanceScore: (item.relevance_score as number) ?? null,
+          content: (item.content as string) ?? null,
+        }))
+
+        return {
+          success: true,
+          output: {
+            results,
+            query: params.query ?? null,
+            totalResults: results.length,
+          },
+        } as BrightDataDiscoverResponse
+      }
+
+      if (data.status === 'failed' || data.status === 'error') {
+        throw new Error(`Discover task failed: ${data.error ?? 'Unknown error'}`)
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
+      elapsedTime += POLL_INTERVAL_MS
     }
+
+    throw new Error(
+      `Discover task ${taskId} timed out after ${MAX_POLL_TIME_MS / 1000}s. Check status manually.`
+    )
   },
 
   outputs: {