@coldiq/mcp 0.3.12 → 0.3.13

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

@@ -1,818 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { findEmailsHandler, FIND_EMAILS_CHUNK_SIZE } from '../../src/tools/find-emails.js'
-
-describe('find_emails handler (bulk)', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('resolves all people from prospeo bulk when all match', 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' } } },
-              { identifier: 'p2', error: false, person: { email: { email: 'bob@example.com' } } },
-            ],
-            total_cost: 2,
-          }),
-          { status: 200 },
-        )
-      }
-      return new Response(JSON.stringify({ error: 'unexpected call' }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await findEmailsHandler({
-      people: [
-        { id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' },
-        { id: 'p2', first_name: 'Bob', last_name: 'Jones', domain: 'example.com' },
-      ],
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.found).toBe(2)
-    expect(parsed.data.total).toBe(2)
-    expect(parsed.data.results).toEqual([
-      { id: 'p1', email: 'alice@example.com', provider: 'prospeo', provider_name: 'Prospeo' },
-      { id: 'p2', email: 'bob@example.com', provider: 'prospeo', provider_name: 'Prospeo' },
-    ])
-  })
-
-  it('falls back to FindyMail for prospeo misses', async () => {
-    let fmCalled = false
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/prospeo/bulk-enrich-person')) {
-        return new Response(
-          JSON.stringify({
-            error: false,
-            results: [
-              { identifier: 'p1', error: true, person: null },
-            ],
-            total_cost: 0,
-          }),
-          { status: 200 },
-        )
-      }
-      if (u.includes('/findymail/search/name')) {
-        fmCalled = true
-        return new Response(JSON.stringify({ email: 'alice@example.com' }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
-    })
-
-    expect(fmCalled).toBe(true)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.results[0]).toEqual({ id: 'p1', email: 'alice@example.com', provider: 'findymail', provider_name: 'Findymail' })
-  })
-
-  it('falls back to IcyPeas when FindyMail also misses', 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: true, person: null }], total_cost: 0 }),
-          { 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: 'alice@example.com' }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.results[0]).toEqual({ id: 'p1', email: 'alice@example.com', provider: 'icypeas', provider_name: 'Icypeas' })
-  })
-
-  it('returns email:null when all providers miss for a person', async () => {
-    globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({ error: true }), { status: 200 }),
-    ) as typeof fetch
-
-    const result = await findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Unknown', last_name: 'Person', domain: 'nowhere.xyz' }],
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.found).toBe(0)
-    expect(parsed.data.results[0]).toEqual({ id: 'p1', email: null, provider: null, provider_name: null })
-  })
-
-  it('handles mixed results: some from prospeo, some from fallback, some missed', async () => {
-    // Track findymail call count to serve different results per person
-    let findymailCalls = 0
-    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@a.com' } } },
-              { identifier: 'p2', error: true, person: null },
-              { identifier: 'p3', error: true, person: null },
-            ],
-            total_cost: 1,
-          }),
-          { status: 200 },
-        )
-      }
-      if (u.includes('/findymail/search/name')) {
-        findymailCalls++
-        // First miss (p2 or p3): one finds, one doesn't
-        return new Response(
-          JSON.stringify({ email: findymailCalls === 1 ? 'bob@b.com' : 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' }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await findEmailsHandler({
-      people: [
-        { id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'a.com' },
-        { id: 'p2', first_name: 'Bob', last_name: 'Jones', domain: 'b.com' },
-        { id: 'p3', first_name: 'Carol', last_name: 'White', domain: 'c.com' },
-      ],
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.found).toBe(2)
-    expect(parsed.data.results.find((r: EmailResult) => r.id === 'p1')).toMatchObject({ email: 'alice@a.com', provider: 'prospeo' })
-    // One of p2/p3 found by findymail (order non-deterministic due to Promise.all)
-    const findymailHit = parsed.data.results.find((r: EmailResult) => r.provider === 'findymail')
-    expect(findymailHit).toBeDefined()
-    expect(findymailHit.email).toMatch(/@/)
-    const missed = parsed.data.results.find((r: EmailResult) => r.email === null)
-    expect(missed).toBeDefined()
-  })
-
-  it('uses linkedin_url in prospeo bulk when provided', async () => {
-    let capturedBulkBody: unknown
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
-      const u = url.toString()
-      if (u.includes('/prospeo/bulk-enrich-person')) {
-        capturedBulkBody = JSON.parse(init?.body as string)
-        return new Response(
-          JSON.stringify({ error: false, results: [], total_cost: 0 }),
-          { status: 200 },
-        )
-      }
-      // Fallback calls (no domain/name so findymail/icypeas return nothing)
-      return new Response(JSON.stringify({ email: null }), { status: 200 })
-    }) as typeof fetch
-
-    await findEmailsHandler({
-      people: [{ id: 'p1', linkedin_url: 'https://linkedin.com/in/michel-lieben' }],
-    })
-
-    const body = capturedBulkBody as { data: Array<Record<string, unknown>> }
-    expect(body.data[0]).toMatchObject({ identifier: 'p1', linkedin_url: 'https://linkedin.com/in/michel-lieben' })
-    expect(body.data[0].first_name).toBeUndefined()
-  })
-
-  it('uses FullEnrich batch for Prospeo misses and matches by custom_id', async () => {
-    vi.useFakeTimers()
-
-    let feCreateBody: unknown
-    let fePollCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
-      const u = url.toString()
-
-      if (u.includes('/prospeo/bulk-enrich-person')) {
-        return new Response(JSON.stringify({
-          error: false,
-          results: [{ identifier: 'p1', error: true, person: null }],
-          total_cost: 0,
-        }), { status: 200 })
-      }
-
-      if (u.includes('/fullenrich/contact/enrich/bulk/abc-fe-123')) {
-        fePollCalled = true
-        return new Response(JSON.stringify({
-          status: 'DONE',
-          data: [{ custom_id: 'p1', emails: ['alice@example.com'] }],
-        }), { status: 200 })
-      }
-
-      if (u.includes('/fullenrich/contact/enrich/bulk')) {
-        feCreateBody = JSON.parse(init?.body as string)
-        return new Response(JSON.stringify({ enrichment_id: 'abc-fe-123' }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const handlerPromise = findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
-    })
-
-    await vi.runAllTimersAsync()
-    const result = await handlerPromise
-    vi.useRealTimers()
-
-    expect(fePollCalled).toBe(true)
-    const body = feCreateBody as { data: Array<Record<string, unknown>> }
-    expect(body.data[0].custom_id).toBe('p1')
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.results[0]).toEqual({ id: 'p1', email: 'alice@example.com', provider: 'fullenrich', provider_name: 'FullEnrich' })
-  })
-
-  it('parallel branches: faster FindyMail wins, slower FullEnrich does not overwrite', async () => {
-    // Step 2 (FullEnrich) and Step 3 (FindyMail/IcyPeas) run concurrently. If FindyMail
-    // returns an email first, the FullEnrich poll later must NOT overwrite it.
-    vi.useFakeTimers()
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/prospeo/bulk-enrich-person')) {
-        return new Response(
-          JSON.stringify({ error: false, results: [{ identifier: 'p1', error: true, person: null }], total_cost: 0 }),
-          { status: 200 },
-        )
-      }
-      // FindyMail wins immediately
-      if (u.includes('/findymail/search/name')) {
-        return new Response(JSON.stringify({ email: 'fm@example.com' }), { status: 200 })
-      }
-      // FullEnrich create + later poll succeed but with a different email
-      if (u.includes('/fullenrich/contact/enrich/bulk/abc-fe-456')) {
-        return new Response(
-          JSON.stringify({ status: 'DONE', data: [{ custom_id: 'p1', emails: ['fe@example.com'] }] }),
-          { status: 200 },
-        )
-      }
-      if (u.includes('/fullenrich/contact/enrich/bulk')) {
-        return new Response(JSON.stringify({ enrichment_id: 'abc-fe-456' }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const handlerPromise = findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
-    })
-
-    await vi.runAllTimersAsync()
-    const result = await handlerPromise
-    vi.useRealTimers()
-
-    const parsed = JSON.parse(result.content[0].text)
-    // FindyMail won the race — its email + provider must persist
-    expect(parsed.data.results[0]).toEqual({ id: 'p1', email: 'fm@example.com', provider: 'findymail', provider_name: 'Findymail' })
-  })
-
-  it('gracefully handles prospeo bulk failure and still tries fallbacks', 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: 'service unavailable' }), { status: 502 })
-      }
-      if (u.includes('/findymail/search/name')) {
-        return new Response(JSON.stringify({ email: 'alice@example.com' }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.results[0]).toMatchObject({ email: 'alice@example.com', provider: 'findymail' })
-  })
-})
-
-interface EmailResult {
-  id: string
-  email: string | null
-  provider: string | null
-}
-
-describe('find_emails handler — use_providers', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('Scenario A — pinned to prospeo only, skips fallback providers', async () => {
-    let findymailCalled = false
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/findymail')) findymailCalled = true
-      if (u.includes('/prospeo/bulk-enrich-person')) {
-        return new Response(JSON.stringify({
-          error: false,
-          results: [{ identifier: 'p1', person: { email: { email: 'alice@example.com' } } }],
-        }), { 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' }],
-      use_providers: ['prospeo'],
-    })
-
-    expect(result.isError).toBeUndefined()
-    expect(findymailCalled).toBe(false)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.results[0]).toMatchObject({ provider: 'prospeo' })
-  })
-
-  it('Scenario H — all pinned providers find nothing → returns isError with pushback message', async () => {
-    globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({ error: false, results: [] }), { status: 200 })
-    ) as typeof fetch
-
-    const result = await findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Unknown', domain: 'nowhere.xyz' }],
-      use_providers: ['findymail'],
-    })
-
-    expect(result.isError).toBe(true)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.error).toContain('Couldn\'t fulfill')
-    expect(parsed.error).toContain('ColdIQ will automatically pick the best tool')
-  })
-
-  it('Scenario E — unrecognized provider name returns isError', async () => {
-    const result = await findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Alice', domain: 'example.com' }],
-      use_providers: ['wiza'],
-    })
-
-    expect(result.isError).toBe(true)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.error).toContain("'wiza' is not a recognized provider")
-    expect(parsed.error).toContain('ColdIQ will automatically pick the best tool')
-  })
-
-  it('Scenario G — ordered providers: first succeeds, second skipped', async () => {
-    let icypeasCalled = false
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/icypeas')) icypeasCalled = true
-      if (u.includes('/findymail/search/name')) {
-        return new Response(JSON.stringify({ email: 'alice@example.com' }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Alice', domain: 'example.com' }],
-      use_providers: ['findymail', 'icypeas'],
-    })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = JSON.parse(result.content[0].text)
-    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', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('findymailIcypeasStep completing correctly even when fullEnrichStep throws', async () => {
-    // Prospeo returns no results.
-    // FullEnrich create call throws (simulates unexpected error).
-    // FindyMail finds the email — result should still be populated.
-
-    vi.useFakeTimers()
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/prospeo/bulk-enrich-person')) {
-        return new Response(JSON.stringify({
-          error: false,
-          results: [{ identifier: 'p1', error: true, person: null }],
-          total_cost: 0,
-        }), { status: 200 })
-      }
-      if (u.includes('/fullenrich/contact/enrich/bulk') && !u.includes('/fullenrich/contact/enrich/bulk/')) {
-        // Throw so fullEnrichStep rejects
-        throw new Error('FullEnrich network failure')
-      }
-      if (u.includes('/findymail/search/name')) {
-        return new Response(JSON.stringify({ email: 'alice@example.com' }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const resultPromise = findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
-    })
-
-    // Advance timers past the FullEnrich poll sleep
-    await vi.runAllTimersAsync()
-    const result = await resultPromise
-
-    vi.useRealTimers()
-
-    // Despite fullEnrichStep throwing, the handler must succeed
-    expect(result.isError).toBeFalsy()
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.found).toBe(1)
-    expect(parsed.data.results[0]).toMatchObject({ id: 'p1', email: 'alice@example.com', provider: 'findymail' })
-  })
-
-  it('FullEnrich poll bails after 3 consecutive errors instead of polling to the 45s deadline', async () => {
-    // Regression: a 502-ing FullEnrich poll used to `continue` every 2s for the full
-    // 45s deadline (~22 polls) — pure latency on the chunk's critical path with zero
-    // emails. It must now stop after COLDIQ_MAX_POLL_ERRORS (default 3) consecutive errors.
-    vi.useFakeTimers()
-
-    let fePollCount = 0
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/prospeo/bulk-enrich-person')) {
-        return new Response(
-          JSON.stringify({ error: false, results: [{ identifier: 'p1', error: true, person: null }], total_cost: 0 }),
-          { status: 200 },
-        )
-      }
-      // FullEnrich poll (has the id segment) — always 502.
-      if (u.includes('/fullenrich/contact/enrich/bulk/abc-fe-err')) {
-        fePollCount++
-        return new Response(JSON.stringify({ error: 'bad gateway' }), { status: 502 })
-      }
-      // FullEnrich create.
-      if (u.includes('/fullenrich/contact/enrich/bulk')) {
-        return new Response(JSON.stringify({ enrichment_id: 'abc-fe-err' }), { status: 200 })
-      }
-      // FindyMail / IcyPeas / single-fallback all miss cleanly (no email, no failure).
-      return new Response(JSON.stringify({ email: null }), { status: 200 })
-    }) as typeof fetch
-
-    const handlerPromise = findEmailsHandler({
-      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
-    })
-
-    await vi.runAllTimersAsync()
-    const result = await handlerPromise
-    vi.useRealTimers()
-
-    // Bailed at the 3-error cap, not the ~22 polls that 45000/2000 would have produced.
-    expect(fePollCount).toBe(3)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.providers.fullenrich).toEqual({ attempted: 1, failed: 1 })
-  })
-
-  it('falls back to single find_email waterfall when bulk providers all miss (covers limadata/blitzapi/linkupapi gap)', async () => {
-    // Bulk path: Prospeo + FullEnrich + Findymail + Icypeas all miss.
-    // Single-only providers (limadata-work-email, blitzapi, limadata-work-email-linkedin, linkupapi)
-    // should be tried; blitzapi finds the email.
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/prospeo/bulk-enrich-person')) {
-        return new Response(
-          JSON.stringify({ error: false, results: [{ identifier: 'p1', error: true, person: null }], total_cost: 0 }),
-          { status: 200 },
-        )
-      }
-      if (u.includes('/fullenrich/contact/enrich/bulk')) {
-        // No enrichment_id returned → fullEnrichStep exits early without polling
-        return new Response(JSON.stringify({}), { status: 200 })
-      }
-      if (u.includes('/findymail/search/name')) {
-        return new Response(JSON.stringify({ email: null }), { status: 200 })
-      }
-      if (u.includes('/icypeas/email-search')) {
-        return new Response(JSON.stringify({ email: null }), { status: 200 })
-      }
-      // Single-only providers — limadata first (per priority), then blitzapi.
-      if (u.includes('/coldiq/find/work-email-linkedin')) {
-        return new Response(JSON.stringify({ email: null }), { status: 200 })
-      }
-      if (u.includes('/coldiq/find/work-email')) {
-        return new Response(JSON.stringify({ email: null }), { status: 200 })
-      }
-      if (u.includes('/blitzapi/enrichment/find-work-email')) {
-        return new Response(JSON.stringify({ email: 'alice@example.com' }), { status: 200 })
-      }
-      if (u.includes('/linkupapi/data/mail/finder')) {
-        return new Response(JSON.stringify({ email: null }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected', url: u }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await findEmailsHandler({
-      people: [{
-        id: 'p1',
-        first_name: 'Alice',
-        last_name: 'Smith',
-        domain: 'example.com',
-        linkedin_url: 'https://linkedin.com/in/alice',
-      }],
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.found).toBe(1)
-    expect(parsed.data.results[0]).toMatchObject({ id: 'p1', email: 'alice@example.com', provider: 'blitzapi' })
-  })
-})
-
-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()
-  })
-})