# === АРХИТЕКТУРА AI SDR-АГЕНТА (СТЕК 2026) ===

import asyncio
from typing import List, Dict, Optional
from dataclasses import dataclass
from enum import Enum

# --- Модель данных лида ---
@dataclass
class Lead:
    email: str
    first_name: str
    last_name: str
    company: str
    title: str
    linkedin_url: str
    enrichment: Dict = None    # данные из Clay
    score: float = 0.0           # AI-скоринг 0..100
    personalization: str = ""  # сгенерированный icebreaker
    sequence_step: int = 0      # шаг в каденции

class LeadStatus(Enum):
    NEW = "new"
    ENRICHED = "enriched"
    SCORED = "scored"
    CONTACTED = "contacted"
    REPLIED = "replied"
    MEETING_BOOKED = "meeting_booked"
    UNSUBSCRIBED = "unsubscribed"

# --- Ядро агента ---
class AISDRAgent:
    """Автономный агент, управляющий полным циклом SDR."""

    def __init__(self, config: Dict):
        self.config = config
        self.leads: List[Lead] = []
        self.daily_limit = config.get("daily_email_limit", 50)
        self.sent_today = 0

    async def run_pipeline(self):
        """Главный цикл: выполняется n8n по расписанию (каждые N минут)."""
        await self.fetch_leads_from_apollo()        # этап 1
        await self.enrich_with_clay()             # этап 2
        await self.score_leads_with_llm()         # этап 3
        await self.generate_personalization()      # этап 4
        await self.send_via_instantly()            # этап 5
        await self.process_replies()               # этап 6

// n8n Workflow: AI SDR Pipeline (JSON-экспорт)
// Триггер: Webhook → выполняется каждый час по cron
{
  "name": "AI SDR Agent Pipeline v2",
  "nodes": [
    {
      "name": "Webhook Trigger",
      "type": "n8n-nodes-base.webhookTrigger",
      "parameters": { "path": "ai-sdr-pipeline" }
    },
    {
      "name": "Fetch from Apollo",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://api.apollo.io/api/v1/people/search",
        "method": "POST",
        "headers": { "Content-Type": "application/json" },
        "body": "{\"q_keywords\":\"CTO|VP Engineering\",\"page\":1,\"per_page\":50}"
      }
    },
    {
      "name": "Python: Enrich & Score",
      "type": "n8n-nodes-base.code",
      "parameters": {
        "language": "python",
        "code": "см. Python-код ниже"
      }
    },
    {
      "name": "Instantly: Send Emails",
      "type": "n8n-nodes-base.httpRequest",
      "parameters": {
        "url": "https://api.instantly.ai/api/v1/emails/send",
        "method": "POST"
      }
    }
  ],
  "settings": { "saveManualExecutions": true }
}

# === КОД PYTHON-НОДЫ В N8N ===
# $input.all() — массив лидов из Apollo (предыдущая нода)
# Доступны: $env.CLAY_API_KEY, $env.OPENAI_KEY, $env.AIRTABLE_KEY

import json, httpx, os
from openai import AsyncOpenAI

async def main(input_data):
    """Основная функция: обогащение → скоринг → отбор → персонализация."""
    client = AsyncOpenAI(api_key=os.environ["OPENAI_KEY"])
    leads = []
    
    for item in input_data[:30]:  # батч до 30 лидов за прогон
        email = item.get("email", "")
        if not email:
            continue
        
        # Этап 1: обогащение через Clay webhook
        enrichment = await enrich_lead(email, item.get("linkedin_url"))
        
        # Этап 2: AI-скоринг лида
        score = await score_lead(client, item, enrichment)
        
        # Этап 3: фильтрация (только score > 60)
        if score < 60:
            continue
        
        # Этап 4: генерация персонализации
        icebreaker = await personalize(client, item, enrichment)
        
        leads.append({"email": email, "score": score, 
                       "icebreaker": icebreaker, "enrichment": enrichment})
    
    return leads  # передаётся в следующую ноду (Instantly)

# === ОБОГАЩЕНИЕ ЛИДА ЧЕРЕЗ CLAY WATERFALL ===
import httpx
import asyncio
from typing import Optional

CLAY_API_URL = "https://api.clay.com/v3/enrich"

async def enrich_lead(
    email: str, 
    linkedin_url: Optional[str] = None
) -> dict:
    """Waterfall-обогащение: Clay → Clearbit → Apollo → PDL."""
    
    async with httpx.AsyncClient(timeout=30) as client:
        payload = {
            "email": email,
            "waterfall": True,  # ключевой параметр: пробует все источники
            "sources": [
                "clearbit", "apollo", "pdl", "hunter",
                "linkedin_scraper", "builtwith"
            ],
            "fields": [
                "company_size", "industry", "technographics",
                "funding_round", "recent_news", "job_openings",
                "personal_phone", "company_revenue"
            ]
        }
        
        if linkedin_url:
            payload["linkedin_url"] = linkedin_url
        
        resp = await client.post(
            CLAY_API_URL,
            json=payload,
            headers={"Authorization": f"Bearer {CLAY_API_KEY}"}
        )
        return resp.json() if resp.status_code == 200 else {}


# === AI-СКОРИНГ ЛИДА НА ОСНОВЕ ОБОГАЩЁННЫХ ДАННЫХ ===
async def score_lead(client, lead: dict, enrichment: dict) -> float:
    """LLM оценивает лида по соответствию ICP (0-100)."""
    
    prompt = f"""Оцени лида по шкале 0–100 на соответствие ICP:
ICP: B2B SaaS, 50–500 сотрудников, US/Europe, English-first.
Данные лида: {json.dumps(lead, ensure_ascii=False)}
Обогащение: {json.dumps(enrichment, ensure_ascii=False)}
Ответь ТОЛЬКО числом от 0 до 100 и кратким обоснованием (1 строка).
Формат: SCORE|REASON"""
    
    response = await client.chat.completions.create(
        model="gpt-4o-mini",  # дёшево и быстро для скоринга
        messages=[{"role": "user", "content": prompt}],
        temperature=0.1,
        max_tokens=50
    )
    raw = response.choices[0].message.content.strip()
    
    try:
        score_str = raw.split("|")[0].strip()
        return float(score_str)
    except ValueError:
        return 50.0  # fallback — средний скоринг

# === ПРОМПТ ДЛЯ ПЕРСОНАЛИЗАЦИИ ПИСЬМА ===

SYSTEM_PROMPT = """
Ты — Senior SDR в B2B SaaS-компании {company_name}. Твоя задача — написать
первое холодное письмо потенциальному клиенту. Письмо должно быть:
- Не длиннее 90 слов (чем короче, тем выше open rate)
- С ОДНИМ конкретным релевантным инсайтом о получателе (не шаблон!)
- Без фраз "I came across your profile", "I noticed you", "Hope this finds you well"
- С чётким CTA: 15-минутный звонок на конкретную тему
- Тональность: профессиональная, но дружелюбная, без продавливания

Наше ценностное предложение (value prop): {value_proposition}

Пример хорошего письма:
---
Subject: {subject_line_example}  ← НЕ используй этот subject, придумай новый
Hi {first_name},
[1 персонализированная строка — инсайт о компании или роли]
[1 строка — проблема, которую мы решаем, привязанная к инсайту]
[1 строка — как мы это делаем, с конкретикой]
[CTA: 15-min call?]
---

ЗАПРЕЩЕНО: эмодзи в subject, вопросы "как дела", комплименты без конкретики,
ссылки на календарь без контекста, фразы "I'd love to connect".
"""


# === ФУНКЦИЯ ГЕНЕРАЦИИ ПЕРСОНАЛИЗАЦИИ ===
async def personalize(
    client, 
    lead: dict, 
    enrichment: dict,
    company_name: str = "Acme AI",
    value_prop: str = "сокращаем цикл продаж на 40% через AI-автоматизацию SDR"
) -> dict:
    """Генерирует subject + тело письма с глубокой персонализацией."""
    
    # Собираем контекст для LLM
    context = {
        "first_name": lead.get("first_name", "there"),
        "company": lead.get("company", ""),
        "title": lead.get("title", ""),
        "company_size": enrichment.get("company_size", ""),
        "industry": enrichment.get("industry", ""),
        "technographics": enrichment.get("technographics", []),
        "recent_news": enrichment.get("recent_news", []),
        "job_openings": enrichment.get("job_openings", []),
        "funding_round": enrichment.get("funding_round", None)
    }
    
    prompt = f"""Напиши персонализированное холодное письмо для:
{json.dumps(context, indent=2, ensure_ascii=False)}
Выдай JSON: {{"subject": "...", "body": "..."}}"""
    
    system = SYSTEM_PROMPT.format(
        company_name=company_name,
        value_proposition=value_prop,
        subject_line_example="quick thought on {context['company']}"
    )
    
    response = await client.chat.completions.create(
        model="gpt-4o",  # gpt-4o-mini для больших объёмов
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": prompt}
        ],
        temperature=0.7,
        max_tokens=350,
        response_format={"type": "json_object"}
    )
    
    return json.loads(response.choices[0].message.content)


# === ГЕНЕРАЦИЯ ВАРИАЦИЙ ДЛЯ A/B-ТЕСТИРОВАНИЯ ===
async def generate_ab_variants(client, lead, enrichment, n=3):
    """Создаёт N вариантов subject line для A/B-теста."""
    variants = []
    for i in range(n):
        variant = await personalize(client, lead, enrichment)
        variant["variant_id"] = f"v{i+1}"
        variants.append(variant)
    return variants

# === МЕТРИКИ AI SDR-АГЕНТА И БЕНЧМАРКИ 2026 ===

SDR_METRICS_BENCHMARKS = {
    # Воронка: от загрузки лида до встречи
    "enrichment_completion_rate": {"good": 0.85, "great": 0.95},
    # % лидов с успешным обогащением
    
    "scoring_pass_rate":          {"good": 0.30, "great": 0.50},
    # % лидов со score > 60 (проходят в рассылку)
    
    "email_open_rate":            {"good": 0.45, "great": 0.65},
    # open rate персонализированных AI-писем
    
    "reply_rate":                 {"good": 0.08, "great": 0.15},
    # % ответивших от отправленных
    
    "positive_reply_rate":         {"good": 0.04, "great": 0.08},
    # % заинтересованных ответов («interested»)
    
    "meeting_booked_rate":         {"good": 0.02, "great": 0.05},
    # % встреч от отправленных писем
    
    # Экономика
    "cost_per_lead_enriched":    {"good": 0.12, "great": 0.05},
    # $ за 1 обогащённый лид (Clay API)
    
    "cost_per_meeting":           {"good": 35.0, "great": 12.0},
    # полная стоимость одной забронированной встречи ($)
    
    "roi_multiplier":             {"good": 3.0,  "great": 8.0},
    # ROI: выручка от встреч / затраты на AI SDR
}


# === ФУНКЦИЯ РАСЧЁТА МЕТРИК ПО РЕЗУЛЬТАТАМ ЦИКЛА ===
def calculate_pipeline_metrics(results: list) -> dict:
    total = len(results)
    if total == 0:
        return {}
    
    enriched = sum(1 for r in results if r.get("enriched"))
    scored_high = sum(1 for r in results if r.get("score", 0) > 60)
    opened = sum(1 for r in results if r.get("opened"))
    replied = sum(1 for r in results if r.get("replied"))
    meetings = sum(1 for r in results if r.get("meeting_booked"))
    
    return {
        "total_leads": total,
        "enrich_rate": round(enriched / total, 2),
        "score_pass_rate": round(scored_high / total, 2),
        "open_rate": round(opened / max(scored_high, 1), 2),
        "reply_rate": round(replied / max(scored_high, 1), 3),
        "meeting_rate": round(meetings / max(scored_high, 1), 3),
        "meetings_booked": meetings
    }


# === ОПТИМИЗАЦИЯ: КАК ПОВЫСИТЬ МЕТРИКИ ===
OPTIMIZATION_GUIDE = {
    "open_rate < 40%": "→ улучшить subject lines (A/B-тест, убрать spam-слова)",
    "reply_rate < 5%": "→ глубже персонализировать icebreaker, сократить длину",
    "meeting_rate < 1.5%": "→ пересмотреть ICP, ужесточить скоринг (score > 75)",
    "bounce_rate > 3%": "→ улучшить валидацию email, добавить ZeroBounce",
    "spam_rate > 0.3%": "→ снизить объём до 30/день/ящик, прогреть домен дольше"
}

# === КЛАССИФИКАЦИЯ ОТВЕТОВ И АВТООТВЕТЧИК ===

from enum import Enum

class ReplyCategory(Enum):
    INTERESTED = "interested"        # хочет встречу → бронируем
    NOT_INTERESTED = "not_interested"  # отказ → стоп-лист
    WRONG_PERSON = "wrong_person"      # не тот человек → ищем правильного
    OUT_OF_OFFICE = "out_of_office"    # автоответ → follow-up через 7 дней
    MORE_INFO = "more_info"          # просит информацию → AI-ответ
    OBJECTION = "objection"          # возражение → AI-ответ с контраргументом


async def classify_reply(client, reply_text: str) -> ReplyCategory:
    """Классифицирует ответ с помощью LLM."""
    
    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{
            "role": "system",
            "content": """Классифицируй ответ на холодное B2B-письмо.
Категории: interested, not_interested, wrong_person, out_of_office, 
more_info, objection. Ответь ТОЛЬКО категорией (одно слово)."""
        }, {
            "role": "user",
            "content": reply_text
        }],
        temperature=0.0,
        max_tokens=20
    )
    
    category_str = response.choices[0].message.content.strip().lower()
    try:
        return ReplyCategory(category_str)
    except ValueError:
        return ReplyCategory.MORE_INFO


async def handle_reply(client, lead: dict, reply_text: str) -> dict:
    """Основной обработчик ответа: классификация → действие."""
    
    category = await classify_reply(client, reply_text)
    
    if category == ReplyCategory.INTERESTED:
        # Бронируем встречу через календарь
        meeting = await book_meeting(lead)
        await send_reply(lead, "meeting_confirmation", meeting)
        return {"action": "meeting_booked", "meeting": meeting}
    
    elif category == ReplyCategory.OBJECTION:
        # AI генерирует ответ на возражение
        response = await generate_objection_response(client, lead, reply_text)
        await send_reply(lead, "objection_handling", response)
        return {"action": "objection_handled"}
    
    elif category == ReplyCategory.MORE_INFO:
        # Отправляем релевантный кейс / one-pager
        response = await generate_info_response(client, lead, reply_text)
        await send_reply(lead, "more_info", response)
        return {"action": "info_sent"}
    
    elif category == ReplyCategory.NOT_INTERESTED:
        await add_to_stop_list(lead)
        return {"action": "stopped"}
    
    elif category == ReplyCategory.OUT_OF_OFFICE:
        await schedule_follow_up(lead, days=7)
        return {"action": "follow_up_scheduled"}
    
    return {"action": "ignored"}

✅ Итог: что нужно для запуска AI SDR-агента

Запуск автономного AI SDR-агента в 2026 году — это не магия, а грамотная интеграция 5–6 инструментов в единый конвейер. При правильной настройке один такой агент заменяет 2–3 SDR-менеджеров, работая 24/7 без выходных, отпусков и падения мотивации.

Минимальный стек для старта:

Общий бюджет: $300–500/мес на весь стек (без учёта зарплаты менеджера). При консервативной конверсии это окупается после 2–3 закрытых сделок. Главное — не пытаться автоматизировать всё сразу: начните с одного сегмента ICP, отладьте метрики на 100–200 лидах и только потом масштабируйте. AI SDR-агент — это не set-and-forget инструмент, а система, требующая регулярной оптимизации промптов, сегментов и последовательностей. Но отдача стоит усилий: в 2026 году компании без AI-автоматизации SDR проигрывают конкурентам по скорости реакции и стоимости лида.