@sellable/mcp 0.1.318 → 0.1.320

package/dist/tools/linkedin.d.ts

@@ -16,6 +16,7 @@ export declare const linkedinToolDefinitions: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             companyUrl?: undefined;
             sortBy?: undefined;
             linkedin_url?: undefined;
@@ -46,6 +47,7 @@ export declare const linkedinToolDefinitions: ({
             };
             linkedinUrl?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             companyUrl?: undefined;
             sortBy?: undefined;
             linkedin_url?: undefined;
@@ -68,6 +70,11 @@ export declare const linkedinToolDefinitions: ({
                 description: string;
                 default: boolean;
             };
+            fetchMinimal: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
             limit?: undefined;
             postUrl?: undefined;
             sources?: undefined;
@@ -93,6 +100,7 @@ export declare const linkedinToolDefinitions: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             sortBy?: undefined;
             linkedin_url?: undefined;
             max_posts?: undefined;
@@ -124,6 +132,7 @@ export declare const linkedinToolDefinitions: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             linkedin_url?: undefined;
             max_posts?: undefined;
         };
@@ -149,6 +158,7 @@ export declare const linkedinToolDefinitions: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             companyUrl?: undefined;
             sortBy?: undefined;
         };
@@ -169,6 +179,7 @@ export declare const linkedinToolDefinitions: ({
             postUrl?: undefined;
             sources?: undefined;
             full?: undefined;
+            fetchMinimal?: undefined;
             companyUrl?: undefined;
             sortBy?: undefined;
             max_posts?: undefined;
@@ -237,6 +248,70 @@ interface SerializedPostMedia {
     articleUrl?: string;
     mediaTypes: string[];
 }
+interface CompactLinkedInProfile {
+    id?: string;
+    publicIdentifier?: string;
+    linkedinUrl?: string;
+    firstName?: string;
+    lastName?: string;
+    fullName?: string;
+    headline?: string;
+    about?: string;
+    location?: string;
+    followerCount?: number;
+    connectionCount?: number;
+    isPremium?: boolean;
+    isCreator?: boolean;
+    isVerified?: boolean;
+    currentRole?: CompactExperience;
+    company?: CompactCompany;
+    experience?: CompactExperience[];
+    education?: CompactEducation[];
+    skills?: string[];
+    languages?: CompactLanguage[];
+    certifications?: CompactNamedItem[];
+    projects?: CompactNamedItem[];
+}
+interface CompactCompany {
+    name?: string;
+    linkedinUrl?: string;
+    website?: string;
+    domain?: string;
+    industry?: string;
+    employeeCount?: number;
+    employeeRange?: string;
+    description?: string;
+    founded?: string | number;
+}
+interface CompactExperience {
+    title?: string;
+    companyName?: string;
+    companyLinkedinUrl?: string;
+    dateRange?: string;
+    duration?: string;
+    location?: string;
+    description?: string;
+    isCurrent?: boolean;
+}
+interface CompactEducation {
+    schoolName?: string;
+    schoolLinkedinUrl?: string;
+    degree?: string;
+    fieldOfStudy?: string;
+    dateRange?: string;
+}
+interface CompactLanguage {
+    name?: string;
+    proficiency?: string;
+}
+interface CompactNamedItem {
+    name?: string;
+    organization?: string;
+    dateRange?: string;
+    description?: string;
+    url?: string;
+}
+export declare function compactLinkedInProfile(profile: unknown): CompactLinkedInProfile;
 export declare function serializeLinkedInPosts(rawPosts: RawLinkedInPost[] | undefined, context: string): SerializedPost[];
 export declare function fetchLinkedInPosts(linkedinUrl: string, limit?: number): Promise<{
     posts: SerializedPost[];
@@ -244,6 +319,7 @@ export declare function fetchLinkedInPosts(linkedinUrl: string, limit?: number):
 }>;
 export declare function fetchLinkedInProfile(linkedinUrl: string, options?: {
     full?: boolean;
+    fetchMinimal?: boolean;
 }): Promise<any>;
 export declare function fetchCompany(companyUrl: string): Promise<unknown>;
 export declare function fetchCompanyPosts(companyUrl: string, limit?: number, sortBy?: "recent" | "top"): Promise<{

package/dist/tools/linkedin.js

@@ -47,7 +47,7 @@ export const linkedinToolDefinitions = [
     },
     {
         name: "fetch_linkedin_profile",
-        description: "Fetch LinkedIn profile details. Defaults to the cheaper 'main' payload — same envelope shape with most-recent role, headline, about, location, education, top skills, certifications, languages, projects, etc. Pass full=true ONLY when you need the long-tail experience history (positions 6+) or complete skill list (skills 3+) for deep research. Most personalization, qualification, and outreach use cases work with main; reach for full only when the user explicitly asks for full work history or comprehensive skill audit.",
+        description: "Fetch LinkedIn profile details. Defaults to compact context (fetchMinimal=true) that strips images/media/provider metadata and returns identity, headline, about, current role, company, limited experience, education, skills, certifications, languages, and projects. Pass fetchMinimal=false only when you need raw provider fields or media URLs. Pass full=true ONLY when you need the long-tail experience history (positions 6+) or complete skill list (skills 3+) for deep research; full still returns compact output unless fetchMinimal=false.",
         inputSchema: {
             type: "object",
             properties: {
@@ -60,6 +60,11 @@ export const linkedinToolDefinitions = [
                     description: "Opt into the full payload (~38% more expensive, slightly slower). Set true only when you specifically need the long-tail experience history or full skill list. Default false (main payload).",
                     default: false,
                 },
+                fetchMinimal: {
+                    type: "boolean",
+                    description: "Return compact agent context by stripping images/media/provider metadata and limiting long lists. Default true. Set false only when raw provider fields or media URLs are needed.",
+                    default: true,
+                },
             },
             required: ["linkedinUrl"],
         },
@@ -187,6 +192,348 @@ function collectImageUrls(value, urls = new Set()) {
 function pickString(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function pickRecord(value, keys) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        if (isRecord(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function pickStringFrom(value, keys, maxLength = 1200) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        const picked = typeof candidate === "string" || typeof candidate === "number"
+            ? compactString(candidate, maxLength)
+            : undefined;
+        if (picked)
+            return picked;
+    }
+    return undefined;
+}
+function pickNumberFrom(value, keys) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        if (typeof candidate === "number" && Number.isFinite(candidate)) {
+            return candidate;
+        }
+        if (typeof candidate === "string" && candidate.trim()) {
+            const parsed = Number(candidate.replace(/,/g, ""));
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+    }
+    return undefined;
+}
+function pickBooleanFrom(value, keys) {
+    if (!isRecord(value))
+        return undefined;
+    for (const key of keys) {
+        const candidate = value[key];
+        if (typeof candidate === "boolean")
+            return candidate;
+    }
+    return undefined;
+}
+function compactString(value, maxLength = 1200) {
+    if (typeof value !== "string" && typeof value !== "number") {
+        return undefined;
+    }
+    const compacted = String(value)
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    if (!compacted)
+        return undefined;
+    return compacted.length > maxLength
+        ? `${compacted.slice(0, maxLength - 3).trim()}...`
+        : compacted;
+}
+function stripEmpty(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => stripEmpty(item))
+            .filter((item) => {
+            if (item == null)
+                return false;
+            if (Array.isArray(item))
+                return item.length > 0;
+            if (isRecord(item))
+                return Object.keys(item).length > 0;
+            return true;
+        });
+    }
+    if (!isRecord(value))
+        return value;
+    const entries = Object.entries(value)
+        .map(([key, item]) => [key, stripEmpty(item)])
+        .filter(([, item]) => {
+        if (item == null || item === "")
+            return false;
+        if (Array.isArray(item))
+            return item.length > 0;
+        if (isRecord(item))
+            return Object.keys(item).length > 0;
+        return true;
+    });
+    return Object.fromEntries(entries);
+}
+function asArray(value) {
+    if (Array.isArray(value))
+        return value;
+    return value == null ? [] : [value];
+}
+function pickProfileArray(profile, keys) {
+    for (const key of keys) {
+        const value = profile[key];
+        if (Array.isArray(value))
+            return value;
+    }
+    return [];
+}
+function datePartText(value) {
+    if (typeof value === "string")
+        return compactString(value, 80);
+    if (!isRecord(value))
+        return undefined;
+    const text = pickStringFrom(value, ["text", "date"], 80);
+    if (text)
+        return text;
+    const year = pickNumberFrom(value, ["year"]);
+    const month = pickStringFrom(value, ["month"], 20) || pickNumberFrom(value, ["month"]);
+    if (!year)
+        return undefined;
+    return month ? `${month} ${year}` : String(year);
+}
+function dateRangeFromItem(item) {
+    const explicit = pickStringFrom(item, ["dateRange", "date_range", "period"], 120);
+    if (explicit)
+        return explicit;
+    const startText = datePartText(item.startDate) ||
+        datePartText(stripEmpty({
+            month: item.start_month ?? item.startMonth,
+            year: item.start_year ?? item.startYear,
+        }));
+    const endText = datePartText(item.endDate) ||
+        datePartText(stripEmpty({
+            month: item.end_month ?? item.endMonth,
+            year: item.end_year ?? item.endYear,
+        }));
+    return [startText, endText].filter(Boolean).join(" - ") || undefined;
+}
+function compactExperienceItem(value) {
+    if (!isRecord(value))
+        return {};
+    const companyRecord = pickRecord(value, ["company"]);
+    return stripEmpty({
+        title: pickStringFrom(value, ["title", "position", "job_title"], 160),
+        companyName: pickStringFrom(value, ["companyName", "company_name", "company"], 160) ||
+            pickStringFrom(companyRecord, ["name"], 160),
+        companyLinkedinUrl: pickStringFrom(value, [
+            "companyLinkedinUrl",
+            "companyLinkedInUrl",
+            "company_linkedin_url",
+            "companyLink",
+            "company_public_url",
+        ], 240),
+        dateRange: dateRangeFromItem(value),
+        duration: pickStringFrom(value, ["duration", "current_job_duration"], 80),
+        location: pickStringFrom(value, ["location"], 180),
+        description: pickStringFrom(value, ["description", "summary"], 700),
+        isCurrent: pickBooleanFrom(value, ["isCurrent", "is_current"]),
+    });
+}
+function compactEducationItem(value) {
+    if (!isRecord(value))
+        return {};
+    return stripEmpty({
+        schoolName: pickStringFrom(value, ["schoolName", "school_name", "school"], 180),
+        schoolLinkedinUrl: pickStringFrom(value, ["schoolLinkedinUrl", "schoolLinkedInUrl", "school_linkedin_url"], 240),
+        degree: pickStringFrom(value, ["degree"], 180),
+        fieldOfStudy: pickStringFrom(value, ["fieldOfStudy", "field_of_study"], 180),
+        dateRange: dateRangeFromItem(value),
+    });
+}
+function compactStringList(value, limit) {
+    return asArray(value)
+        .map((item) => {
+        if (typeof item === "string" || typeof item === "number") {
+            return compactString(item, 120);
+        }
+        return pickStringFrom(item, ["name", "title", "skill"], 120);
+    })
+        .filter((item) => Boolean(item))
+        .slice(0, limit);
+}
+function compactLanguages(value) {
+    return asArray(value)
+        .map((item) => {
+        if (typeof item === "string")
+            return { name: compactString(item, 80) };
+        if (!isRecord(item))
+            return {};
+        return stripEmpty({
+            name: pickStringFrom(item, ["name", "language"], 80),
+            proficiency: pickStringFrom(item, ["proficiency"], 120),
+        });
+    })
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 10);
+}
+function compactNamedItems(value) {
+    return asArray(value)
+        .map((item) => {
+        if (typeof item === "string")
+            return { name: compactString(item, 160) };
+        if (!isRecord(item))
+            return {};
+        return stripEmpty({
+            name: pickStringFrom(item, ["name", "title"], 180),
+            organization: pickStringFrom(item, ["organization", "authority", "issuer", "companyName"], 180),
+            dateRange: dateRangeFromItem(item),
+            description: pickStringFrom(item, ["description"], 500),
+            url: pickStringFrom(item, ["url", "link"], 240),
+        });
+    })
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 5);
+}
+function firstCurrentRole(profile) {
+    const current = pickProfileArray(profile, [
+        "currentPosition",
+        "current_position",
+    ])
+        .map(compactExperienceItem)
+        .find((item) => Object.keys(item).length > 0);
+    if (current)
+        return current;
+    const firstExperience = pickProfileArray(profile, [
+        "experience",
+        "experiences",
+    ])
+        .map(compactExperienceItem)
+        .find((item) => Object.keys(item).length > 0);
+    if (firstExperience)
+        return firstExperience;
+    return stripEmpty({
+        title: pickStringFrom(profile, ["job_title", "jobTitle", "title"], 160),
+        companyName: pickStringFrom(profile, ["company", "companyName"], 160),
+        dateRange: dateRangeFromItem(stripEmpty({
+            start_month: profile.current_company_join_month ?? profile.currentCompanyJoinMonth,
+            start_year: profile.current_company_join_year ?? profile.currentCompanyJoinYear,
+        })),
+        duration: pickStringFrom(profile, ["current_job_duration", "currentJobDuration"], 80),
+    });
+}
+function compactCompanyFromProfile(profile, currentRole) {
+    return stripEmpty({
+        name: pickStringFrom(profile, ["company", "companyName"], 180) ||
+            currentRole.companyName,
+        linkedinUrl: pickStringFrom(profile, [
+            "company_linkedin_url",
+            "companyLinkedinUrl",
+            "companyLinkedInUrl",
+            "currentCompanyLinkedinUrl",
+        ], 240) || currentRole.companyLinkedinUrl,
+        website: pickStringFrom(profile, ["company_website", "companyWebsite", "website"], 240),
+        domain: pickStringFrom(profile, ["company_domain", "companyDomain", "currentCompanyDomain"], 120),
+        industry: pickStringFrom(profile, ["company_industry", "industry"], 160),
+        employeeCount: pickNumberFrom(profile, [
+            "company_employee_count",
+            "companyEmployeeCount",
+            "employeeCount",
+        ]),
+        employeeRange: pickStringFrom(profile, ["company_employee_range", "companyEmployeeRange", "employeeCountRange"], 80),
+        description: pickStringFrom(profile, ["company_description", "companyDescription"], 700),
+        founded: pickStringFrom(profile, ["company_year_founded", "founded"], 80) ||
+            pickNumberFrom(profile, ["company_year_founded", "founded"]),
+    });
+}
+export function compactLinkedInProfile(profile) {
+    if (!isRecord(profile))
+        return {};
+    const currentRole = firstCurrentRole(profile);
+    const experience = pickProfileArray(profile, ["experience", "experiences"])
+        .map(compactExperienceItem)
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 5);
+    const education = pickProfileArray(profile, ["education", "educations"])
+        .map(compactEducationItem)
+        .filter((item) => Object.keys(item).length > 0)
+        .slice(0, 3);
+    const skills = compactStringList(profile.topSkills ?? profile.skills, 12);
+    return stripEmpty({
+        id: pickStringFrom(profile, ["id", "profile_id"], 180),
+        publicIdentifier: pickStringFrom(profile, ["publicIdentifier", "public_id", "publicIdentifier"], 120),
+        linkedinUrl: pickStringFrom(profile, ["linkedinUrl", "linkedin_url", "profile_url"], 240),
+        firstName: pickStringFrom(profile, ["firstName", "first_name"], 120),
+        lastName: pickStringFrom(profile, ["lastName", "last_name"], 120),
+        fullName: pickStringFrom(profile, ["fullName", "full_name", "name"], 180) ||
+            [
+                pickStringFrom(profile, ["firstName", "first_name"], 120),
+                pickStringFrom(profile, ["lastName", "last_name"], 120),
+            ]
+                .filter(Boolean)
+                .join(" "),
+        headline: pickStringFrom(profile, ["headline"], 320),
+        about: pickStringFrom(profile, ["about", "summary"], 1600),
+        location: pickStringFrom(profile, ["location"], 180),
+        followerCount: pickNumberFrom(profile, ["followerCount", "follower_count"]),
+        connectionCount: pickNumberFrom(profile, [
+            "connectionsCount",
+            "connection_count",
+            "connectionCount",
+        ]),
+        isPremium: pickBooleanFrom(profile, ["premium", "is_premium", "isPremium"]),
+        isCreator: pickBooleanFrom(profile, ["is_creator", "isCreator"]),
+        isVerified: pickBooleanFrom(profile, [
+            "verified",
+            "is_verified",
+            "isVerified",
+        ]),
+        currentRole,
+        company: compactCompanyFromProfile(profile, currentRole),
+        experience,
+        education,
+        skills,
+        languages: compactLanguages(profile.languages),
+        certifications: compactNamedItems(profile.certifications),
+        projects: compactNamedItems(profile.projects),
+    });
+}
+function canonicalizeLinkedInProfileResponse(raw) {
+    if (raw &&
+        typeof raw === "object" &&
+        raw.status === "success" &&
+        (raw.data || raw.person || raw.profile?.person)) {
+        const canonical = raw.data ?? raw.person ?? raw.profile?.person;
+        const { status, data, person, profile, ...rest } = raw;
+        return { status, profile: canonical, ...rest };
+    }
+    return raw;
+}
+function compactLinkedInProfileResponse(raw) {
+    const normalized = canonicalizeLinkedInProfileResponse(raw);
+    if (normalized &&
+        typeof normalized === "object" &&
+        normalized.status === "success" &&
+        normalized.profile) {
+        return {
+            status: normalized.status,
+            profile: compactLinkedInProfile(normalized.profile),
+        };
+    }
+    return normalized;
+}
 function serializePostMedia(post) {
     const media = post.media && typeof post.media === "object"
         ? post.media
@@ -295,23 +642,9 @@ export async function fetchLinkedInProfile(linkedinUrl, options = {}) {
         params.set("full", "true");
     }
     const raw = await api.get(`/api/v1/scrape/linkedin/profile?${params.toString()}`);
-    // Server returns the same profile object triplicated as `.data`,
-    // `.person`, AND `.profile.person` for backwards-compat with web
-    // callers (signal-discovery, profile-enrichment, canonical-cache, etc).
-    // For the MCP layer, that ~3xs the JSON size and routinely breaches
-    // Claude Code's max-token cap on tool results — which triggers the
-    // harness's "save to file + read in chunks via python3" overflow
-    // fallback. Strip the duplicates here so the agent gets one clean
-    // copy of the data under a single `profile` key.
-    if (raw &&
-        typeof raw === "object" &&
-        raw.status === "success" &&
-        (raw.data || raw.person || raw.profile?.person)) {
-        const canonical = raw.data ?? raw.person ?? raw.profile?.person;
-        const { status, data, person, profile, ...rest } = raw;
-        return { status, profile: canonical, ...rest };
-    }
-    return raw;
+    return options.fetchMinimal === false
+        ? canonicalizeLinkedInProfileResponse(raw)
+        : compactLinkedInProfileResponse(raw);
 }
 export async function fetchCompany(companyUrl) {
     const api = getApi();

package/dist/tools/readiness.js

@@ -20,6 +20,23 @@ function normalizeLeadSourceProvider(provider) {
         return "csv-linkedin";
     return undefined;
 }
+function isPositiveNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function hasSignalDiscoveryProgressEvidence(rowCount, importProgress) {
+    const phase = importProgress?.phase ?? null;
+    return (rowCount > 0 ||
+        isPositiveNumber(importProgress?.processed) ||
+        isPositiveNumber(importProgress?.leadsImported) ||
+        isPositiveNumber(importProgress?.scrapedEngagers) ||
+        isPositiveNumber(importProgress?.evaluatedEngagers) ||
+        isPositiveNumber(importProgress?.evaluationTotal) ||
+        isPositiveNumber(importProgress?.activeEvaluationBatches) ||
+        isPositiveNumber(importProgress?.queuedForEvaluation) ||
+        isPositiveNumber(importProgress?.postsScraped) ||
+        phase === "scraping" ||
+        phase === "processing");
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -233,6 +250,8 @@ export async function waitForLeadListReady(input) {
             if (typeof configTarget === "number" && !targetLeadCount) {
                 targetLeadCount = configTarget;
             }
+            const signalDiscoveryHasProgressEvidence = provider === "signal-discovery" &&
+                hasSignalDiscoveryProgressEvidence(rowCount, importProgress);
             let jobId = input.jobId;
             if (!jobId && typeof config?.importJobId === "string") {
                 jobId = config.importJobId;
@@ -253,7 +272,9 @@ export async function waitForLeadListReady(input) {
                         targetLeadCount,
                     };
                 }
-                if (configError && configStatus !== "complete") {
+                if (configError &&
+                    configStatus !== "complete" &&
+                    !signalDiscoveryHasProgressEvidence) {
                     return {
                         ready: false,
                         reason: "import_failed",
@@ -267,21 +288,31 @@ export async function waitForLeadListReady(input) {
                         error: configError,
                     };
                 }
+                if (configError &&
+                    configStatus !== "complete" &&
+                    signalDiscoveryHasProgressEvidence) {
+                    lastError = configError;
+                }
                 if (configStatus) {
                     lastStatus = configStatus;
                     if (configStatus === "error") {
-                        return {
-                            ready: false,
-                            reason: "import_failed",
-                            leadListId,
-                            provider: provider ?? null,
-                            attempts,
-                            elapsedMs: Date.now() - start,
-                            rowCount,
-                            status: configStatus,
-                            targetLeadCount,
-                            error: configError,
-                        };
+                        if (signalDiscoveryHasProgressEvidence) {
+                            lastError = configError ?? lastError;
+                        }
+                        else {
+                            return {
+                                ready: false,
+                                reason: "import_failed",
+                                leadListId,
+                                provider: provider ?? null,
+                                attempts,
+                                elapsedMs: Date.now() - start,
+                                rowCount,
+                                status: configStatus,
+                                targetLeadCount,
+                                error: configError,
+                            };
+                        }
                     }
                     if (configStatus === "complete") {
                         importComplete = true;