@coldiq/mcp 0.3.12 → 0.3.13

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

@@ -1,621 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { findPeopleHandler } from '../../src/tools/find-people.js'
-
-describe('find_people handler', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('falls back to Apollo when LeadsFactory async times out', async () => {
-    let callCount = 0
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      callCount++
-      const urlStr = url.toString()
-
-      // LeadsFactory create search — returns an ID
-      if (urlStr.includes('/leadsfactory/contact-finder/searches') && callCount === 1) {
-        return new Response(JSON.stringify({ id: 'abc123', search_id: 'abc', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
-      }
-
-      // LeadsFactory poll — always RUNNING (will timeout)
-      if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
-        return new Response(JSON.stringify({ id: 'abc123', search_id: 'abc', status: 'RUNNING', nb_jobs_total: 1, progress_percentage: 50 }), { status: 200 })
-      }
-
-      // Apollo — succeeds
-      if (urlStr.includes('/apollo/people/search')) {
-        return new Response(JSON.stringify({ people: [{ name: 'Michel Lieben', title: 'CEO', organization: { website_url: 'coldiq.com' } }] }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    // Override timeout to 100ms so test runs fast
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('find_people')
-    const lf = providers.find((p) => p.id === 'leadsfactory')!
-    const originalTimeout = lf.async!.timeoutMs
-    const originalInterval = lf.async!.pollIntervalMs
-
-    try {
-      lf.async!.timeoutMs = 100
-      lf.async!.pollIntervalMs = 20
-      const result = await findPeopleHandler({
-        company_domains: ['coldiq.com'],
-        job_titles: ['CEO'],
-        limit: 5,
-      })
-
-      const parsed = JSON.parse(result.content[0].text)
-      // Should fall back to Apollo since LeadsFactory times out
-      expect(parsed._meta.provider).toBe('apollo')
-    } finally {
-      lf.async!.timeoutMs = originalTimeout
-      lf.async!.pollIntervalMs = originalInterval
-    }
-  })
-
-  it('returns LeadsFactory results when poll completes with companies_personas', async () => {
-    let callCount = 0
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      callCount++
-      const urlStr = url.toString()
-
-      // LeadsFactory create search
-      if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        return new Response(JSON.stringify({ id: 'abc123', search_id: 'abc', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
-      }
-
-      // LeadsFactory poll — first RUNNING, then SUCCESSFUL with contacts
-      if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
-        if (callCount <= 3) {
-          return new Response(JSON.stringify({ id: 'abc123', search_id: 'abc', status: 'RUNNING', nb_jobs_total: 1, progress_percentage: 50 }), { status: 200 })
-        }
-        return new Response(JSON.stringify({
-          id: 'abc123',
-          search_id: 'abc',
-          status: 'SUCCESSFUL',
-          nb_jobs_total: 1,
-          nb_jobs_complete: 1,
-          companies_personas: [
-            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel', last_name: 'Lieben', title: 'CEO' } }]] },
-          ],
-        }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('find_people')
-    const lf = providers.find((p) => p.id === 'leadsfactory')!
-    const originalTimeout = lf.async!.timeoutMs
-    const originalInterval = lf.async!.pollIntervalMs
-
-    try {
-      lf.async!.timeoutMs = 500
-      lf.async!.pollIntervalMs = 20
-      const result = await findPeopleHandler({
-        company_domains: ['coldiq.com'],
-        job_titles: ['CEO'],
-        limit: 5,
-      })
-
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('leadsfactory')
-      // Compact-by-default: raw `companies_personas` is normalized into `people[]`.
-      expect(parsed.data.people).toHaveLength(1)
-      expect(parsed.data.people[0]).toMatchObject({
-        full_name: 'Michel Lieben',
-        first_name: 'Michel',
-        last_name: 'Lieben',
-        title: 'CEO',
-      })
-      expect(parsed.data.companies_personas).toBeUndefined()
-    } finally {
-      lf.async!.timeoutMs = originalTimeout
-      lf.async!.pollIntervalMs = originalInterval
-    }
-  })
-
-  it('fields=verbose returns the raw LeadsFactory passthrough (companies_personas) unchanged', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const urlStr = url.toString()
-      if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        return new Response(JSON.stringify({ id: 'abc123', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
-      }
-      if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
-        return new Response(JSON.stringify({
-          id: 'abc123', status: 'SUCCESSFUL', nb_jobs_total: 1, nb_jobs_complete: 1,
-          companies_personas: [
-            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel', last_name: 'Lieben', title: 'CEO' } }]] },
-          ],
-        }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const lf = getProviders('find_people').find((p) => p.id === 'leadsfactory')!
-    const originalTimeout = lf.async!.timeoutMs
-    const originalInterval = lf.async!.pollIntervalMs
-
-    try {
-      lf.async!.timeoutMs = 500
-      lf.async!.pollIntervalMs = 20
-      const result = await findPeopleHandler({
-        company_domains: ['coldiq.com'],
-        job_titles: ['CEO'],
-        limit: 5,
-        fields: 'verbose',
-      })
-
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('leadsfactory')
-      expect(parsed.data.companies_personas).toHaveLength(1)
-      expect(parsed.data.people).toBeUndefined()
-    } finally {
-      lf.async!.timeoutMs = originalTimeout
-      lf.async!.pollIntervalMs = originalInterval
-    }
-  })
-
-  it('gap-fills with Apollo for domains LeadsFactory missed (no_results_domains)', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
-      const urlStr = url.toString()
-
-      // LeadsFactory create
-      if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        return new Response(JSON.stringify({ id: 'abc123', search_id: 'abc', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
-      }
-
-      // LeadsFactory poll — SUCCESSFUL with one miss.
-      // Real upstream shape: companies_personas[].personas is unknown[][], each
-      // inner item wraps a contact object. The hasResult check counts contacts
-      // across all entries, so mocks must use this nested shape to match prod.
-      if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
-        return new Response(JSON.stringify({
-          id: 'abc123', search_id: 'abc', status: 'SUCCESSFUL',
-          nb_jobs_total: 2, nb_jobs_complete: 2,
-          companies_personas: [
-            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel', last_name: 'Lieben' } }]] },
-          ],
-          no_results_domains: ['folk.app'],
-        }), { status: 200 })
-      }
-
-      // Apollo gap-fill for folk.app
-      if (urlStr.includes('/apollo/people/search')) {
-        const body = JSON.parse((opts?.body as string) ?? '{}')
-        if (body.q_organization_domains?.includes('folk.app')) {
-          return new Response(JSON.stringify({ people: [{ name: 'Thibaud Elziere', title: 'CEO', organization: { website_url: 'folk.app' } }] }), { status: 200 })
-        }
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('find_people')
-    const lf = providers.find((p) => p.id === 'leadsfactory')!
-    const originalTimeout = lf.async!.timeoutMs
-    const originalInterval = lf.async!.pollIntervalMs
-
-    try {
-      lf.async!.timeoutMs = 500
-      lf.async!.pollIntervalMs = 20
-      const result = await findPeopleHandler({
-        company_domains: ['coldiq.com', 'folk.app'],
-        job_titles: ['CEO'],
-        limit: 2,
-      })
-
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('leadsfactory')
-      // Compact-by-default: LF + Apollo gap-fill records are merged into one people[]
-      // and the gap-fill source is surfaced via gap_fill_provider.
-      expect(parsed.data.people).toHaveLength(2)
-      expect(parsed.data.people.map((p: { full_name: string }) => p.full_name)).toEqual(['Michel Lieben', 'Thibaud Elziere'])
-      expect(parsed.data.gap_fill_provider).toBe('apollo')
-      expect(parsed.data.companies_personas).toBeUndefined()
-      expect(parsed.data.gap_fill).toBeUndefined()
-    } finally {
-      lf.async!.timeoutMs = originalTimeout
-      lf.async!.pollIntervalMs = originalInterval
-    }
-  })
-
-  it('skips gap-fill when input used LinkedIn URLs (no trusted domains to pass Apollo)', async () => {
-    let apolloCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const urlStr = url.toString()
-
-      if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        return new Response(JSON.stringify({ id: 'abc123', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
-      }
-
-      if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
-        return new Response(JSON.stringify({
-          id: 'abc123', status: 'SUCCESSFUL', nb_jobs_total: 2, nb_jobs_complete: 2,
-          companies_personas: [
-            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel' } }]] },
-          ],
-          no_results_domains: ['folk.app'],
-        }), { status: 200 })
-      }
-
-      if (urlStr.includes('/apollo/people/search')) {
-        apolloCalled = true
-        return new Response(JSON.stringify({ people: [{ name: 'Thibaud Elziere' }] }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('find_people')
-    const lf = providers.find((p) => p.id === 'leadsfactory')!
-    const originalTimeout = lf.async!.timeoutMs
-    const originalInterval = lf.async!.pollIntervalMs
-
-    try {
-      lf.async!.timeoutMs = 500
-      lf.async!.pollIntervalMs = 20
-      const result = await findPeopleHandler({
-        company_linkedin_urls: ['https://linkedin.com/company/coldiq', 'https://linkedin.com/company/folk'],
-        job_titles: ['CEO'],
-        limit: 2,
-      })
-
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('leadsfactory')
-      expect(parsed.data.gap_fill_provider).toBeUndefined()
-      expect(apolloCalled).toBe(false)
-    } finally {
-      lf.async!.timeoutMs = originalTimeout
-      lf.async!.pollIntervalMs = originalInterval
-    }
-  })
-
-  it('does not pass company_domains to LeadsFactory when LinkedIn URLs are provided', async () => {
-    let capturedBody: Record<string, unknown> | null = null
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
-      const urlStr = url.toString()
-
-      if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
-        return new Response(JSON.stringify({ id: 'abc123', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
-      }
-
-      if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
-        return new Response(JSON.stringify({
-          id: 'abc123', status: 'SUCCESSFUL', nb_jobs_total: 2, nb_jobs_complete: 2,
-          companies_personas: [
-            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel' } }]] },
-          ],
-        }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('find_people')
-    const lf = providers.find((p) => p.id === 'leadsfactory')!
-    const originalTimeout = lf.async!.timeoutMs
-    const originalInterval = lf.async!.pollIntervalMs
-
-    try {
-      lf.async!.timeoutMs = 500
-      lf.async!.pollIntervalMs = 20
-      await findPeopleHandler({
-        company_linkedin_urls: ['https://linkedin.com/company/coldiq', 'https://linkedin.com/company/folk'],
-        company_domains: ['coldiq.com', 'folk.app'],
-        job_titles: ['CEO'],
-        limit: 2,
-      })
-
-      expect(capturedBody).not.toBeNull()
-      expect(capturedBody!.company_linkedin_urls).toBeDefined()
-      expect(capturedBody!.company_domains).toBeUndefined()
-    } finally {
-      lf.async!.timeoutMs = originalTimeout
-      lf.async!.pollIntervalMs = originalInterval
-    }
-  })
-
-  it('sends each job title as a separate persona to LeadsFactory', async () => {
-    let capturedBody: Record<string, unknown> | null = null
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
-      const urlStr = url.toString()
-
-      if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
-        return new Response(JSON.stringify({ id: 'abc123', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
-      }
-
-      if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
-        return new Response(JSON.stringify({
-          id: 'abc123', status: 'SUCCESSFUL', nb_jobs_total: 1, nb_jobs_complete: 1,
-          companies_personas: [
-            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel' } }]] },
-          ],
-        }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('find_people')
-    const lf = providers.find((p) => p.id === 'leadsfactory')!
-    const originalTimeout = lf.async!.timeoutMs
-    const originalInterval = lf.async!.pollIntervalMs
-
-    try {
-      lf.async!.timeoutMs = 500
-      lf.async!.pollIntervalMs = 20
-      await findPeopleHandler({
-        company_domains: ['coldiq.com'],
-        job_titles: ['CEO', 'VP of Sales'],
-        limit: 10,
-      })
-
-      expect(capturedBody).not.toBeNull()
-      expect(capturedBody!.search).toMatchObject({
-        max_persona_results: 10,
-        personas: [{ job_title: 'CEO' }, { job_title: 'VP of Sales' }],
-      })
-    } finally {
-      lf.async!.timeoutMs = originalTimeout
-      lf.async!.pollIntervalMs = originalInterval
-    }
-  })
-
-  it('falls back to Apollo when LeadsFactory fails', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const urlStr = url.toString()
-
-      if (urlStr.includes('/leadsfactory/')) {
-        return new Response(JSON.stringify({ error: 'Provider error' }), { status: 502 })
-      }
-
-      if (urlStr.includes('/apollo/people/search')) {
-        return new Response(JSON.stringify({ people: [{ name: 'Michel Lieben', organization: { website_url: 'coldiq.com' } }] }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const result = await findPeopleHandler({
-      company_domains: ['coldiq.com'],
-      job_titles: ['CEO'],
-      limit: 5,
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('apollo')
-    expect(parsed.data.people).toHaveLength(1)
-    expect(parsed.data.people[0]).toMatchObject({
-      full_name: 'Michel Lieben',
-      company_domain: 'coldiq.com',
-    })
-  })
-
-  it('reveal=true follows obfuscated Apollo search with bulk-match in chunks of 10', async () => {
-    const bulkMatchCalls: Array<{ url: string; body: Record<string, unknown> }> = []
-    const obfuscated = (id: string, n: number) => ({
-      id,
-      first_name: `Person${n}`,
-      last_name: `Ar***t${n}`,
-      organization: { website_url: 'coldiq.com' },
-    })
-    const revealed = (id: string, n: number) => ({
-      id,
-      first_name: `Person${n}`,
-      last_name: `Argent${n}`,
-      email: `person${n}@coldiq.com`,
-      linkedin_url: `https://linkedin.com/in/person${n}`,
-      organization: { website_url: 'coldiq.com' },
-    })
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
-      const urlStr = url.toString()
-
-      if (urlStr.includes('/apollo/people/search')) {
-        return new Response(
-          JSON.stringify({ people: Array.from({ length: 12 }, (_, i) => obfuscated(`id_${i}`, i)) }),
-          { status: 200 },
-        )
-      }
-
-      if (urlStr.includes('/apollo/people/bulk-match')) {
-        const body = JSON.parse((opts?.body as string) ?? '{}') as { details: Array<{ id: string }> }
-        bulkMatchCalls.push({ url: urlStr, body })
-        return new Response(
-          JSON.stringify({
-            matches: body.details.map((d, idx) => revealed(d.id, parseInt(d.id.replace('id_', ''), 10) || idx)),
-          }),
-          { status: 200 },
-        )
-      }
-
-      // Skip LeadsFactory entirely by pinning apollo via use_providers below.
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const result = await findPeopleHandler({
-      company_domains: ['coldiq.com'],
-      job_titles: ['CEO'],
-      limit: 12,
-      reveal: true,
-      use_providers: ['apollo'],
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('apollo')
-    expect(parsed.data.revealed).toBe(true)
-    expect(parsed.data.people).toHaveLength(12)
-    // Chunked at 10 per bulk-match call: 12 IDs → 2 calls (10 + 2)
-    expect(bulkMatchCalls).toHaveLength(2)
-    expect(bulkMatchCalls[0].body.details).toHaveLength(10)
-    expect(bulkMatchCalls[1].body.details).toHaveLength(2)
-    // Revealed payload (compacted) carries email + full last name
-    expect(parsed.data.people[0].email).toBe('person0@coldiq.com')
-    expect(parsed.data.people[0].last_name).toBe('Argent0')
-    // reveal_personal_emails flag forwarded
-    expect(bulkMatchCalls[0].body.reveal_personal_emails).toBe(true)
-  })
-
-  it('reveal=true does NOT set revealed:true when bulk-match returns only some IDs (partial reveal)', async () => {
-    // Apollo's bulk-match can return matches for a subset of submitted IDs (e.g. some
-    // people aren't in their database). Setting `revealed: true` in that case would
-    // mislead callers — entries still obfuscated would look revealed at the top level.
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
-      const urlStr = url.toString()
-
-      if (urlStr.includes('/apollo/people/search')) {
-        return new Response(
-          JSON.stringify({
-            people: [
-              { id: 'id_0', first_name: 'A', last_name: 'A***A', organization: { website_url: 'coldiq.com' } },
-              { id: 'id_1', first_name: 'B', last_name: 'B***B', organization: { website_url: 'coldiq.com' } },
-              { id: 'id_2', first_name: 'C', last_name: 'C***C', organization: { website_url: 'coldiq.com' } },
-            ],
-          }),
-          { status: 200 },
-        )
-      }
-
-      if (urlStr.includes('/apollo/people/bulk-match')) {
-        const body = JSON.parse((opts?.body as string) ?? '{}') as { details: Array<{ id: string }> }
-        // Only return a match for id_0 — id_1 and id_2 stay obfuscated.
-        const onlyFirst = body.details
-          .filter((d) => d.id === 'id_0')
-          .map((d) => ({ id: d.id, first_name: 'A', last_name: 'AlphaReal', email: 'a@coldiq.com', linkedin_url: 'https://linkedin.com/in/a', organization: { website_url: 'coldiq.com' } }))
-        return new Response(JSON.stringify({ matches: onlyFirst }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const result = await findPeopleHandler({
-      company_domains: ['coldiq.com'],
-      job_titles: ['CEO'],
-      limit: 3,
-      reveal: true,
-      use_providers: ['apollo'],
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('apollo')
-    // Partial reveal: flag must be omitted (compactPayload only includes revealed when === true).
-    expect(parsed.data.revealed).toBeUndefined()
-    expect(parsed.data.people).toHaveLength(3)
-    // id_0 came back revealed; id_1/id_2 stayed obfuscated.
-    expect(parsed.data.people[0].last_name).toBe('AlphaReal')
-    expect(parsed.data.people[0].email).toBe('a@coldiq.com')
-    expect(parsed.data.people[1].last_name).toBe('B***B')
-    expect(parsed.data.people[2].last_name).toBe('C***C')
-  })
-
-  it('reveal=false (default) skips bulk-match and returns obfuscated Apollo data unchanged', async () => {
-    let bulkMatchCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const urlStr = url.toString()
-
-      if (urlStr.includes('/apollo/people/search')) {
-        return new Response(
-          JSON.stringify({
-            people: [{ id: 'id_0', first_name: 'Michel', last_name: 'Li***n', organization: { website_url: 'coldiq.com' } }],
-          }),
-          { status: 200 },
-        )
-      }
-
-      if (urlStr.includes('/apollo/people/bulk-match')) {
-        bulkMatchCalled = true
-        return new Response(JSON.stringify({ matches: [] }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const result = await findPeopleHandler({
-      company_domains: ['coldiq.com'],
-      job_titles: ['CEO'],
-      limit: 5,
-      use_providers: ['apollo'],
-    })
-
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('apollo')
-    expect(parsed.data.revealed).toBeUndefined()
-    // Obfuscated last name from /apollo/people/search is preserved through compaction.
-    expect(parsed.data.people[0].last_name).toBe('Li***n')
-    expect(bulkMatchCalled).toBe(false)
-  })
-
-  it('reveal=true is a no-op when the matched provider is not Apollo', async () => {
-    let bulkMatchCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const urlStr = url.toString()
-
-      if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        return new Response(JSON.stringify({ id: 'abc123', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
-      }
-
-      if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
-        return new Response(JSON.stringify({
-          id: 'abc123', status: 'SUCCESSFUL', nb_jobs_total: 1, nb_jobs_complete: 1,
-          companies_personas: [
-            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel', last_name: 'Lieben' } }]] },
-          ],
-        }), { status: 200 })
-      }
-
-      if (urlStr.includes('/apollo/people/bulk-match')) {
-        bulkMatchCalled = true
-        return new Response(JSON.stringify({ matches: [] }), { status: 200 })
-      }
-
-      return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const lf = getProviders('find_people').find((p) => p.id === 'leadsfactory')!
-    const originalTimeout = lf.async!.timeoutMs
-    const originalInterval = lf.async!.pollIntervalMs
-
-    try {
-      lf.async!.timeoutMs = 500
-      lf.async!.pollIntervalMs = 20
-
-      const result = await findPeopleHandler({
-        company_domains: ['coldiq.com'],
-        job_titles: ['CEO'],
-        limit: 5,
-        reveal: true,
-      })
-
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('leadsfactory')
-      expect(bulkMatchCalled).toBe(false)
-    } finally {
-      lf.async!.timeoutMs = originalTimeout
-      lf.async!.pollIntervalMs = originalInterval
-    }
-  })
-})