@coldiq/mcp 0.2.8 → 0.3.1

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

@@ -309,6 +309,72 @@ describe('signalbase-job-change', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// theirstack-intent-discovery
+// ---------------------------------------------------------------------------
+
+describe('theirstack-intent-discovery', () => {
+  const p = () => get('theirstack-intent-discovery')
+
+  it('routes to the company search endpoint', () => {
+    expect(p().endpoint).toBe('/theirstack/companies/search')
+    expect(p().method).toBe('POST')
+  })
+
+  it('isApplicable: true for intent with topics and no companies/domains', () => {
+    expect(p().isApplicable!({ signal_type: 'intent', topics: ['sales-automation'] })).toBe(true)
+  })
+
+  it('isApplicable: false when companies present (verify mode handles that)', () => {
+    expect(p().isApplicable!({ signal_type: 'intent', topics: ['sales-automation'], companies: ['ColdIQ'] })).toBe(false)
+  })
+
+  it('isApplicable: false when domains present', () => {
+    expect(p().isApplicable!({ signal_type: 'intent', topics: ['sales-automation'], domains: ['coldiq.com'] })).toBe(false)
+  })
+
+  it('isApplicable: false when no topics', () => {
+    expect(p().isApplicable!({ signal_type: 'intent' })).toBe(false)
+  })
+
+  it('isApplicable: false for other signal types', () => {
+    expect(p().isApplicable!({ signal_type: 'funding', topics: ['x'] })).toBe(false)
+  })
+
+  it('mapParams forwards topics as company_keyword_slug_or', () => {
+    const result = p().mapParams({ signal_type: 'intent', topics: ['sales-automation', 'lead-generation'], limit: 20 })
+    const body = result.body as Record<string, unknown>
+    expect(body.company_keyword_slug_or).toEqual(['sales-automation', 'lead-generation'])
+    expect(body.limit).toBe(20)
+    expect(body.include_total_results).toBe(true)
+  })
+
+  it('mapParams forwards industries and countries when present', () => {
+    const result = p().mapParams({
+      signal_type: 'intent',
+      topics: ['sales-automation'],
+      industries: ['Software'],
+      countries: ['US', 'GB'],
+    })
+    const body = result.body as Record<string, unknown>
+    expect(body.industry_or).toEqual(['Software'])
+    expect(body.company_country_code_or).toEqual(['US', 'GB'])
+  })
+
+  it('mapParams caps limit at 100', () => {
+    const result = p().mapParams({ signal_type: 'intent', topics: ['x'], limit: 999 })
+    expect((result.body as Record<string, unknown>).limit).toBe(100)
+  })
+
+  it('hasResult: true when data non-empty', () => {
+    expect(p().hasResult({ data: [{ name: 'ColdIQ' }] })).toBe(true)
+  })
+
+  it('hasResult: false on empty data', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // theirstack-buying-intents
 // ---------------------------------------------------------------------------

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

@@ -176,6 +176,22 @@ describe('ai-ark-companies', () => {
 // theirstack — buying-intent keyword discovery via company_keyword_slug_or
 // ---------------------------------------------------------------------------
 
+describe('apollo search_companies', () => {
+  const p = () => get('apollo')
+
+  it('mapParams sends `limit` (not per_page) so the backend auto-paginates', () => {
+    const body = p().mapParams({ keywords: ['SaaS'], industries: ['fintech'], countries: ['US'], limit: 250 }).body as Record<string, unknown>
+    expect(body.limit).toBe(250)
+    expect(body.per_page).toBeUndefined()
+    expect(body.q_organization_keyword_tags).toEqual(['SaaS', 'fintech'])
+  })
+
+  it('mapParams defaults limit to 25 when absent', () => {
+    const body = p().mapParams({ keywords: ['SaaS'] }).body as Record<string, unknown>
+    expect(body.limit).toBe(25)
+  })
+})
+
 describe('theirstack search_companies', () => {
   const p = () => get('theirstack')
 

package/tests/registry.test.ts

@@ -99,7 +99,7 @@ describe('registry', () => {
         q_organization_keyword_tags: ['SaaS'],
         organization_locations: ['United States'],
         organization_num_employees_ranges: ['10,200'],
-        per_page: 25,
+        limit: 25,
       })
     })
 
@@ -119,7 +119,7 @@ describe('registry', () => {
         q_organization_keyword_tags: ['healthcare', 'Hospital & Health Care', 'Medical Devices'],
         organization_locations: ['Paris, France', 'France'],
         organization_num_employees_ranges: ['50,100'],
-        per_page: 25,
+        limit: 25,
       })
     })
 
@@ -131,7 +131,7 @@ describe('registry', () => {
         q_organization_keyword_tags: undefined,
         organization_locations: undefined,
         organization_num_employees_ranges: ['50,100'],
-        per_page: 25,
+        limit: 25,
       })
     })
 

package/tests/tools/extract-post-engagement.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { extractPostEngagementHandler } from '../../src/tools/extract-post-engagement.js'
+
+const POST_URL = 'https://www.linkedin.com/feed/update/urn:li:activity:7234567890123456789'
+
+function res(body: unknown, status = 200, headers?: Record<string, string>) {
+  return new Response(JSON.stringify(body), { status, headers })
+}
+
+describe('extract_post_engagement handler', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+    vi.stubEnv('COLDIQ_ENGAGEMENT_POLL_MS', '1')
+    vi.stubEnv('COLDIQ_ENGAGEMENT_TIMEOUT_MS', '5000')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    vi.unstubAllEnvs()
+  })
+
+  it('runs create → poll → fetch contacts and returns the people', async () => {
+    const people = [{ name: 'Alex Vacca', profile_url: 'https://www.linkedin.com/in/alexvacca' }]
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/jungler/workbooks/wb_1/contacts')) return res(people)
+      if (u.includes('/jungler/tasks/task_1/status')) return res({ task_id: 'task_1', status: 'success', workbook_id: 'wb_1' })
+      if (u.includes('/jungler/workbooks')) return res({ task_id: 'task_1', status: 'PENDING' }, 200, { 'x-coldiq-credits-charged': '10', 'x-coldiq-credits-remaining': '90' })
+      throw new Error(`unexpected url ${u}`)
+    }) as typeof fetch
+
+    const result = await extractPostEngagementHandler({ post_url: POST_URL, type: 'both' })
+    const parsed = JSON.parse(result.content[0].text)
+    expect(result.isError).toBeUndefined()
+    expect(parsed.data.people).toEqual(people)
+    expect(parsed.data.type).toBe('both')
+    expect(parsed._meta.credits_charged).toBe(10)
+  })
+
+  it('passes activity_filter=commenters when type=comments', async () => {
+    let contactsUrl = ''
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/jungler/workbooks/wb_1/contacts')) { contactsUrl = u; return res([]) }
+      if (u.includes('/jungler/tasks/task_1/status')) return res({ task_id: 'task_1', status: 'success', workbook_id: 'wb_1' })
+      if (u.includes('/jungler/workbooks')) return res({ task_id: 'task_1', status: 'PENDING' })
+      throw new Error(`unexpected url ${u}`)
+    }) as typeof fetch
+
+    await extractPostEngagementHandler({ post_url: POST_URL, type: 'comments' })
+    expect(contactsUrl).toContain('activity_filter=commenters')
+  })
+
+  it('returns an error when the task fails upstream', async () => {
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/jungler/tasks/task_1/status')) return res({ task_id: 'task_1', status: 'failure' })
+      if (u.includes('/jungler/workbooks')) return res({ task_id: 'task_1', status: 'PENDING' })
+      throw new Error(`unexpected url ${u}`)
+    }) as typeof fetch
+
+    const result = await extractPostEngagementHandler({ post_url: POST_URL, type: 'both' })
+    expect(result.isError).toBe(true)
+    expect(JSON.parse(result.content[0].text).error).toMatch(/extraction failed/i)
+  })
+
+  it('surfaces the create error when the job cannot start', async () => {
+    globalThis.fetch = vi.fn(async () => res({ error: 'Invalid LinkedIn post URL' }, 400)) as typeof fetch
+    const result = await extractPostEngagementHandler({ post_url: POST_URL, type: 'both' })
+    expect(result.isError).toBe(true)
+    expect(JSON.parse(result.content[0].text).error).toMatch(/Invalid LinkedIn post URL/)
+  })
+})

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

@@ -139,14 +139,17 @@ describe('find_signals handler — hiring industries post-filter', () => {
     expect(body.data.data.map((r: { id: string }) => r.id)).toEqual(['a', 'c'])
   })
 
-  it('returns empty array when no row matches any industry', async () => {
+  it('returns unfiltered rows with a note 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([])
+    // Non-destructive: keep all rows rather than return a misleading empty set,
+    // and flag that the industry filter matched nothing.
+    expect(body.data.data).toHaveLength(5)
+    expect(body.data._industry_filter).toMatch(/UNFILTERED/)
   })
 
   it('leaves rows untouched when industries is absent', async () => {

package/tests/tools/get-place-reviews.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { getPlaceReviewsHandler } from '../../src/tools/get-place-reviews.js'
+import { getProviders } from '../../src/registry.js'
+
+const PLACE_URL = 'https://www.google.com/maps/place/ColdIQ'
+
+describe('get_place_reviews handler', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  function withFastPolling<T>(fn: () => Promise<T>): Promise<T> {
+    const p = getProviders('get_place_reviews').find((x) => x.id === 'google_maps_reviews')!
+    const orig = { t: p.async!.timeoutMs, i: p.async!.pollIntervalMs }
+    p.async!.timeoutMs = 500
+    p.async!.pollIntervalMs = 20
+    return fn().finally(() => {
+      p.async!.timeoutMs = orig.t
+      p.async!.pollIntervalMs = orig.i
+    })
+  }
+
+  it('submits the reviews job and returns reviews when done', async () => {
+    const reviews = [{ text: 'Great service', stars: 5 }]
+    globalThis.fetch = vi.fn(async (url: string | URL) => {
+      const u = url.toString()
+      if (u.includes('/google-maps/reviews/rev-1')) {
+        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'done', reviews }), { status: 200 })
+      }
+      if (u.includes('/google-maps/reviews')) {
+        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'processing' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const result = await withFastPolling(() =>
+      getPlaceReviewsHandler({ place_urls: [PLACE_URL], max_reviews: 10, sort: 'lowestRanking' }),
+    )
+    expect(result.isError).toBeFalsy()
+    const parsed = JSON.parse(result.content[0].text)
+    expect(parsed._meta.provider).toBe('google_maps_reviews')
+    expect(parsed.data.reviews).toEqual(reviews)
+  })
+
+  it('forwards place_urls, max_reviews and sort to the upstream body', async () => {
+    let submitBody: Record<string, unknown> = {}
+    globalThis.fetch = vi.fn(async (url: string | URL, init?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/google-maps/reviews/rev-1')) {
+        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'done', reviews: [] }), { status: 200 })
+      }
+      if (u.includes('/google-maps/reviews')) {
+        submitBody = JSON.parse(init!.body as string)
+        return new Response(JSON.stringify({ jobId: 'rev-1', status: 'processing' }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    await withFastPolling(() =>
+      getPlaceReviewsHandler({ place_urls: [PLACE_URL], max_reviews: 25, sort: 'newest' }),
+    )
+    expect(submitBody.startUrls).toEqual([{ url: PLACE_URL }])
+    expect(submitBody.maxReviews).toBe(25)
+    expect(submitBody.reviewsSort).toBe('newest')
+  })
+})

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

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { initClient } from '../../src/client.js'
-import { searchCompaniesHandler } from '../../src/tools/search-companies.js'
+import { searchCompaniesHandler, searchCompaniesSchema } from '../../src/tools/search-companies.js'
 
 describe('search_companies handler', () => {
   const originalFetch = globalThis.fetch
@@ -56,6 +56,24 @@ describe('search_companies handler', () => {
     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

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

@@ -122,4 +122,73 @@ describe('search_reddit handler', () => {
       reddit.async!.pollIntervalMs = orig.i
     }
   })
+
+  it('rewrites a bare subreddit URL + query into an in-subreddit search URL', async () => {
+    let capturedBody: Record<string, unknown> | null = null
+    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/reddit/scrape') && !u.includes('/scrape/')) {
+        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
+        return new Response(JSON.stringify({ jobId: 'r-4' }), { status: 200 })
+      }
+      if (u.includes('/reddit/scrape/r-4')) {
+        return new Response(JSON.stringify({ jobId: 'r-4', status: 'done', items: [{ title: 'lemlist review' }] }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const { getProviders } = await import('../../src/registry.js')
+    const reddit = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+    const orig = { t: reddit.async!.timeoutMs, i: reddit.async!.pollIntervalMs }
+    try {
+      reddit.async!.timeoutMs = 500
+      reddit.async!.pollIntervalMs = 20
+      await searchRedditHandler({
+        start_urls: ['https://www.reddit.com/r/coldemail/'],
+        query: 'lemlist',
+        time: 'month',
+        limit: 5,
+      })
+      const urls = (capturedBody!.startUrls as Array<{ url: string }>).map((s) => s.url)
+      expect(urls[0]).toContain('/r/coldemail/search/')
+      expect(urls[0]).toContain('q=lemlist')
+      expect(urls[0]).toContain('restrict_sr=1')
+      expect(urls[0]).toContain('t=month')
+      // Query now lives in the URL — top-level searchQueries is dropped to avoid a global search.
+      expect(capturedBody!.searchQueries).toBeUndefined()
+    } finally {
+      reddit.async!.timeoutMs = orig.t
+      reddit.async!.pollIntervalMs = orig.i
+    }
+  })
+
+  it('leaves an existing search URL untouched and keeps it as the start url', async () => {
+    let capturedBody: Record<string, unknown> | null = null
+    const searchUrl = 'https://www.reddit.com/search/?q=lemlist&sort=new'
+    globalThis.fetch = vi.fn(async (url: string | URL | Request, opts?: RequestInit) => {
+      const u = url.toString()
+      if (u.includes('/reddit/scrape') && !u.includes('/scrape/')) {
+        capturedBody = JSON.parse((opts?.body as string) ?? '{}')
+        return new Response(JSON.stringify({ jobId: 'r-5' }), { status: 200 })
+      }
+      if (u.includes('/reddit/scrape/r-5')) {
+        return new Response(JSON.stringify({ jobId: 'r-5', status: 'done', items: [{ title: 'x' }] }), { status: 200 })
+      }
+      return new Response(JSON.stringify({ error: 'unexpected' }), { status: 500 })
+    }) as typeof fetch
+
+    const { getProviders } = await import('../../src/registry.js')
+    const reddit = getProviders('search_reddit').find((p) => p.id === 'reddit')!
+    const orig = { t: reddit.async!.timeoutMs, i: reddit.async!.pollIntervalMs }
+    try {
+      reddit.async!.timeoutMs = 500
+      reddit.async!.pollIntervalMs = 20
+      await searchRedditHandler({ start_urls: [searchUrl], query: 'lemlist', limit: 5 })
+      const urls = (capturedBody!.startUrls as Array<{ url: string }>).map((s) => s.url)
+      expect(urls[0]).toBe(searchUrl)
+    } finally {
+      reddit.async!.timeoutMs = orig.t
+      reddit.async!.pollIntervalMs = orig.i
+    }
+  })
 })