@coldiq/mcp 0.1.11 → 0.1.13

package/tests/live/companyenrich-upstream-probe.ts

@@ -0,0 +1,72 @@
+// Direct upstream probe — bypasses the marketplace proxy.
+// Goal: figure out whether CompanyEnrich's /companies/search wants filters wrapped
+// under { filters: {...} } (current behavior) or at the top level, and whether ANY
+// filter shape narrows results away from their default top-5.
+//
+// Run:  COMPANYENRICH_API_KEY=… npx tsx mcp/tests/live/companyenrich-upstream-probe.ts
+
+const KEY = process.env.COMPANYENRICH_API_KEY
+if (!KEY) {
+  console.error('COMPANYENRICH_API_KEY required')
+  process.exit(1)
+}
+
+const BASE = 'https://api.companyenrich.com'
+
+async function call(body: unknown, label: string) {
+  const t0 = Date.now()
+  let res: Response
+  try {
+    res = await fetch(`${BASE}/companies/search`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(30_000),
+    })
+  } catch (err) {
+    console.log(`\n[${label}] body=${JSON.stringify(body)}`)
+    console.log(`  fetch-failed: ${err instanceof Error ? err.message : String(err)}`)
+    return
+  }
+  let data: any
+  try { data = await res.json() } catch { data = '<non-json>' }
+  const items = (data?.items ?? []).slice(0, 5).map((c: any) => `${c.name} (${c.domain})`)
+  console.log(`\n[${label}] body=${JSON.stringify(body)}`)
+  console.log(`  status=${res.status} ms=${Date.now() - t0} count=${data?.items?.length ?? 0}`)
+  console.log(`  top5=${JSON.stringify(items)}`)
+  if (!res.ok) console.log(`  raw=${JSON.stringify(data).slice(0, 400)}`)
+}
+
+async function main() {
+  console.log('=== CompanyEnrich /companies/search direct upstream probe ===')
+  console.log(`BASE=${BASE}`)
+
+  // A. What our marketplace currently sends
+  await call({ pageSize: 5, filters: { query: 'wework' } }, 'A. filters.query="wework" (our current shape)')
+
+  // B. Try query at top level
+  await call({ query: 'wework', pageSize: 5 }, 'B. top-level query="wework"')
+
+  // C. Try an exact identifier wrapped
+  await call({ pageSize: 5, filters: { domains: ['wework.com'] } }, 'C. filters.domains=["wework.com"]')
+
+  // D. Try an exact identifier top-level
+  await call({ domains: ['wework.com'], pageSize: 5 }, 'D. top-level domains=["wework.com"]')
+
+  // E. Try names wrapped
+  await call({ pageSize: 5, filters: { names: ['WeWork'] } }, 'E. filters.names=["WeWork"]')
+
+  // F. Country filter only (baseline narrowing)
+  await call({ pageSize: 5, filters: { countries: ['BR'] } }, 'F. filters.countries=["BR"] (baseline)')
+
+  // G. Country top-level
+  await call({ countries: ['BR'], pageSize: 5 }, 'G. top-level countries=["BR"]')
+
+  // H. Empty body — what does no filter return?
+  await call({ pageSize: 5 }, 'H. {pageSize:5} — empty body')
+
+  // I. semanticQuery (alternative full-text path)
+  await call({ pageSize: 5, filters: { semanticQuery: 'WeWork coworking real estate' } }, 'I. filters.semanticQuery="WeWork coworking real estate"')
+}
+
+main().catch((err) => { console.error('FATAL:', err); process.exit(1) })

package/tests/live/wework-brazil-trace.ts

@@ -0,0 +1,200 @@
+// Live prod trace for the "C-suite of WeWork Brazil" agent flow.
+// Pinpoints which calls misbehave so we can fix find_people / find_emails / search_companies
+// before re-running and measuring improvement.
+//
+// Run: COLDIQ_API_KEY=ciq_test_xxx tsx mcp/tests/live/wework-brazil-trace.ts
+
+const API_URL = process.env.COLDIQ_API_URL ?? 'https://api.coldiq.com'
+const API_KEY = process.env.COLDIQ_API_KEY
+if (!API_KEY) {
+  console.error('COLDIQ_API_KEY required')
+  process.exit(1)
+}
+
+type Result = { ok: boolean; status: number; data: unknown; ms: number }
+
+async function call(method: 'GET' | 'POST', path: string, body?: unknown): Promise<Result> {
+  const t0 = Date.now()
+  try {
+    const res = await fetch(`${API_URL}/v1${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${API_KEY}`,
+        ...(body ? { 'Content-Type': 'application/json' } : {}),
+      },
+      body: body ? JSON.stringify(body) : undefined,
+      signal: AbortSignal.timeout(120_000),
+    })
+    let data: unknown
+    try { data = await res.json() } catch { data = '<non-json>' }
+    return { ok: res.ok, status: res.status, data, ms: Date.now() - t0 }
+  } catch (err) {
+    return {
+      ok: false,
+      status: 0,
+      data: { error: 'fetch-failed', message: err instanceof Error ? err.message : String(err) },
+      ms: Date.now() - t0,
+    }
+  }
+}
+
+function shortJson(v: unknown, max = 400): string {
+  const s = typeof v === 'string' ? v : JSON.stringify(v)
+  return s.length > max ? s.slice(0, max) + '…' : s
+}
+
+function header(s: string) { console.log(`\n${'='.repeat(78)}\n${s}\n${'='.repeat(78)}`) }
+function step(s: string) { console.log(`\n— ${s} —`) }
+
+async function main() {
+  header('WeWork Brazil — live trace')
+  console.log(`API: ${API_URL}`)
+
+  // ---------------------------------------------------------------
+  // 1. search_companies — does the corrected `query` field surface WeWork?
+  //    Compares the buggy `keywords` shape (before-fix) with the fixed `query` shape (after-fix).
+  // ---------------------------------------------------------------
+  for (const kw of ['wework', 'wework brazil', 'WeWork']) {
+    step(`BEFORE-FIX companyenrich/companies/search keywords=[${kw}]`)
+    let r = await call('POST', '/companyenrich/companies/search', { keywords: [kw], pageSize: 5 })
+    console.log(`  status=${r.status} ms=${r.ms} top=${(((r.data as any)?.items ?? [])[0]?.name) ?? '<none>'}`)
+
+    step(`AFTER-FIX  companyenrich/companies/search query="${kw}"`)
+    r = await call('POST', '/companyenrich/companies/search', { query: kw, pageSize: 5 })
+    const top3 = (((r.data as any)?.items ?? []) as any[]).slice(0, 3).map((c: any) => c.name)
+    console.log(`  status=${r.status} ms=${r.ms} top3=${JSON.stringify(top3)}`)
+  }
+
+  step('fullenrich/company/search keywords=[wework]')
+  let r = await call('POST', '/fullenrich/company/search', {
+    keywords: [{ value: 'wework' }],
+    limit: 5,
+  })
+  console.log(`  status=${r.status} ms=${r.ms} data=${shortJson(r.data, 400)}`)
+
+  step('signalbase/companies search=wework')
+  r = await call('GET', `/signalbase/companies?search=${encodeURIComponent('wework')}&limit=5`)
+  console.log(`  status=${r.status} ms=${r.ms} data=${shortJson(r.data, 400)}`)
+
+  // ---------------------------------------------------------------
+  // 2. enrich_company — confirm wework.com
+  // ---------------------------------------------------------------
+  step('enrich_company domain=wework.com')
+  r = await call('POST', '/companyenrich/companies/enrich', { domain: 'wework.com' })
+  console.log(`  status=${r.status} ms=${r.ms}`)
+  console.log(`  data=${shortJson(r.data, 400)}`)
+
+  // ---------------------------------------------------------------
+  // 3. find_people — LeadsFactory WITHOUT country filter (current behavior)
+  // ---------------------------------------------------------------
+  step('LF contact-finder — wework.com, no country filter')
+  const lfNoCountry = await call('POST', '/leadsfactory/contact-finder/searches', {
+    company_domains: ['wework.com'],
+    search: {
+      max_persona_results: 10,
+      personas: [
+        { job_title: 'CEO, Chief Executive Officer' },
+        { job_title: 'Head of Sales, VP Sales' },
+        { job_title: 'Country Manager, Managing Director' },
+      ],
+    },
+  })
+  console.log(`  status=${lfNoCountry.status} ms=${lfNoCountry.ms}`)
+  console.log(`  data=${shortJson(lfNoCountry.data, 400)}`)
+
+  // ---------------------------------------------------------------
+  // 4. find_people — LeadsFactory WITH country filter (proposed fix)
+  // ---------------------------------------------------------------
+  step('LF contact-finder — wework.com + country_codes BR')
+  const lfBr = await call('POST', '/leadsfactory/contact-finder/searches', {
+    company_domains: ['wework.com'],
+    search: {
+      max_persona_results: 10,
+      personas: [
+        { job_title: 'CEO, Chief Executive Officer' },
+        { job_title: 'Head of Sales, VP Sales' },
+        { job_title: 'Country Manager, Managing Director' },
+      ],
+      country_codes: [{ code: 'BR', name: 'Brazil' }],
+    },
+  })
+  console.log(`  status=${lfBr.status} ms=${lfBr.ms}`)
+  console.log(`  data=${shortJson(lfBr.data, 600)}`)
+
+  // Poll one of them if async
+  function extractId(d: unknown): string | undefined {
+    const o = d as Record<string, unknown>
+    return (o?._id as string) ?? (o?.search_id as string)
+  }
+  const lfId = extractId(lfBr.data)
+  if (lfId) {
+    step(`Polling LF search ${lfId} (up to 90s)…`)
+    const deadline = Date.now() + 90_000
+    let attempt = 0
+    while (Date.now() < deadline) {
+      attempt++
+      const wait = attempt === 1 ? 2000 : attempt === 2 ? 5000 : 12000
+      await new Promise((r) => setTimeout(r, wait))
+      const pr = await call('GET', `/leadsfactory/contact-finder/searches/${lfId}`)
+      const d = pr.data as Record<string, unknown>
+      console.log(`  attempt=${attempt} status=${d?.status} complete=${d?.nb_jobs_complete}/${d?.nb_jobs_total} (${pr.ms}ms)`)
+      if (d?.status === 'SUCCESSFUL' || d?.status === 'FAILED' || d?.status === 'INVALID_URL') {
+        console.log(`  final=${shortJson(d, 1200)}`)
+        break
+      }
+    }
+  }
+
+  // ---------------------------------------------------------------
+  // 5. find_emails (bulk) vs find_email (single) on the same people
+  //    Use realistic test people from a public source — Estefania Barbosa @ wework.com
+  // ---------------------------------------------------------------
+  const testPeople = [
+    { id: 'estefania', first_name: 'Estefania', last_name: 'Barbosa', domain: 'wework.com' },
+    { id: 'marcelo',   first_name: 'Marcelo',   last_name: 'Russo',   domain: 'wework.com' },
+    { id: 'marina',    first_name: 'Marina',    last_name: 'Soares',  domain: 'wework.com' },
+  ]
+
+  step('Prospeo bulk (the bulk-find_emails Step 1)')
+  const prospeoBulk = await call('POST', '/prospeo/bulk-enrich-person', {
+    data: testPeople.map((p) => ({
+      identifier: p.id, first_name: p.first_name, last_name: p.last_name, company_name: p.domain,
+    })),
+  })
+  console.log(`  status=${prospeoBulk.status} ms=${prospeoBulk.ms}`)
+  console.log(`  data=${shortJson(prospeoBulk.data, 800)}`)
+
+  step('Findymail single — each person, in parallel')
+  const findyResults = await Promise.all(
+    testPeople.map(async (p) => {
+      const fr = await call('POST', '/findymail/search/name', {
+        name: `${p.first_name} ${p.last_name}`,
+        domain: p.domain,
+      })
+      return { id: p.id, status: fr.status, ms: fr.ms, data: fr.data }
+    }),
+  )
+  for (const f of findyResults) {
+    console.log(`  ${f.id}: status=${f.status} ms=${f.ms} → ${shortJson(f.data, 200)}`)
+  }
+
+  step('Icypeas single — each person, in parallel')
+  const icyResults = await Promise.all(
+    testPeople.map(async (p) => {
+      const ir = await call('POST', '/icypeas/email-search', {
+        firstname: p.first_name, lastname: p.last_name, domainOrCompany: p.domain,
+      })
+      return { id: p.id, status: ir.status, ms: ir.ms, data: ir.data }
+    }),
+  )
+  for (const f of icyResults) {
+    console.log(`  ${f.id}: status=${f.status} ms=${f.ms} → ${shortJson(f.data, 200)}`)
+  }
+
+  header('Done')
+}
+
+main().catch((err) => {
+  console.error('FATAL:', err)
+  process.exit(1)
+})

package/tests/registry-find-people.test.ts

@@ -430,6 +430,77 @@ describe('leadsfactory (find_people)', () => {
     })
   })
 
+  it('locations are forwarded as ISO country_codes pairs', () => {
+    const result = p().mapParams({
+      company_domains: ['wework.com'],
+      job_titles: ['CEO'],
+      locations: ['BR', 'US'],
+      limit: 10,
+    })
+    const search = (result.body as Record<string, unknown>).search as Record<string, unknown>
+    expect(search.country_codes).toEqual([
+      { code: 'BR', name: 'Brazil' },
+      { code: 'US', name: 'United States' },
+    ])
+  })
+
+  it('country names are coerced to ISO-2 (agents commonly pass "Brazil" instead of "BR")', () => {
+    const result = p().mapParams({
+      company_domains: ['wework.com'],
+      job_titles: ['CEO'],
+      locations: ['Brazil', 'United States'],
+      limit: 10,
+    })
+    const search = (result.body as Record<string, unknown>).search as Record<string, unknown>
+    expect(search.country_codes).toEqual([
+      { code: 'BR', name: 'Brazil' },
+      { code: 'US', name: 'United States' },
+    ])
+  })
+
+  it('common aliases (USA, UK) and case-insensitive names are coerced', () => {
+    const result = p().mapParams({
+      company_domains: ['x.com'],
+      job_titles: ['CEO'],
+      locations: ['usa', 'UK', 'south korea'],
+      limit: 5,
+    })
+    const search = (result.body as Record<string, unknown>).search as Record<string, unknown>
+    expect(search.country_codes).toEqual([
+      { code: 'US', name: 'United States' },
+      { code: 'GB', name: 'United Kingdom' },
+      { code: 'KR', name: 'South Korea' },
+    ])
+  })
+
+  it('unrecognized location strings are dropped rather than forwarded as garbage', () => {
+    const result = p().mapParams({
+      company_domains: ['x.com'],
+      job_titles: ['CEO'],
+      locations: ['Atlantis', 'BR'],
+      limit: 5,
+    })
+    const search = (result.body as Record<string, unknown>).search as Record<string, unknown>
+    expect(search.country_codes).toEqual([{ code: 'BR', name: 'Brazil' }])
+  })
+
+  it('country_codes is omitted when locations is not provided', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['CEO'], limit: 5 })
+    const search = (result.body as Record<string, unknown>).search as Record<string, unknown>
+    expect(search.country_codes).toBeUndefined()
+  })
+
+  it('country_codes is omitted when locations is provided but no value coerces (all unrecognized)', () => {
+    const result = p().mapParams({
+      company_domains: ['x.com'],
+      job_titles: ['CEO'],
+      locations: ['Atlantis', 'Narnia'],
+      limit: 5,
+    })
+    const search = (result.body as Record<string, unknown>).search as Record<string, unknown>
+    expect(search.country_codes).toBeUndefined()
+  })
+
   it('seniorities and keywords are not forwarded', () => {
     const result = p().mapParams({
       company_domains: ['coldiq.com'],
@@ -442,6 +513,46 @@ describe('leadsfactory (find_people)', () => {
     expect(body.seniorities).toBeUndefined()
     expect(body.keywords).toBeUndefined()
   })
+
+  it('hasResult: true when companies_personas is non-empty', () => {
+    expect(p().hasResult({ companies_personas: [{ company: 'ColdIQ' }] })).toBe(true)
+  })
+
+  it('hasResult: false when companies_personas is empty array', () => {
+    expect(p().hasResult({ companies_personas: [] })).toBe(false)
+  })
+
+  it('hasResult: true when SUCCESSFUL + nb_jobs_complete > 0 (no companies_personas in response)', () => {
+    expect(p().hasResult({ status: 'SUCCESSFUL', nb_jobs_complete: 3 })).toBe(true)
+  })
+
+  it('hasResult: false when SUCCESSFUL + nb_jobs_complete is null (no results)', () => {
+    expect(p().hasResult({ status: 'SUCCESSFUL', nb_jobs_complete: null })).toBe(false)
+  })
+
+  it('hasResult: false when SUCCESSFUL + nb_jobs_complete is 0', () => {
+    expect(p().hasResult({ status: 'SUCCESSFUL', nb_jobs_complete: 0 })).toBe(false)
+  })
+
+  it('isComplete: true for SUCCESSFUL', () => {
+    expect(p().async!.isComplete({ status: 'SUCCESSFUL' })).toBe(true)
+  })
+
+  it('isComplete: true for FAILED', () => {
+    expect(p().async!.isComplete({ status: 'FAILED' })).toBe(true)
+  })
+
+  it('isComplete: true for INVALID_URL (terminal error state)', () => {
+    expect(p().async!.isComplete({ status: 'INVALID_URL' })).toBe(true)
+  })
+
+  it('isComplete: false for RUNNING', () => {
+    expect(p().async!.isComplete({ status: 'RUNNING' })).toBe(false)
+  })
+
+  it('isComplete: false for PAUSED', () => {
+    expect(p().async!.isComplete({ status: 'PAUSED' })).toBe(false)
+  })
 })
 
 // ---------------------------------------------------------------------------

package/tests/registry-polling.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders } from '../src/registry.js'
+
+function evalPollSchedule(pollIntervalMs: number | ((attempt: number) => number), maxMs: number) {
+  const result: number[] = []
+  let cumulative = 0
+  let attempt = 1
+  while (cumulative < maxMs) {
+    const interval = typeof pollIntervalMs === 'function' ? pollIntervalMs(attempt) : pollIntervalMs
+    cumulative += interval
+    result.push(interval)
+    attempt++
+  }
+  return result
+}
+
+describe('MCP polling interval schedules', () => {
+  it('Apify shared async configs (jobs/ads/places/reddit): fast early polls, plateau at 4s', () => {
+    const providers = getProviders('search_jobs')
+    const p = providers.find((p) => p.id === 'career_site_jobs' || p.id === 'linkedin_jobs')!
+    expect(p?.async).toBeDefined()
+    const fn = p.async!.pollIntervalMs as (attempt: number) => number
+    expect(typeof fn).toBe('function')
+    expect(fn(1)).toBe(1500)
+    expect(fn(2)).toBe(2500)
+    expect(fn(3)).toBe(2500)
+    expect(fn(4)).toBe(4000) // plateaus at 4s
+    expect(fn(10)).toBe(4000)
+    // Must get ≥ 10 polls inside the 5-minute timeout
+    expect(evalPollSchedule(fn, 300_000).length).toBeGreaterThanOrEqual(10)
+  })
+
+  it('FullEnrich find-email: 2.5s interval fits inside 60s timeout', () => {
+    const providers = getProviders('find_email')
+    const fe = providers.find((p) => p.id === 'fullenrich')!
+    expect(fe?.async).toBeDefined()
+    expect(fe.async!.pollIntervalMs).toBe(2500)
+    // timeoutMs = 60_000 → at least 24 polls
+    expect(60_000 / 2500).toBeGreaterThanOrEqual(24)
+  })
+
+  it('Instantly verify-email: 1.5s interval fits inside 30s timeout', () => {
+    const providers = getProviders('verify_email')
+    const inst = providers.find((p) => p.id === 'instantly')!
+    expect(inst?.async).toBeDefined()
+    expect(inst.async!.pollIntervalMs).toBe(1500)
+    expect(30_000 / 1500).toBeGreaterThanOrEqual(20)
+  })
+
+  it('LeadsFactory find-people: shorter front, ≥7 polls in 5 minutes', () => {
+    const providers = getProviders('find_people')
+    const lf = providers.find((p) => p.id === 'leadsfactory')!
+    expect(lf?.async).toBeDefined()
+    const fn = lf.async!.pollIntervalMs as (attempt: number) => number
+    expect(fn(1)).toBe(2000) // faster first probe vs old 3000
+    expect(fn(2)).toBe(5000)
+    expect(fn(3)).toBe(12000)
+    // Validates ≥7 polls still fit in 5 min (guard against overly aggressive growth)
+    expect(evalPollSchedule(fn, 300_000).length).toBeGreaterThanOrEqual(7)
+  })
+})

package/tests/registry.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import { getProviders, getSearchWebProviders, isoCountryToName, listCapabilityProviderIds } from '../src/registry.js'
-import type { Capability } from '../src/registry.js'
+import type { Capability, ProviderEntry } from '../src/registry.js'
 
 const ALL_CAPABILITIES: Capability[] = [
   'search_companies',
@@ -36,11 +36,11 @@ describe('registry', () => {
     }
   })
 
-  it('returns a copy — mutating does not affect the registry', () => {
+  it('is memoized — consecutive calls return the same frozen reference', () => {
     const first = getProviders('search_companies')
-    first.pop()
     const second = getProviders('search_companies')
-    expect(second.length).toBeGreaterThan(first.length)
+    expect(first).toBe(second) // referential equality — cache is working
+    expect(() => (first as ProviderEntry[]).pop()).toThrow() // frozen — mutation throws
   })
 
   it('throws for unknown capability', () => {
@@ -48,7 +48,7 @@ describe('registry', () => {
   })
 
   describe('search_companies mapParams', () => {
-    it('CompanyEnrich maps correctly and folds industries into keywords', () => {
+    it('CompanyEnrich routes keywords + industries into the `query` full-text field (not the tag-filter `keywords` field)', () => {
       const providers = getProviders('search_companies')
       const ce = providers.find((p) => p.id === 'companyenrich')!
       const result = ce.mapParams({
@@ -59,13 +59,30 @@ describe('registry', () => {
         max_employees: 200,
         limit: 25,
       })
-      expect(result.body).toEqual({
-        keywords: ['SaaS', 'Software'],
-        countries: ['US'],
-        employees: [{ from: 10, to: 200 }],
-        foundedYear: undefined,
-        pageSize: 25,
-      })
+      const body = result.body as Record<string, unknown>
+      expect(body.query).toBe('SaaS Software')
+      expect(body.keywords).toBeUndefined()
+      expect(body.countries).toEqual(['US'])
+      expect(body.employees).toEqual([{ from: 10, to: 200 }])
+      expect(body.pageSize).toBe(25)
+    })
+
+    it('CompanyEnrich brand-name keyword goes to `query` (the WeWork regression)', () => {
+      const providers = getProviders('search_companies')
+      const ce = providers.find((p) => p.id === 'companyenrich')!
+      const result = ce.mapParams({ keywords: ['wework'], limit: 5 })
+      const body = result.body as Record<string, unknown>
+      expect(body.query).toBe('wework')
+      expect(body.keywords).toBeUndefined()
+    })
+
+    it('CompanyEnrich omits `query` when no keywords/industries provided', () => {
+      const providers = getProviders('search_companies')
+      const ce = providers.find((p) => p.id === 'companyenrich')!
+      const result = ce.mapParams({ countries: ['US'], limit: 5 })
+      const body = result.body as Record<string, unknown>
+      expect(body.query).toBeUndefined()
+      expect(body.keywords).toBeUndefined()
     })
 
     it('Apollo maps correctly, translating ISO country codes to English names', () => {
@@ -518,11 +535,11 @@ describe('registry', () => {
       const sched = lf.async!.pollIntervalMs
       expect(typeof sched).toBe('function')
       const fn = sched as (attempt: number) => number
-      expect(fn(1)).toBe(3000)
-      expect(fn(2)).toBe(7000)
-      expect(fn(3)).toBe(15000)
-      expect(fn(4)).toBe(25000)
-      expect(fn(8)).toBe(65000)
+      expect(fn(1)).toBe(2000)
+      expect(fn(2)).toBe(5000)
+      expect(fn(3)).toBe(12000)
+      expect(fn(4)).toBe(20000)
+      expect(fn(8)).toBe(52000)
       // At least 7 polls must fit inside the 5-minute timeout — guards against
       // future tuning that would make the ramp so steep we only get 1–2 polls.
       let cumulative = 0
@@ -1255,7 +1272,7 @@ describe('registry', () => {
       })
       expect(result.body).toEqual({
         countries: ['US'],
-        keywords: ['SaaS'],
+        query: 'SaaS',
         technologies: ['Salesforce', 'HubSpot'],
         employees: undefined,
         foundedYear: undefined,

package/tests/tools/find-emails.test.ts

@@ -400,3 +400,111 @@ describe('find_emails handler — use_providers', () => {
     expect(icypeasCalled).toBe(false)
   })
 })
+
+describe('find_emails handler — resilience', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('findymailIcypeasStep completing correctly even when fullEnrichStep throws', async () => {
+    // Prospeo returns no results.
+    // FullEnrich create call throws (simulates unexpected error).
+    // FindyMail finds the email — result should still be populated.
+
+    vi.useFakeTimers()
+
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        return new Response(JSON.stringify({
+          error: false,
+          results: [{ identifier: 'p1', error: true, person: null }],
+          total_cost: 0,
+        }), { status: 200 })
+      }
+      if (u.includes('/fullenrich/contact/enrich/bulk') && !u.includes('/fullenrich/contact/enrich/bulk/')) {
+        // Throw so fullEnrichStep rejects
+        throw new Error('FullEnrich network failure')
+      }
+      if (u.includes('/findymail/search/name')) {
+        return new Response(JSON.stringify({ email: 'alice@example.com' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const resultPromise = findEmailsHandler({
+      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
+    })
+
+    // Advance timers past the FullEnrich poll sleep
+    await vi.runAllTimersAsync()
+    const result = await resultPromise
+
+    vi.useRealTimers()
+
+    // Despite fullEnrichStep throwing, the handler must succeed
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.data.found).toBe(1)
+    expect(parsed.data.results[0]).toMatchObject({ id: 'p1', email: 'alice@example.com', provider: 'findymail' })
+  })
+
+  it('falls back to single find_email waterfall when bulk providers all miss (covers limadata/blitzapi/linkupapi gap)', async () => {
+    // Bulk path: Prospeo + FullEnrich + Findymail + Icypeas all miss.
+    // Single-only providers (limadata-work-email, blitzapi, limadata-work-email-linkedin, linkupapi)
+    // should be tried; blitzapi finds the email.
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        return new Response(
+          JSON.stringify({ error: false, results: [{ identifier: 'p1', error: true, person: null }], total_cost: 0 }),
+          { status: 200 },
+        )
+      }
+      if (u.includes('/fullenrich/contact/enrich/bulk')) {
+        // No enrichment_id returned → fullEnrichStep exits early without polling
+        return new Response(JSON.stringify({}), { status: 200 })
+      }
+      if (u.includes('/findymail/search/name')) {
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      if (u.includes('/icypeas/email-search')) {
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      // Single-only providers — limadata first (per priority), then blitzapi.
+      if (u.includes('/coldiq/find/work-email-linkedin')) {
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      if (u.includes('/coldiq/find/work-email')) {
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      if (u.includes('/blitzapi/enrichment/find-work-email')) {
+        return new Response(JSON.stringify({ email: 'alice@example.com' }), { status: 200 })
+      }
+      if (u.includes('/linkupapi/data/mail/finder')) {
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected', url: u }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await findEmailsHandler({
+      people: [{
+        id: 'p1',
+        first_name: 'Alice',
+        last_name: 'Smith',
+        domain: 'example.com',
+        linkedin_url: 'https://linkedin.com/in/alice',
+      }],
+    })
+
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.data.found).toBe(1)
+    expect(parsed.data.results[0]).toMatchObject({ id: 'p1', email: 'alice@example.com', provider: 'blitzapi' })
+  })
+})