@coldiq/mcp 0.1.13 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldiq/mcp",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "type": "module",
   "main": "dist/index.js",
   "bin": {

package/src/executor.ts

@@ -128,6 +128,17 @@ function sleep(ms: number): Promise<void> {
 // Execute a single provider
 // ---------------------------------------------------------------------------
 
+// Per-provider sync wall-clock cap. Most providers return "no result" in <5s when
+// they have no match; a slow provider returning empty late only delays the next
+// fallback. Capping keeps a 9-provider waterfall walk bounded — at most ~90s end-
+// to-end when every provider misses, vs. multi-minute stalls observed in production
+// before this cap. Override via COLDIQ_SYNC_PROVIDER_TIMEOUT_MS for debugging/tests.
+// Read each call so tests can adjust without module reloads. Does NOT apply to
+// async providers — their own pollIntervalMs/timeoutMs govern.
+function syncProviderTimeoutMs(): number {
+  return parseInt(process.env.COLDIQ_SYNC_PROVIDER_TIMEOUT_MS ?? '10000', 10)
+}
+
 async function executeSingle(
   provider: ProviderEntry,
   input: Record<string, unknown>,
@@ -151,7 +162,20 @@ async function executeSingle(
     const asyncResult = await executeAsync(provider, payload)
     result = { ...asyncResult, status: asyncResult.ok ? 200 : 500 }
   } else {
-    result = await callApi(provider.method, provider.endpoint, payload.body, payload.queryParams)
+    const cap = syncProviderTimeoutMs()
+    const call = callApi(provider.method, provider.endpoint, payload.body, payload.queryParams)
+    const timeout = new Promise<{ ok: boolean; status: number; data: unknown }>((resolve) =>
+      setTimeout(
+        () =>
+          resolve({
+            ok: false,
+            status: 0,
+            data: { error: `Provider exceeded ${cap}ms sync cap` },
+          }),
+        cap,
+      ),
+    )
+    result = await Promise.race([call, timeout])
   }
 
   return { ...result, latencyMs: Date.now() - start }

package/src/registry.ts

@@ -1045,7 +1045,9 @@ const findPeopleProviders: ProviderEntry[] = [
       },
       extractId: (response) => {
         const d = response as Record<string, unknown>
-        return (d._id as string) ?? (d.search_id as string)
+        // LeadsFactory's upstream returns the ObjectId as `id`; the short `search_id`
+        // cannot be used as the GET param (upstream rejects it as "not a valid ObjectId").
+        return (d.id as string) ?? (d.search_id as string)
       },
     },
   },
@@ -1068,6 +1070,38 @@ const findPeopleProviders: ProviderEntry[] = [
       const d = data as Record<string, unknown>
       return isNonEmptyArray(d.people) || isNonEmptyArray(d.contacts)
     },
+    // Apollo's `q_organization_domains` is a soft hint — when titles match strongly,
+    // Apollo returns people from other companies whose title fits (e.g. a CEO seller
+    // on the Hotmart platform, or a random Brazilian CEO when filtering by WeWork).
+    // Strict-filter post-hoc by the person's actual employer domain when the caller
+    // supplied company identifiers.
+    postFilter: (data, input) => {
+      const wantDomains = ((input.company_domains as string[] | undefined) ?? [])
+        .map((d) => d.toLowerCase().replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0])
+        .filter(Boolean)
+      const wantLinkedIns = ((input.company_linkedin_urls as string[] | undefined) ?? [])
+        .map((u) => u.toLowerCase().replace(/^https?:\/\//, '').replace(/^www\./, '').replace(/\/+$/, ''))
+        .filter(Boolean)
+      if (wantDomains.length === 0 && wantLinkedIns.length === 0) return data
+      const d = { ...(data as Record<string, unknown>) }
+      const people = (d.people as Array<Record<string, unknown>> | undefined) ?? []
+      d.people = people.filter((p) => {
+        const org = p.organization as Record<string, unknown> | undefined
+        const orgWebsite = (org?.website_url as string | undefined)?.toLowerCase()
+          .replace(/^https?:\/\//, '').replace(/^www\./, '').split('/')[0]
+        const orgLinkedIn = (org?.linkedin_url as string | undefined)?.toLowerCase()
+          .replace(/^https?:\/\//, '').replace(/^www\./, '').replace(/\/+$/, '')
+        // Keep only if the person's employer matches one of the requested companies.
+        // Lenient when the field is missing — providers occasionally omit org details
+        // but the person is still a match (e.g. found via name+title lookup).
+        if (orgWebsite && wantDomains.length > 0 && wantDomains.includes(orgWebsite)) return true
+        if (orgLinkedIn && wantLinkedIns.length > 0 && wantLinkedIns.some((u) => orgLinkedIn === u)) return true
+        // If we have org info but neither matches, drop. If we have no org info at all, drop too —
+        // safer to lose an unverified record than to include a false positive.
+        return false
+      })
+      return d
+    },
   },
   {
     id: 'pdl',

package/tests/executor.test.ts

@@ -738,3 +738,54 @@ describe('executeWithFallback with options.providers', () => {
 
 // Note: the LeadsFactory backoff *schedule* itself is asserted against the live
 // provider entry in tests/registry.test.ts to avoid drift between test and source.
+
+// ---------------------------------------------------------------------------
+// Per-provider sync timeout cap — keeps a missing-everywhere waterfall bounded
+// ---------------------------------------------------------------------------
+
+describe('per-provider sync timeout cap', () => {
+  const originalFetch = globalThis.fetch
+  const originalEnv = process.env.COLDIQ_SYNC_PROVIDER_TIMEOUT_MS
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key-123')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    vi.restoreAllMocks()
+    if (originalEnv === undefined) delete process.env.COLDIQ_SYNC_PROVIDER_TIMEOUT_MS
+    else process.env.COLDIQ_SYNC_PROVIDER_TIMEOUT_MS = originalEnv
+  })
+
+  it('caps a hanging sync provider and falls through to the next', async () => {
+    process.env.COLDIQ_SYNC_PROVIDER_TIMEOUT_MS = '120'
+    stubProviders([
+      makeProvider({ id: 'slow', priority: 1, hasResult: () => true }),
+      makeProvider({ id: 'fast', priority: 2, hasResult: (d) => (d as { ok?: boolean }).ok === true }),
+    ])
+
+    let slowCalled = false
+    let fastCalled = false
+    globalThis.fetch = vi.fn(async () => {
+      if (!slowCalled) {
+        slowCalled = true
+        await new Promise((r) => setTimeout(r, 5000))
+        return new Response(JSON.stringify({ ok: true }), { status: 200 })
+      }
+      fastCalled = true
+      return new Response(JSON.stringify({ ok: true }), { status: 200 })
+    }) as typeof fetch
+
+    const start = Date.now()
+    const result = await executeWithFallback('enrich_company', { domain: 'coldiq.com' })
+    const elapsed = Date.now() - start
+
+    expect(slowCalled).toBe(true)
+    expect(fastCalled).toBe(true)
+    expect('data' in result).toBe(true)
+    if ('data' in result) expect(result._meta.provider).toBe('fast')
+    // Slow attempt should give up around 120ms, total well under the 5s hang.
+    expect(elapsed).toBeLessThan(2000)
+  })
+})

package/tests/live/leadsfactory-upstream-probe.ts

@@ -0,0 +1,97 @@
+// Direct upstream probe — bypasses the marketplace proxy. Goal: figure out why
+// GET /api/v1/find-people/searches/{id} returns errors from our proxy. Probe with
+// both id formats (mongo _id and short search_id) and both path forms (singular vs plural).
+//
+// Run:  LEADSFACTORY_API_KEY=… npx tsx mcp/tests/live/leadsfactory-upstream-probe.ts
+
+const KEY = process.env.LEADSFACTORY_API_KEY
+if (!KEY) { console.error('LEADSFACTORY_API_KEY required'); process.exit(1) }
+const BASE = 'https://apiv2.leadsfactory.io'
+
+async function call(method: 'GET' | 'POST', path: string, body?: unknown) {
+  const t0 = Date.now()
+  try {
+    const res = await fetch(`${BASE}${path}`, {
+      method,
+      headers: {
+        'X-API-Key': KEY!,
+        ...(body ? { 'Content-Type': 'application/json' } : {}),
+      },
+      body: body ? JSON.stringify(body) : undefined,
+      signal: AbortSignal.timeout(30_000),
+    })
+    let data: any
+    try { data = await res.json() } catch { data = await res.text().catch(() => '<no body>') }
+    return { ok: res.ok, status: res.status, ms: Date.now() - t0, data }
+  } catch (err) {
+    return { ok: false, status: 0, ms: Date.now() - t0, data: { error: String(err) } }
+  }
+}
+
+function summary(r: any, max = 300) {
+  const s = typeof r.data === 'string' ? r.data : JSON.stringify(r.data)
+  return `status=${r.status} ms=${r.ms} body=${s.slice(0, max)}`
+}
+
+async function main() {
+  console.log('=== LeadsFactory upstream probe ===')
+  console.log(`BASE=${BASE}\n`)
+
+  // 1. Create a small search to get fresh IDs to test against
+  console.log('▸ Step 1: POST to create a small search (1 contact at ColdIQ)')
+  const post = await call('POST', '/api/v1/find-people/search', {
+    company_domains: ['coldiq.com'],
+    search: {
+      max_persona_results: 1,
+      personas: [{ job_title: 'CEO' }],
+    },
+  })
+  console.log(`  ${summary(post, 800)}`)
+
+  if (!post.ok) {
+    console.log('  POST failed; aborting GET probes.')
+    return
+  }
+
+  const mongoId = post.data?._id
+  const searchId = post.data?.search_id
+  console.log(`\n  mongoId=${mongoId}`)
+  console.log(`  searchId=${searchId}\n`)
+
+  // 2. Try the GET in every shape we can think of
+  console.log('▸ Step 2: GET probes (try every path/id combo)')
+
+  for (const id of [mongoId, searchId].filter(Boolean)) {
+    const idType = id === mongoId ? 'mongoId' : 'searchId'
+    for (const path of [
+      `/api/v1/find-people/searches/${id}`,       // current marketplace shape (plural)
+      `/api/v1/find-people/search/${id}`,         // singular — matches POST path style
+      `/api/v1/find-people/searches/${id}/`,      // trailing slash
+      `/api/v1/find-people/${id}`,                // no segment
+      `/api/v1/find-people/search?id=${id}`,      // query param
+      `/api/v1/find-people/search?search_id=${id}`,
+    ]) {
+      const r = await call('GET', path)
+      console.log(`  [${idType}] GET ${path}`)
+      console.log(`    ${summary(r)}`)
+    }
+  }
+
+  // 3. Try the GET via different auth shapes (in case X-API-Key vs Bearer matters for GET)
+  console.log('\n▸ Step 3: alternate auth headers on the canonical path (plural + mongoId)')
+  const probePath = `/api/v1/find-people/searches/${mongoId}`
+  for (const [label, headers] of [
+    ['X-API-Key', { 'X-API-Key': KEY! }],
+    ['Authorization Bearer', { Authorization: `Bearer ${KEY}` }],
+    ['Authorization raw', { Authorization: KEY! }],
+    ['Api-Key', { 'Api-Key': KEY! }],
+  ] as const) {
+    const t0 = Date.now()
+    const res = await fetch(`${BASE}${probePath}`, { headers, signal: AbortSignal.timeout(20_000) })
+    let body: any
+    try { body = await res.json() } catch { body = await res.text() }
+    console.log(`  [${label}] status=${res.status} ms=${Date.now() - t0} body=${JSON.stringify(body).slice(0, 200)}`)
+  }
+}
+
+main().catch((e) => { console.error('FATAL', e); process.exit(1) })

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

@@ -362,6 +362,72 @@ describe('apollo (find_people)', () => {
     const body = result.body as Record<string, unknown>
     expect(body.q_keywords).toBeUndefined()
   })
+
+  it('postFilter drops people whose employer does not match company_domains', () => {
+    const filtered = p().postFilter!(
+      {
+        people: [
+          { name: 'Real WeWork CEO', organization: { website_url: 'https://wework.com/about' } },
+          { name: 'Random Brazilian CEO', organization: { website_url: 'shiftcompany.com' } },
+          { name: 'Hotmart Seller', organization: { website_url: 'someseller.com.br' } },
+        ],
+      },
+      { company_domains: ['wework.com'], job_titles: ['CEO'] },
+    ) as { people: Array<{ name: string }> }
+    expect(filtered.people.map((p) => p.name)).toEqual(['Real WeWork CEO'])
+  })
+
+  it('postFilter handles `www.` and protocol prefixes when matching', () => {
+    const filtered = p().postFilter!(
+      {
+        people: [
+          { name: 'Match A', organization: { website_url: 'https://www.coldiq.com/' } },
+          { name: 'Match B', organization: { website_url: 'coldiq.com' } },
+          { name: 'No match', organization: { website_url: 'otherco.com' } },
+        ],
+      },
+      { company_domains: ['coldiq.com'] },
+    ) as { people: Array<{ name: string }> }
+    expect(filtered.people.map((p) => p.name)).toEqual(['Match A', 'Match B'])
+  })
+
+  it('postFilter matches by LinkedIn URL when company_linkedin_urls is provided', () => {
+    const filtered = p().postFilter!(
+      {
+        people: [
+          { name: 'WW employee', organization: { linkedin_url: 'https://linkedin.com/company/wework' } },
+          { name: 'WW employee normalized', organization: { linkedin_url: 'linkedin.com/company/wework' } },
+          { name: 'Other', organization: { linkedin_url: 'linkedin.com/company/other' } },
+        ],
+      },
+      { company_linkedin_urls: ['https://linkedin.com/company/wework'] },
+    ) as { people: Array<{ name: string }> }
+    expect(filtered.people.map((p) => p.name)).toEqual(['WW employee', 'WW employee normalized'])
+  })
+
+  it('postFilter passes data through unchanged when no company filter is requested', () => {
+    const input = {
+      people: [
+        { name: 'A', organization: { website_url: 'a.com' } },
+        { name: 'B', organization: { website_url: 'b.com' } },
+      ],
+    }
+    const out = p().postFilter!(input, { job_titles: ['CEO'] }) as typeof input
+    expect(out.people.map((p) => p.name)).toEqual(['A', 'B'])
+  })
+
+  it('postFilter drops records that are missing organization info entirely (safer to lose than to risk false positives)', () => {
+    const filtered = p().postFilter!(
+      {
+        people: [
+          { name: 'Has org', organization: { website_url: 'wework.com' } },
+          { name: 'No org' }, // missing organization
+        ],
+      },
+      { company_domains: ['wework.com'] },
+    ) as { people: Array<{ name: string }> }
+    expect(filtered.people.map((p) => p.name)).toEqual(['Has org'])
+  })
 })
 
 // ---------------------------------------------------------------------------

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

@@ -21,7 +21,7 @@ describe('find_people handler', () => {
 
       // LeadsFactory create search — returns an ID
       if (urlStr.includes('/leadsfactory/contact-finder/searches') && callCount === 1) {
-        return new Response(JSON.stringify({ _id: 'abc123', search_id: 'abc', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
+        return new Response(JSON.stringify({ id: 'abc123', search_id: 'abc', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
       }
 
       // LeadsFactory poll — always RUNNING (will timeout)
@@ -31,7 +31,7 @@ describe('find_people handler', () => {
 
       // Apollo — succeeds
       if (urlStr.includes('/apollo/people/search')) {
-        return new Response(JSON.stringify({ people: [{ name: 'Michel Lieben', title: 'CEO' }] }), { status: 200 })
+        return new Response(JSON.stringify({ people: [{ name: 'Michel Lieben', title: 'CEO', organization: { website_url: 'coldiq.com' } }] }), { status: 200 })
       }
 
       return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
@@ -70,7 +70,7 @@ describe('find_people handler', () => {
 
       // LeadsFactory create search
       if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        return new Response(JSON.stringify({ _id: 'abc123', search_id: 'abc', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
+        return new Response(JSON.stringify({ id: 'abc123', search_id: 'abc', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
       }
 
       // LeadsFactory poll — first RUNNING, then SUCCESSFUL with contacts
@@ -121,7 +121,7 @@ describe('find_people handler', () => {
 
       // LeadsFactory create
       if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        return new Response(JSON.stringify({ _id: 'abc123', search_id: 'abc', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
+        return new Response(JSON.stringify({ id: 'abc123', search_id: 'abc', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
       }
 
       // LeadsFactory poll — SUCCESSFUL with one miss
@@ -138,7 +138,7 @@ describe('find_people handler', () => {
       if (urlStr.includes('/apollo/people/search')) {
         const body = JSON.parse((opts?.body as string) ?? '{}')
         if (body.q_organization_domains?.includes('folk.app')) {
-          return new Response(JSON.stringify({ people: [{ name: 'Thibaud Elziere', title: 'CEO' }] }), { status: 200 })
+          return new Response(JSON.stringify({ people: [{ name: 'Thibaud Elziere', title: 'CEO', organization: { website_url: 'folk.app' } }] }), { status: 200 })
         }
       }
 
@@ -179,7 +179,7 @@ describe('find_people handler', () => {
       const urlStr = url.toString()
 
       if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
-        return new Response(JSON.stringify({ _id: 'abc123', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
+        return new Response(JSON.stringify({ id: 'abc123', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
       }
 
       if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
@@ -231,7 +231,7 @@ describe('find_people handler', () => {
 
       if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
         capturedBody = JSON.parse((opts?.body as string) ?? '{}')
-        return new Response(JSON.stringify({ _id: 'abc123', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
+        return new Response(JSON.stringify({ id: 'abc123', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
       }
 
       if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
@@ -277,7 +277,7 @@ describe('find_people handler', () => {
 
       if (urlStr.includes('/leadsfactory/contact-finder/searches') && !urlStr.includes('abc123')) {
         capturedBody = JSON.parse((opts?.body as string) ?? '{}')
-        return new Response(JSON.stringify({ _id: 'abc123', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
+        return new Response(JSON.stringify({ id: 'abc123', nb_jobs_total: 1, progress_percentage: 0 }), { status: 201 })
       }
 
       if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
@@ -325,7 +325,7 @@ describe('find_people handler', () => {
       }
 
       if (urlStr.includes('/apollo/people/search')) {
-        return new Response(JSON.stringify({ people: [{ name: 'Michel Lieben' }] }), { status: 200 })
+        return new Response(JSON.stringify({ people: [{ name: 'Michel Lieben', organization: { website_url: 'coldiq.com' } }] }), { status: 200 })
       }
 
       return new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })