linkedin-secret-sauce 0.12.0 → 0.12.2

package/dist/enrichment/matching.js

@@ -70,8 +70,8 @@ const ldd_1 = require("./providers/ldd");
 function salesLeadToContact(lead) {
     // Use firstName/lastName directly from Sales Nav - they're already separate fields
     // This preserves exact names as shown on LinkedIn (important for SmartProspect matching)
-    const firstName = lead.firstName || '';
-    const lastName = lead.lastName || '';
+    const firstName = lead.firstName || "";
+    const lastName = lead.lastName || "";
     return {
         objectUrn: lead.objectUrn,
         entityUrn: lead.salesProfileUrn,
@@ -100,7 +100,7 @@ function salesLeadToContact(lead) {
  */
 function isSalesLeadSearchResult(input) {
     // SalesLeadSearchResult has 'name' but not 'firstName'
-    return 'name' in input && !('firstName' in input);
+    return "name" in input && !("firstName" in input);
 }
 /**
  * Normalize input to LinkedInContact - accepts either format
@@ -119,8 +119,8 @@ function normalizeToContact(input) {
  */
 function normalize(str) {
     if (!str)
-        return '';
-    return str.toLowerCase().trim().replace(/\s+/g, ' ');
+        return "";
+    return str.toLowerCase().trim().replace(/\s+/g, " ");
 }
 /**
  * Extract company name from LinkedIn position
@@ -128,15 +128,15 @@ function normalize(str) {
 function getLinkedInCompany(contact) {
     const pos = contact.currentPositions?.[0];
     if (!pos)
-        return '';
-    return pos.companyUrnResolutionResult?.name || pos.companyName || '';
+        return "";
+    return pos.companyUrnResolutionResult?.name || pos.companyName || "";
 }
 /**
  * Extract job title from LinkedIn position
  */
 function getLinkedInTitle(contact) {
     const pos = contact.currentPositions?.[0];
-    return pos?.title || '';
+    return pos?.title || "";
 }
 /**
  * Extract location parts from LinkedIn geoRegion
@@ -144,8 +144,8 @@ function getLinkedInTitle(contact) {
  */
 function parseLinkedInLocation(geoRegion) {
     if (!geoRegion)
-        return { city: '', state: '', country: '' };
-    const parts = geoRegion.split(',').map((p) => p.trim());
+        return { city: "", state: "", country: "" };
+    const parts = geoRegion.split(",").map((p) => p.trim());
     if (parts.length >= 3) {
         return {
             city: parts[0],
@@ -156,15 +156,15 @@ function parseLinkedInLocation(geoRegion) {
     else if (parts.length === 2) {
         return {
             city: parts[0],
-            state: '',
+            state: "",
             country: parts[1],
         };
     }
     else {
         return {
-            city: '',
-            state: '',
-            country: parts[0] || '',
+            city: "",
+            state: "",
+            country: parts[0] || "",
         };
     }
 }
@@ -209,7 +209,7 @@ function stringSimilarity(a, b) {
  * Check if strings match exactly (normalized)
  */
 function exactMatch(a, b) {
-    return normalize(a) === normalize(b) && normalize(a) !== '';
+    return normalize(a) === normalize(b) && normalize(a) !== "";
 }
 /**
  * Check if strings match with fuzzy tolerance
@@ -245,50 +245,52 @@ function calculateMatchConfidence(linkedin, smartprospect, options = {}) {
     // First name match
     if (exactMatch(linkedin.firstName, smartprospect.firstName)) {
         score += 20;
-        matchedFields.push('firstName:exact');
+        matchedFields.push("firstName:exact");
     }
-    else if (fuzzyNames && fuzzyMatch(linkedin.firstName, smartprospect.firstName)) {
+    else if (fuzzyNames &&
+        fuzzyMatch(linkedin.firstName, smartprospect.firstName)) {
         score += 15;
-        matchedFields.push('firstName:fuzzy');
+        matchedFields.push("firstName:fuzzy");
     }
     // Last name match
     if (exactMatch(linkedin.lastName, smartprospect.lastName)) {
         score += 20;
-        matchedFields.push('lastName:exact');
+        matchedFields.push("lastName:exact");
     }
-    else if (fuzzyNames && fuzzyMatch(linkedin.lastName, smartprospect.lastName)) {
+    else if (fuzzyNames &&
+        fuzzyMatch(linkedin.lastName, smartprospect.lastName)) {
         score += 15;
-        matchedFields.push('lastName:fuzzy');
+        matchedFields.push("lastName:fuzzy");
     }
     // === Company matching (up to 30 points) ===
     const liCompany = getLinkedInCompany(linkedin);
-    const spCompany = smartprospect.company?.name || '';
+    const spCompany = smartprospect.company?.name || "";
     if (exactMatch(liCompany, spCompany)) {
         score += 30;
-        matchedFields.push('company:exact');
+        matchedFields.push("company:exact");
     }
     else if (fuzzyCompany && fuzzyMatch(liCompany, spCompany, 0.8)) {
         score += 25;
-        matchedFields.push('company:fuzzy');
+        matchedFields.push("company:fuzzy");
     }
     else if (containsMatch(liCompany, spCompany)) {
         score += 15;
-        matchedFields.push('company:contains');
+        matchedFields.push("company:contains");
     }
     // === Title matching (up to 15 points) ===
     const liTitle = getLinkedInTitle(linkedin);
-    const spTitle = smartprospect.title || '';
+    const spTitle = smartprospect.title || "";
     if (exactMatch(liTitle, spTitle)) {
         score += 15;
-        matchedFields.push('title:exact');
+        matchedFields.push("title:exact");
     }
     else if (fuzzyMatch(liTitle, spTitle, 0.75)) {
         score += 12;
-        matchedFields.push('title:fuzzy');
+        matchedFields.push("title:fuzzy");
     }
     else if (containsMatch(liTitle, spTitle)) {
         score += 8;
-        matchedFields.push('title:contains');
+        matchedFields.push("title:contains");
     }
     // === Location matching (up to 15 points) ===
     const liLocation = parseLinkedInLocation(linkedin.geoRegion);
@@ -298,17 +300,17 @@ function calculateMatchConfidence(linkedin, smartprospect, options = {}) {
     // Country match
     if (spCountry && exactMatch(liLocation.country, smartprospect.country)) {
         score += 5;
-        matchedFields.push('country:exact');
+        matchedFields.push("country:exact");
     }
     // State match
     if (spState && exactMatch(liLocation.state, smartprospect.state)) {
         score += 5;
-        matchedFields.push('state:exact');
+        matchedFields.push("state:exact");
     }
     // City match
     if (spCity && exactMatch(liLocation.city, smartprospect.city)) {
         score += 5;
-        matchedFields.push('city:exact');
+        matchedFields.push("city:exact");
     }
     return { confidence: Math.min(100, score), matchedFields };
 }
@@ -316,22 +318,22 @@ function calculateMatchConfidence(linkedin, smartprospect, options = {}) {
  * Classify match quality based on confidence and matched fields
  */
 function classifyMatchQuality(confidence, matchedFields) {
-    const hasNameMatch = matchedFields.some((f) => f.startsWith('firstName:exact')) &&
-        matchedFields.some((f) => f.startsWith('lastName:exact'));
-    const hasCompanyMatch = matchedFields.some((f) => f.startsWith('company:'));
+    const hasNameMatch = matchedFields.some((f) => f.startsWith("firstName:exact")) &&
+        matchedFields.some((f) => f.startsWith("lastName:exact"));
+    const hasCompanyMatch = matchedFields.some((f) => f.startsWith("company:"));
     if (confidence >= 85 && hasNameMatch && hasCompanyMatch) {
-        return 'exact';
+        return "exact";
     }
     else if (confidence >= 70 && hasNameMatch) {
-        return 'high';
+        return "high";
     }
     else if (confidence >= 50) {
-        return 'medium';
+        return "medium";
     }
     else if (confidence >= 30) {
-        return 'low';
+        return "low";
     }
-    return 'none';
+    return "none";
 }
 /**
  * Find the best matching SmartProspect contact for a LinkedIn contact
@@ -399,8 +401,8 @@ function parseLinkedInSearchResponse(elements) {
     return elements.map((el) => ({
         objectUrn: el.objectUrn,
         entityUrn: el.entityUrn,
-        firstName: el.firstName || '',
-        lastName: el.lastName || '',
+        firstName: el.firstName || "",
+        lastName: el.lastName || "",
         fullName: el.fullName || undefined,
         geoRegion: el.geoRegion || undefined,
         currentPositions: el.currentPositions,
@@ -457,7 +459,7 @@ async function enrichLinkedInContact(linkedInContact, smartProspectConfig, optio
         numericLinkedInId,
         matchedContact: null,
         matchConfidence: 0,
-        matchQuality: 'none',
+        matchQuality: "none",
         matchedFields: [],
         email: null,
         emailDeliverability: 0,
@@ -468,7 +470,7 @@ async function enrichLinkedInContact(linkedInContact, smartProspectConfig, optio
     // Create SmartProspect client
     const client = (0, smartprospect_1.createSmartProspectClient)(smartProspectConfig);
     if (!client) {
-        result.error = 'Failed to create SmartProspect client - check credentials';
+        result.error = "Failed to create SmartProspect client - check credentials";
         return result;
     }
     try {
@@ -509,12 +511,16 @@ async function enrichLinkedInContact(linkedInContact, smartProspectConfig, optio
                 }
             }
             if (result.allCandidates.length === 0) {
-                result.error = 'No candidates found in SmartProspect';
+                result.error = "No candidates found in SmartProspect";
                 return result;
             }
         }
         // Step 2: Find best match using intelligent matching
-        const matchResult = findBestMatch(linkedInContact, result.allCandidates, { minConfidence, fuzzyNames, fuzzyCompany });
+        const matchResult = findBestMatch(linkedInContact, result.allCandidates, {
+            minConfidence,
+            fuzzyNames,
+            fuzzyCompany,
+        });
         if (!matchResult) {
             result.error = `No match above ${minConfidence}% confidence threshold`;
             return result;
@@ -525,7 +531,9 @@ async function enrichLinkedInContact(linkedInContact, smartProspectConfig, optio
         result.matchedFields = matchResult.matchedFields;
         // Step 3: Fetch email if auto-fetch enabled and good match (COSTS CREDITS)
         if (autoFetch && matchResult.confidence >= minConfidence) {
-            const fetchResponse = await client.fetch([matchResult.smartProspectContact.id]);
+            const fetchResponse = await client.fetch([
+                matchResult.smartProspectContact.id,
+            ]);
             if (fetchResponse.success && fetchResponse.data.list.length > 0) {
                 const enrichedContact = fetchResponse.data.list[0];
                 result.email = enrichedContact.email || null;
@@ -539,7 +547,7 @@ async function enrichLinkedInContact(linkedInContact, smartProspectConfig, optio
         return result;
     }
     catch (err) {
-        result.error = err instanceof Error ? err.message : 'Unknown error';
+        result.error = err instanceof Error ? err.message : "Unknown error";
         return result;
     }
 }
@@ -604,7 +612,7 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
                 numericLinkedInId,
                 matchedContact: null,
                 matchConfidence: 0,
-                matchQuality: 'none',
+                matchQuality: "none",
                 matchedFields: [],
                 email: null,
                 emailDeliverability: 0,
@@ -634,7 +642,9 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
                 result.allCandidates = searchResponse.data.list;
                 result.totalCandidatesFound = searchResponse.data.total_count;
                 // Broader search fallback
-                if (searchResponse.data.list.length === 0 && includeCompany && filters.companyName) {
+                if (searchResponse.data.list.length === 0 &&
+                    includeCompany &&
+                    filters.companyName) {
                     const broaderResponse = await client.search({
                         firstName: filters.firstName,
                         lastName: filters.lastName,
@@ -646,7 +656,7 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
                     }
                 }
                 if (result.allCandidates.length === 0) {
-                    result.error = 'No candidates found in SmartProspect';
+                    result.error = "No candidates found in SmartProspect";
                     return result;
                 }
                 const matchResult = findBestMatch(contact, result.allCandidates, {
@@ -663,12 +673,16 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
                 result.matchQuality = matchResult.quality;
                 result.matchedFields = matchResult.matchedFields;
                 if (autoFetch && matchResult.confidence >= minConfidence) {
-                    const fetchResponse = await client.fetch([matchResult.smartProspectContact.id]);
+                    const fetchResponse = await client.fetch([
+                        matchResult.smartProspectContact.id,
+                    ]);
                     if (fetchResponse.success && fetchResponse.data.list.length > 0) {
                         const enrichedContact = fetchResponse.data.list[0];
                         result.email = enrichedContact.email || null;
-                        result.emailDeliverability = enrichedContact.emailDeliverability || 0;
-                        result.verificationStatus = enrichedContact.verificationStatus || null;
+                        result.emailDeliverability =
+                            enrichedContact.emailDeliverability || 0;
+                        result.verificationStatus =
+                            enrichedContact.verificationStatus || null;
                         result.matchedContact = enrichedContact;
                     }
                 }
@@ -676,7 +690,7 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
                 return result;
             }
             catch (err) {
-                result.error = err instanceof Error ? err.message : 'Unknown error';
+                result.error = err instanceof Error ? err.message : "Unknown error";
                 return result;
             }
         },
@@ -766,7 +780,7 @@ function createLinkedInEnricher(smartProspectConfig, defaultOptions = {}) {
 async function getEmailsForLinkedInContact(contactOrLead, config, options = {}) {
     // Normalize input - accept either LinkedInContact or raw SalesLeadSearchResult
     const contact = normalizeToContact(contactOrLead);
-    const { skipLdd = false, skipSmartProspect = false, skipPatternGuessing = false, skipPaidProviders = false, minMatchConfidence = 60, paidProviderThreshold = 80, includeCompany = true, } = options;
+    const { skipLdd = false, skipSmartProspect = false, skipCosiall = false, skipTryKitt = false, skipPatternGuessing = false, skipBounceBan = false, skipPaidProviders = false, minMatchConfidence = 60, paidProviderThreshold = 80, includeCompany = true, } = options;
     // Extract numeric ID from objectUrn
     const numericLinkedInId = (0, ldd_1.extractNumericLinkedInId)(contact.objectUrn);
     // Extract company domain from contact (LinkedIn data - often missing)
@@ -778,113 +792,220 @@ async function getEmailsForLinkedInContact(contactOrLead, config, options = {})
         providersQueried: [],
         errors: [],
     };
-    // Track seen emails to deduplicate
-    const seenEmails = new Set();
+    // Track all emails with their sources for confidence boosting
+    const emailsByAddress = new Map();
     const addEmail = (emailResult) => {
         const lower = emailResult.email.toLowerCase();
-        if (!seenEmails.has(lower)) {
-            seenEmails.add(lower);
-            result.emails.push(emailResult);
+        const existing = emailsByAddress.get(lower);
+        if (existing) {
+            // Email already found from another source - track for confidence boosting
+            existing.results.push(emailResult);
+            existing.sources.add(emailResult.source);
+        }
+        else {
+            emailsByAddress.set(lower, {
+                results: [emailResult],
+                sources: new Set([emailResult.source]),
+            });
+        }
+    };
+    /**
+     * Merge emails and boost confidence when found from multiple sources
+     * - 2 sources: boost to at least 95% confidence
+     * - 3+ sources: boost to 100% confidence
+     */
+    const mergeAndBoostEmails = () => {
+        const mergedEmails = [];
+        for (const [_email, { results, sources }] of emailsByAddress) {
+            // Find the best result (highest confidence)
+            const bestResult = results.reduce((best, current) => current.confidence > best.confidence ? current : best);
+            // Boost confidence based on number of sources
+            let boostedConfidence = bestResult.confidence;
+            if (sources.size >= 3) {
+                boostedConfidence = 100;
+            }
+            else if (sources.size === 2) {
+                boostedConfidence = Math.max(boostedConfidence, 95);
+            }
+            // Create merged result
+            const mergedResult = {
+                ...bestResult,
+                confidence: boostedConfidence,
+                metadata: {
+                    ...bestResult.metadata,
+                    foundBySources: Array.from(sources),
+                    sourceCount: sources.size,
+                    confidenceBoosted: sources.size > 1,
+                    originalConfidence: bestResult.confidence,
+                },
+            };
+            // If verified by any source, mark as verified
+            if (results.some((r) => r.verified)) {
+                mergedResult.verified = true;
+            }
+            mergedEmails.push(mergedResult);
         }
+        return mergedEmails;
     };
     // Track company domain discovered from SmartProspect (since LinkedIn doesn't provide it)
     let discoveredCompanyDomain = null;
     // ==========================================================================
-    // Phase 1: FREE providers in PARALLEL (LDD + SmartProspect)
+    // Phase 1: FREE database providers in PARALLEL (no LinkedIn API calls)
+    // LDD + SmartProspect + Cosiall - these are your own databases or already paid
     // ==========================================================================
     const freeProviderPromises = [];
-    // LDD lookup (FREE)
+    // LDD lookup (FREE - your ~500M database)
     if (!skipLdd && config.ldd?.apiUrl && config.ldd?.apiToken) {
-        result.providersQueried.push('ldd');
+        result.providersQueried.push("ldd");
         freeProviderPromises.push(queryLdd(contact, config.ldd, numericLinkedInId, addEmail, result));
     }
-    // SmartProspect lookup (FREE for FlexIQ)
-    // This also extracts company domain for pattern guessing
+    // SmartProspect lookup (FREE for FlexIQ - already paying monthly)
+    // This also extracts company domain for pattern guessing (no extra API call)
     if (!skipSmartProspect && config.smartprospect) {
-        result.providersQueried.push('smartprospect');
-        freeProviderPromises.push(querySmartProspect(contact, config.smartprospect, minMatchConfidence, includeCompany, addEmail, result)
-            .then((domain) => {
+        result.providersQueried.push("smartprospect");
+        freeProviderPromises.push(querySmartProspect(contact, config.smartprospect, minMatchConfidence, includeCompany, addEmail, result).then((domain) => {
             if (domain) {
                 discoveredCompanyDomain = domain;
             }
         }));
     }
-    // Wait for both free providers
+    // Cosiall Profile Emails lookup (FREE - your database)
+    if (!skipCosiall && config.cosiall?.enabled !== false) {
+        result.providersQueried.push("cosiall");
+        freeProviderPromises.push(queryCosiall(contact, addEmail, result));
+    }
+    // TryKitt.ai lookup (FREE for individuals - unlimited)
+    // AI-powered email finder with enterprise identity server catch-all verification
+    if (!skipTryKitt && config.trykitt?.apiKey) {
+        result.providersQueried.push("trykitt");
+        freeProviderPromises.push(queryTryKitt(contact, config.trykitt, linkedInCompanyDomain || discoveredCompanyDomain, addEmail, result));
+    }
+    // Wait for all Phase 1 free providers
     await Promise.all(freeProviderPromises);
-    // Check if we have good enough results already
-    const bestConfidenceAfterFreeProviders = result.emails.length > 0
-        ? Math.max(...result.emails.map(e => e.confidence))
+    // Merge emails and calculate best confidence after Phase 1
+    result.emails = mergeAndBoostEmails();
+    const phase1BestConfidence = result.emails.length > 0
+        ? Math.max(...result.emails.map((e) => e.confidence))
         : 0;
     // ==========================================================================
-    // Phase 2: Domain Discovery (if needed for pattern guessing)
+    // Phase 2: Domain Discovery + Pattern Guessing
+    // ONLY if Phase 1 confidence < threshold (to minimize LinkedIn API calls)
     // ==========================================================================
-    // Priority: LinkedIn contact data > SmartProspect > LinkedIn Company API
     let companyDomain = linkedInCompanyDomain || discoveredCompanyDomain;
-    // If no domain yet and pattern guessing is enabled, try LinkedIn company lookup
-    if (!companyDomain &&
-        !skipPatternGuessing &&
-        !options.skipLinkedInCompanyLookup &&
-        config.linkedInCompanyLookup &&
-        bestConfidenceAfterFreeProviders < paidProviderThreshold) {
-        // Extract company ID from companyUrn
-        const companyUrn = contact.currentPositions?.[0]?.companyUrn;
-        if (companyUrn) {
-            const companyId = extractCompanyIdFromUrn(companyUrn);
-            if (companyId) {
-                result.providersQueried.push('linkedin');
-                try {
-                    const company = await config.linkedInCompanyLookup(companyId);
-                    if (company?.websiteUrl) {
-                        companyDomain = extractDomainFromUrl(company.websiteUrl);
-                        if (companyDomain) {
-                            discoveredCompanyDomain = companyDomain;
+    // Skip Phase 2 entirely if we already have high confidence emails
+    if (phase1BestConfidence < paidProviderThreshold) {
+        // Try LinkedIn Company Lookup for domain discovery (EXPENSIVE - uses LinkedIn API)
+        // Only if we don't have a domain yet
+        if (!companyDomain &&
+            !skipPatternGuessing &&
+            !options.skipLinkedInCompanyLookup &&
+            config.linkedInCompanyLookup) {
+            const companyUrn = contact.currentPositions?.[0]?.companyUrn;
+            if (companyUrn) {
+                const companyId = extractCompanyIdFromUrn(companyUrn);
+                if (companyId) {
+                    result.providersQueried.push("linkedin");
+                    try {
+                        const company = await config.linkedInCompanyLookup(companyId);
+                        if (company?.websiteUrl) {
+                            companyDomain = extractDomainFromUrl(company.websiteUrl);
+                            if (companyDomain) {
+                                discoveredCompanyDomain = companyDomain;
+                            }
                         }
                     }
-                }
-                catch (err) {
-                    result.errors?.push(`LinkedIn: ${err instanceof Error ? err.message : 'Company lookup failed'}`);
+                    catch (err) {
+                        result.errors?.push(`LinkedIn: ${err instanceof Error ? err.message : "Company lookup failed"}`);
+                    }
                 }
             }
         }
+        // Store discovered domain in result for visibility
+        if (discoveredCompanyDomain && !linkedInCompanyDomain) {
+            result.discoveredCompanyDomain = discoveredCompanyDomain;
+        }
+        // Run pattern guessing if we have a domain (from LinkedIn contact, SmartProspect, or LinkedIn API)
+        if (!skipPatternGuessing && companyDomain) {
+            result.providersQueried.push("pattern");
+            await queryPatternGuessing(contact, companyDomain, addEmail, result);
+            // Re-merge after pattern guessing
+            result.emails = mergeAndBoostEmails();
+        }
+        // BounceBan catch-all verification (FREE single emails)
+        // Use BounceBan to verify pattern-guessed emails, especially on catch-all domains
+        if (!skipBounceBan &&
+            config.bounceban?.apiKey &&
+            result.emails.length > 0) {
+            // Only verify emails that are from pattern guessing or have low confidence
+            const emailsToVerify = result.emails
+                .filter((e) => e.source === "pattern" || (e.confidence < 80 && !e.verified))
+                .slice(0, 3); // Verify top 3 to save credits
+            if (emailsToVerify.length > 0) {
+                result.providersQueried.push("bounceban");
+                await queryBounceBan(emailsToVerify, config.bounceban, addEmail, result);
+                // Re-merge after BounceBan verification
+                result.emails = mergeAndBoostEmails();
+            }
+        }
     }
-    // Store discovered domain in result for visibility
-    if (discoveredCompanyDomain && !linkedInCompanyDomain) {
-        result.discoveredCompanyDomain = discoveredCompanyDomain;
-    }
-    // ==========================================================================
-    // Phase 3: Email pattern guessing with MX verification (FREE)
-    // ==========================================================================
-    if (!skipPatternGuessing && companyDomain && bestConfidenceAfterFreeProviders < paidProviderThreshold) {
-        result.providersQueried.push('pattern');
-        await queryPatternGuessing(contact, companyDomain, addEmail, result);
-    }
-    // Recalculate best confidence
+    // Calculate final best confidence
     const finalBestConfidence = result.emails.length > 0
-        ? Math.max(...result.emails.map(e => e.confidence))
+        ? Math.max(...result.emails.map((e) => e.confidence))
         : 0;
     // ==========================================================================
     // Phase 3: PAID providers as last resort (Hunter/Bouncer/Snovio)
     // ==========================================================================
     if (!skipPaidProviders && finalBestConfidence < paidProviderThreshold) {
         // Only use paid providers if we have low confidence or no results
-        // TODO: Implement Hunter, Bouncer, Snovio providers when needed
-        // For now, just mark that we would have queried them
-        if (config.hunter?.apiKey || config.bouncer?.apiKey || config.snovio?.userId) {
-            // result.providersQueried.push('hunter');
-            // result.providersQueried.push('bouncer');
-            // result.providersQueried.push('snovio');
-            // await queryPaidProviders(contact, config, addEmail, result);
+        // Hunter.io - Email Finder ($0.005/lookup)
+        if (config.hunter?.apiKey) {
+            result.providersQueried.push("hunter");
+            // Extract linkedin handle from contact if available
+            // Note: For best results, caller should fetch profile with getSalesNavigatorProfileFull
+            // and extract handle using extractLinkedInHandle(profile.flagshipProfileUrl)
+            let linkedinHandle = null;
+            // Try to extract from entityUrn or any linkedin URL fields
+            // (These won't typically have the vanity, but check anyway)
+            const contactAny = contact;
+            if (contactAny.linkedinHandle) {
+                linkedinHandle = String(contactAny.linkedinHandle);
+            }
+            else if (contactAny.flagshipProfileUrl) {
+                // Extract handle from flagship URL
+                const match = String(contactAny.flagshipProfileUrl).match(/linkedin\.com\/in\/([^\/\?]+)/i);
+                if (match)
+                    linkedinHandle = match[1];
+            }
+            await queryHunter(contact, config.hunter, companyDomain || null, linkedinHandle, addEmail, result);
+            // Re-merge after Hunter
+            result.emails = mergeAndBoostEmails();
         }
+        // Snovio - Email Finder ($0.02/lookup) - best for catch-all domains
+        if (config.snovio?.userId && config.snovio?.apiSecret && companyDomain) {
+            result.providersQueried.push("snovio");
+            await querySnovio(contact, config.snovio, companyDomain, addEmail, result);
+            // Re-merge after Snovio
+            result.emails = mergeAndBoostEmails();
+        }
+        // Note: Bouncer is a VERIFICATION provider (verifies existing emails).
+        // It's automatically used by the construct provider for SMTP verification.
+        // No need to call it separately here since pattern guessing already uses
+        // the built-in mx verification which is similar to Bouncer.
     }
+    // Final merge (in case paid providers added emails) and sort
+    result.emails = mergeAndBoostEmails();
     // Sort emails by confidence (highest first), then by source priority
     const sourcePriority = {
         ldd: 0, // Highest priority - your own data
         smartprospect: 1,
-        linkedin: 2, // LinkedIn company lookup (for domain discovery, doesn't provide emails)
-        pattern: 3,
-        hunter: 4,
-        bouncer: 5,
-        snovio: 6,
+        cosiall: 2, // Cosiall Profile Emails (FREE)
+        trykitt: 3, // TryKitt.ai (FREE for individuals)
+        linkedin: 4, // LinkedIn company lookup (for domain discovery, doesn't provide emails)
+        pattern: 5,
+        bounceban: 6, // BounceBan catch-all verification (FREE single)
+        hunter: 7,
+        bouncer: 8,
+        snovio: 9,
     };
     result.emails.sort((a, b) => {
         if (b.confidence !== a.confidence) {
@@ -920,12 +1041,15 @@ function extractDomainFromUrl(url) {
     if (!url)
         return null;
     try {
-        const fullUrl = url.startsWith('http') ? url : `https://${url}`;
-        return new URL(fullUrl).hostname.replace(/^www\./, '').toLowerCase();
+        const fullUrl = url.startsWith("http") ? url : `https://${url}`;
+        return new URL(fullUrl).hostname.replace(/^www\./, "").toLowerCase();
     }
     catch {
         // If URL parsing fails, try simple extraction
-        return url.replace(/^(https?:\/\/)?(www\.)?/, '').split('/')[0].toLowerCase() || null;
+        return (url
+            .replace(/^(https?:\/\/)?(www\.)?/, "")
+            .split("/")[0]
+            .toLowerCase() || null);
     }
 }
 /**
@@ -950,13 +1074,13 @@ async function queryLdd(contact, lddConfig, numericLinkedInId, addEmail, result)
             firstName: contact.firstName,
             lastName: contact.lastName,
         });
-        if (lddResult && 'emails' in lddResult && lddResult.emails.length > 0) {
+        if (lddResult && "emails" in lddResult && lddResult.emails.length > 0) {
             for (const emailData of lddResult.emails) {
                 addEmail({
                     email: emailData.email,
-                    source: 'ldd',
+                    source: "ldd",
                     confidence: emailData.confidence ?? 90,
-                    type: emailData.metadata?.emailTypeClassified || 'unknown',
+                    type: emailData.metadata?.emailTypeClassified || "unknown",
                     verified: emailData.verified ?? true,
                     metadata: emailData.metadata,
                 });
@@ -964,7 +1088,166 @@ async function queryLdd(contact, lddConfig, numericLinkedInId, addEmail, result)
         }
     }
     catch (err) {
-        result.errors?.push(`LDD: ${err instanceof Error ? err.message : 'Unknown error'}`);
+        result.errors?.push(`LDD: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+}
+/**
+ * Query Cosiall Profile Emails provider
+ */
+async function queryCosiall(contact, addEmail, result) {
+    try {
+        // Import dynamically to avoid circular deps
+        const { fetchProfileEmailsFromCosiall } = await Promise.resolve().then(() => __importStar(require("../cosiall-client")));
+        // Build lookup parameters from contact
+        const objectUrn = contact.objectUrn;
+        const linkedInUrl = contact.entityUrn
+            ? undefined // entityUrn is not a URL
+            : undefined;
+        // Extract vanity from contact if available
+        // (LinkedInContact doesn't have direct username field, but could be derived)
+        // Must have at least objectUrn to query Cosiall
+        if (!objectUrn) {
+            return; // Silently skip - no identifier available
+        }
+        const cosiallResult = await fetchProfileEmailsFromCosiall({
+            objectUrn,
+            linkedInUrl,
+        });
+        if (cosiallResult.emails && cosiallResult.emails.length > 0) {
+            for (const email of cosiallResult.emails) {
+                addEmail({
+                    email,
+                    source: "cosiall",
+                    confidence: 85, // Good confidence - profile-associated emails
+                    type: "unknown", // Cosiall doesn't classify email type
+                    verified: true, // These are from LinkedIn profiles
+                    metadata: {
+                        profileId: cosiallResult.profileId,
+                        objectUrn: cosiallResult.objectUrn,
+                        linkedInUrl: cosiallResult.linkedInUrl,
+                    },
+                });
+            }
+        }
+    }
+    catch (err) {
+        // Silently fail for NOT_FOUND - just means profile not in database
+        const errorMessage = err instanceof Error ? err.message : "Unknown error";
+        if (!errorMessage.includes("not found") &&
+            !errorMessage.includes("NOT_FOUND")) {
+            result.errors?.push(`Cosiall: ${errorMessage}`);
+        }
+    }
+}
+/**
+ * Query TryKitt.ai provider (FREE for individuals)
+ * AI-powered email finder with enterprise identity server catch-all verification
+ */
+async function queryTryKitt(contact, trykittConfig, companyDomain, addEmail, result) {
+    try {
+        // Import TryKitt provider dynamically
+        const { createTryKittProvider } = await Promise.resolve().then(() => __importStar(require("./providers/trykitt")));
+        const trykittProvider = createTryKittProvider(trykittConfig);
+        // Build candidate with available data
+        const fullName = contact.fullName || `${contact.firstName} ${contact.lastName}`.trim();
+        // Need both name and domain to search
+        if (!fullName || !companyDomain) {
+            return; // Silently skip - missing required data
+        }
+        const candidate = {
+            fullName,
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+            domain: companyDomain,
+        };
+        // Add LinkedIn URL if available (improves TryKitt accuracy)
+        if (contact.entityUrn) {
+            // entityUrn is like "urn:li:fs_salesProfile:..." - not useful for TryKitt
+        }
+        const trykittResult = await trykittProvider(candidate);
+        if (trykittResult) {
+            // Single result
+            if ("email" in trykittResult && trykittResult.email) {
+                addEmail({
+                    email: trykittResult.email,
+                    source: "trykitt",
+                    confidence: trykittResult.score ?? 80,
+                    type: "business",
+                    verified: trykittResult.verified ?? false,
+                    metadata: {
+                        provider: "trykitt",
+                        aiPowered: true,
+                    },
+                });
+            }
+            // Multi result
+            else if ("emails" in trykittResult) {
+                const multiResult = trykittResult;
+                for (const emailData of multiResult.emails) {
+                    addEmail({
+                        email: emailData.email,
+                        source: "trykitt",
+                        confidence: emailData.confidence ?? 70,
+                        type: "business",
+                        verified: emailData.verified ?? false,
+                        isCatchAll: emailData.isCatchAll,
+                        metadata: emailData.metadata,
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        result.errors?.push(`TryKitt: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+}
+/**
+ * Query BounceBan for catch-all verification
+ * Verifies pattern-guessed emails with 85-95% accuracy on catch-all domains
+ */
+async function queryBounceBan(emailsToVerify, bouncebanConfig, addEmail, result) {
+    try {
+        // Import BounceBan provider dynamically
+        const { verifyEmailWithBounceBan } = await Promise.resolve().then(() => __importStar(require("./providers/bounceban")));
+        for (const emailResult of emailsToVerify) {
+            const verification = await verifyEmailWithBounceBan(emailResult.email, {
+                apiKey: bouncebanConfig.apiKey,
+                useDeepVerify: bouncebanConfig.useDeepVerify ?? false,
+                useWaterfall: bouncebanConfig.useWaterfall ?? true,
+            });
+            if (verification && verification.status === "success") {
+                // Map BounceBan result to confidence
+                let confidence = verification.score;
+                const verified = verification.result === "deliverable";
+                // Reduce confidence for catch-all domains even if deliverable
+                if (verification.is_accept_all && verified) {
+                    confidence = Math.min(confidence, 75);
+                }
+                // Only add if it's potentially deliverable
+                if (verification.result === "deliverable" ||
+                    verification.result === "risky") {
+                    addEmail({
+                        email: verification.email,
+                        source: "bounceban",
+                        confidence,
+                        type: "business",
+                        verified,
+                        isCatchAll: verification.is_accept_all,
+                        metadata: {
+                            bounceBanResult: verification.result,
+                            bounceBanScore: verification.score,
+                            smtpProvider: verification.smtp_provider,
+                            isDisposable: verification.is_disposable,
+                            isRole: verification.is_role,
+                            originalSource: emailResult.source,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        result.errors?.push(`BounceBan: ${err instanceof Error ? err.message : "Unknown error"}`);
     }
 }
 /**
@@ -975,7 +1258,7 @@ async function querySmartProspect(contact, smartProspectConfig, minMatchConfiden
     try {
         const client = (0, smartprospect_1.createSmartProspectClient)(smartProspectConfig);
         if (!client) {
-            result.errors?.push('SmartProspect: Failed to create client');
+            result.errors?.push("SmartProspect: Failed to create client");
             return null;
         }
         // Build search filters
@@ -1021,21 +1304,23 @@ async function querySmartProspect(contact, smartProspectConfig, minMatchConfiden
         if (companyWebsite) {
             // Clean up the domain (remove protocol, www, trailing slashes)
             discoveredDomain = companyWebsite
-                .replace(/^(https?:\/\/)?(www\.)?/, '')
-                .split('/')[0]
+                .replace(/^(https?:\/\/)?(www\.)?/, "")
+                .split("/")[0]
                 .toLowerCase();
         }
         // Fetch email for matched contact
-        const fetchResponse = await client.fetch([matchResult.smartProspectContact.id]);
+        const fetchResponse = await client.fetch([
+            matchResult.smartProspectContact.id,
+        ]);
         if (fetchResponse.success && fetchResponse.data.list.length > 0) {
             const enrichedContact = fetchResponse.data.list[0];
             if (enrichedContact.email) {
                 addEmail({
                     email: enrichedContact.email,
-                    source: 'smartprospect',
+                    source: "smartprospect",
                     confidence: matchResult.confidence,
-                    type: 'business',
-                    verified: enrichedContact.verificationStatus === 'verified',
+                    type: "business",
+                    verified: enrichedContact.verificationStatus === "verified",
                     deliverability: enrichedContact.emailDeliverability,
                     metadata: {
                         matchQuality: matchResult.quality,
@@ -1051,7 +1336,7 @@ async function querySmartProspect(contact, smartProspectConfig, minMatchConfiden
         return discoveredDomain;
     }
     catch (err) {
-        result.errors?.push(`SmartProspect: ${err instanceof Error ? err.message : 'Unknown error'}`);
+        result.errors?.push(`SmartProspect: ${err instanceof Error ? err.message : "Unknown error"}`);
         return null;
     }
 }
@@ -1061,20 +1346,25 @@ async function querySmartProspect(contact, smartProspectConfig, minMatchConfiden
 async function queryPatternGuessing(contact, companyDomain, addEmail, result) {
     try {
         // Import construct provider dynamically to avoid circular deps
-        const { createConstructProvider } = await Promise.resolve().then(() => __importStar(require('./providers/construct')));
-        const constructProvider = createConstructProvider({ maxAttempts: 12, timeoutMs: 3000 });
+        const { createConstructProvider } = await Promise.resolve().then(() => __importStar(require("./providers/construct")));
+        const constructProvider = createConstructProvider({
+            maxAttempts: 12,
+            timeoutMs: 3000,
+        });
         const constructResult = await constructProvider({
             firstName: contact.firstName,
             lastName: contact.lastName,
             domain: companyDomain,
         });
-        if (constructResult && 'emails' in constructResult && constructResult.emails.length > 0) {
+        if (constructResult &&
+            "emails" in constructResult &&
+            constructResult.emails.length > 0) {
             for (const emailData of constructResult.emails) {
                 addEmail({
                     email: emailData.email,
-                    source: 'pattern',
+                    source: "pattern",
                     confidence: emailData.confidence ?? 50,
-                    type: 'business',
+                    type: "business",
                     verified: emailData.verified ?? false,
                     isCatchAll: emailData.isCatchAll,
                     metadata: emailData.metadata,
@@ -1083,7 +1373,120 @@ async function queryPatternGuessing(contact, companyDomain, addEmail, result) {
         }
     }
     catch (err) {
-        result.errors?.push(`Pattern: ${err instanceof Error ? err.message : 'Unknown error'}`);
+        result.errors?.push(`Pattern: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+}
+/**
+ * Query Hunter.io Email Finder (PAID provider)
+ *
+ * Supports multiple modes:
+ * 1. linkedin_handle - Most accurate (requires getSalesNavigatorProfileFull to get handle)
+ * 2. domain + first_name + last_name
+ * 3. company + first_name + last_name
+ */
+async function queryHunter(contact, hunterConfig, companyDomain, linkedinHandle, addEmail, result) {
+    try {
+        // Import Hunter provider dynamically
+        const { createHunterProvider } = await Promise.resolve().then(() => __importStar(require("./providers/hunter")));
+        const hunterProvider = createHunterProvider(hunterConfig);
+        // Build candidate with all available data
+        const candidate = {
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+        };
+        // Add linkedin_handle if available (best for Hunter)
+        if (linkedinHandle) {
+            candidate.linkedinHandle = linkedinHandle;
+        }
+        // Add domain if available
+        if (companyDomain) {
+            candidate.domain = companyDomain;
+        }
+        // Add company name if available
+        const companyName = contact.currentPositions?.[0]?.companyName;
+        if (companyName) {
+            candidate.company = companyName;
+        }
+        const hunterResult = await hunterProvider(candidate);
+        if (hunterResult) {
+            // Single result
+            if ("email" in hunterResult && hunterResult.email) {
+                addEmail({
+                    email: hunterResult.email,
+                    source: "hunter",
+                    confidence: hunterResult.score ?? 70,
+                    type: "business",
+                    verified: hunterResult.verified ?? false,
+                    metadata: {
+                        usedLinkedInHandle: !!linkedinHandle,
+                        usedDomain: !!companyDomain,
+                        usedCompany: !!companyName && !companyDomain && !linkedinHandle,
+                    },
+                });
+            }
+            // Multi result (from domain-search)
+            else if ("emails" in hunterResult && hunterResult.emails.length > 0) {
+                for (const emailData of hunterResult.emails) {
+                    addEmail({
+                        email: emailData.email,
+                        source: "hunter",
+                        confidence: emailData.confidence ?? 60,
+                        type: "business",
+                        verified: emailData.verified ?? false,
+                        metadata: emailData.metadata,
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        result.errors?.push(`Hunter: ${err instanceof Error ? err.message : "Unknown error"}`);
+    }
+}
+/**
+ * Query Snovio for email addresses
+ */
+async function querySnovio(contact, snovioConfig, companyDomain, addEmail, result) {
+    try {
+        // Import Snovio provider dynamically
+        const { createSnovioProvider } = await Promise.resolve().then(() => __importStar(require("./providers/snovio")));
+        const snovioProvider = createSnovioProvider(snovioConfig);
+        // Build candidate with available data
+        const candidate = {
+            firstName: contact.firstName,
+            lastName: contact.lastName,
+            domain: companyDomain,
+        };
+        const snovioResult = await snovioProvider(candidate);
+        if (snovioResult) {
+            // Single result
+            if ("email" in snovioResult && snovioResult.email) {
+                addEmail({
+                    email: snovioResult.email,
+                    source: "snovio",
+                    confidence: snovioResult.score ?? 70,
+                    type: "business",
+                    verified: snovioResult.verified ?? false,
+                });
+            }
+            // Multi result
+            else if ("emails" in snovioResult && snovioResult.emails.length > 0) {
+                for (const emailData of snovioResult.emails) {
+                    addEmail({
+                        email: emailData.email,
+                        source: "snovio",
+                        confidence: emailData.confidence ?? 60,
+                        type: "business",
+                        verified: emailData.verified ?? false,
+                        isCatchAll: emailData.isCatchAll,
+                        metadata: emailData.metadata,
+                    });
+                }
+            }
+        }
+    }
+    catch (err) {
+        result.errors?.push(`Snovio: ${err instanceof Error ? err.message : "Unknown error"}`);
     }
 }
 /**