@coldiq/mcp 0.1.6 → 0.1.8

package/tests/executor.test.ts

@@ -308,3 +308,172 @@ describe('executor postFilter integration', () => {
     }
   })
 })
+
+// 402 / Insufficient credits propagation
+// ---------------------------------------------------------------------------
+
+describe('executor — 402 propagation', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key-123')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    vi.restoreAllMocks()
+  })
+
+  it('surfaces billingUrl + insufficientCredits when every provider returns 402', async () => {
+    stubProviders([
+      makeProvider({ id: 'p1', hasResult: () => false }),
+      makeProvider({ id: 'p2', hasResult: () => false }),
+    ])
+
+    const body = {
+      error: "You don't have enough credits to run this request — it costs 5 credits and your balance is 0. Top up your account at https://coldiq.com/marketplace/billing to continue.",
+      billingUrl: 'https://coldiq.com/marketplace/billing',
+      needed: 5,
+      balance: 0,
+    }
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify(body), { status: 402 })
+    ) as typeof fetch
+
+    const result = await executeWithFallback('search_companies', { keywords: ['SaaS'] })
+
+    expect('error' in result).toBe(true)
+    if ('error' in result) {
+      expect(result.insufficientCredits).toBe(true)
+      expect(result.billingUrl).toBe('https://coldiq.com/marketplace/billing')
+      expect(result.error).toContain('https://coldiq.com/marketplace/billing')
+      expect(result.error).toMatch(/insufficient credits/i)
+      expect(result.providers_tried).toHaveLength(2)
+      expect(result.providers_tried[0].status).toBe(402)
+    }
+  })
+
+  it('does NOT set insufficientCredits when only some providers return 402', async () => {
+    stubProviders([
+      makeProvider({ id: 'p1', hasResult: () => false }),
+      makeProvider({ id: 'p2', hasResult: () => false }),
+    ])
+
+    let call = 0
+    globalThis.fetch = vi.fn(async () => {
+      call++
+      if (call === 1) {
+        return new Response(
+          JSON.stringify({ error: 'no credits', billingUrl: 'https://coldiq.com/marketplace/billing' }),
+          { status: 402 }
+        )
+      }
+      return new Response(JSON.stringify({ error: 'upstream timeout' }), { status: 502 })
+    }) as typeof fetch
+
+    const result = await executeWithFallback('search_companies', { keywords: ['SaaS'] })
+
+    expect('error' in result).toBe(true)
+    if ('error' in result) {
+      expect(result.insufficientCredits).toBeUndefined()
+      expect(result.billingUrl).toBe('https://coldiq.com/marketplace/billing')
+      expect(result.error).not.toMatch(/insufficient credits/i)
+    }
+  })
+
+  it('preserves the full 402 message in providers_tried (not truncated mid-URL)', async () => {
+    stubProviders([makeProvider({ id: 'p1', hasResult: () => false })])
+
+    const longMessage =
+      "You don't have enough credits to run this request — it costs 5 credits and your balance is 0. Top up your account at https://coldiq.com/marketplace/billing to continue."
+    globalThis.fetch = vi.fn(async () =>
+      new Response(
+        JSON.stringify({ error: longMessage, billingUrl: 'https://coldiq.com/marketplace/billing' }),
+        { status: 402 }
+      )
+    ) as typeof fetch
+
+    const result = await executeWithFallback('search_companies', { keywords: ['SaaS'] })
+
+    if ('error' in result) {
+      expect(result.providers_tried[0].error).toContain('https://coldiq.com/marketplace/billing')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Async polling — function-form pollIntervalMs (backoff schedule)
+// ---------------------------------------------------------------------------
+
+describe('executor async polling intervals', () => {
+  const originalFetch = globalThis.fetch
+  const originalSetTimeout = globalThis.setTimeout
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key-123')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    globalThis.setTimeout = originalSetTimeout
+    vi.restoreAllMocks()
+  })
+
+  it('function-form pollIntervalMs is invoked per attempt with the 1-indexed attempt number', async () => {
+    const intervalCalls: number[] = []
+    const requestedDelays: number[] = []
+
+    // Capture every sleep delay (executeAsync uses setTimeout via the local sleep helper)
+    // and resolve immediately so we don't actually wait.
+    globalThis.setTimeout = ((cb: () => void, ms?: number) => {
+      if (typeof ms === 'number' && ms > 0) requestedDelays.push(ms)
+      cb()
+      return 0 as unknown as ReturnType<typeof setTimeout>
+    }) as typeof setTimeout
+
+    // Provider that completes on poll #4 — drives 4 sleep calls before returning.
+    let pollCount = 0
+    stubProviders([
+      makeProvider({
+        id: 'backoff-provider',
+        hasResult: (data) => (data as Record<string, unknown>).done === true,
+        async: {
+          extractId: () => 'job-xyz',
+          pollEndpoint: (id) => `/poll/${id}`,
+          pollIntervalMs: (attempt) => {
+            intervalCalls.push(attempt)
+            // Use small numbers so total wait stays bounded if setTimeout were real
+            return attempt * 100
+          },
+          timeoutMs: 60_000,
+          isComplete: (data) => (data as Record<string, unknown>).done === true,
+        },
+      }),
+    ])
+
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/poll/')) {
+        pollCount++
+        return new Response(
+          JSON.stringify(pollCount >= 4 ? { done: true } : { done: false }),
+          { status: 200 },
+        )
+      }
+      // create-job response
+      return new Response(JSON.stringify({ id: 'job-xyz' }), { status: 200 })
+    }) as typeof fetch
+
+    const result = await executeWithFallback('enrich_company', { domain: 'coldiq.com' })
+
+    expect('data' in result).toBe(true)
+    // Function called once per loop iteration with 1-indexed attempt numbers
+    expect(intervalCalls).toEqual([1, 2, 3, 4])
+    // Each requested delay matches `attempt * 100`
+    expect(requestedDelays).toEqual([100, 200, 300, 400])
+  })
+
+})
+
+// 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.

package/tests/registry.test.ts

@@ -509,12 +509,29 @@ describe('registry', () => {
       expect((result.body as Record<string, unknown>).company_linkedin_urls).toBeUndefined()
     })
 
-    it('LeadsFactory has async config', () => {
+    it('LeadsFactory has async config with continuous backoff schedule', () => {
       const providers = getProviders('find_people')
       const lf = providers.find((p) => p.id === 'leadsfactory')!
       expect(lf.async).toBeDefined()
-      expect(lf.async!.pollIntervalMs).toBe(15000)
       expect(lf.async!.timeoutMs).toBe(300_000)
+      // Function-form pollIntervalMs: fast first probe, then continuously growing backoff.
+      const sched = lf.async!.pollIntervalMs
+      expect(typeof sched).toBe('function')
+      const fn = sched as (attempt: number) => number
+      expect(fn(1)).toBe(3000)
+      expect(fn(2)).toBe(7000)
+      expect(fn(3)).toBe(15000)
+      expect(fn(4)).toBe(25000)
+      expect(fn(8)).toBe(65000)
+      // At least 7 polls must fit inside the 5-minute timeout — guards against
+      // future tuning that would make the ramp so steep we only get 1–2 polls.
+      let cumulative = 0
+      let attempts = 0
+      while (cumulative < lf.async!.timeoutMs) {
+        attempts++
+        cumulative += fn(attempts)
+      }
+      expect(attempts).toBeGreaterThanOrEqual(7)
     })
 
     it('Apollo maps correctly', () => {

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

@@ -244,6 +244,49 @@ describe('find_emails handler (bulk)', () => {
     expect(parsed.data.results[0]).toEqual({ id: 'p1', email: 'alice@example.com', provider: 'fullenrich' })
   })
 
+  it('parallel branches: faster FindyMail wins, slower FullEnrich does not overwrite', async () => {
+    // Step 2 (FullEnrich) and Step 3 (FindyMail/IcyPeas) run concurrently. If FindyMail
+    // returns an email first, the FullEnrich poll later must NOT overwrite it.
+    vi.useFakeTimers()
+
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/prospeo/bulk-enrich-person')) {
+        return new Response(
+          JSON.stringify({ error: false, results: [{ identifier: 'p1', error: true, person: null }], total_cost: 0 }),
+          { status: 200 },
+        )
+      }
+      // FindyMail wins immediately
+      if (u.includes('/findymail/search/name')) {
+        return new Response(JSON.stringify({ email: 'fm@example.com' }), { status: 200 })
+      }
+      // FullEnrich create + later poll succeed but with a different email
+      if (u.includes('/fullenrich/contact/enrich/bulk/abc-fe-456')) {
+        return new Response(
+          JSON.stringify({ status: 'DONE', data: [{ custom_id: 'p1', emails: ['fe@example.com'] }] }),
+          { status: 200 },
+        )
+      }
+      if (u.includes('/fullenrich/contact/enrich/bulk')) {
+        return new Response(JSON.stringify({ enrichment_id: 'abc-fe-456' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const handlerPromise = findEmailsHandler({
+      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
+    })
+
+    await vi.runAllTimersAsync()
+    const result = await handlerPromise
+    vi.useRealTimers()
+
+    const parsed = JSON.parse(result.content[0].text)
+    // FindyMail won the race — its email + provider must persist
+    expect(parsed.data.results[0]).toEqual({ id: 'p1', email: 'fm@example.com', provider: 'findymail' })
+  })
+
   it('gracefully handles prospeo bulk failure and still tries fallbacks', async () => {
     globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
       const u = url.toString()