@coldiq/mcp 5.4.4 → 5.4.5

package/dist/tools/search-jobs.d.ts

@@ -2,39 +2,71 @@ import { z } from 'zod';
 export declare const searchJobsName = "search_jobs";
 export declare const searchJobsDescription = "Search live job postings as a GTM buying signal \u2014 find companies hiring for specific roles, on specific ATS platforms, in specific regions. Filter routing is automatic: ATS slugs and company-domain filters route to broad career-site coverage (175k+ company sites, 54 ATS platforms); LinkedIn-only filters (seniority, industry, employee count, easy apply) route to LinkedIn. Shared filters (title, location, description, work arrangement, employment type, taxonomies) work everywhere. For aggregated hiring activity at the company level (e.g. \"X is hiring fast\"), use find_signals(signal_type=\"hiring\") instead. Default limit: 25.";
 export declare const searchJobsSchema: {
-    title_keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude_title_keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    locations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude_locations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    description_keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude_description_keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    companies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude_companies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    title_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_title_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_description_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    companies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_companies: z.ZodOptional<z.ZodArray<z.ZodString>>;
     remote: z.ZodOptional<z.ZodBoolean>;
     exclude_agencies: z.ZodOptional<z.ZodBoolean>;
     posted_after: z.ZodOptional<z.ZodString>;
-    time_range: z.ZodDefault<z.ZodOptional<z.ZodEnum<["1h", "24h", "7d", "6m"]>>>;
+    time_range: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        "1h": "1h";
+        "24h": "24h";
+        "7d": "7d";
+        "6m": "6m";
+    }>>>;
     include_description: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    employment_types: z.ZodOptional<z.ZodArray<z.ZodEnum<["FULL_TIME", "PART_TIME", "CONTRACTOR", "TEMPORARY", "INTERN", "VOLUNTEER", "PER_DIEM", "OTHER"]>, "many">>;
-    work_arrangements: z.ZodOptional<z.ZodArray<z.ZodEnum<["On-site", "Hybrid", "Remote OK", "Remote Solely"]>, "many">>;
-    experience_levels: z.ZodOptional<z.ZodArray<z.ZodEnum<["0-2", "2-5", "5-10", "10+"]>, "many">>;
+    employment_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        FULL_TIME: "FULL_TIME";
+        PART_TIME: "PART_TIME";
+        CONTRACTOR: "CONTRACTOR";
+        TEMPORARY: "TEMPORARY";
+        INTERN: "INTERN";
+        VOLUNTEER: "VOLUNTEER";
+        PER_DIEM: "PER_DIEM";
+        OTHER: "OTHER";
+    }>>>;
+    work_arrangements: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "On-site": "On-site";
+        Hybrid: "Hybrid";
+        "Remote OK": "Remote OK";
+        "Remote Solely": "Remote Solely";
+    }>>>;
+    experience_levels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "0-2": "0-2";
+        "2-5": "2-5";
+        "5-10": "5-10";
+        "10+": "10+";
+    }>>>;
     has_salary: z.ZodOptional<z.ZodBoolean>;
     has_visa_sponsorship: z.ZodOptional<z.ZodBoolean>;
-    taxonomies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    taxonomies: z.ZodOptional<z.ZodArray<z.ZodString>>;
     limit: z.ZodDefault<z.ZodNumber>;
-    ats_slugs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude_ats_slugs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    company_domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude_company_domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    seniority_levels: z.ZodOptional<z.ZodArray<z.ZodEnum<["Entry level", "Associate", "Mid-Senior level", "Director", "Executive", "Internship", "Not Applicable"]>, "many">>;
-    industries: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    organization_slugs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude_organization_slugs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ats_slugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_ats_slugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    company_domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_company_domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    seniority_levels: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "Entry level": "Entry level";
+        Associate: "Associate";
+        "Mid-Senior level": "Mid-Senior level";
+        Director: "Director";
+        Executive: "Executive";
+        Internship: "Internship";
+        "Not Applicable": "Not Applicable";
+    }>>>;
+    industries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    organization_slugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_organization_slugs: z.ZodOptional<z.ZodArray<z.ZodString>>;
     min_employees: z.ZodOptional<z.ZodNumber>;
     max_employees: z.ZodOptional<z.ZodNumber>;
     easy_apply_only: z.ZodOptional<z.ZodBoolean>;
     exclude_easy_apply: z.ZodOptional<z.ZodBoolean>;
-    use_providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    use_providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare function searchJobsHandler(input: Record<string, unknown>): Promise<{
     content: [{

package/dist/tools/search-jobs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-jobs.d.ts","sourceRoot":"","sources":["../../src/tools/search-jobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,cAAc,gBAAgB,CAAA;AAE3C,eAAO,MAAM,qBAAqB,moBACulB,CAAA;AAEznB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC5B,CAAA;AAED,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAErE"}
+{"version":3,"file":"search-jobs.d.ts","sourceRoot":"","sources":["../../src/tools/search-jobs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,cAAc,gBAAgB,CAAA;AAE3C,eAAO,MAAM,qBAAqB,moBACulB,CAAA;AAEznB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC5B,CAAA;AAED,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAErE"}

package/dist/tools/search-knowledge.d.ts

@@ -3,8 +3,12 @@ export declare const searchKnowledgeName = "search_knowledge";
 export declare const searchKnowledgeDescription: string;
 export declare const searchKnowledgeSchema: {
     query: z.ZodString;
-    types: z.ZodOptional<z.ZodArray<z.ZodEnum<["play", "provider", "strategy"]>, "many">>;
-    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        provider: "provider";
+        play: "play";
+        strategy: "strategy";
+    }>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
 };
 export declare function searchKnowledgeHandler(input: Record<string, unknown>): Promise<{
     content: {

package/dist/tools/search-knowledge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-knowledge.d.ts","sourceRoot":"","sources":["../../src/tools/search-knowledge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,mBAAmB,qBAAqB,CAAA;AAErD,eAAO,MAAM,0BAA0B,QAIkF,CAAA;AAEzH,eAAO,MAAM,qBAAqB;;;;CAiBjC,CAAA;AAED,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;GAgB1E"}
+{"version":3,"file":"search-knowledge.d.ts","sourceRoot":"","sources":["../../src/tools/search-knowledge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,mBAAmB,qBAAqB,CAAA;AAErD,eAAO,MAAM,0BAA0B,QAIkF,CAAA;AAEzH,eAAO,MAAM,qBAAqB;;;;;;;;CAiBjC,CAAA;AAED,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;GAgB1E"}

package/dist/tools/search-knowledge.js

@@ -21,8 +21,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).'),
 };
 export async function searchKnowledgeHandler(input) {

package/dist/tools/search-knowledge.js.map

@@ -1 +1 @@
-{"version":3,"file":"search-knowledge.js","sourceRoot":"","sources":["../../src/tools/search-knowledge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAU,CAAA;AACrE,MAAM,2BAA2B,GAAG,CAAC,MAAM,EAAE,UAAU,CAAU,CAAA;AAEjE,MAAM,CAAC,MAAM,mBAAmB,GAAG,kBAAkB,CAAA;AAErD,MAAM,CAAC,MAAM,0BAA0B,GACrC,gHAAgH;IAChH,kHAAkH;IAClH,iHAAiH;IACjH,uHAAuH,CAAA;AAEzH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,QAAQ,CAAC,sGAAsG,CAAC;IACnH,KAAK,EAAE,CAAC;SACL,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;SAClC,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,EAAE;SACV,QAAQ,CAAC,oJAAoJ,CAAC;IACjK,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,GAAG,EAAE;SACL,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,EAAE,CAAC;SACP,OAAO,CAAC,CAAC,CAAC;SACV,QAAQ,EAAE;SACV,QAAQ,CAAC,yDAAyD,CAAC;CACvE,CAAA;AAED,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,KAA8B;IACzE,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,MAAM,EAAE,mBAAmB,EAAE;QACrD,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC,GAAG,2BAA2B,CAAC;QACtD,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAC,CAAA;IACF,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QACZ,OAAO;YACL,OAAO,EAAE,CAAC;oBACR,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,yBAAyB,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC;iBAC/E,CAAC;YACF,OAAO,EAAE,IAAI;SACd,CAAA;IACH,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAA;AACjF,CAAC"}
+{"version":3,"file":"search-knowledge.js","sourceRoot":"","sources":["../../src/tools/search-knowledge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,MAAM,mBAAmB,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAU,CAAA;AACrE,MAAM,2BAA2B,GAAG,CAAC,MAAM,EAAE,UAAU,CAAU,CAAA;AAEjE,MAAM,CAAC,MAAM,mBAAmB,GAAG,kBAAkB,CAAA;AAErD,MAAM,CAAC,MAAM,0BAA0B,GACrC,gHAAgH;IAChH,kHAAkH;IAClH,iHAAiH;IACjH,uHAAuH,CAAA;AAEzH,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,QAAQ,CAAC,sGAAsG,CAAC;IACnH,KAAK,EAAE,CAAC;SACL,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;SAClC,GAAG,CAAC,CAAC,CAAC;SACN,QAAQ,EAAE;SACV,QAAQ,CAAC,oJAAoJ,CAAC;IACjK,KAAK,EAAE,CAAC;SACL,MAAM,EAAE;SACR,GAAG,EAAE;SACL,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,EAAE,CAAC;SACP,QAAQ,EAAE;SACV,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;SACpB,QAAQ,CAAC,yDAAyD,CAAC;CACvE,CAAA;AAED,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,KAA8B;IACzE,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,MAAM,EAAE,mBAAmB,EAAE;QACrD,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,CAAC,GAAG,2BAA2B,CAAC;QACtD,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAC,CAAA;IACF,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QACZ,OAAO;YACL,OAAO,EAAE,CAAC;oBACR,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,yBAAyB,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC;iBAC/E,CAAC;YACF,OAAO,EAAE,IAAI;SACd,CAAA;IACH,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAA;AACjF,CAAC"}

package/dist/tools/search-places.d.ts

@@ -6,31 +6,39 @@ export declare const searchPlacesSchema: {
     country: z.ZodOptional<z.ZodString>;
     city: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodNumber>;
-    provider: z.ZodOptional<z.ZodEnum<["openmart", "google_maps"]>>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        openmart: "openmart";
+        google_maps: "google_maps";
+    }>>;
     state: z.ZodOptional<z.ZodString>;
     zip_code: z.ZodOptional<z.ZodString>;
     lat: z.ZodOptional<z.ZodNumber>;
     long: z.ZodOptional<z.ZodNumber>;
     geo_radius: z.ZodOptional<z.ZodNumber>;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     min_overall_rating: z.ZodOptional<z.ZodNumber>;
     max_overall_rating: z.ZodOptional<z.ZodNumber>;
     min_total_reviews: z.ZodOptional<z.ZodNumber>;
     max_total_reviews: z.ZodOptional<z.ZodNumber>;
-    ownership_type: z.ZodOptional<z.ZodEnum<["INDEPENDENT", "FAMILY", "FRANCHISE", "CHAIN"]>>;
+    ownership_type: z.ZodOptional<z.ZodEnum<{
+        INDEPENDENT: "INDEPENDENT";
+        FAMILY: "FAMILY";
+        FRANCHISE: "FRANCHISE";
+        CHAIN: "CHAIN";
+    }>>;
     has_website: z.ZodOptional<z.ZodBoolean>;
     has_valid_website: z.ZodOptional<z.ZodBoolean>;
     has_contact_info: z.ZodOptional<z.ZodBoolean>;
     min_price_tier: z.ZodOptional<z.ZodNumber>;
     max_price_tier: z.ZodOptional<z.ZodNumber>;
-    include_keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude_keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    exclude_root_domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    start_urls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    include_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude_root_domains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    start_urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
     include_opening_hours: z.ZodOptional<z.ZodBoolean>;
     include_additional_info: z.ZodOptional<z.ZodBoolean>;
     language: z.ZodOptional<z.ZodString>;
-    use_providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    use_providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare function searchPlacesHandler(input: Record<string, unknown>): Promise<{
     content: [{

package/dist/tools/search-places.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-places.d.ts","sourceRoot":"","sources":["../../src/tools/search-places.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB,kBAAkB,CAAA;AAE/C,eAAO,MAAM,uBAAuB,slBAC0hB,CAAA;AAE9jB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC9B,CAAA;AAED,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAIvE"}
+{"version":3,"file":"search-places.d.ts","sourceRoot":"","sources":["../../src/tools/search-places.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB,kBAAkB,CAAA;AAE/C,eAAO,MAAM,uBAAuB,slBAC0hB,CAAA;AAE9jB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC9B,CAAA;AAED,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAIvE"}

package/dist/tools/search-reddit.d.ts

@@ -2,18 +2,37 @@ import { z } from 'zod';
 export declare const searchRedditName = "search_reddit";
 export declare const searchRedditDescription = "Scrape Reddit posts, comments, communities, or users via 1 provider (Reddit Scraper). Provide subreddit/post/user URLs and/or a keyword query. Optionally scope a query to one community, sort, filter by time, include comments, and limit by date. Async (~30\u2013120s). Pricing is returned in the response credit headers.";
 export declare const searchRedditSchema: {
-    start_urls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    start_urls: z.ZodOptional<z.ZodArray<z.ZodString>>;
     query: z.ZodOptional<z.ZodString>;
-    search_type: z.ZodDefault<z.ZodEnum<["posts", "comments", "communities", "users"]>>;
+    search_type: z.ZodDefault<z.ZodEnum<{
+        posts: "posts";
+        comments: "comments";
+        communities: "communities";
+        users: "users";
+    }>>;
     search_community_name: z.ZodOptional<z.ZodString>;
-    sort: z.ZodOptional<z.ZodEnum<["relevance", "hot", "top", "new", "rising", "comments"]>>;
-    time: z.ZodOptional<z.ZodEnum<["hour", "day", "week", "month", "year", "all"]>>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        comments: "comments";
+        relevance: "relevance";
+        hot: "hot";
+        top: "top";
+        new: "new";
+        rising: "rising";
+    }>>;
+    time: z.ZodOptional<z.ZodEnum<{
+        hour: "hour";
+        day: "day";
+        week: "week";
+        month: "month";
+        year: "year";
+        all: "all";
+    }>>;
     limit: z.ZodDefault<z.ZodNumber>;
     max_comments: z.ZodOptional<z.ZodNumber>;
     include_comments: z.ZodOptional<z.ZodBoolean>;
     post_date_limit: z.ZodOptional<z.ZodString>;
     comment_date_limit: z.ZodOptional<z.ZodString>;
-    use_providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    use_providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare function searchRedditHandler(input: Record<string, unknown>): Promise<{
     content: [{

package/dist/tools/search-reddit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-reddit.d.ts","sourceRoot":"","sources":["../../src/tools/search-reddit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB,kBAAkB,CAAA;AAE/C,eAAO,MAAM,uBAAuB,oUAC0R,CAAA;AAE9T,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;CAwB9B,CAAA;AAED,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAEvE"}
+{"version":3,"file":"search-reddit.d.ts","sourceRoot":"","sources":["../../src/tools/search-reddit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB,kBAAkB,CAAA;AAE/C,eAAO,MAAM,uBAAuB,oUAC0R,CAAA;AAE9T,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwB9B,CAAA;AAED,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAEvE"}

package/dist/tools/search-seo.d.ts

@@ -2,25 +2,50 @@ import { z } from 'zod';
 export declare const searchSeoName = "search_seo";
 export declare const searchSeoDescription: string;
 export declare const searchSeoSchema: {
-    category: z.ZodEnum<["keywords", "serp", "backlinks", "domain", "labs", "page"]>;
+    category: z.ZodEnum<{
+        keywords: "keywords";
+        domain: "domain";
+        page: "page";
+        serp: "serp";
+        backlinks: "backlinks";
+        labs: "labs";
+    }>;
     target: z.ZodOptional<z.ZodString>;
     keyword: z.ZodOptional<z.ZodString>;
-    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
     location: z.ZodOptional<z.ZodString>;
     language: z.ZodOptional<z.ZodString>;
     limit: z.ZodDefault<z.ZodNumber>;
     date_from: z.ZodOptional<z.ZodString>;
     date_to: z.ZodOptional<z.ZodString>;
     time_range: z.ZodOptional<z.ZodString>;
-    engine: z.ZodDefault<z.ZodEnum<["google", "bing", "youtube"]>>;
-    device: z.ZodOptional<z.ZodEnum<["desktop", "mobile"]>>;
-    action: z.ZodOptional<z.ZodEnum<["technologies", "whois"]>>;
-    lab_action: z.ZodOptional<z.ZodEnum<["ranked-keywords", "competitors", "keyword-ideas", "rank-overview"]>>;
+    engine: z.ZodDefault<z.ZodEnum<{
+        google: "google";
+        youtube: "youtube";
+        bing: "bing";
+    }>>;
+    device: z.ZodOptional<z.ZodEnum<{
+        mobile: "mobile";
+        desktop: "desktop";
+    }>>;
+    action: z.ZodOptional<z.ZodEnum<{
+        technologies: "technologies";
+        whois: "whois";
+    }>>;
+    lab_action: z.ZodOptional<z.ZodEnum<{
+        "rank-overview": "rank-overview";
+        "ranked-keywords": "ranked-keywords";
+        competitors: "competitors";
+        "keyword-ideas": "keyword-ideas";
+    }>>;
     url: z.ZodOptional<z.ZodString>;
-    page_action: z.ZodDefault<z.ZodEnum<["lighthouse", "content"]>>;
+    page_action: z.ZodDefault<z.ZodEnum<{
+        content: "content";
+        lighthouse: "lighthouse";
+    }>>;
     enable_javascript: z.ZodOptional<z.ZodBoolean>;
     full_data: z.ZodOptional<z.ZodBoolean>;
-    use_providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    use_providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare function searchSeoHandler(input: Record<string, unknown>): Promise<{
     content: [{

package/dist/tools/search-seo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-seo.d.ts","sourceRoot":"","sources":["../../src/tools/search-seo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,aAAa,eAAe,CAAA;AAEzC,eAAO,MAAM,oBAAoB,QAQiD,CAAA;AAElF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;CAoC3B,CAAA;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAEpE"}
+{"version":3,"file":"search-seo.d.ts","sourceRoot":"","sources":["../../src/tools/search-seo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,aAAa,eAAe,CAAA;AAEzC,eAAO,MAAM,oBAAoB,QAQiD,CAAA;AAElF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC3B,CAAA;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAEpE"}

package/dist/tools/search-web.d.ts

@@ -5,8 +5,13 @@ export declare const searchWebSchema: {
     query: z.ZodString;
     num_results: z.ZodDefault<z.ZodNumber>;
     country: z.ZodOptional<z.ZodString>;
-    search_type: z.ZodDefault<z.ZodEnum<["general", "neural", "deep", "deep-reasoning"]>>;
-    use_providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    search_type: z.ZodDefault<z.ZodEnum<{
+        deep: "deep";
+        "deep-reasoning": "deep-reasoning";
+        general: "general";
+        neural: "neural";
+    }>>;
+    use_providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare function searchWebHandler(input: Record<string, unknown>): Promise<{
     content: [{

package/dist/tools/search-web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search-web.d.ts","sourceRoot":"","sources":["../../src/tools/search-web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,aAAa,eAAe,CAAA;AAEzC,eAAO,MAAM,oBAAoB,QAIsE,CAAA;AAEvG,eAAO,MAAM,eAAe;;;;;;CAM3B,CAAA;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAEpE"}
+{"version":3,"file":"search-web.d.ts","sourceRoot":"","sources":["../../src/tools/search-web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,aAAa,eAAe,CAAA;AAEzC,eAAO,MAAM,oBAAoB,QAIsE,CAAA;AAEvG,eAAO,MAAM,eAAe;;;;;;;;;;;CAM3B,CAAA;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;GAEpE"}

package/dist/tools/verify-email.d.ts

@@ -3,7 +3,7 @@ export declare const verifyEmailName = "verify_email";
 export declare const verifyEmailDescription = "Check whether an email address is valid and deliverable. Returns a normalized `status` field \u2014 one of \"valid\", \"invalid\", \"catch_all\", \"risky\", \"disposable\", \"unknown\" \u2014 alongside the raw provider response. BounceBan leads the waterfall: it resolves catch-all and risky addresses without sending (the gap most verifiers leave as \"unknown\"); if it cannot conclude, the chain falls through to leadmagic, findymail, icypeas, instantly, and linkupapi. Findymail only distinguishes valid vs invalid. Use before cold outreach to protect sender reputation. ColdIQ automatically runs the waterfall \u2014 pass use_providers only if you need a specific tool.";
 export declare const verifyEmailSchema: {
     email: z.ZodString;
-    use_providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    use_providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare function verifyEmailHandler(input: Record<string, unknown>): Promise<{
     content: [{

package/dist/tools/verify-emails-bulk.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 export declare const verifyEmailsBulkName = "verify_emails_bulk";
 export declare const verifyEmailsBulkDescription: string;
 export declare const verifyEmailsBulkSchema: {
-    emails: z.ZodArray<z.ZodString, "many">;
-    use_providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    emails: z.ZodArray<z.ZodString>;
+    use_providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
     webhook_url: z.ZodOptional<z.ZodString>;
 };
 export declare function verifyEmailsBulkHandler(input: Record<string, unknown>): Promise<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldiq/mcp",
-  "version": "5.4.4",
+  "version": "5.4.5",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -21,14 +21,16 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
     "undici": "^6.25.0",
-    "zod": "^3.24.2"
+    "zod": "4.5.4"
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.52.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
-    "vitest": "^3.1.3",
-    "zod-to-json-schema": "^3.25.0"
+    "vitest": "^3.1.3"
+  },
+  "overrides": {
+    "vite": "6.4.3"
   }
 }

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/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')
+  })
+})