@coldiq/mcp 0.3.11 → 0.3.13

package/tests/tools/search-companies.test.ts

@@ -1,192 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { searchCompaniesHandler, searchCompaniesSchema } from '../../src/tools/search-companies.js'
-
-describe('search_companies handler', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('returns results from first successful provider (compact by default)', async () => {
-    globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({ data: [{ name: 'ColdIQ', domain: 'coldiq.com' }] }), { status: 200 })
-    ) as typeof fetch
-
-    const result = await searchCompaniesHandler({ countries: ['FR'], limit: 5 })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('companyenrich')
-    // Compact-by-default: the raw provider array is normalized into companies[].
-    expect(parsed.data.companies).toHaveLength(1)
-    expect(parsed.data.companies[0]).toMatchObject({ name: 'ColdIQ', domain: 'coldiq.com' })
-  })
-
-  it('compact (default) keeps identity + firmographic fields and drops heavy ones', async () => {
-    // Mirror the real CompanyEnrich shape: companies under data.items[], each a
-    // heavy object with funding/technologies/keywords/socials/seo.
-    globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({
-        items: [{
-          id: '0192562e-7008-702b-97a2-0b2c489d339b',
-          name: 'Hugging Face',
-          domain: 'huggingface.co',
-          website: 'https://huggingface.co',
-          industry: 'Business Services',
-          categories: ['b2b', 'b2c', 'saas'],
-          employees: '201-500',
-          revenue: '10m-50m',
-          founded_year: 2016,
-          description: 'A very long company description that should be dropped in compact mode...',
-          keywords: Array.from({ length: 28 }, (_, i) => `kw${i}`),
-          technologies: ['Stripe', 'Nginx', 'Node-Js'],
-          naics_codes: ['511210', '518210'],
-          socials: { linkedin_url: 'https://www.linkedin.com/company/huggingface', twitter_url: 'https://twitter.com/huggingface' },
-          financial: { total_funding: 395200000, funding: [{ date: '2024-08-01', type: 'Venture Round' }] },
-          location: { country: { code: 'FR', name: 'France' }, city: { name: 'Paris' } },
-        }],
-        page: 1,
-        totalItems: 10000,
-      }), { status: 200 })
-    ) as typeof fetch
-
-    const result = await searchCompaniesHandler({ keywords: ['SaaS'], countries: ['FR'], limit: 5 })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.data.total).toBe(10000)
-    expect(parsed.data.companies).toHaveLength(1)
-    const c = parsed.data.companies[0]
-    // Kept: identity + firmographics + downstream-critical linkedin_url.
-    expect(c).toEqual({
-      name: 'Hugging Face',
-      domain: 'huggingface.co',
-      website: 'https://huggingface.co',
-      linkedin_url: 'https://www.linkedin.com/company/huggingface',
-      employees: '201-500',
-      revenue: '10m-50m',
-      industry: 'Business Services',
-      country: 'France',
-      city: 'Paris',
-      founded_year: 2016,
-      categories: ['b2b', 'b2c', 'saas'],
-    })
-    // Dropped heavy fields.
-    expect(c.description).toBeUndefined()
-    expect(c.keywords).toBeUndefined()
-    expect(c.technologies).toBeUndefined()
-    expect(c.naics_codes).toBeUndefined()
-    expect(c.financial).toBeUndefined()
-    expect(c.id).toBeUndefined()
-  })
-
-  it('fields=verbose returns the raw provider passthrough unchanged', async () => {
-    globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({ items: [{ name: 'Hugging Face', keywords: ['ai'], technologies: ['Stripe'] }], totalItems: 10000 }), { status: 200 })
-    ) as typeof fetch
-
-    const result = await searchCompaniesHandler({ keywords: ['SaaS'], limit: 5, fields: 'verbose' })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = JSON.parse(result.content[0].text)
-    // Raw shape preserved: items[] with heavy fields, no companies[] normalization.
-    expect(parsed.data.items).toHaveLength(1)
-    expect(parsed.data.items[0].keywords).toEqual(['ai'])
-    expect(parsed.data.items[0].technologies).toEqual(['Stripe'])
-    expect(parsed.data.companies).toBeUndefined()
-  })
-
-  it('falls back to FullEnrich (priority 2) on CompanyEnrich failure', async () => {
-    let callCount = 0
-    globalThis.fetch = vi.fn(async () => {
-      callCount++
-      if (callCount === 1) {
-        return new Response(JSON.stringify({ error: 'Provider error' }), { status: 502 })
-      }
-      return new Response(JSON.stringify({ companies: [{ name: 'ColdIQ' }] }), { status: 200 })
-    }) as typeof fetch
-
-    const result = await searchCompaniesHandler({ countries: ['FR'], limit: 5 })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('fullenrich')
-  })
-
-  it('returns error when all providers fail', async () => {
-    globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({ error: 'Service down' }), { status: 500 })
-    ) as typeof fetch
-
-    const result = await searchCompaniesHandler({ countries: ['FR'], limit: 5 })
-
-    expect(result.isError).toBe(true)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.error).toContain('All')
-    expect(parsed.providers_tried.length).toBeGreaterThan(0)
-  })
-
-  it('surfaces the upstream match count as _meta.total_entries (TAM signal)', async () => {
-    globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({ organizations: [{ name: 'ColdIQ' }], pagination: { total_entries: 8371 } }), { status: 200 })
-    ) as typeof fetch
-
-    const result = await searchCompaniesHandler({ keywords: ['SaaS'], limit: 250, use_providers: ['apollo'] })
-
-    expect(result.isError).toBeUndefined()
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('apollo')
-    expect(parsed._meta.total_entries).toBe(8371)
-  })
-
-  it('limit accepts up to 500 and rejects above', () => {
-    expect(searchCompaniesSchema.limit.safeParse(500).success).toBe(true)
-    expect(searchCompaniesSchema.limit.safeParse(600).success).toBe(false)
-  })
-
-  describe('use_providers', () => {
-    it('Scenario A — pinned provider succeeds, skips others', async () => {
-      let callCount = 0
-      globalThis.fetch = vi.fn(async () => {
-        callCount++
-        return new Response(JSON.stringify({ data: [{ name: 'ColdIQ' }] }), { status: 200 })
-      }) as typeof fetch
-
-      const result = await searchCompaniesHandler({ countries: ['FR'], limit: 5, use_providers: ['companyenrich'] })
-
-      expect(result.isError).toBeUndefined()
-      expect(callCount).toBe(1)
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('companyenrich')
-    })
-
-    it('Scenario E — unrecognized provider returns isError with helpful message', async () => {
-      const result = await searchCompaniesHandler({ countries: ['FR'], limit: 5, use_providers: ['salesforce'] })
-
-      expect(result.isError).toBe(true)
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed.error).toContain("'salesforce' is not a recognized provider")
-      expect(parsed.error).toContain('ColdIQ will automatically pick the best tool')
-      expect(parsed.available_providers).toBeInstanceOf(Array)
-    })
-
-    it('Scenario D — fuzzy match resolves typo and surfaces matchedFrom', async () => {
-      globalThis.fetch = vi.fn(async () =>
-        new Response(JSON.stringify({ data: [{ name: 'ColdIQ' }] }), { status: 200 })
-      ) as typeof fetch
-
-      const result = await searchCompaniesHandler({ countries: ['FR'], limit: 5, use_providers: ['fullenrch'] })
-
-      expect(result.isError).toBeUndefined()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('fullenrich')
-      expect(parsed._meta.matchedFrom).toEqual({ fullenrch: 'fullenrich' })
-    })
-  })
-})

package/tests/tools/search-jobs.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { searchJobsHandler } from '../../src/tools/search-jobs.js'
-
-describe('search_jobs handler', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('contradictory filters — rejected at handler level before any provider is called', async () => {
-    let fetchCalled = false
-    globalThis.fetch = vi.fn(async () => {
-      fetchCalled = true
-      return new Response(JSON.stringify({}), { status: 200 })
-    }) as typeof fetch
-
-    const result = await searchJobsHandler({
-      ats_slugs: ['greenhouse'],
-      seniority_levels: ['Director'],
-    })
-
-    expect(result.isError).toBe(true)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.error).toMatch(/contradictory/i)
-    expect(fetchCalled).toBe(false)
-  })
-
-  it('ats_slugs filter — routes to career_site_jobs only (LinkedIn skipped)', async () => {
-    let linkedinCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/linkedin-jobs-api/search')) {
-        linkedinCalled = true
-        throw new Error('linkedin_jobs_api should not fire when ats_slugs is set')
-      }
-      if (u.includes('/career-site-jobs/search') && !u.includes('/search/')) {
-        // Async create — returns a jobId
-        return new Response(JSON.stringify({ jobId: 'job-1' }), { status: 200 })
-      }
-      if (u.includes('/career-site-jobs/search/job-1')) {
-        // Poll — done with results
-        return new Response(JSON.stringify({ jobId: 'job-1', status: 'done', jobs: [{ title: 'Software Engineer', company: 'Stripe' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_jobs')
-    const cs = providers.find((p) => p.id === 'career_site_jobs')!
-    const orig = { t: cs.async!.timeoutMs, i: cs.async!.pollIntervalMs }
-    cs.async!.timeoutMs = 500
-    cs.async!.pollIntervalMs = 20
-
-    try {
-      const result = await searchJobsHandler({
-        ats_slugs: ['greenhouse'],
-        title_keywords: ['Engineer'],
-        limit: 10,
-      })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('career_site_jobs')
-      expect(linkedinCalled).toBe(false)
-    } finally {
-      cs.async!.timeoutMs = orig.t
-      cs.async!.pollIntervalMs = orig.i
-    }
-  })
-
-  it('seniority_levels filter — routes to linkedin_jobs_api only (career_site_jobs skipped)', async () => {
-    let careerSiteCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/career-site-jobs/search') && !u.includes('/search/')) {
-        careerSiteCalled = true
-        throw new Error('career_site_jobs should not fire when seniority_levels is set')
-      }
-      if (u.includes('/linkedin-jobs-api/search') && !u.includes('/search/')) {
-        return new Response(JSON.stringify({ jobId: 'job-2' }), { status: 200 })
-      }
-      if (u.includes('/linkedin-jobs-api/search/job-2')) {
-        return new Response(JSON.stringify({ jobId: 'job-2', status: 'done', jobs: [{ title: 'VP of Sales', company: 'HubSpot' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_jobs')
-    const li = providers.find((p) => p.id === 'linkedin_jobs_api')!
-    const orig = { t: li.async!.timeoutMs, i: li.async!.pollIntervalMs }
-    li.async!.timeoutMs = 500
-    li.async!.pollIntervalMs = 20
-
-    try {
-      const result = await searchJobsHandler({
-        seniority_levels: ['Director'],
-        title_keywords: ['VP'],
-        limit: 10,
-      })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('linkedin_jobs_api')
-      expect(careerSiteCalled).toBe(false)
-    } finally {
-      li.async!.timeoutMs = orig.t
-      li.async!.pollIntervalMs = orig.i
-    }
-  })
-
-  it('async timeout — career_site_jobs times out, falls back to theirstack-jobs', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/career-site-jobs/search') && !u.includes('/search/')) {
-        return new Response(JSON.stringify({ jobId: 'job-3' }), { status: 200 })
-      }
-      if (u.includes('/career-site-jobs/search/job-3')) {
-        // Always running — will cause timeout
-        return new Response(JSON.stringify({ jobId: 'job-3', status: 'running' }), { status: 200 })
-      }
-      if (u.includes('/linkedin-jobs-api/search') && !u.includes('/search/')) {
-        return new Response(JSON.stringify({ jobId: 'job-4' }), { status: 200 })
-      }
-      if (u.includes('/linkedin-jobs-api/search/job-4')) {
-        return new Response(JSON.stringify({ jobId: 'job-4', status: 'running' }), { status: 200 })
-      }
-      if (u.includes('/theirstack/jobs/search')) {
-        return new Response(JSON.stringify({ data: [{ title: 'SDR', company_name: 'ColdIQ' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_jobs')
-    const cs = providers.find((p) => p.id === 'career_site_jobs')!
-    const li = providers.find((p) => p.id === 'linkedin_jobs_api')!
-    const origCs = { t: cs.async!.timeoutMs, i: cs.async!.pollIntervalMs }
-    const origLi = { t: li.async!.timeoutMs, i: li.async!.pollIntervalMs }
-    cs.async!.timeoutMs = 100
-    cs.async!.pollIntervalMs = 20
-    li.async!.timeoutMs = 100
-    li.async!.pollIntervalMs = 20
-
-    try {
-      const result = await searchJobsHandler({
-        title_keywords: ['SDR'],
-        limit: 10,
-      })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('theirstack-jobs')
-      expect(parsed.data.data).toHaveLength(1)
-    } finally {
-      cs.async!.timeoutMs = origCs.t
-      cs.async!.pollIntervalMs = origCs.i
-      li.async!.timeoutMs = origLi.t
-      li.async!.pollIntervalMs = origLi.i
-    }
-  })
-
-  it('shared-only filters — both career_site_jobs and linkedin_jobs_api are applicable', async () => {
-    // With only title_keywords and locations (shared filters), career_site_jobs fires first
-    let careerSiteCreate = 0
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/career-site-jobs/search') && !u.includes('/search/')) {
-        careerSiteCreate++
-        return new Response(JSON.stringify({ jobId: 'job-5' }), { status: 200 })
-      }
-      if (u.includes('/career-site-jobs/search/job-5')) {
-        return new Response(JSON.stringify({ jobId: 'job-5', status: 'done', jobs: [{ title: 'SDR', company: 'ColdIQ' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_jobs')
-    const cs = providers.find((p) => p.id === 'career_site_jobs')!
-    const orig = { t: cs.async!.timeoutMs, i: cs.async!.pollIntervalMs }
-    cs.async!.timeoutMs = 500
-    cs.async!.pollIntervalMs = 20
-
-    try {
-      const result = await searchJobsHandler({
-        title_keywords: ['SDR'],
-        locations: ['Paris, France'],
-        limit: 10,
-      })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('career_site_jobs')
-      expect(careerSiteCreate).toBe(1)
-    } finally {
-      cs.async!.timeoutMs = orig.t
-      cs.async!.pollIntervalMs = orig.i
-    }
-  })
-})

package/tests/tools/search-places.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initClient } from '../../src/client.js'
-import { searchPlacesHandler, applyPlaceFilters } from '../../src/tools/search-places.js'
-
-describe('applyPlaceFilters', () => {
-  const sample = {
-    places: [
-      { title: 'Low rating, many reviews', totalScore: 2.9, reviewsCount: 81 },
-      { title: 'Mid rating, mid reviews', totalScore: 3.9, reviewsCount: 322 },
-      { title: 'High rating, many reviews', totalScore: 4.6, reviewsCount: 1101 },
-      { title: 'High rating, few reviews', totalScore: 4.7, reviewsCount: 12 },
-      { title: 'Missing fields', /* no totalScore or reviewsCount */ },
-    ],
-  }
-
-  it('passes through unchanged when no filters supplied', () => {
-    const out = applyPlaceFilters(sample, {}) as { places: unknown[] }
-    expect(out.places).toHaveLength(5)
-  })
-
-  it('does not mutate its input', () => {
-    const before = JSON.stringify(sample)
-    applyPlaceFilters(sample, { maxRating: 4 })
-    expect(JSON.stringify(sample)).toBe(before)
-  })
-
-  it('max_overall_rating drops places above the cap', () => {
-    const out = applyPlaceFilters(sample, { maxRating: 4 }) as { places: Array<{ totalScore?: number }> }
-    expect(out.places.map((p) => p.totalScore)).toEqual([2.9, 3.9])
-  })
-
-  it('min_total_reviews drops places below the floor', () => {
-    const out = applyPlaceFilters(sample, { minReviews: 20 }) as { places: Array<{ reviewsCount?: number }> }
-    expect(out.places.map((p) => p.reviewsCount)).toEqual([81, 322, 1101])
-  })
-
-  it('combined filters apply as AND', () => {
-    const out = applyPlaceFilters(sample, { maxRating: 4, minReviews: 20 }) as { places: Array<{ title?: string }> }
-    expect(out.places.map((p) => p.title)).toEqual(['Low rating, many reviews', 'Mid rating, mid reviews'])
-  })
-
-  it('places with missing totalScore/reviewsCount are dropped when corresponding filter is active', () => {
-    const out = applyPlaceFilters(sample, { minRating: 0 }) as { places: Array<{ title?: string }> }
-    expect(out.places.map((p) => p.title)).not.toContain('Missing fields')
-  })
-
-  it('non-object / non-array shapes are passed through untouched', () => {
-    expect(applyPlaceFilters(null, { maxRating: 4 })).toBe(null)
-    expect(applyPlaceFilters({ places: 'not an array' }, { maxRating: 4 })).toEqual({ places: 'not an array' })
-  })
-})
-
-describe('search_places handler', () => {
-  const originalFetch = globalThis.fetch
-
-  beforeEach(() => {
-    initClient('http://test-api.local', 'test-key')
-  })
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch
-  })
-
-  it('US query — openmart wins (sync, highest priority for supported countries)', async () => {
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/openmart/search')) {
-        return new Response(JSON.stringify({ data: [{ name: 'Blue Bottle Coffee', city: 'San Francisco' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const result = await searchPlacesHandler({ query: 'coffee shop', country: 'US', limit: 5 })
-
-    expect(result.isError).toBeFalsy()
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed._meta.provider).toBe('openmart')
-    expect(parsed.data.data).toHaveLength(1)
-  })
-
-  it('non-openmart country — routes to google_maps (openmart skipped)', async () => {
-    let openmartCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/openmart/search')) { openmartCalled = true }
-      if (u.includes('/google-maps/scraper') && !u.includes('/scraper/')) {
-        return new Response(JSON.stringify({ jobId: 'gm-1' }), { status: 200 })
-      }
-      if (u.includes('/google-maps/scraper/gm-1')) {
-        return new Response(JSON.stringify({ jobId: 'gm-1', status: 'done', places: [{ title: 'Café de Flore', address: 'Paris' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_places')
-    const gm = providers.find((p) => p.id === 'google_maps')!
-    const orig = { t: gm.async!.timeoutMs, i: gm.async!.pollIntervalMs }
-
-    try {
-      gm.async!.timeoutMs = 500
-      gm.async!.pollIntervalMs = 20
-      const result = await searchPlacesHandler({ query: 'café', country: 'FR', limit: 5 })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('google_maps')
-      expect(openmartCalled).toBe(false)
-    } finally {
-      gm.async!.timeoutMs = orig.t
-      gm.async!.pollIntervalMs = orig.i
-    }
-  })
-
-  it('provider=google_maps pinned — openmart skipped even for US', async () => {
-    let openmartCalled = false
-
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/openmart/search')) { openmartCalled = true }
-      if (u.includes('/google-maps/scraper') && !u.includes('/scraper/')) {
-        return new Response(JSON.stringify({ jobId: 'gm-2' }), { status: 200 })
-      }
-      if (u.includes('/google-maps/scraper/gm-2')) {
-        return new Response(JSON.stringify({ jobId: 'gm-2', status: 'done', places: [{ title: 'Starbucks' }] }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_places')
-    const gm = providers.find((p) => p.id === 'google_maps')!
-    const orig = { t: gm.async!.timeoutMs, i: gm.async!.pollIntervalMs }
-
-    try {
-      gm.async!.timeoutMs = 500
-      gm.async!.pollIntervalMs = 20
-      const result = await searchPlacesHandler({ query: 'coffee', country: 'US', provider: 'google_maps', limit: 5 })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('google_maps')
-      expect(openmartCalled).toBe(false)
-    } finally {
-      gm.async!.timeoutMs = orig.t
-      gm.async!.pollIntervalMs = orig.i
-    }
-  })
-
-  it('google_maps response is post-filtered by max_overall_rating + min_total_reviews', async () => {
-    // Regression guard: if the handler stops wiring applyPlaceFilters, this test fails.
-    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
-      const u = url.toString()
-      if (u.includes('/google-maps/scraper') && !u.includes('/scraper/')) {
-        return new Response(JSON.stringify({ jobId: 'gm-filter' }), { status: 200 })
-      }
-      if (u.includes('/google-maps/scraper/gm-filter')) {
-        return new Response(JSON.stringify({
-          jobId: 'gm-filter',
-          status: 'done',
-          places: [
-            { title: 'Strict match — keep', totalScore: 3.5, reviewsCount: 120 },
-            { title: 'Rating too high — drop', totalScore: 4.7, reviewsCount: 800 },
-            { title: 'Too few reviews — drop', totalScore: 2.9, reviewsCount: 10 },
-          ],
-        }), { status: 200 })
-      }
-      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
-    }) as typeof fetch
-
-    const { getProviders } = await import('../../src/registry.js')
-    const providers = getProviders('search_places')
-    const gm = providers.find((p) => p.id === 'google_maps')!
-    const orig = { t: gm.async!.timeoutMs, i: gm.async!.pollIntervalMs }
-
-    try {
-      gm.async!.timeoutMs = 500
-      gm.async!.pollIntervalMs = 20
-      const result = await searchPlacesHandler({
-        query: 'dentist',
-        country: 'FR',
-        provider: 'google_maps',
-        max_overall_rating: 4,
-        min_total_reviews: 20,
-        limit: 10,
-      })
-
-      expect(result.isError).toBeFalsy()
-      const parsed = JSON.parse(result.content[0].text)
-      expect(parsed._meta.provider).toBe('google_maps')
-      expect(parsed.data.places.map((p: { title: string }) => p.title)).toEqual(['Strict match — keep'])
-    } finally {
-      gm.async!.timeoutMs = orig.t
-      gm.async!.pollIntervalMs = orig.i
-    }
-  })
-
-  it('all providers fail — returns isError', async () => {
-    globalThis.fetch = vi.fn(async () => {
-      return new Response(JSON.stringify({ error: 'down' }), { status: 503 })
-    }) as typeof fetch
-
-    const result = await searchPlacesHandler({ query: 'coffee', country: 'US' })
-
-    expect(result.isError).toBe(true)
-    const parsed = JSON.parse(result.content[0].text)
-    expect(parsed.error).toBeTruthy()
-  })
-})