python -m venv venv
source venv/bin/activate
pip install openai httpx pydantic pandas
export OPENAI_API_KEY="sk-your-key"

import json
import logging
from typing import Any, Dict, List, Optional

from openai import AsyncOpenAI

logger = logging.getLogger(__name__)


class LeadScorer:
    """Score B2B leads using LLM analysis of fit, intent, and timing."""

    def __init__(self, model: str = "gpt-4o"):
        self.client = AsyncOpenAI()
        self.model = model

    async def score(self, lead: Dict[str, Any]) -> Dict[str, Any]:
        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": """Score this B2B sales lead.
                    Consider: company size, industry fit, role seniority, engagement signals, intent.
                    Return JSON:
                    {
                        "score": 1-100,
                        "fit_score": 1-10,
                        "intent_score": 1-10,
                        "timing_score": 1-10,
                        "grade": "A|B|C|D",
                        "reasoning": "explanation",
                        "recommended_approach": "strategy suggestion"
                    }""",
                },
                {"role": "user", "content": json.dumps(lead, indent=2)},
            ],
            temperature=0.0,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return {"score": 50, "grade": "C", "reasoning": "Unable to score"}

    async def score_batch(self, leads: List[Dict]) -> List[Dict]:
        import asyncio
        tasks = [self.score(lead) for lead in leads]
        return await asyncio.gather(*tasks)

    async def prioritize(self, leads: List[Dict]) -> List[Dict]:
        scored = []
        for lead in leads:
            score = await self.score(lead)
            scored.append({"lead": lead, "score": score})
        return sorted(scored, key=lambda x: x["score"].get("score", 0), reverse=True)

class ProspectResearcher:
    """Research prospects using LLM for personalized outreach."""

    def __init__(self, model: str = "gpt-4o"):
        self.client = AsyncOpenAI()
        self.model = model

    async def research(self, prospect: Dict[str, Any]) -> Dict[str, Any]:
        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": """Research this prospect and provide insights for personalized outreach.
                    Return JSON:
                    {
                        "pain_points": ["likely challenges"],
                        "interests": ["professional interests"],
                        "recent_news": "any relevant company news",
                        "personalization_hooks": ["things to mention"],
                        "best_approach": "recommended outreach strategy"
                    }""",
                },
                {"role": "user", "content": f"Prospect: {json.dumps(prospect, indent=2)}"},
            ],
            temperature=0.2,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return {"pain_points": [], "personalization_hooks": []}


class EmailGenerator:
    """Generate personalized cold outreach emails."""

    def __init__(self, model: str = "gpt-4o"):
        self.client = AsyncOpenAI()
        self.model = model

    async def generate_cold_email(
        self,
        prospect: Dict[str, Any],
        research: Dict[str, Any],
        product: str,
        tone: str = "professional",
    ) -> Dict[str, Any]:
        response = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": f"""Write a personalized cold outreach email.
                    Tone: {tone}
                    Product: {product}

                    Rules:
                    - Subject line under 50 characters
                    - Opening that references something specific about them
                    - Value proposition tied to their pain points
                    - Clear, low-friction CTA
                    - Under 150 words
                    - No generic phrases like "I hope this finds you well\"""",
                },
                {
                    "role": "user",
                    "content": f"Prospect: {prospect.get('name', 'Unknown')} at {prospect.get('company', 'Unknown')}\nRole: {prospect.get('role', 'Unknown')}\n\nResearch insights:\n{research}",
                },
            ],
            temperature=0.7,
        )
        content = response.choices[0].message.content
        return {
            "subject": content.split("\n")[0].replace("Subject:", "").strip() if "\n" in content else "Quick question",
            "body": content,
            "personalization_hooks": research.get("personalization_hooks", []),
        }

    async def generate_followup(self, original_email: str, response: str = None, step: int = 1) -> str:
        prompt = f"Write follow-up email #{step} for this sequence."
        if response:
            prompt += f"\n\nTheir response: {response}"
        prompt += f"\n\nOriginal email: {original_email[:500]}"
        result = await self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "Write brief, value-adding follow-up emails. Under 100 words."},
                {"role": "user", "content": prompt},
            ],
            temperature=0.7,
        )
        return result.choices[0].message.content

from datetime import datetime


class SequenceManager:
    """Manage multi-step outreach sequences for leads."""

    def __init__(self):
        self.sequences: Dict[str, Dict] = {}

    def create_sequence(self, lead_id: str, steps: List[Dict]) -> str:
        sequence_id = f"seq_{lead_id}_{datetime.now().strftime('%Y%m%d')}"
        self.sequences[sequence_id] = {
            "lead_id": lead_id,
            "steps": steps,
            "current_step": 0,
            "status": "active",
            "created_at": datetime.now().isoformat(),
        }
        return sequence_id

    def get_next_action(self, sequence_id: str) -> Dict:
        seq = self.sequences.get(sequence_id)
        if not seq or seq["status"] != "active":
            return {"action": "none"}
        current = seq["current_step"]
        if current >= len(seq["steps"]):
            seq["status"] = "completed"
            return {"action": "none"}
        step = seq["steps"][current]
        seq["current_step"] = current + 1
        return step

    def pause_sequence(self, sequence_id: str) -> None:
        if sequence_id in self.sequences:
            self.sequences[sequence_id]["status"] = "paused"

    def resume_sequence(self, sequence_id: str) -> None:
        if sequence_id in self.sequences:
            self.sequences[sequence_id]["status"] = "active"


class SalesOutreachAgent:
    """Orchestrate the complete sales outreach pipeline."""

    def __init__(self, model: str = "gpt-4o"):
        self.scorer = LeadScorer(model)
        self.researcher = ProspectResearcher(model)
        self.email_gen = EmailGenerator(model)
        self.sequence_mgr = SequenceManager()

    async def process_lead(self, lead: Dict[str, Any], product: str) -> Dict[str, Any]:
        score = await self.scorer.score(lead)
        research = await self.researcher.research(lead)
        email = await self.email_gen.generate_cold_email(lead, research, product)
        return {"lead": lead, "score": score, "research": research, "email": email}

    async def create_outreach_sequence(self, lead: Dict[str, Any], product: str) -> str:
        data = await self.process_lead(lead, product)
        steps = [
            {"type": "email", "content": data["email"]["body"], "delay_days": 0},
            {"type": "email", "content": "followup_1", "delay_days": 3},
            {"type": "email", "content": "followup_2", "delay_days": 7},
            {"type": "task", "content": "LinkedIn connect", "delay_days": 5},
            {"type": "email", "content": "breakup_email", "delay_days": 14},
        ]
        return self.sequence_mgr.create_sequence(lead.get("email", "unknown"), steps)

    async def batch_outreach(self, leads: List[Dict], product: str) -> List[Dict]:
        prioritized = await self.scorer.prioritize(leads)
        return [await self.process_lead(item["lead"], product) for item in prioritized[:10]]