@sellable/mcp 0.1.225 → 0.1.226

package/dist/tools/leads.js

@@ -63,6 +63,47 @@ const prospeoCompanySearchTokenRefs = new Map();
 let prospeoCompanySearchTokenRefCounter = 0;
 const PROSPEO_COMPANY_SEARCH_TOKEN_REF_PREFIX = "mcp-prospeo-company-search-token:";
 const MAX_PROSPEO_COMPANY_SEARCH_TOKEN_REFS = 200;
+const PROSPEO_LARGE_TITLE_INCLUDE_BOOLEAN_THRESHOLD = 8;
+const prospeoCompanyKeywordIncludeAliases = new Map([
+    ["ai", "artificial intelligence"],
+    ["api", "application programming interface"],
+    ["gtm", "go to market"],
+    ["saas", "software as a service"],
+]);
+const prospeoCompanyIcpRegionAliases = new Map([
+    ["north america", ["United States", "Canada"]],
+    ["na", ["United States", "Canada"]],
+    ["us", ["United States"]],
+    ["usa", ["United States"]],
+    ["u.s.", ["United States"]],
+    ["u.s.a.", ["United States"]],
+]);
+const prospeoCompanyIcpDepartments = new Set([
+    "Consumers",
+    "Customer Success",
+    "Data",
+    "Design",
+    "Engineering",
+    "Finance",
+    "HR",
+    "IT",
+    "Legal",
+    "Marketing",
+    "Operations",
+    "Procurement",
+    "SMB Owners",
+    "Sales",
+    "Security",
+]);
+const prospeoKeyCustomerCompanionFilters = [
+    "company_attributes",
+    "company_headcount_range",
+    "company_headcount_custom",
+    "company_industry",
+    "company_keywords",
+    "company_website_search",
+    "company_icp",
+];
 const prospeoFilterValueSchema = {
     type: "object",
     description: "Include/exclude list filter (values must match Prospeo enums)",
@@ -2375,13 +2416,185 @@ function normalizeProspeoCompanySearchInputForMcp(input) {
             !Array.isArray(lookalike) &&
             "company_oids" in lookalike) {
             delete lookalike.company_oids;
+            removeEmptyObjectFilter(filters, "company_lookalike");
         }
     }
+    normalizeMcpCompanyKeywords(filters);
+    normalizeMcpCompanyIcp(filters);
+    stripMcpDuplicateCompanyIndustry(filters);
+    stripMcpKeyCustomerCompanionFilters(filters);
     return {
         ...input,
         filters,
     };
 }
+function normalizeProspeoSearchInputForMcp(input) {
+    const filters = input?.filters && typeof input.filters === "object"
+        ? clonePlainObject(input.filters)
+        : {};
+    normalizeMcpPersonJobTitle(filters);
+    return {
+        ...input,
+        filters,
+    };
+}
+function normalizeMcpCompanyKeywords(filters) {
+    const keywords = filters.company_keywords;
+    if (!isPlainObject(keywords)) {
+        return;
+    }
+    const include = normalizeStringArray(keywords.include).map((keyword) => {
+        const alias = prospeoCompanyKeywordIncludeAliases.get(keyword.toLowerCase());
+        return alias ?? keyword;
+    });
+    const validInclude = include.filter((keyword) => keyword.length >= 3);
+    if (validInclude.length > 0) {
+        keywords.include = uniqueStrings(validInclude);
+    }
+    else {
+        delete keywords.include;
+        delete keywords.exclude;
+    }
+    if (keywords.exclude !== undefined && validInclude.length === 0) {
+        delete keywords.exclude;
+    }
+    removeEmptyObjectFilter(filters, "company_keywords");
+}
+function normalizeMcpCompanyIcp(filters) {
+    const icp = filters.company_icp;
+    if (!isPlainObject(icp)) {
+        return;
+    }
+    const scope = typeof icp.geographic_scope === "string"
+        ? icp.geographic_scope.trim()
+        : "";
+    const scopeMarkets = expandMcpCompanyIcpMarket(scope);
+    if (scopeMarkets.length > 0) {
+        icp.geographic_scope = "multi_country";
+        icp.geographic_markets = uniqueStrings([
+            ...scopeMarkets,
+            ...normalizeMcpCompanyIcpMarkets(icp.geographic_markets),
+        ]);
+    }
+    else if (scope &&
+        scope !== "single_country" &&
+        scope !== "multi_country") {
+        delete icp.geographic_scope;
+    }
+    if (icp.geographic_markets !== undefined) {
+        icp.geographic_markets = normalizeMcpCompanyIcpMarkets(icp.geographic_markets);
+        if (Array.isArray(icp.geographic_markets) &&
+            icp.geographic_markets.length === 0) {
+            delete icp.geographic_markets;
+        }
+    }
+    normalizeMcpCompanyIcpDepartments(icp);
+    removeEmptyObjectFilter(filters, "company_icp");
+}
+function normalizeMcpCompanyIcpDepartments(icp) {
+    const departments = icp.departments;
+    if (Array.isArray(departments)) {
+        const valid = departments
+            .filter((department) => typeof department === "string")
+            .filter((department) => prospeoCompanyIcpDepartments.has(department));
+        if (valid.length > 0) {
+            icp.departments = uniqueStrings(valid);
+        }
+        else {
+            delete icp.departments;
+        }
+        return;
+    }
+    if (!isPlainObject(departments)) {
+        return;
+    }
+    const include = normalizeStringArray(departments.include).filter((department) => prospeoCompanyIcpDepartments.has(department));
+    const exclude = normalizeStringArray(departments.exclude).filter((department) => prospeoCompanyIcpDepartments.has(department));
+    if (include.length > 0) {
+        departments.include = uniqueStrings(include);
+    }
+    else {
+        delete departments.include;
+    }
+    if (exclude.length > 0) {
+        departments.exclude = uniqueStrings(exclude);
+    }
+    else {
+        delete departments.exclude;
+    }
+    if (departments.include === undefined && departments.exclude === undefined) {
+        delete icp.departments;
+    }
+}
+function normalizeMcpCompanyIcpMarkets(input) {
+    const markets = normalizeStringArray(input);
+    return uniqueStrings(markets.flatMap(expandMcpCompanyIcpMarket));
+}
+function expandMcpCompanyIcpMarket(market) {
+    const trimmed = market.trim();
+    if (!trimmed) {
+        return [];
+    }
+    return prospeoCompanyIcpRegionAliases.get(trimmed.toLowerCase()) ?? [trimmed];
+}
+function stripMcpDuplicateCompanyIndustry(filters) {
+    const icp = filters.company_icp;
+    if (isPlainObject(icp) &&
+        Array.isArray(icp.industries) &&
+        icp.industries.length > 0) {
+        delete filters.company_industry;
+    }
+}
+function stripMcpKeyCustomerCompanionFilters(filters) {
+    const keyCustomers = filters.company_key_customers;
+    if (!isPlainObject(keyCustomers)) {
+        return;
+    }
+    const include = normalizeStringArray(keyCustomers.include);
+    if (include.length === 0) {
+        return;
+    }
+    for (const filterName of prospeoKeyCustomerCompanionFilters) {
+        delete filters[filterName];
+    }
+}
+function normalizeMcpPersonJobTitle(filters) {
+    const jobTitle = filters.person_job_title;
+    if (!isPlainObject(jobTitle)) {
+        return;
+    }
+    const include = normalizeStringArray(jobTitle.include);
+    const exclude = normalizeStringArray(jobTitle.exclude);
+    if (include.length > PROSPEO_LARGE_TITLE_INCLUDE_BOOLEAN_THRESHOLD &&
+        exclude.length === 0 &&
+        typeof jobTitle.boolean_search !== "string") {
+        delete jobTitle.include;
+        jobTitle.boolean_search = include
+            .map((title) => `"${title.replace(/"/g, '\\"')}"`)
+            .join(" OR ");
+    }
+}
+function isPlainObject(input) {
+    return Boolean(input) && typeof input === "object" && !Array.isArray(input);
+}
+function normalizeStringArray(input) {
+    if (!Array.isArray(input)) {
+        return [];
+    }
+    return input
+        .filter((value) => typeof value === "string")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+}
+function uniqueStrings(input) {
+    return Array.from(new Set(input));
+}
+function removeEmptyObjectFilter(filters, filterName) {
+    const filter = filters[filterName];
+    if (isPlainObject(filter) && Object.keys(filter).length === 0) {
+        delete filters[filterName];
+    }
+}
 function clonePlainObject(input) {
     return JSON.parse(JSON.stringify(input));
 }
@@ -2514,7 +2727,8 @@ export async function searchProspeo(input) {
         nestedCompany?.names !== undefined) {
         throw new Error("search_prospeo does not accept filters.company.websites or filters.company.names. For known accounts, resolve names/domains into a domainFilterId with load_csv_domains or save_domain_filters. For company/account lookalikes, use search_prospeo_companies first, then confirm_prospeo_company_accounts.");
     }
-    const response = await api.post(`/api/v3/prospeo/search`, input);
+    const safeInput = normalizeProspeoSearchInputForMcp(input);
+    const response = await api.post(`/api/v3/prospeo/search`, safeInput);
     return compactProspeoSearchResponse(response);
 }
 function compactProspeoSearchResponse(response) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.225",
+  "version": "0.1.226",
   "type": "module",
   "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
   "main": "dist/index.js",

package/skills/create-campaign/SKILL.md

@@ -219,7 +219,6 @@ Package-backed MCP may return a short `mcp-prospeo-company-search-token:*`
 reference to avoid long-token copy errors. Account rows are not people leads
 yet. The confirmation creates the `domainFilterId` that constrains the follow-on
 `search_prospeo` people search.
-Always copy the `companySearchToken` exactly.
 
 Prospeo company/account search is useful when the source plan depends on
 website traffic (`company_website_traffic`), confirmed AI Attributes including