linkedin-secret-sauce 0.12.4 → 0.13.0

package/dist/enrichment/matching.js

@@ -813,12 +813,41 @@ async function getEmailsForLinkedInContact(contactOrLead, config, options = {})
      * Merge emails and boost confidence when found from multiple sources
      * - 2 sources: boost to at least 95% confidence
      * - 3+ sources: boost to 100% confidence
+     *
+     * IMPORTANT: When multiple sources find the same email, we pick the
+     * most authoritative source (not just highest confidence), then boost.
+     * Source priority: ldd > smartprospect > cosiall > trykitt > bounceban > hunter > snovio > pattern
      */
     const mergeAndBoostEmails = () => {
         const mergedEmails = [];
+        // Source priority for merging (lower = higher priority)
+        const mergePriority = {
+            ldd: 0, // Highest priority - your own data
+            smartprospect: 1, // Very reliable - verified database
+            cosiall: 2, // LinkedIn profile data
+            trykitt: 3, // AI-powered finder
+            bounceban: 4, // Verification provider
+            hunter: 5, // Paid finder
+            snovio: 6, // Paid finder
+            linkedin: 7, // Company lookup only
+            pattern: 8, // Pattern guessing - lowest priority
+        };
         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);
+            // Find the best result by SOURCE PRIORITY first, then confidence
+            // This ensures SmartProspect/LDD are preferred over pattern guessing
+            const bestResult = results.reduce((best, current) => {
+                const bestPriority = mergePriority[best.source] ?? 99;
+                const currentPriority = mergePriority[current.source] ?? 99;
+                // Pick by source priority first
+                if (currentPriority < bestPriority) {
+                    return current;
+                }
+                if (currentPriority > bestPriority) {
+                    return best;
+                }
+                // Same source priority - pick higher confidence
+                return current.confidence > best.confidence ? current : best;
+            });
             // Boost confidence based on number of sources
             let boostedConfidence = bestResult.confidence;
             if (sources.size >= 3) {
@@ -874,90 +903,110 @@ async function getEmailsForLinkedInContact(contactOrLead, config, options = {})
         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));
-    }
+    // TryKitt.ai is moved to Phase 2 (after domain discovery)
+    // It needs name + domain to find emails
     // Wait for all Phase 1 free providers
     await Promise.all(freeProviderPromises);
-    // Merge emails and calculate best confidence after Phase 1
+    // Merge emails 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 + Pattern Guessing
-    // ONLY if Phase 1 confidence < threshold (to minimize LinkedIn API calls)
+    // Phase 2: Domain Discovery + FREE Email Finding (TryKitt, Pattern Guessing)
+    // FREE providers ALWAYS run - no reason to skip them
     // ==========================================================================
     let companyDomain = linkedInCompanyDomain || discoveredCompanyDomain;
-    // 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;
-                            }
+    // Try LinkedIn Company Lookup for domain discovery
+    // 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
+    }
+    // Store discovered domain in result for visibility
+    if (discoveredCompanyDomain && !linkedInCompanyDomain) {
+        result.discoveredCompanyDomain = discoveredCompanyDomain;
+    }
+    // TryKitt.ai lookup (FREE for individuals - unlimited)
+    // AI-powered email finder - runs after domain discovery
+    if (!skipTryKitt && config.trykitt?.apiKey && companyDomain) {
+        result.providersQueried.push("trykitt");
+        await queryTryKitt(contact, config.trykitt, companyDomain, addEmail, result);
+        // Re-merge after TryKitt
+        result.emails = mergeAndBoostEmails();
+    }
+    // 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();
+    }
+    // ==========================================================================
+    // Check if we already have a verified BUSINESS email from a trusted source
+    // If so, skip BounceBan and paid providers entirely
+    //
+    // NOTE: LDD and Cosiall can return personal emails (Gmail, Yahoo, etc.)
+    // Don't stop searching if we only have personal emails - keep looking for business.
+    // ==========================================================================
+    const hasVerifiedBusinessEmail = result.emails.some((e) => e.verified &&
+        e.type === "business" &&
+        (e.source === "smartprospect" ||
+            e.source === "ldd" ||
+            e.source === "cosiall" ||
+            e.source === "trykitt"));
+    const phase2BestConfidence = result.emails.length > 0
+        ? Math.max(...result.emails.map((e) => e.confidence))
+        : 0;
+    // BounceBan catch-all verification (costs $0.008/lookup)
+    // SKIP if we already have a verified BUSINESS email from SmartProspect/Cosiall/TryKitt
+    // Only run to verify pattern-guessed emails when no trusted source found a business email
+    // NOTE: LDD personal emails don't count - we still want to find the business email
+    if (!skipBounceBan &&
+        config.bounceban?.apiKey &&
+        result.emails.length > 0 &&
+        !hasVerifiedBusinessEmail && // Skip if we have a verified BUSINESS email
+        phase2BestConfidence < paidProviderThreshold) {
+        // Only verify pattern-guessed emails (the ones we're uncertain about)
+        const emailsToVerify = result.emails.filter((e) => e.source === "pattern" && !e.verified);
+        if (emailsToVerify.length > 0) {
+            result.providersQueried.push("bounceban");
+            await queryBounceBan(emailsToVerify, config.bounceban, addEmail, result);
+            // Re-merge after BounceBan verification
             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();
-            }
-        }
     }
     // Calculate final best confidence
     const finalBestConfidence = result.emails.length > 0
         ? Math.max(...result.emails.map((e) => e.confidence))
         : 0;
     // ==========================================================================
-    // Phase 3: PAID providers as last resort (Hunter/Bouncer/Snovio)
+    // Phase 3: PAID providers as LAST RESORT (Hunter then Snovio)
+    // SKIP if we already have a verified BUSINESS email
+    // NOTE: LDD personal emails don't count - we still want to find the business email
     // ==========================================================================
-    if (!skipPaidProviders && finalBestConfidence < paidProviderThreshold) {
-        // Only use paid providers if we have low confidence or no results
-        // Hunter.io - Email Finder ($0.015/lookup)
+    const hasAnyVerifiedBusinessEmail = result.emails.some((e) => e.verified && e.type === "business");
+    if (!skipPaidProviders &&
+        !hasAnyVerifiedBusinessEmail && // Skip if we have a verified BUSINESS email
+        finalBestConfidence < paidProviderThreshold) {
+        // Hunter.io - Email Finder ($0.005/lookup) - try first
         if (config.hunter?.apiKey) {
             result.providersQueried.push("hunter");
             // Extract linkedin handle from contact if available
@@ -980,10 +1029,15 @@ async function getEmailsForLinkedInContact(contactOrLead, config, options = {})
             // Re-merge after Hunter
             result.emails = mergeAndBoostEmails();
         }
-        // Snovio - Email Finder ($0.02/lookup) - best for catch-all domains
+        // Check if Hunter found a verified email - if so, skip Snovio
+        const hunterFoundVerified = result.emails.some((e) => e.source === "hunter" && e.verified);
+        // Snovio - Email Finder ($0.02/lookup) - ONLY if Hunter didn't find anything
+        // This is the absolute last resort since it's the most expensive
         if (config.snovio?.clientId &&
             config.snovio?.clientSecret &&
-            companyDomain) {
+            companyDomain &&
+            !hunterFoundVerified // Skip if Hunter already found a verified email
+        ) {
             result.providersQueried.push("snovio");
             await querySnovio(contact, config.snovio, companyDomain, addEmail, result);
             // Re-merge after Snovio
@@ -1217,20 +1271,26 @@ async function queryBounceBan(emailsToVerify, bouncebanConfig, addEmail, result)
                 useWaterfall: bouncebanConfig.useWaterfall ?? true,
             });
             if (verification && verification.status === "success") {
-                // Map BounceBan result to confidence
-                let confidence = verification.score;
+                // BounceBan specializes in catch-all verification with 97%+ accuracy
+                // Trust the score they return - don't artificially cap it
+                const 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);
-                }
+                // For catch-all domains:
+                // - "deliverable" = BounceBan's algorithm determined this specific email exists (97%+ accuracy)
+                // - "risky" = Could not determine with high confidence
+                // - "undeliverable" = Email definitely doesn't exist
                 // Only add if it's potentially deliverable
                 if (verification.result === "deliverable" ||
                     verification.result === "risky") {
+                    // For "deliverable" on catch-all, BounceBan has verified this is the REAL email
+                    // For "risky", we keep lower confidence as BounceBan couldn't determine
+                    const finalConfidence = verification.result === "deliverable"
+                        ? Math.max(confidence, 85) // Deliverable = high confidence (BounceBan verified it)
+                        : Math.min(confidence, 60); // Risky = lower confidence
                     addEmail({
                         email: verification.email,
                         source: "bounceban",
-                        confidence,
+                        confidence: finalConfidence,
                         type: "business",
                         verified,
                         isCatchAll: verification.is_accept_all,
@@ -1309,20 +1369,39 @@ async function querySmartProspect(contact, smartProspectConfig, minMatchConfiden
                 .split("/")[0]
                 .toLowerCase();
         }
-        // Fetch email for matched contact
-        const fetchResponse = await client.fetch([
-            matchResult.smartProspectContact.id,
-        ]);
+        // Fetch email for matched contact (pass filter_id from search for polling)
+        const searchFilterId = searchResponse.data.filter_id;
+        const fetchResponse = await client.fetch([matchResult.smartProspectContact.id], searchFilterId);
         if (fetchResponse.success && fetchResponse.data.list.length > 0) {
             const enrichedContact = fetchResponse.data.list[0];
             if (enrichedContact.email) {
+                // Calculate email confidence based on verification status AND match quality
+                // SmartProspect verification status: "valid", "catch_all", "invalid", etc.
+                const isVerified = enrichedContact.verificationStatus === "valid" ||
+                    enrichedContact.verificationStatus === "verified";
+                const isCatchAll = enrichedContact.verificationStatus === "catch_all";
+                // Base confidence from match quality (60-100%)
+                let emailConfidence = matchResult.confidence;
+                // Boost confidence for verified emails from SmartProspect
+                // A verified email from SmartProspect is more reliable than pattern guessing
+                if (isVerified) {
+                    emailConfidence = Math.max(emailConfidence, 90); // Verified = at least 90%
+                }
+                else if (isCatchAll) {
+                    emailConfidence = Math.max(emailConfidence, 80); // Catch-all = at least 80%
+                }
+                else if (enrichedContact.emailDeliverability > 0) {
+                    // Use deliverability score if available
+                    emailConfidence = Math.max(emailConfidence, enrichedContact.emailDeliverability * 100);
+                }
                 addEmail({
                     email: enrichedContact.email,
                     source: "smartprospect",
-                    confidence: matchResult.confidence,
+                    confidence: emailConfidence,
                     type: "business",
-                    verified: enrichedContact.verificationStatus === "verified",
+                    verified: isVerified || isCatchAll,
                     deliverability: enrichedContact.emailDeliverability,
+                    isCatchAll,
                     metadata: {
                         matchQuality: matchResult.quality,
                         matchedFields: matchResult.matchedFields,
@@ -1330,6 +1409,7 @@ async function querySmartProspect(contact, smartProspectConfig, minMatchConfiden
                         company: enrichedContact.company?.name,
                         companyWebsite: companyWebsite,
                         title: enrichedContact.title,
+                        verificationStatus: enrichedContact.verificationStatus,
                     },
                 });
             }

package/dist/enrichment/providers/bounceban.js

@@ -99,14 +99,16 @@ function extractEmailsToVerify(candidate) {
  */
 async function verifyEmailStandard(email, apiKey, apiUrl, timeoutMs, useDeepVerify) {
     const params = new URLSearchParams({
-        api_key: apiKey,
         email: email,
     });
     if (useDeepVerify) {
         params.set("mode", "deepverify");
     }
+    const url = `${apiUrl}/v1/verify/single?${params.toString()}`;
     try {
-        const response = await (0, http_retry_1.getWithRetry)(`${apiUrl}/v1/verify/single?${params.toString()}`, undefined, {
+        const response = await (0, http_retry_1.getWithRetry)(url, {
+            Authorization: apiKey,
+        }, {
             retries: 1,
             backoffMs: 500,
             timeoutMs,
@@ -114,7 +116,8 @@ async function verifyEmailStandard(email, apiKey, apiUrl, timeoutMs, useDeepVeri
         });
         return response;
     }
-    catch {
+    catch (err) {
+        console.error("[BounceBan] Standard verification failed:", err instanceof Error ? err.message : err);
         return null;
     }
 }
@@ -128,15 +131,17 @@ async function verifyEmailStandard(email, apiKey, apiUrl, timeoutMs, useDeepVeri
  */
 async function verifyEmailWaterfall(email, apiKey, waterfallApiUrl, timeoutMs, useDeepVerify) {
     const params = new URLSearchParams({
-        api_key: apiKey,
         email: email,
         timeout: String(Math.floor(timeoutMs / 1000)), // Convert to seconds
     });
     if (useDeepVerify) {
         params.set("mode", "deepverify");
     }
+    const url = `${waterfallApiUrl}/v1/verify/single?${params.toString()}`;
     try {
-        const response = await (0, http_retry_1.getWithRetry)(`${waterfallApiUrl}/v1/verify/single?${params.toString()}`, undefined, {
+        const response = await (0, http_retry_1.getWithRetry)(url, {
+            Authorization: apiKey,
+        }, {
             retries: 2, // Waterfall allows free retries within 30 mins
             backoffMs: 5000, // Wait 5s between retries as recommended
             timeoutMs: timeoutMs + 10000, // Add buffer for network
@@ -144,7 +149,8 @@ async function verifyEmailWaterfall(email, apiKey, waterfallApiUrl, timeoutMs, u
         });
         return response;
     }
-    catch {
+    catch (err) {
+        console.error("[BounceBan] Waterfall verification failed:", err instanceof Error ? err.message : err);
         return null;
     }
 }
@@ -256,9 +262,9 @@ async function submitBulkVerification(emails, apiKey, apiUrl, useDeepVerify) {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
+                Authorization: apiKey,
             },
             body: JSON.stringify({
-                api_key: apiKey,
                 emails: emails,
                 mode: useDeepVerify ? "deepverify" : "regular",
             }),
@@ -279,10 +285,13 @@ async function submitBulkVerification(emails, apiKey, apiUrl, useDeepVerify) {
 async function checkBulkStatus(taskId, apiKey, apiUrl) {
     try {
         const params = new URLSearchParams({
-            api_key: apiKey,
             id: taskId,
         });
-        const response = await fetch(`${apiUrl}/v1/verify/bulk/status?${params.toString()}`);
+        const response = await fetch(`${apiUrl}/v1/verify/bulk/status?${params.toString()}`, {
+            headers: {
+                Authorization: apiKey,
+            },
+        });
         if (!response.ok) {
             return null;
         }
@@ -301,9 +310,9 @@ async function fetchBulkResults(taskId, apiKey, apiUrl, page = 1, perPage = 100)
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
+                Authorization: apiKey,
             },
             body: JSON.stringify({
-                api_key: apiKey,
                 id: taskId,
                 page: page,
                 per_page: perPage,

package/dist/enrichment/providers/construct.js

@@ -68,104 +68,112 @@ function createConstructProvider(config) {
     const timeoutMs = config?.timeoutMs ?? 5000;
     const smtpVerifyDelayMs = config?.smtpVerifyDelayMs ?? 2000; // Delay between SMTP checks
     async function fetchEmail(candidate) {
-        const { firstName: first, lastName: last } = (0, candidate_parser_1.extractName)(candidate);
-        const { domain } = (0, candidate_parser_1.extractCompany)(candidate);
-        // Skip if missing required fields
-        if (!first || !domain) {
-            return null;
-        }
-        // Skip personal domains
-        if ((0, personal_domains_1.isPersonalDomain)(domain)) {
-            return null;
-        }
-        const candidates = buildCandidates({ first, last, domain });
-        const max = Math.min(candidates.length, maxAttempts);
-        // First, check if domain is catch-all
-        const catchAllResult = await (0, mx_1.checkDomainCatchAll)(domain, {
-            timeoutMs: 10000,
-        });
-        const isCatchAll = catchAllResult.isCatchAll;
-        // Collect ALL valid email patterns (not just first match)
-        const validEmails = [];
-        // Track all attempted patterns for debugging
-        const attemptedPatterns = [];
-        // If NOT catch-all, we can verify each email via SMTP
-        if (isCatchAll === false) {
-            // Verify emails one by one, stop when we find a valid one
-            const emailsToVerify = candidates.slice(0, max);
-            for (let i = 0; i < emailsToVerify.length; i++) {
-                const email = emailsToVerify[i];
-                // If we already found a valid email, skip the rest
-                if (validEmails.length > 0) {
-                    attemptedPatterns.push({ email, status: "skipped" });
-                    continue;
-                }
-                // Add delay between checks (except first one)
-                if (i > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, smtpVerifyDelayMs));
-                }
-                // Verify single email
-                const results = await (0, mx_1.verifyEmailsExist)([email], {
-                    delayMs: 0,
-                    timeoutMs,
-                });
-                const result = results[0];
-                if (result.exists === true) {
-                    // Email confirmed to exist!
-                    attemptedPatterns.push({ email, status: "exists" });
-                    validEmails.push({
-                        email: result.email,
-                        verified: true,
-                        confidence: 95, // High confidence - SMTP verified
-                        isCatchAll: false,
-                        metadata: {
-                            pattern: result.email.split("@")[0],
-                            mxRecords: catchAllResult.mxRecords,
-                            smtpVerified: true,
-                            attemptedPatterns, // Include what was tried
-                        },
+        try {
+            const { firstName: first, lastName: last } = (0, candidate_parser_1.extractName)(candidate);
+            const { domain } = (0, candidate_parser_1.extractCompany)(candidate);
+            // Skip if missing required fields
+            if (!first || !domain) {
+                return null;
+            }
+            // Skip personal domains
+            if ((0, personal_domains_1.isPersonalDomain)(domain)) {
+                return null;
+            }
+            const candidates = buildCandidates({ first, last, domain });
+            const max = Math.min(candidates.length, maxAttempts);
+            // First, check if domain is catch-all
+            const catchAllResult = await (0, mx_1.checkDomainCatchAll)(domain, {
+                timeoutMs: 10000,
+            });
+            const isCatchAll = catchAllResult.isCatchAll;
+            // Collect ALL valid email patterns (not just first match)
+            const validEmails = [];
+            // Track all attempted patterns for debugging
+            const attemptedPatterns = [];
+            // If NOT catch-all, we can verify each email via SMTP
+            if (isCatchAll === false) {
+                // Verify emails one by one, stop when we find a valid one
+                const emailsToVerify = candidates.slice(0, max);
+                for (let i = 0; i < emailsToVerify.length; i++) {
+                    const email = emailsToVerify[i];
+                    // If we already found a valid email, skip the rest
+                    if (validEmails.length > 0) {
+                        attemptedPatterns.push({ email, status: "skipped" });
+                        continue;
+                    }
+                    // Add delay between checks (except first one)
+                    if (i > 0) {
+                        await new Promise((resolve) => setTimeout(resolve, smtpVerifyDelayMs));
+                    }
+                    // Verify single email
+                    const results = await (0, mx_1.verifyEmailsExist)([email], {
+                        delayMs: 0,
+                        timeoutMs,
                     });
-                    // Found one! Stop checking more
-                    break;
-                }
-                else if (result.exists === false) {
-                    attemptedPatterns.push({ email, status: "not_found" });
+                    const result = results[0];
+                    if (result.exists === true) {
+                        // Email confirmed to exist!
+                        attemptedPatterns.push({ email, status: "exists" });
+                        validEmails.push({
+                            email: result.email,
+                            verified: true,
+                            confidence: 80, // Good confidence - SMTP verified pattern guess
+                            // Note: 80% is appropriate for pattern guessing with SMTP verification
+                            // Higher-priority sources like SmartProspect (90%) should rank above
+                            isCatchAll: false,
+                            metadata: {
+                                pattern: result.email.split("@")[0],
+                                mxRecords: catchAllResult.mxRecords,
+                                smtpVerified: true,
+                                attemptedPatterns, // Include what was tried
+                            },
+                        });
+                        // Found one! Stop checking more
+                        break;
+                    }
+                    else if (result.exists === false) {
+                        attemptedPatterns.push({ email, status: "not_found" });
+                    }
+                    else {
+                        attemptedPatterns.push({ email, status: "unknown" });
+                    }
                 }
-                else {
-                    attemptedPatterns.push({ email, status: "unknown" });
+                // If no valid email found, include attempted patterns in metadata
+                if (validEmails.length === 0 && attemptedPatterns.length > 0) {
+                    // Return null but could add metadata about attempts
                 }
             }
-            // If no valid email found, include attempted patterns in metadata
-            if (validEmails.length === 0 && attemptedPatterns.length > 0) {
-                // Return null but could add metadata about attempts
-            }
-        }
-        else {
-            // Catch-all or unknown - fall back to MX verification only
-            for (let i = 0; i < max; i++) {
-                const email = candidates[i];
-                const verification = await (0, mx_1.verifyEmailMx)(email, { timeoutMs });
-                if (verification.valid === true && verification.confidence >= 50) {
-                    validEmails.push({
-                        email,
-                        verified: true,
-                        confidence: verification.confidence,
-                        isCatchAll: isCatchAll ?? undefined,
-                        metadata: {
-                            pattern: email.split("@")[0],
-                            mxRecords: verification.mxRecords,
-                            smtpVerified: false,
-                        },
-                    });
+            else {
+                // Catch-all or unknown - fall back to MX verification only
+                for (let i = 0; i < max; i++) {
+                    const email = candidates[i];
+                    const verification = await (0, mx_1.verifyEmailMx)(email, { timeoutMs });
+                    if (verification.valid === true && verification.confidence >= 50) {
+                        validEmails.push({
+                            email,
+                            verified: true,
+                            confidence: verification.confidence,
+                            isCatchAll: isCatchAll ?? undefined,
+                            metadata: {
+                                pattern: email.split("@")[0],
+                                mxRecords: verification.mxRecords,
+                                smtpVerified: false,
+                            },
+                        });
+                    }
                 }
             }
+            if (validEmails.length === 0) {
+                return null;
+            }
+            // Sort by confidence
+            validEmails.sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0));
+            return { emails: validEmails };
         }
-        if (validEmails.length === 0) {
+        catch (err) {
+            console.error("[Construct] Email pattern generation failed:", err instanceof Error ? err.message : err);
             return null;
         }
-        // Sort by confidence
-        validEmails.sort((a, b) => (b.confidence ?? 0) - (a.confidence ?? 0));
-        return { emails: validEmails };
     }
     // Mark provider name for orchestrator
     fetchEmail.__name = "construct";

package/dist/enrichment/providers/cosiall.js

@@ -98,8 +98,8 @@ function createCosiallProvider(config) {
             }));
             return { emails };
         }
-        catch {
-            // Silently fail - provider failures shouldn't stop the enrichment flow
+        catch (err) {
+            console.error("[Cosiall] Profile email lookup failed:", err instanceof Error ? err.message : err);
             return null;
         }
     }