linkedin-secret-sauce 0.6.0 → 0.7.2

package/dist/config.js

@@ -106,7 +106,7 @@ async function initializeLinkedInClient(config) {
             }
             else {
                 // Default: throw to alert consumer immediately
-                throw new errors_1.LinkedInClientError('Failed to initialize LinkedIn client: ' + error.message, 'INITIALIZATION_FAILED', 0);
+                throw new errors_1.LinkedInClientError(`Failed to initialize LinkedIn client: ${error.message}`, 'INITIALIZATION_FAILED', 0);
             }
         }
     }

package/dist/cosiall-client.js

@@ -115,8 +115,9 @@ async function fetchCookiesFromCosiall() {
             return false;
         if (!rec.cookies.every(isCookie))
             return false;
-        if (rec.expiresAt !== undefined && typeof rec.expiresAt !== "number")
+        if (rec.expiresAt !== undefined && typeof rec.expiresAt !== "number") {
             return false;
+        }
         return true;
     }
     return data

package/dist/enrichment/auth/smartlead-auth.js

@@ -306,8 +306,6 @@ function clearFileCache() {
         // Ignore errors
     }
 }
-// Patch the existing getSmartLeadToken to save to file cache after login
-const originalGetSmartLeadToken = getSmartLeadToken;
 // We need to modify the token caching behavior to persist to file
 // This is done by wrapping the cache set operation
 // Override tokenCache.set to also persist to file

package/dist/enrichment/index.d.ts

@@ -40,6 +40,7 @@ export { isDisposableEmail, isDisposableDomain, DISPOSABLE_DOMAINS, } from "./ut
 export { isValidEmailSyntax, isRoleAccount, asciiFold, cleanNamePart, hostnameFromUrl, extractLinkedInUsername, } from "./utils/validation";
 export { verifyEmailMx } from "./verification/mx";
 export { createConstructProvider, createLddProvider, createSmartProspectProvider, createHunterProvider, createApolloProvider, createDropcontactProvider, } from "./providers";
+export { extractNumericLinkedInId } from "./providers/ldd";
 export { createSmartProspectClient, type SmartProspectClient, type SmartProspectLocationOptions, } from "./providers/smartprospect";
 export { enrichBusinessEmail, enrichBatch, enrichAllEmails, enrichAllBatch } from "./orchestrator";
 export { getSmartLeadToken, getSmartLeadUser, clearSmartLeadToken, clearAllSmartLeadTokens, getSmartLeadTokenCacheStats, enableFileCache, disableFileCache, isFileCacheEnabled, clearFileCache, type SmartLeadCredentials, type SmartLeadAuthConfig, type SmartLeadUser, type SmartLeadLoginResponse, } from "./auth";

package/dist/enrichment/index.js

@@ -42,7 +42,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLinkedInEnricher = exports.enrichLinkedInContactsBatch = exports.enrichLinkedInContact = exports.parseLinkedInSearchResponse = exports.buildSmartProspectFiltersFromLinkedIn = exports.matchContacts = exports.findBestMatch = exports.classifyMatchQuality = exports.calculateMatchConfidence = exports.clearFileCache = exports.isFileCacheEnabled = exports.disableFileCache = exports.enableFileCache = exports.getSmartLeadTokenCacheStats = exports.clearAllSmartLeadTokens = exports.clearSmartLeadToken = exports.getSmartLeadUser = exports.getSmartLeadToken = exports.enrichAllBatch = exports.enrichAllEmails = exports.enrichBatch = exports.enrichBusinessEmail = exports.createSmartProspectClient = exports.createDropcontactProvider = exports.createApolloProvider = exports.createHunterProvider = exports.createSmartProspectProvider = exports.createLddProvider = exports.createConstructProvider = exports.verifyEmailMx = exports.extractLinkedInUsername = exports.hostnameFromUrl = exports.cleanNamePart = exports.asciiFold = exports.isRoleAccount = exports.isValidEmailSyntax = exports.DISPOSABLE_DOMAINS = exports.isDisposableDomain = exports.isDisposableEmail = exports.PERSONAL_DOMAINS = exports.isPersonalDomain = exports.isBusinessEmail = exports.isPersonalEmail = void 0;
+exports.createLinkedInEnricher = exports.enrichLinkedInContactsBatch = exports.enrichLinkedInContact = exports.parseLinkedInSearchResponse = exports.buildSmartProspectFiltersFromLinkedIn = exports.matchContacts = exports.findBestMatch = exports.classifyMatchQuality = exports.calculateMatchConfidence = exports.clearFileCache = exports.isFileCacheEnabled = exports.disableFileCache = exports.enableFileCache = exports.getSmartLeadTokenCacheStats = exports.clearAllSmartLeadTokens = exports.clearSmartLeadToken = exports.getSmartLeadUser = exports.getSmartLeadToken = exports.enrichAllBatch = exports.enrichAllEmails = exports.enrichBatch = exports.enrichBusinessEmail = exports.createSmartProspectClient = exports.extractNumericLinkedInId = exports.createDropcontactProvider = exports.createApolloProvider = exports.createHunterProvider = exports.createSmartProspectProvider = exports.createLddProvider = exports.createConstructProvider = exports.verifyEmailMx = exports.extractLinkedInUsername = exports.hostnameFromUrl = exports.cleanNamePart = exports.asciiFold = exports.isRoleAccount = exports.isValidEmailSyntax = exports.DISPOSABLE_DOMAINS = exports.isDisposableDomain = exports.isDisposableEmail = exports.PERSONAL_DOMAINS = exports.isPersonalDomain = exports.isBusinessEmail = exports.isPersonalEmail = void 0;
 exports.createEnrichmentClient = createEnrichmentClient;
 const orchestrator_1 = require("./orchestrator");
 const construct_1 = require("./providers/construct");
@@ -250,6 +250,9 @@ Object.defineProperty(exports, "createSmartProspectProvider", { enumerable: true
 Object.defineProperty(exports, "createHunterProvider", { enumerable: true, get: function () { return providers_1.createHunterProvider; } });
 Object.defineProperty(exports, "createApolloProvider", { enumerable: true, get: function () { return providers_1.createApolloProvider; } });
 Object.defineProperty(exports, "createDropcontactProvider", { enumerable: true, get: function () { return providers_1.createDropcontactProvider; } });
+// Re-export LDD utilities
+var ldd_2 = require("./providers/ldd");
+Object.defineProperty(exports, "extractNumericLinkedInId", { enumerable: true, get: function () { return ldd_2.extractNumericLinkedInId; } });
 // Re-export SmartProspect client for direct API access
 var smartprospect_2 = require("./providers/smartprospect");
 Object.defineProperty(exports, "createSmartProspectClient", { enumerable: true, get: function () { return smartprospect_2.createSmartProspectClient; } });

package/dist/enrichment/matching.d.ts

@@ -107,6 +107,8 @@ export interface LinkedInEnrichmentResult {
     success: boolean;
     /** The original LinkedIn contact */
     linkedInContact: LinkedInContact;
+    /** Numeric LinkedIn ID extracted from objectUrn (stable identifier for LDD lookup) */
+    numericLinkedInId: string | null;
     /** The matched SmartProspect contact (if found) */
     matchedContact: SmartProspectContact | null;
     /** Match confidence score (0-100) */

package/dist/enrichment/matching.js

@@ -16,6 +16,7 @@ exports.enrichLinkedInContact = enrichLinkedInContact;
 exports.enrichLinkedInContactsBatch = enrichLinkedInContactsBatch;
 exports.createLinkedInEnricher = createLinkedInEnricher;
 const smartprospect_1 = require("./providers/smartprospect");
+const ldd_1 = require("./providers/ldd");
 // =============================================================================
 // Utility Functions
 // =============================================================================
@@ -143,10 +144,10 @@ function calculateMatchConfidence(linkedin, smartprospect, options = {}) {
     const matchedFields = [];
     let score = 0;
     // === Name matching (up to 40 points) ===
-    const liFirstName = normalize(linkedin.firstName);
-    const liLastName = normalize(linkedin.lastName);
-    const spFirstName = normalize(smartprospect.firstName);
-    const spLastName = normalize(smartprospect.lastName);
+    const _liFirstName = normalize(linkedin.firstName);
+    const _liLastName = normalize(linkedin.lastName);
+    const _spFirstName = normalize(smartprospect.firstName);
+    const _spLastName = normalize(smartprospect.lastName);
     // First name match
     if (exactMatch(linkedin.firstName, smartprospect.firstName)) {
         score += 20;
@@ -353,10 +354,13 @@ function parseLinkedInSearchResponse(elements) {
  */
 async function enrichLinkedInContact(linkedInContact, smartProspectConfig, options = {}) {
     const { minConfidence = 60, autoFetch = true, fuzzyNames = true, fuzzyCompany = true, searchLimit = 25, includeCompany = true, includeLocation = false, } = options;
+    // Extract numeric LinkedIn ID from objectUrn (stable identifier for LDD)
+    const numericLinkedInId = (0, ldd_1.extractNumericLinkedInId)(linkedInContact.objectUrn);
     // Initialize result
     const result = {
         success: false,
         linkedInContact,
+        numericLinkedInId,
         matchedContact: null,
         matchConfidence: 0,
         matchQuality: 'none',
@@ -497,10 +501,13 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
         client,
         async enrich(contact, options = {}) {
             const mergedOptions = { ...defaultOptions, ...options };
+            // Extract numeric LinkedIn ID from objectUrn (stable identifier for LDD)
+            const numericLinkedInId = (0, ldd_1.extractNumericLinkedInId)(contact.objectUrn);
             // We reuse the existing client rather than creating a new one
             const result = {
                 success: false,
                 linkedInContact: contact,
+                numericLinkedInId,
                 matchedContact: null,
                 matchConfidence: 0,
                 matchQuality: 'none',

package/dist/enrichment/orchestrator.js

@@ -16,7 +16,7 @@ const validation_1 = require("./utils/validation");
 /**
  * Default provider costs in USD per lookup
  */
-const DEFAULT_PROVIDER_COSTS = {
+const _PROVIDER_COSTS = {
     construct: 0,
     ldd: 0,
     smartprospect: 0.01,
@@ -63,7 +63,7 @@ function getProviderName(provider, index) {
  * Get provider cost
  */
 function getProviderCost(providerName) {
-    return DEFAULT_PROVIDER_COSTS[providerName] ?? 0;
+    return _PROVIDER_COSTS[providerName] ?? 0;
 }
 /**
  * Check if a provider result is a multi-result (returns multiple emails)

package/dist/enrichment/providers/ldd.d.ts

@@ -3,9 +3,27 @@
  *
  * YOUR private database of ~500M scraped LinkedIn profiles with emails.
  * This is FREE and unlimited - it's your own service.
+ *
+ * IMPORTANT: Prefer numeric LinkedIn ID over username for lookups.
+ * The numeric ID (from objectUrn like "urn:li:member:307567") is STABLE and never changes,
+ * while usernames can be changed by users at any time.
  */
 import type { EnrichmentCandidate, ProviderResult, ProviderMultiResult, LddConfig } from "../types";
+/**
+ * Extract numeric LinkedIn ID from various formats:
+ * - Direct number: "307567"
+ * - URN format: "urn:li:member:307567"
+ * - Full URN: "urn:li:fs_salesProfile:(ACwAAAAEsW8B...,NAME_SEARCH,PJOV)"
+ * - objectUrn: "urn:li:member:307567"
+ *
+ * Returns the numeric ID as a string, or null if not found.
+ */
+export declare function extractNumericLinkedInId(input: string | undefined | null): string | null;
 /**
  * Create the LDD provider function
+ *
+ * Lookup priority:
+ * 1. Numeric LinkedIn ID (PREFERRED - stable, never changes)
+ * 2. Username (FALLBACK - can change over time)
  */
 export declare function createLddProvider(config: LddConfig): (candidate: EnrichmentCandidate) => Promise<ProviderResult | ProviderMultiResult | null>;

package/dist/enrichment/providers/ldd.js

@@ -4,8 +4,13 @@
  *
  * YOUR private database of ~500M scraped LinkedIn profiles with emails.
  * This is FREE and unlimited - it's your own service.
+ *
+ * IMPORTANT: Prefer numeric LinkedIn ID over username for lookups.
+ * The numeric ID (from objectUrn like "urn:li:member:307567") is STABLE and never changes,
+ * while usernames can be changed by users at any time.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractNumericLinkedInId = extractNumericLinkedInId;
 exports.createLddProvider = createLddProvider;
 const validation_1 = require("../utils/validation");
 /**
@@ -45,6 +50,35 @@ async function requestWithRetry(url, token, retries = 1, backoffMs = 200) {
     }
     throw lastErr ?? new Error("ldd_http_error");
 }
+/**
+ * Extract numeric LinkedIn ID from various formats:
+ * - Direct number: "307567"
+ * - URN format: "urn:li:member:307567"
+ * - Full URN: "urn:li:fs_salesProfile:(ACwAAAAEsW8B...,NAME_SEARCH,PJOV)"
+ * - objectUrn: "urn:li:member:307567"
+ *
+ * Returns the numeric ID as a string, or null if not found.
+ */
+function extractNumericLinkedInId(input) {
+    if (!input)
+        return null;
+    const trimmed = input.trim();
+    // Direct numeric ID
+    if (/^\d+$/.test(trimmed)) {
+        return trimmed;
+    }
+    // URN format: urn:li:member:307567
+    const memberMatch = trimmed.match(/urn:li:member:(\d+)/i);
+    if (memberMatch) {
+        return memberMatch[1];
+    }
+    // Sales profile URN with numeric ID
+    const salesMatch = trimmed.match(/urn:li:fs_salesProfile:\((\d+),/i);
+    if (salesMatch) {
+        return salesMatch[1];
+    }
+    return null;
+}
 /**
  * Extract LinkedIn username from candidate
  */
@@ -62,8 +96,43 @@ function extractUsername(candidate) {
     }
     return null;
 }
+/**
+ * Extract numeric LinkedIn ID from candidate.
+ * Checks multiple fields in order of preference:
+ * 1. numericLinkedInId / numeric_linkedin_id (direct numeric ID)
+ * 2. objectUrn / object_urn (URN format like "urn:li:member:307567")
+ * 3. linkedinId / linkedin_id (may contain URN or numeric ID)
+ */
+function extractNumericId(candidate) {
+    // Direct numeric ID field
+    const numericId = candidate.numericLinkedInId || candidate.numeric_linkedin_id;
+    if (numericId) {
+        const extracted = extractNumericLinkedInId(numericId);
+        if (extracted)
+            return extracted;
+    }
+    // objectUrn field (from Sales Navigator search results)
+    const objectUrn = candidate.objectUrn || candidate.object_urn;
+    if (objectUrn) {
+        const extracted = extractNumericLinkedInId(objectUrn);
+        if (extracted)
+            return extracted;
+    }
+    // linkedinId field (may contain URN or numeric ID)
+    const linkedinId = candidate.linkedinId || candidate.linkedin_id;
+    if (linkedinId) {
+        const extracted = extractNumericLinkedInId(linkedinId);
+        if (extracted)
+            return extracted;
+    }
+    return null;
+}
 /**
  * Create the LDD provider function
+ *
+ * Lookup priority:
+ * 1. Numeric LinkedIn ID (PREFERRED - stable, never changes)
+ * 2. Username (FALLBACK - can change over time)
  */
 function createLddProvider(config) {
     const { apiUrl, apiToken } = config;
@@ -74,44 +143,109 @@ function createLddProvider(config) {
         return noopProvider;
     }
     async function fetchEmail(candidate) {
+        // PRIORITY 1: Try numeric ID first (stable identifier)
+        const numericId = extractNumericId(candidate);
+        if (numericId) {
+            const result = await lookupByNumericId(numericId);
+            if (result)
+                return result;
+        }
+        // PRIORITY 2: Fall back to username (less reliable)
         const username = extractUsername(candidate);
-        if (!username) {
-            return null;
+        if (username) {
+            const result = await lookupByUsername(username);
+            if (result)
+                return result;
         }
+        return null;
+    }
+    async function lookupByNumericId(numericId) {
         try {
-            const endpoint = `${apiUrl}/api/v1/profiles/by-username/${encodeURIComponent(username)}`;
+            const endpoint = `${apiUrl}/api/v1/profiles/by-numeric-id/${encodeURIComponent(numericId)}`;
             const response = await requestWithRetry(endpoint, apiToken, 1, 100);
             if (!response.ok) {
                 return null;
             }
-            const data = (await response.json());
-            if (!data.success || !data.data) {
-                return null;
-            }
-            // Return ALL valid emails from the profile
-            const profileEmails = data.data.emails || [];
-            const validEmails = profileEmails.filter((e) => e.email_address && e.email_address.includes("@"));
-            if (validEmails.length === 0) {
+            return parseResponse(await response.json());
+        }
+        catch {
+            return null;
+        }
+    }
+    async function lookupByUsername(username) {
+        try {
+            const endpoint = `${apiUrl}/api/v1/profiles/by-username/${encodeURIComponent(username)}`;
+            const response = await requestWithRetry(endpoint, apiToken, 1, 100);
+            if (!response.ok) {
                 return null;
             }
-            // Build multi-result with all emails
-            const emails = validEmails.map((e) => ({
-                email: e.email_address,
-                verified: true, // LDD data is pre-verified
-                confidence: 90, // High confidence from your own database
-                metadata: {
-                    emailType: e.email_type,
-                    fullName: data.data.full_name,
-                    linkedinUsername: data.data.linkedin_username,
-                    linkedinUrl: data.data.linkedin_profile_url,
-                },
-            }));
-            return { emails };
+            return parseResponse(await response.json());
         }
         catch {
             return null;
         }
     }
+    /**
+     * Calculate confidence score based on email type
+     * Professional emails are scored higher than personal ones
+     */
+    function getConfidenceScore(emailType) {
+        if (!emailType)
+            return 75; // Unknown type
+        const type = emailType.toLowerCase();
+        // Professional/business emails - highest confidence
+        if (type === 'professional' || type === 'business' || type === 'work') {
+            return 95;
+        }
+        // Personal emails - still valid but lower priority for B2B
+        if (type === 'personal' || type === 'private') {
+            return 70;
+        }
+        // Other types (e.g., "other", "unknown")
+        return 75;
+    }
+    /**
+     * Classify email type for the enrichment result
+     */
+    function classifyEmailType(emailType) {
+        if (!emailType)
+            return 'unknown';
+        const type = emailType.toLowerCase();
+        if (type === 'professional' || type === 'business' || type === 'work') {
+            return 'business';
+        }
+        if (type === 'personal' || type === 'private') {
+            return 'personal';
+        }
+        return 'unknown';
+    }
+    function parseResponse(data) {
+        if (!data.success || !data.data) {
+            return null;
+        }
+        // Return ALL valid emails from the profile
+        const profileEmails = data.data.emails || [];
+        const validEmails = profileEmails.filter((e) => e.emailAddress && e.emailAddress.includes("@"));
+        if (validEmails.length === 0) {
+            return null;
+        }
+        // Build multi-result with all emails, sorted by confidence (professional first)
+        const emails = validEmails
+            .map((e) => ({
+            email: e.emailAddress,
+            verified: true, // LDD data is pre-verified
+            confidence: getConfidenceScore(e.emailType),
+            metadata: {
+                emailType: e.emailType,
+                emailTypeClassified: classifyEmailType(e.emailType),
+                linkedinUsername: data.data.linkedInUsername,
+                numericLinkedInId: data.data.numericLinkedInId,
+                sourceRecordId: data.data.sourceRecordId,
+            },
+        }))
+            .sort((a, b) => b.confidence - a.confidence); // Sort by confidence descending
+        return { emails };
+    }
     // Mark provider name for orchestrator
     fetchEmail.__name = "ldd";
     return fetchEmail;

package/dist/enrichment/providers/smartprospect.js

@@ -24,6 +24,12 @@ const DEFAULT_API_URL = "https://prospect-api.smartlead.ai/api/search-email-lead
 async function delay(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
+const DEFAULT_POLLING_CONFIG = {
+    initialDelay: 500,
+    pollInterval: 1000,
+    maxAttempts: 10,
+    maxWaitTime: 15000,
+};
 /**
  * HTTP request with retry on 429 rate limit
  */
@@ -202,11 +208,85 @@ function createSmartProspectProvider(config) {
             };
         }
     }
+    /**
+     * Poll get-contacts until email lookup is complete (provider version)
+     */
+    async function pollForContactResults(filterId, expectedCount) {
+        const { initialDelay, pollInterval, maxAttempts, maxWaitTime } = DEFAULT_POLLING_CONFIG;
+        const startTime = Date.now();
+        await delay(initialDelay);
+        const makeRequest = async (token) => {
+            return requestWithRetry(`${apiUrl}/get-contacts`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                },
+                body: JSON.stringify({
+                    filter_id: filterId,
+                    limit: expectedCount,
+                    offset: 0,
+                }),
+            });
+        };
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            if (Date.now() - startTime > maxWaitTime) {
+                break;
+            }
+            try {
+                const token = await getAuthToken();
+                const result = await makeRequest(token);
+                if (result.success && result.data.metrics) {
+                    const { completed, totalContacts } = result.data.metrics;
+                    if (completed >= totalContacts || completed >= expectedCount) {
+                        return result;
+                    }
+                }
+                await delay(pollInterval);
+            }
+            catch (err) {
+                if (err instanceof Error && err.message.includes("401") && hasCredentials) {
+                    await handleAuthError();
+                }
+                await delay(pollInterval);
+            }
+        }
+        // Return last result
+        try {
+            const token = await getAuthToken();
+            return await makeRequest(token);
+        }
+        catch {
+            return {
+                success: false,
+                message: "Polling timed out",
+                data: {
+                    list: [],
+                    total_count: 0,
+                    metrics: {
+                        totalContacts: 0,
+                        totalEmails: 0,
+                        noEmailFound: 0,
+                        invalidEmails: 0,
+                        catchAllEmails: 0,
+                        verifiedEmails: 0,
+                        completed: 0,
+                    },
+                },
+            };
+        }
+    }
     /**
      * Fetch/enrich emails for specific contact IDs (COSTS CREDITS)
+     *
+     * Uses async polling pattern:
+     * 1. Call fetch-contacts (returns immediately with status: "pending")
+     * 2. Poll get-contacts until completed
+     * 3. Return enriched contacts with emails
      */
     async function fetchContacts(contactIds) {
-        const makeRequest = async (token) => {
+        const makeFetchRequest = async (token) => {
             return requestWithRetry(`${apiUrl}/fetch-contacts`, {
                 method: "POST",
                 headers: {
@@ -219,7 +299,30 @@ function createSmartProspectProvider(config) {
         };
         try {
             const token = await getAuthToken();
-            return await makeRequest(token);
+            const fetchResult = await makeFetchRequest(token);
+            // If fetch-contacts returns pending status with filter_id, poll for results
+            const filterId = fetchResult.data?.filter_id;
+            const status = fetchResult.data?.status;
+            if (filterId && status === "pending") {
+                const pollResult = await pollForContactResults(filterId, contactIds.length);
+                if (pollResult.success && pollResult.data.list.length > 0) {
+                    return {
+                        success: true,
+                        message: "Fetch completed",
+                        data: {
+                            list: pollResult.data.list,
+                            total_count: pollResult.data.total_count,
+                            metrics: pollResult.data.metrics,
+                            leads_found: pollResult.data.metrics.totalContacts,
+                            email_fetched: pollResult.data.metrics.totalEmails,
+                            verification_status_list: [],
+                            filter_id: filterId,
+                            status: "completed",
+                        },
+                    };
+                }
+            }
+            return fetchResult;
         }
         catch (err) {
             // On 401, clear token and retry once with fresh token
@@ -229,7 +332,7 @@ function createSmartProspectProvider(config) {
                 await handleAuthError();
                 try {
                     const freshToken = await getAuthToken();
-                    return await makeRequest(freshToken);
+                    return await makeFetchRequest(freshToken);
                 }
                 catch {
                     // Retry failed too
@@ -518,8 +621,90 @@ function createSmartProspectClient(config) {
             };
         }
     }
+    /**
+     * Poll get-contacts until email lookup is complete
+     */
+    async function pollForResults(filterId, expectedCount, pollingConfig = DEFAULT_POLLING_CONFIG) {
+        const { initialDelay, pollInterval, maxAttempts, maxWaitTime } = pollingConfig;
+        const startTime = Date.now();
+        // Wait initial delay before first poll
+        await delay(initialDelay);
+        const makeRequest = async (token) => {
+            return requestWithRetry(`${apiUrl}/get-contacts`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                },
+                body: JSON.stringify({
+                    filter_id: filterId,
+                    limit: expectedCount,
+                    offset: 0,
+                }),
+            });
+        };
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            // Check if we've exceeded max wait time
+            if (Date.now() - startTime > maxWaitTime) {
+                break;
+            }
+            try {
+                const token = await getAuthToken();
+                const result = await makeRequest(token);
+                if (result.success && result.data.metrics) {
+                    const { completed, totalContacts } = result.data.metrics;
+                    // Check if all contacts have been processed
+                    if (completed >= totalContacts || completed >= expectedCount) {
+                        return result;
+                    }
+                }
+                // Wait before next poll
+                await delay(pollInterval);
+            }
+            catch (err) {
+                // On 401, clear token and retry
+                if (err instanceof Error &&
+                    err.message.includes("401") &&
+                    hasCredentials) {
+                    await handleAuthError();
+                }
+                // Continue polling on errors
+                await delay(pollInterval);
+            }
+        }
+        // Return last result even if not complete
+        try {
+            const token = await getAuthToken();
+            return await makeRequest(token);
+        }
+        catch {
+            return {
+                success: false,
+                message: "Polling timed out",
+                data: {
+                    list: [],
+                    total_count: 0,
+                    metrics: {
+                        totalContacts: 0,
+                        totalEmails: 0,
+                        noEmailFound: 0,
+                        invalidEmails: 0,
+                        catchAllEmails: 0,
+                        verifiedEmails: 0,
+                        completed: 0,
+                    },
+                },
+            };
+        }
+    }
     /**
      * Fetch/enrich emails for specific contact IDs (COSTS CREDITS)
+     *
+     * SmartProspect uses async email lookup:
+     * 1. Call fetch-contacts to initiate lookup (returns immediately with status: "pending")
+     * 2. Poll get-contacts until metrics.completed >= expected count
+     * 3. Return the final enriched contacts with emails
      */
     async function fetch(contactIds) {
         if (!contactIds.length) {
@@ -544,7 +729,7 @@ function createSmartProspectClient(config) {
                 },
             };
         }
-        const makeRequest = async (token) => {
+        const makeFetchRequest = async (token) => {
             return requestWithRetry(`${apiUrl}/fetch-contacts`, {
                 method: "POST",
                 headers: {
@@ -557,7 +742,33 @@ function createSmartProspectClient(config) {
         };
         try {
             const token = await getAuthToken();
-            return await makeRequest(token);
+            const fetchResult = await makeFetchRequest(token);
+            // If fetch-contacts returns a filter_id with pending status, we need to poll
+            const filterId = fetchResult.data?.filter_id;
+            const status = fetchResult.data?.status;
+            if (filterId && status === "pending") {
+                // Poll get-contacts for final results
+                const pollResult = await pollForResults(filterId, contactIds.length);
+                if (pollResult.success && pollResult.data.list.length > 0) {
+                    // Convert poll result to fetch response format
+                    return {
+                        success: true,
+                        message: "Fetch completed",
+                        data: {
+                            list: pollResult.data.list,
+                            total_count: pollResult.data.total_count,
+                            metrics: pollResult.data.metrics,
+                            leads_found: pollResult.data.metrics.totalContacts,
+                            email_fetched: pollResult.data.metrics.totalEmails,
+                            verification_status_list: [],
+                            filter_id: filterId,
+                            status: "completed",
+                        },
+                    };
+                }
+            }
+            // If no polling needed or polling failed, return original result
+            return fetchResult;
         }
         catch (err) {
             if (err instanceof Error &&
@@ -566,7 +777,7 @@ function createSmartProspectClient(config) {
                 await handleAuthError();
                 try {
                     const freshToken = await getAuthToken();
-                    return await makeRequest(freshToken);
+                    return await makeFetchRequest(freshToken);
                 }
                 catch {
                     // Retry failed

package/dist/enrichment/types.d.ts

@@ -112,6 +112,10 @@ export interface EnrichmentCandidate {
     linkedin_url?: string;
     linkedinId?: string;
     linkedin_id?: string;
+    numericLinkedInId?: string;
+    numeric_linkedin_id?: string;
+    objectUrn?: string;
+    object_urn?: string;
     title?: string;
     currentRole?: string;
     current_role?: string;
@@ -436,27 +440,45 @@ export interface SmartProspectFetchResponse {
         leads_found: number;
         email_fetched: number;
         verification_status_list: string[];
+        /** Filter ID returned by fetch-contacts for polling */
+        filter_id?: string;
+        /** Status of the fetch operation: "pending" means still processing */
+        status?: string;
+    };
+}
+/**
+ * Response from get-contacts polling endpoint
+ */
+export interface SmartProspectGetContactsResponse {
+    success: boolean;
+    message: string;
+    data: {
+        list: SmartProspectContact[];
+        total_count: number;
+        metrics: {
+            totalContacts: number;
+            totalEmails: number;
+            noEmailFound: number;
+            invalidEmails: number;
+            catchAllEmails: number;
+            verifiedEmails: number;
+            completed: number;
+        };
     };
 }
 export interface LddProfileEmail {
-    email_address: string;
-    email_type?: string | null;
+    id: number;
+    emailAddress: string | null;
+    emailType: string | null;
 }
 export interface LddProfilePhone {
-    phone_number: string;
-    phone_type?: string | null;
+    id: number;
+    phoneNumber: string | null;
 }
 export interface LddProfileData {
-    source_record_id: string;
-    linkedin_profile_url?: string | null;
-    linkedin_id?: string | null;
-    linkedin_username?: string | null;
-    first_name?: string | null;
-    last_name?: string | null;
-    full_name?: string | null;
-    profile_headline?: string | null;
-    profile_summary?: string | null;
-    profile_location?: string | null;
+    sourceRecordId: string;
+    numericLinkedInId: string | null;
+    linkedInUsername: string | null;
     emails: LddProfileEmail[];
     phones: LddProfilePhone[];
 }

package/dist/http-client.js

@@ -44,7 +44,7 @@ const linkedin_config_1 = require("./utils/linkedin-config");
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function isRetryableStatus(status) {
+function _isRetryableStatus(status) {
     return (status === 429 ||
         status === 500 ||
         status === 502 ||

package/dist/linkedin-api.d.ts

@@ -1,5 +1,4 @@
-import type { SalesSearchFilters } from "./types";
-import type { LinkedInProfile, SearchSalesResult, TypeaheadResult, SalesNavigatorProfile, Company } from "./types";
+import type { SalesSearchFilters, LinkedInProfile, SearchSalesResult, TypeaheadResult, SalesNavigatorProfile, Company } from "./types";
 /**
  * Fetches a LinkedIn profile by vanity URL (public identifier).
  * Results are cached for the configured TTL (default: 15 minutes).

package/dist/parsers/profile-parser.js

@@ -102,15 +102,17 @@ function parseFullProfile(rawResponse, vanity) {
     function deepFindCompanyUrn(obj, depth = 0) {
         if (!obj || depth > 3)
             return undefined;
-        if (typeof obj === "string" && /urn:li:(?:fsd_)?company:/i.test(obj))
+        if (typeof obj === "string" && /urn:li:(?:fsd_)?company:/i.test(obj)) {
             return obj;
+        }
         if (typeof obj !== "object")
             return undefined;
         const rec = obj;
         for (const k of Object.keys(rec)) {
             const v = rec[k];
-            if (typeof v === "string" && /urn:li:(?:fsd_)?company:/i.test(v))
+            if (typeof v === "string" && /urn:li:(?:fsd_)?company:/i.test(v)) {
                 return v;
+            }
             if (v && typeof v === "object") {
                 const hit = deepFindCompanyUrn(v, depth + 1);
                 if (hit)

package/dist/utils/linkedin-config.js

@@ -52,7 +52,7 @@ function buildVoyagerHeaders(opts) {
         "x-li-track": JSON.stringify(trackPayload),
         "sec-fetch-site": "same-origin",
         "sec-fetch-mode": "cors",
-        referer: referer ?? exports.defaultOrigin + "/",
+        referer: referer ?? `${exports.defaultOrigin}/`,
         origin: exports.defaultOrigin,
     };
 }

package/dist/utils/search-encoder.js

@@ -13,22 +13,21 @@ exports.buildLeadSearchQuery = buildLeadSearchQuery;
 function stableStringify(obj) {
     if (obj === null || typeof obj !== "object")
         return JSON.stringify(obj);
-    if (Array.isArray(obj))
-        return "[" + obj.map((v) => stableStringify(v)).join(",") + "]";
+    if (Array.isArray(obj)) {
+        return `[${obj.map((v) => stableStringify(v)).join(",")}]`;
+    }
     const rec = obj;
     const keys = Object.keys(rec).sort();
-    return ("{" +
-        keys
-            .map((k) => JSON.stringify(k) + ":" + stableStringify(rec[k]))
-            .join(",") +
-        "}");
+    return (`{${keys
+        .map((k) => `${JSON.stringify(k)}:${stableStringify(rec[k])}`)
+        .join(",")}}`);
 }
 function buildFilterSignature(filters, rawQuery) {
     if (rawQuery)
-        return "rq:" + String(rawQuery).trim();
+        return `rq:${String(rawQuery).trim()}`;
     if (!filters)
         return undefined;
-    return "f:" + stableStringify(filters);
+    return `f:${stableStringify(filters)}`;
 }
 // Temporary minimal encoder: today we include only keywords in the query structure to
 // preserve existing behavior. Once facet ids are confirmed, extend this to encode filters

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkedin-secret-sauce",
-  "version": "0.6.0",
+  "version": "0.7.2",
   "description": "Private LinkedIn Sales Navigator client with automatic cookie management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,8 +15,14 @@
     "search": "node scripts/rg-fast.mjs",
     "rg:fast": "node scripts/rg-fast.mjs",
     "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "typecheck:playground": "pnpm -C apps/playground typecheck",
+    "typecheck:all": "pnpm typecheck && pnpm typecheck:playground",
     "lint": "eslint \"src/**/*.ts\" --max-warnings=0",
-    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "lint:playground": "eslint \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
+    "lint:all": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --max-warnings=0",
+    "lint:fix": "eslint \"src/**/*.ts\" \"apps/playground/src/**/*.{ts,tsx}\" \"apps/playground/server/**/*.ts\" --fix",
+    "check": "pnpm typecheck:all && pnpm lint:all",
     "dev": "tsc -w -p tsconfig.json",
     "test": "vitest run",
     "prepublishOnly": "npm run build",