update

backend/app/main.py

@@ -283,9 +283,33 @@ async def download_sequences(file_id: str = Query(...), db: Session = Depends(ge
         raise HTTPException(status_code=500, detail=f"Error downloading sequences: {str(e)}")
 
 
+@app.get("/api/smartlead-campaigns")
+async def get_smartlead_campaigns():
+    """Get list of campaigns from Smartlead"""
+    try:
+        client = SmartleadClient()
+        campaigns = client.get_campaigns()
+        
+        # Format campaigns for frontend
+        formatted_campaigns = []
+        for campaign in campaigns:
+            campaign_id = campaign.get('campaign_id') or campaign.get('id') or campaign.get('campaignId')
+            campaign_name = campaign.get('name') or campaign.get('campaign_name') or campaign.get('title') or 'Unnamed Campaign'
+            
+            if campaign_id:
+                formatted_campaigns.append({
+                    "id": str(campaign_id),
+                    "name": campaign_name
+                })
+        
+        return {"campaigns": formatted_campaigns}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to fetch campaigns: {str(e)}")
+
+
 @app.post("/api/push-to-smartlead")
 async def push_to_smartlead(request: SmartleadPushRequest, db: Session = Depends(get_db)):
-    """Push generated sequences to Smartlead campaign"""
+    """Push generated sequences to Smartlead campaign (add leads to existing campaign)"""
     import uuid
     
     try:
@@ -314,15 +338,30 @@ async def push_to_smartlead(request: SmartleadPushRequest, db: Session = Depends
             contacts[contact_key]['subjects'][seq.email_number] = seq.subject
             contacts[contact_key]['bodies'][seq.email_number] = seq.email_content
         
+        # Initialize Smartlead client
+        try:
+            client = SmartleadClient()
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        
+        # Get campaign name for logging
+        campaigns = client.get_campaigns()
+        campaign_name = 'Unknown Campaign'
+        for campaign in campaigns:
+            campaign_id = campaign.get('campaign_id') or campaign.get('id') or campaign.get('campaignId')
+            if str(campaign_id) == str(request.campaign_id):
+                campaign_name = campaign.get('name') or campaign.get('campaign_name') or campaign.get('title') or 'Unknown Campaign'
+                break
+        
         # Create run record
         run_id = str(uuid.uuid4())
         run = SmartleadRun(
             run_id=run_id,
             file_id=request.file_id,
-            mode=request.mode,
-            campaign_id=request.campaign_id or '',
-            campaign_name=request.campaign_name or '',
-            steps_count=request.steps_count,
+            mode='existing',  # Always 'existing' now
+            campaign_id=request.campaign_id,
+            campaign_name=campaign_name,
+            steps_count=0,  # Not needed for existing campaigns
             dry_run=1 if request.dry_run else 0,
             total_leads=len(contacts),
             status='pending'
@@ -335,8 +374,7 @@ async def push_to_smartlead(request: SmartleadPushRequest, db: Session = Depends
             return {
                 "run_id": run_id,
                 "campaign_id": request.campaign_id,
-                "campaign_name": request.campaign_name,
-                "steps_count": request.steps_count,
+                "campaign_name": campaign_name,
                 "total": len(contacts),
                 "added": 0,
                 "skipped": 0,
@@ -346,58 +384,8 @@ async def push_to_smartlead(request: SmartleadPushRequest, db: Session = Depends
                 "message": "Dry run completed. No leads were sent to Smartlead."
             }
         
-        # Initialize Smartlead client
-        try:
-            client = SmartleadClient()
-        except ValueError as e:
-            run.status = 'failed'
-            run.error_details = str(e)
-            db.commit()
-            raise HTTPException(status_code=400, detail=str(e))
-        
         campaign_id = request.campaign_id
         
-        # Create campaign if mode is 'new'
-        if request.mode == 'new':
-            try:
-                campaign_response = client.create_campaign(request.campaign_name)
-                campaign_id = campaign_response.get('campaign_id') or campaign_response.get('id')
-                if not campaign_id:
-                    raise Exception("Campaign creation failed: No campaign_id returned")
-                
-                run.campaign_id = campaign_id
-                db.commit()
-                
-                # Build and save sequences
-                sequences_data = client.build_sequences(request.steps_count)
-                client.save_campaign_sequence(campaign_id, sequences_data)
-                
-                # Define custom fields at campaign level (subject_1, body_1, etc.)
-                # Smartlead requires custom fields to be defined before they can be used in leads
-                # Note: This may need to be done via campaign settings or a separate endpoint
-                # For now, we'll try to define them via update_campaign_settings
-                custom_fields = {}
-                for i in range(1, request.steps_count + 1):
-                    custom_fields[f'subject_{i}'] = 'text'  # Field type
-                    custom_fields[f'body_{i}'] = 'text'    # Field type
-                
-                # Try to update campaign settings with custom fields
-                # Note: The exact API structure may vary - this is an attempt
-                try:
-                    client.update_campaign_settings(campaign_id, {
-                        "custom_fields": custom_fields
-                    })
-                except Exception as e:
-                    # If custom fields can't be set via settings, continue anyway
-                    # They might be auto-created when used, or defined differently
-                    pass
-                
-            except Exception as e:
-                run.status = 'failed'
-                run.error_details = str(e)
-                db.commit()
-                raise HTTPException(status_code=500, detail=f"Failed to create campaign: {str(e)}")
-        
         # Prepare leads for Smartlead
         leads = []
         errors = []
@@ -443,33 +431,14 @@ async def push_to_smartlead(request: SmartleadPushRequest, db: Session = Depends
                     continue
                 
                 # Build lead object - Smartlead API doesn't allow "company", "title", or custom variables when adding leads
-                # We'll add leads first, then try to update them with custom variables separately
+                # Custom variables should be set manually in Smartlead via CSV import
                 lead = {
                     "email": email,
                     "first_name": first_name,
                     "last_name": last_name
                 }
                 
-                # Store custom variables separately to update leads after adding
-                custom_vars = {}
-                for i in range(1, request.steps_count + 1):
-                    if i in contact.get('subjects', {}):
-                        subject = contact['subjects'][i]
-                        subject_str = safe_str(subject) if subject else ""
-                        if subject_str:
-                            custom_vars[f'subject_{i}'] = subject_str
-                    if i in contact.get('bodies', {}):
-                        body = contact['bodies'][i]
-                        body_str = safe_str(body) if body else ""
-                        if body_str:
-                            custom_vars[f'body_{i}'] = body_str
-                
-                # Store lead with custom vars for later update
-                leads.append({
-                    "lead_data": lead,
-                    "custom_vars": custom_vars,
-                    "email": email
-                })
+                leads.append(lead)
                 
             except Exception as e:
                 errors.append({
@@ -478,103 +447,22 @@ async def push_to_smartlead(request: SmartleadPushRequest, db: Session = Depends
                 })
                 failed_count += 1
         
-        # Step 1: Add leads without custom variables (chunk in batches of 50)
+        # Add leads to campaign (chunk in batches of 50)
         batch_size = 50
-        leads_to_update = []  # Store leads with their lead_ids for updating custom vars
-        
         for i in range(0, len(leads), batch_size):
             batch = leads[i:i + batch_size]
-            # Extract just the lead_data (without custom_vars) for adding
-            lead_batch = [item["lead_data"] for item in batch]
             try:
-                response = client.add_leads_to_campaign(campaign_id, lead_batch)
-                added_count += len(lead_batch)
-                
-                # Parse response to extract lead_ids
-                # Smartlead API response structure may vary - try common patterns
-                if isinstance(response, dict):
-                    # Check for different response structures
-                    added_leads = response.get('added_leads') or response.get('leads') or response.get('data') or []
-                    
-                    # Map emails to lead_ids from response
-                    email_to_lead_id = {}
-                    if isinstance(added_leads, list):
-                        for lead_info in added_leads:
-                            if isinstance(lead_info, dict):
-                                lead_id = lead_info.get('lead_id') or lead_info.get('id') or lead_info.get('leadId')
-                                lead_email = lead_info.get('email') or lead_info.get('email_address')
-                                if lead_id and lead_email:
-                                    email_to_lead_id[lead_email] = lead_id
-                    
-                    # Store leads with their lead_ids for updating
-                    for item in batch:
-                        lead_email = item.get('email')
-                        lead_id = email_to_lead_id.get(lead_email)
-                        if lead_id and item.get('custom_vars'):
-                            leads_to_update.append({
-                                'lead_id': lead_id,
-                                'email': lead_email,
-                                'custom_vars': item['custom_vars']
-                            })
-                    # If response doesn't have lead_ids, store with email for later lookup
-                    if not email_to_lead_id:
-                        for item in batch:
-                            if item.get('custom_vars'):
-                                leads_to_update.append({
-                                    'lead_id': None,  # Will try to get from email lookup
-                                    'email': item.get('email'),
-                                    'custom_vars': item['custom_vars']
-                                })
-                
+                response = client.add_leads_to_campaign(campaign_id, batch)
+                added_count += len(batch)
             except Exception as e:
                 # Mark batch as failed
-                for item in batch:
+                for lead in batch:
                     errors.append({
-                        "email": item.get('email', 'unknown'),
+                        "email": lead.get('email', 'unknown'),
                         "error": f"Failed to add lead: {str(e)}"
                     })
                     failed_count += 1
         
-        # Step 2: Try to update each successfully added lead with custom variables
-        # First, fetch lead_id for any leads that don't have it
-        for item in leads_to_update:
-            if not item.get('lead_id'):
-                # Try to fetch lead_id by email
-                try:
-                    lead_info = client.get_lead_by_email(campaign_id, item['email'])
-                    if lead_info:
-                        lead_id = lead_info.get('lead_id') or lead_info.get('id') or lead_info.get('leadId')
-                        if lead_id:
-                            item['lead_id'] = lead_id
-                except Exception as e:
-                    # If we can't fetch lead_id, we'll skip updating this lead
-                    pass
-        
-        # Now update leads with custom variables
-        for item in leads_to_update:
-            if item.get('lead_id'):
-                try:
-                    # Convert lead_id to int if it's a string
-                    lead_id = int(item['lead_id'])
-                    client.update_lead(campaign_id, lead_id, item['custom_vars'])
-                except (ValueError, TypeError) as e:
-                    errors.append({
-                        "email": item.get('email', 'unknown'),
-                        "error": f"Lead added but invalid lead_id: {str(e)}"
-                    })
-                except Exception as e:
-                    # If update fails, log but don't fail the entire operation
-                    errors.append({
-                        "email": item.get('email', 'unknown'),
-                        "error": f"Lead added but custom variables could not be set: {str(e)}"
-                    })
-            else:
-                # If we still don't have lead_id after trying to fetch it, log an error
-                errors.append({
-                    "email": item.get('email', 'unknown'),
-                    "error": "Lead added but lead_id not found - cannot update custom variables. You may need to set them manually in Smartlead UI."
-                })
-        
         # Update run record
         run.status = 'completed'
         run.added_leads = added_count
@@ -589,8 +477,7 @@ async def push_to_smartlead(request: SmartleadPushRequest, db: Session = Depends
         return {
             "run_id": run_id,
             "campaign_id": campaign_id,
-            "campaign_name": request.campaign_name or '',
-            "steps_count": request.steps_count,
+            "campaign_name": campaign_name,
             "total": len(contacts),
             "added": added_count,
             "skipped": skipped_count,

backend/app/models.py

@@ -29,10 +29,7 @@ class SequenceResponse(BaseModel):
 
 class SmartleadPushRequest(BaseModel):
     file_id: str
-    mode: str  # 'existing' or 'new'
-    campaign_id: Optional[str] = None
-    campaign_name: Optional[str] = None
-    steps_count: int = 4
+    campaign_id: str  # Required - campaign ID to add leads to
     dry_run: bool = False
 
 

backend/app/smartlead_client.py

@@ -110,39 +110,30 @@ class SmartleadClient:
         
         raise Exception("Failed to make request after retries")
     
-    def create_campaign(self, name: str) -> Dict:
-        """Create a new campaign
+    def get_campaigns(self) -> List[Dict]:
+        """Get list of all campaigns from Smartlead
         
-        Smartlead API might expect different parameter names.
-        Try common variations: "name", "campaign_name", "title"
+        Returns list of campaigns with their IDs and names
         """
-        # Try different parameter name variations
-        variations = [
-            {"name": name},  # Most common format
-            {"campaign_name": name},  # Alternative
-            {"title": name},  # Another alternative
-        ]
-        
-        endpoints = ["/campaigns/create", "/campaigns"]
-        
-        last_error = None
-        for endpoint in endpoints:
-            for data in variations:
-                try:
-                    return self._make_request("POST", endpoint, data)
-                except Exception as e:
-                    last_error = e
-                    # If it's a 400 error about parameter name, try next variation
-                    if "400" in str(e) and ("not allowed" in str(e) or "invalid" in str(e).lower()):
-                        continue
-                    # If it's a 404, try next endpoint
-                    if "404" in str(e):
-                        break
-                    # For other errors, re-raise
-                    raise
-        
-        # If all variations failed, raise the last error
-        raise last_error if last_error else Exception("Failed to create campaign: All parameter variations failed")
+        try:
+            response = self._make_request("GET", "/campaigns")
+            
+            # Handle different response structures
+            if isinstance(response, list):
+                return response
+            elif isinstance(response, dict):
+                # Check for common response structures
+                campaigns = response.get('campaigns') or response.get('data') or response.get('results') or []
+                if isinstance(campaigns, list):
+                    return campaigns
+                # If it's a dict with campaign info, wrap it
+                if response.get('campaign_id') or response.get('id'):
+                    return [response]
+            
+            return []
+        except Exception as e:
+            # If endpoint doesn't exist or fails, return empty list
+            return []
     
     def save_campaign_sequence(self, campaign_id: str, sequences: List[Dict]) -> Dict:
         """Save campaign sequence steps"""

frontend/src/components/smartlead/SmartleadPanel.jsx

@@ -1,34 +1,49 @@
-import React, { useState } from 'react';
-import { Send, Download, Loader2, CheckCircle2, AlertCircle, Settings } from 'lucide-react';
+import React, { useState, useEffect } from 'react';
+import { Send, Download, Loader2, CheckCircle2, AlertCircle, Settings, RefreshCw } from 'lucide-react';
 import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
-import { Badge } from "@/components/ui/badge";
 import { motion } from 'framer-motion';
 
 export default function SmartleadPanel({ uploadedFile, sequencesCount, onPushComplete }) {
-    const [mode, setMode] = useState('existing');
-    const [campaignId, setCampaignId] = useState('');
-    const [campaignName, setCampaignName] = useState('');
-    const [stepsCount, setStepsCount] = useState(4);
+    const [selectedCampaignId, setSelectedCampaignId] = useState('');
+    const [campaigns, setCampaigns] = useState([]);
+    const [isLoadingCampaigns, setIsLoadingCampaigns] = useState(false);
     const [dryRun, setDryRun] = useState(false);
     const [isPushing, setIsPushing] = useState(false);
     const [pushResult, setPushResult] = useState(null);
     const [error, setError] = useState(null);
 
+    // Fetch campaigns on component mount
+    useEffect(() => {
+        fetchCampaigns();
+    }, []);
+
+    const fetchCampaigns = async () => {
+        setIsLoadingCampaigns(true);
+        setError(null);
+        try {
+            const response = await fetch('/api/smartlead-campaigns');
+            const data = await response.json();
+            if (response.ok) {
+                setCampaigns(data.campaigns || []);
+            } else {
+                setError('Failed to fetch campaigns: ' + (data.detail || 'Unknown error'));
+            }
+        } catch (err) {
+            setError('Network error: ' + err.message);
+        } finally {
+            setIsLoadingCampaigns(false);
+        }
+    };
+
     const handlePushToSmartlead = async () => {
         if (!uploadedFile?.fileId) {
             setError('No file uploaded');
             return;
         }
 
-        if (mode === 'existing' && !campaignId.trim()) {
-            setError('Campaign ID is required');
-            return;
-        }
-
-        if (mode === 'new' && !campaignName.trim()) {
-            setError('Campaign name is required');
+        if (!selectedCampaignId) {
+            setError('Please select a campaign');
             return;
         }
 
@@ -42,10 +57,7 @@ export default function SmartleadPanel({ uploadedFile, sequencesCount, onPushCom
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify({
                     file_id: uploadedFile.fileId,
-                    mode: mode,
-                    campaign_id: mode === 'existing' ? campaignId.trim() : null,
-                    campaign_name: mode === 'new' ? campaignName.trim() : null,
-                    steps_count: stepsCount,
+                    campaign_id: selectedCampaignId,
                     dry_run: dryRun
                 })
             });
@@ -98,71 +110,51 @@ export default function SmartleadPanel({ uploadedFile, sequencesCount, onPushCom
                     </div>
                 </div>
 
-                {/* Mode Selector */}
+                {/* Campaign Selector */}
                 <div className="mb-6">
-                    <label className="text-sm font-medium text-slate-700 mb-2 block">
-                        Campaign Mode
-                    </label>
-                    <Select value={mode} onValueChange={setMode}>
-                        <SelectTrigger className="w-full">
-                            <SelectValue />
-                        </SelectTrigger>
-                        <SelectContent>
-                            <SelectItem value="existing">Use Existing Campaign ID</SelectItem>
-                            <SelectItem value="new">Create New Campaign</SelectItem>
-                        </SelectContent>
-                    </Select>
-                </div>
-
-                {/* Campaign ID (Mode 1) */}
-                {mode === 'existing' && (
-                    <div className="mb-4">
-                        <label className="text-sm font-medium text-slate-700 mb-2 block">
-                            Campaign ID
-                        </label>
-                        <Input
-                            value={campaignId}
-                            onChange={(e) => setCampaignId(e.target.value)}
-                            placeholder="Enter existing campaign ID"
-                            className="w-full"
-                        />
-                    </div>
-                )}
-
-                {/* Campaign Name (Mode 2) */}
-                {mode === 'new' && (
-                    <div className="mb-4">
-                        <label className="text-sm font-medium text-slate-700 mb-2 block">
-                            Campaign Name
+                    <div className="flex items-center justify-between mb-2">
+                        <label className="text-sm font-medium text-slate-700">
+                            Select Campaign
                         </label>
-                        <Input
-                            value={campaignName}
-                            onChange={(e) => setCampaignName(e.target.value)}
-                            placeholder="Enter campaign name"
-                            className="w-full"
-                        />
+                        <Button
+                            type="button"
+                            variant="ghost"
+                            size="sm"
+                            onClick={fetchCampaigns}
+                            disabled={isLoadingCampaigns}
+                            className="h-7 text-xs"
+                        >
+                            <RefreshCw className={`h-3 w-3 mr-1 ${isLoadingCampaigns ? 'animate-spin' : ''}`} />
+                            Refresh
+                        </Button>
                     </div>
-                )}
-
-                {/* Steps Count */}
-                <div className="mb-4">
-                    <label className="text-sm font-medium text-slate-700 mb-2 block">
-                        Steps to Use
-                    </label>
-                    <Select value={stepsCount.toString()} onValueChange={(v) => setStepsCount(parseInt(v))}>
-                        <SelectTrigger className="w-full">
-                            <SelectValue />
-                        </SelectTrigger>
-                        <SelectContent>
-                            {[1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(num => (
-                                <SelectItem key={num} value={num.toString()}>
-                                    {num} {num === 1 ? 'step' : 'steps'}
-                                </SelectItem>
-                            ))}
-                        </SelectContent>
-                    </Select>
+                    {isLoadingCampaigns ? (
+                        <div className="flex items-center justify-center p-4 border border-slate-200 rounded-lg">
+                            <Loader2 className="h-4 w-4 animate-spin text-slate-400 mr-2" />
+                            <span className="text-sm text-slate-500">Loading campaigns...</span>
+                        </div>
+                    ) : campaigns.length === 0 ? (
+                        <div className="p-4 border border-slate-200 rounded-lg bg-slate-50">
+                            <p className="text-sm text-slate-600 text-center">
+                                No campaigns found. Please create a campaign in Smartlead first.
+                            </p>
+                        </div>
+                    ) : (
+                        <Select value={selectedCampaignId} onValueChange={setSelectedCampaignId}>
+                            <SelectTrigger className="w-full">
+                                <SelectValue placeholder="Select a campaign" />
+                            </SelectTrigger>
+                            <SelectContent>
+                                {campaigns.map((campaign) => (
+                                    <SelectItem key={campaign.id} value={campaign.id}>
+                                        {campaign.name} ({campaign.id})
+                                    </SelectItem>
+                                ))}
+                            </SelectContent>
+                        </Select>
+                    )}
                     <p className="text-xs text-slate-500 mt-1">
-                        Must align with generated sequences (max {sequencesCount || 10})
+                        Select an existing campaign to add leads to. Create campaigns manually in Smartlead using the CSV download.
                     </p>
                 </div>