Update app.py

app.py

@@ -2,7 +2,7 @@ import os
 import json
 import time
 from datetime import datetime
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Union
 from pydantic import BaseModel, Field, EmailStr, validator
 from fastapi import FastAPI, HTTPException, Query, Depends, Request
 from fastapi.responses import JSONResponse, Response
@@ -23,7 +23,7 @@ except ImportError:
 load_dotenv()
 
 # Configuration
-SMARTLEAD_API_KEY = os.getenv("SMARTLEAD_API_KEY")
+SMARTLEAD_API_KEY = os.getenv("SMARTLEAD_API_KEY", "your-api-key-here")
 SMARTLEAD_BASE_URL = "https://server.smartlead.ai/api/v1"
 
 # Initialize FastAPI app
@@ -74,13 +74,26 @@ class LeadInput(BaseModel):
     first_name: Optional[str] = Field(None, description="Lead's first name")
     last_name: Optional[str] = Field(None, description="Lead's last name")
     email: str = Field(..., description="Lead's email address")
-    phone_number: Optional[str] = Field(None, description="Lead's phone number")
+    phone_number: Optional[Union[str, int]] = Field(None, description="Lead's phone number (can be string or integer)")
     company_name: Optional[str] = Field(None, description="Lead's company name")
     website: Optional[str] = Field(None, description="Lead's website")
     location: Optional[str] = Field(None, description="Lead's location")
-    custom_fields: Optional[Dict[str, str]] = Field(None, description="Custom fields as key-value pairs")
+    custom_fields: Optional[Dict[str, str]] = Field(None, description="Custom fields as key-value pairs (max 20 fields)")
     linkedin_profile: Optional[str] = Field(None, description="Lead's LinkedIn profile URL")
     company_url: Optional[str] = Field(None, description="Company website URL")
+    
+    @validator('custom_fields')
+    def validate_custom_fields(cls, v):
+        if v is not None and len(v) > 20:
+            raise ValueError('Custom fields cannot exceed 20 fields')
+        return v
+    
+    @validator('phone_number')
+    def validate_phone_number(cls, v):
+        if v is not None:
+            # Convert to string if it's an integer
+            return str(v)
+        return v
 
 class LeadSettings(BaseModel):
     ignore_global_block_list: bool = Field(True, description="Ignore leads if they are in the global block list")
@@ -124,54 +137,82 @@ class GenerateSequencesRequest(BaseModel):
     job_description: str = Field(..., description="Job description to generate sequences for")
 
 class Campaign(BaseModel):
-    id: int = Field(..., description="The unique ID of the campaign")
-    user_id: int = Field(..., description="The ID of the user who owns the campaign")
-    created_at: datetime = Field(..., description="Timestamp of when the campaign was created")
-    updated_at: datetime = Field(..., description="Timestamp of the last update to the campaign")
-    status: str = Field(..., description="Current status of the campaign (DRAFTED, ACTIVE, COMPLETED, STOPPED, PAUSED)")
-    name: str = Field(..., description="The name of the campaign")
-    track_settings: str = Field(..., description="Tracking settings string (e.g., 'DONT_REPLY_TO_AN_EMAIL')")
-    scheduler_cron_value: Optional[str] = Field(None, description="Scheduling details as JSON string")
-    min_time_btwn_emails: int = Field(..., description="Minimum time between emails in minutes")
-    max_leads_per_day: int = Field(..., description="Maximum number of leads to process per day")
-    stop_lead_settings: str = Field(..., description="Settings for stopping leads (REPLY_TO_AN_EMAIL, CLICK_ON_ANY_LINK, etc.)")
-    enable_ai_esp_matching: bool = Field(..., description="Indicates if AI ESP matching is enabled")
-    send_as_plain_text: bool = Field(..., description="Indicates if emails for this campaign are sent as plain text")
-    follow_up_percentage: str = Field(..., description="The percentage of follow-up emails allocated (e.g., '40%')")
-    unsubscribe_text: Optional[str] = Field(None, description="The text used for the unsubscribe link")
-    parent_campaign_id: Optional[int] = Field(None, description="Parent campaign ID if this is a child campaign")
-    client_id: Optional[int] = Field(None, description="The ID of the client associated with the campaign (null if not attached to a client)")
-    
-    @validator('scheduler_cron_value', pre=True)
-    def parse_scheduler_cron_value(cls, v):
-        """Parse scheduler_cron_value from JSON string to dict if needed"""
-        if isinstance(v, str) and v:
-            try:
-                import json
-                return json.loads(v)
-            except json.JSONDecodeError:
-                return v
-        return v
-    
-    @validator('follow_up_percentage', pre=True)
-    def parse_follow_up_percentage(cls, v):
-        """Ensure follow_up_percentage is returned as string with % sign"""
-        if isinstance(v, int):
-            return f"{v}%"
-        return v
+    id: int
+    user_id: int
+    created_at: datetime
+    updated_at: datetime
+    status: str
+    name: str
+    track_settings: Union[str, List[Any]] # FIX: Accept string or list
+    scheduler_cron_value: Optional[Union[str, Dict[str, Any]]] = None # FIX: Accept string or dict
+    min_time_btwn_emails: int
+    max_leads_per_day: int
+    stop_lead_settings: str
+    unsubscribe_text: Optional[str] = None
+    client_id: Optional[int] = None
+    enable_ai_esp_matching: bool
+    send_as_plain_text: bool
+    follow_up_percentage: Optional[Union[str, int]] = None # FIX: Accept string or int
+
+class CampaignListResponse(BaseModel):
+    campaigns: List[Campaign]
+    total: int
+    source: str
 
 class Lead(BaseModel):
     id: int
     email: EmailStr
-    first_name: Optional[str]
-    last_name: Optional[str]
-    company: Optional[str]
-    position: Optional[str]
-    phone_number: Optional[str]
-    linkedin_url: Optional[str]
-    status: Optional[str]
-
-# Additional models for new endpoints
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+    company: Optional[str] = None
+    position: Optional[str] = None
+    phone_number: Optional[str] = None
+    linkedin_url: Optional[str] = None
+    status: Optional[str] = None
+
+class WarmupDetails(BaseModel):
+    status: str
+    total_sent_count: int
+    total_spam_count: int
+    warmup_reputation: str
+    warmup_key_id: Optional[str] = None
+    warmup_created_at: Optional[datetime] = None
+    reply_rate: int
+    blocked_reason: Optional[str] = None
+
+class EmailAccount(BaseModel):
+    id: int
+    created_at: datetime
+    updated_at: datetime
+    user_id: int
+    from_name: str
+    from_email: str
+    username: str
+    password: Optional[str] = None
+    smtp_host: Optional[str] = None
+    smtp_port: Optional[int] = None
+    smtp_port_type: Optional[str] = None
+    message_per_day: int
+    different_reply_to_address: Optional[str] = None
+    is_different_imap_account: bool
+    imap_username: Optional[str] = None
+    imap_password: Optional[str] = None
+    imap_host: Optional[str] = None
+    imap_port: Optional[int] = None
+    imap_port_type: Optional[str] = None
+    signature: Optional[str] = None
+    custom_tracking_domain: Optional[str] = None
+    bcc_email: Optional[str] = None
+    is_smtp_success: bool
+    is_imap_success: bool
+    smtp_failure_error: Optional[str] = None
+    imap_failure_error: Optional[str] = None
+    type: str
+    daily_sent_count: int
+    client_id: Optional[int] = None
+    campaign_count: Optional[int] = None
+    warmup_details: Optional[WarmupDetails] = None
+
 class LeadCategoryUpdateRequest(BaseModel):
     category_id: int = Field(..., description="Category ID to assign to the lead")
     pause_lead: bool = Field(False, description="Whether to pause the lead after category update")
@@ -237,61 +278,19 @@ async def call_smartlead_api(method: str, endpoint: str, data: Any = None, param
                 resp = await client.request(method, url, params=params, json=data)
         
         if resp.status_code >= 400:
-            # Try to parse error response as JSON for better error handling
             try:
                 error_data = resp.json()
                 error_message = error_data.get('message', error_data.get('error', 'Unknown error'))
-                error_detail = error_data.get('detail', error_data.get('description', ''))
-                
-                raise HTTPException(
-                    status_code=resp.status_code,
-                    detail={
-                        "error": True,
-                        "message": error_message,
-                        "detail": error_detail,
-                        "endpoint": endpoint,
-                        "method": method,
-                        "status_code": resp.status_code
-                    }
-                )
+                raise HTTPException(status_code=resp.status_code, detail=error_message)
             except (ValueError, KeyError):
-                # Fallback to raw text if JSON parsing fails
-                raise HTTPException(
-                    status_code=resp.status_code,
-                    detail={
-                        "error": True,
-                        "message": "API request failed",
-                        "detail": resp.text,
-                        "endpoint": endpoint,
-                        "method": method,
-                        "status_code": resp.status_code
-                    }
-                )
+                raise HTTPException(status_code=resp.status_code, detail=resp.text)
         
         return resp.json()
         
     except httpx.TimeoutException:
-        raise HTTPException(
-            status_code=408,
-            detail={
-                "error": True,
-                "message": "Request timeout",
-                "detail": "The request to Smartlead API timed out",
-                "endpoint": endpoint,
-                "method": method
-            }
-        )
+        raise HTTPException(status_code=408, detail="Request to Smartlead API timed out")
     except httpx.RequestError as e:
-        raise HTTPException(
-            status_code=503,
-            detail={
-                "error": True,
-                "message": "Service unavailable",
-                "detail": f"Failed to connect to Smartlead API: {str(e)}",
-                "endpoint": endpoint,
-                "method": method
-            }
-        )
+        raise HTTPException(status_code=503, detail=f"Failed to connect to Smartlead API: {str(e)}")
 
 # ============================================================================
 # CAMPAIGN ENDPOINTS
@@ -302,7 +301,7 @@ async def create_campaign(campaign: CreateCampaignRequest):
     """Create a new campaign in Smartlead"""
     return await call_smartlead_api("POST", "campaigns/create", data=campaign.dict())
 
-@app.get("/campaigns", response_model=Dict[str, Any], tags=["Campaigns"])
+@app.get("/campaigns", response_model=CampaignListResponse, tags=["Campaigns"])
 async def list_campaigns():
     """Fetch all campaigns from Smartlead API"""
     campaigns = await call_smartlead_api("GET", "campaigns")
@@ -376,13 +375,39 @@ async def get_campaign_leads(campaign_id: int, offset: int = 0, limit: int = 100
 
 @app.post("/campaigns/{campaign_id}/leads", response_model=Dict[str, Any], tags=["Leads"])
 async def add_leads_to_campaign(campaign_id: int, request: AddLeadsRequest):
-    """Add leads to a campaign by ID"""
+    """Add leads to a campaign by ID with personalized welcome and closing messages"""
     request_data = request.dict()
     
-    # Clean up the data - remove None values and empty strings
+    # Process each lead to generate personalized messages and clean up data
     for lead in request_data.get("lead_list", []):
         lead_cleaned = {k: v for k, v in lead.items() if v is not None and v != ""}
         
+        # Generate personalized welcome and closing messages using LLM
+        try:
+            personalized_messages = await generate_welcome_closing_messages(lead_cleaned)
+            
+            # Initialize custom_fields if it doesn't exist
+            if "custom_fields" not in lead_cleaned:
+                lead_cleaned["custom_fields"] = {}
+            
+            # Add the generated messages to custom_fields
+            if personalized_messages.get("welcome_message"):
+                lead_cleaned["custom_fields"]["Welcome_Message"] = personalized_messages["welcome_message"]
+            if personalized_messages.get("closing_message"):
+                lead_cleaned["custom_fields"]["Closing_Message"] = personalized_messages["closing_message"]
+                
+        except Exception as e:
+            print(f"Error generating personalized messages for lead {lead_cleaned.get('email', 'unknown')}: {str(e)}")
+            # Continue with template messages if LLM fails
+            template_messages = generate_template_welcome_closing_messages(lead_cleaned)
+            if "custom_fields" not in lead_cleaned:
+                lead_cleaned["custom_fields"] = {}
+            if template_messages.get("welcome_message"):
+                lead_cleaned["custom_fields"]["Welcome_Message"] = template_messages["welcome_message"]
+            if template_messages.get("closing_message"):
+                lead_cleaned["custom_fields"]["Closing_Message"] = template_messages["closing_message"]
+        
+        # Clean up custom_fields - remove None values and empty strings
         if "custom_fields" in lead_cleaned:
             custom_fields = lead_cleaned["custom_fields"]
             if custom_fields:
@@ -400,22 +425,18 @@ async def add_leads_to_campaign(campaign_id: int, request: AddLeadsRequest):
     request_data["lead_list"] = [lead for lead in request_data["lead_list"] if lead]
     
     if not request_data["lead_list"]:
-        raise HTTPException(status_code=400, detail="No valid leads to add. Please provide at least one lead with an email address.")
+        raise HTTPException(status_code=400, detail="No valid leads to add.")
     
     if "settings" not in request_data or request_data["settings"] is None:
-        request_data["settings"] = {
-            "ignore_global_block_list": True,
-            "ignore_unsubscribe_list": True,
-            "ignore_duplicate_leads_in_other_campaign": False
-        }
+        request_data["settings"] = LeadSettings().dict()
     
     return await call_smartlead_api("POST", f"campaigns/{campaign_id}/leads", data=request_data)
 
 @app.post("/campaigns/{campaign_id}/leads/bulk", response_model=Dict[str, Any], tags=["Leads"])
 async def add_bulk_leads(campaign_id: int, leads: List[LeadInput]):
-    """Add multiple leads to a Smartlead campaign (legacy endpoint)"""
+    """Add multiple leads to a Smartlead campaign with personalized messages (legacy endpoint)"""
     request = AddLeadsRequest(lead_list=leads)
-    return await call_smartlead_api("POST", f"campaigns/{campaign_id}/leads", data=request.dict())
+    return await add_leads_to_campaign(campaign_id, request)
 
 @app.post("/campaigns/{campaign_id}/leads/{lead_id}/resume", response_model=Dict[str, Any], tags=["Leads"])
 async def resume_lead_by_campaign_id(campaign_id: int, lead_id: int, request: ResumeLeadRequest):
@@ -476,51 +497,24 @@ async def campaigns_for_lead(lead_id: int):
 async def check_lead_in_campaign(campaign_id: int, email: str):
     """Check if a lead exists in a campaign using efficient indexed lookups"""
     try:
-        # Step 1: Get the global lead_id for the email address
         lead_response = await call_smartlead_api("GET", "leads", params={"email": email})
         
         if not lead_response or "id" not in lead_response:
-            return {
-                "exists": False,
-                "message": "Lead not found",
-                "email": email,
-                "campaign_id": campaign_id
-            }
+            return {"exists": False, "message": "Lead not found"}
         
         lead_id = lead_response["id"]
-        
-        # Step 2: Get all campaigns for this lead
         campaigns_response = await call_smartlead_api("GET", f"leads/{lead_id}/campaigns")
         
         if not campaigns_response:
-            return {
-                "exists": False,
-                "message": "No campaigns found for lead",
-                "email": email,
-                "campaign_id": campaign_id,
-                "lead_id": lead_id
-            }
+            return {"exists": False, "message": "No campaigns found for lead"}
         
-        # Step 3: Check if the target campaign_id exists in the lead's campaigns
         campaign_exists = any(campaign.get("id") == campaign_id for campaign in campaigns_response)
         
-        return {
-            "exists": campaign_exists,
-            "message": "Lead found in campaign" if campaign_exists else "Lead not found in campaign",
-            "email": email,
-            "campaign_id": campaign_id,
-            "lead_id": lead_id,
-            "total_campaigns_for_lead": len(campaigns_response)
-        }
+        return {"exists": campaign_exists, "message": "Lead found in campaign" if campaign_exists else "Lead not found in campaign"}
         
     except HTTPException as e:
         if e.status_code == 404:
-            return {
-                "exists": False,
-                "message": "Lead not found",
-                "email": email,
-                "campaign_id": campaign_id
-            }
+            return {"exists": False, "message": "Lead not found"}
         raise e
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error checking lead in campaign: {str(e)}")
@@ -539,68 +533,23 @@ async def export_data_from_campaign(campaign_id: int):
             resp = await client.get(url, params=params)
         
         if resp.status_code >= 400:
-            # Try to parse error response as JSON for better error handling
             try:
                 error_data = resp.json()
                 error_message = error_data.get('message', error_data.get('error', 'Unknown error'))
-                error_detail = error_data.get('detail', error_data.get('description', ''))
-                
-                raise HTTPException(
-                    status_code=resp.status_code,
-                    detail={
-                        "error": True,
-                        "message": error_message,
-                        "detail": error_detail,
-                        "endpoint": f"campaigns/{campaign_id}/leads-export",
-                        "method": "GET",
-                        "status_code": resp.status_code
-                    }
-                )
+                raise HTTPException(status_code=resp.status_code, detail=error_message)
             except (ValueError, KeyError):
-                # Fallback to raw text if JSON parsing fails
-                raise HTTPException(
-                    status_code=resp.status_code,
-                    detail={
-                        "error": True,
-                        "message": "API request failed",
-                        "detail": resp.text,
-                        "endpoint": f"campaigns/{campaign_id}/leads-export",
-                        "method": "GET",
-                        "status_code": resp.status_code
-                    }
-                )
+                raise HTTPException(status_code=resp.status_code, detail=resp.text)
         
-        # Return CSV data with proper headers
         return Response(
             content=resp.text,
             media_type="text/csv",
-            headers={
-                "Content-Disposition": f"attachment; filename=campaign_{campaign_id}_leads.csv"
-            }
+            headers={"Content-Disposition": f"attachment; filename=campaign_{campaign_id}_leads.csv"}
         )
         
     except httpx.TimeoutException:
-        raise HTTPException(
-            status_code=408,
-            detail={
-                "error": True,
-                "message": "Request timeout",
-                "detail": "The request to Smartlead API timed out",
-                "endpoint": f"campaigns/{campaign_id}/leads-export",
-                "method": "GET"
-            }
-        )
+        raise HTTPException(status_code=408, detail="Request to Smartlead API timed out")
     except httpx.RequestError as e:
-        raise HTTPException(
-            status_code=503,
-            detail={
-                "error": True,
-                "message": "Service unavailable",
-                "detail": f"Failed to connect to Smartlead API: {str(e)}",
-                "endpoint": f"campaigns/{campaign_id}/leads-export",
-                "method": "GET"
-            }
-        )
+        raise HTTPException(status_code=503, detail=f"Failed to connect to Smartlead API: {str(e)}")
 
 # ============================================================================
 # SEQUENCE ENDPOINTS
@@ -682,7 +631,7 @@ async def reply_to_lead_from_master_inbox(campaign_id: int, request: MessageHist
 # EMAIL ACCOUNT ENDPOINTS
 # ============================================================================
 
-@app.get("/email-accounts", response_model=Dict[str, Any], tags=["Email Accounts"])
+@app.get("/email-accounts", response_model=List[EmailAccount], tags=["Email Accounts"])
 async def list_email_accounts(offset: int = 0, limit: int = 100):
     """List all email accounts with optional pagination"""
     params = {"offset": offset, "limit": limit}
@@ -693,7 +642,7 @@ async def save_email_account(account: Dict[str, Any]):
     """Create an Email Account"""
     return await call_smartlead_api("POST", "email-accounts/save", data=account)
 
-@app.get("/email-accounts/{account_id}", response_model=Any, tags=["Email Accounts"])
+@app.get("/email-accounts/{account_id}", response_model=EmailAccount, tags=["Email Accounts"])
 async def get_email_account(account_id: int):
     """Fetch Email Account By ID"""
     return await call_smartlead_api("GET", f"email-accounts/{account_id}")
@@ -713,7 +662,7 @@ async def get_warmup_stats(account_id: int):
     """Fetch Warmup Stats By Email Account ID"""
     return await call_smartlead_api("GET", f"email-accounts/{account_id}/warmup-stats")
 
-@app.get("/campaigns/{campaign_id}/email-accounts", response_model=Any, tags=["Email Accounts"])
+@app.get("/campaigns/{campaign_id}/email-accounts", response_model=List[EmailAccount], tags=["Email Accounts"])
 async def list_campaign_email_accounts(campaign_id: int):
     """List all email accounts per campaign"""
     return await call_smartlead_api("GET", f"campaigns/{campaign_id}/email-accounts")
@@ -781,6 +730,121 @@ async def api_info():
 # AI SEQUENCE GENERATION FUNCTIONS
 # ============================================================================
 
+async def generate_welcome_closing_messages(lead_data: Dict[str, Any]) -> Dict[str, str]:
+    """Generate personalized welcome and closing messages using LLM based on candidate details"""
+    
+    if not LANGCHAIN_AVAILABLE:
+        return generate_template_welcome_closing_messages(lead_data)
+    
+    try:
+        openai_api_key = os.getenv("OPENAI_API_KEY")
+        if not openai_api_key:
+            print("Warning: OPENAI_API_KEY not set. Using template messages.")
+            return generate_template_welcome_closing_messages(lead_data)
+        
+        llm = ChatOpenAI(
+            model="gpt-4",
+            temperature=0.7,
+            openai_api_key=openai_api_key
+        )
+        
+        # Extract relevant information from lead data
+        first_name = lead_data.get("first_name", "")
+        last_name = lead_data.get("last_name", "")
+        company_name = lead_data.get("company_name", "")
+        location = lead_data.get("location", "")
+        title = lead_data.get("custom_fields", {}).get("Title", "")
+        linkedin_profile = lead_data.get("linkedin_profile", "")
+        
+        # Create a summary of the candidate's background
+        candidate_info = f"""
+        Name: {first_name} {last_name}
+        Company: {company_name}
+        Location: {location}
+        Title: {title}
+        LinkedIn: {linkedin_profile}
+        """
+        
+        system_prompt = """You are an expert recruiter who creates personalized welcome and closing messages for email campaigns.
+        
+        Based on the candidate's information, generate:
+        1. A personalized welcome message (2-3 sentences)
+        2. A personalized closing message (1-2 sentences)
+        
+        Requirements:
+        - Professional but friendly tone
+        - Reference their specific background/company/role when possible
+        - Keep messages concise and engaging
+        - Make them feel valued and understood
+        
+        Respond with ONLY a JSON object:
+        {
+            "welcome_message": "Personalized welcome message here",
+            "closing_message": "Personalized closing message here"
+        }
+        
+        IMPORTANT: Respond with ONLY valid JSON. No additional text."""
+        
+        prompt_template = ChatPromptTemplate.from_messages([
+            ("system", system_prompt),
+            ("human", "Generate personalized messages for this candidate: {candidate_info}")
+        ])
+        
+        messages = prompt_template.format_messages(candidate_info=candidate_info)
+        response = await llm.ainvoke(messages)
+        
+        try:
+            content = response.content.strip()
+            
+            if content.startswith("```json"):
+                content = content[7:]
+            if content.endswith("```"):
+                content = content[:-3]
+            
+            content = content.strip()
+            parsed_data = json.loads(content)
+            
+            return {
+                "welcome_message": parsed_data.get("welcome_message", ""),
+                "closing_message": parsed_data.get("closing_message", "")
+            }
+            
+        except Exception as parse_error:
+            print(f"JSON parsing failed for welcome/closing messages: {parse_error}")
+            return generate_template_welcome_closing_messages(lead_data)
+        
+    except Exception as e:
+        print(f"Error generating welcome/closing messages with LLM: {str(e)}")
+        return generate_template_welcome_closing_messages(lead_data)
+
+def generate_template_welcome_closing_messages(lead_data: Dict[str, Any]) -> Dict[str, str]:
+    """Generate template-based welcome and closing messages as fallback"""
+    
+    first_name = lead_data.get("first_name", "")
+    company_name = lead_data.get("company_name", "")
+    title = lead_data.get("custom_fields", {}).get("Title", "")
+    
+    # Personalized welcome message
+    if first_name and company_name:
+        welcome_message = f"Hi {first_name}, I came across your profile and was impressed by your work at {company_name}."
+    elif first_name:
+        welcome_message = f"Hi {first_name}, I came across your profile and was impressed by your background."
+    elif company_name:
+        welcome_message = f"Hi there, I came across your profile and was impressed by your work at {company_name}."
+    else:
+        welcome_message = "Hi there, I came across your profile and was impressed by your background."
+    
+    # Personalized closing message
+    if first_name:
+        closing_message = f"Looking forward to connecting with you, {first_name}!"
+    else:
+        closing_message = "Looking forward to connecting with you!"
+    
+    return {
+        "welcome_message": welcome_message,
+        "closing_message": closing_message
+    }
+
 async def generate_sequences_with_llm(job_description: str) -> List[CampaignSequence]:
     """Generate email sequences using LangChain and OpenAI based on job description"""
     
@@ -1134,13 +1198,47 @@ def custom_openapi():
         
         ## Features
         - **Campaign Management**: Create, update, and manage email campaigns
-        - **Lead Management**: Add, update, and manage leads across campaigns
+        - **Lead Management**: Add, update, and manage leads across campaigns with AI-powered personalization
         - **Sequence Management**: Create and manage email sequences with AI generation
         - **Webhook Management**: Set up webhooks for real-time notifications
         - **Analytics**: Get detailed campaign analytics and statistics
         - **Email Account Management**: Manage email accounts and warmup
         - **Client Management**: Handle client accounts and permissions
         
+        ## AI-Powered Personalization
+        When adding leads to campaigns, the API automatically generates personalized welcome and closing messages using LLM (Language Model) based on candidate details. These messages are added to the custom_fields as:
+        - `Welcome_Message`: Personalized greeting based on candidate's background
+        - `Closing_Message`: Personalized closing statement
+        
+        ## Lead Schema
+        The lead schema supports the following structure:
+        ```json
+        {
+          "lead_list": [
+            {
+              "first_name": "Cristiano",
+              "last_name": "Ronaldo", 
+              "email": "[email protected]",
+              "phone_number": "0239392029",
+              "company_name": "Manchester United",
+              "website": "mufc.com",
+              "location": "London",
+              "custom_fields": {
+                "Title": "Regional Manager",
+                "First_Line": "Loved your recent post about remote work on Linkedin"
+              },
+              "linkedin_profile": "http://www.linkedin.com/in/cristianoronaldo",
+              "company_url": "mufc.com"
+            }
+          ],
+          "settings": {
+            "ignore_global_block_list": true,
+            "ignore_unsubscribe_list": true,
+            "ignore_duplicate_leads_in_other_campaign": false
+          }
+        }
+        ```
+        
         ## Authentication
         All requests require a Smartlead API key passed as a query parameter: `?api_key=YOUR_API_KEY`