@coldiq/mcp 0.1.11 → 0.1.13

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/live/companyenrich-async-probe.ts

@@ -0,0 +1,31 @@
+// Probe /companies/search/async body shape — does it want filters flat under `search`
+// or still wrapped under `search.filters`?
+const KEY = process.env.COMPANYENRICH_API_KEY!
+const BASE = 'https://api.companyenrich.com'
+
+async function call(label: string, body: unknown) {
+  const t0 = Date.now()
+  const res = await fetch(`${BASE}/companies/search/async`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${KEY}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(20_000),
+  })
+  let data: any
+  try { data = await res.json() } catch { data = '<non-json>' }
+  console.log(`[${label}]\n  body=${JSON.stringify(body)}\n  status=${res.status} ms=${Date.now() - t0} data=${JSON.stringify(data).slice(0, 300)}\n`)
+}
+
+async function main() {
+  // Use count=1 to minimise credit burn.
+  await call('A: search.filters wrapped (current)', {
+    search: { filters: { query: 'wework' } }, count: 1,
+  })
+  await call('B: search flat (proposed)', {
+    search: { query: 'wework' }, count: 1,
+  })
+  // Some async APIs accept query at the very top too.
+  await call('C: query at top, no search envelope', { query: 'wework', count: 1 })
+}
+
+main()

package/tests/live/companyenrich-fix-validation.ts

@@ -0,0 +1,125 @@
+// Validation suite — confirms the fix direction before committing.
+//
+// What we need to prove:
+//   1. `{filters: {...}}` wrapping is broken across the FOUR search endpoints
+//      (search, preview, count, scroll). If only `/search` is affected, the fix is narrower.
+//   2. Top-level shape works consistently — filter combinations (query + country,
+//      query + employees, etc.) all narrow the result set as expected.
+//   3. The bulk-enrich endpoint is unaffected (the bug is search-specific).
+//   4. Ranges that wrapFilters translates (employees, foundedYear) still need their
+//      translation logic — confirm whether upstream wants employeesFrom/employeesTo top-level
+//      or {employees: {from, to}} or [{from, to}].
+//
+// Run:  COMPANYENRICH_API_KEY=… npx tsx mcp/tests/live/companyenrich-fix-validation.ts
+
+const KEY = process.env.COMPANYENRICH_API_KEY
+if (!KEY) { console.error('COMPANYENRICH_API_KEY required'); process.exit(1) }
+const BASE = 'https://api.companyenrich.com'
+
+async function callRaw(path: string, body: unknown) {
+  const t0 = Date.now()
+  try {
+    const res = await fetch(`${BASE}${path}`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${KEY}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(30_000),
+    })
+    let data: any
+    try { data = await res.json() } catch { data = '<non-json>' }
+    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 summarize(r: any) {
+  const items = (r.data?.items ?? []).slice(0, 3).map((c: any) => `${c.name}/${c.country ?? '?'}`)
+  return `status=${r.status} ms=${r.ms} count=${r.data?.items?.length ?? r.data?.count ?? '?'} top=${JSON.stringify(items)}`
+}
+
+function header(s: string) { console.log(`\n${'═'.repeat(78)}\n${s}\n${'═'.repeat(78)}`) }
+function sub(s: string) { console.log(`\n— ${s}`) }
+
+async function main() {
+  // ============================================================================
+  header('PART 1 — Confirm the wrap-vs-top-level bug on EACH of 4 search endpoints')
+  // ============================================================================
+
+  const wrapped = { pageSize: 5, filters: { query: 'wework' } }
+  const flat    = { pageSize: 5, query: 'wework' }
+
+  for (const path of ['/companies/search', '/companies/search/preview', '/companies/search/scroll']) {
+    sub(`${path}  wrapped (current)`)
+    console.log('  ', summarize(await callRaw(path, wrapped)))
+    sub(`${path}  flat  (proposed)`)
+    console.log('  ', summarize(await callRaw(path, flat)))
+  }
+
+  // count endpoint returns a count not items
+  sub('/companies/search/count  wrapped (current)')
+  let r = await callRaw('/companies/search/count', { filters: { query: 'wework' } })
+  console.log(`  status=${r.status} ms=${r.ms} data=${JSON.stringify(r.data).slice(0, 200)}`)
+  sub('/companies/search/count  flat (proposed)')
+  r = await callRaw('/companies/search/count', { query: 'wework' })
+  console.log(`  status=${r.status} ms=${r.ms} data=${JSON.stringify(r.data).slice(0, 200)}`)
+
+  // ============================================================================
+  header('PART 2 — Confirm flat-shape combinations actually narrow results')
+  // ============================================================================
+
+  sub('flat: query="wework" + countries=["BR"]')
+  console.log('  ', summarize(await callRaw('/companies/search', { pageSize: 5, query: 'wework', countries: ['BR'] })))
+
+  sub('flat: query="wework" + countries=["US"]')
+  console.log('  ', summarize(await callRaw('/companies/search', { pageSize: 5, query: 'wework', countries: ['US'] })))
+
+  sub('flat: countries=["BR"] + keywords=["fintech"]')
+  console.log('  ', summarize(await callRaw('/companies/search', { pageSize: 5, countries: ['BR'], keywords: ['fintech'] })))
+
+  sub('flat: keywords=["SaaS"]  (does keywords field do anything at top level?)')
+  console.log('  ', summarize(await callRaw('/companies/search', { pageSize: 5, keywords: ['SaaS'] })))
+
+  sub('flat: industries=["Software"]  (does industries field do anything?)')
+  console.log('  ', summarize(await callRaw('/companies/search', { pageSize: 5, industries: ['Software'] })))
+
+  // ============================================================================
+  header('PART 3 — Confirm range shape (employees, foundedYear) works at top level')
+  // ============================================================================
+
+  sub('flat: employees=[{from:1000, to:5000}]')
+  console.log('  ', summarize(await callRaw('/companies/search', { pageSize: 5, employees: [{ from: 1000, to: 5000 }] })))
+
+  sub('flat: employeesFrom=1000 + employeesTo=5000 (the wrapFilters translation target)')
+  console.log('  ', summarize(await callRaw('/companies/search', { pageSize: 5, employeesFrom: 1000, employeesTo: 5000 })))
+
+  sub('flat: foundedYear={from:2015, to:2020}')
+  console.log('  ', summarize(await callRaw('/companies/search', { pageSize: 5, foundedYear: { from: 2015, to: 2020 } })))
+
+  sub('flat: foundedFrom=2015 + foundedTo=2020 (translated form)')
+  console.log('  ', summarize(await callRaw('/companies/search', { pageSize: 5, foundedFrom: 2015, foundedTo: 2020 })))
+
+  // ============================================================================
+  header('PART 4 — Confirm bulk-enrich endpoint is unaffected (no wrapFilters there)')
+  // ============================================================================
+
+  sub('POST /companies/enrich?domain=wework.com (single enrich, GET-like)')
+  // Single enrich uses query params, not wrapFilters — should be unaffected.
+  try {
+    const er = await fetch(`${BASE}/companies/enrich?domain=wework.com`, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${KEY}` },
+      signal: AbortSignal.timeout(20_000),
+    })
+    const ed = await er.json()
+    console.log(`  status=${er.status} name=${(ed as any)?.name} domain=${(ed as any)?.domain}`)
+  } catch (err) {
+    console.log(`  failed: ${err}`)
+  }
+
+  // ============================================================================
+  header('DONE')
+  // ============================================================================
+}
+
+main().catch((e) => { console.error('FATAL', e); process.exit(1) })

package/tests/live/companyenrich-hybrid-probe.ts

@@ -0,0 +1,54 @@
+// Hybrid: scalars top-level, ranges wrapped? Or ranges with a special shape?
+const KEY = process.env.COMPANYENRICH_API_KEY!
+const BASE = 'https://api.companyenrich.com'
+
+async function count(label: string, body: unknown) {
+  const t0 = Date.now()
+  const res = await fetch(`${BASE}/companies/search/count`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${KEY}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(20_000),
+  })
+  const data: any = await res.json().catch(() => ({}))
+  console.log(`[${label}]\n  body=${JSON.stringify(body)}\n  status=${res.status} ms=${Date.now() - t0} count=${data?.count} total=${data?.total}\n`)
+}
+
+async function main() {
+  // Hypothesis A: maybe ranges need `filters: {}` wrapping (hybrid model)
+  await count('A1: countries top-level + filters.employees', {
+    countries: ['US'], filters: { employees: { from: 1000, to: 5000 } },
+  })
+  await count('A2: countries top-level + filters.employeesFrom/To', {
+    countries: ['US'], filters: { employeesFrom: 1000, employeesTo: 5000 },
+  })
+
+  // Hypothesis B: everything inside filters (back to old shape)
+  await count('B: filters.countries + filters.employees array', {
+    filters: { countries: ['US'], employees: [{ from: 1000, to: 5000 }] },
+  })
+
+  // Hypothesis C: maybe a different field name (size, headcount_range, employee_range)
+  await count('C1: size {from,to}', { size: { from: 1000, to: 5000 } })
+  await count('C2: headcountRange {min,max}', { headcountRange: { min: 1000, max: 5000 } })
+  await count('C3: employeesRange', { employeesRange: { from: 1000, to: 5000 } })
+
+  // Hypothesis D: maybe array of buckets like ["1001-5000"] or letter codes
+  await count('D1: employees ["1001-5000"]', { employees: ['1001-5000'] })
+  await count('D2: employees ["F"]', { employees: ['F'] }) // LimaData uses letter buckets, just in case
+
+  // Hypothesis E: snake_case field name
+  await count('E: employees_from/employees_to', { employees_from: 1000, employees_to: 5000 })
+
+  // Hypothesis F: revenue & funding to triangulate — do ANY ranges work?
+  await count('F1: revenueFrom/revenueTo', { revenueFrom: 1000000, revenueTo: 10000000 })
+  await count('F2: filters.revenueFrom/revenueTo', { filters: { revenueFrom: 1000000, revenueTo: 10000000 } })
+
+  // Hypothesis G: lookup an actual reference-data endpoint for valid bucket IDs (CompanyEnrich does have one)
+  // Skipping — adds latency; do if all of the above fail.
+
+  // Sanity check
+  await count('sanity: countries=DE alone', { countries: ['DE'] })
+}
+
+main()

package/tests/live/companyenrich-query-probe.ts

@@ -0,0 +1,49 @@
+// Probe CompanyEnrich /companies/search to find the correct field name for brand-name lookup.
+// We hit our marketplace endpoint with different request shapes and observe what comes back.
+const API_URL = process.env.COLDIQ_API_URL ?? 'https://api.coldiq.com'
+const API_KEY = process.env.COLDIQ_API_KEY!
+
+async function call(body: unknown) {
+  const t0 = Date.now()
+  const res = await fetch(`${API_URL}/v1/companyenrich/companies/search`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(30_000),
+  })
+  let data: any
+  try { data = await res.json() } catch { data = '<non-json>' }
+  return { ok: res.ok, status: res.status, ms: Date.now() - t0, data }
+}
+
+function summarize(r: any) {
+  const items = (r.data?.items ?? []).slice(0, 5).map((c: any) => `${c.name} (${c.domain})`)
+  return `status=${r.status} ms=${r.ms} items=${items.length} top5=${JSON.stringify(items)}`
+}
+
+async function main() {
+  console.log('=== Probe: how to find WeWork in CompanyEnrich ===\n')
+
+  console.log('1) query="wework"')
+  console.log('  ', summarize(await call({ query: 'wework', pageSize: 5 })))
+
+  console.log('\n2) names=["WeWork"]')
+  console.log('  ', summarize(await call({ names: ['WeWork'], pageSize: 5 })))
+
+  console.log('\n3) domains=["wework.com"]')
+  console.log('  ', summarize(await call({ domains: ['wework.com'], pageSize: 5 })))
+
+  console.log('\n4) query="wework" + countries=["US"]')
+  console.log('  ', summarize(await call({ query: 'wework', countries: ['US'], pageSize: 5 })))
+
+  console.log('\n5) semanticQuery="WeWork coworking"')
+  console.log('  ', summarize(await call({ semanticQuery: 'WeWork coworking', pageSize: 5 })))
+
+  console.log('\n6) names=["wework"] (lowercase)')
+  console.log('  ', summarize(await call({ names: ['wework'], pageSize: 5 })))
+
+  console.log('\n7) only countries=["BR"] (baseline — what does no name filter return?)')
+  console.log('  ', summarize(await call({ countries: ['BR'], pageSize: 5 })))
+}
+
+main().catch(console.error)

package/tests/live/companyenrich-ranges-probe.ts

@@ -0,0 +1,49 @@
+// Probe the range-filter shape. We use /companies/search/count because it gives a
+// definitive "did the filter narrow?" signal — full-DB count is ~20.4M, so anything
+// less means the filter applied.
+const KEY = process.env.COMPANYENRICH_API_KEY!
+const BASE = 'https://api.companyenrich.com'
+
+async function count(label: string, body: unknown) {
+  const t0 = Date.now()
+  const res = await fetch(`${BASE}/companies/search/count`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${KEY}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(20_000),
+  })
+  const data: any = await res.json().catch(() => ({}))
+  const ms = Date.now() - t0
+  console.log(`[${label}]`)
+  console.log(`  body=${JSON.stringify(body)}`)
+  console.log(`  status=${res.status} ms=${ms} count=${data?.count} total=${data?.total}\n`)
+}
+
+async function main() {
+  // Baselines
+  await count('baseline empty', {})
+  await count('baseline countries=US', { countries: ['US'] })
+
+  // Range candidates — try every shape
+  await count('flat employeesFrom/employeesTo', { employeesFrom: 1000, employeesTo: 5000 })
+  await count('flat employees array [{from,to}]', { employees: [{ from: 1000, to: 5000 }] })
+  await count('flat employees object {from,to}', { employees: { from: 1000, to: 5000 } })
+  await count('flat employees scalar {min,max}', { employees: { min: 1000, max: 5000 } })
+  await count('flat employeesMin/employeesMax', { employeesMin: 1000, employeesMax: 5000 })
+  await count('flat headcount', { headcount: { from: 1000, to: 5000 } })
+  await count('flat employee_count', { employee_count: { from: 1000, to: 5000 } })
+
+  // Ranges combined with a primary filter (in case they need company narrowing first)
+  await count('countries=US + employeesFrom/To', { countries: ['US'], employeesFrom: 1000, employeesTo: 5000 })
+  await count('countries=US + employees array', { countries: ['US'], employees: [{ from: 1000, to: 5000 }] })
+
+  // Founded year shapes
+  await count('foundedFrom/foundedTo', { foundedFrom: 2015, foundedTo: 2020 })
+  await count('foundedYear {from,to}', { foundedYear: { from: 2015, to: 2020 } })
+  await count('foundedYearFrom/foundedYearTo', { foundedYearFrom: 2015, foundedYearTo: 2020 })
+
+  // Sanity — does a known-working filter still narrow alongside ranges?
+  await count('countries=BR (sanity)', { countries: ['BR'] })
+}
+
+main()