chore: import upstream snapshot with attribution

apps/sim/tools/brightdata/discover.ts

@@ -0,0 +1,250 @@
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { sleep } from '@sim/utils/helpers'
+import { DEFAULT_EXECUTION_TIMEOUT_MS } from '@/lib/core/execution-limits'
+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 = DEFAULT_EXECUTION_TIMEOUT_MS
+
+export const brightDataDiscoverTool: ToolConfig<
+  BrightDataDiscoverParams,
+  BrightDataDiscoverResponse
+> = {
+  id: 'brightdata_discover',
+  name: 'Bright Data Discover',
+  description:
+    'AI-powered web discovery that finds and ranks results by intent. Returns up to 20 results with optional cleaned page content for RAG and verification.',
+  version: '1.0.0',
+
+  params: {
+    apiKey: {
+      type: 'string',
+      required: true,
+      visibility: 'user-only',
+      description: 'Bright Data API token',
+    },
+    query: {
+      type: 'string',
+      required: true,
+      visibility: 'user-or-llm',
+      description: 'The search query (e.g., "competitor pricing changes enterprise plan")',
+    },
+    numResults: {
+      type: 'number',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Number of results to return (1-20). Defaults to 10',
+    },
+    mode: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description:
+        'Search depth and ranking mode: "standard" (balanced), "deep" (exhaustive, broader search), "fast" (optimized for speed), or "zeroRanking" (raw volume without AI filtering). Defaults to "standard"',
+    },
+    intent: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description:
+        'Describes what the agent is trying to accomplish, used to rank results by relevance (e.g., "find official pricing pages and change notes")',
+    },
+    includeContent: {
+      type: 'boolean',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Whether to include cleaned page content in results',
+    },
+    format: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Response format: "json" or "md". Defaults to "json"',
+    },
+    language: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Search language code (e.g., "en", "es", "fr"). Defaults to "en"',
+    },
+    country: {
+      type: 'string',
+      required: false,
+      visibility: 'user-or-llm',
+      description: 'Two-letter ISO country code for localized results (e.g., "us", "gb")',
+    },
+  },
+
+  request: {
+    method: 'POST',
+    url: 'https://api.brightdata.com/discover',
+    headers: (params) => ({
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${params.apiKey}`,
+    }),
+    body: (params) => {
+      const body: Record<string, unknown> = {
+        query: params.query,
+      }
+      if (params.numResults) body.num_results = params.numResults
+      if (params.mode) body.mode = params.mode
+      if (params.intent) body.intent = params.intent
+      if (params.includeContent != null) body.include_content = params.includeContent
+      if (params.format) body.format = params.format
+      if (params.language) body.language = params.language
+      if (params.country) body.country = params.country
+      return body
+    },
+  },
+
+  transformResponse: async (response: Response, params) => {
+    if (!response.ok) {
+      const errorText = await response.text()
+      throw new Error(errorText || `Discover request failed with status ${response.status}`)
+    }
+
+    const data = await response.json()
+
+    return {
+      success: true,
+      output: {
+        results: [],
+        query: params?.query ?? null,
+        totalResults: 0,
+        taskId: data.task_id ?? null,
+      },
+    }
+  },
+
+  postProcess: async (result, params) => {
+    if (!result.success) return result
+
+    const taskId = result.output.taskId
+    if (!taskId) {
+      return {
+        ...result,
+        success: false,
+        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) {
+      try {
+        const pollResponse = await fetch(
+          `https://api.brightdata.com/discover?task_id=${encodeURIComponent(taskId)}`,
+          {
+            method: 'GET',
+            headers: {
+              Authorization: `Bearer ${params.apiKey}`,
+            },
+          }
+        )
+
+        if (!pollResponse.ok) {
+          return {
+            ...result,
+            success: false,
+            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,
+            },
+          }
+        }
+
+        if (data.status === 'failed' || data.status === 'error') {
+          return {
+            ...result,
+            success: false,
+            error: `Discover task failed: ${data.error ?? 'Unknown error'}`,
+          }
+        }
+
+        await sleep(POLL_INTERVAL_MS)
+        elapsedTime += POLL_INTERVAL_MS
+      } catch (error) {
+        logger.error('Error polling for discover task:', {
+          message: toError(error).message,
+          taskId,
+        })
+
+        return {
+          ...result,
+          success: false,
+          error: `Error polling for discover task: ${toError(error).message}`,
+        }
+      }
+    }
+
+    logger.warn(
+      `Discover task ${taskId} did not complete within the maximum polling time (${MAX_POLL_TIME_MS / 1000}s)`
+    )
+
+    return {
+      ...result,
+      success: false,
+      error: `Discover task ${taskId} timed out after ${MAX_POLL_TIME_MS / 1000}s. Check status manually.`,
+    }
+  },
+
+  outputs: {
+    results: {
+      type: 'array',
+      description: 'Array of discovered web results ranked by intent relevance',
+      items: {
+        type: 'object',
+        description: 'A discovered result',
+        properties: {
+          url: { type: 'string', description: 'URL of the discovered page', optional: true },
+          title: { type: 'string', description: 'Page title', optional: true },
+          description: {
+            type: 'string',
+            description: 'Page description or snippet',
+            optional: true,
+          },
+          relevanceScore: {
+            type: 'number',
+            description: 'AI-calculated relevance score for intent-based ranking',
+            optional: true,
+          },
+          content: {
+            type: 'string',
+            description:
+              'Cleaned page content in the requested format (when includeContent is true)',
+            optional: true,
+          },
+        },
+      },
+    },
+    query: { type: 'string', description: 'The search query that was executed', optional: true },
+    totalResults: { type: 'number', description: 'Total number of results returned' },
+  },
+}