fix(enrow,firecrawl): drop the fictional retry hint, guard NaN, surface search params

Enrow documents that error responses never carry retry_after, so
parseRetryAfter was dead machinery -- and the test that 'proved' it worked
asserted only a call count while honoring a header Enrow never sends. The
429 arm stays as bounded hygiene: Enrow bills on the result, so a hard throw
would fail a job the workspace already paid for.

Firecrawl's numeric params reached the body as NaN when an LLM emitted a
word, serializing to null against an integer schema. sources/categories/
location/country now have subBlocks; tbs stays agent-only because a
malformed value is silently ignored rather than rejected.

Author: waleedlatif1

apps/sim/blocks/blocks/firecrawl.ts

@@ -7,6 +7,24 @@ import type { FirecrawlResponse } from '@/tools/firecrawl/types'
 /** The document being parsed, whether it was uploaded or passed in by reference. */
 const DOCUMENT_FIELD = ['fileUpload', 'fileReference'] as const
 
+/**
+ * Normalize a `multiSelect` dropdown value into the string array the tool wants.
+ *
+ * The control persists either an array of option ids or a comma-joined string
+ * depending on how the value was written, and an untouched field is `null`.
+ * Returns `undefined` when nothing is selected so the caller can omit the key
+ * and let Firecrawl apply its own default.
+ */
+function toSelectedIds(value: unknown): string[] | undefined {
+  const entries = Array.isArray(value) ? value : [value]
+  const ids = entries
+    .filter((entry): entry is string => typeof entry === 'string')
+    .flatMap((entry) => entry.split(','))
+    .map((id) => id.trim())
+    .filter((id) => id.length > 0)
+  return ids.length > 0 ? ids : undefined
+}
+
 export const FirecrawlBlock: BlockConfig<FirecrawlResponse> = {
   type: 'firecrawl',
   name: 'Firecrawl',
@@ -429,6 +447,68 @@ Example 2 - Product Data:
       },
       required: true,
     },
+    {
+      id: 'sources',
+      title: 'Sources',
+      type: 'dropdown',
+      multiSelect: true,
+      options: [
+        { label: 'Web', id: 'web' },
+        { label: 'News', id: 'news' },
+        { label: 'Images', id: 'images' },
+      ],
+      placeholder: 'Web',
+      description:
+        'Which result sets to search. Each one is returned as its own array — web, news, images.',
+      condition: {
+        field: 'operation',
+        value: 'search',
+      },
+    },
+    {
+      id: 'categories',
+      title: 'Categories',
+      type: 'dropdown',
+      multiSelect: true,
+      options: [
+        { label: 'GitHub', id: 'github' },
+        { label: 'Research', id: 'research' },
+        { label: 'PDF', id: 'pdf' },
+        { label: 'Developer', id: 'developer' },
+      ],
+      placeholder: 'All categories',
+      description:
+        'Restrict web results to these categories. Developer cannot be combined with the others.',
+      mode: 'advanced',
+      condition: {
+        field: 'operation',
+        value: 'search',
+      },
+    },
+    {
+      id: 'location',
+      title: 'Location',
+      type: 'short-input',
+      placeholder: 'Germany',
+      description: 'Where to search from. Set Country alongside it for best results.',
+      mode: 'advanced',
+      condition: {
+        field: 'operation',
+        value: 'search',
+      },
+    },
+    {
+      id: 'country',
+      title: 'Country',
+      type: 'short-input',
+      placeholder: 'US',
+      description: 'ISO country code for geo-targeting, e.g. US, DE, JP.',
+      mode: 'advanced',
+      condition: {
+        field: 'operation',
+        value: 'search',
+      },
+    },
     {
       id: 'apiKey',
       title: 'API Key',
@@ -563,14 +643,21 @@ Example 2 - Product Data:
             if (mobile != null) result.mobile = mobile
             break
 
-          case 'search':
+          case 'search': {
             if (query) result.query = query
             if (timeout) result.firecrawlTimeout = Number.parseInt(timeout)
             if (limit) result.limit = Number.parseInt(limit)
             if (params.ignoreInvalidURLs != null) {
               result.ignoreInvalidURLs = params.ignoreInvalidURLs
             }
+            const sources = toSelectedIds(params.sources)
+            if (sources) result.sources = sources
+            const categories = toSelectedIds(params.categories)
+            if (categories) result.categories = categories
+            if (params.location) result.location = params.location
+            if (params.country) result.country = params.country
             break
+          }
 
           case 'crawl':
             if (url) result.url = url

apps/sim/tools/enrow/find_email.test.ts

@@ -11,7 +11,9 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
  */
 vi.mock('@sim/utils/helpers', () => ({ sleep: vi.fn().mockResolvedValue(undefined) }))
 
+import { sleep } from '@sim/utils/helpers'
 import { enrowFindEmailTool } from '@/tools/enrow/find_email'
+import { POLL_INTERVAL_MS } from '@/tools/enrow/poll'
 import type {
   EnrowFindEmailParams,
   EnrowFindEmailResponse,
@@ -158,10 +160,10 @@ describe('enrow_find_email', () => {
     expect(result.output.email).toBe('john.doe@stripe.com')
   })
 
-  it('retries a 429 and honors Retry-After', async () => {
+  it('still absorbs a 429, which Enrow documents as impossible on a GET poll', async () => {
     const fetchMock = vi
       .fn()
-      .mockResolvedValueOnce(jsonResponse(429, { message: 'slow down' }, { 'retry-after': '5' }))
+      .mockResolvedValueOnce(jsonResponse(429, { message: 'Too Many Requests' }))
       .mockResolvedValueOnce(jsonResponse(200, DOCUMENTED_FIND_BODY))
     vi.stubGlobal('fetch', fetchMock)
 
@@ -175,6 +177,34 @@ describe('enrow_find_email', () => {
     expect(result.output.qualification).toBe('valid')
   })
 
+  it('escalates the retry delay and ignores an undocumented Retry-After header', async () => {
+    const throttled = () =>
+      jsonResponse(503, { message: 'upstream unavailable' }, { 'retry-after': '5' })
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(throttled())
+      .mockResolvedValueOnce(throttled())
+      .mockResolvedValueOnce(throttled())
+      .mockResolvedValueOnce(jsonResponse(200, DOCUMENTED_FIND_BODY))
+    vi.stubGlobal('fetch', fetchMock)
+
+    await enrowFindEmailTool.postProcess!(submittedFindResult, findParams, executeTool)
+
+    const delays = vi.mocked(sleep).mock.calls.map(([ms]) => ms as number)
+
+    expect(delays).toHaveLength(4)
+    expect(delays[0]).toBe(POLL_INTERVAL_MS)
+
+    // 3000 * 2 ** (attempt - 1) with the shared +/-20% jitter. Enrow documents
+    // that error responses carry no retry hint, so a `Retry-After: 5` header
+    // must not flatten this curve to a flat 5,000 ms.
+    for (const [attempt, delay] of [delays[1], delays[2], delays[3]].entries()) {
+      const exponential = POLL_INTERVAL_MS * 2 ** attempt
+      expect(delay, `attempt ${attempt + 1} delay`).toBeGreaterThanOrEqual(exponential * 0.8)
+      expect(delay, `attempt ${attempt + 1} delay`).toBeLessThan(exponential * 1.2)
+    }
+  })
+
   it('gives up on a persistent 500 — an expired search id must surface, not loop', async () => {
     const fetchMock = vi.fn().mockResolvedValue(jsonResponse(500, { message: 'unknown search id' }))
     vi.stubGlobal('fetch', fetchMock)

apps/sim/tools/enrow/hosting.test.ts

@@ -2,14 +2,42 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { ENROW_CREDIT_USD } from '@/tools/enrow/hosting'
+import { ENROW_CREDIT_USD, enrowHosting } from '@/tools/enrow/hosting'
 
-describe('enrow hosted-key pricing', () => {
-  it('prices a credit at the entry Start tier ($17 / 1,000 credits)', () => {
+/**
+ * Per-tool credit accounting lives in `tools/enrow-hosting.test.ts`. This file
+ * covers the shared factory itself: the credits-to-dollars conversion and the
+ * request-rate ceiling, both checked against Enrow's published limits rather
+ * than against the constants the factory happens to hold.
+ */
+describe('enrowHosting', () => {
+  const hosting = enrowHosting<{ apiKey: string }>((_params, output) => Number(output.credits ?? 0))
+
+  it('prices a credit at the published Start tier ($17 / 1,000 credits)', () => {
     expect(ENROW_CREDIT_USD).toBeCloseTo(17 / 1000, 6)
   })
 
-  it('never bills below the entry tier rate', () => {
-    expect(ENROW_CREDIT_USD).toBeGreaterThanOrEqual(0.017)
+  it('converts the reported credits to dollars and reports the count as metadata', () => {
+    expect(hosting.pricing.getCost!({ apiKey: 'k' }, { credits: 0.25 })).toEqual({
+      cost: 0.25 * ENROW_CREDIT_USD,
+      metadata: { credits: 0.25 },
+    })
+    expect(hosting.pricing.getCost!({ apiKey: 'k' }, { credits: 4 })).toEqual({
+      cost: 4 * ENROW_CREDIT_USD,
+      metadata: { credits: 4 },
+    })
+  })
+
+  it('stays inside the documented 10 req/s POST ceiling', () => {
+    // https://docs.enrow.io/rate-limits — 10 requests per second per API key on
+    // every POST endpoint. Anything above 600/min would exceed it outright.
+    expect(hosting.rateLimit).toMatchObject({ mode: 'per_request' })
+    expect(hosting.rateLimit!.requestsPerMinute).toBeLessThanOrEqual(600)
+    expect(hosting.rateLimit!.requestsPerMinute).toBeGreaterThan(0)
+  })
+
+  it('reads the hosted key into the tool `apiKey` param', () => {
+    expect(hosting.apiKeyParam).toBe('apiKey')
+    expect(hosting.envKeyPrefix).toBe('ENROW_API_KEY')
   })
 })

apps/sim/tools/enrow/hosting.ts

@@ -9,13 +9,17 @@ export const ENROW_API_KEY_PREFIX = 'ENROW_API_KEY'
 /**
  * Dollar cost of a single Enrow credit.
  *
- * Based on the entry Start plan ($17/month, 1,000 credits = $0.017/credit),
- * which matches Enrow's own Start unit price of $0.017/email for the finder.
- * Per-credit drops at higher tiers (Pro $0.0087, Scale $0.00794), so pricing at
- * the entry tier guarantees hosted-key cost recovery rather than under-billing.
- * The email finder costs 1 credit per valid result and the email verifier
- * costs 0.25 credits per verification.
- * Source: https://enrow.io/pricing
+ * Sourced from the published plan rates on https://enrow.io/pricing: Start
+ * $17 / 1,000 credits ($0.017/credit), Pro $87 / 10,000 ($0.0087), Scale
+ * $397 / 50,000 ($0.00794). The email finder costs 1 credit per valid result
+ * and the email verifier costs 0.25 credits per verification.
+ *
+ * UNCONFIRMED — do not treat as established: whether $0.017 actually recovers
+ * hosted-key cost. The pricing page toggles between Annually (-40%), Monthly
+ * (-30%), and Pay-as-you-go, and we could not determine which mode the $17
+ * figure belongs to without account visibility. If $17 is a discounted rate,
+ * undiscounted pay-as-you-go is higher and this constant under-bills. Settling
+ * it needs a look at an actual Enrow invoice.
  */
 export const ENROW_CREDIT_USD = 0.017
 

apps/sim/tools/enrow/poll.ts

@@ -1,5 +1,5 @@
 import { sleep } from '@sim/utils/helpers'
-import { backoffWithJitter, parseRetryAfter } from '@sim/utils/retry'
+import { backoffWithJitter } from '@sim/utils/retry'
 
 /** Base gap between two in-progress (202) polls. */
 export const POLL_INTERVAL_MS = 3000
@@ -10,15 +10,29 @@ export const MAX_POLL_TIME_MS = 120_000
 /**
  * Consecutive transient failures tolerated before the loop gives up.
  *
- * Enrow documents 429 and 5xx as "safe to retry after a short delay", but it
- * also returns 500 for an unknown or expired search id on the single
- * endpoints. That makes 500 ambiguous, so the retry is deliberately bounded:
- * an expired id simply re-fails on each attempt and the loop exits with the
- * upstream status and body instead of masking it.
+ * Enrow documents 5xx as "safe to retry after a short delay", but it also
+ * returns 500 for an unknown or expired search id on the single endpoints.
+ * That makes 500 ambiguous, so the retry is deliberately bounded: an expired
+ * id simply re-fails on each attempt and the loop exits with the upstream
+ * status and body instead of masking it.
+ *
+ * Source: https://docs.enrow.io/status-codes
  */
 export const MAX_TRANSIENT_RETRIES = 3
 
-/** The statuses Enrow documents as retryable. */
+/**
+ * Statuses worth another bounded attempt.
+ *
+ * 5xx is the load-bearing arm: Enrow documents those as safe to retry.
+ *
+ * 429 cannot occur on this path today — Enrow documents GET endpoints as not
+ * rate limited, and this loop only issues GETs — so it is kept purely as a
+ * bounded fallback against an undocumented change. It is cheap (the retry
+ * count caps it at MAX_TRANSIENT_RETRIES) and strictly safer than the
+ * alternative, which is failing a job Enrow has already charged for.
+ *
+ * Source: https://docs.enrow.io/rate-limits
+ */
 function isRetryableStatus(status: number): boolean {
   return status === 429 || status >= 500
 }
@@ -58,11 +72,13 @@ export async function pollEnrowJob(
     if (!pollResponse.ok) {
       if (isRetryableStatus(pollResponse.status) && transientFailures < MAX_TRANSIENT_RETRIES) {
         transientFailures += 1
-        delayMs = backoffWithJitter(
-          transientFailures,
-          parseRetryAfter(pollResponse.headers.get('retry-after')),
-          { baseMs: POLL_INTERVAL_MS, maxMs: MAX_POLL_TIME_MS / 4 }
-        )
+        // No `Retry-After` is read: Enrow documents that its error responses
+        // carry no retry hint and tells callers to use their own exponential
+        // backoff. Source: https://docs.enrow.io/error-handling
+        delayMs = backoffWithJitter(transientFailures, null, {
+          baseMs: POLL_INTERVAL_MS,
+          maxMs: MAX_POLL_TIME_MS / 4,
+        })
         continue
       }
       const errorText = await pollResponse.text()

apps/sim/tools/firecrawl/map.test.ts

@@ -65,3 +65,27 @@ describe('firecrawl map timeout is not the transport deadline', () => {
     expect(body.timeout).toBe(45000)
   })
 })
+
+describe('firecrawl map numeric coercion', () => {
+  it('drops a non-numeric limit rather than putting JSON null on the wire', () => {
+    const body = resolveBody({ ...mapParams, limit: 'ten' as unknown as number })
+
+    expect(Object.hasOwn(body, 'limit')).toBe(false)
+  })
+
+  it('drops a non-numeric firecrawlTimeout rather than putting JSON null on the wire', () => {
+    const body = resolveBody({ ...mapParams, firecrawlTimeout: 'soon' as unknown as number })
+
+    expect(Object.hasOwn(body, 'timeout')).toBe(false)
+  })
+
+  it('still forwards numeric strings, which the block short-inputs produce', () => {
+    const body = resolveBody({
+      ...mapParams,
+      limit: '5' as unknown as number,
+      firecrawlTimeout: '45000' as unknown as number,
+    })
+
+    expect(body).toMatchObject({ limit: 5, timeout: 45000 })
+  })
+})

apps/sim/tools/firecrawl/map.ts

@@ -1,6 +1,7 @@
 import { firecrawlHosting } from '@/tools/firecrawl/hosting'
 import type { MapParams, MapResponse } from '@/tools/firecrawl/types'
 import { MAP_DOCUMENT_OUTPUT_PROPERTIES } from '@/tools/firecrawl/types'
+import { finiteNumber } from '@/tools/firecrawl/utils'
 import type { ToolConfig } from '@/tools/types'
 
 export const mapTool: ToolConfig<MapParams, MapResponse> = {
@@ -89,8 +90,10 @@ export const mapTool: ToolConfig<MapParams, MapResponse> = {
         body.includeSubdomains = params.includeSubdomains
       if (typeof params.ignoreQueryParameters === 'boolean')
         body.ignoreQueryParameters = params.ignoreQueryParameters
-      if (params.limit) body.limit = Number(params.limit)
-      if (params.firecrawlTimeout) body.timeout = Number(params.firecrawlTimeout)
+      const limit = finiteNumber(params.limit)
+      if (limit !== undefined) body.limit = limit
+      const firecrawlTimeout = finiteNumber(params.firecrawlTimeout)
+      if (firecrawlTimeout !== undefined) body.timeout = firecrawlTimeout
       if (params.location) body.location = params.location
 
       return body

apps/sim/tools/firecrawl/scrape.test.ts

@@ -63,3 +63,32 @@ describe('firecrawl scrape timeout is not the transport deadline', () => {
     expect(body.timeout).toBe(45000)
   })
 })
+
+describe('firecrawl scrape numeric coercion', () => {
+  it('drops a non-numeric firecrawlTimeout rather than putting JSON null on the wire', () => {
+    const body = resolveBody({ ...scrapeParams, firecrawlTimeout: 'soon' as unknown as number })
+
+    expect(Object.hasOwn(body, 'timeout')).toBe(false)
+  })
+
+  it('drops non-numeric maxAge and waitFor, which arrive via scrapeOptions passthrough', () => {
+    const body = resolveBody({
+      ...scrapeParams,
+      maxAge: 'fresh' as unknown as number,
+      waitFor: 'a bit' as unknown as number,
+    } as ScrapeParams)
+
+    expect(Object.hasOwn(body, 'maxAge')).toBe(false)
+    expect(Object.hasOwn(body, 'waitFor')).toBe(false)
+  })
+
+  it('still forwards numeric strings, which the block short-inputs produce', () => {
+    const body = resolveBody({
+      ...scrapeParams,
+      firecrawlTimeout: '45000' as unknown as number,
+      waitFor: '250' as unknown as number,
+    } as ScrapeParams)
+
+    expect(body).toMatchObject({ timeout: 45000, waitFor: 250 })
+  })
+})