@coldiq/mcp 0.1.0

package/tests/tools/enrich-company.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { enrichCompanyHandler } from '../../src/tools/enrich-company.js'
+
+describe('enrich_company handler', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('returns error when no identifier provided', async () => {
+    const result = await enrichCompanyHandler({})
+    expect(result.isError).toBe(true)
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.error).toMatch(/domain.*linkedin_url.*name/i)
+  })
+
+  it('returns enriched company from CompanyEnrich (GET)', async () => {
+    let capturedUrl = ''
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      capturedUrl = url.toString()
+      return new Response(JSON.stringify({ name: 'Stripe', domain: 'stripe.com', employees: 8000 }), { status: 200 })
+    }) as typeof fetch
+
+    const result = await enrichCompanyHandler({ domain: 'stripe.com' })
+
+    expect(capturedUrl).toContain('domain=stripe.com')
+    expect(capturedUrl).toContain('/companyenrich/companies/enrich')
+
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('companyenrich')
+    expect(parsed.data.name).toBe('Stripe')
+  })
+
+  it('falls back to Apollo on CompanyEnrich failure', async () => {
+    let callCount = 0
+    globalThis.fetch = vi.fn(async () => {
+      callCount++
+      if (callCount === 1) {
+        return new Response(JSON.stringify({ error: 'Provider error' }), { status: 502 })
+      }
+      return new Response(JSON.stringify({ organization: { name: 'Stripe' } }), { status: 200 })
+    }) as typeof fetch
+
+    const result = await enrichCompanyHandler({ domain: 'stripe.com' })
+
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('apollo')
+  })
+
+  it('skips CompanyEnrich GET and Apollo when only linkedin_url is provided', async () => {
+    const calledEndpoints: string[] = []
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const endpoint = url.toString()
+      calledEndpoints.push(endpoint)
+      // PDL (3rd provider) succeeds
+      if (endpoint.includes('/pdl/company/enrich')) {
+        return new Response(JSON.stringify({ name: 'Stripe', website: 'stripe.com' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'not found' }), { status: 404 })
+    }) as typeof fetch
+
+    const result = await enrichCompanyHandler({ linkedin_url: 'https://www.linkedin.com/company/stripe' })
+
+    expect(calledEndpoints.every((u) => !u.includes('/companyenrich/companies/enrich?'))).toBe(true)
+    expect(calledEndpoints.every((u) => !u.includes('/apollo/'))).toBe(true)
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('pdl')
+  })
+
+  it('skips all domain-only providers when only name is provided', async () => {
+    const calledEndpoints: string[] = []
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const endpoint = url.toString()
+      calledEndpoints.push(endpoint)
+      if (endpoint.includes('/pdl/company/enrich')) {
+        return new Response(JSON.stringify({ name: 'Stripe', website: 'stripe.com' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'not found' }), { status: 404 })
+    }) as typeof fetch
+
+    await enrichCompanyHandler({ name: 'Stripe' })
+
+    expect(calledEndpoints.every((u) => !u.includes('/companyenrich/companies/enrich?'))).toBe(true)
+    expect(calledEndpoints.every((u) => !u.includes('/apollo/'))).toBe(true)
+  })
+})

package/tests/tools/enrich-email.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { findEmailHandler as enrichEmailHandler } from '../../src/tools/find-email.js'
+
+describe('find_email handler (waterfall)', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('returns email from first provider that finds one', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ email: 'michel@coldiq.com' }), { status: 200 })
+    ) as typeof fetch
+
+    const result = await enrichEmailHandler({
+      first_name: 'Michel',
+      last_name: 'Lieben',
+      domain: 'coldiq.com',
+    })
+
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('findymail')
+    expect(parsed.data.email).toBe('michel@coldiq.com')
+  })
+
+  it('falls through to IcyPeas when FindyMail has no result', async () => {
+    let callCount = 0
+    globalThis.fetch = vi.fn(async () => {
+      callCount++
+      if (callCount === 1) {
+        // FindyMail — no email found
+        return new Response(JSON.stringify({ email: null }), { status: 200 })
+      }
+      // IcyPeas — found
+      return new Response(JSON.stringify({ email: 'michel@coldiq.com' }), { status: 200 })
+    }) as typeof fetch
+
+    const result = await enrichEmailHandler({
+      first_name: 'Michel',
+      last_name: 'Lieben',
+      domain: 'coldiq.com',
+    })
+
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('icypeas')
+  })
+
+  it('falls through to Prospeo when FindyMail and IcyPeas both fail', async () => {
+    let callCount = 0
+    globalThis.fetch = vi.fn(async () => {
+      callCount++
+      if (callCount <= 2) {
+        return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
+      }
+      // Prospeo success response — email is nested under person.email.email
+      return new Response(
+        JSON.stringify({ error: false, person: { email: { email: 'michel@coldiq.com', status: 'VERIFIED' } } }),
+        { status: 200 },
+      )
+    }) as typeof fetch
+
+    const result = await enrichEmailHandler({
+      first_name: 'Michel',
+      last_name: 'Lieben',
+      domain: 'coldiq.com',
+    })
+
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('prospeo')
+  })
+
+  it('returns error when all providers fail', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
+    ) as typeof fetch
+
+    const result = await enrichEmailHandler({
+      first_name: 'Unknown',
+      last_name: 'Person',
+      domain: 'unknown.xyz',
+    })
+
+    expect(result.isError).toBe(true)
+    const parsed = JSON.parse(result.content[0].text)
+    // No linkedin_url → blitzapi and limadata-work-email-linkedin are skipped via isApplicable
+    expect(parsed.providers_tried.length).toBe(6) // findymail, icypeas, limadata-work-email, prospeo, fullenrich, linkupapi
+  })
+})

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

@@ -0,0 +1,271 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { findEmailsHandler as enrichEmailsHandler } 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 enrichEmailsHandler({
+      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' },
+      { id: 'p2', email: 'bob@example.com', provider: '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 enrichEmailsHandler({
+      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' })
+  })
+
+  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 enrichEmailsHandler({
+      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' })
+  })
+
+  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 enrichEmailsHandler({
+      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 })
+  })
+
+  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 enrichEmailsHandler({
+      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 enrichEmailsHandler({
+      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 index', async () => {
+    vi.useFakeTimers()
+
+    let feCreateCalled = false
+    let fePollCalled = 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('/fullenrich/contact/enrich/bulk/abc-fe-123')) {
+        fePollCalled = true
+        return new Response(JSON.stringify({
+          status: 'DONE',
+          data: [{ emails: ['alice@example.com'] }],
+        }), { status: 200 })
+      }
+
+      if (u.includes('/fullenrich/contact/enrich/bulk')) {
+        feCreateCalled = true
+        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 = enrichEmailsHandler({
+      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
+    })
+
+    await vi.runAllTimersAsync()
+    const result = await handlerPromise
+    vi.useRealTimers()
+
+    expect(feCreateCalled).toBe(true)
+    expect(fePollCalled).toBe(true)
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.data.results[0]).toEqual({ id: 'p1', email: 'alice@example.com', provider: 'fullenrich' })
+  })
+
+  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 enrichEmailsHandler({
+      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
+}

package/tests/tools/enrich-person.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { enrichPersonHandler } from '../../src/tools/enrich-person.js'
+
+describe('enrich_person handler', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('email input — linkupapi-email-reverse wins on first try', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/linkupapi/data/profil/enrich')) {
+        // profile-enrich not applicable for email-only, should not be called
+        throw new Error('profile-enrich should not fire for email-only input')
+      }
+      if (u.includes('/linkupapi/data/mail/reverse')) {
+        return new Response(JSON.stringify({ status: 'success', data: { linkedin_url: 'https://linkedin.com/in/michel-lieben', name: 'Michel Lieben' } }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await enrichPersonHandler({ email: 'michel@coldiq.com' })
+
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('linkupapi-email-reverse')
+    // linkupapi wraps: { status, data: { ... } }
+    expect(parsed.data.data.linkedin_url).toContain('linkedin.com')
+  })
+
+  it('email input — falls back to pdl-person-enrich when linkupapi-email-reverse returns empty', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/linkupapi/data/mail/reverse')) {
+        // hasResult fails: status not 'success'
+        return new Response(JSON.stringify({ status: 'not_found', data: null }), { status: 200 })
+      }
+      if (u.includes('/pdl/person/enrich')) {
+        return new Response(JSON.stringify({ status: 200, data: { full_name: 'Michel Lieben', linkedin_url: 'https://linkedin.com/in/michel-lieben' } }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await enrichPersonHandler({ email: 'michel@coldiq.com' })
+
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('pdl-person-enrich')
+    // PDL wraps: { status: 200, data: { ... } }
+    expect(parsed.data.data.full_name).toBe('Michel Lieben')
+  })
+
+  it('name+company input — linkupapi-profile-enrich wins (highest priority for this input type)', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/linkupapi/data/profil/enrich')) {
+        return new Response(JSON.stringify({ status: 'success', data: { linkedin_url: 'https://linkedin.com/in/michel-lieben', headline: 'CEO at ColdIQ' } }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await enrichPersonHandler({ first_name: 'Michel', last_name: 'Lieben', company_name: 'ColdIQ' })
+
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('linkupapi-profile-enrich')
+    // linkupapi wraps: { status, data: { ... } }
+    expect(parsed.data.data.headline).toBe('CEO at ColdIQ')
+  })
+
+  it('linkedin_url input — findymail-business-profile wins after non-applicable providers are skipped', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      // linkupapi-profile-enrich not applicable (no first_name)
+      // linkupapi-email-reverse not applicable (no email)
+      // pdl-person-enrich fires but returns no match
+      if (u.includes('/pdl/person/enrich')) {
+        return new Response(JSON.stringify({ status: 404, data: null }), { status: 200 })
+      }
+      // apollo-people-match fires but returns no person
+      if (u.includes('/apollo/people/match')) {
+        return new Response(JSON.stringify({ person: null }), { status: 200 })
+      }
+      // blitzapi-reverse-email not applicable (no email)
+      // findymail-business-profile: applicable (linkedin_url present)
+      if (u.includes('/findymail/search/business-profile')) {
+        return new Response(JSON.stringify({ name: 'Michel Lieben', email: 'michel@coldiq.com', linkedin_url: 'https://linkedin.com/in/michel-lieben' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await enrichPersonHandler({ linkedin_url: 'https://www.linkedin.com/in/michel-lieben' })
+
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('findymail-business-profile')
+    expect(parsed.data.name).toBe('Michel Lieben')
+  })
+
+  it('phone input — ai-ark-reverse-lookup wins (gated on phone present)', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/pdl/person/enrich')) {
+        return new Response(JSON.stringify({ status: 404, data: null }), { status: 200 })
+      }
+      if (u.includes('/apollo/people/match')) {
+        return new Response(JSON.stringify({ person: null }), { status: 200 })
+      }
+      if (u.includes('/ai-ark/people/reverse-lookup')) {
+        return new Response(JSON.stringify({ name: 'Michel Lieben', email: 'michel@coldiq.com' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await enrichPersonHandler({ phone: '+32123456789' })
+
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('ai-ark-reverse-lookup')
+  })
+
+  it('all providers fail — returns isError with error object', async () => {
+    globalThis.fetch = vi.fn(async () => {
+      return new Response(JSON.stringify({ error: 'Provider unavailable' }), { status: 503 })
+    }) as typeof fetch
+
+    const result = await enrichPersonHandler({ email: 'michel@coldiq.com' })
+
+    expect(result.isError).toBe(true)
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.error).toBeTruthy()
+  })
+})