@coldiq/mcp 0.1.18 → 0.2.4

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

@@ -115,10 +115,10 @@ describe('prospeo-search-person', () => {
     })).toEqual({
       body: {
         filters: {
-          job_title: { include: ['CEO', 'CTO'] },
+          person_job_title: { include: ['CEO', 'CTO'] },
           person_seniority: { include: ['C-Level'] },
           company: { websites: { include: ['coldiq.com'] } },
-          person_location: { include: ['Belgium'] },
+          person_location_search: { include: ['Belgium'] },
         },
       },
     })
@@ -129,7 +129,7 @@ describe('prospeo-search-person', () => {
     const filters = (result.body as Record<string, unknown>).filters as Record<string, unknown>
     expect(filters.person_seniority).toBeUndefined()
     expect(filters.company).toBeUndefined()
-    expect(filters.person_location).toBeUndefined()
+    expect(filters.person_location_search).toBeUndefined()
   })
 
   it('hasResult: true when data array non-empty', () => {
@@ -229,8 +229,16 @@ describe('ai-ark-people', () => {
 describe('fullenrich-people-search', () => {
   const p = () => get('fullenrich-people-search')
 
-  it('has no isApplicable gate (always runs)', () => {
-    expect(p().isApplicable).toBeUndefined()
+  it('isApplicable: true with company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'], job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only company_linkedin_urls (upstream rejects LinkedIn-URL filters)', () => {
+    expect(p().isApplicable!({ company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'], job_titles: ['CEO'] })).toBe(false)
+  })
+
+  it('isApplicable: false without any company identifier (titles-only would degrade to global search)', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'] })).toBe(false)
   })
 
   it('mapParams wraps all fields in {value} objects', () => {
@@ -252,9 +260,8 @@ describe('fullenrich-people-search', () => {
   })
 
   it('mapParams omits undefined fields', () => {
-    const result = p().mapParams({ job_titles: ['CEO'], limit: 5 })
+    const result = p().mapParams({ company_domains: ['coldiq.com'], limit: 5 })
     const body = result.body as Record<string, unknown>
-    expect(body.current_company_domains).toBeUndefined()
     expect(body.current_position_seniority_level).toBeUndefined()
     expect(body.person_locations).toBeUndefined()
   })
@@ -357,6 +364,18 @@ describe('apollo (find_people)', () => {
     expect(body.q_keywords).toBe('growth AI')
   })
 
+  it('mapParams clamps per_page to 100 when limit exceeds Apollo upstream cap', () => {
+    const result = p().mapParams({ job_titles: ['CEO'], limit: 150 })
+    const body = result.body as Record<string, unknown>
+    expect(body.per_page).toBe(100)
+  })
+
+  it('mapParams passes through per_page when limit is at or below 100', () => {
+    const result = p().mapParams({ job_titles: ['CEO'], limit: 50 })
+    const body = result.body as Record<string, unknown>
+    expect(body.per_page).toBe(50)
+  })
+
   it('mapParams omits q_keywords when keywords absent', () => {
     const result = p().mapParams({ job_titles: ['CEO'], limit: 10 })
     const body = result.body as Record<string, unknown>
@@ -459,6 +478,22 @@ describe('leadsfactory (find_people)', () => {
   const personas = (result: ReturnType<ReturnType<typeof p>['mapParams']>) =>
     ((result.body as Record<string, unknown>).search as Record<string, unknown>).personas as { job_title: string }[]
 
+  it('isApplicable: true with company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'], job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: true with company_linkedin_urls', () => {
+    expect(p().isApplicable!({ company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'], job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: false without any company identifier (LF upstream 500s on pure prospecting)', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'], seniorities: ['C-Level'], locations: ['FR'] })).toBe(false)
+  })
+
+  it('isApplicable: false on empty input', () => {
+    expect(p().isApplicable!({})).toBe(false)
+  })
+
   it('same-domain variants collapse to 1 persona with comma-joined titles', () => {
     const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['VP Sales', 'Head of Sales'], limit: 5 })
     expect(personas(result)).toEqual([{ job_title: 'VP Sales, Head of Sales' }])
@@ -655,6 +690,162 @@ describe('leadsfactory (find_people)', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// pdl
+// ---------------------------------------------------------------------------
+
+describe('pdl (find_people)', () => {
+  const p = () => get('pdl')
+
+  it('isApplicable: true with company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(true)
+  })
+
+  it('isApplicable: true with company_linkedin_urls', () => {
+    expect(p().isApplicable!({ company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'] })).toBe(true)
+  })
+
+  it('isApplicable: true with job_titles', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: true with seniorities', () => {
+    expect(p().isApplicable!({ seniorities: ['c_suite'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only locations (would return entire index)', () => {
+    expect(p().isApplicable!({ locations: ['FR'] })).toBe(false)
+  })
+
+  it('isApplicable: false with no filters', () => {
+    expect(p().isApplicable!({})).toBe(false)
+  })
+
+  it('mapParams maps company_domains to job_company_website term', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['CEO'], limit: 10 })
+    const body = result.body as { query: { bool: { must: unknown[] } }; size: number }
+    expect(body.query.bool.must).toContainEqual({ terms: { job_company_website: ['coldiq.com'] } })
+    expect(body.query.bool.must).toContainEqual({ terms: { job_title: ['CEO'] } })
+    expect(body.size).toBe(10)
+  })
+
+  it('mapParams normalizes LinkedIn URLs to PDL canonical short form', () => {
+    // PDL indexes URLs as `linkedin.com/company/x` (no protocol, no www, no trailing slash);
+    // its `terms` query is exact-match — full URLs from callers must be stripped first.
+    const result = p().mapParams({
+      company_linkedin_urls: [
+        'https://www.linkedin.com/company/coldiq',
+        'https://linkedin.com/company/microsoft/',
+        'www.linkedin.com/company/aircall',
+      ],
+      job_titles: ['CMO'],
+    })
+    const body = result.body as { query: { bool: { must: unknown[] } } }
+    expect(body.query.bool.must).toContainEqual({
+      terms: {
+        job_company_linkedin_url: [
+          'linkedin.com/company/coldiq',
+          'linkedin.com/company/microsoft',
+          'linkedin.com/company/aircall',
+        ],
+      },
+    })
+  })
+
+  it('mapParams emits both domain and linkedin terms when both provided', () => {
+    const result = p().mapParams({
+      company_domains: ['coldiq.com'],
+      company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'],
+      job_titles: ['CEO'],
+    })
+    const body = result.body as { query: { bool: { must: unknown[] } } }
+    expect(body.query.bool.must).toContainEqual({ terms: { job_company_website: ['coldiq.com'] } })
+    expect(body.query.bool.must).toContainEqual({
+      terms: { job_company_linkedin_url: ['linkedin.com/company/coldiq'] },
+    })
+  })
+
+  it('hasResult: true when data array non-empty', () => {
+    expect(p().hasResult({ data: [{ full_name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: false when data is empty', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+
+  it('priority is 3', () => {
+    expect(p().priority).toBe(3)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// companyenrich
+// ---------------------------------------------------------------------------
+
+describe('companyenrich (find_people)', () => {
+  const p = () => get('companyenrich')
+
+  it('isApplicable: true with company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'], job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: true with neither company filter (degrades to titles/locations search)', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only company_linkedin_urls (upstream has no LinkedIn-URL filter)', () => {
+    expect(p().isApplicable!({
+      company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'],
+      job_titles: ['CEO'],
+    })).toBe(false)
+  })
+
+  it('isApplicable: true when both linkedin_urls AND domains are present (domains carry the search)', () => {
+    expect(p().isApplicable!({
+      company_domains: ['coldiq.com'],
+      company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'],
+      job_titles: ['CEO'],
+    })).toBe(true)
+  })
+
+  it('mapParams maps company_domains to filters.companies', () => {
+    const result = p().mapParams({
+      company_domains: ['coldiq.com', 'microsoft.com'],
+      job_titles: ['CEO'],
+      locations: ['FR'],
+      limit: 10,
+    })
+    expect(result).toEqual({
+      body: {
+        filters: {
+          jobTitles: ['CEO'],
+          companies: ['coldiq.com', 'microsoft.com'],
+          countries: ['FR'],
+        },
+        pageSize: 10,
+      },
+    })
+  })
+
+  it('mapParams omits filters.companies when no domains', () => {
+    const result = p().mapParams({ job_titles: ['CEO'], limit: 25 })
+    const body = result.body as { filters: Record<string, unknown> }
+    expect(body.filters.companies).toBeUndefined()
+  })
+
+  it('hasResult: true when data array non-empty', () => {
+    expect(p().hasResult({ data: [{ name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: false when data is empty', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+
+  it('priority is 4', () => {
+    expect(p().priority).toBe(4)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // Ordering: find_people providers sorted correctly
 // ---------------------------------------------------------------------------

package/tests/registry-search-companies.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { getProviders } from '../src/registry.js'
+import { getProviders, prospeoHeadcountBuckets } from '../src/registry.js'
 
 const providers = () => getProviders('search_companies')
 const get = (id: string) => {
@@ -43,8 +43,8 @@ describe('prospeo-search-company', () => {
         filters: {
           company_keywords: { include: ['sales engagement'] },
           company_industry: { include: ['SaaS'] },
-          company_country: { include: ['Belgium'] },
-          company_headcount_custom: { min: 10, max: 200 },
+          company_location_search: { include: ['Belgium'] },
+          company_headcount_range: ['1-10', '11-20', '21-50', '51-100', '101-200'],
         },
       },
     })
@@ -54,14 +54,17 @@ describe('prospeo-search-company', () => {
     const result = p().mapParams({ keywords: ['outbound'] })
     const filters = (result.body as Record<string, unknown>).filters as Record<string, unknown>
     expect(filters.company_industry).toBeUndefined()
-    expect(filters.company_country).toBeUndefined()
-    expect(filters.company_headcount_custom).toBeUndefined()
+    expect(filters.company_location_search).toBeUndefined()
+    expect(filters.company_headcount_range).toBeUndefined()
   })
 
-  it('mapParams includes headcount when only min is given', () => {
+  it('mapParams includes headcount buckets when only min is given', () => {
     const result = p().mapParams({ keywords: ['crm'], min_employees: 50 })
     const filters = (result.body as Record<string, unknown>).filters as Record<string, unknown>
-    expect(filters.company_headcount_custom).toEqual({ min: 50, max: undefined })
+    expect(filters.company_headcount_range).toEqual([
+      '21-50', '51-100', '101-200', '201-500', '501-1000',
+      '1001-2000', '2001-5000', '5001-10000', '10000+',
+    ])
   })
 
   it('hasResult: true when data array non-empty', () => {
@@ -250,6 +253,42 @@ describe('theirstack search_companies', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// prospeoHeadcountBuckets — maps numeric range to Prospeo's fixed buckets
+// ---------------------------------------------------------------------------
+
+describe('prospeoHeadcountBuckets', () => {
+  it('returns all overlapping buckets for a finite range', () => {
+    expect(prospeoHeadcountBuckets(10, 500)).toEqual([
+      '1-10', '11-20', '21-50', '51-100', '101-200', '201-500',
+    ])
+  })
+
+  it('treats undefined min as 0 (open lower bound)', () => {
+    expect(prospeoHeadcountBuckets(undefined, 50)).toEqual(['1-10', '11-20', '21-50'])
+  })
+
+  it('treats undefined max as +Infinity (open upper bound)', () => {
+    expect(prospeoHeadcountBuckets(2001, undefined)).toEqual([
+      '2001-5000', '5001-10000', '10000+',
+    ])
+  })
+
+  it('returns single bucket when min === max within a bucket', () => {
+    expect(prospeoHeadcountBuckets(75, 75)).toEqual(['51-100'])
+  })
+
+  it('includes 10000+ when min is above 10000', () => {
+    expect(prospeoHeadcountBuckets(15000, undefined)).toEqual(['10000+'])
+  })
+
+  it('excludes 10000+ when max is exactly 10000', () => {
+    const buckets = prospeoHeadcountBuckets(5001, 10000)
+    expect(buckets).toEqual(['5001-10000'])
+    expect(buckets).not.toContain('10000+')
+  })
+})
+
 // ---------------------------------------------------------------------------
 // Ordering: search_companies providers sorted correctly
 // ---------------------------------------------------------------------------

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

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { initClient } from '../../src/client.js'
-import { findEmailsHandler } from '../../src/tools/find-emails.js'
+import { findEmailsHandler, FIND_EMAILS_CHUNK_SIZE } from '../../src/tools/find-emails.js'
 
 describe('find_emails handler (bulk)', () => {
   const originalFetch = globalThis.fetch
@@ -399,6 +399,73 @@ describe('find_emails handler — use_providers', () => {
     expect(parsed.data.results[0]).toMatchObject({ provider: 'findymail', email: 'alice@example.com' })
     expect(icypeasCalled).toBe(false)
   })
+
+  it('pinning a single-only provider (limadata-work-email) routes through Step 4 and succeeds', async () => {
+    // Regression: previously FIND_EMAILS_PROVIDERS only listed the 4 bulk providers,
+    // so pinning a Step 4 provider was rejected as "unrecognized". Now all 8 are exposed.
+    let prospeoCalled = false
+    let limadataCalled = false
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        prospeoCalled = true
+        return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+      }
+      if (u.includes('/coldiq/find/work-email')) {
+        limadataCalled = true
+        return new Response(JSON.stringify({ email: 'alice@example.com' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected', url: u }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await findEmailsHandler({
+      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
+      use_providers: ['limadata-work-email'],
+    })
+
+    expect(result.isError).toBeUndefined()
+    expect(prospeoCalled).toBe(false)
+    expect(limadataCalled).toBe(true)
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.data.results[0]).toMatchObject({ provider: 'limadata-work-email', email: 'alice@example.com' })
+  })
+
+  it('all-failed error after pinning bulk-only providers surfaces single-only providers as remaining options', async () => {
+    // Regression: with only 4 providers exposed, after the user pinned all 4 bulk providers
+    // and they missed, available_providers was [] — falsely implying no more options existed.
+    // Now the error must point them at the single-only providers they could retry with.
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        return new Response(JSON.stringify({ error: false, results: [] }), { status: 200 })
+      }
+      if (u.includes('/fullenrich/contact/enrich/bulk')) {
+        return new Response(JSON.stringify({}), { status: 200 })
+      }
+      if (u.includes('/findymail/search/name')) {
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      if (u.includes('/icypeas/email-search')) {
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected', url: u }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await findEmailsHandler({
+      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
+      use_providers: ['prospeo', 'fullenrich', 'findymail', 'icypeas'],
+    })
+
+    expect(result.isError).toBe(true)
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.available_providers).toEqual([
+      'limadata-work-email',
+      'blitzapi',
+      'limadata-work-email-linkedin',
+      'linkupapi',
+    ])
+    expect(parsed.error).toContain('limadata-work-email')
+  })
 })
 
 describe('find_emails handler — resilience', () => {
@@ -508,3 +575,202 @@ describe('find_emails handler — resilience', () => {
     expect(parsed.data.results[0]).toMatchObject({ id: 'p1', email: 'alice@example.com', provider: 'blitzapi' })
   })
 })
+
+describe('find_emails handler — chunking', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  function makePeople(n: number): Array<{ id: string; first_name: string; last_name: string; domain: string }> {
+    return Array.from({ length: n }, (_, i) => ({
+      id: `p${i + 1}`,
+      first_name: `First${i + 1}`,
+      last_name: `Last${i + 1}`,
+      domain: 'example.com',
+    }))
+  }
+
+  it('splits 25 people into 3 chunks of ≤10 and issues one Prospeo bulk per chunk', async () => {
+    const bulkBodies: Array<{ data: Array<{ identifier: string }> }> = []
+
+    globalThis.fetch = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        const body = JSON.parse(init!.body as string) as { data: Array<{ identifier: string }> }
+        bulkBodies.push(body)
+        return new Response(
+          JSON.stringify({
+            error: false,
+            results: body.data.map((d) => ({
+              identifier: d.identifier,
+              error: false,
+              person: { email: { email: `${d.identifier}@example.com` } },
+            })),
+            total_cost: body.data.length,
+          }),
+          { status: 200 },
+        )
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await findEmailsHandler({ people: makePeople(25) })
+    const parsed = JSON.parse(result.content[0].text)
+
+    expect(bulkBodies.length).toBe(3)
+    expect(bulkBodies[0]!.data.length).toBeLessThanOrEqual(FIND_EMAILS_CHUNK_SIZE)
+    expect(bulkBodies[1]!.data.length).toBeLessThanOrEqual(FIND_EMAILS_CHUNK_SIZE)
+    expect(bulkBodies[2]!.data.length).toBeLessThanOrEqual(FIND_EMAILS_CHUNK_SIZE)
+    expect(bulkBodies.flatMap((b) => b.data.map((d) => d.identifier)).sort()).toEqual(
+      makePeople(25).map((p) => p.id).sort(),
+    )
+
+    expect(parsed.data.found).toBe(25)
+    expect(parsed.data.total).toBe(25)
+    expect(parsed._meta.batch_status).toBe('complete')
+    expect(parsed._meta.chunk_count).toBe(3)
+    expect(parsed._meta.chunk_size).toBe(FIND_EMAILS_CHUNK_SIZE)
+    expect(parsed._meta.providers.prospeo).toEqual({ attempted: 3, failed: 0 })
+    expect(result.isError).toBeUndefined()
+  })
+
+  it('one chunk Prospeo network failure → batch_status="partial" + isError absent when others succeed', async () => {
+    // First Prospeo bulk call simulates a network failure (status 0 via a fetch throw).
+    // Remaining chunks succeed. FindyMail picks up the failed chunk's misses.
+    let bulkCallCount = 0
+    globalThis.fetch = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        bulkCallCount++
+        if (bulkCallCount === 1) {
+          // Simulate network failure → client returns { ok: false, status: 0 }
+          throw new Error('socket hang up')
+        }
+        const body = JSON.parse(init!.body as string) as { data: Array<{ identifier: string }> }
+        return new Response(
+          JSON.stringify({
+            error: false,
+            results: body.data.map((d) => ({
+              identifier: d.identifier,
+              error: false,
+              person: { email: { email: `${d.identifier}@example.com` } },
+            })),
+            total_cost: body.data.length,
+          }),
+          { status: 200 },
+        )
+      }
+      // FullEnrich create call for the failed chunk's misses — no enrichment_id so it bails fast.
+      if (u.includes('/fullenrich/contact/enrich/bulk')) {
+        return new Response(JSON.stringify({}), { status: 200 })
+      }
+      if (u.includes('/findymail/search/name')) {
+        return new Response(JSON.stringify({ email: 'recovered@example.com' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await findEmailsHandler({ people: makePeople(25) })
+    const parsed = JSON.parse(result.content[0].text)
+
+    expect(parsed._meta.providers.prospeo.attempted).toBe(3)
+    expect(parsed._meta.providers.prospeo.failed).toBe(1)
+    expect(parsed._meta.batch_status).toBe('partial')
+    expect(parsed.data.found).toBeGreaterThan(0)
+    expect(result.isError).toBeUndefined()
+  })
+
+  it('every chunk fails → batch_status="failed" and isError:true even unconstrained', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        // 502 → counted as a network-level failure
+        return new Response(JSON.stringify({ error: 'upstream down' }), { status: 502 })
+      }
+      if (u.includes('/fullenrich/contact/enrich/bulk')) {
+        return new Response(JSON.stringify({ error: 'down' }), { status: 502 })
+      }
+      if (u.includes('/findymail/search/name')) {
+        return new Response(JSON.stringify({ error: 'down' }), { status: 502 })
+      }
+      if (u.includes('/icypeas/email-search')) {
+        return new Response(JSON.stringify({ error: 'down' }), { status: 502 })
+      }
+      // Single-only fallbacks: all return 502 so executeWithFallback yields an error.
+      return new Response(JSON.stringify({ error: 'down' }), { status: 502 })
+    }) as typeof fetch
+
+    const result = await findEmailsHandler({ people: makePeople(15) })
+    const parsed = JSON.parse(result.content[0].text)
+
+    expect(parsed.data.found).toBe(0)
+    expect(parsed._meta.batch_status).toBe('failed')
+    expect(parsed._meta.providers.prospeo.failed).toBeGreaterThan(0)
+    expect(result.isError).toBe(true)
+  })
+
+  it('legitimate "no coverage" (every provider 200s with no email) stays batch_status="complete" and is NOT an error', async () => {
+    // Distinguishing failure from no-coverage: providers respond cleanly but find no email.
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        return new Response(
+          JSON.stringify({ error: false, results: [], total_cost: 0 }),
+          { status: 200 },
+        )
+      }
+      if (u.includes('/fullenrich/contact/enrich/bulk')) {
+        return new Response(JSON.stringify({}), { status: 200 })
+      }
+      if (u.includes('/findymail/search/name')) {
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      if (u.includes('/icypeas/email-search')) {
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ email: null }), { status: 200 })
+    }) as typeof fetch
+
+    const result = await findEmailsHandler({ people: makePeople(12) })
+    const parsed = JSON.parse(result.content[0].text)
+
+    expect(parsed.data.found).toBe(0)
+    expect(parsed._meta.batch_status).toBe('complete')
+    expect(parsed._meta.providers.prospeo.failed).toBe(0)
+    expect(parsed._meta.providers.findymail.failed).toBe(0)
+    expect(result.isError).toBeUndefined()
+  })
+
+  it('small input (≤10) still works and emits _meta without chunking overhead', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        return new Response(
+          JSON.stringify({
+            error: false,
+            results: [{ identifier: 'p1', error: false, person: { email: { email: 'alice@example.com' } } }],
+            total_cost: 1,
+          }),
+          { status: 200 },
+        )
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await findEmailsHandler({
+      people: [{ id: 'p1', first_name: 'Alice', domain: 'example.com' }],
+    })
+    const parsed = JSON.parse(result.content[0].text)
+
+    expect(parsed._meta.chunk_count).toBe(1)
+    expect(parsed._meta.batch_status).toBe('complete')
+    expect(parsed._meta.providers.prospeo).toEqual({ attempted: 1, failed: 0 })
+    expect(result.isError).toBeUndefined()
+  })
+})