@coldiq/mcp 0.3.12 → 0.3.13

package/src/tools/find-emails.ts

@@ -1,59 +1,17 @@
 import { z } from 'zod'
-import { callApi, type ApiResponse } from '../client.js'
-import { executeWithFallback, isExecutionError } from '../executor.js'
-import { resolvePreferredProviders, buildAllFailedError, FIND_EMAILS_PROVIDERS } from '../utils/provider-resolver.js'
-import { providerDisplayName } from '../utils/provider-display.js'
-import { buildSelectionInsight } from '../utils/selection-insight.js'
-
-// Single-find_email registry providers that the bulk pipeline does NOT already cover.
-// Used as a fallback waterfall for residual misses after Prospeo + FullEnrich + Findymail + Icypeas.
-const SINGLE_ONLY_FIND_EMAIL_PROVIDERS = ['limadata-work-email', 'blitzapi', 'limadata-work-email-linkedin', 'linkupapi'] as const
-
-// Chunk inputs of >10 people into independent waterfalls. Empirically, Prospeo bulk on 25-50
-// names regularly exceeds the 30s client timeout; 10 keeps each Prospeo call well under it.
-export const FIND_EMAILS_CHUNK_SIZE = 10
-// Concurrency cap keeps peak in-flight calls (per-chunk fan-out × concurrent chunks) under
-// the undici Agent's 32-connection budget (client.ts).
-const CHUNK_CONCURRENCY = 3
-
-// Pulls a string email from any of the provider-specific response shapes used in the
-// find_email registry (registry.ts:1228-1413). Keep in sync with the providers covered there.
-function extractEmail(data: unknown): string | null {
-  if (!data || typeof data !== 'object') return null
-  const d = data as Record<string, unknown>
-  if (typeof d.email === 'string' && d.email.includes('@')) return d.email
-  if (Array.isArray(d.emails) && typeof d.emails[0] === 'string' && (d.emails[0] as string).includes('@')) return d.emails[0] as string
-  const person = d.person as Record<string, unknown> | undefined
-  const personEmail = person?.email as Record<string, unknown> | undefined
-  if (typeof personEmail?.email === 'string' && (personEmail.email as string).includes('@')) return personEmail.email as string
-  const nested = d.data
-  if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
-    const inner = (nested as Record<string, unknown>).email
-    if (typeof inner === 'string' && inner.includes('@')) return inner
-  }
-  if (Array.isArray(nested) && nested[0] && typeof nested[0] === 'object') {
-    const first = nested[0] as Record<string, unknown>
-    if (Array.isArray(first.emails) && typeof first.emails[0] === 'string' && (first.emails[0] as string).includes('@')) {
-      return first.emails[0] as string
-    }
-  }
-  return null
-}
+import { callVerb } from '../verb-client.js'
+import { FIND_EMAILS_PROVIDERS } from '../utils/provider-resolver.js'
 
 export const findEmailsName = 'find_emails'
 
 export const findEmailsDescription =
   'Find professional emails for multiple people in one batch. ' +
-  'Uses Prospeo bulk first; for any misses, runs FullEnrich and FindyMail/IcyPeas in parallel — ' +
-  'whichever provider returns an email first wins. ' +
-  'Much faster than calling find_email one-by-one. Max 50 people per call — ' +
-  `inputs are split into chunks of ${FIND_EMAILS_CHUNK_SIZE} internally for reliability, so larger batches work transparently. ` +
+  'Runs the managed email waterfall in parallel across all people — ' +
+  'much faster than calling find_email one-by-one. Max 50 people per call. ' +
   'Each person needs a unique id to match results back. ' +
   'Always pass first_name, last_name, and domain — they are the primary enrichment signal. ' +
   'Also pass linkedin_url when available, but never rely on it alone as some providers cannot resolve vanity URLs. ' +
-  'ColdIQ automatically picks the best waterfall — pass use_providers only if you need specific tools. ' +
-  'Response includes `_meta.batch_status` (complete|partial|failed) and per-provider call stats so callers can ' +
-  'tell a real "no coverage" result apart from a provider-level failure.'
+  'ColdIQ automatically picks the best waterfall — pass use_providers only if you need specific tools.'
 
 export const findEmailsSchema = {
   people: z
@@ -72,464 +30,8 @@ export const findEmailsSchema = {
   use_providers: z.array(z.string()).optional().describe(`Optional ordered list of providers to use. Leave empty to let ColdIQ automatically run the best waterfall — recommended for most use cases. Available providers: ${FIND_EMAILS_PROVIDERS.join(', ')}. Provider names are matched fuzzily, so minor typos are tolerated.`),
 }
 
-interface PersonInput {
-  id: string
-  first_name?: string
-  last_name?: string
-  domain?: string
-  linkedin_url?: string
-}
-
-interface EmailResult {
-  id: string
-  email: string | null
-  provider: string | null
-}
-
-interface ProviderStats {
-  attempted: number
-  failed: number
-}
-
-interface BatchStats {
-  prospeo: ProviderStats
-  fullenrich: ProviderStats
-  findymail: ProviderStats
-  icypeas: ProviderStats
-  single_fallback: ProviderStats
-}
-
-function newBatchStats(): BatchStats {
-  return {
-    prospeo: { attempted: 0, failed: 0 },
-    fullenrich: { attempted: 0, failed: 0 },
-    findymail: { attempted: 0, failed: 0 },
-    icypeas: { attempted: 0, failed: 0 },
-    single_fallback: { attempted: 0, failed: 0 },
-  }
-}
-
-function mergeStats(into: BatchStats, from: BatchStats): void {
-  for (const key of Object.keys(into) as (keyof BatchStats)[]) {
-    into[key].attempted += from[key].attempted
-    into[key].failed += from[key].failed
-  }
-}
-
-function totalFailures(s: BatchStats): number {
-  let n = 0
-  for (const key of Object.keys(s) as (keyof BatchStats)[]) n += s[key].failed
-  return n
-}
-
-// A call counts as a "failure" when callApi never received a usable response: network error,
-// abort/timeout (status === 0), or upstream 5xx. Upstream 4xx is a data-shape problem, not a
-// provider outage — we don't surface it as a batch-level failure.
-function isCallFailure(res: ApiResponse): boolean {
-  return !res.ok && (res.status === 0 || res.status >= 500)
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-function missesOf(people: PersonInput[], results: EmailResult[]): PersonInput[] {
-  return people.filter((p) => !results.find((r) => r.id === p.id)?.email)
-}
-
-function chunkArray<T>(arr: T[], size: number): T[][] {
-  if (arr.length <= size) return [arr]
-  const out: T[][] = []
-  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size))
-  return out
-}
-
-async function withConcurrency<T, R>(
-  items: T[],
-  concurrency: number,
-  fn: (item: T, idx: number) => Promise<R>,
-): Promise<R[]> {
-  const results: R[] = new Array(items.length)
-  let cursor = 0
-  const workerCount = Math.min(concurrency, items.length)
-  const workers = Array.from({ length: workerCount }, async () => {
-    while (true) {
-      const i = cursor++
-      if (i >= items.length) return
-      results[i] = await fn(items[i]!, i)
-    }
-  })
-  await Promise.all(workers)
-  return results
-}
-
-async function prospeoBulkStep(
-  chunk: PersonInput[],
-  results: EmailResult[],
-  stats: BatchStats,
-): Promise<void> {
-  const bulkBody = {
-    data: chunk.map((p) =>
-      p.linkedin_url
-        ? { identifier: p.id, linkedin_url: p.linkedin_url }
-        : { identifier: p.id, first_name: p.first_name, last_name: p.last_name, company_name: p.domain },
-    ),
-  }
-
-  stats.prospeo.attempted += 1
-  const bulkRes = await callApi('POST', '/prospeo/bulk-enrich-person', bulkBody)
-  if (isCallFailure(bulkRes)) stats.prospeo.failed += 1
-  if (!bulkRes.ok) return
-
-  const data = bulkRes.data as {
-    results?: Array<{
-      identifier: string
-      person?: { email?: { email?: string } }
-    }>
-  }
-  for (const item of data.results ?? []) {
-    const email = item.person?.email?.email
-    if (typeof email === 'string' && email.includes('@')) {
-      const hit = results.find((r) => r.id === item.identifier)
-      if (hit) {
-        hit.email = email
-        hit.provider = 'prospeo'
-      }
-    }
-  }
-}
-
-async function fullEnrichStep(
-  misses: PersonInput[],
-  results: EmailResult[],
-  stats: BatchStats,
-): Promise<void> {
-  stats.fullenrich.attempted += 1
-
-  const feBody = {
-    name: 'mcp-enrich-batch',
-    data: misses.map((p) => ({
-      custom_id: p.id,
-      first_name: p.first_name,
-      last_name: p.last_name,
-      domain: p.domain,
-      ...(p.linkedin_url ? { linkedin_url: p.linkedin_url } : {}),
-      enrich_fields: ['contact.emails'],
-    })),
-  }
-
-  const feCreateRes = await callApi('POST', '/fullenrich/contact/enrich/bulk', feBody)
-  if (!feCreateRes.ok) {
-    if (isCallFailure(feCreateRes)) stats.fullenrich.failed += 1
-    return
-  }
-
-  const enrichmentId = (feCreateRes.data as Record<string, unknown>).enrichment_id as string | undefined
-  if (!enrichmentId) {
-    // No id returned but POST 2xx — treat as a soft skip, not a network failure.
-    return
-  }
-
-  // Tightened from 90s → 45s: Step 3 runs in parallel and typically fills misses
-  // faster, so FullEnrich's marginal value decays past this point.
-  const deadline = Date.now() + 45_000
-  // Bail out once the poll endpoint fails repeatedly (e.g. upstream 502s) instead
-  // of hammering it for the full 45s. A poll that keeps erroring will never return
-  // data, and this branch gates the chunk's critical path (Promise.allSettled in
-  // processChunk), so polling to the deadline added ~30s of pure latency with zero
-  // emails. Mirrors the executor's COLDIQ_MAX_POLL_ERRORS guard (executor.ts).
-  const maxPollErrors = parseInt(process.env.COLDIQ_MAX_POLL_ERRORS ?? '3', 10)
-  let consecutivePollErrors = 0
-  while (Date.now() < deadline) {
-    await sleep(2000)
-    const pollRes = await callApi('GET', `/fullenrich/contact/enrich/bulk/${enrichmentId}`)
-    if (!pollRes.ok) {
-      consecutivePollErrors += 1
-      if (consecutivePollErrors >= maxPollErrors) {
-        stats.fullenrich.failed += 1
-        return
-      }
-      continue
-    }
-    consecutivePollErrors = 0
-
-    const pd = pollRes.data as Record<string, unknown>
-    const status = pd.status as string | undefined
-    if (status !== 'DONE' && status !== 'FAILED') continue
-
-    if (status === 'DONE') {
-      const feItems = pd.data as Array<Record<string, unknown>> | undefined
-      if (Array.isArray(feItems)) {
-        for (const item of feItems) {
-          const personId = item.custom_id as string | undefined
-          const hit = personId ? results.find((r) => r.id === personId) : undefined
-          if (!hit || hit.email) continue
-          const emails = item.emails as string[] | undefined
-          if (Array.isArray(emails) && emails.length > 0 && typeof emails[0] === 'string' && emails[0].includes('@')) {
-            hit.email = emails[0]
-            hit.provider = 'fullenrich'
-          }
-        }
-      }
-    }
-    return
-  }
-  // Polling deadline reached without DONE/FAILED — count as a failure so the caller
-  // sees fullenrich didn't actually finish.
-  stats.fullenrich.failed += 1
-}
-
-async function findymailIcypeasStep(
-  misses: PersonInput[],
-  results: EmailResult[],
-  stats: BatchStats,
-  allowedProviders?: string[],
-): Promise<void> {
-  const useFindymail = !allowedProviders || allowedProviders.includes('findymail')
-  const useIcypeas = !allowedProviders || allowedProviders.includes('icypeas')
-
-  await Promise.all(
-    misses.map(async (person) => {
-      const hit = results.find((r) => r.id === person.id)
-      if (!hit) return
-
-      // Skip if the parallel FullEnrich branch already filled this person.
-      if (hit.email) return
-
-      if (useFindymail) {
-        const fullName = [person.first_name, person.last_name].filter(Boolean).join(' ')
-
-        stats.findymail.attempted += 1
-        const fmRes = await callApi('POST', '/findymail/search/name', {
-          name: fullName,
-          domain: person.domain,
-        })
-        if (isCallFailure(fmRes)) stats.findymail.failed += 1
-        if (!hit.email && fmRes.ok) {
-          const d = fmRes.data as Record<string, unknown>
-          if (typeof d.email === 'string' && d.email.includes('@')) {
-            hit.email = d.email
-            hit.provider = 'findymail'
-            return
-          }
-        }
-      }
-
-      if (hit.email || !useIcypeas) return
-
-      stats.icypeas.attempted += 1
-      const icyRes = await callApi('POST', '/icypeas/email-search', {
-        firstname: person.first_name,
-        lastname: person.last_name,
-        domainOrCompany: person.domain,
-      })
-      if (isCallFailure(icyRes)) stats.icypeas.failed += 1
-      if (!hit.email && icyRes.ok) {
-        const d = icyRes.data as Record<string, unknown>
-        const email =
-          typeof d.email === 'string' && d.email.includes('@')
-            ? d.email
-            : Array.isArray(d.emails) && typeof d.emails[0] === 'string' && d.emails[0].includes('@')
-              ? (d.emails[0] as string)
-              : null
-        if (email) {
-          hit.email = email
-          hit.provider = 'icypeas'
-        }
-      }
-    }),
-  )
-}
-
-async function singleFallbackStep(
-  stragglers: PersonInput[],
-  results: EmailResult[],
-  stats: BatchStats,
-  fallbackProviders: string[],
-): Promise<void> {
-  if (fallbackProviders.length === 0 || stragglers.length === 0) return
-
-  await Promise.all(
-    stragglers.map(async (person) => {
-      const hit = results.find((r) => r.id === person.id)
-      if (!hit || hit.email) return
-      const singleInput: Record<string, unknown> = {
-        first_name: person.first_name,
-        last_name: person.last_name,
-        domain: person.domain,
-        linkedin_url: person.linkedin_url,
-      }
-      stats.single_fallback.attempted += 1
-      // Per-person 30s ceiling so one slow provider doesn't block the rest.
-      const exec = executeWithFallback('find_email', singleInput, { providers: fallbackProviders })
-      const timeout = new Promise<null>((resolve) => setTimeout(() => resolve(null), 30_000))
-      const raced = await Promise.race([exec, timeout])
-      if (!raced) {
-        // Race timed out — none of the fallback providers returned in time.
-        stats.single_fallback.failed += 1
-        return
-      }
-      if (isExecutionError(raced)) {
-        // Every fallback provider returned an error. Only count as `failed` when at least
-        // one of them looked like a real network/upstream failure — providers that responded
-        // 200 with no result are legitimate "no coverage", not a batch failure.
-        const hadRealFailure = raced.providers_tried.some((p) => p.status === 0 || p.status >= 500)
-        if (hadRealFailure) stats.single_fallback.failed += 1
-        return
-      }
-      const email = extractEmail(raced.data)
-      if (email && !hit.email) {
-        hit.email = email
-        hit.provider = raced._meta.provider
-      }
-    }),
-  )
-}
-
-async function processChunk(
-  chunk: PersonInput[],
-  allowedProviders: string[],
-  isConstrained: boolean,
-): Promise<{ results: EmailResult[]; stats: BatchStats }> {
-  const results: EmailResult[] = chunk.map((p) => ({ id: p.id, email: null, provider: null }))
-  const stats = newBatchStats()
-
-  // Step 1: Prospeo bulk — 1 call for everyone in this chunk.
-  if (!isConstrained || allowedProviders.includes('prospeo')) {
-    await prospeoBulkStep(chunk, results, stats)
-  }
-
-  // Steps 2 & 3 run concurrently for misses.
-  //   Step 2: FullEnrich bulk async (slow tail, better European coverage)
-  //   Step 3: per-person FindyMail → IcyPeas waterfall
-  // Both branches write to the shared `results` array; every write site checks
-  // `if (hit.email)` first so whichever provider arrives first wins and the
-  // other does not overwrite.
-  const misses = missesOf(chunk, results)
-  if (misses.length > 0) {
-    const steps: Promise<void>[] = []
-    if (!isConstrained || allowedProviders.includes('fullenrich')) {
-      steps.push(fullEnrichStep(misses, results, stats))
-    }
-    if (!isConstrained || allowedProviders.includes('findymail') || allowedProviders.includes('icypeas')) {
-      steps.push(findymailIcypeasStep(misses, results, stats, isConstrained ? allowedProviders : undefined))
-    }
-    if (steps.length > 0) await Promise.allSettled(steps)
-  }
-
-  // Step 4 — single-find_email fallback for stragglers.
-  // Bulk covers Prospeo + FullEnrich + FindyMail + IcyPeas. The single-find_email registry
-  // (registry.ts:1228-1413) additionally covers LimaData, BlitzAPI, LimaData-LinkedIn, LinkupAPI.
-  // Without this step, agents would observe bulk return 0 and fall back to N+1 single calls.
-  const stragglers = missesOf(chunk, results)
-  if (stragglers.length > 0) {
-    const fallbackProviders = isConstrained
-      ? allowedProviders.filter((p) => (SINGLE_ONLY_FIND_EMAIL_PROVIDERS as readonly string[]).includes(p))
-      : [...SINGLE_ONLY_FIND_EMAIL_PROVIDERS]
-    await singleFallbackStep(stragglers, results, stats, fallbackProviders)
-  }
-
-  return { results, stats }
-}
-
-function computeBatchStatus(found: number, total: number, stats: BatchStats): 'complete' | 'partial' | 'failed' {
-  const failures = totalFailures(stats)
-  if (failures === 0) return 'complete'
-  if (found === 0 && total > 0) return 'failed'
-  return 'partial'
-}
-
 export async function findEmailsHandler(input: Record<string, unknown>) {
-  const { use_providers: rawUseProviders, ...restInput } = input
-  const people = restInput.people as PersonInput[]
-
-  const resolved = resolvePreferredProviders('find_emails', restInput, rawUseProviders)
-  if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
-  }
-
-  const allowedProviders = resolved.providers
-  const isConstrained = allowedProviders.length > 0
-
-  const chunks = chunkArray(people, FIND_EMAILS_CHUNK_SIZE)
-  const chunkOutputs = await withConcurrency(chunks, CHUNK_CONCURRENCY, (chunk) =>
-    processChunk(chunk, allowedProviders, isConstrained),
-  )
-
-  const results: EmailResult[] = chunkOutputs.flatMap((c) => c.results)
-  const aggregateStats = newBatchStats()
-  for (const c of chunkOutputs) mergeStats(aggregateStats, c.stats)
-
-  const found = results.filter((r) => r.email !== null).length
-  const batchStatus = computeBatchStatus(found, people.length, aggregateStats)
-
-  // Constrained-mode behaviour preserved: if the caller pinned providers and got zero, push back.
-  if (isConstrained && found === 0) {
-    const err = buildAllFailedError(allowedProviders, 'find_emails', FIND_EMAILS_PROVIDERS)
-    return { content: [{ type: 'text' as const, text: JSON.stringify(err) }], isError: true }
-  }
-
-  const meta: Record<string, unknown> = {
-    providers: aggregateStats,
-    batch_status: batchStatus,
-    chunk_size: FIND_EMAILS_CHUNK_SIZE,
-    chunk_count: chunks.length,
-  }
-  if (resolved.matchedFrom && Object.keys(resolved.matchedFrom).length > 0) {
-    meta.matchedFrom = resolved.matchedFrom
-  }
-
-  // Batch-level selection insight: the per-person waterfall returns a provider per
-  // result, so attribute the batch to the provider that resolved the most emails.
-  // Prospeo is the primary bulk step (Step 1); anything else means we relied on a
-  // fallback step, so soften the wording.
-  if (found > 0) {
-    const winCounts = new Map<string, number>()
-    for (const r of results) {
-      if (r.email && r.provider) winCounts.set(r.provider, (winCounts.get(r.provider) ?? 0) + 1)
-    }
-    // Tie-break deterministically by waterfall rank: scan in FIND_EMAILS_PROVIDERS
-    // order and replace only on a strictly greater count, so an equal-count primary
-    // (Prospeo, Step 1) is never displaced by a later fallback step — keeps the
-    // attribution stable regardless of people-input order.
-    let dominant: string | undefined
-    let best = 0
-    for (const id of FIND_EMAILS_PROVIDERS) {
-      const count = winCounts.get(id) ?? 0
-      if (count > best) { best = count; dominant = id }
-    }
-    if (dominant) {
-      const insight = buildSelectionInsight('find_emails', dominant, restInput, {
-        // Steps 2-4 only run on Prospeo's misses, so a non-Prospeo winner is a
-        // genuine fallthrough — unless the caller pinned providers (no Prospeo step),
-        // in which case the pinnedByUser branch governs the wording anyway.
-        wasFallback: dominant !== 'prospeo' && !isConstrained,
-        pinnedByUser: isConstrained,
-      })
-      if (insight) {
-        meta.selection_insight = insight.insight
-        if (insight.signals.length > 0) meta.selection_signals = insight.signals
-      }
-    }
-  }
-
-  // Surface branded provider names per person so users never see a raw slug.
-  const brandedResults = results.map((r) => ({
-    ...r,
-    provider_name: r.provider ? providerDisplayName(r.provider) : null,
-  }))
-
-  // Surface the silent-failure case the user reported: 200 OK with all-nulls is misleading
-  // when the nulls were caused by provider failures rather than legitimate no-coverage.
-  const isError = batchStatus === 'failed'
-
-  return {
-    content: [
-      {
-        type: 'text' as const,
-        text: JSON.stringify({ data: { results: brandedResults, found, total: people.length }, _meta: meta }),
-      },
-    ],
-    ...(isError ? { isError: true } : {}),
-  }
+  // Bulk verb returns results positionally with no id echo — re-attach each
+  // person's `id` so callers can still match results back.
+  return callVerb('/email/find', input, { bulkField: 'people', reattachIdField: 'id' })
 }

package/src/tools/find-influencers.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
-import { executeWithFallback, isExecutionError } from '../executor.js'
-import { resolvePreferredProviders, getProvidersForCapability } from '../utils/provider-resolver.js'
+import { callVerb } from '../verb-client.js'
+import { getProvidersForCapability } from '../utils/provider-resolver.js'
 
 export const findInfluencersName = 'find_influencers'
 
@@ -29,14 +29,5 @@ export const findInfluencersSchema = {
 }
 
 export async function findInfluencersHandler(input: Record<string, unknown>) {
-  const { use_providers: rawUseProviders, ...restInput } = input
-  const resolved = resolvePreferredProviders('find_influencers', restInput, rawUseProviders)
-  if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
-  }
-  const result = await executeWithFallback('find_influencers', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
-  if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
-  }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
+  return callVerb('/influencers/find', input)
 }

package/src/tools/find-people.ts

@@ -1,9 +1,6 @@
 import { z } from 'zod'
-import { executeWithFallback, isExecutionError } from '../executor.js'
-import { callApi } from '../client.js'
-import { getProviders } from '../registry.js'
-import { resolvePreferredProviders, getProvidersForCapability } from '../utils/provider-resolver.js'
-import { compactPayload } from '../utils/compact-people.js'
+import { callVerb } from '../verb-client.js'
+import { getProvidersForCapability } from '../utils/provider-resolver.js'
 
 export const findPeopleName = 'find_people'
 
@@ -33,107 +30,6 @@ export const findPeopleSchema = {
   use_providers: z.array(z.string()).optional().describe(`Optional ordered list of providers to use. Leave empty to let ColdIQ automatically pick the best tool for your inputs — recommended for most use cases. Available providers: ${getProvidersForCapability('find_people').join(', ')}. Provider names are matched fuzzily, so minor typos are tolerated.`),
 }
 
-function buildSuccess(
-  result: { data: unknown; _meta: { provider: string; latencyMs: number; matchedFrom?: Record<string, string> } },
-  fields: 'compact' | 'verbose',
-) {
-  const payload = fields === 'compact'
-    ? { ...result, data: compactPayload(result.data, result._meta.provider) }
-    : result
-  return { content: [{ type: 'text' as const, text: JSON.stringify(payload) }] }
-}
-
 export async function findPeopleHandler(input: Record<string, unknown>) {
-  const { use_providers: rawUseProviders, reveal: rawReveal, fields: rawFields, ...restInput } = input
-  const reveal = rawReveal === true
-  const fields: 'compact' | 'verbose' = rawFields === 'verbose' ? 'verbose' : 'compact'
-  const resolved = resolvePreferredProviders('find_people', restInput, rawUseProviders)
-  if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
-  }
-  const result = await executeWithFallback('find_people', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
-  if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
-  }
-
-  // Apollo's /people/search returns obfuscated data (last names like "Ar***t",
-  // no emails). When the caller opts in with reveal=true, follow up with
-  // /apollo/people/bulk-match (10 IDs per call, Apollo's bulk cap) to swap each
-  // person object for its fully-revealed counterpart. Costs 1 extra credit per
-  // revealed person on top of the original search credit.
-  if (reveal && result._meta.provider === 'apollo') {
-    const data = result.data as Record<string, unknown>
-    const people = (data.people as Array<Record<string, unknown>> | undefined) ?? []
-    const ids = people
-      .map((p) => p.id)
-      .filter((id): id is string => typeof id === 'string' && id.length > 0)
-
-    if (ids.length > 0) {
-      const matches: Array<Record<string, unknown>> = []
-      for (let i = 0; i < ids.length; i += 10) {
-        const chunk = ids.slice(i, i + 10)
-        const res = await callApi('POST', '/apollo/people/bulk-match', {
-          details: chunk.map((id) => ({ id })),
-          reveal_personal_emails: true,
-        })
-        if (res.ok && res.data && typeof res.data === 'object') {
-          const body = res.data as Record<string, unknown>
-          const chunkMatches = (body.matches as Array<Record<string, unknown>> | undefined) ?? []
-          matches.push(...chunkMatches)
-        }
-      }
-
-      if (matches.length > 0) {
-        const matchById = new Map<string, Record<string, unknown>>()
-        for (const m of matches) {
-          const id = m.id
-          if (typeof id === 'string') matchById.set(id, m)
-        }
-        const revealedPeople = people.map((p) => {
-          const id = p.id
-          if (typeof id === 'string' && matchById.has(id)) return matchById.get(id)!
-          return p
-        })
-        // Only claim `revealed: true` when bulk-match returned a result for every ID.
-        // Partial reveals (some entries remain obfuscated) would otherwise mislead
-        // callers into trusting `last_name` / `email` that aren't actually filled.
-        const fullyRevealed = matchById.size >= ids.length
-        const merged = { ...data, people: revealedPeople, revealed: fullyRevealed }
-        return buildSuccess({ ...result, data: merged }, fields)
-      }
-    }
-  }
-
-  // Gap-fill: if LeadsFactory missed some domains, try Apollo for those.
-  // Only runs when domains were the input — if we sent LinkedIn URLs, no_results_domains
-  // is unreliable (LF may resolve arbitrary domains from URLs, e.g. linkedin.com itself).
-  const inputHadDomains = Array.isArray(restInput.company_domains) && (restInput.company_domains as unknown[]).length > 0
-  const inputHadLinkedInUrls = Array.isArray(restInput.company_linkedin_urls) && (restInput.company_linkedin_urls as unknown[]).length > 0
-  if (resolved.providers.length === 0 && result._meta.provider === 'leadsfactory' && inputHadDomains && !inputHadLinkedInUrls) {
-    const data = result.data as Record<string, unknown>
-    const missedDomains = (data.no_results_domains as string[] | undefined) ?? []
-
-    if (missedDomains.length > 0) {
-      const apollo = getProviders('find_people').find((p) => p.id === 'apollo')
-      if (apollo) {
-        const gapInput = { ...restInput, company_domains: missedDomains, company_linkedin_urls: undefined }
-        const payload = apollo.mapParams(gapInput)
-        const apolloRes = await callApi(apollo.method, apollo.endpoint, payload.body, payload.queryParams)
-
-        if (apolloRes.ok && apollo.hasResult(apolloRes.data)) {
-          const merged = {
-            ...data,
-            gap_fill: {
-              provider: 'apollo',
-              domains: missedDomains,
-              ...(apolloRes.data as Record<string, unknown>),
-            },
-          }
-          return buildSuccess({ ...result, data: merged }, fields)
-        }
-      }
-    }
-  }
-
-  return buildSuccess(result, fields)
+  return callVerb('/people/search', input)
 }