@coldiq/mcp 0.3.11 → 0.3.13

package/tests/executor.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { initClient } from '../src/client.js'
 import { executeWithFallback } from '../src/executor.js'
+import { getSessionUsage, resetSessionUsage } from '../src/session-usage.js'
 import * as registry from '../src/registry.js'
 import type { ProviderEntry } from '../src/registry.js'
 
@@ -225,6 +226,74 @@ describe('executor exception safety', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// Session-usage integration — the async create/poll path must record a charge
+// exactly once. Locks in the "no double count" guarantee against future
+// refactors of executeAsync's header merging.
+// ---------------------------------------------------------------------------
+
+describe('executor records session credit usage exactly once on the async path', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key-123')
+    resetSessionUsage(0)
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    vi.restoreAllMocks()
+  })
+
+  it('charge header on the create response is counted once; polls add nothing', async () => {
+    stubProviders([
+      makeProvider({
+        id: 'async-charged',
+        endpoint: '/async-charged',
+        hasResult: (data) => (data as Record<string, unknown>).done === true,
+        async: {
+          extractId: () => 'job-1',
+          pollEndpoint: (id) => `/poll/${id}`,
+          pollIntervalMs: 5,
+          timeoutMs: 500,
+          // Complete only once the poll body says so, forcing ≥1 poll round.
+          isComplete: (data) => (data as Record<string, unknown>).done === true,
+        },
+      }),
+    ])
+
+    let pollCount = 0
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/poll/')) {
+        pollCount++
+        // First poll still processing (no charge header), second completes.
+        const body = pollCount >= 2 ? { done: true } : { status: 'processing' }
+        return new Response(JSON.stringify(body), { status: 200 })
+      }
+      // Create response — carries the billing headers, like the real API.
+      return new Response(JSON.stringify({ job_id: 'job-1' }), {
+        status: 200,
+        headers: {
+          'X-ColdIQ-Credits-Charged': '5',
+          'X-ColdIQ-Credits-Remaining': '120',
+        },
+      })
+    }) as typeof fetch
+
+    const result = await executeWithFallback('find_people', { domain: 'coldiq.com' })
+
+    expect('data' in result).toBe(true)
+    expect(pollCount).toBeGreaterThanOrEqual(2)
+
+    const usage = getSessionUsage()
+    expect(usage.billedCalls).toBe(1)
+    expect(usage.totalCreditsCharged).toBe(5)
+    expect(usage.balanceAfterLastCharge).toBe(120)
+    expect(usage.byEndpoint).toEqual([{ endpoint: '/async-charged', calls: 1, credits: 5 }])
+  })
+})
+
 // ---------------------------------------------------------------------------
 // postFilter integration (existing tests)
 // ---------------------------------------------------------------------------

package/tests/session-usage.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest'
+import {
+  recordCharge,
+  recordChargeFromHeaders,
+  getSessionUsage,
+  resetSessionUsage,
+} from '../src/session-usage.js'
+import { initClient, callApi } from '../src/client.js'
+
+describe('session-usage accumulator', () => {
+  beforeEach(() => {
+    resetSessionUsage(1_000)
+  })
+
+  it('starts empty', () => {
+    const usage = getSessionUsage(1_000)
+    expect(usage.billedCalls).toBe(0)
+    expect(usage.totalCreditsCharged).toBe(0)
+    expect(usage.byEndpoint).toEqual([])
+    expect(usage.balanceAfterLastCharge).toBeUndefined()
+    expect(usage.startedAt).toBe(new Date(1_000).toISOString())
+  })
+
+  it('accumulates charges and tracks the last reported balance', () => {
+    recordCharge('/prospeo/find-email', 1, 99)
+    recordCharge('/prospeo/find-email', 1, 98)
+    recordCharge('/companyenrich/companies/search', 3, 95)
+
+    const usage = getSessionUsage(2_000)
+    expect(usage.billedCalls).toBe(3)
+    expect(usage.totalCreditsCharged).toBe(5)
+    expect(usage.balanceAfterLastCharge).toBe(95)
+    expect(usage.durationMs).toBe(1_000)
+  })
+
+  it('breaks down per endpoint sorted by credits descending', () => {
+    recordCharge('/cheap', 1)
+    recordCharge('/expensive', 10)
+    recordCharge('/cheap', 1)
+
+    const { byEndpoint } = getSessionUsage()
+    expect(byEndpoint).toEqual([
+      { endpoint: '/expensive', calls: 1, credits: 10 },
+      { endpoint: '/cheap', calls: 2, credits: 2 },
+    ])
+  })
+
+  it('rounds fractional credit sums to avoid float noise', () => {
+    recordCharge('/x', 0.1)
+    recordCharge('/x', 0.2)
+    expect(getSessionUsage().totalCreditsCharged).toBe(0.3)
+  })
+
+  it('ignores malformed and negative charges', () => {
+    recordCharge('/x', Number.NaN)
+    recordCharge('/x', -5)
+    recordCharge('/x', Infinity)
+    const usage = getSessionUsage()
+    expect(usage.billedCalls).toBe(0)
+    expect(usage.totalCreditsCharged).toBe(0)
+  })
+
+  describe('recordChargeFromHeaders', () => {
+    it('records when the charge header is present', () => {
+      recordChargeFromHeaders('/find-email', {
+        'x-coldiq-credits-charged': '2',
+        'x-coldiq-credits-remaining': '198',
+      })
+      const usage = getSessionUsage()
+      expect(usage.billedCalls).toBe(1)
+      expect(usage.totalCreditsCharged).toBe(2)
+      expect(usage.balanceAfterLastCharge).toBe(198)
+    })
+
+    it('is a no-op when no charge header is present (e.g. a poll response)', () => {
+      recordChargeFromHeaders('/poll', { 'content-type': 'application/json' })
+      expect(getSessionUsage().billedCalls).toBe(0)
+    })
+
+    it('records the charge even when the remaining header is absent', () => {
+      recordChargeFromHeaders('/x', { 'x-coldiq-credits-charged': '4' })
+      const usage = getSessionUsage()
+      expect(usage.totalCreditsCharged).toBe(4)
+      expect(usage.balanceAfterLastCharge).toBeUndefined()
+    })
+  })
+})
+
+describe('callApi records credit charges into session usage', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+    resetSessionUsage(0)
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('tallies a charge surfaced in response headers', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ email: 'michel@coldiq.com' }), {
+        status: 200,
+        headers: {
+          'X-ColdIQ-Credits-Charged': '1',
+          'X-ColdIQ-Credits-Remaining': '249',
+        },
+      }),
+    ) as typeof fetch
+
+    await callApi('POST', '/prospeo/find-email', { domain: 'coldiq.com' })
+
+    const usage = getSessionUsage()
+    expect(usage.billedCalls).toBe(1)
+    expect(usage.totalCreditsCharged).toBe(1)
+    expect(usage.balanceAfterLastCharge).toBe(249)
+    expect(usage.byEndpoint).toEqual([{ endpoint: '/prospeo/find-email', calls: 1, credits: 1 }])
+  })
+
+  it('does not tally calls that return no charge header', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ status: 'processing' }), { status: 200 }),
+    ) as typeof fetch
+
+    await callApi('GET', '/jobs/abc123')
+
+    expect(getSessionUsage().billedCalls).toBe(0)
+  })
+})

package/tests/tools/get-session-usage.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import {
+  getSessionUsageHandler,
+  getSessionUsageName,
+  getSessionUsageSchema,
+} from '../../src/tools/get-session-usage.js'
+import { recordCharge, resetSessionUsage } from '../../src/session-usage.js'
+
+describe('get_session_usage handler', () => {
+  beforeEach(() => {
+    resetSessionUsage()
+  })
+
+  it('is registered as a zero-arg tool', () => {
+    expect(getSessionUsageName).toBe('get_session_usage')
+    expect(getSessionUsageSchema).toEqual({})
+  })
+
+  it('returns an empty snapshot before any billed call', async () => {
+    const result = await getSessionUsageHandler({})
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.data.billedCalls).toBe(0)
+    expect(parsed.data.totalCreditsCharged).toBe(0)
+    expect(parsed.data.byEndpoint).toEqual([])
+  })
+
+  it('reflects recorded charges with a per-endpoint breakdown', async () => {
+    recordCharge('/prospeo/find-email', 1, 99)
+    recordCharge('/companyenrich/companies/search', 3, 96)
+
+    const result = await getSessionUsageHandler({})
+    const parsed = JSON.parse(result.content[0].text)
+
+    expect(parsed.data.billedCalls).toBe(2)
+    expect(parsed.data.totalCreditsCharged).toBe(4)
+    expect(parsed.data.balanceAfterLastCharge).toBe(96)
+    expect(parsed.data.byEndpoint[0]).toEqual({
+      endpoint: '/companyenrich/companies/search',
+      calls: 1,
+      credits: 3,
+    })
+  })
+})

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()
-  })
-})