@coldiq/mcp 0.2.5 → 0.2.7

package/tests/registry-enrich-person.test.ts

@@ -92,8 +92,36 @@ describe('apollo-people-match', () => {
     })
   })
 
-  it('hasResult: true when person object present', () => {
-    expect(p().hasResult({ person: { name: 'Michel Lieben', id: 'abc' } })).toBe(true)
+  it('hasResult: true when person has linkedin_url', () => {
+    expect(p().hasResult({ person: { name: 'Michel Lieben', id: 'abc', linkedin_url: 'https://www.linkedin.com/in/michel-lieben' } })).toBe(true)
+  })
+
+  it('hasResult: true when person has email', () => {
+    expect(p().hasResult({ person: { name: 'Michel Lieben', email: 'michel@coldiq.com' } })).toBe(true)
+  })
+
+  it('hasResult: true when person has non-empty employment_history', () => {
+    expect(p().hasResult({ person: { name: 'Michel Lieben', employment_history: [{ organization_id: 'org_1' }] } })).toBe(true)
+  })
+
+  it('hasResult: false on Apollo silent-empty record (name only, all other fields null)', () => {
+    // Apollo /people/match returns 200 with this shape when no real match is found.
+    // The executor must fall through to the next provider instead of surfacing junk.
+    expect(p().hasResult({
+      person: {
+        id: '6a0c19edfe0e7300102a02dc',
+        first_name: 'Alex',
+        last_name: 'Vacca',
+        name: 'Alex Vacca',
+        linkedin_url: null,
+        title: null,
+        organization_id: null,
+        employment_history: [],
+        email: null,
+        headline: null,
+        seniority: null,
+      },
+    })).toBe(false)
   })
 
   it('hasResult: false when person is null', () => {

package/tests/registry-find-signals.test.ts

@@ -60,6 +60,18 @@ describe('signalbase-funding', () => {
     expect((result.queryParams as Record<string, string>).limit).toBe('100')
   })
 
+  it('mapParams forwards round_type as comma-joined `round` upstream param', () => {
+    const result = p().mapParams({ signal_type: 'funding', round_type: ['Series A', 'Seed'], limit: 10 })
+    expect((result.queryParams as Record<string, string>).round).toBe('Series A,Seed')
+  })
+
+  it('mapParams omits `round` when round_type is missing or empty', () => {
+    const noRound = p().mapParams({ signal_type: 'funding', limit: 10 })
+    expect((noRound.queryParams as Record<string, string>).round).toBeUndefined()
+    const emptyRound = p().mapParams({ signal_type: 'funding', round_type: [], limit: 10 })
+    expect((emptyRound.queryParams as Record<string, string>).round).toBeUndefined()
+  })
+
   it('hasResult: true when data array non-empty', () => {
     expect(p().hasResult({ data: [{ company: 'ColdIQ', amount: 1000000 }] })).toBe(true)
   })
@@ -335,6 +347,25 @@ describe('theirstack-buying-intents', () => {
     const body = result.body as Record<string, unknown>
     expect(body.company_name_or).toBeUndefined()
     expect(body.company_domain).toBeUndefined()
+    expect(body.keyword_slug_or).toBeUndefined()
+  })
+
+  it('mapParams forwards topics as keyword_slug_or upstream param', () => {
+    const result = p().mapParams({
+      signal_type: 'intent',
+      companies: ['ColdIQ'],
+      topics: ['sales-automation', 'lead-generation'],
+    })
+    const body = result.body as Record<string, unknown>
+    expect(body.keyword_slug_or).toEqual(['sales-automation', 'lead-generation'])
+    // topics is supplemental — company filter still forwarded.
+    expect(body.company_name_or).toEqual(['ColdIQ'])
+  })
+
+  it('mapParams omits keyword_slug_or when topics is empty', () => {
+    const result = p().mapParams({ signal_type: 'intent', companies: ['ColdIQ'], topics: [] })
+    const body = result.body as Record<string, unknown>
+    expect(body.keyword_slug_or).toBeUndefined()
   })
 
   it('hasResult: true when data non-empty', () => {

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

@@ -108,3 +108,65 @@ describe('find_signals handler — company-targeted types pass through', () => {
     })
   }
 })
+
+// ---------------------------------------------------------------------------
+// hiring industries client-side post-filter
+//
+// Signalbase /hiring-signals has no upstream `industry` query param, so the
+// handler filters the result rows by industries instead of silently dropping
+// the filter.
+// ---------------------------------------------------------------------------
+
+import { executeWithFallback as mockedExecute } from '../../src/executor.js'
+
+describe('find_signals handler — hiring industries post-filter', () => {
+  const hiringRows = [
+    { id: 'a', title: 'Sales Lead', companyName: 'CreatePay', industries: 'Financial Services' },
+    { id: 'b', title: 'Sales Assistant', companyName: 'AstraZeneca', industries: 'Pharmaceutical Manufacturing' },
+    { id: 'c', title: 'Account Executive', companyName: 'Monex Europe', industries: 'Financial Services and Foreign Exchange' },
+    { id: 'd', title: 'Legal Counsel', companyName: 'Eversheds', industries: 'Law Practice and Legal Services' },
+    { id: 'e', title: 'Engineer', companyName: 'NoIndustries', industries: '' },
+  ]
+
+  it('filters rows by case-insensitive industries substring match', async () => {
+    vi.mocked(mockedExecute).mockResolvedValueOnce({
+      data: { success: true, data: [...hiringRows] },
+      _meta: { provider: 'signalbase-hiring', latencyMs: 1 },
+    })
+    const result = await findSignalsHandler({ signal_type: 'hiring', industries: ['financial services'], limit: 25 })
+    const body = JSON.parse(result.content[0].text)
+    expect(body.data.data).toHaveLength(2)
+    expect(body.data.data.map((r: { id: string }) => r.id)).toEqual(['a', 'c'])
+  })
+
+  it('returns empty array when no row matches any industry', async () => {
+    vi.mocked(mockedExecute).mockResolvedValueOnce({
+      data: { success: true, data: [...hiringRows] },
+      _meta: { provider: 'signalbase-hiring', latencyMs: 1 },
+    })
+    const result = await findSignalsHandler({ signal_type: 'hiring', industries: ['Aerospace'], limit: 25 })
+    const body = JSON.parse(result.content[0].text)
+    expect(body.data.data).toEqual([])
+  })
+
+  it('leaves rows untouched when industries is absent', async () => {
+    vi.mocked(mockedExecute).mockResolvedValueOnce({
+      data: { success: true, data: [...hiringRows] },
+      _meta: { provider: 'signalbase-hiring', latencyMs: 1 },
+    })
+    const result = await findSignalsHandler({ signal_type: 'hiring', limit: 25 })
+    const body = JSON.parse(result.content[0].text)
+    expect(body.data.data).toHaveLength(5)
+  })
+
+  it('does not apply filter to non-hiring signal types', async () => {
+    vi.mocked(mockedExecute).mockResolvedValueOnce({
+      data: { success: true, data: [...hiringRows] },
+      _meta: { provider: 'signalbase-funding', latencyMs: 1 },
+    })
+    const result = await findSignalsHandler({ signal_type: 'funding', industries: ['Aerospace'], limit: 25 })
+    const body = JSON.parse(result.content[0].text)
+    // Untouched: industries is forwarded upstream for funding, not post-filtered here.
+    expect(body.data.data).toHaveLength(5)
+  })
+})

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

@@ -1,6 +1,54 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { initClient } from '../../src/client.js'
-import { searchPlacesHandler } from '../../src/tools/search-places.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
@@ -100,6 +148,54 @@ describe('search_places handler', () => {
     }
   })
 
+  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 })

package/tests/tools/verify-email.test.ts

@@ -1,6 +1,66 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { initClient } from '../../src/client.js'
-import { verifyEmailHandler } from '../../src/tools/verify-email.js'
+import { verifyEmailHandler, addNormalizedStatus } from '../../src/tools/verify-email.js'
+
+describe('addNormalizedStatus', () => {
+  it('findymail verified=true → status valid', () => {
+    const out = addNormalizedStatus({ email: 'michel@coldiq.com', verified: true, provider: 'Google' }, 'findymail') as Record<string, unknown>
+    expect(out.status).toBe('valid')
+    // Original fields preserved for back-compat.
+    expect(out.verified).toBe(true)
+    expect(out.provider).toBe('Google')
+  })
+
+  it('findymail verified=false → status invalid', () => {
+    const out = addNormalizedStatus({ email: 'bad@example.com', verified: false, provider: 'Other' }, 'findymail') as Record<string, unknown>
+    expect(out.status).toBe('invalid')
+  })
+
+  it('icypeas item.status=catch_all → catch_all', () => {
+    const out = addNormalizedStatus({ success: true, item: { status: 'catch_all', email: 'x@y.com' } }, 'icypeas') as Record<string, unknown>
+    expect(out.status).toBe('catch_all')
+  })
+
+  it('icypeas missing item → unknown', () => {
+    const out = addNormalizedStatus({ success: true }, 'icypeas') as Record<string, unknown>
+    expect(out.status).toBe('unknown')
+  })
+
+  it('upstream status="catchall" is normalized to catch_all', () => {
+    const out = addNormalizedStatus({ status: 'catchall', email: 'x@y.com' }, 'instantly') as Record<string, unknown>
+    expect(out.status).toBe('catch_all')
+  })
+
+  it('upstream status="risky" stays risky', () => {
+    const out = addNormalizedStatus({ status: 'risky' }, 'instantly') as Record<string, unknown>
+    expect(out.status).toBe('risky')
+  })
+
+  it('upstream status="disposable" stays disposable', () => {
+    const out = addNormalizedStatus({ status: 'disposable' }, 'instantly') as Record<string, unknown>
+    expect(out.status).toBe('disposable')
+  })
+
+  it('upstream status="VALID" is lowercased to valid', () => {
+    const out = addNormalizedStatus({ status: 'VALID' }, 'instantly') as Record<string, unknown>
+    expect(out.status).toBe('valid')
+  })
+
+  it('unknown provider id with no signal fields → unknown', () => {
+    const out = addNormalizedStatus({ foo: 'bar' }, 'mystery-provider') as Record<string, unknown>
+    expect(out.status).toBe('unknown')
+  })
+
+  it('null / non-object data is returned unchanged', () => {
+    expect(addNormalizedStatus(null, 'findymail')).toBe(null)
+    expect(addNormalizedStatus('a string', 'findymail')).toBe('a string')
+  })
+
+  it('linkupapi-validate verified=true → valid', () => {
+    const out = addNormalizedStatus({ verified: true }, 'linkupapi-validate') as Record<string, unknown>
+    expect(out.status).toBe('valid')
+  })
+})
 
 describe('verify_email handler', () => {
   const originalFetch = globalThis.fetch
@@ -13,9 +73,9 @@ describe('verify_email handler', () => {
     globalThis.fetch = originalFetch
   })
 
-  it('returns verification result from FindyMail', async () => {
+  it('normalizes findymail real upstream shape (verified boolean) to status=valid', async () => {
     globalThis.fetch = vi.fn(async () =>
-      new Response(JSON.stringify({ status: 'valid', email: 'michel@coldiq.com' }), { status: 200 })
+      new Response(JSON.stringify({ email: 'michel@coldiq.com', verified: true, provider: 'Google' }), { status: 200 })
     ) as typeof fetch
 
     const result = await verifyEmailHandler({ email: 'michel@coldiq.com' })
@@ -23,6 +83,20 @@ describe('verify_email handler', () => {
     const parsed = JSON.parse(result.content[0].text)
     expect(parsed._meta.provider).toBe('findymail')
     expect(parsed.data.status).toBe('valid')
+    // Raw fields still surfaced for callers that already depend on them.
+    expect(parsed.data.verified).toBe(true)
+    expect(parsed.data.provider).toBe('Google')
+  })
+
+  it('normalizes findymail verified=false to status=invalid', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ email: 'bad@example.com', verified: false, provider: 'Other' }), { status: 200 })
+    ) as typeof fetch
+
+    const result = await verifyEmailHandler({ email: 'bad@example.com' })
+
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed.data.status).toBe('invalid')
   })
 
   it('falls back to IcyPeas on FindyMail failure', async () => {