Агент автоответа по почте

1
import os
2
from dotenv import load_dotenv
3
4
# Load environment variables FIRST
5
load_dotenv()
6
7
from flask import Flask, request, Response
8
import ngrok
9
from agentinbox import Agentinbox
10
11
# Initialize the Agent Inbox client
12
client = Agentinbox()  # Reads AGENTINBOX_API_KEY from environment
13
app = Flask(__name__)

1
def setup_agentinbox():
2
    """Create inbox and webhook with idempotency."""
3
4
    # Create inbox (or get existing one)
5
    try:
6
        inbox = client.inboxes.create(
7
            username=INBOX_USERNAME,
8
            client_id=f"{INBOX_USERNAME}-inbox"  # ← Idempotency key
9
        )
10
        print(f"✓ Inbox created: {inbox.inbox_id}")
11
    except Exception as e:
12
        if "already exists" in str(e).lower():
13
            # Inbox already exists, that's fine!
14
            inbox_id = f"{INBOX_USERNAME}@agentinbox.space"
15
            inbox = SimpleInbox(inbox_id)

1
    # Start ngrok tunnel
2
    listener = ngrok.forward(PORT, domain=WEBHOOK_DOMAIN, authtoken_from_env=True)
3
4
    # Create webhook
5
    webhook = client.webhooks.create(
6
        url=f"{listener.url()}/webhook/inbound",
7
        event_types=["message.received"],  # ← Only subscribe to incoming emails
8
        client_id=f"{INBOX_USERNAME}-webhook"  # ← Idempotency
9
    )

1
@app.route('/webhook/inbound', methods=['POST'])
2
def receive_webhook():
3
    """Webhook endpoint to receive incoming email notifications."""
4
    payload = request.json
5
    event_type = payload.get('type') or payload.get('event_type')
6
7
    # Ignore outgoing messages (prevents infinite loops!)
8
    if event_type == 'message.sent':
9
        return Response(status=200)

1
    message = payload.get('message', {})
2
    message_id = message.get('message_id')
3
    inbox_id = message.get('inbox_id')
4
    from_field = message.get('from_', '') or message.get('from', '')
5
6
    # Validate required fields
7
    if not message_id or not inbox_id or not from_field:
8
        return Response(status=200)  # Gracefully skip incomplete data

1
# Extract sender email and name
2
if '<' in from_field and '>' in from_field:
3
    # Format: "John Doe <john@example.com>"
4
    sender_email = from_field.split('<')[1].split('>')[0].strip()
5
    sender_name = from_field.split('<')[0].strip()
6
    if not sender_name or ',' in sender_name:
7
        # Name is empty or has comma, use email username
8
        sender_name = sender_email.split('@')[0].title()
9
else:
10
    # Format: "john@example.com"
11
    sender_email = from_field.strip()
12
    sender_name = sender_email.split('@')[0].title()

1
def generate_reply(sender_name, subject):
2
    """Generate auto-reply message using a template."""
3
    return (
4
        f"Hi {sender_name},\n\n"
5
        f"Thank you for your email! I've received your message and will get back to you within 24 hours.\n\n"
6
        f"If your matter is urgent, please reply with \"URGENT\" in the subject line.\n\n"
7
        f"Best regards,\n"
8
        f"Auto-Reply Agent"
9
    )

1
try:
2
    reply_text = generate_reply(sender_name, subject)
3
    client.inboxes.messages.reply(
4
        inbox_id=inbox_id,
5
        message_id=message_id,
6
        to=[sender_email],  # ← Must be a list!
7
        text=reply_text
8
    )
9
    print(f"Auto-reply sent to {sender_email}\n")
10
except Exception as e:
11
    print(f"Error: {e}\n")
12
13
return Response(status=200)  # Always return 200 to acknowledge webhook

1
def get_thread_history(thread_id):
2
    """Fetch conversation history for the thread."""
3
    try:
4
        thread = client.threads.get(thread_id=thread_id)
5
        return thread.messages if hasattr(thread, 'messages') else []
6
    except Exception as e:
7
        print(f"Failed to fetch thread history: {e}")
8
        return []
9
10
11
def format_thread_for_ai(messages):
12
    """Format thread messages into conversation history for AI."""
13
    conversation = []
14
15
    for msg in messages:
16
        if hasattr(msg, 'from_'):
17
            sender = msg.from_
18
            text = msg.text or msg.html or ""
19
        else:
20
            sender = msg.get('from_', '') or msg.get('from', '')
21
            text = msg.get('text', '') or msg.get('html', '') or msg.get('body', '')
22
23
        if '<' in sender and '>' in sender:
24
            sender = sender.split('<')[1].split('>')[0].strip()
25
26
        if text:
27
            conversation.append(f"From: {sender}\n{text}")
28
29
    return "\n\n---\n\n".join(reversed(conversation))
30
31
32
def generate_ai_reply(sender_name, email_body, subject, thread_history=""):
33
    """Generate AI-powered reply using OpenAI with thread context."""
34
    try:
35
        context = f"Email thread history:\n\n{thread_history}\n\n---\n\nLatest message from {sender_name}:\nSubject: {subject}\n{email_body}" if thread_history else f"Subject: {subject}\nFrom: {sender_name}\n{email_body}"
36
37
        response = openai_client.chat.completions.create(
38
            model="gpt-4o-mini",
39
            messages=[
40
                {
41
                    "role": "system",
42
                    "content": "You are an intelligent email assistant. Read the email thread and respond in a helpful, contextual way. If this is a follow-up in a conversation, acknowledge what was previously discussed. If you can provide helpful information based on the context, do so. If the question requires detailed research or expertise you don't have, acknowledge receipt and set expectations. Be conversational, professional, and concise."
43
                },
44
                {
45
                    "role": "user",
46
                    "content": f"{context}\n\nGenerate a helpful reply that considers the conversation history. Keep it concise (2-4 sentences) but be actually helpful if you can address their question or continue the conversation meaningfully."
47
                }
48
            ],
49
            max_tokens=250,
50
            temperature=0.7
51
        )
52
        return response.choices[0].message.content
53
    except Exception as e:
54
        print(f"AI generation failed, using template: {e}")
55
        return generate_reply(sender_name, subject)

1
    subject = message.get('subject', '(no subject)')
2
    thread_id = message.get('thread_id', '')  # Add this line
3
4
    # Log incoming email
5
    print(f"Email from {sender_email}: {subject}")
6
7
    # Generate and send auto-reply
8
    try:
9
        if USE_AI_REPLY:
10
            email_body = message.get('text', '') or message.get('body', '')
11
12
            # Fetch thread history for context
13
            thread_history = ""
14
            if thread_id:
15
                print(f"Fetching thread history for: {thread_id[:20]}...")
16
                messages = get_thread_history(thread_id)
17
                if messages:
18
                    thread_history = format_thread_for_ai(messages)
19
                    print(f"Found {len(messages)} messages in thread")
20
21
            reply_text = generate_ai_reply(sender_name, email_body, subject, thread_history)
22
            print("Using AI-generated reply with thread context")
23
        else:
24
            reply_text = generate_reply(sender_name, subject)
25
            print("Using template reply")
26
27
        client.inboxes.messages.reply(
28
            inbox_id=inbox_id,
29
            message_id=message_id,
30
            to=[sender_email],
31
            text=reply_text
32
        )
33
        print(f"Auto-reply sent to {sender_email}\n")
34
    except Exception as e:
35
        print(f"Error: {e}\n")