@coldiq/mcp 5.4.2 → 5.4.4

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

@@ -172,24 +172,50 @@ describe('ai-ark-people', () => {
     expect(p().isApplicable!({ keywords: ['cold email'] })).toBe(true)
   })
 
-  it('isApplicable: false with only company_domains', () => {
-    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(false)
+  it('isApplicable: true with company identifiers or locations', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(true)
+    expect(p().isApplicable!({ company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'] })).toBe(true)
+    expect(p().isApplicable!({ locations: ['Belgium'] })).toBe(true)
+  })
+
+  it('isApplicable: false for an unsupported seniority by itself', () => {
+    expect(p().isApplicable!({ seniorities: ['Supreme Leader'] })).toBe(false)
   })
 
-  it('mapParams builds AI-Ark contact shape', () => {
+  it('mapParams builds the documented AI Ark account and contact shape', () => {
     expect(p().mapParams({
       job_titles: ['VP Sales'],
       seniorities: ['Director'],
       locations: ['Belgium'],
       keywords: ['outbound'],
+      company_domains: ['coldiq.com'],
+      company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'],
       limit: 20,
     })).toEqual({
       body: {
+        account: {
+          domain: { any: { include: ['coldiq.com'] } },
+          linkedin: { any: { include: ['https://www.linkedin.com/company/coldiq'] } },
+        },
         contact: {
-          departmentAndFunction: { any: { include: ['VP Sales'] } },
-          seniority: { any: { include: ['Director'] } },
+          experience: {
+            latest: {
+              title: { any: { include: { mode: 'SMART', content: ['VP Sales'] } } },
+            },
+          },
+          seniority: { any: { include: ['director'] } },
           location: { any: { include: ['Belgium'] } },
-          keywordsInProfile: { any: { include: ['outbound'] } },
+          keyword: {
+            any: {
+              include: {
+                sources: [
+                  { mode: 'SMART', source: 'HEADLINE' },
+                  { mode: 'SMART', source: 'SUMMARY' },
+                ],
+                content: ['outbound'],
+              },
+            },
+          },
         },
         size: 20,
       },
@@ -201,7 +227,7 @@ describe('ai-ark-people', () => {
     const contact = (result.body as Record<string, unknown>).contact as Record<string, unknown>
     expect(contact.seniority).toBeUndefined()
     expect(contact.location).toBeUndefined()
-    expect(contact.keywordsInProfile).toBeUndefined()
+    expect(contact.keyword).toBeUndefined()
   })
 
   it('mapParams caps size at 100', () => {

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

@@ -103,15 +103,31 @@ describe('ai-ark-companies', () => {
     expect(p().isApplicable!({ countries: ['BE'] })).toBe(true)
   })
 
-  it('isApplicable: false with only min_employees', () => {
-    expect(p().isApplicable!({ min_employees: 50 })).toBe(false)
+  it('isApplicable: true with employee range, valid funding, or lookalike domains', () => {
+    expect(p().isApplicable!({ min_employees: 50 })).toBe(true)
+    expect(p().isApplicable!({ funding_stages: ['Series A'] })).toBe(true)
+    expect(p().isApplicable!({ similar_to_domains: ['coldiq.com'] })).toBe(true)
+  })
+
+  it('isApplicable: false for an unsupported funding stage by itself', () => {
+    expect(p().isApplicable!({ funding_stages: ['not-a-real-stage'] })).toBe(false)
+  })
+
+  it('isApplicable: false when lookalike input exceeds AI Ark\'s five-domain limit', () => {
+    const similarToDomains = ['a.com', 'b.com', 'c.com', 'd.com', 'e.com', 'f.com']
+    expect(p().isApplicable!({
+      keywords: ['outbound sales'],
+      similar_to_domains: similarToDomains,
+    })).toBe(false)
+    expect(() => p().mapParams({ similar_to_domains: similarToDomains })).toThrow()
   })
 
-  it('mapParams builds AI-Ark account/contact shape', () => {
+  it('mapParams builds the documented AI Ark company filter shape', () => {
     const result = p().mapParams({
       keywords: ['outbound sales'],
       industries: ['SaaS'],
       countries: ['BE'],
+      similar_to_domains: ['coldiq.com'],
       min_employees: 10,
       max_employees: 500,
       funding_stages: ['Series A'],
@@ -119,17 +135,28 @@ describe('ai-ark-companies', () => {
     })
     expect(result).toEqual({
       body: {
+        lookalikeDomains: ['coldiq.com'],
         account: {
-          industries: { any: { include: ['SaaS'] } },
+          industries: { any: { include: { mode: 'WORD', content: ['SaaS'] } } },
+          keyword: {
+            any: {
+              include: {
+                sources: [
+                  { mode: 'SMART', source: 'NAME' },
+                  { mode: 'SMART', source: 'KEYWORD' },
+                  { mode: 'SMART', source: 'DESCRIPTION' },
+                  { mode: 'SMART', source: 'SEO' },
+                ],
+                content: ['outbound sales'],
+              },
+            },
+          },
           location: { any: { include: ['Belgium'] } },
           employeeSize: {
             type: 'RANGE',
             range: [{ start: 10, end: 500 }],
           },
-          funding: { stage: { include: ['Series A'] } },
-        },
-        contact: {
-          keywordsInProfile: { any: { include: ['outbound sales'] } },
+          funding: { type: ['SERIES_A'] },
         },
         size: 20,
       },
@@ -145,7 +172,7 @@ describe('ai-ark-companies', () => {
     expect(account.funding).toBeUndefined()
   })
 
-  it('mapParams omits contact when no keywords', () => {
+  it('mapParams never creates a contact filter for company keywords', () => {
     const result = p().mapParams({ industries: ['SaaS'] })
     expect((result.body as Record<string, unknown>).contact).toBeUndefined()
   })

package/tests/registry.test.ts

@@ -223,7 +223,7 @@ describe('registry', () => {
     })
 
     it('BlitzAPI folds industries into keywords (industry filter requires LinkedIn taxonomy)', () => {
-      const providers = getProviders('search_companies')
+      const providers = getConfiguredProviders('search_companies')
       const blitz = providers.find((p) => p.id === 'blitzapi')!
       const result = blitz.mapParams({
         keywords: ['AI'],
@@ -246,7 +246,7 @@ describe('registry', () => {
     })
 
     it('BlitzAPI isApplicable rejects empty input but accepts basic narrowing filters', () => {
-      const providers = getProviders('search_companies')
+      const providers = getConfiguredProviders('search_companies')
       const blitz = providers.find((p) => p.id === 'blitzapi')!
       expect(blitz.isApplicable!({})).toBe(false)
       expect(blitz.isApplicable!({ keywords: ['AI'] })).toBe(true)
@@ -255,7 +255,7 @@ describe('registry', () => {
     })
 
     it('BlitzAPI isApplicable rejects advanced filters it cannot apply', () => {
-      const providers = getProviders('search_companies')
+      const providers = getConfiguredProviders('search_companies')
       const blitz = providers.find((p) => p.id === 'blitzapi')!
       expect(blitz.isApplicable!({ technologies: ['Salesforce'] })).toBe(false)
       expect(blitz.isApplicable!({ funding_stages: ['series_a'] })).toBe(false)
@@ -271,7 +271,7 @@ describe('registry', () => {
     })
 
     it('BlitzAPI postFilter enforces employee count when present, passes through when missing', () => {
-      const providers = getProviders('search_companies')
+      const providers = getConfiguredProviders('search_companies')
       const blitz = providers.find((p) => p.id === 'blitzapi')!
       const results = [
         { name: 'A', employees_on_linkedin: 30 },
@@ -284,7 +284,7 @@ describe('registry', () => {
     })
 
     it('BlitzAPI postFilter is a no-op when no employee filters are set', () => {
-      const providers = getProviders('search_companies')
+      const providers = getConfiguredProviders('search_companies')
       const blitz = providers.find((p) => p.id === 'blitzapi')!
       const results = [{ name: 'A', employees_on_linkedin: 30 }]
       const out = blitz.postFilter!({ results }, {}) as Record<string, unknown>
@@ -292,7 +292,7 @@ describe('registry', () => {
     })
 
     it('BlitzAPI caps max_results at 50', () => {
-      const providers = getProviders('search_companies')
+      const providers = getConfiguredProviders('search_companies')
       const blitz = providers.find((p) => p.id === 'blitzapi')!
       const result = blitz.mapParams({ keywords: ['AI'], limit: 100 })
       expect((result.body as { max_results: number }).max_results).toBe(50)
@@ -472,7 +472,6 @@ describe('registry', () => {
         'fullenrich',
         'theirstack',
         'signalbase',
-        'blitzapi',
         'apollo',
         'limadata',
         'predictleads',
@@ -800,7 +799,7 @@ describe('registry', () => {
       const ids = getProviders('enrich_company').map((p) => p.id)
       expect(ids).toEqual([
         'apollo', 'limadata', 'prospeo',
-        'blitzapi', 'wiza', 'findymail', 'icypeas',
+        'wiza', 'findymail', 'icypeas',
         'builtwith', 'openmart', 'linkupapi-by-domain', 'linkupapi-by-url', 'discolike',
       ])
     })
@@ -890,7 +889,7 @@ describe('registry', () => {
     })
 
     it('BlitzAPI is gated on linkedin_url and passes company_linkedin_url', () => {
-      const bz = getProviders('enrich_company').find((p) => p.id === 'blitzapi')!
+      const bz = getConfiguredProviders('enrich_company').find((p) => p.id === 'blitzapi')!
       expect(bz.isApplicable!({ linkedin_url: 'https://linkedin.com/company/stripe' })).toBe(true)
       expect(bz.isApplicable!({ domain: 'stripe.com' })).toBe(false)
       expect(bz.mapParams({ linkedin_url: 'https://linkedin.com/company/stripe' }).body).toEqual({ company_linkedin_url: 'https://linkedin.com/company/stripe' })

package/tests/tools/visitor-id-tools.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { getWebsiteVisitorsHandler, getWebsiteVisitorsSchema } from '../../src/tools/get-website-visitors.js'
+
+describe('visitor-ID MCP tools', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    vi.restoreAllMocks()
+  })
+
+  function captureUrl(payload: unknown, status = 200) {
+    const seen: { url: string } = { url: '' }
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      seen.url = url.toString()
+      return new Response(JSON.stringify(payload), { status })
+    }) as typeof fetch
+    return seen
+  }
+
+  describe('get_website_visitors', () => {
+    it('reads identified people from the contacts endpoint', async () => {
+      const seen = captureUrl({ data: [{ email: 'michel@coldiq.com' }], next_cursor: 'abc' })
+
+      const result = await getWebsiteVisitorsHandler({ website_id: 7, type: 'people', limit: 25 })
+
+      const url = new URL(seen.url)
+      expect(url.pathname).toBe('/v1/visitor-id/websites/7/contacts')
+      expect(url.searchParams.get('limit')).toBe('25')
+      expect(result.isError).toBeFalsy()
+    })
+
+    it('reads identified companies from the accounts endpoint', async () => {
+      const seen = captureUrl({ data: [{ domain: 'coldiq.com' }] })
+
+      await getWebsiteVisitorsHandler({ website_id: 7, type: 'companies', domain: 'coldiq.com' })
+
+      const url = new URL(seen.url)
+      expect(url.pathname).toBe('/v1/visitor-id/websites/7/accounts')
+      expect(url.searchParams.get('domain')).toBe('coldiq.com')
+    })
+
+    it('sends people-only filters only for people, and company-only filters only for companies', async () => {
+      const people = captureUrl({ data: [] })
+      await getWebsiteVisitorsHandler({
+        website_id: 7,
+        type: 'people',
+        email: 'michel@coldiq.com',
+        account_id: 'acc_1',
+        domain: 'coldiq.com',
+      })
+      const peopleUrl = new URL(people.url)
+      expect(peopleUrl.searchParams.get('email')).toBe('michel@coldiq.com')
+      expect(peopleUrl.searchParams.get('account_id')).toBe('acc_1')
+      expect(peopleUrl.searchParams.get('domain')).toBeNull()
+
+      const companies = captureUrl({ data: [] })
+      await getWebsiteVisitorsHandler({
+        website_id: 7,
+        type: 'companies',
+        domain: 'coldiq.com',
+        email: 'michel@coldiq.com',
+      })
+      const companiesUrl = new URL(companies.url)
+      expect(companiesUrl.searchParams.get('domain')).toBe('coldiq.com')
+      expect(companiesUrl.searchParams.get('email')).toBeNull()
+    })
+
+    it('forwards the pagination cursor', async () => {
+      const seen = captureUrl({ data: [] })
+
+      await getWebsiteVisitorsHandler({ website_id: 7, type: 'people', cursor: 'next-page' })
+
+      expect(new URL(seen.url).searchParams.get('cursor')).toBe('next-page')
+    })
+
+    it('passes the upstream cursor envelope through verbatim', async () => {
+      captureUrl({ data: [{ id: 'c1' }], next_cursor: 'page2', has_more: true })
+
+      const result = await getWebsiteVisitorsHandler({ website_id: 7, type: 'people' })
+      const parsed = JSON.parse(result.content[0].text)
+
+      expect(parsed.data).toEqual({ data: [{ id: 'c1' }], next_cursor: 'page2', has_more: true })
+    })
+
+    it('returns isError when the website is not found', async () => {
+      captureUrl({ error: 'Website not found' }, 404)
+
+      const result = await getWebsiteVisitorsHandler({ website_id: 999, type: 'companies' })
+
+      expect(result.isError).toBe(true)
+      const parsed = JSON.parse(result.content[0].text)
+      expect(parsed.status).toBe(404)
+      expect(parsed.error).toBe('Failed to read identified companies')
+    })
+
+    it('rejects a type outside people/companies at the schema layer', () => {
+      expect(getWebsiteVisitorsSchema.type.safeParse('visitors').success).toBe(false)
+      expect(getWebsiteVisitorsSchema.type.safeParse('people').success).toBe(true)
+      expect(getWebsiteVisitorsSchema.limit.safeParse(101).success).toBe(false)
+    })
+  })
+})

package/tests/version.test.ts

@@ -1,14 +1,27 @@
 import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
 import { readPackageVersion } from '../src/version.js'
 
 describe('readPackageVersion', () => {
   it('reports the real package.json version relative to the caller URL', () => {
     // This test file sits at mcp/tests/, so '../package.json' from here is mcp/package.json.
     const version = readPackageVersion(import.meta.url)
-    expect(version).toMatch(/^\d+\.\d+\.\d+/)
+    expect(version).toMatch(/^5\.4\.\d+$/)
     expect(version).not.toBe('0.1.0') // the old hardcoded placeholder
   })
 
+  it('keeps package.json and package-lock.json on the same 5.4.x version', () => {
+    const packageJsonPath = fileURLToPath(new URL('../package.json', import.meta.url))
+    const packageLockPath = fileURLToPath(new URL('../package-lock.json', import.meta.url))
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
+    const packageLock = JSON.parse(readFileSync(packageLockPath, 'utf8'))
+
+    expect(packageJson.version).toMatch(/^5\.4\.\d+$/)
+    expect(packageLock.version).toBe(packageJson.version)
+    expect(packageLock.packages[''].version).toBe(packageJson.version)
+  })
+
   it('falls back to 0.0.0 instead of throwing when package.json cannot be resolved', () => {
     const version = readPackageVersion('file:///nonexistent/deeply/nested/module.js')
     expect(version).toBe('0.0.0')