@coldiq/mcp 0.1.0

package/test-influencers-live.ts

@@ -0,0 +1,66 @@
+import { initClient } from './src/client.js'
+import { findInfluencersHandler } from './src/tools/find-influencers.js'
+
+const API_URL = 'https://api.coldiq.com'
+const API_KEY = 'ciq_test_3797d4ddc5542ceb'
+
+initClient(API_URL, API_KEY)
+
+async function run(label: string, input: Record<string, unknown>) {
+  console.log(`\n${'─'.repeat(60)}`)
+  console.log(`TEST: ${label}`)
+  console.log(`INPUT: ${JSON.stringify(input)}`)
+  const result = await findInfluencersHandler(input)
+  const parsed = JSON.parse(result.content[0].text)
+  if (result.isError) {
+    console.log(`RESULT: ERROR — ${parsed.error}`)
+    if (parsed.providers_tried?.length) {
+      console.log(`PROVIDERS TRIED: ${parsed.providers_tried.map((p: { id: string }) => p.id).join(' → ')}`)
+    }
+    return
+  }
+  const meta = parsed._meta
+  const data = parsed.data as Record<string, unknown>
+  const creators = (data.accounts as unknown[] | undefined) ?? (data.creators as unknown[] | undefined) ?? []
+  console.log(`RESULT: provider=${meta.provider} latency=${meta.latencyMs}ms creators=${creators.length}`)
+}
+
+async function main() {
+  // Test 1: Instagram + ai_search → discovery
+  await run('Instagram + ai_search (discovery expected)', {
+    platform: 'instagram',
+    ai_search: 'fitness influencers who post about nutrition',
+    limit: 5,
+  })
+
+  // Test 2: YouTube + location filter → discovery
+  await run('YouTube + location filter (discovery expected)', {
+    platform: 'youtube',
+    location: ['United States'],
+    limit: 5,
+  })
+
+  // Test 3: TikTok + handle → influencers_similar runs first
+  await run('TikTok + handle (influencers_similar expected first)', {
+    platform: 'tiktok',
+    handle: 'charlidamelio',
+    limit: 5,
+  })
+
+  // Test 4: Twitter + sort_by=engagement_rate → discovery
+  await run('Twitter + sort_by=engagement_rate (discovery expected)', {
+    platform: 'twitter',
+    sort_by: 'engagement_rate',
+    sort_order: 'desc',
+    limit: 5,
+  })
+
+  // Test 5: handle + platform=instagram → influencers_similar tried first
+  await run('Instagram + handle (influencers_similar tried first)', {
+    platform: 'instagram',
+    handle: 'cristiano',
+    limit: 5,
+  })
+}
+
+main().catch(console.error)

package/test-jobs-live.ts

@@ -0,0 +1,69 @@
+import { initClient } from './src/client.js'
+import { searchJobsHandler } from './src/tools/search-jobs.js'
+
+const API_URL = 'https://api.coldiq.com'
+const API_KEY = 'ciq_test_3797d4ddc5542ceb'
+
+initClient(API_URL, API_KEY)
+
+async function run(label: string, input: Record<string, unknown>) {
+  console.log(`\n${'─'.repeat(60)}`)
+  console.log(`TEST: ${label}`)
+  console.log(`INPUT: ${JSON.stringify(input)}`)
+  const result = await searchJobsHandler(input)
+  const parsed = JSON.parse(result.content[0].text)
+  if (result.isError) {
+    console.log(`RESULT: ERROR — ${parsed.error}`)
+    if (parsed.providers_tried?.length) {
+      console.log(`PROVIDERS TRIED: ${parsed.providers_tried.map((p: { id: string }) => p.id).join(' → ')}`)
+    }
+    return
+  }
+  const meta = parsed._meta
+  const jobs = (parsed.data as { jobs: Array<Record<string, unknown>> }).jobs ?? []
+  console.log(`RESULT: provider=${meta.provider} latency=${meta.latencyMs}ms jobs=${jobs.length}`)
+  for (const j of jobs.slice(0, 3)) {
+    console.log(`  • ${j.title ?? '-'} @ ${j.organization ?? j.company ?? '-'} — ${j.location ?? j.locations_derived ?? '-'}`)
+  }
+}
+
+async function main() {
+  // Test 1: Generic title search — no provider-specific filter, Career Site expected first
+  await run('Sales engineer in US (Career Site expected)', {
+    title_keywords: ['sales engineer'],
+    locations: ['United States'],
+    limit: 10,
+    time_range: '7d',
+  })
+
+  // Test 2: ATS-pinned — only Career Site can serve ats_slugs, LinkedIn skipped
+  await run('Greenhouse customers hiring SDRs (Career Site only)', {
+    title_keywords: ['sdr', 'sales development representative'],
+    ats_slugs: ['greenhouse'],
+    limit: 10,
+  })
+
+  // Test 3: Seniority + industry — LinkedIn-only filters, Career Site skipped
+  await run('Director-level roles in Software (LinkedIn only)', {
+    title_keywords: ['director of sales'],
+    industries: ['Software Development'],
+    seniority_levels: ['Director'],
+    limit: 10,
+  })
+
+  // Test 4: Employee-size gate — LinkedIn-only filter, Career Site skipped
+  await run('Mid-market AE roles 100-1000 employees (LinkedIn only)', {
+    title_keywords: ['account executive'],
+    min_employees: 100,
+    max_employees: 1000,
+    limit: 10,
+  })
+
+  // Test 5: Bogus title — should exhaust both providers
+  await run('Unmatchable title (expect waterfall failure)', {
+    title_keywords: ['zzznotarealjobzzz12345'],
+    limit: 10,
+  })
+}
+
+main().catch(console.error)

package/test-linkupapi-live.ts

@@ -0,0 +1,137 @@
+/**
+ * Live integration tests for the new and updated Linkup API MCP providers.
+ *
+ * Tests are kept minimal to limit credit spend:
+ * - enrich_person (name path): michel@coldiq.com context
+ * - enrich_person (email path): reverse lookup
+ * - verify_email: full waterfall — Linkup fires at p4 if prior 3 fail
+ * - enrich_company: domain + URL paths — Linkup at p13/14
+ * - find_people: keyword-only (no company filters) — Linkup at p5
+ * - search_companies (is_hiring): Linkup at p16 as last resort
+ */
+
+import { initClient } from './src/client.js'
+import { enrichPersonHandler } from './src/tools/enrich-person.js'
+import { verifyEmailHandler } from './src/tools/verify-email.js'
+import { enrichCompanyHandler } from './src/tools/enrich-company.js'
+import { findPeopleHandler } from './src/tools/find-people.js'
+import { searchCompaniesHandler } from './src/tools/search-companies.js'
+
+const API_URL = 'https://api.coldiq.com'
+const API_KEY = 'ciq_test_3797d4ddc5542ceb'
+
+initClient(API_URL, API_KEY)
+
+type Result = { content: Array<{ type: string; text: string }>; isError?: boolean }
+
+function parse(r: Result) {
+  try {
+    return JSON.parse(r.content[0].text)
+  } catch {
+    return r.content[0].text
+  }
+}
+
+function print(label: string, r: Result) {
+  const d = parse(r)
+  const ok = !r.isError
+  const provider = d?._meta?.provider ?? d?._meta?.tried ?? '—'
+  const summary = ok
+    ? `✅ provider=${provider}`
+    : `❌ error: ${JSON.stringify(d).slice(0, 120)}`
+  console.log(`\n${label}`)
+  console.log(`  ${summary}`)
+  if (ok && d?.data) {
+    const preview = JSON.stringify(d.data).slice(0, 200)
+    console.log(`  data: ${preview}`)
+  }
+}
+
+async function run() {
+  console.log('=== Linkup MCP Integration Tests ===\n')
+
+  // ─── 1. enrich_person — name + company path ───────────────────────────────
+  // New capability; Linkup is the only p1 provider — should always hit Linkup.
+  {
+    const r = await enrichPersonHandler({
+      first_name: 'Michel',
+      last_name: 'Lieben',
+      company_name: 'ColdIQ',
+    }) as Result
+    print('1. enrich_person (name+company) → linkupapi-profile-enrich', r)
+  }
+
+  // ─── 2. enrich_person — email reverse path ────────────────────────────────
+  // isApplicable on linkupapi-email-reverse fires when email is present.
+  // linkupapi-profile-enrich is skipped (no first_name).
+  {
+    const r = await enrichPersonHandler({
+      email: 'michel@coldiq.com',
+    }) as Result
+    print('2. enrich_person (email) → linkupapi-email-reverse', r)
+  }
+
+  // ─── 3. verify_email — full waterfall ─────────────────────────────────────
+  // Findymail/IcyPeas/Instantly at p1-p3, Linkup at p4.
+  // Report whichever provider wins.
+  {
+    const r = await verifyEmailHandler({ email: 'michel@coldiq.com' }) as Result
+    print('3. verify_email (waterfall — Linkup p4 fallback)', r)
+  }
+
+  // ─── 4. enrich_company — domain path ──────────────────────────────────────
+  // 12 providers before Linkup; report the winner.
+  {
+    const r = await enrichCompanyHandler({ domain: 'coldiq.com' }) as Result
+    print('4. enrich_company (domain) — Linkup at p13 fallback', r)
+  }
+
+  // ─── 5. enrich_company — LinkedIn URL path ────────────────────────────────
+  {
+    const r = await enrichCompanyHandler({
+      linkedin_url: 'https://www.linkedin.com/company/coldiq/',
+    }) as Result
+    print('5. enrich_company (linkedin_url) — Linkup at p14 fallback', r)
+  }
+
+  // ─── 6. find_people — keyword-only, no company filters ───────────────────
+  // LeadsFactory/Apollo/PDL/CompanyEnrich fire first (p1-p4).
+  // Linkup search-profiles fires at p5 if none return results.
+  // Without company identifiers, early providers often return nothing.
+  {
+    const r = await findPeopleHandler({
+      job_titles: ['CEO'],
+      keywords: 'ColdIQ',
+      limit: 5,
+    }) as Result
+    print('6. find_people (keyword-only) — Linkup search-profiles p5 fallback', r)
+  }
+
+  // ─── 7. search_companies — funding filter + keyword ───────────────────────
+  // TheirStack (p4) fires first for funding_stages. Linkup-fundraising at p15.
+  {
+    const r = await searchCompaniesHandler({
+      funding_stages: ['series_b'],
+      keywords: ['SaaS'],
+      industries: ['Software'],
+      limit: 5,
+    }) as Result
+    print('7. search_companies (funding) — Linkup-fundraising p15 fallback', r)
+  }
+
+  // ─── 8. search_companies — is_hiring ──────────────────────────────────────
+  // LimaData handles is_hiring at p9. Linkup-hiring at p16.
+  {
+    const r = await searchCompaniesHandler({
+      is_hiring: true,
+      industries: ['Software'],
+      locations: ['United States'],
+      limit: 5,
+    }) as Result
+    print('8. search_companies (is_hiring) — Linkup-hiring p16 last resort', r)
+  }
+
+  console.log('\n=== Done ===')
+}
+
+run().catch(console.error)

package/test-phone-live.ts

@@ -0,0 +1,41 @@
+import { initClient } from './src/client.js'
+import { findPhoneHandler } from './src/tools/find-phone.js'
+
+const API_URL = 'https://api.coldiq.com'
+const API_KEY = 'ciq_test_3797d4ddc5542ceb'
+
+initClient(API_URL, API_KEY)
+
+async function run(label: string, input: Record<string, unknown>) {
+  console.log(`\n${'─'.repeat(60)}`)
+  console.log(`TEST: ${label}`)
+  console.log(`INPUT: ${JSON.stringify(input)}`)
+  const result = await findPhoneHandler(input)
+  const parsed = JSON.parse(result.content[0].text)
+  if (result.isError) {
+    console.log(`RESULT: ERROR — ${parsed.error}`)
+    console.log(`PROVIDERS TRIED: ${parsed.providers_tried?.join(' → ')}`)
+  } else {
+    const meta = parsed._meta
+    const data = parsed.data
+    const phone = data?.phone ?? data?.phones?.[0] ?? data?.data?.[0]?.[0] ?? '(none)'
+    console.log(`RESULT: provider=${meta.provider} latency=${meta.latencyMs}ms`)
+    console.log(`PHONE: ${phone}`)
+  }
+}
+
+async function main() {
+  // Scenario 1: LinkedIn URL only — Findymail first, falls through if no record
+  await run('LinkedIn URL only (Michel Lieben)', {
+    linkedin_url: 'https://www.linkedin.com/in/michel-lieben',
+  })
+
+  // Scenario 2: Name + domain only — Findymail skipped, LimaData/AI Ark run
+  await run('Name + domain only (no LinkedIn URL)', {
+    first_name: 'Michel',
+    last_name: 'Lieben',
+    company_domain: 'coldiq.com',
+  })
+}
+
+main().catch(console.error)

package/test-places-live.ts

@@ -0,0 +1,89 @@
+import { initClient } from './src/client.js'
+import { searchPlacesHandler } from './src/tools/search-places.js'
+
+const API_URL = 'https://api.coldiq.com'
+const API_KEY = 'ciq_test_3797d4ddc5542ceb'
+
+initClient(API_URL, API_KEY)
+
+async function run(label: string, input: Record<string, unknown>) {
+  console.log(`\n${'─'.repeat(60)}`)
+  console.log(`TEST: ${label}`)
+  console.log(`INPUT: ${JSON.stringify(input)}`)
+  const result = await searchPlacesHandler(input)
+  const parsed = JSON.parse(result.content[0].text)
+  if (result.isError) {
+    console.log(`RESULT: ERROR — ${parsed.error}`)
+    if (parsed.providers_tried?.length) {
+      console.log(`PROVIDERS TRIED: ${parsed.providers_tried.map((p: { id: string }) => p.id).join(' → ')}`)
+    }
+    return
+  }
+  const meta = parsed._meta
+  const places = (parsed.data as { places?: Array<Record<string, unknown>> }).places
+    ?? (Array.isArray(parsed.data) ? parsed.data : [])
+  console.log(`RESULT: provider=${meta.provider} latency=${meta.latencyMs}ms places=${places.length}`)
+  for (const p of places.slice(0, 3)) {
+    console.log(`  • ${p.title ?? p.name ?? p.business_name ?? '-'} — ${p.address ?? p.city ?? '-'}`)
+  }
+}
+
+async function main() {
+  // Test 1: Country=US + query → Openmart wins (sync, fast)
+  await run('US query (Openmart expected)', {
+    query: 'coffee shop',
+    country: 'US',
+    city: 'New York',
+    limit: 5,
+  })
+
+  // Test 2: Country=FR (outside Openmart whitelist) → Google Maps
+  await run('FR query (Google Maps expected)', {
+    query: 'boulangerie',
+    country: 'FR',
+    city: 'Paris',
+    limit: 5,
+  })
+
+  // Test 3: start_urls present → Google Maps only
+  await run('Maps URL (Google Maps expected)', {
+    start_urls: ['https://www.google.com/maps/search/dentists+in+Austin'],
+    limit: 5,
+  })
+
+  // Test 4: Pin provider=openmart with structured filter + query
+  await run('Openmart pinned (filters)', {
+    provider: 'openmart',
+    query: 'restaurant',
+    country: 'US',
+    state: 'CA',
+    ownership_type: 'INDEPENDENT',
+    min_overall_rating: 4,
+    limit: 5,
+  })
+
+  // Test 5: Pin provider=google_maps with opening hours
+  await run('Google Maps pinned (opening hours)', {
+    provider: 'google_maps',
+    query: 'pizza',
+    city: 'Chicago',
+    include_opening_hours: true,
+    limit: 5,
+  })
+
+  // Test 6: Bare query → Openmart attempts first (no country gate)
+  await run('Bare query waterfall', {
+    query: 'plumber',
+    limit: 5,
+  })
+
+  // Test 7: Non-US Openmart-supported country (AU) — Openmart handles it
+  await run('AU query (Openmart expected)', {
+    query: 'cafe',
+    country: 'AU',
+    city: 'Sydney',
+    limit: 5,
+  })
+}
+
+main().catch(console.error)

package/test-reddit-live.ts

@@ -0,0 +1,66 @@
+import { initClient } from './src/client.js'
+import { searchRedditHandler } from './src/tools/search-reddit.js'
+
+const API_URL = 'https://api.coldiq.com'
+const API_KEY = 'ciq_test_3797d4ddc5542ceb'
+
+initClient(API_URL, API_KEY)
+
+async function run(label: string, input: Record<string, unknown>) {
+  console.log(`\n${'─'.repeat(60)}`)
+  console.log(`TEST: ${label}`)
+  console.log(`INPUT: ${JSON.stringify(input)}`)
+  const result = await searchRedditHandler(input)
+  const parsed = JSON.parse(result.content[0].text)
+  if (result.isError) {
+    console.log(`RESULT: ERROR — ${parsed.error}`)
+    if (parsed.providers_tried?.length) {
+      console.log(`PROVIDERS TRIED: ${parsed.providers_tried.map((p: { id: string }) => p.id).join(' → ')}`)
+    }
+    return
+  }
+  const meta = parsed._meta
+  const items = ((parsed.data as Record<string, unknown>).items as unknown[] | undefined) ?? []
+  console.log(`RESULT: provider=${meta.provider} latency=${meta.latencyMs}ms items=${items.length}`)
+  for (const item of (items as Array<Record<string, unknown>>).slice(0, 3)) {
+    console.log(`  • ${item.title ?? item.body ?? '-'}`)
+  }
+}
+
+async function main() {
+  // Test 1: query='B2B sales tools' → posts
+  await run('Query: B2B sales tools (posts)', {
+    query: 'B2B sales tools',
+    limit: 5,
+  })
+
+  // Test 2: query + sort=top + time=month
+  await run('Query + sort=top + time=month', {
+    query: 'CRM software review',
+    sort: 'top',
+    time: 'month',
+    limit: 5,
+  })
+
+  // Test 3: start_urls with a subreddit URL
+  await run('start_urls: r/sales subreddit', {
+    start_urls: ['https://www.reddit.com/r/sales/'],
+    limit: 5,
+  })
+
+  // Test 4: type=comments on a topic
+  await run('type=comments on sales topic', {
+    query: 'outbound sales',
+    type: 'comments',
+    limit: 5,
+  })
+
+  // Test 5: query + include_comments=true
+  await run('query + include_comments=true', {
+    query: 'B2B SaaS startup',
+    include_comments: true,
+    limit: 5,
+  })
+}
+
+main().catch(console.error)

package/test-search-live.ts

@@ -0,0 +1,79 @@
+import { initClient } from './src/client.js'
+import { searchCompaniesHandler } from './src/tools/search-companies.js'
+
+const API_URL = 'https://api.coldiq.com'
+const API_KEY = 'ciq_test_3797d4ddc5542ceb'
+
+initClient(API_URL, API_KEY)
+
+async function run(label: string, input: Record<string, unknown>) {
+  console.log(`\n${'─'.repeat(60)}`)
+  console.log(`TEST: ${label}`)
+  console.log(`INPUT: ${JSON.stringify(input)}`)
+  const result = await searchCompaniesHandler(input)
+  const parsed = JSON.parse(result.content[0].text)
+  if (result.isError) {
+    console.log(`RESULT: ERROR — ${parsed.error}`)
+    console.log(`PROVIDERS TRIED: ${parsed.providers_tried?.join(' → ')}`)
+  } else {
+    const meta = parsed._meta
+    const data = parsed.data
+    console.log(`RESULT: provider=${meta.provider} latency=${meta.latencyMs}ms`)
+    // Find the orgs/companies array in the response
+    const orgs: Record<string, unknown>[] =
+      data?.organizations ?? data?.data ?? data?.companies ?? data?.results ?? []
+    console.log(`COMPANIES (${orgs.length}):`)
+    for (const o of orgs.slice(0, 3)) {
+      const name = o.name ?? o.company_name ?? '-'
+      const country = o.country ?? o.hq_country ?? o.location?.country ?? '-'
+      const emp = o.estimated_num_employees ?? o.employee_count ?? o.headcount ?? '-'
+      const year = o.founded_year ?? o.founded ?? '-'
+      console.log(`  • ${name} | country=${country} | emp=${emp} | founded=${year}`)
+    }
+  }
+}
+
+async function main() {
+  // Test 1: Strict firmographic search — should hit CompanyEnrich/FullEnrich/PDL, NOT Apollo
+  await run('Strict firmographic (min_founded_year set → Apollo must be skipped)', {
+    keywords: ['B2B SaaS'],
+    countries: ['FR'],
+    min_employees: 50,
+    max_employees: 200,
+    min_founded_year: 2015,
+    limit: 5,
+  })
+
+  // Test 2: Same without founded_year — Apollo eligible as fallback
+  await run('Loose search (no founded_year → Apollo eligible)', {
+    keywords: ['B2B SaaS'],
+    countries: ['FR'],
+    min_employees: 50,
+    max_employees: 200,
+    limit: 3,
+  })
+
+  // Test 3: Technology filter — TheirStack should fire, Apollo must be skipped
+  await run('Tech filter (technologies → TheirStack fires, Apollo skipped)', {
+    technologies: ['Salesforce'],
+    countries: ['US'],
+    limit: 3,
+  })
+
+  // Test 4: Funding stage — Wiza + TheirStack eligible, Apollo skipped
+  await run('Funding filter (funding_stages → Apollo skipped)', {
+    industries: ['SaaS'],
+    funding_stages: ['series_a'],
+    limit: 3,
+  })
+
+  // Test 5: is_hiring flag — LimaData picks this up
+  await run('Hiring signal (is_hiring: true)', {
+    keywords: ['fintech'],
+    countries: ['US'],
+    is_hiring: true,
+    limit: 3,
+  })
+}
+
+main().catch(console.error)

package/test-seo-live.ts

@@ -0,0 +1,68 @@
+import { initClient } from './src/client.js'
+import { searchSeoHandler } from './src/tools/search-seo.js'
+
+const API_URL = 'https://api.coldiq.com'
+const API_KEY = 'ciq_test_3797d4ddc5542ceb'
+
+initClient(API_URL, API_KEY)
+
+async function run(label: string, input: Record<string, unknown>) {
+  console.log(`\n${'─'.repeat(60)}`)
+  console.log(`TEST: ${label}`)
+  console.log(`INPUT: ${JSON.stringify(input)}`)
+  const result = await searchSeoHandler(input)
+  const parsed = JSON.parse(result.content[0].text)
+  if (result.isError) {
+    console.log(`RESULT: ERROR — ${parsed.error}`)
+    if (parsed.providers_tried?.length) {
+      console.log(`PROVIDERS TRIED: ${parsed.providers_tried.map((p: { id: string }) => p.id).join(' → ')}`)
+    }
+    return
+  }
+  const meta = parsed._meta
+  console.log(`RESULT: provider=${meta.provider} latency=${meta.latencyMs}ms`)
+}
+
+async function main() {
+  // Test 1: category=keywords
+  await run('keywords: CRM software search volume', {
+    category: 'keywords',
+    keywords: ['CRM software'],
+    location: 'United States',
+  })
+
+  // Test 2: category=serp
+  await run('serp: best B2B CRM Google', {
+    category: 'serp',
+    keyword: 'best B2B CRM',
+    engine: 'google',
+    limit: 5,
+  })
+
+  // Test 3: category=backlinks
+  await run('backlinks: salesforce.com summary', {
+    category: 'backlinks',
+    target: 'salesforce.com',
+  })
+
+  // Test 4: category=domain (technologies)
+  await run('domain: hubspot.com technologies', {
+    category: 'domain',
+    target: 'hubspot.com',
+  })
+
+  // Test 5: category=labs (rank-overview default)
+  await run('labs: pipedrive.com rank-overview', {
+    category: 'labs',
+    target: 'pipedrive.com',
+  })
+
+  // Test 6: category=page lighthouse
+  await run('page: coldiq.com lighthouse', {
+    category: 'page',
+    url: 'https://coldiq.com',
+    page_action: 'lighthouse',
+  })
+}
+
+main().catch(console.error)

package/test-web-live.ts

@@ -0,0 +1,67 @@
+import { initClient } from './src/client.js'
+import { searchWebHandler } from './src/tools/search-web.js'
+
+const API_URL = 'https://api.coldiq.com'
+const API_KEY = 'ciq_test_3797d4ddc5542ceb'
+
+initClient(API_URL, API_KEY)
+
+async function run(label: string, input: Record<string, unknown>) {
+  console.log(`\n${'─'.repeat(60)}`)
+  console.log(`TEST: ${label}`)
+  console.log(`INPUT: ${JSON.stringify(input)}`)
+  const result = await searchWebHandler(input)
+  const parsed = JSON.parse(result.content[0].text)
+  if (result.isError) {
+    console.log(`RESULT: ERROR — ${parsed.error}`)
+    if (parsed.providers_tried?.length) {
+      console.log(`PROVIDERS TRIED: ${parsed.providers_tried.map((p: { id: string }) => p.id).join(' → ')}`)
+    }
+  } else {
+    const meta = parsed._meta
+    const data = parsed.data as Record<string, unknown>
+    console.log(`RESULT: provider=${meta.provider} latency=${meta.latencyMs}ms`)
+    const items =
+      (data.organic as Record<string, unknown>[] | undefined) ??
+      (data.results as Record<string, unknown>[] | undefined) ??
+      (data.data as Record<string, unknown>[] | undefined) ??
+      []
+    console.log(`HITS (${items.length}):`)
+    for (const r of items.slice(0, 3)) {
+      const title = r.title ?? r.name ?? '-'
+      const url = r.url ?? r.link ?? '-'
+      console.log(`  • ${title} — ${url}`)
+    }
+  }
+}
+
+async function main() {
+  // Test 1: Plain web search — should hit Serper first
+  await run('General query (Serper expected)', {
+    query: 'ColdIQ AI sales tools',
+    num_results: 5,
+    country: 'us',
+  })
+
+  // Test 2: Neural search — Exa hoisted to #1
+  await run('Neural query (Exa expected)', {
+    query: 'companies using AI to automate outbound sales',
+    num_results: 5,
+    search_type: 'neural',
+  })
+
+  // Test 3: Country-targeted query
+  await run('FR-targeted query (Serper expected)', {
+    query: 'startups B2B SaaS Paris',
+    num_results: 5,
+    country: 'fr',
+  })
+
+  // Test 4: News-style query — exercises top providers
+  await run('News query', {
+    query: 'Stripe latest fundraising 2025',
+    num_results: 5,
+  })
+}
+
+main().catch(console.error)