@coldiq/mcp 5.4.3 → 5.4.5

package/src/provider-availability.ts

@@ -6,11 +6,15 @@
  * configured and testable while public routing and tool schemas omit them.
  */
 const DISABLED_PROVIDERS = new Set([
+  'blitzapi',
   'companyenrich',
   'people-data-labs',
 ])
 
 const PROVIDER_ALIASES: Record<string, string> = {
+  blitz: 'blitzapi',
+  'blitz-api': 'blitzapi',
+  'blitzapi-reverse-email': 'blitzapi',
   'company-enrich': 'companyenrich',
   'companyenrich-props': 'companyenrich',
   pdl: 'people-data-labs',

package/src/registry.ts

@@ -3,6 +3,12 @@
 // ---------------------------------------------------------------------------
 
 import { isProviderEnabled } from './provider-availability.js'
+import {
+  isAiArkCompanySearchApplicable,
+  isAiArkPeopleSearchApplicable,
+  mapAiArkCompanySearchParams,
+  mapAiArkPeopleSearchParams,
+} from './ai-ark-mapping.js'
 
 export interface AsyncConfig {
   /** Build the poll endpoint path from the ID returned by the create call */
@@ -1069,37 +1075,8 @@ const searchCompaniesProviders: ProviderEntry[] = [
     endpoint: '/ai-ark/companies',
     method: 'POST',
     priority: 18,
-    isApplicable: (input) =>
-      isNonEmptyArray(input.keywords) ||
-      isNonEmptyArray(input.industries) ||
-      isNonEmptyArray(input.countries),
-    mapParams: (input) => ({
-      body: {
-        account: {
-          ...(isNonEmptyArray(input.industries) && {
-            industries: { any: { include: input.industries } },
-          }),
-          ...(isNonEmptyArray(input.countries) && {
-            location: { any: { include: (input.countries as string[]).map(isoCountryToName) } },
-          }),
-          ...((input.min_employees !== undefined || input.max_employees !== undefined) && {
-            employeeSize: {
-              type: 'RANGE',
-              range: [{ start: input.min_employees, end: input.max_employees }],
-            },
-          }),
-          ...(isNonEmptyArray(input.funding_stages) && {
-            funding: { stage: { include: input.funding_stages } },
-          }),
-        },
-        ...(isNonEmptyArray(input.keywords) && {
-          contact: {
-            keywordsInProfile: { any: { include: input.keywords } },
-          },
-        }),
-        size: Math.min((input.limit as number | undefined) ?? 10, 100),
-      },
-    }),
+    isApplicable: isAiArkCompanySearchApplicable,
+    mapParams: (input) => mapAiArkCompanySearchParams(input, isoCountryToName),
     hasResult: (data) => {
       const d = data as Record<string, unknown>
       return isNonEmptyArray(d.content)
@@ -1518,29 +1495,8 @@ const findPeopleProviders: ProviderEntry[] = [
     endpoint: '/ai-ark/people',
     method: 'POST',
     priority: 8,
-    isApplicable: (input) =>
-      isNonEmptyArray(input.job_titles) ||
-      isNonEmptyArray(input.seniorities) ||
-      isNonEmptyArray(input.keywords),
-    mapParams: (input) => ({
-      body: {
-        contact: {
-          ...(isNonEmptyArray(input.job_titles) && {
-            departmentAndFunction: { any: { include: input.job_titles } },
-          }),
-          ...(isNonEmptyArray(input.seniorities) && {
-            seniority: { any: { include: input.seniorities } },
-          }),
-          ...(isNonEmptyArray(input.locations) && {
-            location: { any: { include: input.locations } },
-          }),
-          ...(isNonEmptyArray(input.keywords) && {
-            keywordsInProfile: { any: { include: input.keywords } },
-          }),
-        },
-        size: Math.min((input.limit as number | undefined) ?? 10, 100),
-      },
-    }),
+    isApplicable: isAiArkPeopleSearchApplicable,
+    mapParams: mapAiArkPeopleSearchParams,
     hasResult: (data) => {
       const d = data as Record<string, unknown>
       return isNonEmptyArray(d.content)

package/src/tool-json-schema.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod'
+
+const ToolInputJsonSchema = z.object({
+  type: z.literal('object'),
+  properties: z.json().optional(),
+}).passthrough()
+
+/** Convert a tool input schema without widening Zod object contracts. */
+export function toOpenApiInputSchema(schema: z.ZodObject) {
+  const generated = z.toJSONSchema(schema, {
+    target: 'openapi-3.0',
+    io: 'input',
+    override: ({ zodSchema, jsonSchema }) => {
+      if (zodSchema instanceof z.ZodObject && jsonSchema.additionalProperties === undefined) {
+        jsonSchema.additionalProperties = false
+      }
+    },
+  })
+
+  return ToolInputJsonSchema.parse(generated)
+}

package/src/tools/call-endpoint.ts

@@ -16,7 +16,7 @@ export const callEndpointSchema = {
   method: z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']).optional()
     .describe('HTTP method from search_endpoints. Set this when one path supports more than one method.'),
   params: z
-    .record(z.unknown())
+    .record(z.string(), z.unknown())
     .optional()
     .describe('Provider-native request params (request body fields, plus any path/query params), as shown in get_endpoint_details.'),
 }

package/src/tools/find-influencers.ts

@@ -13,7 +13,7 @@ export const findInfluencersSchema = {
     .describe('Target platform.'),
   limit: z.number().int().min(1).max(100).default(25)
     .describe('Max creators to return (1–100). Pricing is returned in the response credit headers.'),
-  page: z.number().int().min(1).default(1).optional()
+  page: z.number().int().min(1).optional().meta({ default: 1 })
     .describe('Page number for pagination.'),
   sort_by: z.enum(['relevancy', 'number_of_followers', 'engagement_rate']).optional(),
   sort_order: z.enum(['asc', 'desc']).optional(),

package/src/tools/search-knowledge.ts

@@ -26,8 +26,8 @@ export const searchKnowledgeSchema = {
     .int()
     .min(1)
     .max(15)
-    .default(5)
     .optional()
+    .meta({ default: 5 })
     .describe('Maximum ranked documents to return (default 5, max 15).'),
 }
 

package/src/utils/provider-resolver.ts

@@ -202,14 +202,14 @@ const GATED_DESCRIPTIONS: Partial<Record<Capability, Partial<Record<string, Gate
     'linkupapi-fundraising': { kind: 'requires',         fields: 'funding filters and keywords or industries' },
     'linkupapi-hiring':      { kind: 'requires',         fields: 'is_hiring: true' },
     'prospeo-search-company': { kind: 'requires',        fields: 'keywords, industries, or countries' },
-    'ai-ark-companies':      { kind: 'requires',         fields: 'keywords, industries, or countries' },
+    'ai-ark-companies':      { kind: 'requires',         fields: 'keywords, industries, countries, similar_to_domains, funding_stages, or employee range' },
   },
   // -------------------------------------------------------------------------
   find_people: {
     'linkupapi-search-profiles': { kind: 'incompatible_with', fields: 'company_linkedin_urls or company_domains (this provider only works without company filters)' },
     'sumble-people-find':    { kind: 'requires',         fields: 'company_domains or company_linkedin_urls, and job_titles or seniorities' },
     'prospeo-search-person': { kind: 'requires',         fields: 'job_titles or company_domains' },
-    'ai-ark-people':         { kind: 'requires',         fields: 'job_titles, seniorities, or keywords' },
+    'ai-ark-people':         { kind: 'requires',         fields: 'job_titles, seniorities, keywords, locations, or company identifiers' },
     'findymail-search-employees': { kind: 'requires',    fields: 'company_domains and job_titles' },
     'fullenrich-people-search': { kind: 'requires',      fields: 'company_domains (upstream does not accept LinkedIn URL filters)' },
     pdl:                     { kind: 'requires',         fields: 'company_domains, company_linkedin_urls, job_titles, or seniorities' },

package/tests/gtm/harness.ts

@@ -1,10 +1,10 @@
 import Anthropic from '@anthropic-ai/sdk'
-import { zodToJsonSchema } from 'zod-to-json-schema'
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import * as url from 'node:url'
 
 import { MODEL_PROFILES } from '../../../src/agent/model-policy.js'
+import { toOpenApiInputSchema } from '../../src/tool-json-schema.js'
 import { MCP_TOOLS } from './tools-bridge.js'
 
 export interface ToolCall {
@@ -49,7 +49,7 @@ export async function runAgent(options: RunAgentOptions): Promise<AgentResult> {
   const anthropicTools: Anthropic.Tool[] = MCP_TOOLS.map((t) => ({
     name: t.name,
     description: t.description,
-    input_schema: zodToJsonSchema(t.schema, { target: 'openApi3' }) as Anthropic.Tool['input_schema'],
+    input_schema: toOpenApiInputSchema(t.schema),
   }))
 
   const messages: Anthropic.MessageParam[] = [{ role: 'user', content: prompt }]

package/tests/provider-availability.test.ts

@@ -2,10 +2,13 @@ import { describe, expect, it } from 'vitest'
 import { isProviderEnabled as isWorkerProviderEnabled } from '../../src/lib/provider-availability.js'
 import { isProviderEnabled } from '../src/provider-availability.js'
 import { getConfiguredProviders, getProviders, type Capability } from '../src/registry.js'
+import { enrichCompanySchema } from '../src/tools/enrich-company.js'
+import { enrichPersonSchema } from '../src/tools/enrich-person.js'
 import { findEmailSchema } from '../src/tools/find-email.js'
 import { findEmailsSchema } from '../src/tools/find-emails.js'
 import { findEmailsBulkSchema } from '../src/tools/find-emails-bulk.js'
 import { getEndpointDetailsSchema } from '../src/tools/get-endpoint-details.js'
+import { searchCompaniesSchema } from '../src/tools/search-companies.js'
 import { listDataSourcesHandler } from '../src/tools/list-data-sources.js'
 import {
   FIND_EMAILS_PROVIDERS,
@@ -36,6 +39,12 @@ const CAPABILITIES: Capability[] = [
 describe('standalone MCP provider availability', () => {
   it('mirrors every disabled-provider alias from the Worker policy', () => {
     for (const alias of [
+      'blitzapi',
+      'BlitzAPI',
+      'Blitz API',
+      'Blitz',
+      'blitzapi-reverse-email',
+      'blitzapi_reverse_email',
       'companyenrich',
       'CompanyEnrich',
       'Company Enrich',
@@ -58,12 +67,17 @@ describe('standalone MCP provider availability', () => {
     expect(getConfiguredProviders('find_people').some((provider) => provider.id === 'pdl')).toBe(true)
     expect(getConfiguredProviders('search_companies').some((provider) => provider.id === 'companyenrich')).toBe(true)
     expect(getConfiguredProviders('enrich_company').some((provider) => provider.id === 'companyenrich_props')).toBe(true)
+    expect(getConfiguredProviders('search_companies').some((provider) => provider.id === 'blitzapi')).toBe(true)
+    expect(getConfiguredProviders('enrich_company').some((provider) => provider.id === 'blitzapi')).toBe(true)
+    expect(getConfiguredProviders('enrich_person').some((provider) => provider.id === 'blitzapi-reverse-email')).toBe(true)
 
     for (const capability of CAPABILITIES) {
       expect(getProviders(capability).every((provider) => isProviderEnabled(provider.id))).toBe(true)
     }
     expect(FIND_EMAILS_PROVIDERS.every(isProviderEnabled)).toBe(true)
     expect(getProvidersForCapability('find_people')).not.toContain('pdl')
+    expect(getProvidersForCapability('search_companies')).not.toContain('blitzapi')
+    expect(getProvidersForCapability('enrich_person')).not.toContain('blitzapi-reverse-email')
   })
 
   it('rejects an explicit disabled-provider pin without advertising it as available', () => {
@@ -72,6 +86,9 @@ describe('standalone MCP provider availability', () => {
       ['find_emails', 'pdl-person-enrich'],
       ['search_companies', 'companyenrich'],
       ['enrich_company', 'companyenrich_props'],
+      ['search_companies', 'blitzapi'],
+      ['enrich_company', 'blitzapi'],
+      ['enrich_person', 'blitzapi-reverse-email'],
     ] as const) {
       const result = resolvePreferredProviders(capability, {}, [provider])
       expect(result.ok).toBe(false)
@@ -92,11 +109,15 @@ describe('standalone MCP provider availability', () => {
       findEmailsSchema.max_credits.description,
       findEmailsBulkSchema.max_credits.description,
       getEndpointDetailsSchema.api.description,
+      searchCompaniesSchema.use_providers.description,
+      enrichCompanySchema.use_providers.description,
+      enrichPersonSchema.use_providers.description,
     ].join('\n').toLowerCase()
 
     expect(publicMetadata).not.toContain('people data labs')
     expect(publicMetadata).not.toMatch(/\bpdl\b/)
     expect(publicMetadata).not.toContain('companyenrich')
     expect(publicMetadata).not.toContain('/companyenrich')
+    expect(publicMetadata).not.toMatch(/\bblitz(api)?\b/)
   })
 })

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/tool-json-schema.test.ts

@@ -0,0 +1,93 @@
+import { readdirSync, readFileSync } from 'node:fs'
+import { describe, expect, it } from 'vitest'
+import { z } from 'zod'
+
+import { toOpenApiInputSchema } from '../src/tool-json-schema.js'
+import { MCP_TOOLS } from './gtm/tools-bridge.js'
+
+const PublicToolSchema = z.record(z.string(), z.instanceof(z.ZodType))
+
+describe('public MCP tool JSON schemas', () => {
+  it('converts every registered public tool schema', async () => {
+    const toolFiles = readdirSync(new URL('../src/tools/', import.meta.url))
+      .filter((file) => file.endsWith('.ts'))
+      .sort()
+    const indexSource = readFileSync(new URL('../src/index.ts', import.meta.url), 'utf8')
+
+    expect(indexSource.match(/server\.tool\(/g)).toHaveLength(toolFiles.length)
+
+    for (const file of toolFiles) {
+      const exports = await import(new URL(`../src/tools/${file}`, import.meta.url).href)
+      const schemaEntries = Object.entries(exports).filter(([name]) => name.endsWith('Schema'))
+      const nameEntries = Object.entries(exports).filter(([name]) => name.endsWith('Name'))
+
+      expect(schemaEntries, file).toHaveLength(1)
+      expect(nameEntries, file).toHaveLength(1)
+
+      const schema = toOpenApiInputSchema(z.object(PublicToolSchema.parse(schemaEntries[0][1])))
+      expect(schema, z.string().parse(nameEntries[0][1])).toMatchObject({
+        type: 'object',
+        additionalProperties: false,
+        properties: expect.any(Object),
+      })
+    }
+  })
+
+  it('converts every tool schema without widening object inputs', () => {
+    for (const tool of MCP_TOOLS) {
+      const schema = toOpenApiInputSchema(tool.schema)
+
+      expect(schema, tool.name).toMatchObject({
+        type: 'object',
+        additionalProperties: false,
+        properties: expect.any(Object),
+      })
+      expect(schema, tool.name).not.toHaveProperty('$schema')
+    }
+  })
+
+  it('closes only Zod objects and does not change record or default data', () => {
+    const schema = toOpenApiInputSchema(z.object({
+      nested: z.object({ value: z.string() }),
+      labels: z.record(z.string(), z.string()),
+      settings: z.object({ type: z.literal('object') }).default({ type: 'object' }),
+    }))
+
+    expect(schema).toMatchObject({
+      properties: {
+        nested: { additionalProperties: false },
+        labels: { additionalProperties: { type: 'string' } },
+        settings: {
+          additionalProperties: false,
+          default: { type: 'object' },
+        },
+      },
+    })
+  })
+
+  it('preserves required fields, defaults, limits, and optional defaults', () => {
+    const tool = MCP_TOOLS.find((candidate) => candidate.name === 'find_influencers')
+    expect(tool).toBeDefined()
+    if (!tool) throw new Error('find_influencers is not registered')
+
+    const schema = toOpenApiInputSchema(tool.schema)
+
+    expect(schema.required).toEqual(['platform'])
+    expect(schema).toMatchObject({
+      properties: {
+        limit: {
+          type: 'integer',
+          minimum: 1,
+          maximum: 100,
+          default: 25,
+        },
+        page: {
+          type: 'integer',
+          minimum: 1,
+          default: 1,
+        },
+      },
+    })
+    expect(schema.properties?.page).not.toHaveProperty('nullable')
+  })
+})

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')