fusesell 1.2.8__py3-none-any.whl → 1.3.0__py3-none-any.whl

{fusesell-1.2.8.dist-info → fusesell-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusesell
-Version: 1.2.8
+Version: 1.3.0
 Summary: Local implementation of FuseSell AI sales automation pipeline
 Author-email: FuseSell Team <team@fusesell.ai>
 License-Expression: MIT

{fusesell-1.2.8.dist-info → fusesell-1.3.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 fusesell.py,sha256=t5PjkhWEJGINp4k517u0EX0ge7lzuHOUHHro-BE1mGk,596
-fusesell-1.2.8.dist-info/licenses/LICENSE,sha256=GDz1ZoC4lB0kwjERpzqc_OdA_awYVso2aBnUH-ErW_w,1070
-fusesell_local/__init__.py,sha256=ORlqpW5kTRov-Xw9f3Bk0L7wy1Q5bxTdaZAT9fIhLcQ,966
+fusesell-1.3.0.dist-info/licenses/LICENSE,sha256=GDz1ZoC4lB0kwjERpzqc_OdA_awYVso2aBnUH-ErW_w,1070
+fusesell_local/__init__.py,sha256=7shpYv9KVMmtCmwRUUrJOIid2cvvUuLpZwnbNNk4TS8,967
 fusesell_local/api.py,sha256=AcPune5YJdgi7nsMeusCUqc49z5UiycsQb6n3yiV_No,10839
 fusesell_local/cli.py,sha256=MYnVxuEf5KTR4VcO3sc-VtP9NkWlSixJsYfOWST2Ds0,65859
 fusesell_local/pipeline.py,sha256=RMF_kgwNEc1ka8-CDJyzIOTSo8PGtR_zPKAgRevhlNo,39913
@@ -12,7 +12,7 @@ fusesell_local/stages/base_stage.py,sha256=ldo5xuHZto7ceEg3i_3rxAx0xPccK4n2jaxEJ
 fusesell_local/stages/data_acquisition.py,sha256=Td3mwakJRoEYbi3od4v2ZzKOHLgLSgccZVxH3ezs1_4,71081
 fusesell_local/stages/data_preparation.py,sha256=XWLg9b1w2NrMxLcrWDqB95mRmLQmVIMXpKNaBNr98TQ,52751
 fusesell_local/stages/follow_up.py,sha256=H9Xek6EoIbHrerQvGTRswXDNFH6zq71DcRxxj0zpo2g,77747
-fusesell_local/stages/initial_outreach.py,sha256=0JJMRtfvy1F83Z5anLm8b0634q4JXoFi__IxginPURw,120643
+fusesell_local/stages/initial_outreach.py,sha256=hvt0tpJQGDX5-k3pb2SR54IOnhQv2XyYXYtiVVECmts,131850
 fusesell_local/stages/lead_scoring.py,sha256=ir3l849eMGrGLf0OYUcmA1F3FwyYhAplS4niU3R2GRY,60658
 fusesell_local/tests/conftest.py,sha256=TWUtlP6cNPVOYkTPz-j9BzS_KnXdPWy8D-ObPLHvXYs,366
 fusesell_local/tests/test_api.py,sha256=763rUVb5pAuAQOovug6Ka0T9eGK8-WVOC_J08M7TETo,1827
@@ -22,14 +22,14 @@ fusesell_local/tests/test_data_manager_sales_process.py,sha256=NbwxQ9oBKCZfrkRQY
 fusesell_local/tests/test_data_manager_teams.py,sha256=kjk4V4r9ja4EVREIiQMxkuZd470SSwRHJAvpHln9KO4,4578
 fusesell_local/utils/__init__.py,sha256=TVemlo0wpckhNUxP3a1Tky3ekswy8JdIHaXBlkKXKBQ,330
 fusesell_local/utils/birthday_email_manager.py,sha256=NKLoUyzPedyhewZPma21SOoU8p9wPquehloer7TRA9U,20478
-fusesell_local/utils/data_manager.py,sha256=60CLOVkVB76AQx1wQyja0PFmA1t-YJITiGNni14IPOs,188449
-fusesell_local/utils/event_scheduler.py,sha256=YwWIdkvRdWFdDLX-sepI5AXJOhEIullIclpk9njvZAA,38577
+fusesell_local/utils/data_manager.py,sha256=FHW9nvLXDgf-HYNFwxZlegZp0OgB3altszW6INIgyLM,188910
+fusesell_local/utils/event_scheduler.py,sha256=TDk1v19cNgLhn2aJriQfpvZnwBcRpOWyHLDvkefW110,39834
 fusesell_local/utils/llm_client.py,sha256=FVc25UlGt6hro7h5Iw7PHSXY3E3_67Xc-SUbHuMSRs0,10437
 fusesell_local/utils/logger.py,sha256=sWlV8Tjyz_Z8J4zXKOnNalh8_iD6ytfrwPZpD-wcEOs,6259
 fusesell_local/utils/timezone_detector.py,sha256=0cAE4c8ZXqCA8AvxRKm6PrFKmAmsbq3HOHR6w-mW3KQ,39997
 fusesell_local/utils/validators.py,sha256=Z1VzeoxFsnuzlIA_ZaMWoy-0Cgyqupd47kIdljlMDbs,15438
-fusesell-1.2.8.dist-info/METADATA,sha256=9r91NKwHYUIJ-FiYGr7JoNsWe5dDLMd0JO6Nf8MlXW0,35074
-fusesell-1.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fusesell-1.2.8.dist-info/entry_points.txt,sha256=Vqek7tbiX7iF4rQkCRBZvT5WrB0HUduqKTsI2ZjhsXo,53
-fusesell-1.2.8.dist-info/top_level.txt,sha256=VP9y1K6DEq6gNq2UgLd7ChujxViF6OzeAVCK7IUBXPA,24
-fusesell-1.2.8.dist-info/RECORD,,
+fusesell-1.3.0.dist-info/METADATA,sha256=cBJe2l9s_vsCApaTmAtH_tOjdq9berqTED9CGOtSoEM,35074
+fusesell-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fusesell-1.3.0.dist-info/entry_points.txt,sha256=Vqek7tbiX7iF4rQkCRBZvT5WrB0HUduqKTsI2ZjhsXo,53
+fusesell-1.3.0.dist-info/top_level.txt,sha256=VP9y1K6DEq6gNq2UgLd7ChujxViF6OzeAVCK7IUBXPA,24
+fusesell-1.3.0.dist-info/RECORD,,

fusesell_local/__init__.py

@@ -32,6 +32,6 @@ __all__ = [
     "validate_config",
 ]
 
-__version__ = "1.2.8"
+__version__ = "1.3.0"
 __author__ = "FuseSell Team"
 __description__ = "Local implementation of FuseSell AI sales automation pipeline"

fusesell_local/stages/initial_outreach.py

@@ -7,7 +7,7 @@ import json
 import uuid
 import requests
 import re
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional
 from datetime import datetime
 from .base_stage import BaseStage
 
@@ -169,11 +169,17 @@ class InitialOutreachStage(BaseStage):
             raise ValueError(f"Draft not found: {selected_draft_id}")
         
         # Get customer data for context
-        customer_data = self._get_customer_data(context)
-        scoring_data = self._get_scoring_data(context)
-        
-        # Rewrite the draft based on reason
-        rewritten_draft = self._rewrite_draft(existing_draft, reason, customer_data, scoring_data, context)
+        customer_data = self._get_customer_data(context)
+        scoring_data = self._get_scoring_data(context)
+
+        recipient_identity = self._resolve_recipient_identity(customer_data, context)
+        context.setdefault('_recipient_identity', recipient_identity)
+        context.setdefault('_recipient_identity', recipient_identity)
+        if recipient_identity.get('first_name') and not context.get('customer_first_name'):
+            context['customer_first_name'] = recipient_identity['first_name']
+        
+        # Rewrite the draft based on reason
+        rewritten_draft = self._rewrite_draft(existing_draft, reason, customer_data, scoring_data, context)
         
         # Save the rewritten draft
         saved_draft = self._save_rewritten_draft(context, rewritten_draft, selected_draft_id)
@@ -563,11 +569,11 @@ class InitialOutreachStage(BaseStage):
             'lead_scoring': input_data.get('lead_scoring', [])
         }
 
-    def _get_recommended_product(self, scoring_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        """Get recommended product from scoring data."""
-        try:
-            # Try to get from analysis first
-            analysis = scoring_data.get('analysis', {})
+    def _get_recommended_product(self, scoring_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Get recommended product from scoring data."""
+        try:
+            # Try to get from analysis first
+            analysis = scoring_data.get('analysis', {})
             if 'recommended_product' in analysis:
                 return analysis['recommended_product']
             
@@ -584,14 +590,73 @@ class InitialOutreachStage(BaseStage):
             
             return None
         except Exception as e:
-            self.logger.error(f"Failed to get recommended product: {str(e)}")
-            return None
-
-    def _get_auto_interaction_config(self, team_id: str = None) -> Dict[str, Any]:
-        """
-        Get auto interaction configuration from team settings.
-
-        Args:
+            self.logger.error(f"Failed to get recommended product: {str(e)}")
+            return None
+
+    def _resolve_recipient_identity(
+        self,
+        customer_data: Dict[str, Any],
+        context: Dict[str, Any]
+    ) -> Dict[str, Optional[str]]:
+        """
+        Resolve recipient contact information and derive a safe first name.
+        """
+        input_data = context.get('input_data', {}) or {}
+        stage_results = context.get('stage_results', {}) or {}
+        data_acquisition: Dict[str, Any] = {}
+        if isinstance(stage_results, dict):
+            data_acquisition = stage_results.get('data_acquisition', {}).get('data', {}) or {}
+
+        primary_contact = dict(customer_data.get('primaryContact', {}) or {})
+
+        recipient_email = (
+            input_data.get('recipient_address')
+            or primary_contact.get('email')
+            or primary_contact.get('emailAddress')
+            or data_acquisition.get('contact_email')
+            or data_acquisition.get('customer_email')
+            or input_data.get('customer_email')
+        )
+
+        recipient_name = (
+            input_data.get('recipient_name')
+            or primary_contact.get('name')
+            or primary_contact.get('fullName')
+            or data_acquisition.get('contact_name')
+            or data_acquisition.get('customer_contact')
+            or input_data.get('customer_name')
+        )
+
+        first_name_source = (
+            context.get('customer_first_name')
+            or input_data.get('customer_first_name')
+            or recipient_name
+        )
+
+        first_name = ''
+        if isinstance(first_name_source, str) and first_name_source.strip():
+            first_name = self._extract_first_name(first_name_source.strip())
+        if not first_name and isinstance(recipient_name, str) and recipient_name.strip():
+            first_name = self._extract_first_name(recipient_name.strip())
+
+        if recipient_name and not primary_contact.get('name'):
+            primary_contact['name'] = recipient_name
+        if recipient_email and not primary_contact.get('email'):
+            primary_contact['email'] = recipient_email
+        if primary_contact and isinstance(customer_data, dict):
+            customer_data['primaryContact'] = primary_contact
+
+        return {
+            'email': recipient_email,
+            'full_name': recipient_name,
+            'first_name': first_name
+        }
+
+    def _get_auto_interaction_config(self, team_id: str = None) -> Dict[str, Any]:
+        """
+        Get auto interaction configuration from team settings.
+
+        Args:
             team_id: Team ID to get settings for
 
         Returns:
@@ -648,6 +713,10 @@ class InitialOutreachStage(BaseStage):
         try:
             input_data = context.get('input_data', {})
             rep_profile = rep_profile or {}
+            recipient_identity = self._resolve_recipient_identity(customer_data, context)
+            if recipient_identity.get('first_name') and not context.get('customer_first_name'):
+                context['customer_first_name'] = recipient_identity['first_name']
+            context.setdefault('_recipient_identity', recipient_identity)
             if rep_profile:
                 primary_name = rep_profile.get('name')
                 if primary_name:
@@ -725,26 +794,33 @@ class InitialOutreachStage(BaseStage):
                     # Select the best subject line (first one, or most relevant)
                     selected_subject = subject_lines[0] if subject_lines else f"Partnership opportunity for {company_info.get('name', 'your company')}"
                     
-                    draft = {
-                        'draft_id': draft_id,
-                        'approach': approach['name'],
-                        'tone': approach['tone'],
-                        'focus': approach['focus'],
-                        'subject': selected_subject,  # Single subject instead of array
-                        'subject_alternatives': subject_lines[1:4] if len(subject_lines) > 1 else [],  # Store alternatives separately
-                        'email_body': email_content,
-                        'call_to_action': self._extract_call_to_action(email_content),
-                        'personalization_score': self._calculate_personalization_score(email_content, customer_data),
-                        'generated_at': datetime.now().isoformat(),
-                        'status': 'draft',
-                        'metadata': {
-                            'customer_company': company_info.get('name', 'Unknown'),
-                            'contact_name': contact_info.get('name', 'Unknown'),
-                            'recommended_product': recommended_product.get('product_name', 'Unknown'),
-                            'pain_points_addressed': len([p for p in pain_points if p.get('severity') in ['high', 'medium']]),
-                            'generation_method': 'llm_powered'
-                        }
-                    }
+                    draft = {
+                        'draft_id': draft_id,
+                        'approach': approach['name'],
+                        'tone': approach['tone'],
+                        'focus': approach['focus'],
+                        'subject': selected_subject,  # Single subject instead of array
+                        'subject_alternatives': subject_lines[1:4] if len(subject_lines) > 1 else [],  # Store alternatives separately
+                        'email_body': email_content,
+                        'email_format': 'html',
+                        'recipient_email': recipient_identity.get('email'),
+                        'recipient_name': recipient_identity.get('full_name'),
+                        'customer_first_name': recipient_identity.get('first_name'),
+                        'call_to_action': self._extract_call_to_action(email_content),
+                        'personalization_score': self._calculate_personalization_score(email_content, customer_data),
+                        'generated_at': datetime.now().isoformat(),
+                        'status': 'draft',
+                        'metadata': {
+                            'customer_company': company_info.get('name', 'Unknown'),
+                            'contact_name': contact_info.get('name', 'Unknown'),
+                            'recipient_email': recipient_identity.get('email'),
+                            'recipient_name': recipient_identity.get('full_name'),
+                            'email_format': 'html',
+                            'recommended_product': recommended_product.get('product_name', 'Unknown'),
+                            'pain_points_addressed': len([p for p in pain_points if p.get('severity') in ['high', 'medium']]),
+                            'generation_method': 'llm_powered'
+                        }
+                    }
                     
                     generated_drafts.append(draft)
                     
@@ -904,6 +980,7 @@ class InitialOutreachStage(BaseStage):
                 first_name = name_parts[0]
         else:
             first_name = contact_name or ''
+        context.setdefault('customer_first_name', first_name or contact_name or '')
 
         action = input_data.get('action', 'draft_write')
         action_labels = {
@@ -1044,7 +1121,7 @@ class InitialOutreachStage(BaseStage):
                 return rep
         return reps[0] if reps else {}
 
-    def _sanitize_email_body(self, html: str, staff_name: str, rep_profile: Dict[str, Any]) -> str:
+    def _sanitize_email_body(self, html: str, staff_name: str, rep_profile: Dict[str, Any], customer_first_name: str) -> str:
         if not html:
             return ''
 
@@ -1065,12 +1142,84 @@ class InitialOutreachStage(BaseStage):
             else:
                 html = html.replace(placeholder, '')
 
-        # Remove any lingering placeholder fragments such as "[Your LinkedIn Profile"
         html = re.sub(r'\[Your[^<\]]+\]?', '', html, flags=re.IGNORECASE)
-        # Collapse empty paragraphs created by placeholder removal
+
+        if '<p' not in html.lower():
+            lines = [line.strip() for line in html.splitlines() if line.strip()]
+            if lines:
+                html = ''.join(f'<p>{line}</p>' for line in lines)
+
+        html = self._deduplicate_greeting(html, customer_first_name or '')
         html = re.sub(r'(<p>\s*</p>)+', '', html, flags=re.IGNORECASE)
         return html
 
+    def _deduplicate_greeting(self, html: str, customer_first_name: str) -> str:
+        paragraphs = re.findall(r'(<p.*?>.*?</p>)', html, flags=re.IGNORECASE | re.DOTALL)
+        if not paragraphs:
+            return html
+
+        greeting_seen = False
+        cleaned: List[str] = []
+        for para in paragraphs:
+            text = self._strip_html_tags(para).strip()
+            normalized_para = para
+            if self._looks_like_greeting(text):
+                normalized_para = self._standardize_greeting_paragraph(para, customer_first_name)
+                if greeting_seen:
+                    continue
+                greeting_seen = True
+            cleaned.append(normalized_para)
+
+        remainder = re.sub(r'(<p.*?>.*?</p>)', '__PARA__', html, flags=re.IGNORECASE | re.DOTALL)
+        rebuilt = ''
+        idx = 0
+        for segment in remainder.split('__PARA__'):
+            rebuilt += segment
+            if idx < len(cleaned):
+                rebuilt += cleaned[idx]
+                idx += 1
+        if idx < len(cleaned):
+            rebuilt += ''.join(cleaned[idx:])
+        return rebuilt
+
+    def _looks_like_greeting(self, text: str) -> bool:
+        lowered = text.lower().replace('\xa0', ' ').strip()
+        return lowered.startswith(('hi ', 'hello ', 'dear '))
+
+    def _standardize_greeting_paragraph(self, paragraph_html: str, customer_first_name: str) -> str:
+        text = self._strip_html_tags(paragraph_html).strip()
+        lowered = text.lower()
+        first_word = next((candidate.title() for candidate in ('dear', 'hello', 'hi') if lowered.startswith(candidate)), 'Hi')
+
+        if customer_first_name:
+            greeting = f"{first_word} {customer_first_name},"
+        else:
+            greeting = f"{first_word} there,"
+
+        remainder = ''
+        match = re.match(r' *(hi|hello|dear)\b[^,]*,(.*)', text, flags=re.IGNORECASE | re.DOTALL)
+        if match:
+            remainder = match.group(2).lstrip()
+        elif lowered.startswith(('hi', 'hello', 'dear')):
+            parts = text.split(',', 1)
+            if len(parts) > 1:
+                remainder = parts[1].lstrip()
+        else:
+            remainder = text[len(text.split(' ', 1)[0]):].lstrip()
+
+        if remainder:
+            sanitized_text = f"{greeting} {remainder}".strip()
+        else:
+            sanitized_text = greeting
+
+        return re.sub(
+            r'(<p.*?>).*?(</p>)',
+            lambda m: f"{m.group(1)}{sanitized_text}{m.group(2)}",
+            paragraph_html,
+            count=1,
+            flags=re.IGNORECASE | re.DOTALL
+        )
+
     def _extract_first_name(self, full_name: str) -> str:
         if not full_name:
             return ''
@@ -1120,18 +1269,22 @@ class InitialOutreachStage(BaseStage):
             self.logger.debug('Skipping prompt entry because it is not a dict: %s', entry)
             return None
 
-        email_body = entry.get('body') or entry.get('content') or ''
-        if isinstance(email_body, dict):
-            email_body = email_body.get('html') or email_body.get('text') or email_body.get('content') or ''
-        email_body = str(email_body).strip()
-        if not email_body:
-            self.logger.debug('Skipping prompt entry because email body is empty: %s', entry)
-            return None
-
-        subject = entry.get('subject')
-        if isinstance(subject, list):
-            subject = subject[0] if subject else ''
-        subject = str(subject).strip() if subject else ''
+        email_body = entry.get('body') or entry.get('content') or ''
+        if isinstance(email_body, dict):
+            email_body = email_body.get('html') or email_body.get('text') or email_body.get('content') or ''
+        email_body = str(email_body).strip()
+        if not email_body:
+            self.logger.debug('Skipping prompt entry because email body is empty: %s', entry)
+            return None
+
+        recipient_identity = self._resolve_recipient_identity(customer_data, context)
+        if recipient_identity.get('first_name') and not context.get('customer_first_name'):
+            context['customer_first_name'] = recipient_identity['first_name']
+
+        subject = entry.get('subject')
+        if isinstance(subject, list):
+            subject = subject[0] if subject else ''
+        subject = str(subject).strip() if subject else ''
 
         subject_alternatives: List[str] = []
         for key in ('subject_alternatives', 'subject_variations', 'subject_variants', 'alternative_subjects', 'subjects'):
@@ -1177,16 +1330,22 @@ class InitialOutreachStage(BaseStage):
         message_type = entry.get('message_type') or 'Email'
         rep_profile = getattr(self, '_active_rep_profile', {}) or {}
         staff_name = context.get('input_data', {}).get('staff_name') or self.config.get('staff_name', 'Sales Team')
-        email_body = self._sanitize_email_body(email_body, staff_name, rep_profile)
-
-        metadata = {
-            'customer_company': customer_data.get('companyInfo', {}).get('name', 'Unknown'),
-            'contact_name': customer_data.get('primaryContact', {}).get('name', 'Unknown'),
-            'recommended_product': product_name or 'Unknown',
-            'generation_method': 'prompt_template',
-            'tags': tags,
-            'message_type': message_type
-        }
+        first_name = recipient_identity.get('first_name') or context.get('customer_first_name') or context.get('input_data', {}).get('customer_name') or ''
+        email_body = self._sanitize_email_body(email_body, staff_name, rep_profile, first_name)
+        if '<html' not in email_body.lower():
+            email_body = f"<html><body>{email_body}</body></html>"
+
+        metadata = {
+            'customer_company': customer_data.get('companyInfo', {}).get('name', 'Unknown'),
+            'contact_name': customer_data.get('primaryContact', {}).get('name', 'Unknown'),
+            'recipient_email': recipient_identity.get('email'),
+            'recipient_name': recipient_identity.get('full_name'),
+            'email_format': 'html',
+            'recommended_product': product_name or 'Unknown',
+            'generation_method': 'prompt_template',
+            'tags': tags,
+            'message_type': message_type
+        }
 
         draft_id = entry.get('draft_id') or f"uuid:{str(uuid.uuid4())}"
         draft_approach = "prompt"
@@ -1196,15 +1355,19 @@ class InitialOutreachStage(BaseStage):
             'draft_id': draft_id,
             'approach': approach,
             'tone': mail_tone,
-            'focus': focus,
-            'subject': subject,
-            'subject_alternatives': subject_alternatives,
-            'email_body': email_body,
-            'call_to_action': call_to_action,
-            'product_mention': product_mention,
-            'product_name': product_name,
-            'priority_order': priority_order if priority_order is not None else 0,
-            'personalization_score': personalization_score,
+            'focus': focus,
+            'subject': subject,
+            'subject_alternatives': subject_alternatives,
+            'email_body': email_body,
+            'email_format': 'html',
+            'recipient_email': recipient_identity.get('email'),
+            'recipient_name': recipient_identity.get('full_name'),
+            'customer_first_name': recipient_identity.get('first_name'),
+            'call_to_action': call_to_action,
+            'product_mention': product_mention,
+            'product_name': product_name,
+            'priority_order': priority_order if priority_order is not None else 0,
+            'personalization_score': personalization_score,
             'generated_at': datetime.now().isoformat(),
             'status': 'draft',
             'metadata': metadata
@@ -1258,7 +1421,7 @@ class InitialOutreachStage(BaseStage):
             )
             
             # Clean and validate the generated content
-            cleaned_content = self._clean_email_content(email_content)
+            cleaned_content = self._clean_email_content(email_content, context)
             
             return cleaned_content
             
@@ -1369,35 +1532,61 @@ Generate 4 subject lines, one per line, no numbering or bullets:"""
             f"5-minute chat about {company_name}?"
         ]
 
-    def _clean_email_content(self, raw_content: str) -> str:
-        """Clean and validate generated email content."""
-        # Remove any unwanted prefixes or suffixes
-        content = raw_content.strip()
-        
-        # Remove common LLM artifacts
-        artifacts_to_remove = [
-            "Here's the email:",
-            "Here is the email:",
-            "Email content:",
-            "Generated email:",
-            "Subject:",
-            "Email:"
-        ]
-        
-        for artifact in artifacts_to_remove:
-            if content.startswith(artifact):
-                content = content[len(artifact):].strip()
-        
-        # Ensure proper email structure
-        if not content.startswith(('Dear', 'Hi', 'Hello', 'Greetings')):
-            # Add a greeting if missing
-            content = f"Dear Valued Customer,\n\n{content}"
-        
-        # Ensure proper closing
-        if not any(closing in content.lower() for closing in ['best regards', 'sincerely', 'best', 'thanks']):
-            content += "\n\nBest regards"
-        
-        return content
+    def _clean_email_content(
+        self,
+        raw_content: str,
+        context: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Clean and normalize generated email content, returning HTML.
+        """
+        content = (raw_content or "").replace("\r\n", "\n").strip()
+
+        artifacts_to_remove = (
+            "Here's the email:",
+            "Here is the email:",
+            "Email content:",
+            "Generated email:",
+            "Subject:",
+            "Email:"
+        )
+
+        for artifact in artifacts_to_remove:
+            if content.startswith(artifact):
+                content = content[len(artifact):].strip()
+
+        lines = [line.strip() for line in content.split('\n') if line.strip()]
+        content = '\n\n'.join(lines)
+
+        if not content:
+            return "<html><body></body></html>"
+
+        if not content.lower().startswith(('dear ', 'hi ', 'hello ', 'greetings')):
+            content = f"Dear Valued Customer,\n\n{content}"
+
+        closings = ('best regards', 'sincerely', 'thanks', 'thank you', 'kind regards')
+        if not any(closing in content.lower() for closing in closings):
+            content += "\n\nBest regards,\n[Your Name]"
+
+        ctx = context or {}
+        input_data = ctx.get('input_data', {}) or {}
+        rep_profile = getattr(self, '_active_rep_profile', {}) or {}
+        staff_name = input_data.get('staff_name') or self.config.get('staff_name') or 'Sales Team'
+        identity = ctx.get('_recipient_identity') or {}
+        customer_first_name = (
+            identity.get('first_name')
+            or ctx.get('customer_first_name')
+            or input_data.get('customer_first_name')
+            or input_data.get('recipient_name')
+            or input_data.get('customer_name')
+            or ''
+        )
+
+        sanitized = self._sanitize_email_body(content, staff_name, rep_profile, customer_first_name)
+        if '<html' not in sanitized.lower():
+            sanitized = f"<html><body>{sanitized}</body></html>"
+
+        return sanitized
 
     def _extract_call_to_action(self, email_content: str) -> str:
         """Extract the main call-to-action from email content."""
@@ -1489,55 +1678,85 @@ Best regards,
 
     def _generate_fallback_draft(self, customer_data: Dict[str, Any], recommended_product: Dict[str, Any], context: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Generate fallback draft when LLM generation fails."""
-        draft_id = f"uuid:{str(uuid.uuid4())}"
-        draft_approach = "fallback"
-        draft_type = "initial"
-        
-        return [{
-            'draft_id': draft_id,
-            'approach': 'fallback_template',
-            'tone': 'professional',
-            'focus': 'general outreach',
-            'subject': self._generate_fallback_subject_lines(customer_data, recommended_product)[0],
-            'subject_alternatives': self._generate_fallback_subject_lines(customer_data, recommended_product)[1:],
-            'email_body': self._generate_template_email(customer_data, recommended_product, {'tone': 'professional'}, context),
-            'call_to_action': 'Would you be interested in a brief call?',
-            'personalization_score': 50,
-            'generated_at': datetime.now().isoformat(),
-            'status': 'draft',
-            'metadata': {
-                'generation_method': 'template_fallback',
-                'note': 'Generated using template due to LLM failure'
-            }
-        }]
+        draft_id = f"uuid:{str(uuid.uuid4())}"
+        recipient_identity = self._resolve_recipient_identity(customer_data, context)
+        context.setdefault('_recipient_identity', recipient_identity)
+        if recipient_identity.get('first_name') and not context.get('customer_first_name'):
+            context['customer_first_name'] = recipient_identity['first_name']
+
+        template_body = self._generate_template_email(
+            customer_data,
+            recommended_product,
+            {'tone': 'professional'},
+            context
+        )
+        email_body = self._clean_email_content(template_body, context)
+
+        fallback_subjects = self._generate_fallback_subject_lines(customer_data, recommended_product)
+
+        return [{
+            'draft_id': draft_id,
+            'approach': 'fallback_template',
+            'tone': 'professional',
+            'focus': 'general outreach',
+            'subject': fallback_subjects[0],
+            'subject_alternatives': fallback_subjects[1:],
+            'email_body': email_body,
+            'email_format': 'html',
+            'recipient_email': recipient_identity.get('email'),
+            'recipient_name': recipient_identity.get('full_name'),
+            'customer_first_name': recipient_identity.get('first_name'),
+            'call_to_action': 'Would you be interested in a brief call?',
+            'personalization_score': 50,
+            'generated_at': datetime.now().isoformat(),
+            'status': 'draft',
+            'metadata': {
+                'generation_method': 'template_fallback',
+                'note': 'Generated using template due to LLM failure',
+                'recipient_email': recipient_identity.get('email'),
+                'recipient_name': recipient_identity.get('full_name'),
+                'email_format': 'html'
+            }
+        }]
 
     def _get_mock_email_drafts(self, customer_data: Dict[str, Any], recommended_product: Dict[str, Any], context: Dict[str, Any]) -> List[Dict[str, Any]]:
         """Get mock email drafts for dry run."""
         input_data = context.get('input_data', {})
         company_info = customer_data.get('companyInfo', {})
         
-        return [{
-            'draft_id': 'mock_draft_001',
-            'approach': 'professional_direct',
-            'tone': 'professional and direct',
-            'focus': 'business value and ROI',
-            'subject': f"Partnership Opportunity for {company_info.get('name', 'Test Company')}",
-            'subject_alternatives': [
-                f"Quick Question About {company_info.get('name', 'Test Company')}",
-                f"Helping Companies Like {company_info.get('name', 'Test Company')}"
-            ],
-            'email_body': f"""[DRY RUN] Mock email content for {company_info.get('name', 'Test Company')}
-
-This is a mock email that would be generated for testing purposes. In a real execution, this would contain personalized content based on the customer's company information, pain points, and our product recommendations.""",
-            'call_to_action': 'Mock call to action',
-            'personalization_score': 85,
-            'generated_at': datetime.now().isoformat(),
-            'status': 'mock',
-            'metadata': {
-                'generation_method': 'mock_data',
-                'note': 'This is mock data for dry run testing'
-            }
-        }]
+        recipient_identity = self._resolve_recipient_identity(customer_data, context)
+        context.setdefault('_recipient_identity', recipient_identity)
+        mock_body = f"""[DRY RUN] Mock email content for {company_info.get('name', 'Test Company')}
+
+This is a mock email that would be generated for testing purposes. In a real execution, this would contain personalized content based on the customer's company information, pain points, and our product recommendations."""
+
+        return [{
+            'draft_id': 'mock_draft_001',
+            'approach': 'professional_direct',
+            'tone': 'professional and direct',
+            'focus': 'business value and ROI',
+            'subject': f"Partnership Opportunity for {company_info.get('name', 'Test Company')}",
+            'subject_alternatives': [
+                f"Quick Question About {company_info.get('name', 'Test Company')}",
+                f"Helping Companies Like {company_info.get('name', 'Test Company')}"
+            ],
+            'email_body': self._clean_email_content(mock_body, context),
+            'email_format': 'html',
+            'recipient_email': recipient_identity.get('email'),
+            'recipient_name': recipient_identity.get('full_name'),
+            'customer_first_name': recipient_identity.get('first_name'),
+            'call_to_action': 'Mock call to action',
+            'personalization_score': 85,
+            'generated_at': datetime.now().isoformat(),
+            'status': 'mock',
+            'metadata': {
+                'generation_method': 'mock_data',
+                'note': 'This is mock data for dry run testing',
+                'recipient_email': recipient_identity.get('email'),
+                'recipient_name': recipient_identity.get('full_name'),
+                'email_format': 'html'
+            }
+        }]
 
     
     def _convert_draft_to_server_format(self, draft: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
@@ -1876,16 +2095,17 @@ This is a mock email that would be generated for testing purposes. In a real exe
 
     def _rewrite_draft(self, existing_draft: Dict[str, Any], reason: str, customer_data: Dict[str, Any], scoring_data: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
         """Rewrite existing draft based on reason using LLM."""
-        try:
-            if self.is_dry_run():
-                rewritten = existing_draft.copy()
-                rewritten['draft_id'] = f"uuid:{str(uuid.uuid4())}"
-                rewritten['draft_approach'] = "rewrite"
-                rewritten['draft_type'] = "rewrite"
-                rewritten['email_body'] = f"[DRY RUN - REWRITTEN: {reason}] " + existing_draft.get('email_body', '')
-                rewritten['rewrite_reason'] = reason
-                rewritten['rewritten_at'] = datetime.now().isoformat()
-                return rewritten
+        try:
+            if self.is_dry_run():
+                rewritten = existing_draft.copy()
+                rewritten['draft_id'] = f"uuid:{str(uuid.uuid4())}"
+                rewritten['draft_approach'] = "rewrite"
+                rewritten['draft_type'] = "rewrite"
+                rewritten['email_body'] = f"[DRY RUN - REWRITTEN: {reason}] " + existing_draft.get('email_body', '')
+                rewritten['rewrite_reason'] = reason
+                rewritten['rewritten_at'] = datetime.now().isoformat()
+                rewritten.setdefault('email_format', 'html')
+                return rewritten
             
             input_data = context.get('input_data', {})
             company_info = customer_data.get('companyInfo', {})
@@ -1923,46 +2143,66 @@ Generate only the rewritten email content:"""
             )
             
             # Clean the rewritten content
-            cleaned_content = self._clean_email_content(rewritten_content)
-            
-            # Create rewritten draft object
-            rewritten = existing_draft.copy()
-            rewritten['draft_id'] = f"uuid:{str(uuid.uuid4())}"
-            rewritten['draft_approach'] = "rewrite"
-            rewritten['draft_type'] = "rewrite"
-            rewritten['email_body'] = cleaned_content
-            rewritten['rewrite_reason'] = reason
-            rewritten['rewritten_at'] = datetime.now().isoformat()
-            rewritten['version'] = existing_draft.get('version', 1) + 1
-            rewritten['call_to_action'] = self._extract_call_to_action(cleaned_content)
-            rewritten['personalization_score'] = self._calculate_personalization_score(cleaned_content, customer_data)
+            cleaned_content = self._clean_email_content(rewritten_content, context)
+            
+            # Create rewritten draft object
+            rewritten = existing_draft.copy()
+            rewritten['draft_id'] = f"uuid:{str(uuid.uuid4())}"
+            rewritten['draft_approach'] = "rewrite"
+            rewritten['draft_type'] = "rewrite"
+            rewritten['email_body'] = cleaned_content
+            rewritten['rewrite_reason'] = reason
+            rewritten['rewritten_at'] = datetime.now().isoformat()
+            rewritten['version'] = existing_draft.get('version', 1) + 1
+            rewritten['call_to_action'] = self._extract_call_to_action(cleaned_content)
+            rewritten['personalization_score'] = self._calculate_personalization_score(cleaned_content, customer_data)
+            recipient_identity = context.get('_recipient_identity') or self._resolve_recipient_identity(customer_data, context)
+            if recipient_identity:
+                rewritten['recipient_email'] = recipient_identity.get('email')
+                rewritten['recipient_name'] = recipient_identity.get('full_name')
+                rewritten['customer_first_name'] = recipient_identity.get('first_name')
+            rewritten['email_format'] = 'html'
             
             # Update metadata
             if 'metadata' not in rewritten:
                 rewritten['metadata'] = {}
             rewritten['metadata']['rewrite_history'] = rewritten['metadata'].get('rewrite_history', [])
-            rewritten['metadata']['rewrite_history'].append({
-                'reason': reason,
-                'rewritten_at': datetime.now().isoformat(),
-                'original_draft_id': existing_draft.get('draft_id')
-            })
-            rewritten['metadata']['generation_method'] = 'llm_rewrite'
+            rewritten['metadata']['rewrite_history'].append({
+                'reason': reason,
+                'rewritten_at': datetime.now().isoformat(),
+                'original_draft_id': existing_draft.get('draft_id')
+            })
+            rewritten['metadata']['generation_method'] = 'llm_rewrite'
+            if recipient_identity:
+                rewritten['metadata']['recipient_email'] = recipient_identity.get('email')
+                rewritten['metadata']['recipient_name'] = recipient_identity.get('full_name')
+            rewritten['metadata']['email_format'] = 'html'
             
             self.logger.info(f"Successfully rewrote draft based on reason: {reason}")
             return rewritten
             
-        except Exception as e:
-            self.logger.error(f"Failed to rewrite draft: {str(e)}")
-            # Fallback to simple modification
-            rewritten = existing_draft.copy()
-            rewritten['draft_id'] = f"uuid:{str(uuid.uuid4())}"
-            rewritten['draft_approach'] = "rewrite"
-            rewritten['draft_type'] = "rewrite"
-            rewritten['email_body'] = f"[REWRITTEN: {reason}]\n\n" + existing_draft.get('email_body', '')
-            rewritten['rewrite_reason'] = reason
-            rewritten['rewritten_at'] = datetime.now().isoformat()
-            rewritten['metadata'] = {'generation_method': 'template_rewrite', 'error': str(e)}
-            return rewritten
+        except Exception as e:
+            self.logger.error(f"Failed to rewrite draft: {str(e)}")
+            # Fallback to simple modification
+            rewritten = existing_draft.copy()
+            rewritten['draft_id'] = f"uuid:{str(uuid.uuid4())}"
+            rewritten['draft_approach'] = "rewrite"
+            rewritten['draft_type'] = "rewrite"
+            rewritten['email_body'] = f"[REWRITTEN: {reason}]\n\n" + existing_draft.get('email_body', '')
+            rewritten['rewrite_reason'] = reason
+            rewritten['rewritten_at'] = datetime.now().isoformat()
+            rewritten['metadata'] = {'generation_method': 'template_rewrite', 'error': str(e)}
+            rewritten['email_body'] = self._clean_email_content(rewritten['email_body'], context)
+            fallback_identity = context.get('_recipient_identity') or self._resolve_recipient_identity(customer_data, context)
+            if fallback_identity:
+                rewritten['recipient_email'] = fallback_identity.get('email')
+                rewritten['recipient_name'] = fallback_identity.get('full_name')
+                rewritten['customer_first_name'] = fallback_identity.get('first_name')
+                rewritten['metadata']['recipient_email'] = fallback_identity.get('email')
+                rewritten['metadata']['recipient_name'] = fallback_identity.get('full_name')
+            rewritten['metadata']['email_format'] = 'html'
+            rewritten['email_format'] = 'html'
+            return rewritten
 
     def _save_rewritten_draft(self, context: Dict[str, Any], rewritten_draft: Dict[str, Any], original_draft_id: str) -> Dict[str, Any]:
         """Save rewritten draft to database and file system."""

fusesell_local/utils/data_manager.py

@@ -552,6 +552,7 @@ class LocalDataManager:
                         status TEXT NOT NULL,
                         task TEXT NOT NULL,
                         cron TEXT NOT NULL,
+                        cron_ts INTEGER,
                         room_id TEXT,
                         tags TEXT,
                         customextra TEXT,
@@ -567,6 +568,11 @@ class LocalDataManager:
                     )
                 """)
 
+                cursor.execute("PRAGMA table_info(reminder_task)")
+                reminder_columns = {row[1] for row in cursor.fetchall()}
+                if 'cron_ts' not in reminder_columns:
+                    cursor.execute("ALTER TABLE reminder_task ADD COLUMN cron_ts INTEGER")
+
                 # Create extracted_files table (equivalent to gs_plan_setting_extracted_file)
                 cursor.execute("""
                     CREATE TABLE IF NOT EXISTS extracted_files (
@@ -684,6 +690,8 @@ class LocalDataManager:
                     "CREATE INDEX IF NOT EXISTS idx_reminder_task_task_id ON reminder_task(task_id)")
                 cursor.execute(
                     "CREATE INDEX IF NOT EXISTS idx_reminder_task_cron ON reminder_task(cron)")
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_reminder_task_cron_ts ON reminder_task(cron_ts)")
                 cursor.execute(
                     "CREATE INDEX IF NOT EXISTS idx_extracted_files_org_id ON extracted_files(org_id)")
                 cursor.execute(

fusesell_local/utils/event_scheduler.py

@@ -4,7 +4,7 @@ Creates scheduled events in database for external app to handle
 """
 
 import logging
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Dict, Any, Optional, List, Union
 import pytz
 import json
@@ -84,6 +84,7 @@ class EventScheduler:
                     status TEXT NOT NULL,
                     task TEXT NOT NULL,
                     cron TEXT NOT NULL,
+                    cron_ts INTEGER,
                     room_id TEXT,
                     tags TEXT,
                     customextra TEXT,
@@ -115,6 +116,11 @@ class EventScheduler:
                 CREATE INDEX IF NOT EXISTS idx_reminder_task_cron 
                 ON reminder_task(cron)
             """)
+
+            cursor.execute("PRAGMA table_info(reminder_task)")
+            columns = {row[1] for row in cursor.fetchall()}
+            if 'cron_ts' not in columns:
+                cursor.execute("ALTER TABLE reminder_task ADD COLUMN cron_ts INTEGER")
             
             conn.commit()
             conn.close()
@@ -191,6 +197,19 @@ class EventScheduler:
         except ValueError:
             return value_str
 
+    def _to_unix_timestamp(self, value: Union[str, datetime, None]) -> Optional[int]:
+        """
+        Convert a datetime-like value to a Unix timestamp (seconds).
+        """
+        iso_value = self._format_datetime(value)
+        try:
+            parsed = datetime.fromisoformat(iso_value)
+        except ValueError:
+            return None
+        if parsed.tzinfo is None:
+            parsed = parsed.replace(tzinfo=timezone.utc)
+        return int(parsed.timestamp())
+
     def _build_reminder_payload(
         self,
         base_context: Dict[str, Any],
@@ -296,11 +315,13 @@ class EventScheduler:
 
         cron_value = self._format_datetime(cron_value or send_time)
         scheduled_time_str = self._format_datetime(scheduled_time_value or send_time)
+        cron_ts = self._to_unix_timestamp(cron_value)
 
         return {
             'status': status,
             'task': task_label,
             'cron': cron_value,
+            'cron_ts': cron_ts,
             'room_id': room_id,
             'tags': tags,
             'customextra': customextra,
@@ -346,15 +367,20 @@ class EventScheduler:
             conn = sqlite3.connect(self.main_db_path)
             cursor = conn.cursor()
 
+            cron_ts = payload.get('cron_ts')
+            if cron_ts is None:
+                cron_ts = self._to_unix_timestamp(payload.get('cron'))
+
             cursor.execute("""
                 INSERT INTO reminder_task
-                (id, status, task, cron, room_id, tags, customextra, org_id, customer_id, task_id, import_uuid, scheduled_time)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                (id, status, task, cron, cron_ts, room_id, tags, customextra, org_id, customer_id, task_id, import_uuid, scheduled_time)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """, (
                 reminder_id,
                 payload.get('status', 'published'),
                 payload.get('task') or 'FuseSell Reminder',
                 self._format_datetime(payload.get('cron')),
+                cron_ts,
                 payload.get('room_id'),
                 tags_str,
                 customextra_str,
@@ -455,6 +481,7 @@ class EventScheduler:
                     draft_id=draft_id,
                     customer_timezone=customer_timezone
                 )
+                reminder_payload.setdefault('cron_ts', self._to_unix_timestamp(reminder_payload.get('cron')))
                 reminder_task_id = self._insert_reminder_task(reminder_payload)
 
             # Log the scheduling
@@ -585,6 +612,7 @@ class EventScheduler:
                     draft_id=original_draft_id,
                     customer_timezone=event_data['customer_timezone']
                 )
+                reminder_payload.setdefault('cron_ts', self._to_unix_timestamp(reminder_payload.get('cron')))
                 reminder_task_id = self._insert_reminder_task(reminder_payload)
             
             self.logger.info(f"Scheduled follow-up event {followup_event_id} for {follow_up_time}")
@@ -834,18 +862,18 @@ class EventScheduler:
             
             # Convert to list of dictionaries
             events = []
-            for row in rows:
-                event = dict(zip(columns, row))
-                # Parse event_data JSON
-                if event['event_data']:
-                    try:
-                        event['event_data'] = json.loads(event['event_data'])
-                    except json.JSONDecodeError:
-                        pass
-                events.append(event)
-            
-            return events
-            
+            for row in rows:
+                event = dict(zip(columns, row))
+                # Parse event_data JSON
+                if event['event_data']:
+                    try:
+                        event['event_data'] = json.loads(event['event_data'])
+                    except json.JSONDecodeError:
+                        pass
+                events.append(event)
+            
+            return events
+            
         except Exception as e:
             self.logger.error(f"Failed to get scheduled events: {str(e)}")
             return []