@coldiq/mcp 0.1.0

package/tests/registry.test.ts

@@ -0,0 +1,2210 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders, getSearchWebProviders, isoCountryToName } from '../src/registry.js'
+import type { Capability } from '../src/registry.js'
+
+const ALL_CAPABILITIES: Capability[] = [
+  'search_companies',
+  'find_people',
+  'find_email',
+  'verify_email',
+  'find_phone',
+  'enrich_company',
+  'enrich_person',
+  'search_web',
+  'search_jobs',
+  'search_ads',
+  'search_places',
+  'find_influencers',
+  'search_reddit',
+  'search_seo',
+]
+
+describe('registry', () => {
+  it('every capability has at least one provider', () => {
+    for (const cap of ALL_CAPABILITIES) {
+      const providers = getProviders(cap)
+      expect(providers.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('providers are sorted by priority', () => {
+    for (const cap of ALL_CAPABILITIES) {
+      const providers = getProviders(cap)
+      for (let i = 1; i < providers.length; i++) {
+        expect(providers[i].priority).toBeGreaterThanOrEqual(providers[i - 1].priority)
+      }
+    }
+  })
+
+  it('returns a copy — mutating does not affect the registry', () => {
+    const first = getProviders('search_companies')
+    first.pop()
+    const second = getProviders('search_companies')
+    expect(second.length).toBeGreaterThan(first.length)
+  })
+
+  it('throws for unknown capability', () => {
+    expect(() => getProviders('unknown' as Capability)).toThrow('Unknown capability')
+  })
+
+  describe('search_companies mapParams', () => {
+    it('CompanyEnrich maps correctly and folds industries into keywords', () => {
+      const providers = getProviders('search_companies')
+      const ce = providers.find((p) => p.id === 'companyenrich')!
+      const result = ce.mapParams({
+        keywords: ['SaaS'],
+        industries: ['Software'],
+        countries: ['US'],
+        min_employees: 10,
+        max_employees: 200,
+        limit: 25,
+      })
+      expect(result.body).toEqual({
+        keywords: ['SaaS', 'Software'],
+        countries: ['US'],
+        employees: [{ from: 10, to: 200 }],
+        foundedYear: undefined,
+        pageSize: 25,
+      })
+    })
+
+    it('Apollo maps correctly, translating ISO country codes to English names', () => {
+      const providers = getProviders('search_companies')
+      const apollo = providers.find((p) => p.id === 'apollo')!
+      const result = apollo.mapParams({
+        keywords: ['SaaS'],
+        countries: ['US'],
+        min_employees: 10,
+        max_employees: 200,
+        limit: 25,
+      })
+      expect(result.body).toEqual({
+        q_organization_keyword_tags: ['SaaS'],
+        organization_locations: ['United States'],
+        organization_num_employees_ranges: ['10,200'],
+        per_page: 25,
+      })
+    })
+
+    it('Apollo folds industries into keyword tags and translates country codes in org_locations', () => {
+      const providers = getProviders('search_companies')
+      const apollo = providers.find((p) => p.id === 'apollo')!
+      const result = apollo.mapParams({
+        keywords: ['healthcare'],
+        industries: ['Hospital & Health Care', 'Medical Devices'],
+        locations: ['Paris, France'],
+        countries: ['FR'],
+        min_employees: 50,
+        max_employees: 100,
+        limit: 25,
+      })
+      expect(result.body).toEqual({
+        q_organization_keyword_tags: ['healthcare', 'Hospital & Health Care', 'Medical Devices'],
+        organization_locations: ['Paris, France', 'France'],
+        organization_num_employees_ranges: ['50,100'],
+        per_page: 25,
+      })
+    })
+
+    it('Apollo omits empty keyword/location arrays', () => {
+      const providers = getProviders('search_companies')
+      const apollo = providers.find((p) => p.id === 'apollo')!
+      const result = apollo.mapParams({ min_employees: 50, max_employees: 100, limit: 25 })
+      expect(result.body).toEqual({
+        q_organization_keyword_tags: undefined,
+        organization_locations: undefined,
+        organization_num_employees_ranges: ['50,100'],
+        per_page: 25,
+      })
+    })
+
+    it('FullEnrich wraps each filter value in {value}, translates ISO country codes to English names', () => {
+      const providers = getProviders('search_companies')
+      const fe = providers.find((p) => p.id === 'fullenrich')!
+      const result = fe.mapParams({
+        keywords: ['SaaS', 'fintech'],
+        industries: ['Technology'],
+        locations: ['Paris'],
+        countries: ['FR'],
+        min_employees: 50,
+        max_employees: 500,
+        min_founded_year: 2010,
+        limit: 10,
+      })
+      expect(result.body).toEqual({
+        keywords: [{ value: 'SaaS' }, { value: 'fintech' }],
+        industries: [{ value: 'Technology' }],
+        headquarters_locations: [{ value: 'Paris' }, { value: 'France' }],
+        headcounts: [{ min: 50, max: 500 }],
+        founded_years: [{ min: 2010 }],
+        limit: 10,
+      })
+    })
+
+    it('FullEnrich hasResult checks companies/data/results array', () => {
+      const providers = getProviders('search_companies')
+      const fe = providers.find((p) => p.id === 'fullenrich')!
+      expect(fe.hasResult({ companies: [{ name: 'ColdIQ' }] })).toBe(true)
+      expect(fe.hasResult({ data: [{ name: 'ColdIQ' }] })).toBe(true)
+      expect(fe.hasResult({ companies: [] })).toBe(false)
+      expect(fe.hasResult({})).toBe(false)
+    })
+
+    it('SignalBase uses keywords for search and industries for the dedicated industry param', () => {
+      const providers = getProviders('search_companies')
+      const sb = providers.find((p) => p.id === 'signalbase')!
+      expect(sb.method).toBe('GET')
+      const result = sb.mapParams({
+        keywords: ['SaaS'],
+        industries: ['Software'],
+        countries: ['FR', 'US'],
+        min_employees: 50,
+        max_employees: 500,
+        limit: 25,
+      })
+      expect(result.body).toBeUndefined()
+      expect(result.queryParams).toEqual({
+        search: 'SaaS',
+        industry: 'Software',
+        countries: 'FR,US',
+        employee_count_min: '50',
+        employee_count_max: '500',
+        limit: '25',
+      })
+    })
+
+    it('BlitzAPI folds industries into keywords (industry filter requires LinkedIn taxonomy)', () => {
+      const providers = getProviders('search_companies')
+      const blitz = providers.find((p) => p.id === 'blitzapi')!
+      const result = blitz.mapParams({
+        keywords: ['AI'],
+        industries: ['Technology'],
+        countries: ['US'],
+        min_employees: 50,
+        max_employees: 500,
+        min_founded_year: 2015,
+        limit: 10,
+      })
+      expect(result.body).toEqual({
+        company: {
+          keywords: { include: ['AI', 'Technology'] },
+          employee_count: { min: 50, max: 500 },
+          founded_year: { min: 2015 },
+          hq: { country_code: ['US'] },
+        },
+        max_results: 10,
+      })
+    })
+
+    it('BlitzAPI isApplicable rejects empty input but accepts basic narrowing filters', () => {
+      const providers = getProviders('search_companies')
+      const blitz = providers.find((p) => p.id === 'blitzapi')!
+      expect(blitz.isApplicable!({})).toBe(false)
+      expect(blitz.isApplicable!({ keywords: ['AI'] })).toBe(true)
+      expect(blitz.isApplicable!({ countries: ['US'] })).toBe(true)
+      expect(blitz.isApplicable!({ min_employees: 50 })).toBe(true)
+    })
+
+    it('BlitzAPI isApplicable rejects advanced filters it cannot apply', () => {
+      const providers = getProviders('search_companies')
+      const blitz = providers.find((p) => p.id === 'blitzapi')!
+      expect(blitz.isApplicable!({ technologies: ['Salesforce'] })).toBe(false)
+      expect(blitz.isApplicable!({ funding_stages: ['series_a'] })).toBe(false)
+      expect(blitz.isApplicable!({ min_funding_amount: 1_000_000 })).toBe(false)
+      expect(blitz.isApplicable!({ max_funding_amount: 50_000_000 })).toBe(false)
+      expect(blitz.isApplicable!({ min_revenue: 500_000 })).toBe(false)
+      expect(blitz.isApplicable!({ max_revenue: 10_000_000 })).toBe(false)
+      expect(blitz.isApplicable!({ exclude_industries: ['Gaming'] })).toBe(false)
+      expect(blitz.isApplicable!({ exclude_countries: ['CN'] })).toBe(false)
+      expect(blitz.isApplicable!({ is_hiring: true })).toBe(false)
+      // is_hiring=false is not an active filter — still fires on other narrowing filters
+      expect(blitz.isApplicable!({ keywords: ['SaaS'], is_hiring: false })).toBe(true)
+    })
+
+    it('BlitzAPI postFilter enforces employee count when present, passes through when missing', () => {
+      const providers = getProviders('search_companies')
+      const blitz = providers.find((p) => p.id === 'blitzapi')!
+      const results = [
+        { name: 'A', employees_on_linkedin: 30 },
+        { name: 'B', employees_on_linkedin: 100 },
+        { name: 'C', employees_on_linkedin: 600 },
+        { name: 'D' }, // no field — passes through (lenient)
+      ]
+      const out = blitz.postFilter!({ results }, { min_employees: 50, max_employees: 500 }) as Record<string, unknown>
+      expect((out.results as Array<Record<string, unknown>>).map((o) => o.name)).toEqual(['B', 'D'])
+    })
+
+    it('BlitzAPI postFilter is a no-op when no employee filters are set', () => {
+      const providers = getProviders('search_companies')
+      const blitz = providers.find((p) => p.id === 'blitzapi')!
+      const results = [{ name: 'A', employees_on_linkedin: 30 }]
+      const out = blitz.postFilter!({ results }, {}) as Record<string, unknown>
+      expect((out.results as unknown[]).length).toBe(1)
+    })
+
+    it('BlitzAPI caps max_results at 50', () => {
+      const providers = getProviders('search_companies')
+      const blitz = providers.find((p) => p.id === 'blitzapi')!
+      const result = blitz.mapParams({ keywords: ['AI'], limit: 100 })
+      expect((result.body as { max_results: number }).max_results).toBe(50)
+    })
+
+    it('LimaData search folds keywords+industries into query and maps employees to A-H buckets', () => {
+      const providers = getProviders('search_companies')
+      const ld = providers.find((p) => p.id === 'limadata')!
+      const result = ld.mapParams({
+        keywords: ['SaaS'],
+        industries: ['Software'],
+        min_employees: 51,
+        max_employees: 500,
+        limit: 25,
+      })
+      expect(result.body).toEqual({
+        query: 'SaaS Software',
+        company_size: 'C,D',
+      })
+    })
+
+    it('LimaData search uses fallback query when no keywords/industries provided', () => {
+      const providers = getProviders('search_companies')
+      const ld = providers.find((p) => p.id === 'limadata')!
+      const result = ld.mapParams({ min_employees: 51, max_employees: 200 })
+      expect((result.body as { query: string }).query).toBe('company')
+    })
+
+    it('PredictLeads maps employee range to comma-separated size enum and uses first location', () => {
+      const providers = getProviders('search_companies')
+      const pl = providers.find((p) => p.id === 'predictleads')!
+      expect(pl.method).toBe('GET')
+      const result = pl.mapParams({
+        countries: ['US'],
+        locations: ['San Francisco'],
+        min_employees: 51,
+        max_employees: 500,
+        limit: 25,
+      })
+      expect(result.queryParams).toEqual({
+        location: 'San Francisco',
+        sizes: '51-200,201-500',
+        limit: '25',
+      })
+    })
+
+    it('PredictLeads isApplicable requires both location and employee range', () => {
+      const providers = getProviders('search_companies')
+      const pl = providers.find((p) => p.id === 'predictleads')!
+      expect(pl.isApplicable!({})).toBe(false)
+      expect(pl.isApplicable!({ countries: ['US'] })).toBe(false)
+      expect(pl.isApplicable!({ min_employees: 50 })).toBe(false)
+      expect(pl.isApplicable!({ countries: ['US'], min_employees: 50 })).toBe(true)
+      expect(pl.isApplicable!({ locations: ['SF'], max_employees: 500 })).toBe(true)
+    })
+
+    it('TheirStack maps technologies to company_technology_slug_or and forwards employee/industry/country filters', () => {
+      const providers = getProviders('search_companies')
+      const ts = providers.find((p) => p.id === 'theirstack')!
+      const result = ts.mapParams({
+        technologies: ['salesforce', 'hubspot'],
+        industries: ['Technology'],
+        countries: ['US'],
+        min_employees: 50,
+        max_employees: 500,
+        limit: 10,
+      })
+      expect(result.body).toEqual({
+        company_technology_slug_or: ['salesforce', 'hubspot'],
+        industry_or: ['Technology'],
+        company_country_code_or: ['US'],
+        min_employee_count: 50,
+        max_employee_count: 500,
+        funding_stage_or: undefined,
+        min_funding_usd: undefined,
+        max_funding_usd: undefined,
+        limit: 10,
+      })
+    })
+
+    it('TheirStack maps funding_stage_or and funding amounts', () => {
+      const providers = getProviders('search_companies')
+      const ts = providers.find((p) => p.id === 'theirstack')!
+      const result = ts.mapParams({
+        industries: ['SaaS'],
+        funding_stages: ['series_a', 'series_b'],
+        min_funding_amount: 1_000_000,
+        max_funding_amount: 50_000_000,
+        limit: 10,
+      })
+      expect(result.body).toEqual({
+        company_technology_slug_or: undefined,
+        industry_or: ['SaaS'],
+        company_country_code_or: undefined,
+        min_employee_count: undefined,
+        max_employee_count: undefined,
+        funding_stage_or: ['series_a', 'series_b'],
+        min_funding_usd: 1_000_000,
+        max_funding_usd: 50_000_000,
+        limit: 10,
+      })
+    })
+
+    it('Sumble folds keywords+industries into filters.query', () => {
+      const providers = getProviders('search_companies')
+      const sumble = providers.find((p) => p.id === 'sumble')!
+      const result = sumble.mapParams({
+        keywords: ['SaaS'],
+        industries: ['Tech'],
+        limit: 10,
+      })
+      expect(result.body).toEqual({
+        filters: { query: 'SaaS Tech' },
+        limit: 10,
+      })
+    })
+
+    it('Sumble passes technologies into filters.technologies', () => {
+      const providers = getProviders('search_companies')
+      const sumble = providers.find((p) => p.id === 'sumble')!
+      const result = sumble.mapParams({
+        technologies: ['Salesforce', 'HubSpot'],
+        limit: 5,
+      })
+      expect(result.body).toEqual({
+        filters: { technologies: ['Salesforce', 'HubSpot'] },
+        limit: 5,
+      })
+    })
+
+    it('Sumble isApplicable requires keywords, industries, or technologies', () => {
+      const providers = getProviders('search_companies')
+      const sumble = providers.find((p) => p.id === 'sumble')!
+      expect(sumble.isApplicable!({})).toBe(false)
+      expect(sumble.isApplicable!({ keywords: ['SaaS'] })).toBe(true)
+      expect(sumble.isApplicable!({ industries: ['Tech'] })).toBe(true)
+      expect(sumble.isApplicable!({ technologies: ['Salesforce'] })).toBe(true)
+      expect(sumble.isApplicable!({ countries: ['FR'] })).toBe(false)
+    })
+
+    it('Wiza creates a prospect list with [{v}] filter shape, translates ISO codes, and has async config', () => {
+      const providers = getProviders('search_companies')
+      const wiza = providers.find((p) => p.id === 'wiza')!
+      const result = wiza.mapParams({
+        industries: ['SaaS'],
+        countries: ['FR'],
+        min_founded_year: 2015,
+        limit: 25,
+      })
+      expect(result.body).toEqual({
+        list: { name: 'mcp-search-companies', max_profiles: 25 },
+        filters: {
+          company_industry: [{ v: 'SaaS' }],
+          company_location: [{ v: 'France' }],
+          year_founded_start: [{ v: '2015' }],
+        },
+        enrichment_level: 'none',
+      })
+      expect(wiza.async).toBeDefined()
+      expect(wiza.async!.pollEndpoint('123')).toBe('/wiza/lists/123')
+      expect(wiza.async!.extractId({ data: { id: 123 } })).toBe('123')
+    })
+
+    it('Wiza isComplete accepts both finished and completed terminal states', () => {
+      const providers = getProviders('search_companies')
+      const wiza = providers.find((p) => p.id === 'wiza')!
+      expect(wiza.async!.isComplete({ data: { status: 'finished' } })).toBe(true)
+      expect(wiza.async!.isComplete({ data: { status: 'completed' } })).toBe(true)
+      expect(wiza.async!.isComplete({ data: { status: 'failed' } })).toBe(true)
+      expect(wiza.async!.isComplete({ data: { status: 'scraping' } })).toBe(false)
+      expect(wiza.async!.isComplete({ data: { status: 'queued' } })).toBe(false)
+    })
+
+    it('Wiza extractId throws when no list id is present', () => {
+      const providers = getProviders('search_companies')
+      const wiza = providers.find((p) => p.id === 'wiza')!
+      expect(() => wiza.async!.extractId({})).toThrow('Wiza response has no list id')
+      expect(() => wiza.async!.extractId({ data: {} })).toThrow('Wiza response has no list id')
+    })
+
+    it('Wiza hasResult checks data.stats.people > 0', () => {
+      const providers = getProviders('search_companies')
+      const wiza = providers.find((p) => p.id === 'wiza')!
+      expect(wiza.hasResult({ data: { status: 'finished', stats: { people: 10 } } })).toBe(true)
+      expect(wiza.hasResult({ data: { status: 'finished', stats: { people: 0 } } })).toBe(false)
+      expect(wiza.hasResult({ data: { status: 'finished' } })).toBe(false)
+    })
+
+    it('LimaData prospect filter maps employees to company_headcount filter_type', () => {
+      const providers = getProviders('search_companies')
+      const ld = providers.find((p) => p.id === 'limadata-prospect-filter')!
+      const result = ld.mapParams({ min_employees: 51, max_employees: 500 })
+      expect(result.body).toEqual({
+        filters: [{ filter_type: 'company_headcount', values: ['C', 'D'] }],
+      })
+    })
+
+    it('LimaData prospect filter isApplicable requires a non-trivial employee range', () => {
+      const providers = getProviders('search_companies')
+      const ld = providers.find((p) => p.id === 'limadata-prospect-filter')!
+      expect(ld.isApplicable!({})).toBe(false)
+      expect(ld.isApplicable!({ keywords: ['SaaS'] })).toBe(false) // no employee filter
+      expect(ld.isApplicable!({ min_employees: 51, max_employees: 500 })).toBe(true)
+    })
+
+    it('LimaData prospect URL passes search_url when provided', () => {
+      const providers = getProviders('search_companies')
+      const ld = providers.find((p) => p.id === 'limadata-prospect-url')!
+      const result = ld.mapParams({ linkedin_search_url: 'https://www.linkedin.com/sales/search/company?...' })
+      expect(result.body).toEqual({ search_url: 'https://www.linkedin.com/sales/search/company?...' })
+    })
+
+    it('LimaData prospect URL isApplicable requires linkedin_search_url', () => {
+      const providers = getProviders('search_companies')
+      const ld = providers.find((p) => p.id === 'limadata-prospect-url')!
+      expect(ld.isApplicable!({})).toBe(false)
+      expect(ld.isApplicable!({ keywords: ['SaaS'] })).toBe(false)
+      expect(ld.isApplicable!({ linkedin_search_url: 'https://...' })).toBe(true)
+    })
+
+    it('search_companies has 18 providers in priority order', () => {
+      const providers = getProviders('search_companies')
+      expect(providers.map((p) => p.id)).toEqual([
+        'companyenrich',
+        'fullenrich',
+        'pdl',
+        'theirstack',
+        'wiza',
+        'signalbase',
+        'blitzapi',
+        'apollo',
+        'limadata',
+        'predictleads',
+        'sumble',
+        'limadata-prospect-filter',
+        'limadata-prospect-url',
+        'linkupapi-search',
+        'linkupapi-fundraising',
+        'linkupapi-hiring',
+        'prospeo-search-company',
+        'ai-ark-companies',
+      ])
+    })
+
+    it('PDL uses POST to /pdl/company/search', () => {
+      const pdl = getProviders('search_companies').find((p) => p.id === 'pdl')!
+      expect(pdl.endpoint).toBe('/pdl/company/search')
+      expect(pdl.method).toBe('POST')
+    })
+  })
+
+  describe('find_people mapParams', () => {
+    it('LeadsFactory keeps distinct roles as separate personas (seniority not forwarded)', () => {
+      const providers = getProviders('find_people')
+      const lf = providers.find((p) => p.id === 'leadsfactory')!
+      const result = lf.mapParams({
+        company_domains: ['microsoft.com'],
+        job_titles: ['CEO', 'CRO'],
+        seniorities: ['C-suite'],   // must NOT be forwarded
+        limit: 5,
+      })
+      expect(result.body).toEqual({
+        company_domains: ['microsoft.com'],
+        search: {
+          max_persona_results: 5,
+          personas: [{ job_title: 'CEO' }, { job_title: 'CRO' }],
+        },
+      })
+    })
+
+    it('LeadsFactory defaults to Decision Maker persona when no job titles provided', () => {
+      const providers = getProviders('find_people')
+      const lf = providers.find((p) => p.id === 'leadsfactory')!
+      const result = lf.mapParams({ company_domains: ['coldiq.com'], limit: 3 })
+      expect(result.body).toEqual({
+        company_domains: ['coldiq.com'],
+        search: {
+          max_persona_results: 3,
+          personas: [{ job_title: 'Decision Maker' }],
+        },
+      })
+    })
+
+    it('LeadsFactory omits company_domains when LinkedIn URLs are provided', () => {
+      const providers = getProviders('find_people')
+      const lf = providers.find((p) => p.id === 'leadsfactory')!
+      const result = lf.mapParams({
+        company_linkedin_urls: ['https://linkedin.com/company/microsoft'],
+        company_domains: ['microsoft.com'],
+        job_titles: ['CEO'],
+        limit: 5,
+      })
+      expect(result.body).toEqual({
+        company_linkedin_urls: ['https://linkedin.com/company/microsoft'],
+        search: {
+          max_persona_results: 5,
+          personas: [{ job_title: 'CEO' }],
+        },
+      })
+    })
+
+    it('LeadsFactory falls back to company_domains when no LinkedIn URLs', () => {
+      const providers = getProviders('find_people')
+      const lf = providers.find((p) => p.id === 'leadsfactory')!
+      const result = lf.mapParams({
+        company_domains: ['coldiq.com'],
+        job_titles: ['CEO'],
+        limit: 3,
+      })
+      expect((result.body as Record<string, unknown>).company_domains).toEqual(['coldiq.com'])
+      expect((result.body as Record<string, unknown>).company_linkedin_urls).toBeUndefined()
+    })
+
+    it('LeadsFactory has async config', () => {
+      const providers = getProviders('find_people')
+      const lf = providers.find((p) => p.id === 'leadsfactory')!
+      expect(lf.async).toBeDefined()
+      expect(lf.async!.pollIntervalMs).toBe(15000)
+      expect(lf.async!.timeoutMs).toBe(300_000)
+    })
+
+    it('Apollo maps correctly', () => {
+      const providers = getProviders('find_people')
+      const apollo = providers.find((p) => p.id === 'apollo')!
+      const result = apollo.mapParams({
+        company_domains: ['microsoft.com'],
+        job_titles: ['CEO'],
+        seniorities: ['c_suite'],
+        limit: 10,
+      })
+      expect(result.body).toEqual({
+        person_titles: ['CEO'],
+        q_organization_domains: ['microsoft.com'],
+        person_seniorities: ['c_suite'],
+        person_locations: undefined,
+        q_keywords: undefined,
+        per_page: 10,
+      })
+    })
+
+    it('PDL uses POST to /pdl/person/search', () => {
+      const pdl = getProviders('find_people').find((p) => p.id === 'pdl')!
+      expect(pdl.endpoint).toBe('/pdl/person/search')
+      expect(pdl.method).toBe('POST')
+    })
+  })
+
+  describe('find_email mapParams', () => {
+    it('FindyMail maps name + domain', () => {
+      const providers = getProviders('find_email')
+      const fm = providers.find((p) => p.id === 'findymail')!
+      const result = fm.mapParams({
+        first_name: 'Michel',
+        last_name: 'Lieben',
+        domain: 'coldiq.com',
+      })
+      expect(result.body).toEqual({ name: 'Michel Lieben', domain: 'coldiq.com' })
+    })
+
+    it('IcyPeas maps correctly', () => {
+      const providers = getProviders('find_email')
+      const icy = providers.find((p) => p.id === 'icypeas')!
+      const result = icy.mapParams({
+        first_name: 'Michel',
+        last_name: 'Lieben',
+        domain: 'coldiq.com',
+      })
+      expect(result.body).toEqual({
+        firstname: 'Michel',
+        lastname: 'Lieben',
+        domainOrCompany: 'coldiq.com',
+      })
+    })
+
+    it('Prospeo maps with linkedin_url when provided', () => {
+      const providers = getProviders('find_email')
+      const prospeo = providers.find((p) => p.id === 'prospeo')!
+      const result = prospeo.mapParams({
+        linkedin_url: 'https://linkedin.com/in/michel-lieben',
+      })
+      expect(result.body).toEqual({
+        data: { linkedin_url: 'https://linkedin.com/in/michel-lieben' },
+      })
+    })
+
+    it('Prospeo hasResult detects email nested at person.email.email', () => {
+      const providers = getProviders('find_email')
+      const prospeo = providers.find((p) => p.id === 'prospeo')!
+      expect(prospeo.hasResult({ error: false, person: { email: { email: 'michel@coldiq.com' } } })).toBe(true)
+      expect(prospeo.hasResult({ error: false, person: { email: { email: null } } })).toBe(false)
+      expect(prospeo.hasResult({ error: true })).toBe(false)
+      expect(prospeo.hasResult({ email: null })).toBe(false)
+    })
+
+    it('FullEnrich maps to batch-of-1 with contact.emails field', () => {
+      const providers = getProviders('find_email')
+      const fe = providers.find((p) => p.id === 'fullenrich')!
+      const result = fe.mapParams({
+        first_name: 'Michel',
+        last_name: 'Lieben',
+        domain: 'coldiq.com',
+        linkedin_url: 'https://linkedin.com/in/michel-lieben',
+      })
+      expect(result.body).toEqual({
+        name: 'mcp-enrich',
+        data: [{
+          first_name: 'Michel',
+          last_name: 'Lieben',
+          domain: 'coldiq.com',
+          linkedin_url: 'https://linkedin.com/in/michel-lieben',
+          enrich_fields: ['contact.emails'],
+        }],
+      })
+    })
+
+    it('FullEnrich hasResult detects email in data[0].emails array', () => {
+      const providers = getProviders('find_email')
+      const fe = providers.find((p) => p.id === 'fullenrich')!
+      expect(fe.hasResult({ status: 'DONE', data: [{ emails: ['michel@coldiq.com'] }] })).toBe(true)
+      expect(fe.hasResult({ status: 'DONE', data: [{ emails: [] }] })).toBe(false)
+      expect(fe.hasResult({ status: 'DONE', data: [] })).toBe(false)
+      expect(fe.hasResult({ status: 'FAILED', data: [] })).toBe(false)
+    })
+
+    it('FullEnrich has async config with correct poll endpoint', () => {
+      const providers = getProviders('find_email')
+      const fe = providers.find((p) => p.id === 'fullenrich')!
+      expect(fe.async).toBeDefined()
+      expect(fe.async!.pollEndpoint('abc-123')).toBe('/fullenrich/contact/enrich/bulk/abc-123')
+      expect(fe.async!.isComplete({ status: 'DONE' })).toBe(true)
+      expect(fe.async!.isComplete({ status: 'FAILED' })).toBe(true)
+      expect(fe.async!.isComplete({ status: 'IN_PROGRESS' })).toBe(false)
+      expect(fe.async!.extractId({ enrichment_id: 'abc-123' })).toBe('abc-123')
+    })
+
+    it('FullEnrich is priority 6 and LinkupAPI is priority 8 in the new 8-provider chain', () => {
+      const providers = getProviders('find_email')
+      const fe = providers.find((p) => p.id === 'fullenrich')!
+      const lu = providers.find((p) => p.id === 'linkupapi')!
+      expect(fe.priority).toBe(6)
+      expect(lu.priority).toBe(8)
+    })
+
+    it('LimaData work-email maps full_name + company_domain', () => {
+      const providers = getProviders('find_email')
+      const ld = providers.find((p) => p.id === 'limadata-work-email')!
+      const result = ld.mapParams({
+        first_name: 'Michel',
+        last_name: 'Lieben',
+        domain: 'coldiq.com',
+      })
+      expect(result.body).toEqual({ full_name: 'Michel Lieben', company_domain: 'coldiq.com' })
+    })
+
+    it('LimaData work-email hasResult accepts top-level email or nested data.email or emails array', () => {
+      const providers = getProviders('find_email')
+      const ld = providers.find((p) => p.id === 'limadata-work-email')!
+      expect(ld.hasResult({ email: 'michel@coldiq.com' })).toBe(true)
+      expect(ld.hasResult({ data: { email: 'michel@coldiq.com' } })).toBe(true)
+      expect(ld.hasResult({ emails: ['michel@coldiq.com'] })).toBe(true)
+      expect(ld.hasResult({ email: null })).toBe(false)
+      expect(ld.hasResult({})).toBe(false)
+    })
+
+    it('BlitzAPI maps person_linkedin_url from linkedin_url input', () => {
+      const providers = getProviders('find_email')
+      const blitz = providers.find((p) => p.id === 'blitzapi')!
+      const result = blitz.mapParams({
+        linkedin_url: 'https://linkedin.com/in/michel-lieben',
+      })
+      expect(result.body).toEqual({ person_linkedin_url: 'https://linkedin.com/in/michel-lieben' })
+    })
+
+    it('BlitzAPI isApplicable requires linkedin_url', () => {
+      const providers = getProviders('find_email')
+      const blitz = providers.find((p) => p.id === 'blitzapi')!
+      expect(blitz.isApplicable!({})).toBe(false)
+      expect(blitz.isApplicable!({ first_name: 'Michel', domain: 'coldiq.com' })).toBe(false)
+      expect(blitz.isApplicable!({ linkedin_url: 'https://...' })).toBe(true)
+    })
+
+    it('BlitzAPI hasResult checks top-level email', () => {
+      const providers = getProviders('find_email')
+      const blitz = providers.find((p) => p.id === 'blitzapi')!
+      expect(blitz.hasResult({ email: 'michel@coldiq.com' })).toBe(true)
+      expect(blitz.hasResult({ email: null })).toBe(false)
+    })
+
+    it('LimaData work-email-linkedin maps linkedin_url passthrough', () => {
+      const providers = getProviders('find_email')
+      const ld = providers.find((p) => p.id === 'limadata-work-email-linkedin')!
+      const result = ld.mapParams({
+        linkedin_url: 'https://linkedin.com/in/michel-lieben',
+      })
+      expect(result.body).toEqual({ linkedin_url: 'https://linkedin.com/in/michel-lieben' })
+    })
+
+    it('LimaData work-email-linkedin isApplicable requires linkedin_url', () => {
+      const providers = getProviders('find_email')
+      const ld = providers.find((p) => p.id === 'limadata-work-email-linkedin')!
+      expect(ld.isApplicable!({})).toBe(false)
+      expect(ld.isApplicable!({ first_name: 'Michel', domain: 'coldiq.com' })).toBe(false)
+      expect(ld.isApplicable!({ linkedin_url: 'https://...' })).toBe(true)
+    })
+
+    it('LimaData work-email isApplicable requires first_name + last_name + domain', () => {
+      const providers = getProviders('find_email')
+      const ld = providers.find((p) => p.id === 'limadata-work-email')!
+      expect(ld.isApplicable!({})).toBe(false)
+      expect(ld.isApplicable!({ first_name: 'Michel' })).toBe(false)
+      expect(ld.isApplicable!({ first_name: 'Michel', last_name: 'Lieben' })).toBe(false)
+      expect(ld.isApplicable!({ first_name: 'Michel', last_name: 'Lieben', domain: 'coldiq.com' })).toBe(true)
+    })
+  })
+
+  describe('verify_email', () => {
+    it('providers are ordered findymail → icypeas → instantly → linkupapi-validate', () => {
+      expect(getProviders('verify_email').map((p) => p.id)).toEqual(['findymail', 'icypeas', 'instantly', 'linkupapi-validate'])
+    })
+
+    it('FindyMail hasResult accepts verified field', () => {
+      const providers = getProviders('verify_email')
+      const fm = providers.find((p) => p.id === 'findymail')!
+      // Findymail verify returns { email, verified: boolean, provider }
+      expect(fm.hasResult({ email: 'michel@coldiq.com', verified: true, provider: 'Google' })).toBe(true)
+      expect(fm.hasResult({ email: 'michel@coldiq.com', verified: false, provider: 'Google' })).toBe(true)
+      expect(fm.hasResult({})).toBe(false)
+      expect(fm.hasResult({ email: 'michel@coldiq.com' })).toBe(false)
+    })
+
+    it('IcyPeas hasResult accepts success field', () => {
+      const providers = getProviders('verify_email')
+      const icy = providers.find((p) => p.id === 'icypeas')!
+      // IcyPeas verify returns { success: boolean, item: { _id, status } }
+      expect(icy.hasResult({ success: true, item: { _id: 'abc', status: 'NONE' } })).toBe(true)
+      expect(icy.hasResult({ success: false })).toBe(true)
+      expect(icy.hasResult({})).toBe(false)
+      expect(icy.hasResult({ item: { status: 'NONE' } })).toBe(false)
+    })
+
+    it('Instantly mapParams forwards email', () => {
+      const inst = getProviders('verify_email').find((p) => p.id === 'instantly')!
+      expect(inst.mapParams({ email: 'michel@coldiq.com' }).body).toEqual({ email: 'michel@coldiq.com' })
+    })
+
+    it('Instantly hasResult accepts known terminal statuses', () => {
+      const inst = getProviders('verify_email').find((p) => p.id === 'instantly')!
+      expect(inst.hasResult({ email: 'michel@coldiq.com', status: 'valid' })).toBe(true)
+      expect(inst.hasResult({ email: 'michel@coldiq.com', status: 'invalid' })).toBe(true)
+      expect(inst.hasResult({ email: 'michel@coldiq.com', status: 'unknown' })).toBe(true)
+      expect(inst.hasResult({ email: 'michel@coldiq.com', status: 'risky' })).toBe(true)
+      expect(inst.hasResult({ email: 'michel@coldiq.com', status: 'catch_all' })).toBe(true)
+      expect(inst.hasResult({ email: 'michel@coldiq.com', status: 'disposable' })).toBe(true)
+      expect(inst.hasResult({ email: 'michel@coldiq.com', status: 'pending' })).toBe(false)
+      expect(inst.hasResult({ email: 'michel@coldiq.com' })).toBe(false)
+      expect(inst.hasResult({})).toBe(false)
+    })
+
+    it('Instantly async config extracts email as job ID and polls correctly', () => {
+      const inst = getProviders('verify_email').find((p) => p.id === 'instantly')!
+      expect(inst.async).toBeDefined()
+      expect(inst.async!.extractId({ email: 'michel@coldiq.com', status: 'pending' })).toBe('michel@coldiq.com')
+      expect(inst.async!.pollEndpoint('michel@coldiq.com')).toBe('/instantly/email-verification/michel%40coldiq.com')
+      expect(inst.async!.isComplete({ status: 'valid' })).toBe(true)
+      expect(inst.async!.isComplete({ status: 'invalid' })).toBe(true)
+      expect(inst.async!.isComplete({ status: 'pending' })).toBe(false)
+      expect(inst.async!.isComplete({})).toBe(false)
+    })
+
+    it('Instantly async config throws when email missing from create response', () => {
+      const inst = getProviders('verify_email').find((p) => p.id === 'instantly')!
+      expect(() => inst.async!.extractId({})).toThrow('no email field')
+    })
+  })
+
+  describe('enrich_company', () => {
+    it('providers are ordered companyenrich → pdl → apollo → limadata → prospeo → companyenrich_props → blitzapi → wiza → findymail → icypeas → builtwith → openmart → linkupapi-by-domain → linkupapi-by-url', () => {
+      const ids = getProviders('enrich_company').map((p) => p.id)
+      expect(ids).toEqual([
+        'companyenrich', 'pdl', 'apollo', 'limadata', 'prospeo',
+        'companyenrich_props', 'blitzapi', 'wiza', 'findymail', 'icypeas',
+        'builtwith', 'openmart', 'linkupapi-by-domain', 'linkupapi-by-url',
+      ])
+    })
+
+    it('CompanyEnrich uses GET with queryParams and is gated on domain', () => {
+      const ce = getProviders('enrich_company').find((p) => p.id === 'companyenrich')!
+      expect(ce.method).toBe('GET')
+      expect(ce.mapParams({ domain: 'stripe.com' }).queryParams).toEqual({ domain: 'stripe.com' })
+      expect(ce.isApplicable!({ domain: 'stripe.com' })).toBe(true)
+      expect(ce.isApplicable!({ linkedin_url: 'https://linkedin.com/company/stripe' })).toBe(false)
+      expect(ce.isApplicable!({})).toBe(false)
+    })
+
+    it('Apollo uses POST with body and is gated on domain', () => {
+      const apollo = getProviders('enrich_company').find((p) => p.id === 'apollo')!
+      expect(apollo.method).toBe('POST')
+      expect(apollo.mapParams({ domain: 'stripe.com' }).body).toEqual({ domain: 'stripe.com' })
+      expect(apollo.isApplicable!({ domain: 'stripe.com' })).toBe(true)
+      expect(apollo.isApplicable!({ name: 'Stripe' })).toBe(false)
+    })
+
+    it('PDL uses GET with correct path and maps all identifier types', () => {
+      const pdl = getProviders('enrich_company').find((p) => p.id === 'pdl')!
+      expect(pdl.endpoint).toBe('/pdl/company/enrich')
+      expect(pdl.method).toBe('GET')
+      expect(pdl.mapParams({ domain: 'stripe.com' }).queryParams).toEqual({ website: 'stripe.com' })
+      expect(pdl.mapParams({ linkedin_url: 'https://linkedin.com/company/stripe' }).queryParams).toEqual({ profile: 'https://linkedin.com/company/stripe' })
+      expect(pdl.mapParams({ name: 'Stripe' }).queryParams).toEqual({ name: 'Stripe' })
+      expect(pdl.mapParams({ domain: 'stripe.com', linkedin_url: 'https://linkedin.com/company/stripe', name: 'Stripe' }).queryParams).toEqual({
+        website: 'stripe.com',
+        profile: 'https://linkedin.com/company/stripe',
+        name: 'Stripe',
+      })
+      expect(pdl.isApplicable).toBeUndefined()
+    })
+
+    it('Findymail maps all identifier types and has no gate', () => {
+      const fm = getProviders('enrich_company').find((p) => p.id === 'findymail')!
+      expect(fm.method).toBe('POST')
+      expect(fm.mapParams({ domain: 'stripe.com' }).body).toEqual({ domain: 'stripe.com' })
+      expect(fm.mapParams({ linkedin_url: 'https://linkedin.com/company/stripe' }).body).toEqual({ linkedin_url: 'https://linkedin.com/company/stripe' })
+      expect(fm.mapParams({ name: 'Stripe' }).body).toEqual({ name: 'Stripe' })
+      expect(fm.isApplicable).toBeUndefined()
+    })
+
+    it('Wiza is gated on domain or name and maps accordingly', () => {
+      const wiza = getProviders('enrich_company').find((p) => p.id === 'wiza')!
+      expect(wiza.isApplicable!({ domain: 'stripe.com' })).toBe(true)
+      expect(wiza.isApplicable!({ name: 'Stripe' })).toBe(true)
+      expect(wiza.isApplicable!({ linkedin_url: 'https://linkedin.com/company/stripe' })).toBe(false)
+      expect(wiza.mapParams({ domain: 'stripe.com' }).body).toEqual({ company_domain: 'stripe.com' })
+      expect(wiza.mapParams({ name: 'Stripe' }).body).toEqual({ company_name: 'Stripe' })
+    })
+
+    it('LimaData is gated on domain or linkedin_url', () => {
+      const ld = getProviders('enrich_company').find((p) => p.id === 'limadata')!
+      expect(ld.isApplicable!({ domain: 'stripe.com' })).toBe(true)
+      expect(ld.isApplicable!({ linkedin_url: 'https://linkedin.com/company/stripe' })).toBe(true)
+      expect(ld.isApplicable!({ name: 'Stripe' })).toBe(false)
+      expect(ld.mapParams({ domain: 'stripe.com' }).body).toEqual({ domain: 'stripe.com' })
+      expect(ld.mapParams({ linkedin_url: 'https://linkedin.com/company/stripe' }).body).toEqual({ linkedin_url: 'https://linkedin.com/company/stripe' })
+    })
+
+    it('Prospeo wraps all identifiers under data object and has no gate', () => {
+      const pr = getProviders('enrich_company').find((p) => p.id === 'prospeo')!
+      expect(pr.isApplicable).toBeUndefined()
+      expect(pr.mapParams({ domain: 'stripe.com' }).body).toEqual({ data: { company_website: 'stripe.com' } })
+      expect(pr.mapParams({ linkedin_url: 'https://linkedin.com/company/stripe' }).body).toEqual({ data: { company_linkedin_url: 'https://linkedin.com/company/stripe' } })
+      expect(pr.mapParams({ name: 'Stripe' }).body).toEqual({ data: { company_name: 'Stripe' } })
+    })
+
+    it('Prospeo hasResult detects success via response field', () => {
+      const pr = getProviders('enrich_company').find((p) => p.id === 'prospeo')!
+      expect(pr.hasResult({ error: false, response: { name: 'Stripe' } })).toBe(true)
+      expect(pr.hasResult({ error: true })).toBe(false)
+      expect(pr.hasResult({ response: null })).toBe(false)
+    })
+
+    it('CompanyEnrich POST maps name and linkedinUrl (camelCase)', () => {
+      const cp = getProviders('enrich_company').find((p) => p.id === 'companyenrich_props')!
+      expect(cp.method).toBe('POST')
+      expect(cp.isApplicable!({ name: 'Stripe' })).toBe(true)
+      expect(cp.isApplicable!({ linkedin_url: 'https://linkedin.com/company/stripe' })).toBe(true)
+      expect(cp.isApplicable!({ domain: 'stripe.com' })).toBe(false)
+      expect(cp.mapParams({ name: 'Stripe' }).body).toEqual({ name: 'Stripe' })
+      expect(cp.mapParams({ linkedin_url: 'https://linkedin.com/company/stripe' }).body).toEqual({ linkedinUrl: 'https://linkedin.com/company/stripe' })
+    })
+
+    it('BlitzAPI is gated on linkedin_url and passes company_linkedin_url', () => {
+      const bz = getProviders('enrich_company').find((p) => p.id === 'blitzapi')!
+      expect(bz.isApplicable!({ linkedin_url: 'https://linkedin.com/company/stripe' })).toBe(true)
+      expect(bz.isApplicable!({ domain: 'stripe.com' })).toBe(false)
+      expect(bz.mapParams({ linkedin_url: 'https://linkedin.com/company/stripe' }).body).toEqual({ company_linkedin_url: 'https://linkedin.com/company/stripe' })
+    })
+
+    it('Icypeas is gated on linkedin_url and passes url', () => {
+      const ic = getProviders('enrich_company').find((p) => p.id === 'icypeas')!
+      expect(ic.isApplicable!({ linkedin_url: 'https://linkedin.com/company/stripe' })).toBe(true)
+      expect(ic.isApplicable!({ domain: 'stripe.com' })).toBe(false)
+      expect(ic.mapParams({ linkedin_url: 'https://linkedin.com/company/stripe' }).body).toEqual({ url: 'https://linkedin.com/company/stripe' })
+    })
+
+    it('Wiza hasResult checks data.domain / data.industry / data.description', () => {
+      const wiza = getProviders('enrich_company').find((p) => p.id === 'wiza')!
+      expect(wiza.hasResult({ data: { domain: 'stripe.com' } })).toBe(true)
+      expect(wiza.hasResult({ data: { industry: 'fintech' } })).toBe(true)
+      expect(wiza.hasResult({ data: {} })).toBe(false)
+      expect(wiza.hasResult({})).toBe(false)
+    })
+
+    it('BuiltWith uses POST, gated on domain, body { domain }', () => {
+      const bw = getProviders('enrich_company').find((p) => p.id === 'builtwith')!
+      expect(bw.method).toBe('POST')
+      expect(bw.endpoint).toBe('/builtwith/domain')
+      expect(bw.isApplicable!({ domain: 'coldiq.com' })).toBe(true)
+      expect(bw.isApplicable!({ linkedin_url: 'https://linkedin.com/company/coldiq' })).toBe(false)
+      expect(bw.isApplicable!({ name: 'ColdIQ' })).toBe(false)
+      expect(bw.isApplicable!({})).toBe(false)
+      expect(bw.mapParams({ domain: 'coldiq.com' }).body).toEqual({ domain: 'coldiq.com' })
+    })
+
+    it('BuiltWith hasResult requires Results[0].Result.Paths non-empty', () => {
+      const bw = getProviders('enrich_company').find((p) => p.id === 'builtwith')!
+      expect(bw.hasResult({
+        Results: [{ Result: { Lookup: 'coldiq.com', Paths: [{ Technologies: [{ Name: 'Hubspot' }] }] } }],
+      })).toBe(true)
+      expect(bw.hasResult({ Results: [{ Result: { Lookup: 'coldiq.com', Paths: [] } }] })).toBe(false)
+      expect(bw.hasResult({ Results: [{ Result: { Lookup: 'coldiq.com' } }] })).toBe(false)
+      expect(bw.hasResult({ Results: [] })).toBe(false)
+      expect(bw.hasResult({})).toBe(false)
+    })
+
+    it('Openmart uses POST, gated on domain, body { website, limit: 1 }', () => {
+      const om = getProviders('enrich_company').find((p) => p.id === 'openmart')!
+      expect(om.method).toBe('POST')
+      expect(om.endpoint).toBe('/openmart/enrich_company')
+      expect(om.isApplicable!({ domain: 'coldiq.com' })).toBe(true)
+      expect(om.isApplicable!({ linkedin_url: 'https://linkedin.com/company/coldiq' })).toBe(false)
+      expect(om.isApplicable!({ name: 'ColdIQ' })).toBe(false)
+      expect(om.isApplicable!({})).toBe(false)
+      expect(om.mapParams({ domain: 'coldiq.com' }).body).toEqual({ website: 'coldiq.com', limit: 1 })
+    })
+
+    it('Openmart hasResult accepts bare array, { data: [...] }, or { results: [...] }', () => {
+      const om = getProviders('enrich_company').find((p) => p.id === 'openmart')!
+      expect(om.hasResult([{ name: 'ColdIQ' }])).toBe(true)
+      expect(om.hasResult({ data: [{ name: 'ColdIQ' }] })).toBe(true)
+      expect(om.hasResult({ results: [{ name: 'ColdIQ' }] })).toBe(true)
+      expect(om.hasResult([])).toBe(false)
+      expect(om.hasResult({ data: [] })).toBe(false)
+      expect(om.hasResult({})).toBe(false)
+    })
+  })
+
+  describe('find_phone', () => {
+    it('providers are ordered findymail → limadata → ai-ark', () => {
+      const providers = getProviders('find_phone')
+      expect(providers.map((p) => p.id)).toEqual(['findymail', 'limadata', 'ai-ark'])
+    })
+
+    it('Findymail isApplicable requires linkedin_url', () => {
+      const fm = getProviders('find_phone').find((p) => p.id === 'findymail')!
+      expect(fm.isApplicable!({})).toBe(false)
+      expect(fm.isApplicable!({ first_name: 'Michel', last_name: 'Lieben', company_domain: 'coldiq.com' })).toBe(false)
+      expect(fm.isApplicable!({ linkedin_url: 'https://linkedin.com/in/michel-lieben' })).toBe(true)
+    })
+
+    it('Findymail mapParams passes linkedin_url', () => {
+      const fm = getProviders('find_phone').find((p) => p.id === 'findymail')!
+      expect(fm.mapParams({ linkedin_url: 'https://linkedin.com/in/michel-lieben' }).body).toEqual({
+        linkedin_url: 'https://linkedin.com/in/michel-lieben',
+      })
+    })
+
+    it('Findymail hasResult accepts top-level phone or phones array', () => {
+      const fm = getProviders('find_phone').find((p) => p.id === 'findymail')!
+      expect(fm.hasResult({ phone: '+33612345678' })).toBe(true)
+      expect(fm.hasResult({ phones: ['+33612345678'] })).toBe(true)
+      expect(fm.hasResult({})).toBe(false)
+      expect(fm.hasResult({ phone: null })).toBe(false)
+      expect(fm.hasResult({ phones: [] })).toBe(false)
+    })
+
+    it('LimaData isApplicable accepts linkedin_url or name+company', () => {
+      const ld = getProviders('find_phone').find((p) => p.id === 'limadata')!
+      expect(ld.isApplicable!({})).toBe(false)
+      expect(ld.isApplicable!({ first_name: 'Michel' })).toBe(false)
+      expect(ld.isApplicable!({ first_name: 'Michel', last_name: 'Lieben' })).toBe(false)
+      expect(ld.isApplicable!({ linkedin_url: 'https://linkedin.com/in/michel-lieben' })).toBe(true)
+      expect(ld.isApplicable!({ first_name: 'Michel', last_name: 'Lieben', company_name: 'ColdIQ' })).toBe(true)
+      expect(ld.isApplicable!({ first_name: 'Michel', last_name: 'Lieben', company_domain: 'coldiq.com' })).toBe(true)
+    })
+
+    it('LimaData mapParams forwards linkedin_url path', () => {
+      const ld = getProviders('find_phone').find((p) => p.id === 'limadata')!
+      expect(ld.mapParams({ linkedin_url: 'https://linkedin.com/in/michel-lieben' }).body).toEqual({
+        linkedin_url: 'https://linkedin.com/in/michel-lieben',
+      })
+    })
+
+    it('LimaData mapParams forwards name+company path', () => {
+      const ld = getProviders('find_phone').find((p) => p.id === 'limadata')!
+      expect(ld.mapParams({ first_name: 'Michel', last_name: 'Lieben', company_domain: 'coldiq.com' }).body).toEqual({
+        name: 'Michel Lieben',
+        company_domain: 'coldiq.com',
+      })
+    })
+
+    it('LimaData mapParams forwards company_name when no domain', () => {
+      const ld = getProviders('find_phone').find((p) => p.id === 'limadata')!
+      expect(ld.mapParams({ first_name: 'Michel', last_name: 'Lieben', company_name: 'ColdIQ' }).body).toEqual({
+        name: 'Michel Lieben',
+        company_name: 'ColdIQ',
+      })
+    })
+
+    it('LimaData hasResult checks multiple phone shapes including phone_numbers', () => {
+      const ld = getProviders('find_phone').find((p) => p.id === 'limadata')!
+      expect(ld.hasResult({ phone: '+33612345678' })).toBe(true)
+      expect(ld.hasResult({ phones: ['+33612345678'] })).toBe(true)
+      expect(ld.hasResult({ phone_numbers: [{ number: '+33612345678' }] })).toBe(true)
+      expect(ld.hasResult({ data: { phone: '+33612345678' } })).toBe(true)
+      expect(ld.hasResult({ data: { phones: ['+33612345678'] } })).toBe(true)
+      expect(ld.hasResult({ data: { phone_numbers: [{ number: '+33612345678' }] } })).toBe(true)
+      expect(ld.hasResult({})).toBe(false)
+      expect(ld.hasResult({ phone: '' })).toBe(false)
+      expect(ld.hasResult({ phones: [] })).toBe(false)
+      expect(ld.hasResult({ phone_numbers: [] })).toBe(false)
+      expect(ld.hasResult({ data: {} })).toBe(false)
+    })
+
+    it('AI Ark isApplicable accepts linkedin_url or name+company_domain (not company_name)', () => {
+      const ark = getProviders('find_phone').find((p) => p.id === 'ai-ark')!
+      expect(ark.isApplicable!({})).toBe(false)
+      expect(ark.isApplicable!({ first_name: 'Michel', last_name: 'Lieben', company_name: 'ColdIQ' })).toBe(false)
+      expect(ark.isApplicable!({ linkedin_url: 'https://linkedin.com/in/michel-lieben' })).toBe(true)
+      expect(ark.isApplicable!({ first_name: 'Michel', last_name: 'Lieben', company_domain: 'coldiq.com' })).toBe(true)
+    })
+
+    it('AI Ark mapParams uses linkedin key (not linkedin_url)', () => {
+      const ark = getProviders('find_phone').find((p) => p.id === 'ai-ark')!
+      expect(ark.mapParams({ linkedin_url: 'https://linkedin.com/in/michel-lieben' }).body).toEqual({
+        linkedin: 'https://linkedin.com/in/michel-lieben',
+      })
+    })
+
+    it('AI Ark mapParams maps name+domain path', () => {
+      const ark = getProviders('find_phone').find((p) => p.id === 'ai-ark')!
+      expect(ark.mapParams({ first_name: 'Michel', last_name: 'Lieben', company_domain: 'coldiq.com' }).body).toEqual({
+        name: 'Michel Lieben',
+        domain: 'coldiq.com',
+      })
+    })
+
+    it('AI Ark hasResult requires non-empty inner string arrays in data', () => {
+      const ark = getProviders('find_phone').find((p) => p.id === 'ai-ark')!
+      expect(ark.hasResult({ data: [['+33612345678']] })).toBe(true)
+      expect(ark.hasResult({ data: [['mobile', '+33612345678']] })).toBe(true)
+      expect(ark.hasResult({ data: [] })).toBe(false)
+      expect(ark.hasResult({ data: [[]] })).toBe(false)
+      expect(ark.hasResult({})).toBe(false)
+      expect(ark.hasResult({ data: [[123]] })).toBe(false)
+    })
+  })
+
+  describe('search_web provider ordering', () => {
+    it('default order is serper → limadata → exa → jina', () => {
+      const providers = getSearchWebProviders(false)
+      expect(providers.map((p) => p.id)).toEqual(['serper', 'limadata', 'exa', 'jina'])
+    })
+
+    it('neural mode puts exa first, jina stays at the tail', () => {
+      const providers = getSearchWebProviders(true)
+      expect(providers[0].id).toBe('exa')
+      expect(providers[providers.length - 1].id).toBe('jina')
+    })
+
+    it('Jina uses POST /jina/search, maps query/num_results/country, clamps count to 20', () => {
+      const jina = getProviders('search_web').find((p) => p.id === 'jina')!
+      expect(jina.method).toBe('POST')
+      expect(jina.endpoint).toBe('/jina/search')
+      expect(jina.priority).toBe(4)
+      expect(jina.mapParams({ query: 'B2B SaaS news', num_results: 5, country: 'us' }).body).toEqual({
+        q: 'B2B SaaS news',
+        count: 5,
+        gl: 'us',
+      })
+      // Jina's upstream caps at 20; tool allows up to 100
+      expect((jina.mapParams({ query: 'x', num_results: 100 }).body as { count: number }).count).toBe(20)
+      // Default count when num_results omitted
+      expect((jina.mapParams({ query: 'x' }).body as { count: number }).count).toBe(10)
+    })
+
+    it('Jina hasResult checks data/results array non-empty', () => {
+      const jina = getProviders('search_web').find((p) => p.id === 'jina')!
+      expect(jina.hasResult({ data: [{ title: 'x', url: 'https://x' }] })).toBe(true)
+      expect(jina.hasResult({ results: [{ title: 'x' }] })).toBe(true)
+      expect(jina.hasResult({ data: [] })).toBe(false)
+      expect(jina.hasResult({})).toBe(false)
+    })
+  })
+
+  describe('isoCountryToName', () => {
+    it('converts known alpha-2 codes to English names', () => {
+      expect(isoCountryToName('FR')).toBe('France')
+      expect(isoCountryToName('US')).toBe('United States')
+      expect(isoCountryToName('GB')).toBe('United Kingdom')
+      expect(isoCountryToName('DE')).toBe('Germany')
+    })
+
+    it('passes through unknown alpha-2 codes unchanged', () => {
+      expect(isoCountryToName('XX')).toBe('XX')
+    })
+
+    it('passes through free-text strings unchanged', () => {
+      expect(isoCountryToName('Paris, France')).toBe('Paris, France')
+      expect(isoCountryToName('France')).toBe('France')
+    })
+
+    it('passes through empty string unchanged', () => {
+      expect(isoCountryToName('')).toBe('')
+    })
+
+    it('is case-insensitive for alpha-2 input', () => {
+      expect(isoCountryToName('fr')).toBe('France')
+      expect(isoCountryToName('us')).toBe('United States')
+    })
+  })
+
+  describe('search_companies postFilter and gates', () => {
+    it('Apollo isApplicable: rejects input with min_founded_year', () => {
+      const apollo = getProviders('search_companies').find((p) => p.id === 'apollo')!
+      expect(apollo.isApplicable!({})).toBe(true)
+      expect(apollo.isApplicable!({ keywords: ['SaaS'] })).toBe(true)
+      expect(apollo.isApplicable!({ min_founded_year: 2015 })).toBe(false)
+      expect(apollo.isApplicable!({ max_founded_year: 2020 })).toBe(false)
+      expect(apollo.isApplicable!({ min_founded_year: 2015, max_founded_year: 2020 })).toBe(false)
+    })
+
+    it('TheirStack isApplicable: requires technologies, industries, or funding filters (not keywords alone)', () => {
+      const ts = getProviders('search_companies').find((p) => p.id === 'theirstack')!
+      expect(ts.isApplicable!({})).toBe(false)
+      expect(ts.isApplicable!({ keywords: ['x'] })).toBe(false)
+      expect(ts.isApplicable!({ technologies: ['Salesforce'] })).toBe(true)
+      expect(ts.isApplicable!({ industries: ['y'] })).toBe(true)
+      expect(ts.isApplicable!({ funding_stages: ['seed'] })).toBe(true)
+      expect(ts.isApplicable!({ min_funding_amount: 1_000_000 })).toBe(true)
+      expect(ts.isApplicable!({ max_funding_amount: 50_000_000 })).toBe(true)
+      expect(ts.isApplicable!({ countries: ['FR'] })).toBe(false)
+    })
+
+    it('Wiza isApplicable: fires for min/max_founded_year and funding filters', () => {
+      const wiza = getProviders('search_companies').find((p) => p.id === 'wiza')!
+      expect(wiza.isApplicable!({})).toBe(false)
+      expect(wiza.isApplicable!({ keywords: ['x'] })).toBe(false)
+      expect(wiza.isApplicable!({ min_founded_year: 2015 })).toBe(true)
+      expect(wiza.isApplicable!({ max_founded_year: 2020 })).toBe(true)
+      expect(wiza.isApplicable!({ funding_stages: ['seed'] })).toBe(true)
+      expect(wiza.isApplicable!({ min_funding_amount: 500_000 })).toBe(true)
+      expect(wiza.isApplicable!({ max_funding_amount: 10_000_000 })).toBe(true)
+    })
+
+    it('Apollo postFilter strips accounts key entirely', () => {
+      const apollo = getProviders('search_companies').find((p) => p.id === 'apollo')!
+      const data = { organizations: [{ name: 'ColdIQ' }], accounts: [{ id: 1 }] }
+      const result = apollo.postFilter!(data, {}) as Record<string, unknown>
+      expect(result.accounts).toBeUndefined()
+      expect(Array.isArray(result.organizations)).toBe(true)
+    })
+
+    it('Apollo postFilter drops orgs with estimated_num_employees out of range (present-and-wrong)', () => {
+      const apollo = getProviders('search_companies').find((p) => p.id === 'apollo')!
+      const orgs = [
+        { name: 'A', estimated_num_employees: 100 },
+        { name: 'B', estimated_num_employees: 10 },
+        { name: 'C', estimated_num_employees: 500 },
+        { name: 'D' }, // no field — passes through (lenient)
+      ]
+      const result = apollo.postFilter!({ organizations: orgs }, { min_employees: 50, max_employees: 200 }) as Record<string, unknown>
+      expect(((result.organizations as Array<Record<string, unknown>>).map((o) => o.name))).toEqual(['A', 'D'])
+    })
+
+    it('Apollo postFilter drops orgs whose country is present and wrong (ISO-aware), passes orgs with no country', () => {
+      const apollo = getProviders('search_companies').find((p) => p.id === 'apollo')!
+      const orgs = [
+        { name: 'A', country: 'France' },
+        { name: 'B', country: 'france' },
+        { name: 'C', country: 'Germany' },
+        { name: 'D' }, // no country — passes through (lenient)
+      ]
+      const result = apollo.postFilter!({ organizations: orgs }, { countries: ['FR'] }) as Record<string, unknown>
+      expect(((result.organizations as Array<Record<string, unknown>>).map((o) => o.name))).toEqual(['A', 'B', 'D'])
+    })
+
+    it('Apollo postFilter is a no-op for orgs when no filters are set (only strips accounts)', () => {
+      const apollo = getProviders('search_companies').find((p) => p.id === 'apollo')!
+      const orgs = [{ name: 'A' }, { name: 'B' }]
+      const result = apollo.postFilter!({ organizations: orgs, accounts: [] }, {}) as Record<string, unknown>
+      expect((result.organizations as unknown[]).length).toBe(2)
+      expect(result.accounts).toBeUndefined()
+    })
+
+    it('Apollo hasResult returns false when postFilter empties organizations', () => {
+      const apollo = getProviders('search_companies').find((p) => p.id === 'apollo')!
+      const filtered = apollo.postFilter!({ organizations: [] }, {})
+      expect(apollo.hasResult(filtered)).toBe(false)
+    })
+
+    it('Top-tier providers (companyenrich, fullenrich, pdl, signalbase) have no postFilter', () => {
+      const providers = getProviders('search_companies')
+      for (const id of ['companyenrich', 'fullenrich', 'pdl', 'signalbase']) {
+        const p = providers.find((x) => x.id === id)!
+        expect(p.postFilter, `${id} should not have postFilter`).toBeUndefined()
+      }
+    })
+
+    it('Apollo isApplicable: rejects Phase B filters (technologies, funding, revenue, exclusions, workforce growth, is_hiring)', () => {
+      const apollo = getProviders('search_companies').find((p) => p.id === 'apollo')!
+      expect(apollo.isApplicable!({ keywords: ['SaaS'] })).toBe(true)
+      expect(apollo.isApplicable!({ technologies: ['Salesforce'] })).toBe(false)
+      expect(apollo.isApplicable!({ funding_stages: ['seed'] })).toBe(false)
+      expect(apollo.isApplicable!({ min_funding_amount: 1_000_000 })).toBe(false)
+      expect(apollo.isApplicable!({ max_funding_amount: 50_000_000 })).toBe(false)
+      expect(apollo.isApplicable!({ min_revenue: 500_000 })).toBe(false)
+      expect(apollo.isApplicable!({ max_revenue: 10_000_000 })).toBe(false)
+      expect(apollo.isApplicable!({ exclude_domains: ['competitor.com'] })).toBe(false)
+      expect(apollo.isApplicable!({ exclude_industries: ['Gaming'] })).toBe(false)
+      expect(apollo.isApplicable!({ exclude_countries: ['CN'] })).toBe(false)
+      expect(apollo.isApplicable!({ min_workforce_growth_pct: 10 })).toBe(false)
+      expect(apollo.isApplicable!({ is_hiring: true })).toBe(false)
+    })
+
+    it('SignalBase isApplicable: skips for advanced filters it cannot apply', () => {
+      const signalbase = getProviders('search_companies').find((p) => p.id === 'signalbase')!
+      // Passes for basic filters SignalBase supports
+      expect(signalbase.isApplicable!({})).toBe(true)
+      expect(signalbase.isApplicable!({ keywords: ['SaaS'] })).toBe(true)
+      expect(signalbase.isApplicable!({ countries: ['FR'], min_employees: 50 })).toBe(true)
+      expect(signalbase.isApplicable!({ is_hiring: false })).toBe(true)
+      // Skips for filters SignalBase cannot enforce
+      expect(signalbase.isApplicable!({ technologies: ['Salesforce'] })).toBe(false)
+      expect(signalbase.isApplicable!({ funding_stages: ['series_a'] })).toBe(false)
+      expect(signalbase.isApplicable!({ min_funding_amount: 1_000_000 })).toBe(false)
+      expect(signalbase.isApplicable!({ max_funding_amount: 50_000_000 })).toBe(false)
+      expect(signalbase.isApplicable!({ min_revenue: 500_000 })).toBe(false)
+      expect(signalbase.isApplicable!({ max_revenue: 10_000_000 })).toBe(false)
+      expect(signalbase.isApplicable!({ is_hiring: true })).toBe(false)
+    })
+  })
+
+  describe('search_companies Phase B GTM filters', () => {
+    it('CompanyEnrich maps technologies, fundingAmount, fundingYear, revenue, workforceGrowth, and exclude', () => {
+      const ce = getProviders('search_companies').find((p) => p.id === 'companyenrich')!
+      const result = ce.mapParams({
+        keywords: ['SaaS'],
+        technologies: ['Salesforce', 'HubSpot'],
+        countries: ['US'],
+        min_funding_amount: 1_000_000,
+        max_funding_amount: 50_000_000,
+        min_funding_year: 2020,
+        max_funding_year: 2024,
+        min_revenue: 500_000,
+        max_revenue: 10_000_000,
+        min_workforce_growth_pct: 15,
+        exclude_domains: ['competitor.com'],
+        exclude_industries: ['Gaming'],
+        exclude_countries: ['CN'],
+        limit: 10,
+      })
+      expect(result.body).toEqual({
+        countries: ['US'],
+        keywords: ['SaaS'],
+        technologies: ['Salesforce', 'HubSpot'],
+        employees: undefined,
+        foundedYear: undefined,
+        fundingAmount: { from: 1_000_000, to: 50_000_000 },
+        fundingYear: { from: 2020, to: 2024 },
+        revenue: [{ from: 500_000, to: 10_000_000 }],
+        workforceGrowth: { from: 15 },
+        exclude: { domains: ['competitor.com'], industries: ['Gaming'], countries: ['CN'] },
+        pageSize: 10,
+      })
+    })
+
+    it('CompanyEnrich omits optional Phase B fields when not provided', () => {
+      const ce = getProviders('search_companies').find((p) => p.id === 'companyenrich')!
+      const result = ce.mapParams({ countries: ['US'], limit: 5 })
+      const body = result.body as Record<string, unknown>
+      expect(body.technologies).toBeUndefined()
+      expect(body.fundingAmount).toBeUndefined()
+      expect(body.fundingYear).toBeUndefined()
+      expect(body.revenue).toBeUndefined()
+      expect(body.workforceGrowth).toBeUndefined()
+      expect(body.exclude).toBeUndefined()
+    })
+
+    it('CompanyEnrich exclude object only includes keys that were provided', () => {
+      const ce = getProviders('search_companies').find((p) => p.id === 'companyenrich')!
+      const result = ce.mapParams({ exclude_domains: ['a.com'], limit: 5 })
+      expect((result.body as Record<string, unknown>).exclude).toEqual({ domains: ['a.com'] })
+    })
+
+    it('Wiza mapParams adds funding_stage, funding_min, funding_max in [{v}] shape', () => {
+      const wiza = getProviders('search_companies').find((p) => p.id === 'wiza')!
+      const result = wiza.mapParams({
+        funding_stages: ['seed', 'series_a'],
+        min_funding_amount: 500_000,
+        max_funding_amount: 20_000_000,
+        limit: 25,
+      })
+      expect(result.body).toEqual({
+        list: { name: 'mcp-search-companies', max_profiles: 25 },
+        filters: {
+          funding_stage: [{ v: 'seed' }, { v: 'series_a' }],
+          funding_min: [{ v: '500000' }],
+          funding_max: [{ v: '20000000' }],
+        },
+        enrichment_level: 'none',
+      })
+    })
+
+    it('LimaData passes has_jobs: true when is_hiring is true', () => {
+      const ld = getProviders('search_companies').find((p) => p.id === 'limadata')!
+      const result = ld.mapParams({ keywords: ['SaaS'], is_hiring: true })
+      expect((result.body as Record<string, unknown>).has_jobs).toBe(true)
+    })
+
+    it('LimaData omits has_jobs when is_hiring is false or unset', () => {
+      const ld = getProviders('search_companies').find((p) => p.id === 'limadata')!
+      const falseResult = ld.mapParams({ keywords: ['SaaS'], is_hiring: false })
+      const unsetResult = ld.mapParams({ keywords: ['SaaS'] })
+      expect((falseResult.body as Record<string, unknown>).has_jobs).toBeUndefined()
+      expect((unsetResult.body as Record<string, unknown>).has_jobs).toBeUndefined()
+    })
+  })
+
+  describe('search_jobs', () => {
+    it('providers are ordered career_site_jobs → linkedin_jobs_api → theirstack-jobs', () => {
+      const ids = getProviders('search_jobs').map((p) => p.id)
+      expect(ids).toEqual(['career_site_jobs', 'linkedin_jobs_api', 'theirstack-jobs'])
+    })
+
+    it('Career Site is async POST to /career-site-jobs/search', () => {
+      const cs = getProviders('search_jobs').find((p) => p.id === 'career_site_jobs')!
+      expect(cs.method).toBe('POST')
+      expect(cs.endpoint).toBe('/career-site-jobs/search')
+      expect(cs.async).toBeDefined()
+      expect(cs.async!.pollEndpoint('42')).toBe('/career-site-jobs/search/42')
+      expect(cs.async!.isComplete({ status: 'done' })).toBe(true)
+      expect(cs.async!.isComplete({ status: 'failed' })).toBe(true)
+      expect(cs.async!.isComplete({ status: 'timed_out' })).toBe(true)
+      expect(cs.async!.isComplete({ status: 'processing' })).toBe(false)
+      expect(cs.async!.extractId({ jobId: 99 })).toBe('99')
+      expect(cs.async!.extractId({ jobId: '55' })).toBe('55')
+      expect(() => cs.async!.extractId({ jobId: undefined })).toThrow('no jobId')
+      expect(() => cs.async!.extractId({})).toThrow('no jobId')
+    })
+
+    it('Career Site is skipped when LinkedIn-only filters are set', () => {
+      const cs = getProviders('search_jobs').find((p) => p.id === 'career_site_jobs')!
+      expect(cs.isApplicable!({ title_keywords: ['engineer'] })).toBe(true)
+      expect(cs.isApplicable!({ seniority_levels: ['Director'] })).toBe(false)
+      expect(cs.isApplicable!({ min_employees: 100 })).toBe(false)
+      expect(cs.isApplicable!({ industries: ['Software'] })).toBe(false)
+      expect(cs.isApplicable!({ easy_apply_only: true })).toBe(false)
+      expect(cs.isApplicable!({ easy_apply_only: false })).toBe(true)
+      expect(cs.isApplicable!({ seniority_levels: [] })).toBe(true)
+    })
+
+    it('Career Site mapParams clamps limit to 10–500 and translates field names', () => {
+      const cs = getProviders('search_jobs').find((p) => p.id === 'career_site_jobs')!
+      const out = cs.mapParams({
+        title_keywords: ['sales engineer'],
+        ats_slugs: ['greenhouse'],
+        limit: 9999,
+        time_range: '24h',
+        include_description: true,
+      }).body as Record<string, unknown>
+      expect(out.titleSearch).toEqual(['sales engineer'])
+      expect(out.ats).toEqual(['greenhouse'])
+      expect(out.limit).toBe(500)
+      expect(out.timeRange).toBe('24h')
+      expect(out.descriptionType).toBe('text')
+      expect(out.includeAi).toBe(true)
+    })
+
+    it('Career Site mapParams sets descriptionType undefined when include_description is false', () => {
+      const cs = getProviders('search_jobs').find((p) => p.id === 'career_site_jobs')!
+      const out = cs.mapParams({ include_description: false }).body as Record<string, unknown>
+      expect(out.descriptionType).toBeUndefined()
+    })
+
+    it('Career Site hasResult requires jobs[] non-empty', () => {
+      const cs = getProviders('search_jobs').find((p) => p.id === 'career_site_jobs')!
+      expect(cs.hasResult({ jobs: [{ title: 'SE' }] })).toBe(true)
+      expect(cs.hasResult({ jobs: [] })).toBe(false)
+      expect(cs.hasResult({ status: 'done' })).toBe(false)
+      expect(cs.hasResult({})).toBe(false)
+    })
+
+    it('LinkedIn is async POST to /linkedin-jobs-api/search', () => {
+      const li = getProviders('search_jobs').find((p) => p.id === 'linkedin_jobs_api')!
+      expect(li.method).toBe('POST')
+      expect(li.endpoint).toBe('/linkedin-jobs-api/search')
+      expect(li.async).toBeDefined()
+      expect(li.async!.pollEndpoint('77')).toBe('/linkedin-jobs-api/search/77')
+      expect(li.async!.extractId({ jobId: '55' })).toBe('55')
+    })
+
+    it('LinkedIn is skipped when Career-Site-only filters are set', () => {
+      const li = getProviders('search_jobs').find((p) => p.id === 'linkedin_jobs_api')!
+      expect(li.isApplicable!({ title_keywords: ['engineer'] })).toBe(true)
+      expect(li.isApplicable!({ ats_slugs: ['greenhouse'] })).toBe(false)
+      expect(li.isApplicable!({ company_domains: ['stripe.com'] })).toBe(false)
+      expect(li.isApplicable!({ exclude_ats_slugs: ['lever'] })).toBe(false)
+      expect(li.isApplicable!({ ats_slugs: [] })).toBe(true)
+    })
+
+    it('LinkedIn mapParams uses misspelled locationExclusionSeach and PascalCase EmploymentTypeFilter', () => {
+      const li = getProviders('search_jobs').find((p) => p.id === 'linkedin_jobs_api')!
+      const out = li.mapParams({
+        exclude_locations: ['New York, NY, United States'],
+        employment_types: ['FULL_TIME'],
+        seniority_levels: ['Director'],
+        industries: ['Software Development'],
+        min_employees: 100,
+        max_employees: 5000,
+        limit: 50,
+      }).body as Record<string, unknown>
+      expect(out.locationExclusionSeach).toEqual(['New York, NY, United States'])
+      expect(out.EmploymentTypeFilter).toEqual(['FULL_TIME'])
+      expect(out.seniorityFilter).toEqual(['Director'])
+      expect(out.industryFilter).toEqual(['Software Development'])
+      expect(out.organizationEmployeesGte).toBe(100)
+      expect(out.organizationEmployeesLte).toBe(5000)
+      expect(out.limit).toBe(50)
+      expect(out.excludeATSDuplicate).toBe(true)
+    })
+
+    it('LinkedIn mapParams clamps limit to 10–500 (schema cap, not upstream cap)', () => {
+      const li = getProviders('search_jobs').find((p) => p.id === 'linkedin_jobs_api')!
+      const hi = li.mapParams({ limit: 99999 }).body as Record<string, unknown>
+      const lo = li.mapParams({ limit: 1 }).body as Record<string, unknown>
+      expect(hi.limit).toBe(500)
+      expect(lo.limit).toBe(10)
+    })
+
+    it('LinkedIn hasResult requires jobs[] non-empty', () => {
+      const li = getProviders('search_jobs').find((p) => p.id === 'linkedin_jobs_api')!
+      expect(li.hasResult({ jobs: [{ id: 1 }] })).toBe(true)
+      expect(li.hasResult({ jobs: [] })).toBe(false)
+      expect(li.hasResult({})).toBe(false)
+    })
+
+    it('LinkedIn mapParams only forwards easy_apply_only/exclude_easy_apply when truthy', () => {
+      const li = getProviders('search_jobs').find((p) => p.id === 'linkedin_jobs_api')!
+      const trueOut = li.mapParams({ easy_apply_only: true, exclude_easy_apply: true }).body as Record<string, unknown>
+      expect(trueOut.directApply).toBe(true)
+      expect(trueOut.noDirectApply).toBe(true)
+      const falseOut = li.mapParams({ easy_apply_only: false, exclude_easy_apply: false }).body as Record<string, unknown>
+      expect(falseOut.directApply).toBeUndefined()
+      expect(falseOut.noDirectApply).toBeUndefined()
+    })
+
+    it('contradictory filter set: both isApplicable return false', () => {
+      const cs = getProviders('search_jobs').find((p) => p.id === 'career_site_jobs')!
+      const li = getProviders('search_jobs').find((p) => p.id === 'linkedin_jobs_api')!
+      const contradictory = { ats_slugs: ['greenhouse'], seniority_levels: ['Director'] }
+      expect(cs.isApplicable!(contradictory)).toBe(false)
+      expect(li.isApplicable!(contradictory)).toBe(false)
+    })
+  })
+
+  describe('search_ads', () => {
+    it('providers are ordered google_ads → linkedin_ad_library → meta_ads → twitter_ads → reddit_ads', () => {
+      const ids = getProviders('search_ads').map((p) => p.id)
+      expect(ids).toEqual(['google_ads', 'linkedin_ad_library', 'meta_ads', 'twitter_ads', 'reddit_ads'])
+    })
+
+    it('google_ads is async POST to /google-ads/search', () => {
+      const g = getProviders('search_ads').find((p) => p.id === 'google_ads')!
+      expect(g.method).toBe('POST')
+      expect(g.endpoint).toBe('/google-ads/search')
+      expect(g.async).toBeDefined()
+      expect(g.async!.pollEndpoint('42')).toBe('/google-ads/search/42')
+      expect(g.async!.isComplete({ status: 'done' })).toBe(true)
+      expect(g.async!.isComplete({ status: 'failed' })).toBe(true)
+      expect(g.async!.isComplete({ status: 'timed_out' })).toBe(true)
+      expect(g.async!.isComplete({ status: 'processing' })).toBe(false)
+      expect(g.async!.extractId({ jobId: 99 })).toBe('99')
+      expect(g.async!.extractId({ jobId: '55' })).toBe('55')
+      expect(() => g.async!.extractId({ jobId: undefined })).toThrow('no jobId')
+      expect(() => g.async!.extractId({})).toThrow('no jobId')
+    })
+
+    it('linkedin_ad_library is async POST to /linkedin-ad-library/search', () => {
+      const li = getProviders('search_ads').find((p) => p.id === 'linkedin_ad_library')!
+      expect(li.method).toBe('POST')
+      expect(li.endpoint).toBe('/linkedin-ad-library/search')
+      expect(li.async!.pollEndpoint('7')).toBe('/linkedin-ad-library/search/7')
+      expect(li.async!.isComplete({ status: 'done' })).toBe(true)
+      expect(li.async!.isComplete({ status: 'processing' })).toBe(false)
+    })
+
+    it('meta_ads is async POST to /meta-ads/search', () => {
+      const m = getProviders('search_ads').find((p) => p.id === 'meta_ads')!
+      expect(m.method).toBe('POST')
+      expect(m.endpoint).toBe('/meta-ads/search')
+      expect(m.async!.pollEndpoint('3')).toBe('/meta-ads/search/3')
+    })
+
+    it('twitter_ads is async POST to /twitter-ads-scraper/search', () => {
+      const t = getProviders('search_ads').find((p) => p.id === 'twitter_ads')!
+      expect(t.method).toBe('POST')
+      expect(t.endpoint).toBe('/twitter-ads-scraper/search')
+      expect(t.async!.pollEndpoint('8')).toBe('/twitter-ads-scraper/search/8')
+    })
+
+    it('reddit_ads is async POST to /reddit-ads/scrape', () => {
+      const r = getProviders('search_ads').find((p) => p.id === 'reddit_ads')!
+      expect(r.method).toBe('POST')
+      expect(r.endpoint).toBe('/reddit-ads/scrape')
+      expect(r.async!.pollEndpoint('5')).toBe('/reddit-ads/scrape/5')
+      expect(r.async!.isComplete({ status: 'done' })).toBe(true)
+      expect(r.async!.isComplete({ status: 'failed' })).toBe(true)
+      expect(r.async!.isComplete({ status: 'timed_out' })).toBe(true)
+      expect(r.async!.isComplete({ status: 'processing' })).toBe(false)
+    })
+
+    it('google_ads.isApplicable: true for query/domains/advertiser_ids, false for empty or wrong platform', () => {
+      const g = getProviders('search_ads').find((p) => p.id === 'google_ads')!
+      expect(g.isApplicable!({ query: 'Salesforce' })).toBe(true)
+      expect(g.isApplicable!({ domains: ['salesforce.com'] })).toBe(true)
+      expect(g.isApplicable!({ advertiser_ids: ['AR123'] })).toBe(true)
+      expect(g.isApplicable!({})).toBe(false)
+      expect(g.isApplicable!({ domains: [] })).toBe(false)
+      expect(g.isApplicable!({ query: 'Salesforce', platform: 'meta' })).toBe(false)
+      expect(g.isApplicable!({ query: 'Salesforce', platform: 'google' })).toBe(true)
+    })
+
+    it('linkedin_ad_library.isApplicable: true only when search_urls non-empty', () => {
+      const li = getProviders('search_ads').find((p) => p.id === 'linkedin_ad_library')!
+      expect(li.isApplicable!({ search_urls: ['https://linkedin.com/ad-library/search?accountOwner=salesforce'] })).toBe(true)
+      expect(li.isApplicable!({ search_urls: [] })).toBe(false)
+      expect(li.isApplicable!({ query: 'Salesforce' })).toBe(false)
+      expect(li.isApplicable!({})).toBe(false)
+      expect(li.isApplicable!({ search_urls: ['https://...'], platform: 'google' })).toBe(false)
+      expect(li.isApplicable!({ search_urls: ['https://...'], platform: 'linkedin' })).toBe(true)
+    })
+
+    it('meta_ads.isApplicable: true for bare query, false when domains/advertiser_ids/search_urls set or wrong platform', () => {
+      const m = getProviders('search_ads').find((p) => p.id === 'meta_ads')!
+      expect(m.isApplicable!({ query: 'HubSpot' })).toBe(true)
+      expect(m.isApplicable!({})).toBe(false)
+      expect(m.isApplicable!({ domains: ['hubspot.com'] })).toBe(false)
+      expect(m.isApplicable!({ advertiser_ids: ['AR123'] })).toBe(false)
+      expect(m.isApplicable!({ search_urls: ['https://linkedin.com/...'] })).toBe(false)
+      expect(m.isApplicable!({ query: 'HubSpot', platform: 'twitter' })).toBe(false)
+      expect(m.isApplicable!({ query: 'HubSpot', platform: 'meta' })).toBe(true)
+    })
+
+    it('twitter_ads.isApplicable: same gating as meta_ads', () => {
+      const t = getProviders('search_ads').find((p) => p.id === 'twitter_ads')!
+      expect(t.isApplicable!({ query: 'ColdIQ' })).toBe(true)
+      expect(t.isApplicable!({})).toBe(false)
+      expect(t.isApplicable!({ domains: ['coldiq.com'] })).toBe(false)
+      expect(t.isApplicable!({ advertiser_ids: ['AR123'] })).toBe(false)
+      expect(t.isApplicable!({ search_urls: ['https://...'] })).toBe(false)
+      expect(t.isApplicable!({ query: 'ColdIQ', platform: 'meta' })).toBe(false)
+      expect(t.isApplicable!({ query: 'ColdIQ', platform: 'twitter' })).toBe(true)
+    })
+
+    it('reddit_ads.isApplicable: true for empty/query, false when domains/advertiser_ids/search_urls set', () => {
+      const r = getProviders('search_ads').find((p) => p.id === 'reddit_ads')!
+      expect(r.isApplicable!({})).toBe(true)
+      expect(r.isApplicable!({ query: 'sales automation' })).toBe(true)
+      expect(r.isApplicable!({ industry: 'TECH_B2B' })).toBe(true)
+      expect(r.isApplicable!({ domains: ['coldiq.com'] })).toBe(false)
+      expect(r.isApplicable!({ advertiser_ids: ['AR123'] })).toBe(false)
+      expect(r.isApplicable!({ search_urls: ['https://...'] })).toBe(false)
+      expect(r.isApplicable!({ platform: 'google' })).toBe(false)
+      expect(r.isApplicable!({ platform: 'reddit' })).toBe(true)
+    })
+
+    it('platform pin: platform=linkedin makes only linkedin_ad_library applicable (even without search_urls it fails the URL check)', () => {
+      const providers = getProviders('search_ads')
+      const pinned = { platform: 'linkedin', query: 'Salesforce' }
+      const applicable = providers.filter((p) => p.isApplicable!(pinned))
+      expect(applicable.map((p) => p.id)).toEqual([])
+      // linkedin_ad_library passes the platform check but fails the search_urls check
+      const li = providers.find((p) => p.id === 'linkedin_ad_library')!
+      expect(li.isApplicable!({ platform: 'linkedin', search_urls: ['https://...'] })).toBe(true)
+    })
+
+    it('google_ads.mapParams: query→searchTerms[], country→region, max_results clamped [1,1000]', () => {
+      const g = getProviders('search_ads').find((p) => p.id === 'google_ads')!
+      const out = g.mapParams({ query: 'Salesforce', country: 'US', max_results: 50 }).body as Record<string, unknown>
+      expect(out.searchTerms).toEqual(['Salesforce'])
+      expect(out.region).toBe('US')
+      expect(out.maxAds).toBe(50)
+
+      const withDomains = g.mapParams({ domains: ['salesforce.com'], advertiser_ids: ['AR123'], max_results: 9999 }).body as Record<string, unknown>
+      expect(withDomains.searchTerms).toBeUndefined()
+      expect(withDomains.domains).toEqual(['salesforce.com'])
+      expect(withDomains.advertiserIds).toEqual(['AR123'])
+      expect(withDomains.maxAds).toBe(1000)
+
+      const minClamp = g.mapParams({ query: 'x', max_results: 0 }).body as Record<string, unknown>
+      expect(minClamp.maxAds).toBe(1)
+    })
+
+    it('linkedin_ad_library.mapParams: search_urls→searchUrls, max_results clamped [1,200]', () => {
+      const li = getProviders('search_ads').find((p) => p.id === 'linkedin_ad_library')!
+      const out = li.mapParams({ search_urls: ['https://linkedin.com/...'], max_results: 50 }).body as Record<string, unknown>
+      expect(out.searchUrls).toEqual(['https://linkedin.com/...'])
+      expect(out.maxResults).toBe(50)
+
+      const capped = li.mapParams({ search_urls: ['https://...'], max_results: 9999 }).body as Record<string, unknown>
+      expect(capped.maxResults).toBe(200)
+    })
+
+    it('meta_ads.mapParams: query→search, defaults country=US/adType=ALL, max_results clamped [1,200]', () => {
+      const m = getProviders('search_ads').find((p) => p.id === 'meta_ads')!
+      const out = m.mapParams({ query: 'HubSpot', max_results: 30 }).body as Record<string, unknown>
+      expect(out.search).toBe('HubSpot')
+      expect(out.country).toBe('US')
+      expect(out.adType).toBe('ALL')
+      expect(out.maxItems).toBe(30)
+
+      const withOverrides = m.mapParams({ query: 'x', country: 'FR', ad_type: 'POLITICAL_AND_ISSUE_ADS', max_results: 9999 }).body as Record<string, unknown>
+      expect(withOverrides.country).toBe('FR')
+      expect(withOverrides.adType).toBe('POLITICAL_AND_ISSUE_ADS')
+      expect(withOverrides.maxItems).toBe(200)
+    })
+
+    it('twitter_ads.mapParams: query→searchTerms[], forwards dates, max_results clamped [1,100]', () => {
+      const t = getProviders('search_ads').find((p) => p.id === 'twitter_ads')!
+      const out = t.mapParams({ query: 'ColdIQ', country: 'US', start_date: '2025-01-01', end_date: '2025-12-31', max_results: 20 }).body as Record<string, unknown>
+      expect(out.searchTerms).toEqual(['ColdIQ'])
+      expect(out.country).toBe('US')
+      expect(out.startDate).toBe('2025-01-01')
+      expect(out.endDate).toBe('2025-12-31')
+      expect(out.maxItems).toBe(20)
+
+      const capped = t.mapParams({ query: 'x', max_results: 9999 }).body as Record<string, unknown>
+      expect(capped.maxItems).toBe(100)
+    })
+
+    it('reddit_ads.mapParams: query→keywords, forwards industry/budget_category/post_type/objective_type', () => {
+      const r = getProviders('search_ads').find((p) => p.id === 'reddit_ads')!
+      const out = r.mapParams({
+        query: 'sales automation',
+        industry: 'TECH_B2B',
+        budget_category: 'HIGH',
+        post_type: 'VIDEO',
+        objective_type: 'CONVERSIONS',
+      }).body as Record<string, unknown>
+      expect(out.keywords).toBe('sales automation')
+      expect(out.industry).toBe('TECH_B2B')
+      expect(out.budgetCategory).toBe('HIGH')
+      expect(out.postType).toBe('VIDEO')
+      expect(out.objectiveType).toBe('CONVERSIONS')
+    })
+
+    it('reddit_ads.mapParams: query is optional (scrape-all)', () => {
+      const r = getProviders('search_ads').find((p) => p.id === 'reddit_ads')!
+      const out = r.mapParams({ industry: 'TECH_B2B' }).body as Record<string, unknown>
+      expect(out.keywords).toBeUndefined()
+      expect(out.industry).toBe('TECH_B2B')
+    })
+
+    it('hasResult requires ads[] non-empty for all 5 providers', () => {
+      const providers = getProviders('search_ads')
+      for (const p of providers) {
+        expect(p.hasResult({ ads: [{ id: '1' }] }), `${p.id} should return true`).toBe(true)
+        expect(p.hasResult({ ads: [] }), `${p.id} should return false for empty`).toBe(false)
+        expect(p.hasResult({}), `${p.id} should return false for no ads key`).toBe(false)
+      }
+    })
+  })
+
+  describe('search_places', () => {
+    it('has exactly 2 providers in order [openmart, google_maps]', () => {
+      const providers = getProviders('search_places')
+      expect(providers.map((p) => p.id)).toEqual(['openmart', 'google_maps'])
+    })
+
+    it('openmart is sync POST to /openmart/search (no async block)', () => {
+      const om = getProviders('search_places').find((p) => p.id === 'openmart')!
+      expect(om.method).toBe('POST')
+      expect(om.endpoint).toBe('/openmart/search')
+      expect(om.async).toBeUndefined()
+    })
+
+    it('google_maps is async POST to /google-maps/scraper', () => {
+      const gm = getProviders('search_places').find((p) => p.id === 'google_maps')!
+      expect(gm.method).toBe('POST')
+      expect(gm.endpoint).toBe('/google-maps/scraper')
+      expect(gm.async!.pollEndpoint('123')).toBe('/google-maps/scraper/123')
+      expect(gm.async!.isComplete({ status: 'done' })).toBe(true)
+      expect(gm.async!.isComplete({ status: 'failed' })).toBe(true)
+      expect(gm.async!.isComplete({ status: 'timed_out' })).toBe(true)
+      expect(gm.async!.isComplete({ status: 'processing' })).toBe(false)
+      expect(gm.async!.extractId({ jobId: 42 })).toBe('42')
+      expect(gm.async!.extractId({ jobId: '7' })).toBe('7')
+      expect(() => gm.async!.extractId({})).toThrow('no jobId')
+      expect(() => gm.async!.extractId({ jobId: undefined })).toThrow('no jobId')
+    })
+
+    it('openmart.isApplicable: true for query/tags/city/Openmart-country, false for outside-whitelist country/Google-only keys/wrong provider/empty input', () => {
+      const om = getProviders('search_places').find((p) => p.id === 'openmart')!
+      expect(om.isApplicable!({ query: 'coffee' })).toBe(true)
+      expect(om.isApplicable!({ tags: ['cafe'] })).toBe(true)
+      expect(om.isApplicable!({ city: 'NYC' })).toBe(true)
+      expect(om.isApplicable!({ country: 'US', query: 'x' })).toBe(true)
+      expect(om.isApplicable!({ country: 'us', query: 'x' })).toBe(true)
+      expect(om.isApplicable!({ ownership_type: 'INDEPENDENT' })).toBe(true)
+      expect(om.isApplicable!({ state: 'CA' })).toBe(true)
+      expect(om.isApplicable!({})).toBe(false)
+      expect(om.isApplicable!({ country: 'FR' })).toBe(false)
+      expect(om.isApplicable!({ country: 'fr', query: 'boulangerie' })).toBe(false)
+      expect(om.isApplicable!({ start_urls: ['https://maps.google.com/...'] })).toBe(false)
+      expect(om.isApplicable!({ include_opening_hours: true })).toBe(false)
+      expect(om.isApplicable!({ include_additional_info: true })).toBe(false)
+      expect(om.isApplicable!({ language: 'en' })).toBe(false)
+      expect(om.isApplicable!({ query: 'coffee', provider: 'google_maps' })).toBe(false)
+      expect(om.isApplicable!({ query: 'coffee', provider: 'openmart' })).toBe(true)
+    })
+
+    it('google_maps.isApplicable: true for query/start_urls/city, false for empty/filter-only/wrong provider', () => {
+      const gm = getProviders('search_places').find((p) => p.id === 'google_maps')!
+      expect(gm.isApplicable!({ query: 'dentist' })).toBe(true)
+      expect(gm.isApplicable!({ start_urls: ['https://maps.google.com/...'] })).toBe(true)
+      expect(gm.isApplicable!({ city: 'Paris' })).toBe(true)
+      expect(gm.isApplicable!({})).toBe(false)
+      expect(gm.isApplicable!({ ownership_type: 'CHAIN' })).toBe(false)
+      expect(gm.isApplicable!({ min_overall_rating: 4 })).toBe(false)
+      expect(gm.isApplicable!({ query: 'pizza', provider: 'openmart' })).toBe(false)
+      expect(gm.isApplicable!({ query: 'pizza', provider: 'google_maps' })).toBe(true)
+    })
+
+    it('provider pin: provider=openmart blocks google_maps; provider=google_maps blocks openmart', () => {
+      const providers = getProviders('search_places')
+      const pinOpenmart = { provider: 'openmart', query: 'cafe' }
+      expect(providers.filter((p) => p.isApplicable!(pinOpenmart)).map((p) => p.id)).toEqual(['openmart'])
+
+      const pinGoogle = { provider: 'google_maps', query: 'cafe', city: 'London' }
+      expect(providers.filter((p) => p.isApplicable!(pinGoogle)).map((p) => p.id)).toEqual(['google_maps'])
+    })
+
+    it('openmart.mapParams: normalizes country to uppercase, builds location from bits, clamps limit to [1,500]', () => {
+      const om = getProviders('search_places').find((p) => p.id === 'openmart')!
+      const out = om.mapParams({ query: 'coffee', country: 'us', city: 'New York', state: 'NY', limit: 10 }).body as Record<string, unknown>
+      expect(out.query).toBe('coffee')
+      expect(out.limit).toBe(10)
+      const loc = out.location as Record<string, unknown>
+      expect(loc.country).toBe('US')
+      expect(loc.city).toBe('New York')
+      expect(loc.state).toBe('NY')
+
+      const noLocation = om.mapParams({ query: 'x' }).body as Record<string, unknown>
+      expect(noLocation.location).toBeUndefined()
+
+      const clamped = om.mapParams({ query: 'x', limit: 9999 }).body as Record<string, unknown>
+      expect(clamped.limit).toBe(500)
+
+      const minClamp = om.mapParams({ query: 'x', limit: 0 }).body as Record<string, unknown>
+      expect(minClamp.limit).toBe(1)
+    })
+
+    it('openmart.mapParams: forwards all structured filters', () => {
+      const om = getProviders('search_places').find((p) => p.id === 'openmart')!
+      const out = om.mapParams({
+        country: 'US',
+        state: 'CA',
+        ownership_type: 'INDEPENDENT',
+        min_overall_rating: 4,
+        max_overall_rating: 5,
+        has_website: true,
+        min_price_tier: 1,
+        max_price_tier: 2,
+        include_keywords: ['organic'],
+        exclude_keywords: ['chain'],
+        exclude_root_domains: ['yelp.com'],
+        limit: 5,
+      }).body as Record<string, unknown>
+      expect(out.ownership_type).toBe('INDEPENDENT')
+      expect(out.min_overall_rating).toBe(4)
+      expect(out.max_overall_rating).toBe(5)
+      expect(out.has_website).toBe(true)
+      expect(out.min_price_tier).toBe(1)
+      expect(out.max_price_tier).toBe(2)
+      expect(out.include_keywords).toEqual(['organic'])
+      expect(out.exclude_keywords).toEqual(['chain'])
+      expect(out.exclude_root_domains).toEqual(['yelp.com'])
+    })
+
+    it('google_maps.mapParams: query→searchStringsArray, country lowercase, limit clamped [1,200], start_urls→startUrls[]', () => {
+      const gm = getProviders('search_places').find((p) => p.id === 'google_maps')!
+      const out = gm.mapParams({ query: 'boulangerie', country: 'FR', city: 'Paris', limit: 15 }).body as Record<string, unknown>
+      expect(out.searchStringsArray).toEqual(['boulangerie'])
+      expect(out.countryCode).toBe('fr')
+      expect(out.city).toBe('Paris')
+      expect(out.maxCrawledPlacesPerSearch).toBe(15)
+
+      const urls = gm.mapParams({ start_urls: ['https://maps.google.com/place/foo'] }).body as Record<string, unknown>
+      expect(urls.startUrls).toEqual([{ url: 'https://maps.google.com/place/foo' }])
+      expect(urls.searchStringsArray).toBeUndefined()
+
+      const capped = gm.mapParams({ query: 'x', limit: 9999 }).body as Record<string, unknown>
+      expect(capped.maxCrawledPlacesPerSearch).toBe(200)
+
+      const minClamp = gm.mapParams({ query: 'x', limit: 0 }).body as Record<string, unknown>
+      expect(minClamp.maxCrawledPlacesPerSearch).toBe(1)
+    })
+
+    it('google_maps.mapParams: forwards include_opening_hours and include_additional_info', () => {
+      const gm = getProviders('search_places').find((p) => p.id === 'google_maps')!
+      const out = gm.mapParams({ query: 'pizza', include_opening_hours: true, include_additional_info: true, language: 'fr' }).body as Record<string, unknown>
+      expect(out.includeOpeningHours).toBe(true)
+      expect(out.additionalInfo).toBe(true)
+      expect(out.language).toBe('fr')
+    })
+
+    it('openmart.hasResult: true for non-empty root array or {data:[…]}, false otherwise', () => {
+      const om = getProviders('search_places').find((p) => p.id === 'openmart')!
+      expect(om.hasResult([{ name: 'ColdIQ HQ' }])).toBe(true)
+      expect(om.hasResult({ data: [{ name: 'x' }] })).toBe(true)
+      expect(om.hasResult([])).toBe(false)
+      expect(om.hasResult({ data: [] })).toBe(false)
+      expect(om.hasResult({})).toBe(false)
+    })
+
+    it('google_maps.hasResult: true for non-empty places[], false otherwise', () => {
+      const gm = getProviders('search_places').find((p) => p.id === 'google_maps')!
+      expect(gm.hasResult({ places: [{ name: 'Eiffel Tower' }] })).toBe(true)
+      expect(gm.hasResult({ places: [] })).toBe(false)
+      expect(gm.hasResult({})).toBe(false)
+    })
+  })
+
+  describe('find_influencers', () => {
+    it('providers are ordered influencers_similar → influencers_discovery', () => {
+      expect(getProviders('find_influencers').map((p) => p.id)).toEqual(['influencers_similar', 'influencers_discovery'])
+    })
+
+    it('influencers_similar is sync POST to /influencers-club/discovery/creators/similar', () => {
+      const p = getProviders('find_influencers').find((p) => p.id === 'influencers_similar')!
+      expect(p.method).toBe('POST')
+      expect(p.endpoint).toBe('/influencers-club/discovery/creators/similar')
+      expect(p.async).toBeUndefined()
+    })
+
+    it('influencers_similar.isApplicable: true only when handle is set', () => {
+      const p = getProviders('find_influencers').find((p) => p.id === 'influencers_similar')!
+      expect(p.isApplicable!({ handle: 'cristiano', platform: 'instagram' })).toBe(true)
+      expect(p.isApplicable!({ platform: 'instagram' })).toBe(false)
+      expect(p.isApplicable!({})).toBe(false)
+    })
+
+    it('influencers_similar.mapParams: builds paging and filters correctly', () => {
+      const p = getProviders('find_influencers').find((p) => p.id === 'influencers_similar')!
+      const out = p.mapParams({
+        handle: 'cristiano',
+        platform: 'instagram',
+        limit: 10,
+        page: 2,
+        location: ['United States'],
+        gender: 'male',
+        type: 'creator',
+      }).body as Record<string, unknown>
+      expect(out.handle).toBe('cristiano')
+      expect(out.platform).toBe('instagram')
+      expect(out.paging).toEqual({ limit: 10, page: 2 })
+      expect(out.filters).toEqual({ location: ['United States'], gender: 'male', type: 'creator' })
+    })
+
+    it('influencers_similar.mapParams: defaults paging to limit=25, page=1', () => {
+      const p = getProviders('find_influencers').find((p) => p.id === 'influencers_similar')!
+      const out = p.mapParams({ handle: 'cristiano', platform: 'instagram' }).body as Record<string, unknown>
+      expect(out.paging).toEqual({ limit: 25, page: 1 })
+    })
+
+    it('influencers_similar.hasResult: true for non-empty accounts or creators', () => {
+      const p = getProviders('find_influencers').find((p) => p.id === 'influencers_similar')!
+      expect(p.hasResult({ accounts: [{ id: 1 }] })).toBe(true)
+      expect(p.hasResult({ creators: [{ id: 2 }] })).toBe(true)
+      expect(p.hasResult({ accounts: [] })).toBe(false)
+      expect(p.hasResult({})).toBe(false)
+    })
+
+    it('influencers_discovery is sync POST to /influencers-club/discovery with no gate', () => {
+      const p = getProviders('find_influencers').find((p) => p.id === 'influencers_discovery')!
+      expect(p.method).toBe('POST')
+      expect(p.endpoint).toBe('/influencers-club/discovery')
+      expect(p.isApplicable).toBeUndefined()
+      expect(p.async).toBeUndefined()
+    })
+
+    it('influencers_discovery.mapParams: builds sort and filters correctly', () => {
+      const p = getProviders('find_influencers').find((p) => p.id === 'influencers_discovery')!
+      const out = p.mapParams({
+        platform: 'youtube',
+        limit: 10,
+        sort_by: 'engagement_rate',
+        sort_order: 'asc',
+        ai_search: 'fitness nutrition',
+        location: ['United States'],
+        gender: 'female',
+        type: 'creator',
+      }).body as Record<string, unknown>
+      expect(out.platform).toBe('youtube')
+      expect(out.paging).toEqual({ limit: 10, page: 1 })
+      expect(out.sort).toEqual({ sort_by: 'engagement_rate', sort_order: 'asc' })
+      expect(out.filters).toEqual({ ai_search: 'fitness nutrition', location: ['United States'], gender: 'female', type: 'creator' })
+    })
+
+    it('influencers_discovery.mapParams: sort is undefined when sort_by not provided', () => {
+      const p = getProviders('find_influencers').find((p) => p.id === 'influencers_discovery')!
+      const out = p.mapParams({ platform: 'instagram', limit: 5 }).body as Record<string, unknown>
+      expect(out.sort).toBeUndefined()
+    })
+
+    it('influencers_discovery.mapParams: sort_order defaults to desc when sort_by set but sort_order omitted', () => {
+      const p = getProviders('find_influencers').find((p) => p.id === 'influencers_discovery')!
+      const out = p.mapParams({ platform: 'instagram', sort_by: 'number_of_followers' }).body as Record<string, unknown>
+      expect(out.sort).toEqual({ sort_by: 'number_of_followers', sort_order: 'desc' })
+    })
+  })
+
+  describe('search_reddit', () => {
+    it('has exactly 1 provider: reddit', () => {
+      expect(getProviders('search_reddit').map((p) => p.id)).toEqual(['reddit'])
+    })
+
+    it('reddit is async POST to /reddit/scrape', () => {
+      const r = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+      expect(r.method).toBe('POST')
+      expect(r.endpoint).toBe('/reddit/scrape')
+      expect(r.async!.pollEndpoint('42')).toBe('/reddit/scrape/42')
+      expect(r.async!.isComplete({ status: 'done' })).toBe(true)
+      expect(r.async!.isComplete({ status: 'failed' })).toBe(true)
+      expect(r.async!.isComplete({ status: 'timed_out' })).toBe(true)
+      expect(r.async!.isComplete({ status: 'processing' })).toBe(false)
+      expect(r.async!.extractId({ jobId: 99 })).toBe('99')
+      expect(r.async!.extractId({ jobId: '55' })).toBe('55')
+      expect(() => r.async!.extractId({})).toThrow('no jobId')
+    })
+
+    it('reddit.isApplicable: true only when start_urls is non-empty; query alone is not sufficient', () => {
+      const r = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+      expect(r.isApplicable!({ start_urls: ['https://reddit.com/r/sales/'] })).toBe(true)
+      expect(r.isApplicable!({ query: 'x', start_urls: ['https://reddit.com/r/sales/'] })).toBe(true)
+      expect(r.isApplicable!({ query: 'B2B sales' })).toBe(false)
+      expect(r.isApplicable!({})).toBe(false)
+      expect(r.isApplicable!({ start_urls: [] })).toBe(false)
+    })
+
+    it('reddit.mapParams: maps all fields correctly', () => {
+      const r = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+      const out = r.mapParams({
+        query: 'best CRM',
+        type: 'posts',
+        sort: 'top',
+        time: 'month',
+        limit: 10,
+        include_comments: true,
+      }).body as Record<string, unknown>
+      expect(out.searchQueries).toEqual(['best CRM'])
+      expect(out.type).toBe('posts')
+      expect(out.sort).toBe('top')
+      expect(out.time).toBe('month')
+      expect(out.maxItems).toBe(10)
+      expect(out.includeComments).toBe(true)
+    })
+
+    it('reddit.mapParams: clamps maxItems to [1,200]', () => {
+      const r = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+      const hi = r.mapParams({ query: 'x', limit: 9999 }).body as Record<string, unknown>
+      const lo = r.mapParams({ query: 'x', limit: 0 }).body as Record<string, unknown>
+      expect(hi.maxItems).toBe(200)
+      expect(lo.maxItems).toBe(1)
+    })
+
+    it('reddit.mapParams: searchQueries undefined when query not provided; start_urls strings wrapped as {url} objects', () => {
+      const r = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+      const out = r.mapParams({ start_urls: ['https://reddit.com/r/sales/'] }).body as Record<string, unknown>
+      expect(out.searchQueries).toBeUndefined()
+      expect(out.startUrls).toEqual([{ url: 'https://reddit.com/r/sales/' }])
+    })
+
+    it('reddit.hasResult: true for non-empty items[], false otherwise', () => {
+      const r = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+      expect(r.hasResult({ items: [{ id: '1' }] })).toBe(true)
+      expect(r.hasResult({ items: [] })).toBe(false)
+      expect(r.hasResult({})).toBe(false)
+    })
+  })
+
+  describe('search_seo', () => {
+    it('has 16 providers in priority order', () => {
+      const ids = getProviders('search_seo').map((p) => p.id)
+      expect(ids).toEqual([
+        'kw_search_volume', 'kw_trends',
+        'serp_google', 'serp_bing', 'serp_youtube',
+        'bl_summary', 'bl_backlinks', 'bl_referring',
+        'domain_tech', 'domain_whois',
+        'labs_rank_overview', 'labs_ranked_kw', 'labs_competitors', 'labs_kw_ideas',
+        'page_lighthouse', 'page_content',
+      ])
+    })
+
+    it('all providers are sync POST (no async)', () => {
+      for (const p of getProviders('search_seo')) {
+        expect(p.method, `${p.id} should be POST`).toBe('POST')
+        expect(p.async, `${p.id} should have no async`).toBeUndefined()
+      }
+    })
+
+    it('kw_search_volume.isApplicable: true for category=keywords + keywords[]', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'kw_search_volume')!
+      expect(p.isApplicable!({ category: 'keywords', keywords: ['CRM'] })).toBe(true)
+      expect(p.isApplicable!({ category: 'keywords', keywords: [] })).toBe(false)
+      expect(p.isApplicable!({ category: 'serp', keywords: ['CRM'] })).toBe(false)
+    })
+
+    it('kw_search_volume.mapParams: maps keywords, location_name, language_code', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'kw_search_volume')!
+      const out = p.mapParams({ category: 'keywords', keywords: ['CRM'], location: 'United States', language: 'en' }).body as Record<string, unknown>
+      expect(out.keywords).toEqual(['CRM'])
+      expect(out.location_name).toBe('United States')
+      expect(out.language_code).toBe('en')
+    })
+
+    it('kw_trends.mapParams: maps date_from, date_to, time_range', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'kw_trends')!
+      const out = p.mapParams({ category: 'keywords', keywords: ['CRM'], date_from: '2024-01-01', date_to: '2024-12-31', time_range: 'past_30_days' }).body as Record<string, unknown>
+      expect(out.date_from).toBe('2024-01-01')
+      expect(out.date_to).toBe('2024-12-31')
+      expect(out.time_range).toBe('past_30_days')
+    })
+
+    it('serp_google.isApplicable: true for category=serp+keyword+default engine, false for bing/youtube', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'serp_google')!
+      expect(p.isApplicable!({ category: 'serp', keyword: 'CRM' })).toBe(true)
+      expect(p.isApplicable!({ category: 'serp', keyword: 'CRM', engine: 'google' })).toBe(true)
+      expect(p.isApplicable!({ category: 'serp', keyword: 'CRM', engine: 'bing' })).toBe(false)
+      expect(p.isApplicable!({ category: 'serp', keyword: 'CRM', engine: 'youtube' })).toBe(false)
+      expect(p.isApplicable!({ category: 'serp' })).toBe(false)
+    })
+
+    it('serp_bing.isApplicable: true only for engine=bing', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'serp_bing')!
+      expect(p.isApplicable!({ category: 'serp', keyword: 'CRM', engine: 'bing' })).toBe(true)
+      expect(p.isApplicable!({ category: 'serp', keyword: 'CRM', engine: 'google' })).toBe(false)
+      expect(p.isApplicable!({ category: 'serp', keyword: 'CRM' })).toBe(false)
+    })
+
+    it('serp_youtube.isApplicable: true only for engine=youtube', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'serp_youtube')!
+      expect(p.isApplicable!({ category: 'serp', keyword: 'CRM', engine: 'youtube' })).toBe(true)
+      expect(p.isApplicable!({ category: 'serp', keyword: 'CRM', engine: 'google' })).toBe(false)
+    })
+
+    it('serp_google.mapParams: maps keyword, depth, device', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'serp_google')!
+      const out = p.mapParams({ category: 'serp', keyword: 'best CRM', limit: 5, device: 'mobile' }).body as Record<string, unknown>
+      expect(out.keyword).toBe('best CRM')
+      expect(out.depth).toBe(5)
+      expect(out.device).toBe('mobile')
+    })
+
+    it('serp_youtube.mapParams: uses block_depth instead of depth', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'serp_youtube')!
+      const out = p.mapParams({ category: 'serp', keyword: 'CRM tutorial', limit: 5, engine: 'youtube' }).body as Record<string, unknown>
+      expect(out.block_depth).toBe(5)
+      expect(out.depth).toBeUndefined()
+    })
+
+    it('bl_summary.isApplicable: true for category=backlinks+target', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'bl_summary')!
+      expect(p.isApplicable!({ category: 'backlinks', target: 'salesforce.com' })).toBe(true)
+      expect(p.isApplicable!({ category: 'backlinks' })).toBe(false)
+      expect(p.isApplicable!({ category: 'domain', target: 'salesforce.com' })).toBe(false)
+    })
+
+    it('bl_summary.hasResult: checks total_count or rank under tasks wrapper', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'bl_summary')!
+      expect(p.hasResult({ tasks: [{ result: [{ total_count: 1000 }] }] })).toBe(true)
+      expect(p.hasResult({ tasks: [{ result: [{ rank: 50 }] }] })).toBe(true)
+      expect(p.hasResult({ tasks: [{ result: [{}] }] })).toBe(false)
+      expect(p.hasResult({})).toBe(false)
+    })
+
+    it('bl_backlinks.mapParams: passes target, limit, offset=0', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'bl_backlinks')!
+      const out = p.mapParams({ category: 'backlinks', target: 'salesforce.com', limit: 20 }).body as Record<string, unknown>
+      expect(out.target).toBe('salesforce.com')
+      expect(out.limit).toBe(20)
+      expect(out.offset).toBe(0)
+    })
+
+    it('domain_tech.isApplicable: true for category=domain+target when action is not whois', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'domain_tech')!
+      expect(p.isApplicable!({ category: 'domain', target: 'hubspot.com' })).toBe(true)
+      expect(p.isApplicable!({ category: 'domain', target: 'hubspot.com', action: 'technologies' })).toBe(true)
+      expect(p.isApplicable!({ category: 'domain', target: 'hubspot.com', action: 'whois' })).toBe(false)
+      expect(p.isApplicable!({ category: 'domain' })).toBe(false)
+    })
+
+    it('domain_whois.isApplicable: true only for action=whois', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'domain_whois')!
+      expect(p.isApplicable!({ category: 'domain', target: 'hubspot.com', action: 'whois' })).toBe(true)
+      expect(p.isApplicable!({ category: 'domain', target: 'hubspot.com' })).toBe(false)
+      expect(p.isApplicable!({ category: 'domain', target: 'hubspot.com', action: 'technologies' })).toBe(false)
+    })
+
+    it('domain_whois.mapParams: uses filters array format', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'domain_whois')!
+      const out = p.mapParams({ category: 'domain', target: 'hubspot.com', action: 'whois', limit: 10 }).body as Record<string, unknown>
+      expect(out.filters).toEqual([['domain', '=', 'hubspot.com']])
+      expect(out.limit).toBe(10)
+    })
+
+    it('labs_rank_overview.isApplicable: true for category=labs+target with no lab_action or rank-overview', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'labs_rank_overview')!
+      expect(p.isApplicable!({ category: 'labs', target: 'pipedrive.com' })).toBe(true)
+      expect(p.isApplicable!({ category: 'labs', target: 'pipedrive.com', lab_action: 'rank-overview' })).toBe(true)
+      expect(p.isApplicable!({ category: 'labs', target: 'pipedrive.com', lab_action: 'ranked-keywords' })).toBe(false)
+      expect(p.isApplicable!({ category: 'labs' })).toBe(false)
+    })
+
+    it('labs_ranked_kw.isApplicable: true for lab_action=ranked-keywords+target', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'labs_ranked_kw')!
+      expect(p.isApplicable!({ category: 'labs', target: 'pipedrive.com', lab_action: 'ranked-keywords' })).toBe(true)
+      expect(p.isApplicable!({ category: 'labs', target: 'pipedrive.com' })).toBe(false)
+      expect(p.isApplicable!({ category: 'labs', lab_action: 'ranked-keywords' })).toBe(false)
+    })
+
+    it('labs_competitors.isApplicable: true for lab_action=competitors+target', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'labs_competitors')!
+      expect(p.isApplicable!({ category: 'labs', target: 'pipedrive.com', lab_action: 'competitors' })).toBe(true)
+      expect(p.isApplicable!({ category: 'labs', target: 'pipedrive.com' })).toBe(false)
+    })
+
+    it('labs_kw_ideas.isApplicable: true only for lab_action=keyword-ideas + keywords[]', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'labs_kw_ideas')!
+      expect(p.isApplicable!({ category: 'labs', keywords: ['CRM'], lab_action: 'keyword-ideas' })).toBe(true)
+      expect(p.isApplicable!({ category: 'labs', keywords: [], lab_action: 'keyword-ideas' })).toBe(false)
+      expect(p.isApplicable!({ category: 'labs', keywords: ['CRM'] })).toBe(false)
+    })
+
+    it('page_lighthouse.isApplicable: true for category=page+url when page_action is not content', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'page_lighthouse')!
+      expect(p.isApplicable!({ category: 'page', url: 'https://coldiq.com' })).toBe(true)
+      expect(p.isApplicable!({ category: 'page', url: 'https://coldiq.com', page_action: 'lighthouse' })).toBe(true)
+      expect(p.isApplicable!({ category: 'page', url: 'https://coldiq.com', page_action: 'content' })).toBe(false)
+      expect(p.isApplicable!({ category: 'page' })).toBe(false)
+    })
+
+    it('page_content.isApplicable: true only for page_action=content', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'page_content')!
+      expect(p.isApplicable!({ category: 'page', url: 'https://coldiq.com', page_action: 'content' })).toBe(true)
+      expect(p.isApplicable!({ category: 'page', url: 'https://coldiq.com' })).toBe(false)
+    })
+
+    it('page_lighthouse.mapParams: maps url, enable_javascript, full_data', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'page_lighthouse')!
+      const out = p.mapParams({ url: 'https://coldiq.com', enable_javascript: true, full_data: true }).body as Record<string, unknown>
+      expect(out.url).toBe('https://coldiq.com')
+      expect(out.enable_javascript).toBe(true)
+      expect(out.full_data).toBe(true)
+    })
+
+    it('page_content.mapParams: maps url and enable_javascript, no full_data', () => {
+      const p = getProviders('search_seo').find((p) => p.id === 'page_content')!
+      const out = p.mapParams({ url: 'https://coldiq.com', enable_javascript: false }).body as Record<string, unknown>
+      expect(out.url).toBe('https://coldiq.com')
+      expect(out.enable_javascript).toBe(false)
+      expect(out.full_data).toBeUndefined()
+    })
+  })
+})