@coldiq/mcp 0.1.14 → 0.1.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldiq/mcp",
-  "version": "0.1.14",
+  "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

@@ -1070,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/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

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