@sellable/mcp 0.1.225 → 0.1.227

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)",
@@ -2363,11 +2404,12 @@ function removeUndefinedValues(input) {
     return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
 }
 function normalizeProspeoCompanySearchInputForMcp(input) {
+    const seedCompanies = normalizeMcpSeeds(input.seedCompanies, "company");
+    const seedDomains = normalizeMcpSeeds(input.seedDomains, "domain");
     const filters = input?.filters && typeof input.filters === "object"
         ? clonePlainObject(input.filters)
         : {};
-    const hasSeeds = (input.seedCompanies?.length ?? 0) > 0 ||
-        (input.seedDomains?.length ?? 0) > 0;
+    const hasSeeds = seedCompanies.length > 0 || seedDomains.length > 0;
     if (hasSeeds) {
         const lookalike = filters.company_lookalike;
         if (lookalike &&
@@ -2375,13 +2417,233 @@ function normalizeProspeoCompanySearchInputForMcp(input) {
             !Array.isArray(lookalike) &&
             "company_oids" in lookalike) {
             delete lookalike.company_oids;
+            removeEmptyObjectFilter(filters, "company_lookalike");
         }
     }
+    normalizeMcpCompanyKeywords(filters);
+    normalizeMcpCompanyWebsiteSearch(filters);
+    normalizeMcpCompanyIcp(filters);
+    stripMcpDuplicateCompanyIndustry(filters);
+    stripMcpSeededLookalikeRiskyRefinements(filters, hasSeeds);
+    stripMcpKeyCustomerCompanionFilters(filters);
     return {
         ...input,
+        seedCompanies: seedCompanies.length > 0 ? seedCompanies : undefined,
+        seedDomains: seedDomains.length > 0 ? seedDomains : undefined,
         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 normalizeMcpCompanyWebsiteSearch(filters) {
+    const websiteSearch = filters.company_website_search;
+    if (!isPlainObject(websiteSearch)) {
+        return;
+    }
+    const includeKeywords = normalizeStringArray(websiteSearch.include_keywords);
+    const hasPositiveWebsiteSignal = includeKeywords.length > 0 ||
+        normalizeStringArray(websiteSearch.url_contains).length > 0 ||
+        normalizeStringArray(websiteSearch.urls).length > 0 ||
+        Object.entries(websiteSearch).some(([key, value]) => key.startsWith("has_") && typeof value === "boolean" && value);
+    if (!hasPositiveWebsiteSignal) {
+        delete websiteSearch.exclude_keywords;
+    }
+    removeEmptyObjectFilter(filters, "company_website_search");
+}
+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 stripMcpSeededLookalikeRiskyRefinements(filters, hasSeeds) {
+    if (!hasSeeds || !isPlainObject(filters.company_lookalike)) {
+        return;
+    }
+    const icp = filters.company_icp;
+    if (isPlainObject(icp) &&
+        Array.isArray(icp.industries) &&
+        icp.industries.length > 0 &&
+        !filters.company_industry) {
+        filters.company_industry = { include: icp.industries };
+    }
+    delete filters.company_icp;
+    delete filters.company_keywords;
+    delete filters.company_website_search;
+}
+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 normalizeMcpSeeds(input, kind) {
+    return uniqueStrings(normalizeStringArray(input).filter((seed) => kind === "domain" ? isLikelyConcreteDomain(seed) : isLikelyConcreteSeedCompany(seed)));
+}
+function isLikelyConcreteDomain(input) {
+    return /^[a-z0-9.-]+\.[a-z]{2,}$/i.test(input);
+}
+function isLikelyConcreteSeedCompany(input) {
+    const normalized = input.toLowerCase();
+    return !(normalized.includes("placeholder") ||
+        normalized.includes("another approved") ||
+        normalized.includes("approved seed") ||
+        normalized.includes("best-customer seed") ||
+        normalized.includes("example seed"));
+}
+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 +2776,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.227",
   "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
@@ -253,6 +252,12 @@ without an include keyword, and do not duplicate `company_industry` when
 search, prefer `person_job_title.boolean_search` for long role synonym lists
 instead of many `person_job_title.include` values plus broad department/seniority
 filters.
+For seeded company lookalikes, keep the first call simple: resolved seed
+company/domain plus `company_lookalike.minimum_tier` and simple confirmed
+attributes, headcount, or industry. Do not add `company_website_search`,
+`company_keywords`, or `company_icp` until the account sample proves the seed
+works. Do not send placeholder seed names like `another approved best-customer seed`,
+and only use concrete companies or domains you actually resolved. Do not send `company_website_search.exclude_keywords` without a positive website include signal.
 Do not use `AI`, `API`, `GTM`, or `SaaS` as company keyword terms.
 Do not combine `company_key_customers` with ICP, website-search, keyword,
 attribute, industry, or headcount filters until the standalone pass proves

package/skills/find-leads/SKILL.md

@@ -427,6 +427,12 @@ Use first for broad persona expansion, ABM/domain targeting, hiring-led targetin
 - Do not send `company_keywords.exclude` unless at least one include keyword is
   present. Do not duplicate `company_industry` when `company_icp.industries`
   already carries the industry.
+- For seeded company lookalikes, keep the first call simple: resolved seed
+  company/domain plus `company_lookalike.minimum_tier` and simple confirmed
+  attributes, headcount, or industry. Do not add `company_website_search`,
+  `company_keywords`, or `company_icp` until the account sample proves the seed
+  works. Do not send placeholder seed names like `another approved best-customer seed`,
+  and only use concrete companies or domains you actually resolved. Do not send `company_website_search.exclude_keywords` without a positive website include signal.
 - Do not use `company_intent`. Do not invent unsupported support-channel filters
   or AI Attribute guesses like phone/email/chat/ticket/social.
 - Company/account search returns an account sample only; account rows are not people leads yet. Ask the user to approve the account sample.

package/skills/providers/prospeo.md

@@ -106,6 +106,9 @@ Avoidable-400 guardrails:
 - Do not use `AI`, `API`, `GTM`, or `SaaS` as company keyword terms. Use confirmed attributes such as `uses_ai` / `has_api`, or spell out `artificial intelligence`, `application programming interface`, `go to market`, and `software as a service`.
 - Do not send `company_keywords.exclude` unless at least one include keyword is present.
 - Do not duplicate `company_industry` when `company_icp.industries` already carries the industry.
+- For seeded company lookalikes, keep the first call simple: seed company/domain + `company_lookalike.minimum_tier` + confirmed attributes, headcount, or industry. Do not add `company_website_search`, `company_keywords`, or `company_icp` until the account sample proves the seed works.
+- Do not send placeholder seed names such as `another approved best-customer seed`; use only concrete company names or domains you have actually resolved.
+- Do not send `company_website_search.exclude_keywords` without a positive website include signal.
 - For post-confirm people search, prefer `person_job_title.boolean_search` for long role synonym lists instead of many `person_job_title.include` values plus broad department/seniority filters.
 
 Unsupported/caveats:
@@ -249,6 +252,7 @@ Preference rules:
 - `company_keywords.include/exclude` values must be at least 3 characters; use `artificial intelligence` instead of `AI`, or use confirmed attributes such as `uses_ai` when that is the real signal.
 - Do not use `AI`, `API`, `GTM`, or `SaaS` as company keyword terms; use longer phrases such as `artificial intelligence`, `application programming interface`, `go to market`, or `software as a service`.
 - Run `company_key_customers` as a standalone first-pass filter. Do not combine `company_key_customers` with ICP, website-search, keyword, attribute, industry, or headcount filters until the standalone pass proves useful.
+- For seeded lookalikes, avoid first-call `company_website_search`, `company_keywords`, and `company_icp`; use resolved seeds plus lookalike tier and simple attributes/headcount/industry first.
 
 ### Person Filters