update

backend/app/main.py

@@ -103,25 +103,70 @@ async def save_prompts(request: PromptSaveRequest, db: Session = Depends(get_db)
         raise HTTPException(status_code=500, detail=f"Error saving prompts: {str(e)}")
 
 
+@app.get("/api/generation-status")
+async def generation_status(file_id: str = Query(...), db: Session = Depends(get_db)):
+    """Return progress for sequence generation (so frontend can resume after sleep/reconnect)."""
+    db_file = db.query(UploadedFile).filter(UploadedFile.file_id == file_id).first()
+    if not db_file:
+        raise HTTPException(status_code=404, detail="File not found")
+    total_contacts = db_file.contact_count or 0
+    completed = (
+        db.query(GeneratedSequence.sequence_id)
+        .filter(GeneratedSequence.file_id == file_id)
+        .distinct()
+        .count()
+    )
+    return {
+        "file_id": file_id,
+        "total_contacts": total_contacts,
+        "completed_count": completed,
+        "is_complete": total_contacts > 0 and completed >= total_contacts,
+    }
+
+
+@app.get("/api/sequences")
+async def get_sequences(file_id: str = Query(...), db: Session = Depends(get_db)):
+    """Return all generated sequences for a file (for catch-up after reconnect)."""
+    sequences = (
+        db.query(GeneratedSequence)
+        .filter(GeneratedSequence.file_id == file_id)
+        .order_by(GeneratedSequence.sequence_id, GeneratedSequence.email_number)
+        .all()
+    )
+    out = []
+    for seq in sequences:
+        out.append({
+            "id": seq.sequence_id,
+            "emailNumber": seq.email_number,
+            "firstName": seq.first_name,
+            "lastName": seq.last_name,
+            "email": seq.email,
+            "company": seq.company,
+            "title": seq.title or "",
+            "product": seq.product,
+            "subject": seq.subject,
+            "emailContent": seq.email_content,
+        })
+    return {"sequences": out}
+
+
 @app.get("/api/generate-sequences")
 async def generate_sequences(
     file_id: str = Query(...),
-    db: Session = Depends(get_db)
+    reset: bool = Query(True),
+    db: Session = Depends(get_db),
 ):
-    """Generate email sequences using GPT with Server-Sent Events streaming"""
+    """Generate email sequences using GPT with Server-Sent Events streaming.
+    Use reset=1 for a fresh run (clears existing). Use reset=0 to resume after disconnect/sleep."""
     
     async def event_generator():
         try:
-            # Get uploaded file
             db_file = db.query(UploadedFile).filter(UploadedFile.file_id == file_id).first()
             if not db_file:
                 yield f"data: {json.dumps({'type': 'error', 'error': 'File not found'})}\n\n"
                 return
             
-            # Read CSV
             df = pd.read_csv(db_file.file_path)
-            
-            # Get prompts for this file
             prompts = db.query(Prompt).filter(Prompt.file_id == file_id).all()
             prompt_dict = {p.product_name: p.prompt_template for p in prompts}
             
@@ -129,37 +174,59 @@ async def generate_sequences(
                 yield f"data: {json.dumps({'type': 'error', 'error': 'No prompts found'})}\n\n"
                 return
             
-            # Get products from prompts
             products = list(prompt_dict.keys())
+            if reset:
+                db.query(GeneratedSequence).filter(GeneratedSequence.file_id == file_id).delete()
+                db.commit()
             
-            # Clear existing sequences
-            db.query(GeneratedSequence).filter(GeneratedSequence.file_id == file_id).delete()
-            db.commit()
-            
-            sequence_id = 1
             total_contacts = len(df)
+            sequence_id = 1
             
-            # Process each contact
             for idx, row in df.iterrows():
-                # Convert row to dict
-                contact = row.to_dict()
+                existing = (
+                    db.query(GeneratedSequence)
+                    .filter(
+                        GeneratedSequence.file_id == file_id,
+                        GeneratedSequence.sequence_id == sequence_id,
+                    )
+                    .order_by(GeneratedSequence.email_number)
+                    .all()
+                )
+                if existing:
+                    for seq in existing:
+                        sequence_response = {
+                            "id": seq.sequence_id,
+                            "emailNumber": seq.email_number,
+                            "firstName": seq.first_name,
+                            "lastName": seq.last_name,
+                            "email": seq.email,
+                            "company": seq.company,
+                            "title": seq.title or "",
+                            "product": seq.product,
+                            "subject": seq.subject,
+                            "emailContent": seq.email_content,
+                        }
+                        yield f"data: {json.dumps({'type': 'sequence', 'sequence': sequence_response})}\n\n"
+                    progress = min(100, max(0, (sequence_id / total_contacts) * 100)) if total_contacts > 0 else 0
+                    yield f"data: {json.dumps({'type': 'progress', 'progress': float(progress)})}\n\n"
+                    sequence_id += 1
+                    await asyncio.sleep(0.05)
+                    continue
                 
-                # Select product (round-robin or random)
+                contact = row.to_dict()
                 product_name = products[sequence_id % len(products)]
                 prompt_template = prompt_dict[product_name]
                 
-                # Generate sequence using GPT (run in executor to avoid blocking)
                 loop = asyncio.get_event_loop()
                 with concurrent.futures.ThreadPoolExecutor() as executor:
                     sequence_data_list = await loop.run_in_executor(
-                        executor, 
-                        generate_email_sequence, 
-                        contact, 
-                        prompt_template, 
-                        product_name
+                        executor,
+                        generate_email_sequence,
+                        contact,
+                        prompt_template,
+                        product_name,
                     )
                 
-                # Save all emails for this contact to database
                 for seq_data in sequence_data_list:
                     db_sequence = GeneratedSequence(
                         file_id=file_id,
@@ -172,13 +239,12 @@ async def generate_sequences(
                         title=seq_data.get("title", ""),
                         product=seq_data["product"],
                         subject=seq_data["subject"],
-                        email_content=seq_data["email_content"]
+                        email_content=seq_data["email_content"],
                     )
                     db.add(db_sequence)
                 
                 db.commit()
                 
-                # Stream all emails for this contact
                 for seq_data in sequence_data_list:
                     sequence_response = {
                         "id": sequence_id,
@@ -190,21 +256,15 @@ async def generate_sequences(
                         "title": seq_data.get("title", ""),
                         "product": seq_data["product"],
                         "subject": seq_data["subject"],
-                        "emailContent": seq_data["email_content"]
+                        "emailContent": seq_data["email_content"],
                     }
-                    
                     yield f"data: {json.dumps({'type': 'sequence', 'sequence': sequence_response})}\n\n"
                 
-                # Send progress update
                 progress = min(100, max(0, (sequence_id / total_contacts) * 100)) if total_contacts > 0 else 0
                 yield f"data: {json.dumps({'type': 'progress', 'progress': float(progress)})}\n\n"
-                
                 sequence_id += 1
-                
-                # Small delay to prevent overwhelming the API
                 await asyncio.sleep(0.1)
             
-            # Send completion
             yield f"data: {json.dumps({'type': 'complete'})}\n\n"
             
         except Exception as e:
@@ -252,10 +312,10 @@ async def download_sequences(file_id: str = Query(...), db: Session = Depends(ge
         output = io.StringIO()
         writer = csv.writer(output, quoting=csv.QUOTE_MINIMAL)
         
-        # Write header - only include columns up to the maximum email number found
+        # Write header – fixed format: subject1, body1, subject2, body2, ... (separate columns, not merged)
         header = ['First Name', 'Last Name', 'Email', 'Company', 'Title', 'Product']
         for i in range(1, max_email_number + 1):
-            header.extend([f'Subject {i}', f'Body {i}'])
+            header.extend([f'subject{i}', f'body{i}'])
         writer.writerow(header)
         
         # Write rows (one row per contact with subjects/bodies up to max_email_number)
@@ -287,12 +347,12 @@ async def download_sequences(file_id: str = Query(...), db: Session = Depends(ge
         
         output.seek(0)
         
-        # Return as downloadable file
+        # Return as downloadable file (fixed format: one row per contact, separate subject/body columns)
         return StreamingResponse(
             iter([output.getvalue()]),
             media_type="text/csv",
             headers={
-                "Content-Disposition": f"attachment; filename=email_sequences_{file_id}.csv"
+                "Content-Disposition": "attachment; filename=email_sequences_fixed.csv"
             }
         )
         

frontend/src/components/sequences/SequenceViewer.jsx

@@ -1,4 +1,4 @@
-import React, { useState, useEffect } from 'react';
+import React, { useState, useEffect, useRef } from 'react';
 import { Download, Mail, Loader2, CheckCircle2, Search, Filter } from 'lucide-react';
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
@@ -7,107 +7,170 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@
 import { motion, AnimatePresence } from 'framer-motion';
 import SequenceCard from './SequenceCard';
 
-export default function SequenceViewer({ isGenerating, contactCount, selectedProducts, uploadedFile, prompts, onComplete }) {
+function applySequenceToContacts(prev, sequence, contactCount, setProgress) {
+    const existingContact = prev.find(c =>
+        c.firstName === sequence.firstName &&
+        c.lastName === sequence.lastName &&
+        c.email === sequence.email
+    );
+    let updatedContacts;
+    if (existingContact) {
+        existingContact.emails.push({
+            emailNumber: sequence.emailNumber || existingContact.emails.length + 1,
+            subject: sequence.subject,
+            emailContent: sequence.emailContent
+        });
+        updatedContacts = [...prev];
+    } else {
+        updatedContacts = [...prev, {
+            id: sequence.id,
+            firstName: sequence.firstName,
+            lastName: sequence.lastName,
+            email: sequence.email,
+            company: sequence.company,
+            title: sequence.title,
+            product: sequence.product,
+            emails: [{
+                emailNumber: sequence.emailNumber || 1,
+                subject: sequence.subject,
+                emailContent: sequence.emailContent
+            }]
+        }];
+    }
+    const progressValue = contactCount > 0
+        ? Math.min(100, Math.max(0, (updatedContacts.length / contactCount) * 100))
+        : 0;
+    setProgress(progressValue);
+    return updatedContacts;
+}
+
+export default function SequenceViewer({ isGenerating, generationRunId, contactCount, selectedProducts, uploadedFile, prompts, onComplete }) {
     const [sequences, setSequences] = useState([]);
     const [contacts, setContacts] = useState([]);
     const [progress, setProgress] = useState(0);
     const [searchQuery, setSearchQuery] = useState('');
     const [filterProduct, setFilterProduct] = useState('all');
     const [isComplete, setIsComplete] = useState(false);
-    const [displayedCount, setDisplayedCount] = useState(50); // Pagination: show 50 at a time
+    const [displayedCount, setDisplayedCount] = useState(50);
+    const [reconnectKey, setReconnectKey] = useState(0);
+    const prevRunIdRef = useRef(null);
 
     useEffect(() => {
-        if (isGenerating && uploadedFile?.fileId) {
+        if (!isGenerating || !uploadedFile?.fileId) return;
+
+        const isNewRun = prevRunIdRef.current !== generationRunId;
+        if (isNewRun) {
+            prevRunIdRef.current = generationRunId;
             setSequences([]);
             setContacts([]);
             setProgress(0);
             setIsComplete(false);
-            
-            // Start streaming sequences from API
-            const eventSource = new EventSource(`/api/generate-sequences?file_id=${uploadedFile.fileId}`, {
-                withCredentials: false
-            });
-            
-            eventSource.onmessage = (event) => {
-                try {
-                    const data = JSON.parse(event.data);
-                    
-                    if (data.type === 'sequence') {
-                        const sequence = data.sequence;
-                        setSequences(prev => [...prev, sequence]);
-                        
-                        // Group sequences by contact (sequence.id)
-                        setContacts(prev => {
-                            const existingContact = prev.find(c => 
-                                c.firstName === sequence.firstName && 
-                                c.lastName === sequence.lastName && 
-                                c.email === sequence.email
-                            );
-                            
-                            let updatedContacts;
-                            if (existingContact) {
-                                // Add email to existing contact
-                                existingContact.emails.push({
-                                    emailNumber: sequence.emailNumber || existingContact.emails.length + 1,
-                                    subject: sequence.subject,
-                                    emailContent: sequence.emailContent
+        }
+
+        const reset = isNewRun ? 1 : 0;
+        const url = `/api/generate-sequences?file_id=${encodeURIComponent(uploadedFile.fileId)}&reset=${reset}`;
+        const eventSource = new EventSource(url, { withCredentials: false });
+
+        eventSource.onmessage = (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                if (data.type === 'sequence') {
+                    const seq = data.sequence;
+                    setSequences(prev => {
+                        if (prev.some(s => s.id === seq.id && s.emailNumber === seq.emailNumber)) return prev;
+                        return [...prev, seq];
+                    });
+                    setContacts(prev => {
+                        const existing = prev.find(c => c.email === seq.email);
+                        if (existing?.emails.some(e => e.emailNumber === seq.emailNumber)) return prev;
+                        return applySequenceToContacts(prev, seq, contactCount, setProgress);
+                    });
+                } else if (data.type === 'progress') {
+                    setProgress(data.progress);
+                } else if (data.type === 'complete') {
+                    setIsComplete(true);
+                    onComplete?.();
+                    eventSource.close();
+                } else if (data.type === 'error') {
+                    console.error('Generation error:', data.error);
+                    alert('Error generating sequences: ' + data.error);
+                    eventSource.close();
+                }
+            } catch (err) {
+                console.error('Error parsing SSE data:', err);
+            }
+        };
+
+        eventSource.onerror = () => {
+            eventSource.close();
+            if (!isComplete) setReconnectKey(k => k + 1);
+        };
+
+        return () => eventSource.close();
+    }, [isGenerating, uploadedFile?.fileId, generationRunId, contactCount, reconnectKey, onComplete, isComplete]);
+
+    useEffect(() => {
+        if (!isGenerating || !uploadedFile?.fileId || reconnectKey === 0) return;
+        let cancelled = false;
+        (async () => {
+            try {
+                const [statusRes, seqRes] = await Promise.all([
+                    fetch(`/api/generation-status?file_id=${encodeURIComponent(uploadedFile.fileId)}`),
+                    fetch(`/api/sequences?file_id=${encodeURIComponent(uploadedFile.fileId)}`)
+                ]);
+                if (cancelled) return;
+                if (statusRes.ok && seqRes.ok) {
+                    const status = await statusRes.json();
+                    const { sequences: list } = await seqRes.json();
+                    if (status.is_complete) {
+                        setIsComplete(true);
+                        onComplete?.();
+                    }
+                    if (list?.length > 0) {
+                        const byContact = new Map();
+                        list.forEach(seq => {
+                            const key = seq.email;
+                            if (!byContact.has(key)) {
+                                byContact.set(key, {
+                                    id: seq.id,
+                                    firstName: seq.firstName,
+                                    lastName: seq.lastName,
+                                    email: seq.email,
+                                    company: seq.company,
+                                    title: seq.title,
+                                    product: seq.product,
+                                    emails: []
                                 });
-                                updatedContacts = [...prev];
-                            } else {
-                                // Create new contact
-                                updatedContacts = [...prev, {
-                                    id: sequence.id,
-                                    firstName: sequence.firstName,
-                                    lastName: sequence.lastName,
-                                    email: sequence.email,
-                                    company: sequence.company,
-                                    title: sequence.title,
-                                    product: sequence.product,
-                                    emails: [{
-                                        emailNumber: sequence.emailNumber || 1,
-                                        subject: sequence.subject,
-                                        emailContent: sequence.emailContent
-                                    }]
-                                }];
                             }
-                            
-                            // Update progress based on unique contacts
-                            const progressValue = contactCount > 0 
-                                ? Math.min(100, Math.max(0, (updatedContacts.length / contactCount) * 100))
-                                : 0;
-                            setProgress(progressValue);
-                            
-                            return updatedContacts;
+                            byContact.get(key).emails.push({
+                                emailNumber: seq.emailNumber,
+                                subject: seq.subject,
+                                emailContent: seq.emailContent
+                            });
                         });
-                    } else if (data.type === 'progress') {
-                        setProgress(data.progress);
-                    } else if (data.type === 'complete') {
-                        setIsComplete(true);
-                        onComplete?.();
-                        eventSource.close();
-                    } else if (data.type === 'error') {
-                        console.error('Generation error:', data.error);
-                        alert('Error generating sequences: ' + data.error);
-                        eventSource.close();
+                        const arr = [...byContact.values()];
+                        arr.sort((a, b) => (a.id || 0) - (b.id || 0));
+                        setSequences(list);
+                        setContacts(arr);
+                        const p = status.total_contacts > 0 ? Math.min(100, (arr.length / status.total_contacts) * 100) : 0;
+                        setProgress(p);
                     }
-                } catch (error) {
-                    console.error('Error parsing SSE data:', error);
                 }
-            };
-            
-            eventSource.onerror = (error) => {
-                console.error('SSE error:', error);
-                eventSource.close();
-                if (!isComplete) {
-                    alert('Connection error. Please try again.');
-                }
-            };
-            
-            return () => {
-                eventSource.close();
-            };
-        }
-    }, [isGenerating, uploadedFile, contactCount, selectedProducts, prompts, onComplete, isComplete]);
+            } catch (e) {
+                if (!cancelled) console.error('Reconnect fetch error:', e);
+            }
+        })();
+        return () => { cancelled = true; };
+    }, [reconnectKey, isGenerating, uploadedFile?.fileId, contactCount, onComplete]);
+
+    useEffect(() => {
+        if (!isGenerating || !uploadedFile?.fileId) return;
+        const onVisible = () => {
+            if (document.visibilityState === 'visible') setReconnectKey(k => k + 1);
+        };
+        document.addEventListener('visibilitychange', onVisible);
+        return () => document.removeEventListener('visibilitychange', onVisible);
+    }, [isGenerating, uploadedFile?.fileId]);
 
     const handleDownload = async () => {
         try {
@@ -117,7 +180,7 @@ export default function SequenceViewer({ isGenerating, contactCount, selectedPro
                 const url = URL.createObjectURL(blob);
                 const a = document.createElement('a');
                 a.href = url;
-                a.download = 'email_sequences.csv';
+                a.download = 'email_sequences_fixed.csv';
                 a.click();
                 URL.revokeObjectURL(url);
             } else {

frontend/src/components/smartlead/SmartleadPanel.jsx

@@ -85,7 +85,7 @@ export default function SmartleadPanel({ uploadedFile, sequencesCount, onPushCom
                 const url = URL.createObjectURL(blob);
                 const a = document.createElement('a');
                 a.href = url;
-                a.download = 'email_sequences.csv';
+                a.download = 'email_sequences_fixed.csv';
                 a.click();
                 URL.revokeObjectURL(url);
             } else {

frontend/src/pages/EmailSequenceGenerator.jsx

@@ -15,6 +15,7 @@ export default function EmailSequenceGenerator() {
     const [prompts, setPrompts] = useState({});
     const [isGenerating, setIsGenerating] = useState(false);
     const [generationComplete, setGenerationComplete] = useState(false);
+    const [generationRunId, setGenerationRunId] = useState(0);
     const generateButtonRef = useRef(null);
 
     const canProceedToStep2 = uploadedFile && selectedProducts.length > 0;
@@ -56,6 +57,7 @@ export default function EmailSequenceGenerator() {
             return;
         }
 
+        setGenerationRunId((r) => r + 1);
         setStep(3);
         setIsGenerating(true);
     };
@@ -265,6 +267,7 @@ export default function EmailSequenceGenerator() {
 
                             <SequenceViewer
                                 isGenerating={isGenerating}
+                                generationRunId={generationRunId}
                                 contactCount={uploadedFile?.contactCount || 50}
                                 selectedProducts={selectedProducts}
                                 uploadedFile={uploadedFile}