Allow LinkedIn generation for contacts with no email but a LinkedIn URL

Apollo CSV exports frequently can't verify an email but still include a
valid LinkedIn profile URL — generate_linkedin_sequence() was hard-
requiring an email and failing these contacts entirely, even though
LinkedIn sending never uses email (it already resolves the profile from
the LinkedIn URL at send time). Also fixes contact field extraction
(both email and LinkedIn generation) to recognize Apollo's actual
column names like "Company Name" instead of only "Company", which was
silently leaving company blank for every Apollo-sourced contact.

- gpt_service.py: case-insensitive field lookup with the same alias
list main.py already uses elsewhere; LinkedIn generation now only
requires a name, email, or LinkedIn URL — not specifically an email.
Email generation still requires an email (needed to actually send).
- Give generate_email_sequence the same typed generation_failed marker
treatment as LinkedIn instead of silently returning fake fallback
email content on error.
- main.py: surface email-generation failures as contact_error SSE
events (previously only LinkedIn failures were surfaced this way);
include the contact's name in failure events so a no-email contact
shows up as "Jane Doe" instead of "Unknown contact".
- mergeSequenceIntoContacts.js: match generated content back to the
right contact by the stable per-row id instead of firstName+lastName
+email, so two different no-email contacts can never collide.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

backend/app/gpt_service.py

@@ -16,6 +16,24 @@ logger = logging.getLogger(__name__)
 client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
 
 
+def _pick_contact_field(contact: Dict, aliases: List[str]) -> str:
+    """Case-insensitive lookup across CSV column name variants (e.g. Apollo exports use
+    "Company Name" / "Company Name for Emails" rather than a plain "Company" column)."""
+    if not isinstance(contact, dict):
+        return ""
+    lowered = {str(k).strip().lower(): v for k, v in contact.items()}
+    for alias in aliases:
+        val = lowered.get(alias.lower())
+        if val is None:
+            continue
+        if isinstance(val, float) and math.isnan(val):
+            continue
+        s = str(val).strip()
+        if s and s.lower() != "nan":
+            return s
+    return ""
+
+
 def normalize_email_body_format(
     body: str,
     *,
@@ -166,15 +184,18 @@ def generate_email_sequence(
                 return str(value).strip()
             return str(value).strip() if value else ""
         
-        # Extract variables from contact (handle empty strings, None, and float/NaN values)
-        first_name = safe_str(contact.get("first_name") or contact.get("First Name") or "")
-        last_name = safe_str(contact.get("last_name") or contact.get("Last Name") or "")
-        company = safe_str(contact.get("company") or contact.get("Company") or contact.get("Organization") or "")
-        email = safe_str(contact.get("email") or contact.get("Email") or "")
-        title = safe_str(contact.get("title") or contact.get("Title") or contact.get("Job Title") or "")
-        industry = safe_str(contact.get("industry") or contact.get("Industry") or "")
-        location = safe_str(contact.get("location") or contact.get("Location") or "")
-        company_size = safe_str(contact.get("company_size") or contact.get("Company Size") or "")
+        # Extract variables from contact (handle empty strings, None, and float/NaN values,
+        # and Apollo-style column names like "Company Name" that don't match a plain "Company")
+        first_name = _pick_contact_field(contact, ["first_name", "first name", "firstname"])
+        last_name = _pick_contact_field(contact, ["last_name", "last name", "lastname"])
+        company = _pick_contact_field(
+            contact, ["company", "company name", "company name for emails", "organization", "organization name", "account name"]
+        )
+        email = _pick_contact_field(contact, ["email", "work email", "email address"])
+        title = _pick_contact_field(contact, ["title", "job title"])
+        industry = _pick_contact_field(contact, ["industry"])
+        location = _pick_contact_field(contact, ["location", "address", "city"])
+        company_size = _pick_contact_field(contact, ["company_size", "company size", "# employees"])
         signoff = (sender_mailbox_name or "").strip()
         
         # Validate required fields
@@ -486,24 +507,28 @@ Touches in order:
         } for email_data in emails]
         
     except Exception as e:
-        print(f"Error generating sequence: {e}")
-        # Return a fallback email
-        first_name = contact.get("first_name", contact.get("First Name", "there"))
-        company = contact.get("company", contact.get("Company", contact.get("Organization", "your company")))
-        fb = (sender_mailbox_name or "").strip()
-        tail = f"\n\nBest Regards\n{fb}" if fb else "\n\nBest Regards"
-
-        return [{
-            "first_name": first_name,
-            "last_name": contact.get("last_name", contact.get("Last Name", "")),
-            "email": contact.get("email", contact.get("Email", "")),
-            "company": company,
-            "title": contact.get("title", contact.get("Title", contact.get("Job Title", ""))),
-            "product": product_name,
-            "email_number": 1,
-            "subject": f"{first_name}, let's talk about {product_name}",
-            "email_content": f"Hi {first_name},\n\nI wanted to reach out about how {product_name} could benefit {company}.{tail}",
-        }]
+        contact_email = _pick_contact_field(contact, ["email", "work email", "email address"])
+        contact_name = " ".join(
+            filter(
+                None,
+                [
+                    _pick_contact_field(contact, ["first_name", "first name", "firstname"]),
+                    _pick_contact_field(contact, ["last_name", "last name", "lastname"]),
+                ],
+            )
+        )
+        logger.exception(
+            "Email sequence generation failed for contact %s (product=%s): %s",
+            contact_email or contact_name or "unknown", product_name, e,
+        )
+        return [
+            {
+                "generation_failed": True,
+                "error": str(e),
+                "email": contact_email,
+                "name": contact_name,
+            }
+        ]
 
 
 def generate_linkedin_sequence(
@@ -529,16 +554,24 @@ def generate_linkedin_sequence(
         return str(value).strip() if value else ""
 
     try:
-        first_name = safe_str(contact.get("first_name") or contact.get("First Name") or "")
-        last_name = safe_str(contact.get("last_name") or contact.get("Last Name") or "")
-        company = safe_str(contact.get("company") or contact.get("Company") or contact.get("Organization") or "")
-        email = safe_str(contact.get("email") or contact.get("Email") or "")
-        title = safe_str(contact.get("title") or contact.get("Title") or contact.get("Job Title") or "")
-        industry = safe_str(contact.get("industry") or contact.get("Industry") or "")
-        location = safe_str(contact.get("location") or contact.get("Location") or "")
+        first_name = _pick_contact_field(contact, ["first_name", "first name", "firstname"])
+        last_name = _pick_contact_field(contact, ["last_name", "last name", "lastname"])
+        company = _pick_contact_field(
+            contact, ["company", "company name", "company name for emails", "organization", "organization name", "account name"]
+        )
+        # Email is NOT required for LinkedIn outreach — Apollo exports frequently have a valid
+        # LinkedIn profile but an unverified/missing email, and sending uses the LinkedIn URL
+        # (handled separately at send time), not the email address.
+        email = _pick_contact_field(contact, ["email", "work email", "email address"])
+        title = _pick_contact_field(contact, ["title", "job title"])
+        industry = _pick_contact_field(contact, ["industry"])
+        location = _pick_contact_field(contact, ["location", "address", "city"])
+        linkedin_url = _pick_contact_field(
+            contact, ["person linkedin url", "linkedin url", "linkedin_url", "li_url", "profile_url"]
+        )
 
-        if not email:
-            raise ValueError(f"Contact missing email address: {contact}")
+        if not first_name and not last_name and not linkedin_url and not email:
+            raise ValueError(f"Contact has no name, email, or LinkedIn URL to personalize against: {contact}")
 
         li_sign = (sender_linkedin_name or "").strip()
 
@@ -738,15 +771,26 @@ Use the contact's real first name where a greeting is appropriate. Do not use pl
             raise ValueError("LinkedIn sequence generation produced no usable messages after parsing")
         return out
     except Exception as e:
+        contact_email = _pick_contact_field(contact, ["email", "work email", "email address"])
+        contact_name = " ".join(
+            filter(
+                None,
+                [
+                    _pick_contact_field(contact, ["first_name", "first name", "firstname"]),
+                    _pick_contact_field(contact, ["last_name", "last name", "lastname"]),
+                ],
+            )
+        )
         logger.exception(
             "LinkedIn sequence generation failed for contact %s (product=%s): %s",
-            safe_str(contact.get("email") or contact.get("Email") or ""), product_name, e,
+            contact_email or contact_name or "unknown", product_name, e,
         )
         return [
             {
                 "generation_failed": True,
                 "error": str(e),
-                "email": safe_str(contact.get("email") or contact.get("Email") or ""),
+                "email": contact_email,
+                "name": contact_name,
             }
         ]
 

backend/app/main.py

@@ -5388,49 +5388,53 @@ async def generate_sequences(
                                 product_name,
                             )
 
-                    for i, seq_data in enumerate(sequence_data_list):
-                        step_order_v = None
-                        if plan_pack and gmail_specs and i < len(gmail_specs):
-                            step_order_v = gmail_specs[i]["step_order"]
-                        db_sequence = GeneratedSequence(
-                            tenant_id=tenant_id,
-                            file_id=file_id,
-                            sequence_id=sequence_id,
-                            email_number=seq_data["email_number"],
-                            channel="email",
-                            first_name=seq_data["first_name"],
-                            last_name=seq_data["last_name"],
-                            email=seq_data["email"],
-                            company=seq_data["company"],
-                            title=seq_data.get("title", ""),
-                            product=seq_data["product"],
-                            subject=seq_data["subject"],
-                            email_content=seq_data["email_content"],
-                            step_order=step_order_v,
-                        )
-                        db.add(db_sequence)
-
-                    db.commit()
-
-                    for i, seq_data in enumerate(sequence_data_list):
-                        step_order_v = None
-                        if plan_pack and gmail_specs and i < len(gmail_specs):
-                            step_order_v = gmail_specs[i]["step_order"]
-                        sequence_response = {
-                            "id": sequence_id,
-                            "emailNumber": seq_data["email_number"],
-                            "firstName": seq_data["first_name"],
-                            "lastName": seq_data["last_name"],
-                            "email": seq_data["email"],
-                            "company": seq_data["company"],
-                            "title": seq_data.get("title", ""),
-                            "product": seq_data["product"],
-                            "subject": seq_data["subject"],
-                            "emailContent": seq_data["email_content"],
-                            "channel": "email",
-                            "stepOrder": step_order_v,
-                        }
-                        yield f"data: {json.dumps({'type': 'sequence', 'sequence': sequence_response})}\n\n"
+                    email_failed = bool(sequence_data_list) and sequence_data_list[0].get("generation_failed")
+                    if email_failed:
+                        yield f"data: {json.dumps({'type': 'contact_error', 'channel': 'email', 'sequence_id': sequence_id, 'email': sequence_data_list[0].get('email', ''), 'name': sequence_data_list[0].get('name', ''), 'error': sequence_data_list[0].get('error', '')})}\n\n"
+                    else:
+                        for i, seq_data in enumerate(sequence_data_list):
+                            step_order_v = None
+                            if plan_pack and gmail_specs and i < len(gmail_specs):
+                                step_order_v = gmail_specs[i]["step_order"]
+                            db_sequence = GeneratedSequence(
+                                tenant_id=tenant_id,
+                                file_id=file_id,
+                                sequence_id=sequence_id,
+                                email_number=seq_data["email_number"],
+                                channel="email",
+                                first_name=seq_data["first_name"],
+                                last_name=seq_data["last_name"],
+                                email=seq_data["email"],
+                                company=seq_data["company"],
+                                title=seq_data.get("title", ""),
+                                product=seq_data["product"],
+                                subject=seq_data["subject"],
+                                email_content=seq_data["email_content"],
+                                step_order=step_order_v,
+                            )
+                            db.add(db_sequence)
+
+                        db.commit()
+
+                        for i, seq_data in enumerate(sequence_data_list):
+                            step_order_v = None
+                            if plan_pack and gmail_specs and i < len(gmail_specs):
+                                step_order_v = gmail_specs[i]["step_order"]
+                            sequence_response = {
+                                "id": sequence_id,
+                                "emailNumber": seq_data["email_number"],
+                                "firstName": seq_data["first_name"],
+                                "lastName": seq_data["last_name"],
+                                "email": seq_data["email"],
+                                "company": seq_data["company"],
+                                "title": seq_data.get("title", ""),
+                                "product": seq_data["product"],
+                                "subject": seq_data["subject"],
+                                "emailContent": seq_data["email_content"],
+                                "channel": "email",
+                                "stepOrder": step_order_v,
+                            }
+                            yield f"data: {json.dumps({'type': 'sequence', 'sequence': sequence_response})}\n\n"
 
                     prog = plan_progress_pct() if plan_pack else progress_pct(sequence_id, linkedin_phase=False)
                     yield f"data: {json.dumps({'type': 'progress', 'progress': prog})}\n\n"
@@ -5528,7 +5532,7 @@ async def generate_sequences(
 
                     li_failed = bool(li_list) and li_list[0].get("generation_failed")
                     if li_failed:
-                        yield f"data: {json.dumps({'type': 'contact_error', 'channel': 'linkedin', 'sequence_id': sequence_id, 'email': li_list[0].get('email', ''), 'error': li_list[0].get('error', '')})}\n\n"
+                        yield f"data: {json.dumps({'type': 'contact_error', 'channel': 'linkedin', 'sequence_id': sequence_id, 'email': li_list[0].get('email', ''), 'name': li_list[0].get('name', ''), 'error': li_list[0].get('error', '')})}\n\n"
                     else:
                         def _step_order_for(seq_data):
                             if not (plan_pack and li_meta_for_rows):

frontend/src/components/campaigns/CreateCampaignWizard.jsx

@@ -796,7 +796,12 @@ export default function CreateCampaignWizard({
                 } else if (data.type === 'contact_error') {
                     setGenFailedContacts((prev) => [
                         ...prev,
-                        { email: data.email || '', channel: data.channel || '', error: data.error || '' },
+                        {
+                            email: data.email || '',
+                            name: data.name || '',
+                            channel: data.channel || '',
+                            error: data.error || '',
+                        },
                     ]);
                 } else if (data.type === 'preview_complete') {
                     setGenRunning(false);
@@ -1254,8 +1259,8 @@ export default function CreateCampaignWizard({
                                             </p>
                                             <ul className="mt-1.5 max-h-24 space-y-0.5 overflow-y-auto text-xs text-amber-800">
                                                 {genFailedContacts.slice(0, 10).map((f, i) => (
-                                                    <li key={`${f.email}-${i}`}>
-                                                        {f.email || 'Unknown contact'}
+                                                    <li key={`${f.email || f.name}-${i}`}>
+                                                        {f.email || f.name || 'Unknown contact'}
                                                         {f.channel ? ` (${f.channel})` : ''}
                                                         {f.error ? `: ${f.error}` : ''}
                                                     </li>

frontend/src/lib/mergeSequenceIntoContacts.js

@@ -5,12 +5,18 @@
  */
 export function mergeSequenceIntoContacts(prev, sequence) {
     const ch = sequence.channel || 'email';
-    const matchIdx = prev.findIndex(
-        (c) =>
-            c.firstName === sequence.firstName &&
-            c.lastName === sequence.lastName &&
-            c.email === sequence.email
-    );
+    // `id` (the CSV row's sequence_id) is a stable per-contact identifier that's always present
+    // and unique within a run — prefer it so contacts without an email (common for Apollo rows
+    // with only a LinkedIn URL) never collide with another no-email contact sharing the same name.
+    const matchIdx =
+        sequence.id != null
+            ? prev.findIndex((c) => c.id === sequence.id)
+            : prev.findIndex(
+                  (c) =>
+                      c.firstName === sequence.firstName &&
+                      c.lastName === sequence.lastName &&
+                      c.email === sequence.email
+              );
 
     const stepOrder =
         sequence.stepOrder != null && sequence.stepOrder !== undefined ? sequence.stepOrder : null;