@coldiq/mcp 0.3.12 → 0.3.13

package/tests/verb-client.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// Mock the HTTP client so callVerb's envelope-building can be asserted without
+// touching the network. The factory returns a vi.fn() we capture below.
+const callApiMock = vi.fn()
+vi.mock('../src/client.js', () => ({
+  callApi: (...args: unknown[]) => callApiMock(...args),
+}))
+
+import { callVerb } from '../src/verb-client.js'
+
+beforeEach(() => {
+  callApiMock.mockReset()
+  callApiMock.mockResolvedValue({ ok: true, status: 200, data: { data: { ok: true }, _meta: {} }, headers: {} })
+})
+
+describe('callVerb', () => {
+  it('maps single input into envelope.input and forwards the verb path', async () => {
+    await callVerb('/email/find', { first_name: 'Michel', last_name: 'Lieben', domain: 'coldiq.com' })
+
+    expect(callApiMock).toHaveBeenCalledTimes(1)
+    const [method, path, envelope] = callApiMock.mock.calls[0]
+    expect(method).toBe('POST')
+    expect(path).toBe('/email/find')
+    expect(envelope).toEqual({
+      input: { first_name: 'Michel', last_name: 'Lieben', domain: 'coldiq.com' },
+    })
+  })
+
+  it('maps use_providers (non-empty array) to envelope.provider and keeps it out of input', async () => {
+    await callVerb('/email/find', {
+      first_name: 'Michel',
+      domain: 'coldiq.com',
+      use_providers: ['prospeo', 'fullenrich'],
+    })
+
+    const [, , envelope] = callApiMock.mock.calls[0]
+    expect(envelope.provider).toEqual(['prospeo', 'fullenrich'])
+    expect(envelope.input).toEqual({ first_name: 'Michel', domain: 'coldiq.com' })
+    expect(envelope.input).not.toHaveProperty('use_providers')
+  })
+
+  it('omits provider when use_providers is empty or absent', async () => {
+    await callVerb('/email/find', { domain: 'coldiq.com', use_providers: [] })
+    const [, , envelope] = callApiMock.mock.calls[0]
+    expect(envelope).not.toHaveProperty('provider')
+  })
+
+  it('passes fields and reveal through to the envelope', async () => {
+    await callVerb('/people/search', {
+      job_titles: ['CEO'],
+      fields: 'verbose',
+      reveal: true,
+    })
+
+    const [, , envelope] = callApiMock.mock.calls[0]
+    expect(envelope.fields).toBe('verbose')
+    expect(envelope.reveal).toBe(true)
+    expect(envelope.input).toEqual({ job_titles: ['CEO'] })
+  })
+
+  it('only sets fields/reveal when defined', async () => {
+    await callVerb('/people/search', { job_titles: ['CEO'] })
+    const [, , envelope] = callApiMock.mock.calls[0]
+    expect(envelope).not.toHaveProperty('fields')
+    expect(envelope).not.toHaveProperty('reveal')
+  })
+
+  it('bulk mode maps the named list field to inputs[]', async () => {
+    const people = [
+      { id: 'a', first_name: 'Michel', last_name: 'Lieben', domain: 'coldiq.com' },
+      { id: 'b', first_name: 'Ada', last_name: 'Lovelace', domain: 'microsoft.com' },
+    ]
+    await callVerb('/email/find', { people, use_providers: ['prospeo'] }, { bulkField: 'people' })
+
+    const [, , envelope] = callApiMock.mock.calls[0]
+    expect(envelope.inputs).toEqual(people)
+    expect(envelope).not.toHaveProperty('input')
+    expect(envelope.provider).toEqual(['prospeo'])
+  })
+
+  it('bulk mode merges sibling rest fields alongside inputs', async () => {
+    await callVerb(
+      '/email/find',
+      { people: [{ id: 'a' }], country: 'US' },
+      { bulkField: 'people' },
+    )
+    const [, , envelope] = callApiMock.mock.calls[0]
+    expect(envelope.inputs).toEqual([{ id: 'a' }])
+    expect(envelope.country).toBe('US')
+  })
+
+  it('forwards res.data and does not set isError on a 2xx response', async () => {
+    callApiMock.mockResolvedValue({ ok: true, status: 200, data: { data: { email: 'x@y.com' } }, headers: {} })
+    const out = await callVerb('/email/find', { domain: 'coldiq.com' })
+
+    expect(out.content[0].type).toBe('text')
+    expect(JSON.parse(out.content[0].text)).toEqual({ data: { email: 'x@y.com' } })
+    expect(out.isError).toBe(false)
+  })
+
+  it('sets isError when the response is not ok', async () => {
+    callApiMock.mockResolvedValue({
+      ok: false,
+      status: 404,
+      data: { error: 'No usable result', providers_tried: ['prospeo'] },
+      headers: {},
+    })
+    const out = await callVerb('/email/find', { domain: 'coldiq.com' })
+
+    expect(out.isError).toBe(true)
+    expect(JSON.parse(out.content[0].text)).toEqual({ error: 'No usable result', providers_tried: ['prospeo'] })
+  })
+
+  // --- schema-drift mappings (find_phone / search_places / find_emails) ---
+
+  it('remap renames input keys before building the envelope (company_domain → domain)', async () => {
+    await callVerb('/phone/find', { first_name: 'Michel', company_domain: 'coldiq.com', company_name: 'ColdIQ' }, { remap: { company_domain: 'domain' } })
+    const [, , envelope] = callApiMock.mock.calls[0]
+    expect(envelope.input).toEqual({ first_name: 'Michel', domain: 'coldiq.com', company_name: 'ColdIQ' })
+    expect(envelope.input).not.toHaveProperty('company_domain')
+  })
+
+  it('providerFromField routes a tool-specific provider field into the provider pin', async () => {
+    await callVerb('/places/search', { query: 'coffee', provider: 'openmart' }, { providerFromField: 'provider' })
+    const [, , envelope] = callApiMock.mock.calls[0]
+    expect(envelope.provider).toEqual(['openmart'])
+    expect(envelope.input).toEqual({ query: 'coffee' })
+    expect(envelope.input).not.toHaveProperty('provider')
+  })
+
+  it('providerFromField defers to an explicit use_providers when both are present', async () => {
+    await callVerb('/places/search', { query: 'coffee', provider: 'openmart', use_providers: ['google_maps'] }, { providerFromField: 'provider' })
+    const [, , envelope] = callApiMock.mock.calls[0]
+    expect(envelope.provider).toEqual(['google_maps'])
+    expect(envelope.input).toEqual({ query: 'coffee' })
+  })
+
+  it('reattachIdField re-attaches each input id onto bulk results by index', async () => {
+    callApiMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      data: { results: [{ data: { email: 'm@coldiq.com' } }, { error: 'not found' }] },
+      headers: {},
+    })
+    const people = [{ id: 'michel', first_name: 'Michel', domain: 'coldiq.com' }, { id: 'ada', first_name: 'Ada', domain: 'microsoft.com' }]
+    const out = await callVerb('/email/find', { people }, { bulkField: 'people', reattachIdField: 'id' })
+    const results = JSON.parse(out.content[0].text).results
+    expect(results[0]).toEqual({ id: 'michel', data: { email: 'm@coldiq.com' } })
+    expect(results[1]).toEqual({ id: 'ada', error: 'not found' })
+  })
+})

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

@@ -1,92 +0,0 @@
-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-person.test.ts

@@ -1,140 +0,0 @@
-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()
-  })
-})

package/tests/tools/fetch-page-content.test.ts

@@ -1,108 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { fetchPageContentHandler } from '../../src/tools/fetch-page-content.js'
-
-describe('fetch_page_content handler', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('single URL — exa-contents returns results', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/exa/contents')) {
-        return new Response(JSON.stringify({
-          results: [{ url: 'https://coldiq.com', text: 'ColdIQ page text' }],
-        }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await fetchPageContentHandler({ urls: ['https://coldiq.com'] })
-
-    expect(result.isError).toBeFalsy()
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('exa-contents')
-    expect(parsed.data.results).toHaveLength(1)
-    expect(parsed.data.results[0].text).toBe('ColdIQ page text')
-  })
-
-  it('batch URLs — all returned in one call', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
-      const u = url.toString()
-      if (u.includes('/exa/contents')) {
-        const body = JSON.parse((opts?.body as string) ?? '{}')
-        return new Response(JSON.stringify({
-          results: body.urls.map((pageUrl: string) => ({ url: pageUrl, text: `text for ${pageUrl}` })),
-        }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const urls = ['https://coldiq.com', 'https://hubspot.com', 'https://salesforce.com']
-    const result = await fetchPageContentHandler({ urls })
-
-    expect(result.isError).toBeFalsy()
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('exa-contents')
-    expect(parsed.data.results).toHaveLength(3)
-  })
-
-  it('include_summary=true — summary flag forwarded to exa', async () => {
-    let capturedBody: Record<string, unknown> | null = null
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
-      const u = url.toString()
-      if (u.includes('/exa/contents')) {
-        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
-        return new Response(JSON.stringify({
-          results: [{ url: 'https://coldiq.com', text: 'text', summary: 'summary text' }],
-        }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    await fetchPageContentHandler({ urls: ['https://coldiq.com'], include_summary: true })
-
-    expect(capturedBody).not.toBeNull()
-    expect(capturedBody!.summary).toEqual({})
-  })
-
-  it('include_summary=false (default) — no summary field in request', async () => {
-    let capturedBody: Record<string, unknown> | null = null
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
-      const u = url.toString()
-      if (u.includes('/exa/contents')) {
-        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
-        return new Response(JSON.stringify({
-          results: [{ url: 'https://coldiq.com', text: 'text' }],
-        }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    await fetchPageContentHandler({ urls: ['https://coldiq.com'] })
-
-    expect(capturedBody).not.toBeNull()
-    expect(capturedBody!.summary).toBeUndefined()
-  })
-
-  it('provider fails — returns isError', async () => {
-    globalThis.fetch = vi.fn(async () => {
-      return new Response(JSON.stringify({ error: 'upstream error' }), { status: 502 })
-    }) as typeof fetch
-
-    const result = await fetchPageContentHandler({ urls: ['https://coldiq.com'] })
-
-    expect(result.isError).toBe(true)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.error).toBeTruthy()
-  })
-})

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

@@ -1,137 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { findEmailHandler } 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 findEmailHandler({
-      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 findEmailHandler({
-      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 findEmailHandler({
-      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 findEmailHandler({
-      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
-  })
-
-  describe('use_providers', () => {
-    it('Scenario A — pinned provider succeeds', async () => {
-      globalThis.fetch = vi.fn(async () =>
-        new Response(JSON.stringify({ email: 'michel@coldiq.com' }), { status: 200 })
-      ) as typeof fetch
-
-      const result = await findEmailHandler({
-        first_name: 'Michel',
-        domain: 'coldiq.com',
-        use_providers: ['findymail'],
-      })
-
-      expect(result.isError).toBeUndefined()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('findymail')
-    })
-
-    it('Scenario C — gated provider without required input returns helpful error', async () => {
-      const result = await findEmailHandler({
-        first_name: 'Michel',
-        domain: 'coldiq.com',
-        use_providers: ['blitzapi'],
-      })
-
-      expect(result.isError).toBe(true)
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed.error).toContain("'blitzapi' requires")
-      expect(parsed.error).toContain('ColdIQ will automatically pick the best tool')
-    })
-
-    it('Scenario E — unrecognized provider returns isError', async () => {
-      const result = await findEmailHandler({
-        first_name: 'Michel',
-        domain: 'coldiq.com',
-        use_providers: ['apollo'],
-      })
-
-      expect(result.isError).toBe(true)
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed.error).toContain("'apollo' is not a recognized provider")
-    })
-  })
-})