@coldiq/mcp 5.4.4 → 5.4.6

package/src/index.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { McpServer, type ToolCallback } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { z } from 'zod'
 import { initClient } from './client.js'
 import { MCP_SERVER_INSTRUCTIONS } from './instructions.js'
 import { withKnowledgeFirstRequirement } from './knowledge-policy.js'
@@ -220,48 +221,61 @@ const server = new McpServer(
   },
 )
 
+function registerPublicTool<Fields extends Record<string, z.ZodType>>(
+  name: string,
+  description: string,
+  schema: Fields,
+  handler: ToolCallback<z.ZodObject<Fields>>,
+): void {
+  const inputSchema = z.strictObject(schema)
+  server.registerTool<never, typeof inputSchema>(name, {
+    description,
+    inputSchema,
+  }, handler)
+}
+
 // Register knowledge retrieval before every operational tool so clients that
 // preserve registration order surface the mandatory prerequisite first.
-server.tool(searchKnowledgeName, searchKnowledgeDescription, searchKnowledgeSchema, searchKnowledgeHandler)
-server.tool(searchCompaniesName, withKnowledgeFirstRequirement(searchCompaniesDescription), searchCompaniesSchema, searchCompaniesHandler)
-server.tool(findPeopleName, withKnowledgeFirstRequirement(findPeopleDescription), findPeopleSchema, findPeopleHandler)
-server.tool(findEmailName, withKnowledgeFirstRequirement(findEmailDescription), findEmailSchema, findEmailHandler)
-server.tool(enrichPersonName, withKnowledgeFirstRequirement(enrichPersonDescription), enrichPersonSchema, enrichPersonHandler)
-server.tool(findEmailsName, withKnowledgeFirstRequirement(findEmailsDescription), findEmailsSchema, findEmailsHandler)
-server.tool(verifyEmailName, withKnowledgeFirstRequirement(verifyEmailDescription), verifyEmailSchema, verifyEmailHandler)
-server.tool(verifyEmailsBulkName, withKnowledgeFirstRequirement(verifyEmailsBulkDescription), verifyEmailsBulkSchema, verifyEmailsBulkHandler)
-server.tool(findEmailsBulkName, withKnowledgeFirstRequirement(findEmailsBulkDescription), findEmailsBulkSchema, findEmailsBulkHandler)
-server.tool(enrichPersonBulkName, withKnowledgeFirstRequirement(enrichPersonBulkDescription), enrichPersonBulkSchema, enrichPersonBulkHandler)
-server.tool(enrichCompanyBulkName, withKnowledgeFirstRequirement(enrichCompanyBulkDescription), enrichCompanyBulkSchema, enrichCompanyBulkHandler)
-server.tool(findPhoneBulkName, withKnowledgeFirstRequirement(findPhoneBulkDescription), findPhoneBulkSchema, findPhoneBulkHandler)
-server.tool(getBulkJobName, withKnowledgeFirstRequirement(getBulkJobDescription), getBulkJobSchema, getBulkJobHandler)
-server.tool(cancelBulkJobName, withKnowledgeFirstRequirement(cancelBulkJobDescription), cancelBulkJobSchema, cancelBulkJobHandler)
-server.tool(findPhoneName, withKnowledgeFirstRequirement(findPhoneDescription), findPhoneSchema, findPhoneHandler)
-server.tool(enrichCompanyName, withKnowledgeFirstRequirement(enrichCompanyDescription), enrichCompanySchema, enrichCompanyHandler)
-server.tool(searchWebName, withKnowledgeFirstRequirement(searchWebDescription), searchWebSchema, searchWebHandler)
-server.tool(searchJobsName, withKnowledgeFirstRequirement(searchJobsDescription), searchJobsSchema, searchJobsHandler)
-server.tool(searchAdsName, withKnowledgeFirstRequirement(searchAdsDescription), searchAdsSchema, searchAdsHandler)
-server.tool(searchPlacesName, withKnowledgeFirstRequirement(searchPlacesDescription), searchPlacesSchema, searchPlacesHandler)
-server.tool(findInfluencersName, withKnowledgeFirstRequirement(findInfluencersDescription), findInfluencersSchema, findInfluencersHandler)
-server.tool(searchRedditName, withKnowledgeFirstRequirement(searchRedditDescription), searchRedditSchema, searchRedditHandler)
-server.tool(searchSeoName, withKnowledgeFirstRequirement(searchSeoDescription), searchSeoSchema, searchSeoHandler)
-server.tool(findSignalsName, withKnowledgeFirstRequirement(findSignalsDescription), findSignalsSchema, findSignalsHandler)
-server.tool(fetchPageContentName, withKnowledgeFirstRequirement(fetchPageContentDescription), fetchPageContentSchema, fetchPageContentHandler)
-server.tool(getCreditBalanceName, getCreditBalanceDescription, getCreditBalanceSchema, getCreditBalanceHandler)
-server.tool(getSessionUsageName, getSessionUsageDescription, getSessionUsageSchema, getSessionUsageHandler)
-server.tool(listDataSourcesName, withKnowledgeFirstRequirement(listDataSourcesDescription), listDataSourcesSchema, listDataSourcesHandler)
-server.tool(listSkillsName, listSkillsDescription, listSkillsSchema, listSkillsHandler)
-server.tool(loadSkillName, loadSkillDescription, loadSkillSchema, loadSkillHandler)
-server.tool(extractPostEngagementName, withKnowledgeFirstRequirement(extractPostEngagementDescription), extractPostEngagementSchema, extractPostEngagementHandler)
-server.tool(getPlaceReviewsName, withKnowledgeFirstRequirement(getPlaceReviewsDescription), getPlaceReviewsSchema, getPlaceReviewsHandler)
+registerPublicTool(searchKnowledgeName, searchKnowledgeDescription, searchKnowledgeSchema, searchKnowledgeHandler)
+registerPublicTool(searchCompaniesName, withKnowledgeFirstRequirement(searchCompaniesDescription), searchCompaniesSchema, searchCompaniesHandler)
+registerPublicTool(findPeopleName, withKnowledgeFirstRequirement(findPeopleDescription), findPeopleSchema, findPeopleHandler)
+registerPublicTool(findEmailName, withKnowledgeFirstRequirement(findEmailDescription), findEmailSchema, findEmailHandler)
+registerPublicTool(enrichPersonName, withKnowledgeFirstRequirement(enrichPersonDescription), enrichPersonSchema, enrichPersonHandler)
+registerPublicTool(findEmailsName, withKnowledgeFirstRequirement(findEmailsDescription), findEmailsSchema, findEmailsHandler)
+registerPublicTool(verifyEmailName, withKnowledgeFirstRequirement(verifyEmailDescription), verifyEmailSchema, verifyEmailHandler)
+registerPublicTool(verifyEmailsBulkName, withKnowledgeFirstRequirement(verifyEmailsBulkDescription), verifyEmailsBulkSchema, verifyEmailsBulkHandler)
+registerPublicTool(findEmailsBulkName, withKnowledgeFirstRequirement(findEmailsBulkDescription), findEmailsBulkSchema, findEmailsBulkHandler)
+registerPublicTool(enrichPersonBulkName, withKnowledgeFirstRequirement(enrichPersonBulkDescription), enrichPersonBulkSchema, enrichPersonBulkHandler)
+registerPublicTool(enrichCompanyBulkName, withKnowledgeFirstRequirement(enrichCompanyBulkDescription), enrichCompanyBulkSchema, enrichCompanyBulkHandler)
+registerPublicTool(findPhoneBulkName, withKnowledgeFirstRequirement(findPhoneBulkDescription), findPhoneBulkSchema, findPhoneBulkHandler)
+registerPublicTool(getBulkJobName, withKnowledgeFirstRequirement(getBulkJobDescription), getBulkJobSchema, getBulkJobHandler)
+registerPublicTool(cancelBulkJobName, withKnowledgeFirstRequirement(cancelBulkJobDescription), cancelBulkJobSchema, cancelBulkJobHandler)
+registerPublicTool(findPhoneName, withKnowledgeFirstRequirement(findPhoneDescription), findPhoneSchema, findPhoneHandler)
+registerPublicTool(enrichCompanyName, withKnowledgeFirstRequirement(enrichCompanyDescription), enrichCompanySchema, enrichCompanyHandler)
+registerPublicTool(searchWebName, withKnowledgeFirstRequirement(searchWebDescription), searchWebSchema, searchWebHandler)
+registerPublicTool(searchJobsName, withKnowledgeFirstRequirement(searchJobsDescription), searchJobsSchema, searchJobsHandler)
+registerPublicTool(searchAdsName, withKnowledgeFirstRequirement(searchAdsDescription), searchAdsSchema, searchAdsHandler)
+registerPublicTool(searchPlacesName, withKnowledgeFirstRequirement(searchPlacesDescription), searchPlacesSchema, searchPlacesHandler)
+registerPublicTool(findInfluencersName, withKnowledgeFirstRequirement(findInfluencersDescription), findInfluencersSchema, findInfluencersHandler)
+registerPublicTool(searchRedditName, withKnowledgeFirstRequirement(searchRedditDescription), searchRedditSchema, searchRedditHandler)
+registerPublicTool(searchSeoName, withKnowledgeFirstRequirement(searchSeoDescription), searchSeoSchema, searchSeoHandler)
+registerPublicTool(findSignalsName, withKnowledgeFirstRequirement(findSignalsDescription), findSignalsSchema, findSignalsHandler)
+registerPublicTool(fetchPageContentName, withKnowledgeFirstRequirement(fetchPageContentDescription), fetchPageContentSchema, fetchPageContentHandler)
+registerPublicTool(getCreditBalanceName, getCreditBalanceDescription, getCreditBalanceSchema, getCreditBalanceHandler)
+registerPublicTool(getSessionUsageName, getSessionUsageDescription, getSessionUsageSchema, getSessionUsageHandler)
+registerPublicTool(listDataSourcesName, withKnowledgeFirstRequirement(listDataSourcesDescription), listDataSourcesSchema, listDataSourcesHandler)
+registerPublicTool(listSkillsName, listSkillsDescription, listSkillsSchema, listSkillsHandler)
+registerPublicTool(loadSkillName, loadSkillDescription, loadSkillSchema, loadSkillHandler)
+registerPublicTool(extractPostEngagementName, withKnowledgeFirstRequirement(extractPostEngagementDescription), extractPostEngagementSchema, extractPostEngagementHandler)
+registerPublicTool(getPlaceReviewsName, withKnowledgeFirstRequirement(getPlaceReviewsDescription), getPlaceReviewsSchema, getPlaceReviewsHandler)
 // ColdIQ Visitor ID: read the leads identified on the account's own websites.
 // Listing the websites themselves needs no tool — search_endpoints/call_endpoint
 // already reach GET /visitor-id/websites.
-server.tool(getWebsiteVisitorsName, withKnowledgeFirstRequirement(getWebsiteVisitorsDescription), getWebsiteVisitorsSchema, getWebsiteVisitorsHandler)
+registerPublicTool(getWebsiteVisitorsName, withKnowledgeFirstRequirement(getWebsiteVisitorsDescription), getWebsiteVisitorsSchema, getWebsiteVisitorsHandler)
 // Generic endpoint discovery + invoke: reach any integrated provider without a dedicated tool.
-server.tool(searchEndpointsName, withKnowledgeFirstRequirement(searchEndpointsDescription), searchEndpointsSchema, searchEndpointsHandler)
-server.tool(getEndpointDetailsName, withKnowledgeFirstRequirement(getEndpointDetailsDescription), getEndpointDetailsSchema, getEndpointDetailsHandler)
-server.tool(callEndpointName, withKnowledgeFirstRequirement(callEndpointDescription), callEndpointSchema, callEndpointHandler)
+registerPublicTool(searchEndpointsName, withKnowledgeFirstRequirement(searchEndpointsDescription), searchEndpointsSchema, searchEndpointsHandler)
+registerPublicTool(getEndpointDetailsName, withKnowledgeFirstRequirement(getEndpointDetailsDescription), getEndpointDetailsSchema, getEndpointDetailsHandler)
+registerPublicTool(callEndpointName, withKnowledgeFirstRequirement(callEndpointDescription), callEndpointSchema, callEndpointHandler)
 
 // Connect via stdio transport
 const transport = new StdioServerTransport()

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/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/instructions.test.ts

@@ -50,7 +50,7 @@ describe('MCP knowledge-first policy', () => {
     const indexPath = fileURLToPath(new URL('../src/index.ts', import.meta.url))
     const registrations = readFileSync(indexPath, 'utf8')
       .split('\n')
-      .filter((line) => line.trimStart().startsWith('server.tool('))
+      .filter((line) => line.trimStart().startsWith('registerPublicTool('))
     const unguardedCompatibilityTools = [
       'getCreditBalanceName',
       'getSessionUsageName',
@@ -58,9 +58,9 @@ describe('MCP knowledge-first policy', () => {
       'loadSkillName',
     ]
 
-    expect(registrations[0]).toContain('server.tool(searchKnowledgeName, searchKnowledgeDescription')
+    expect(registrations[0]).toContain('registerPublicTool(searchKnowledgeName, searchKnowledgeDescription')
     for (const registration of registrations.slice(1)) {
-      if (unguardedCompatibilityTools.some((name) => registration.includes(`server.tool(${name},`))) continue
+      if (unguardedCompatibilityTools.some((name) => registration.includes(`registerPublicTool(${name},`))) continue
       expect(registration).toContain('withKnowledgeFirstRequirement(')
     }
   })

package/tests/sdk-zod4-compatibility.test.ts

@@ -0,0 +1,59 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { afterEach, describe, expect, it } from 'vitest'
+import { z } from 'zod'
+
+describe('MCP SDK Zod 4 compatibility', () => {
+  const closeCallbacks: Array<() => Promise<void>> = []
+
+  afterEach(async () => {
+    await Promise.all(closeCallbacks.splice(0).map((close) => close()))
+  })
+
+  it('publishes populated input properties and required fields over the wire', async () => {
+    const server = new McpServer({ name: 'schema-contract-server', version: '1.0.0' })
+    server.registerTool(
+      'schema_contract',
+      {
+        description: 'Verify Zod 4 tool schema conversion.',
+        inputSchema: z.strictObject({
+          platform: z.enum(['linkedin', 'instagram']),
+          limit: z.number().int().min(1).max(100).default(25),
+        }),
+      },
+      async () => ({ content: [{ type: 'text', text: 'ok' }] }),
+    )
+
+    const client = new Client({ name: 'schema-contract-client', version: '1.0.0' })
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+    closeCallbacks.push(() => client.close(), () => server.close())
+
+    await server.connect(serverTransport)
+    await client.connect(clientTransport)
+
+    const result = await client.listTools()
+    expect(result.tools).toHaveLength(1)
+    expect(result.tools[0]?.inputSchema).toMatchObject({
+      type: 'object',
+      properties: {
+        platform: { type: 'string', enum: ['linkedin', 'instagram'] },
+        limit: { type: 'integer', minimum: 1, maximum: 100, default: 25 },
+      },
+      required: ['platform'],
+      additionalProperties: false,
+    })
+
+    const invalidCall = await client.callTool({
+      name: 'schema_contract',
+      arguments: { platform: 'linkedin', unexpected: true },
+    })
+    expect(invalidCall.isError).toBe(true)
+    expect(invalidCall.content).toEqual([
+      expect.objectContaining({
+        type: 'text',
+        text: expect.stringContaining('Unrecognized key: "unexpected"'),
+      }),
+    ])
+  })
+})

package/tests/tool-json-schema.test.ts

@@ -0,0 +1,94 @@
+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(/registerPublicTool\(/g)).toHaveLength(toolFiles.length)
+    expect(indexSource).not.toContain('server.tool(')
+
+    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')
+  })
+})