@coldiq/mcp 0.1.10 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldiq/mcp",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -16,8 +16,12 @@
     "version": "git add package.json package-lock.json",
     "postversion": "git commit -m \"chore(mcp): release $npm_package_version\" && git tag mcp-v$npm_package_version && git push && git push --tags"
   },
+  "engines": {
+    "node": ">=18.18"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
+    "undici": "^6.25.0",
     "zod": "^3.24.2"
   },
   "devDependencies": {

package/src/client.ts

@@ -1,3 +1,5 @@
+import { Agent, setGlobalDispatcher } from 'undici'
+
 export type ApiResponse = {
   ok: boolean
   status: number
@@ -6,15 +8,29 @@ export type ApiResponse = {
 
 let _apiUrl: string
 let _apiKey: string
+let _httpTimeoutMs: number
 
 export function initClient(apiUrl?: string, apiKey?: string): void {
   _apiUrl = apiUrl ?? process.env.COLDIQ_API_URL ?? 'https://api.coldiq.com'
   _apiKey = apiKey ?? process.env.COLDIQ_API_KEY ?? ''
+  _httpTimeoutMs = parseInt(process.env.COLDIQ_HTTP_TIMEOUT_MS ?? '30000', 10)
   if (!_apiKey) {
     throw new Error('COLDIQ_API_KEY is required — set it in .mcp.json env or as an environment variable')
   }
   // Strip trailing slash
   _apiUrl = _apiUrl.replace(/\/+$/, '')
+
+  // Tune the global undici dispatcher: keep-alive + connection pool.
+  // pipelining: 1 — Cloudflare front-door does not reliably support HTTP/1.1 pipelining.
+  // connections: 32 — covers worst-case find_emails fan-out (50 people × 2 providers).
+  setGlobalDispatcher(
+    new Agent({
+      keepAliveTimeout: 30_000,
+      keepAliveMaxTimeout: 60_000,
+      connections: 32,
+      pipelining: 1,
+    }),
+  )
 }
 
 export async function callApi(
@@ -34,7 +50,11 @@ export async function callApi(
     Authorization: `Bearer ${_apiKey}`,
   }
 
-  const init: RequestInit = { method, headers }
+  const init: RequestInit = {
+    method,
+    headers,
+    signal: AbortSignal.timeout(_httpTimeoutMs),
+  }
 
   if (method === 'POST' && body !== undefined) {
     headers['Content-Type'] = 'application/json'
@@ -51,6 +71,16 @@ export async function callApi(
     }
     return { ok: res.ok, status: res.status, data }
   } catch (err) {
+    const isTimeout =
+      err instanceof Error &&
+      (err.name === 'AbortError' || err.name === 'TimeoutError')
+    if (isTimeout) {
+      return {
+        ok: false,
+        status: 0,
+        data: { error: 'Request timed out' },
+      }
+    }
     if (process.env.COLDIQ_DEBUG) {
       console.error(`[coldiq:debug] network error: ${err instanceof Error ? err.message : String(err)}`)
     }

package/src/executor.ts

@@ -51,6 +51,8 @@ async function executeAsync(
   payload: { body?: unknown; queryParams?: Record<string, string> },
 ): Promise<{ ok: boolean; data: unknown }> {
   const asyncCfg = provider.async!
+  const firstPollMs = parseInt(process.env.COLDIQ_FIRST_POLL_MS ?? '750', 10)
+  const maxPollErrors = parseInt(process.env.COLDIQ_MAX_POLL_ERRORS ?? '3', 10)
 
   // Step 1: create the job
   debug(`${provider.id} async: creating job...`)
@@ -70,28 +72,48 @@ async function executeAsync(
   if (!jobId) return { ok: false, data: { error: 'Empty job ID from async response' } }
   debug(`${provider.id} async: job created (${jobId}), polling...`)
 
-  // Step 3: poll until complete or timeout
+  // Step 3: poll until complete or timeout.
+  // First probe fires quickly — capped by both COLDIQ_FIRST_POLL_MS and the provider's
+  // configured first interval, so tests that set a short pollIntervalMs aren't blocked
+  // by the default 750ms.
   const deadline = Date.now() + asyncCfg.timeoutMs
   let pollCount = 0
+  let consecutivePollErrors = 0
+
+  const configuredFirstInterval = typeof asyncCfg.pollIntervalMs === 'function'
+    ? asyncCfg.pollIntervalMs(1)
+    : asyncCfg.pollIntervalMs
+  await sleep(Math.min(firstPollMs, configuredFirstInterval))
+
   while (Date.now() < deadline) {
+    const pollRes = await callApi('GET', asyncCfg.pollEndpoint(jobId))
+    pollCount++
+
+    if (!pollRes.ok) {
+      consecutivePollErrors++
+      if (consecutivePollErrors >= maxPollErrors) {
+        log(`${provider.id} async: poll failing (${consecutivePollErrors} consecutive errors), skipping`)
+        return { ok: false, data: { error: `Poll endpoint failed ${consecutivePollErrors} consecutive times` } }
+      }
+    } else {
+      consecutivePollErrors = 0
+      const status = (pollRes.data as Record<string, unknown>).status ?? 'unknown'
+      const progress = (pollRes.data as Record<string, unknown>).progress_percentage ?? '?'
+      debug(`${provider.id} async: poll #${pollCount} — status=${status}, progress=${progress}%`)
+
+      if (asyncCfg.isComplete(pollRes.data)) {
+        debug(`${provider.id} async: complete`)
+        return pollRes
+      }
+    }
+
+    if (Date.now() >= deadline) break
+
     const interval =
       typeof asyncCfg.pollIntervalMs === 'function'
         ? asyncCfg.pollIntervalMs(pollCount + 1)
         : asyncCfg.pollIntervalMs
     await sleep(interval)
-    pollCount++
-
-    const pollRes = await callApi('GET', asyncCfg.pollEndpoint(jobId))
-    if (!pollRes.ok) continue // transient poll errors — retry
-
-    const status = (pollRes.data as Record<string, unknown>).status ?? 'unknown'
-    const progress = (pollRes.data as Record<string, unknown>).progress_percentage ?? '?'
-    debug(`${provider.id} async: poll #${pollCount} — status=${status}, progress=${progress}%`)
-
-    if (asyncCfg.isComplete(pollRes.data)) {
-      debug(`${provider.id} async: complete`)
-      return pollRes
-    }
   }
 
   debug(`${provider.id} async: timed out after ${asyncCfg.timeoutMs / 1000}s`)

package/src/registry.ts

@@ -967,11 +967,10 @@ const findPeopleProviders: ProviderEntry[] = [
     },
     async: {
       pollEndpoint: (id: string) => `/leadsfactory/contact-finder/searches/${id}`,
-      // Continuously growing backoff: fast first probe (3s), then ramp up indefinitely
-      // — never plateaus, but the cumulative delay is bounded by timeoutMs.
-      // Schedule: 3s, 7s, 15s, 25s, 35s, 45s, 55s, 65s, +10s per attempt thereafter.
+      // Growing backoff: fast early probes, then steady growth bounded by timeoutMs.
+      // Schedule: 2s, 5s, 12s, 20s, 28s, 36s, +8s per attempt thereafter.
       pollIntervalMs: (attempt) =>
-        attempt === 1 ? 3000 : attempt === 2 ? 7000 : 15000 + (attempt - 3) * 10000,
+        attempt === 1 ? 2000 : attempt === 2 ? 5000 : 12000 + (attempt - 3) * 8000,
       timeoutMs: 300_000, // 5 minutes
       isComplete: (data) => {
         const d = data as Record<string, unknown>
@@ -1368,7 +1367,7 @@ const findEmailProviders: ProviderEntry[] = [
         return d.enrichment_id as string
       },
       pollEndpoint: (id) => `/fullenrich/contact/enrich/bulk/${id}`,
-      pollIntervalMs: 5000,
+      pollIntervalMs: 2500,
       timeoutMs: 60_000,
       isComplete: (data) => {
         const d = data as Record<string, unknown>
@@ -1463,7 +1462,7 @@ const verifyEmailProviders: ProviderEntry[] = [
         throw new Error('Instantly verification response has no email field')
       },
       pollEndpoint: (email) => `/instantly/email-verification/${encodeURIComponent(email)}`,
-      pollIntervalMs: 3000,
+      pollIntervalMs: 1500,
       timeoutMs: 30_000,
       isComplete: (data) => {
         const d = data as Record<string, unknown>
@@ -1879,7 +1878,7 @@ function _hasJobFilter(input: Record<string, unknown>, keys: string[]): boolean
 }
 
 const _jobsSharedAsync = {
-  pollIntervalMs: 5_000,
+  pollIntervalMs: (attempt: number) => (attempt === 1 ? 1500 : attempt <= 3 ? 2500 : 4000),
   timeoutMs: 300_000,
   extractId: (data: unknown) => {
     const jobId = (data as { jobId?: number | string }).jobId
@@ -2013,7 +2012,7 @@ const searchJobsProviders: ProviderEntry[] = [
 // ---------------------------------------------------------------------------
 
 const _adsSharedAsync = {
-  pollIntervalMs: 5_000,
+  pollIntervalMs: (attempt: number) => (attempt === 1 ? 1500 : attempt <= 3 ? 2500 : 4000),
   timeoutMs: 300_000,
   extractId: (data: unknown) => {
     const jobId = (data as { jobId?: number | string }).jobId
@@ -2181,7 +2180,7 @@ function _hasAny(input: Record<string, unknown>, keys: readonly string[]): boole
 }
 
 const _placesSharedAsync = {
-  pollIntervalMs: 5_000,
+  pollIntervalMs: (attempt: number) => (attempt === 1 ? 1500 : attempt <= 3 ? 2500 : 4000),
   timeoutMs: 300_000,
   extractId: (data: unknown) => {
     const jobId = (data as { jobId?: number | string }).jobId
@@ -2351,7 +2350,7 @@ const findInfluencersProviders: ProviderEntry[] = [
 // ---------------------------------------------------------------------------
 
 const _redditSharedAsync = {
-  pollIntervalMs: 5_000,
+  pollIntervalMs: (attempt: number) => (attempt === 1 ? 1500 : attempt <= 3 ? 2500 : 4000),
   timeoutMs: 300_000,
   extractId: (data: unknown) => {
     const jobId = (data as { jobId?: number | string }).jobId
@@ -3093,28 +3092,45 @@ export function getProviderApplicabilityGuard(
   return providers.find((p) => p.id === providerId)?.isApplicable
 }
 
+const _providersCache = new Map<Capability, ProviderEntry[]>()
+
 /**
  * Get the ordered provider list for a capability.
- * Returns a copy sorted by priority (lower = first).
+ * Returns a frozen sorted copy — cached after the first call (registry is static).
  */
 export function getProviders(capability: Capability): ProviderEntry[] {
-  const providers = registry[capability]
-  if (!providers) throw new Error(`Unknown capability: ${capability}`)
-  return [...providers].sort((a, b) => a.priority - b.priority)
+  let cached = _providersCache.get(capability)
+  if (!cached) {
+    const providers = registry[capability]
+    if (!providers) throw new Error(`Unknown capability: ${capability}`)
+    cached = Object.freeze([...providers].sort((a, b) => a.priority - b.priority)) as ProviderEntry[]
+    _providersCache.set(capability, cached)
+  }
+  return cached
 }
 
+const _searchWebProvidersCache = new Map<boolean, ProviderEntry[]>()
+
 /**
  * Get providers for search_web, reordering for neural search preference.
+ * Result is cached per preferNeural value — registry is static.
  */
 export function getSearchWebProviders(preferNeural: boolean): ProviderEntry[] {
-  const providers = getProviders('search_web')
-  if (preferNeural) {
-    // Put Exa first when neural is requested
-    return providers.sort((a, b) => {
-      if (a.id === 'exa') return -1
-      if (b.id === 'exa') return 1
-      return a.priority - b.priority
-    })
+  let cached = _searchWebProvidersCache.get(preferNeural)
+  if (!cached) {
+    const base = getProviders('search_web')
+    if (preferNeural) {
+      cached = Object.freeze(
+        [...base].sort((a, b) => {
+          if (a.id === 'exa') return -1
+          if (b.id === 'exa') return 1
+          return a.priority - b.priority
+        }),
+      ) as ProviderEntry[]
+    } else {
+      cached = base
+    }
+    _searchWebProvidersCache.set(preferNeural, cached)
   }
-  return providers
+  return cached
 }

package/src/tools/enrich-company.ts

@@ -18,15 +18,15 @@ export async function enrichCompanyHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   if (!restInput.domain && !restInput.linkedin_url && !restInput.name) {
     const err = { error: 'At least one of domain, linkedin_url, or name is required', providers_tried: [] }
-    return { content: [{ type: 'text' as const, text: JSON.stringify(err, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(err) }], isError: true }
   }
   const resolved = resolvePreferredProviders('enrich_company', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('enrich_company', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/enrich-person.ts

@@ -25,11 +25,11 @@ export async function enrichPersonHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('enrich_person', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('enrich_person', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/fetch-page-content.ts

@@ -33,11 +33,11 @@ export async function fetchPageContentHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('fetch_page_content', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('fetch_page_content', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/find-email.ts

@@ -45,19 +45,19 @@ export async function findEmailHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('find_email', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const validation = inputSchema.safeParse(restInput)
   if (!validation.success) {
     const msg = validation.error.issues.map((i) => i.message).join('; ')
     return {
-      content: [{ type: 'text' as const, text: JSON.stringify({ error: msg }, null, 2) }],
+      content: [{ type: 'text' as const, text: JSON.stringify({ error: msg }) }],
       isError: true,
     }
   }
   const result = await executeWithFallback('find_email', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/find-emails.ts

@@ -76,7 +76,7 @@ async function fullEnrichStep(misses: PersonInput[], results: EmailResult[]): Pr
   // faster, so FullEnrich's marginal value decays past this point.
   const deadline = Date.now() + 45_000
   while (Date.now() < deadline) {
-    await sleep(5000)
+    await sleep(2000)
     const pollRes = await callApi('GET', `/fullenrich/contact/enrich/bulk/${enrichmentId}`)
     if (!pollRes.ok) continue
 
@@ -162,7 +162,7 @@ export async function findEmailsHandler(input: Record<string, unknown>) {
 
   const resolved = resolvePreferredProviders('find_emails', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
 
   const allowedProviders = resolved.providers
@@ -218,14 +218,14 @@ export async function findEmailsHandler(input: Record<string, unknown>) {
     if (!isConstrained || allowedProviders.includes('findymail') || allowedProviders.includes('icypeas')) {
       steps.push(findymailIcypeasStep(misses, results, isConstrained ? allowedProviders : undefined))
     }
-    if (steps.length > 0) await Promise.all(steps)
+    if (steps.length > 0) await Promise.allSettled(steps)
   }
 
   const found = results.filter((r) => r.email !== null).length
 
   if (isConstrained && found === 0) {
     const err = buildAllFailedError(allowedProviders, 'find_emails', FIND_EMAILS_PROVIDERS)
-    return { content: [{ type: 'text' as const, text: JSON.stringify(err, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(err) }], isError: true }
   }
 
   const meta = resolved.matchedFrom && Object.keys(resolved.matchedFrom).length > 0
@@ -236,7 +236,7 @@ export async function findEmailsHandler(input: Record<string, unknown>) {
     content: [
       {
         type: 'text' as const,
-        text: JSON.stringify({ data: { results, found, total: people.length }, ...(meta ? { _meta: meta } : {}) }, null, 2),
+        text: JSON.stringify({ data: { results, found, total: people.length }, ...(meta ? { _meta: meta } : {}) }),
       },
     ],
   }

package/src/tools/find-influencers.ts

@@ -31,11 +31,11 @@ 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, null, 2) }], isError: true }
+    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, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/find-people.ts

@@ -32,11 +32,11 @@ export async function findPeopleHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('find_people', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    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, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
 
   // Gap-fill: if LeadsFactory missed some domains, try Apollo for those.
@@ -65,12 +65,12 @@ export async function findPeopleHandler(input: Record<string, unknown>) {
             },
           }
           return {
-            content: [{ type: 'text' as const, text: JSON.stringify({ ...result, data: merged }, null, 2) }],
+            content: [{ type: 'text' as const, text: JSON.stringify({ ...result, data: merged }) }],
           }
         }
       }
     }
   }
 
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/find-phone.ts

@@ -42,19 +42,19 @@ export async function findPhoneHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('find_phone', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const validation = inputSchema.safeParse(restInput)
   if (!validation.success) {
     const msg = validation.error.issues.map((i) => i.message).join('; ')
     return {
-      content: [{ type: 'text' as const, text: JSON.stringify({ error: msg }, null, 2) }],
+      content: [{ type: 'text' as const, text: JSON.stringify({ error: msg }) }],
       isError: true,
     }
   }
   const result = await executeWithFallback('find_phone', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/find-signals.ts

@@ -60,7 +60,7 @@ export async function findSignalsHandler(input: Record<string, unknown>) {
     return {
       content: [{
         type: 'text' as const,
-        text: JSON.stringify({ error: 'intent signal_type requires at least one of: companies or domains' }, null, 2),
+        text: JSON.stringify({ error: 'intent signal_type requires at least one of: companies or domains' }),
       }],
       isError: true,
     }
@@ -72,7 +72,7 @@ export async function findSignalsHandler(input: Record<string, unknown>) {
         type: 'text' as const,
         text: JSON.stringify({
           error: 'news and startup_post are feed-style signal types that only filter by country and since date — they do not support company filtering. Remove companies/domains, or use signal_type=intent for company-targeted intent signals.',
-        }, null, 2),
+        }),
       }],
       isError: true,
     }
@@ -80,12 +80,12 @@ export async function findSignalsHandler(input: Record<string, unknown>) {
 
   const resolved = resolvePreferredProviders('find_signals', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
 
   const result = await executeWithFallback('find_signals', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
 
   // buying_intents upstream has no limit param — truncate to requested limit
@@ -97,5 +97,5 @@ export async function findSignalsHandler(input: Record<string, unknown>) {
     }
   }
 
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/search-ads.ts

@@ -41,11 +41,11 @@ export async function searchAdsHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('search_ads', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('search_ads', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/search-companies.ts

@@ -38,11 +38,11 @@ export async function searchCompaniesHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('search_companies', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('search_companies', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/search-jobs.ts

@@ -66,15 +66,15 @@ export async function searchJobsHandler(input: Record<string, unknown>) {
         'Contradictory filters: ATS/domain filters (ats_slugs, company_domains) are Career Site only, ' +
         'while seniority/industry/employee filters are LinkedIn only. Remove one set.',
     }
-    return { content: [{ type: 'text' as const, text: JSON.stringify(err, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(err) }], isError: true }
   }
   const resolved = resolvePreferredProviders('search_jobs', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('search_jobs', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/search-places.ts

@@ -49,11 +49,11 @@ export async function searchPlacesHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('search_places', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('search_places', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/search-reddit.ts

@@ -31,11 +31,11 @@ export async function searchRedditHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('search_reddit', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('search_reddit', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/search-seo.ts

@@ -56,11 +56,11 @@ export async function searchSeoHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('search_seo', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('search_seo', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/search-web.ts

@@ -22,11 +22,11 @@ export async function searchWebHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('search_web', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('search_web', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/src/tools/verify-email.ts

@@ -16,11 +16,11 @@ export async function verifyEmailHandler(input: Record<string, unknown>) {
   const { use_providers: rawUseProviders, ...restInput } = input
   const resolved = resolvePreferredProviders('verify_email', restInput, rawUseProviders)
   if (!resolved.ok) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(resolved.error) }], isError: true }
   }
   const result = await executeWithFallback('verify_email', restInput, { providers: resolved.providers, matchedFrom: resolved.matchedFrom })
   if (isExecutionError(result)) {
-    return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }], isError: true }
+    return { content: [{ type: 'text' as const, text: JSON.stringify(result) }], isError: true }
   }
-  return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] }
+  return { content: [{ type: 'text' as const, text: JSON.stringify(result) }] }
 }

package/tests/client.test.ts

@@ -87,4 +87,36 @@ describe('client', () => {
     expect(result.ok).toBe(false)
     expect(result.status).toBe(404)
   })
+
+  it('maps AbortError (timeout) to { error: "Request timed out" }', async () => {
+    globalThis.fetch = vi.fn(async (_url: unknown, init?: RequestInit) => {
+      const signal = init?.signal as AbortSignal | undefined
+      if (signal?.aborted) {
+        const err = new Error('aborted')
+        err.name = 'AbortError'
+        throw err
+      }
+      await new Promise<void>((_, reject) => {
+        signal?.addEventListener('abort', () => {
+          const err = new Error('aborted')
+          err.name = 'AbortError'
+          reject(err)
+        })
+      })
+      return new Response(JSON.stringify({}), { status: 200 })
+    }) as typeof fetch
+
+    const origTimeout = process.env.COLDIQ_HTTP_TIMEOUT_MS
+    process.env.COLDIQ_HTTP_TIMEOUT_MS = '1'
+    initClient('http://test-api.local', 'test-key-123')
+    try {
+      const res = await callApi('GET', '/test')
+      expect(res.ok).toBe(false)
+      expect(res.status).toBe(0)
+      expect((res.data as Record<string, unknown>).error).toBe('Request timed out')
+    } finally {
+      if (origTimeout === undefined) delete process.env.COLDIQ_HTTP_TIMEOUT_MS
+      else process.env.COLDIQ_HTTP_TIMEOUT_MS = origTimeout
+    }
+  })
 })

package/tests/executor.test.ts

@@ -541,6 +541,87 @@ describe('executor async polling intervals', () => {
     expect(requestedDelays).toEqual([100, 200, 300, 400])
   })
 
+  it('first poll fires after firstPollMs (≤ configured interval) — not after the full interval', async () => {
+    const delays: number[] = []
+    globalThis.setTimeout = ((cb: () => void, ms?: number) => {
+      if (typeof ms === 'number' && ms > 0) delays.push(ms)
+      cb()
+      return 0 as unknown as ReturnType<typeof setTimeout>
+    }) as typeof setTimeout
+
+    let pollCount = 0
+    stubProviders([
+      makeProvider({
+        id: 'fast-complete',
+        hasResult: (data) => (data as Record<string, unknown>).done === true,
+        async: {
+          extractId: () => 'job-1',
+          pollEndpoint: (id) => `/poll/${id}`,
+          pollIntervalMs: 5000, // long interval
+          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({ done: true }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ id: 'job-1' }), { status: 200 })
+    }) as typeof fetch
+
+    await executeWithFallback('enrich_company', { domain: 'coldiq.com' })
+
+    // First poll fired after ≤ 750ms (COLDIQ_FIRST_POLL_MS default), which is less
+    // than the configured 5000ms interval.
+    expect(pollCount).toBe(1)
+    expect(delays.length).toBe(1)
+    expect(delays[0]).toBeLessThanOrEqual(750)
+  })
+
+  it('consecutive poll errors up to maxPollErrors abort the async job', async () => {
+    globalThis.setTimeout = ((cb: () => void) => { cb(); return 0 as unknown as ReturnType<typeof setTimeout> }) as typeof setTimeout
+
+    let createCalled = false
+    stubProviders([
+      makeProvider({
+        id: 'stuck-poll',
+        hasResult: () => false,
+        async: {
+          extractId: () => 'job-stuck',
+          pollEndpoint: (id) => `/poll/${id}`,
+          pollIntervalMs: 10,
+          timeoutMs: 60_000,
+          isComplete: () => false,
+        },
+      }),
+    ])
+
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      const u = url.toString()
+      if (u.includes('/poll/')) {
+        return new Response(JSON.stringify({ error: 'Internal error' }), { status: 500 })
+      }
+      createCalled = true
+      return new Response(JSON.stringify({ id: 'job-stuck' }), { status: 200 })
+    }) as typeof fetch
+
+    const origMax = process.env.COLDIQ_MAX_POLL_ERRORS
+    process.env.COLDIQ_MAX_POLL_ERRORS = '3'
+    try {
+      const result = await executeWithFallback('enrich_company', { domain: 'coldiq.com' })
+      expect(createCalled).toBe(true)
+      expect('error' in result).toBe(true)
+      // Should return in well under the 60s timeout (no setTimeout mocking needed beyond immediate)
+    } finally {
+      if (origMax === undefined) delete process.env.COLDIQ_MAX_POLL_ERRORS
+      else process.env.COLDIQ_MAX_POLL_ERRORS = origMax
+    }
+  })
+
 })
 
 // ---------------------------------------------------------------------------

package/tests/registry-polling.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest'
+import { getProviders } from '../src/registry.js'
+
+function evalPollSchedule(pollIntervalMs: number | ((attempt: number) => number), maxMs: number) {
+  const result: number[] = []
+  let cumulative = 0
+  let attempt = 1
+  while (cumulative < maxMs) {
+    const interval = typeof pollIntervalMs === 'function' ? pollIntervalMs(attempt) : pollIntervalMs
+    cumulative += interval
+    result.push(interval)
+    attempt++
+  }
+  return result
+}
+
+describe('MCP polling interval schedules', () => {
+  it('Apify shared async configs (jobs/ads/places/reddit): fast early polls, plateau at 4s', () => {
+    const providers = getProviders('search_jobs')
+    const p = providers.find((p) => p.id === 'career_site_jobs' || p.id === 'linkedin_jobs')!
+    expect(p?.async).toBeDefined()
+    const fn = p.async!.pollIntervalMs as (attempt: number) => number
+    expect(typeof fn).toBe('function')
+    expect(fn(1)).toBe(1500)
+    expect(fn(2)).toBe(2500)
+    expect(fn(3)).toBe(2500)
+    expect(fn(4)).toBe(4000) // plateaus at 4s
+    expect(fn(10)).toBe(4000)
+    // Must get ≥ 10 polls inside the 5-minute timeout
+    expect(evalPollSchedule(fn, 300_000).length).toBeGreaterThanOrEqual(10)
+  })
+
+  it('FullEnrich find-email: 2.5s interval fits inside 60s timeout', () => {
+    const providers = getProviders('find_email')
+    const fe = providers.find((p) => p.id === 'fullenrich')!
+    expect(fe?.async).toBeDefined()
+    expect(fe.async!.pollIntervalMs).toBe(2500)
+    // timeoutMs = 60_000 → at least 24 polls
+    expect(60_000 / 2500).toBeGreaterThanOrEqual(24)
+  })
+
+  it('Instantly verify-email: 1.5s interval fits inside 30s timeout', () => {
+    const providers = getProviders('verify_email')
+    const inst = providers.find((p) => p.id === 'instantly')!
+    expect(inst?.async).toBeDefined()
+    expect(inst.async!.pollIntervalMs).toBe(1500)
+    expect(30_000 / 1500).toBeGreaterThanOrEqual(20)
+  })
+
+  it('LeadsFactory find-people: shorter front, ≥7 polls in 5 minutes', () => {
+    const providers = getProviders('find_people')
+    const lf = providers.find((p) => p.id === 'leadsfactory')!
+    expect(lf?.async).toBeDefined()
+    const fn = lf.async!.pollIntervalMs as (attempt: number) => number
+    expect(fn(1)).toBe(2000) // faster first probe vs old 3000
+    expect(fn(2)).toBe(5000)
+    expect(fn(3)).toBe(12000)
+    // Validates ≥7 polls still fit in 5 min (guard against overly aggressive growth)
+    expect(evalPollSchedule(fn, 300_000).length).toBeGreaterThanOrEqual(7)
+  })
+})

package/tests/registry.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import { getProviders, getSearchWebProviders, isoCountryToName, listCapabilityProviderIds } from '../src/registry.js'
-import type { Capability } from '../src/registry.js'
+import type { Capability, ProviderEntry } from '../src/registry.js'
 
 const ALL_CAPABILITIES: Capability[] = [
   'search_companies',
@@ -36,11 +36,11 @@ describe('registry', () => {
     }
   })
 
-  it('returns a copy — mutating does not affect the registry', () => {
+  it('is memoized — consecutive calls return the same frozen reference', () => {
     const first = getProviders('search_companies')
-    first.pop()
     const second = getProviders('search_companies')
-    expect(second.length).toBeGreaterThan(first.length)
+    expect(first).toBe(second) // referential equality — cache is working
+    expect(() => (first as ProviderEntry[]).pop()).toThrow() // frozen — mutation throws
   })
 
   it('throws for unknown capability', () => {
@@ -518,11 +518,11 @@ describe('registry', () => {
       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)
+      expect(fn(1)).toBe(2000)
+      expect(fn(2)).toBe(5000)
+      expect(fn(3)).toBe(12000)
+      expect(fn(4)).toBe(20000)
+      expect(fn(8)).toBe(52000)
       // 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

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

@@ -400,3 +400,58 @@ describe('find_emails handler — use_providers', () => {
     expect(icypeasCalled).toBe(false)
   })
 })
+
+describe('find_emails handler — resilience', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('findymailIcypeasStep completing correctly even when fullEnrichStep throws', async () => {
+    // Prospeo returns no results.
+    // FullEnrich create call throws (simulates unexpected error).
+    // FindyMail finds the email — result should still be populated.
+
+    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 })
+      }
+      if (u.includes('/fullenrich/contact/enrich/bulk') && !u.includes('/fullenrich/contact/enrich/bulk/')) {
+        // Throw so fullEnrichStep rejects
+        throw new Error('FullEnrich network failure')
+      }
+      if (u.includes('/findymail/search/name')) {
+        return new Response(JSON.stringify({ email: 'alice@example.com' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const resultPromise = findEmailsHandler({
+      people: [{ id: 'p1', first_name: 'Alice', last_name: 'Smith', domain: 'example.com' }],
+    })
+
+    // Advance timers past the FullEnrich poll sleep
+    await vi.runAllTimersAsync()
+    const result = await resultPromise
+
+    vi.useRealTimers()
+
+    // Despite fullEnrichStep throwing, the handler must succeed
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.data.found).toBe(1)
+    expect(parsed.data.results[0]).toMatchObject({ id: 'p1', email: 'alice@example.com', provider: 'findymail' })
+  })
+})

package/tests/tools/response-format.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { searchCompaniesHandler } from '../../src/tools/search-companies.js'
+import { findEmailHandler } from '../../src/tools/find-email.js'
+
+describe('tool response format', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    vi.restoreAllMocks()
+  })
+
+  it('success response is compact JSON (no indentation)', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ companies: [{ name: 'Acme' }] }), { status: 200 }),
+    ) as typeof fetch
+
+    const result = await searchCompaniesHandler({ keywords: ['SaaS'], limit: 5 })
+    const text = result.content[0].text
+
+    expect(result.isError).toBeFalsy()
+    // Compact JSON has no newlines
+    expect(text).not.toContain('\n')
+    // Must be valid JSON
+    expect(() => JSON.parse(text)).not.toThrow()
+  })
+
+  it('error response is compact JSON (no indentation)', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ error: 'Bad request' }), { status: 400 }),
+    ) as typeof fetch
+
+    const result = await findEmailHandler({ first_name: 'Michel', last_name: 'Lieben', domain: 'coldiq.com' })
+    const text = result.content[0].text
+
+    expect(result.isError).toBeTruthy()
+    expect(text).not.toContain('\n')
+    expect(() => JSON.parse(text)).not.toThrow()
+  })
+})