@sellable/mcp 0.1.257 → 0.1.259

package/dist/tools/leads.js

@@ -4,7 +4,7 @@ import { getApi, SellableApiError } from "../api.js";
 import { resolveSkillsDir } from "../skills.js";
 import { resolveWorkspaceRoot } from "../utils/workspace-root.js";
 import { buildCsvDomainPreview, matchesConfirmationToken, parseConfirmationToken, projectCsvCarryRows, } from "./csv-domains.js";
-import { loadCsvDncEntries, } from "./csv-dnc.js";
+import { listDncEntries, loadCsvDncEntries, } from "./csv-dnc.js";
 import { buildCsvLinkedinPreview, matchesLinkedinConfirmationToken, parseLinkedinConfirmationToken, uploadCsvLinkedinFile, } from "./csv-linkedin.js";
 import { assertInteractionApproval } from "./interaction-mode.js";
 import { assertProviderPromptLoaded, markProviderPromptLoaded, } from "./provider-preflight.js";
@@ -1149,6 +1149,109 @@ Approval card should say:
         targetEngagerCount: effectiveTargetEngagerCount,
     };
 }
+function hasUsableSignalValidationPost(post) {
+    if (!post)
+        return false;
+    const likes = post.engagement?.likes ?? 0;
+    const comments = post.engagement?.comments ?? 0;
+    const shares = post.engagement?.shares ?? 0;
+    return Boolean(post.url ||
+        post.content?.trim() ||
+        post.author?.name?.trim() ||
+        likes > 0 ||
+        comments > 0 ||
+        shares > 0);
+}
+function signalImportPostKey(post) {
+    return normalizePostUrl(post.url) || post.url.trim().toLowerCase();
+}
+function compactSignalValidationReason(value) {
+    const text = typeof value === "string"
+        ? value
+        : value instanceof Error
+            ? value.message
+            : "";
+    const compacted = text.replace(/\s+/g, " ").trim();
+    return compacted
+        ? compacted.slice(0, 220)
+        : "Post lookup returned no usable post details.";
+}
+function describeSignalPostValidationError(error) {
+    if (error instanceof SellableApiError) {
+        try {
+            const parsed = JSON.parse(error.body);
+            return compactSignalValidationReason(parsed.details ?? parsed.error);
+        }
+        catch {
+            return compactSignalValidationReason(error.body);
+        }
+    }
+    return compactSignalValidationReason(error);
+}
+function invalidSignalPostExamples(posts) {
+    return posts
+        .slice(0, 3)
+        .map((post) => {
+        const label = post.author.name || post.keyword || "Selected post";
+        return `${label}: ${post.url}`;
+    })
+        .join("; ");
+}
+function serializeInvalidSignalPosts(posts) {
+    return posts.map((post) => ({
+        id: post.id,
+        url: post.url,
+        authorName: post.author.name,
+        keyword: post.keyword,
+        reason: post.reason,
+    }));
+}
+async function validateSelectedSignalPostsForImport(api, posts) {
+    const results = await Promise.all(posts.map(async (post) => {
+        if (!post.url.trim()) {
+            return {
+                post,
+                valid: false,
+                reason: "Selected post is missing a LinkedIn URL.",
+            };
+        }
+        try {
+            const response = await api.post("/api/v1/signal-discovery/search-signals", {
+                type: "post",
+                postUrl: post.url,
+            });
+            const valid = response.success !== false &&
+                Array.isArray(response.posts) &&
+                response.posts.some(hasUsableSignalValidationPost);
+            return valid
+                ? { post, valid: true }
+                : {
+                    post,
+                    valid: false,
+                    reason: "Post lookup returned no usable post details.",
+                };
+        }
+        catch (error) {
+            if (error instanceof SellableApiError &&
+                (error.isAuthError || error.status === 429 || error.guidance)) {
+                throw error;
+            }
+            return {
+                post,
+                valid: false,
+                reason: describeSignalPostValidationError(error),
+            };
+        }
+    }));
+    return {
+        validPosts: results
+            .filter((result) => result.valid)
+            .map((result) => result.post),
+        invalidPosts: results
+            .filter((result) => !result.valid)
+            .map((result) => ({ ...result.post, reason: result.reason })),
+    };
+}
 function normalizeImportProvider(provider) {
     if (provider === "apollo-ai" || provider === "apollo")
         return "apollo";
@@ -1477,6 +1580,41 @@ export const leadToolDefinitions = [
             required: ["filePath"],
         },
     },
+    {
+        name: "list_dnc_entries",
+        description: "Show the active workspace's current Sellable DNC count, list names, and a compact page of entries through the workspace-scoped DNC endpoint. Use this when the user asks to show/check the current DNC list, count, or first page before importing. This is Sellable DNC used by DNC Check, not provider source-list routing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                page: {
+                    type: "number",
+                    description: "Page to read. Defaults to 1.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Entries per page. Defaults to 25. Backend hard cap is 100.",
+                },
+                search: {
+                    type: "string",
+                    description: "Optional search across domain, LinkedIn username, or entry name.",
+                },
+                listName: {
+                    type: "string",
+                    description: "Optional Sellable DNC list name filter.",
+                },
+                sourceType: {
+                    type: "string",
+                    enum: ["all", "manual", "hubspot"],
+                    description: "Optional source filter. Defaults to all Sellable DNC entries.",
+                },
+                includeDeleted: {
+                    type: "boolean",
+                    description: "Include deleted/disabled source entries when true. Defaults to false.",
+                },
+            },
+            required: [],
+        },
+    },
     {
         name: "load_csv_dnc_entries",
         description: "Preview and confirm pasted text, pasted CSV, or a CSV file of domains and LinkedIn profile URLs, then add the valid entries to the active workspace's Sellable DNC list. This is the blocklist/suppression-list path. It reuses Sellable's workspace-scoped DNC endpoints and the campaign DNC Check column, not provider search filters or source-list workarounds.",
@@ -1928,6 +2066,10 @@ export const leadToolDefinitions = [
                     type: "number",
                     description: "Signal Discovery: optional hard cap on selected posts to scrape after ranking selected posts by engagement. Values above 10 are clamped to the backend hard cap.",
                 },
+                allowInvalidSignalPosts: {
+                    type: "boolean",
+                    description: "Signal Discovery: set true only after the user explicitly approves continuing when import_leads reports that one or more planned posts no longer fetch. Invalid posts are skipped before scraping.",
+                },
                 rubricGuidelines: {
                     type: "array",
                     items: { type: "string" },
@@ -3384,6 +3526,9 @@ export async function loadCsvLinkedinLeads(input) {
 export async function loadCsvDncEntriesTool(input) {
     return loadCsvDncEntries(input);
 }
+export async function listDncEntriesTool(input = {}) {
+    return listDncEntries(input);
+}
 export async function saveDomainFilters(input) {
     const api = getApi();
     return api.post(`/api/v3/prospeo/domain-filters`, {
@@ -3458,7 +3603,7 @@ export async function searchSignals(input) {
 }
 export async function importLeads(input) {
     const api = getApi();
-    const { campaignOfferId, currentStep, sourceLeadListId: inputSourceLeadListId, searchId, targetLeadCount, mode, searchName, leadListName, headlineICPCriteria, targetEngagerCount, maxPostsToScrape, rubricGuidelines, confirmed, } = input;
+    const { campaignOfferId, currentStep, sourceLeadListId: inputSourceLeadListId, searchId, targetLeadCount, mode, searchName, leadListName, headlineICPCriteria, targetEngagerCount, maxPostsToScrape, allowInvalidSignalPosts, rubricGuidelines, confirmed, } = input;
     assertInteractionApproval({
         campaignId: campaignOfferId,
         action: "import-leads",
@@ -3640,17 +3785,84 @@ export async function importLeads(input) {
         if (uniqueSelectedPosts.length > MAX_SIGNAL_DISCOVERY_POSTS) {
             throw new Error(`Maximum ${MAX_SIGNAL_DISCOVERY_POSTS} Signal Discovery posts can be imported for scraping. ${uniqueSelectedPosts.length} unique posts are currently selected; reduce the selected posts to the strongest ${MAX_SIGNAL_DISCOVERY_POSTS} before calling import_leads.`);
         }
-        const importSelection = selectSignalPostsForImport(uniqueSelectedPosts, {
+        let importSelection = selectSignalPostsForImport(uniqueSelectedPosts, {
             targetEngagerCount: effectiveTargetEngagerCount,
             maxPostsToScrape,
         });
-        const postsToScrape = importSelection.posts;
+        let postsToScrape = importSelection.posts;
         if (!importSelection.targetReached && importSelection.targetEngagerCount) {
             const capClause = importSelection.availableEngagers >= importSelection.targetEngagerCount
                 ? ` The selected posts can cover the target, but maxPostsToScrape=${normalizePositiveInteger(maxPostsToScrape)} prevents reaching it. Increase maxPostsToScrape or remove that cap.`
                 : " Select/promote more right-content posts, run another narrow Signal Discovery search, or switch to Sales Nav recent activity if the lane cannot produce enough source candidates.";
             throw new Error(`Signal Discovery selected posts only cover about ${importSelection.estimatedEngagers.toLocaleString("en-US")} people to check, below the approved ${importSelection.targetEngagerCount.toLocaleString("en-US")} source-candidate target. Do not scrape this under-capacity post set.${capClause}`);
         }
+        const postValidation = await validateSelectedSignalPostsForImport(api, uniqueSelectedPosts);
+        const plannedPostKeys = new Set(postsToScrape.map(signalImportPostKey));
+        const invalidPlannedPosts = postValidation.invalidPosts.filter((post) => plannedPostKeys.has(signalImportPostKey(post)));
+        const skippedInvalidPostWarning = postValidation.invalidPosts.length > 0
+            ? `Skipped ${postValidation.invalidPosts.length.toLocaleString("en-US")} invalid selected post${postValidation.invalidPosts.length === 1 ? "" : "s"} after validation.`
+            : "";
+        if (postValidation.invalidPosts.length > 0 &&
+            postValidation.validPosts.length === 0) {
+            return {
+                provider: "signal-discovery",
+                error: "all_signal_posts_invalid",
+                message: `I checked ${uniqueSelectedPosts.length.toLocaleString("en-US")} selected LinkedIn post${uniqueSelectedPosts.length === 1 ? "" : "s"} before scraping, and none of them currently fetch. Do not call import_leads again with this selected-post set. Run another narrow Signal Discovery search or select replacement posts, then call select_promising_posts before retrying import_leads. Invalid: ${invalidSignalPostExamples(postValidation.invalidPosts)}`,
+                invalidPostCount: postValidation.invalidPosts.length,
+                invalidPosts: serializeInvalidSignalPosts(postValidation.invalidPosts),
+                validSelectedPostCount: 0,
+                recommendedValidPostCount: 0,
+                estimatedValidEngagers: 0,
+                targetEngagerCount: effectiveTargetEngagerCount,
+                suggestedToolCalls: [],
+            };
+        }
+        if (invalidPlannedPosts.length > 0 && !allowInvalidSignalPosts) {
+            const validImportSelection = selectSignalPostsForImport(postValidation.validPosts, {
+                targetEngagerCount: effectiveTargetEngagerCount,
+                maxPostsToScrape,
+            });
+            const validRecommendedCount = validImportSelection.posts.length;
+            const shortfallCopy = validImportSelection.targetEngagerCount &&
+                !validImportSelection.targetReached
+                ? ` The remaining valid selected posts cover about ${validImportSelection.estimatedEngagers.toLocaleString("en-US")} of the approved ${validImportSelection.targetEngagerCount.toLocaleString("en-US")} people-to-check target.`
+                : "";
+            const continueCopy = postValidation.validPosts.length > 0
+                ? `Continue anyway with ${validRecommendedCount.toLocaleString("en-US")} valid post${validRecommendedCount === 1 ? "" : "s"}, or replace the invalid post${invalidPlannedPosts.length === 1 ? "" : "s"} first?`
+                : "No valid selected posts remain. Replace the invalid posts before importing leads.";
+            return {
+                provider: "signal-discovery",
+                needsInvalidPostConfirmation: true,
+                invalidPostCount: invalidPlannedPosts.length,
+                invalidPosts: serializeInvalidSignalPosts(invalidPlannedPosts),
+                validSelectedPostCount: postValidation.validPosts.length,
+                recommendedValidPostCount: validRecommendedCount,
+                estimatedValidEngagers: validImportSelection.estimatedEngagers,
+                targetEngagerCount: effectiveTargetEngagerCount,
+                message: `I checked ${uniqueSelectedPosts.length.toLocaleString("en-US")} selected LinkedIn post${uniqueSelectedPosts.length === 1 ? "" : "s"} before scraping. ${invalidPlannedPosts.length.toLocaleString("en-US")} planned post${invalidPlannedPosts.length === 1 ? "" : "s"} no longer fetch${invalidPlannedPosts.length === 1 ? "es" : ""}, so starting the scrape as-is could break the flow. ${continueCopy}${shortfallCopy} Invalid: ${invalidSignalPostExamples(invalidPlannedPosts)}`,
+                suggestedToolCalls: postValidation.validPosts.length > 0
+                    ? [
+                        {
+                            tool: "import_leads",
+                            args: {
+                                ...input,
+                                campaignOfferId,
+                                provider: "signal-discovery",
+                                confirmed: true,
+                                allowInvalidSignalPosts: true,
+                            },
+                        },
+                    ]
+                    : [],
+            };
+        }
+        if (allowInvalidSignalPosts && postValidation.invalidPosts.length > 0) {
+            importSelection = selectSignalPostsForImport(postValidation.validPosts, {
+                targetEngagerCount: effectiveTargetEngagerCount,
+                maxPostsToScrape,
+            });
+            postsToScrape = importSelection.posts;
+        }
         const effectiveHeadlineICPCriteria = headlineICPCriteria && headlineICPCriteria.length > 0
             ? headlineICPCriteria
             : rubricGuidelines;
@@ -3692,8 +3904,10 @@ export async function importLeads(input) {
             targetEngagerCount: effectiveTargetEngagerCount,
             maxPostsToScrape: normalizePositiveInteger(maxPostsToScrape) ?? null,
             limitedSelectedPosts: importSelection.limited,
+            invalidSelectedPostCount: postValidation.invalidPosts.length,
+            warnings: skippedInvalidPostWarning ? [skippedInvalidPostWarning] : [],
             targetLeadCount: cappedTargetLeadCount ?? null,
-            message: `Started scraping ${postsToScrape.length} posts (up to ~${result.estimatedEngagers} people to check). Leads will appear as scraping completes.${importSelection.limited
+            message: `${skippedInvalidPostWarning ? `${skippedInvalidPostWarning} ` : ""}Started scraping ${postsToScrape.length} posts (up to ~${result.estimatedEngagers} people to check). Leads will appear as scraping completes.${importSelection.limited
                 ? ` Limited from ${uniqueSelectedPosts.length} selected posts by the approved source-capacity scrape plan.`
                 : ""} The watched campaign has been moved to confirm-lead-list with import progress copy. Keep calling wait_for_lead_list_ready until it reports ready, failed, or cancelled before confirm_lead_list; only confirm a partial list with allowPartialSourceList after the user explicitly asks to keep going early. Do not call update_campaign to fix that step.`,
         };