1
import asyncio
2
import websockets
3
import json
4
from agentmail import AgentMail #Import the AgentMail client
5
import os
6
from dotenv import load_dotenv
7
8
load_dotenv()

1
async def connect_to_agent(address: str):
2
   uri = f"ws://localhost:8000/ws/{address}"
3
   client = AgentMail(api_key=os.getenv("AGENTMAIL_API_KEY"))

1
async def connect_to_agent(address: str):
2
   uri = f"ws://localhost:8000/ws/{address}"
3
   client = AgentMail(api_key=os.getenv("AGENTMAIL_API_KEY"))
4
5
   client.inboxes.create(
6
       username = address, # Optional, will randomly generate if not provided
7
       domain = 'agentmail.to' # Optional, defaults to agentmail.to can use custom domain
8
       ) # Our first sdk call!!!
9
   print(f"Connected to agent for {email_address}")
10
   print("Waiting for new emails...")
11
12
   # At this point in the code the inbox is created!
13
   async with websockets.connect(uri) as websocket:
14
       print(f"Connected to agent for {address}")
15
       print("Waiting for new messages...")
16
17
       while True:
18
           try:
19
               # Check for new messages
20
                messages = client.messages.list(
21
                   inbox_id=address,  # Required
22
                   received=True,     # Optional: filter for received messages
23
                   sent=False,        # Optional: filter for sent messages
24
                   limit=10,          # Optional: limit number of messages
25
                   last_key=None      # Optional: for pagination
26
               )
27
28
29
               if messages:
30
                   notification = {
31
                       "type": "new_message",
32
                       "data": {
33
                           "address": address,
34
                           "messages": [{"id": msg.id, "subject": msg.subject} for msg in messages]
35
                       }
36
                   }
37
                   await websocket.send(json.dumps(notification))
38
39
                   response = await websocket.recv()
40
                   response_data = json.loads(response)
41
42
                   if response_data.get('status') == 'success':
43
                       print("Message processing completed")
44
                       return
45
46
               await asyncio.sleep(5)  # Check every 5 seconds
47
48
           except websockets.ConnectionClosed:
49
               print("Connection closed")
50
               break
51
           except Exception as e:
52
               print(f"Error: {e}")
53
               await asyncio.sleep(5)

1
from langchain_openai import ChatOpenAI
2
from browser_use import Agent, BrowserConfig, Browser
3
from browser_use.browser.context import BrowserContextConfig
4
from playwright.async_api import BrowserContext
5
from dotenv import load_dotenv
6
from browser_use.controller.service import Controller
7
from agentmail import AgentMail
8
from typing import Optional, List
9
from fastapi import FastAPI, WebSocket
10
from fastapi.middleware.cors import CORSMiddleware

1
load_dotenv()
2
3
browser = Browser(
4
    config=BrowserConfig(
5
        headless=False,
6
        disable_security=True,
7
        chrome_instance_path="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
8
        new_context_config=BrowserContextConfig(
9
        wait_for_network_idle_page_load_time=3.0,
10
        browser_window_size={'width': 1280, 'height': 1100},
11
    )
12
    )
13
)

1
llm = ChatOpenAI(model="gpt-4o")
2
3
class EmailManager:
4
    def __init__(self):
5
        self.active_connections: Dict[str, WebSocket] = {}
6
        self.agents: Dict[str, Agent] = {}
7
8
    async def connect(self, email_address: str, websocket: WebSocket):
9
        await websocket.accept()
10
        self.active_connections[email_address] = websocket
11
12
         # Clear any existing log file
13
        log_path = f"logs/conversation_{email_address}.json"
14
        if os.path.exists(log_path):
15
            os.remove(log_path)
16
17
        # Create agent instance for this connection
18
        self.agents[email_address] = Agent(
19
           task=task,
20
            llm=llm,
21
            use_vision=True,
22
            save_conversation_path=f"logs/conversation_{email_address}.json",
23
            browser=browser,
24
            controller=controller
25
        )
26
27
    async def disconnect(self, email_address: str):
28
        if email_address in self.active_connections:
29
            del self.active_connections[email_address]
30
        if email_address in self.agents:
31
            del self.agents[email_address]
32
33
    async def process_email_update(self, email_address: str, data: dict):
34
        if email_address in self.agents:
35
            agent = self.agents[email_address]
36
            await agent.run()

1
task = f"""
2
You are Agent Kelly, an email and web assistant. Your personal email url is {email_address}
3
        Do not attempt to create your own inbox. You already have one.
4
        You must follow these strict rules:
5
        1. ALWAYS use the provided tool calls for ANY email operations - never try to access emails directly via URLs
6
        2. Use 'Get all messages' tool to check for new emails
7
        3. When you receive messages, first get their IDs from the messages.messages list returned by 'Get all messages'
8
        4. Loop through each message and check message.subject and if the word Newsletter is in the subject use this email address to get the message content
9
            - save this original message.from field - this is who you'll reply to later
10
            - save this original message_id for replying later
11
        5. When you find the Newsletter Signup Request message, read it by calling 'Get message content' with the message ID.
12
        6. DO NOT go to the substack website. Directly search the newsletter name + 'signup' in google and sign up for the top link
13
        7. After signing up, there will be a second screen asking you to sign up to donate. Select the fourth option which means none. Then just click through skipping and then finally maybe later. Don't close the tab until you see the confirmation that you are subscribed.'
14
        8. Be sure to not click the check box to confirm before clicking submit since it is already checked.
15
        9. Use 'reply_to_message' tool to reply to the newsletter signup request message saying you succesfully signed up and will keep the user updated with everything they requested to be kept to up to date with. Use the original message ID you used earlier. For new lines, don't use double slash n. Use a single slash n. In the message, say that you are subscribed to the newsletter, and will be forwarding the best deals that align with the user's interests in the future.
16
            - Use ONLY inbox_id and message_id parameters from the newsletter signup request when replying
17
            - make sure to reply to the original sender
18
            - DO NOT reply to the welcome email or your own inbox.
19
            - Include a confirmation message about the subscription
20
            - use the newsletter signup request messages message.from as the to address here. It should never be your own. And you shouldn't you assume and create one.
21
        Your goal is to:
22
        1. Monitor your inbox for a Newsletter Signup Request email
23
        2. When found, sign up for the requested fashion brand newsletters
24
        3. Reply with a kind email using the reply_to_message tool with the original message ID. and titled 'Best Promotions' including a summary of the newsletter on LLMs.
25
26
        Remember: You must ONLY interact with emails through the provided tools.
27
        Example workflow:
28
        1. messages = Get all messages
29
        2. if messages.messages exists and has items:
30
           - message_id = messages.messages[0].message_id
31
           - Use 'Get specific message' with message_id to read it
32
33
        Remember: Never call 'Get all messages' repeatedly without processing the results.
34
        """

1
email_manager = EmailManager()
2
3
browser = Browser()
4
controller = Controller()
5
client = AgentMail(api_key=os.getenv("AGENTMAIL_API_KEY"))
6
app = FastAPI()
7
app.add_middleware(
8
    CORSMiddleware,
9
    allow_origins=["*"],
10
    allow_credentials=True,
11
    allow_methods=["*"],
12
    allow_headers=["*"],
13
)

1
@controller.action('Create new inbox')
2
def create_inbox() -> str:
3
    result = client.inboxes.create()
4
    return f"Created inbox: {result.address}"
5
6
@controller.action('Delete inbox')
7
def delete_inbox(inbox_id: str) -> str:
8
    client.inboxes.delete(inbox_id=inbox_id)
9
    return f"Deleted inbox: {inbox_id}"
10
11
@controller.action('Get all messages from inbox')
12
def get_messages(inbox_id: str) -> str:
13
    messages = client.messages.list(
14
        inbox_id=inbox_id,
15
16
    )
17
    if not messages.messages:
18
        return "No messages found in inbox"
19
20
    message_ids = []
21
    for msg in messages.messages:
22
        message_ids.append(msg.message_id)
23
    return f"Retrieved {len(message_ids)} messages from {inbox_id} with IDs: {message_ids}"
24
25
@controller.action('Get message by ID')
26
def get_message(inbox_id: str, message_id: str) -> str:
27
    message = client.messages.get(inbox_id = inbox_id, message_id=message_id)
28
    return f"Retrieved message: {message.subject}"
29
30
@controller.action('Get message content')
31
def get_message(inbox_id: str, message_id: str) -> str:
32
    message = client.messages.get(inbox_id = inbox_id, message_id=message_id)
33
    return f"Retrieved message: {message.text}"
34
35
@controller.action('Send new message')
36
def send_message(
37
    inbox_id: str,
38
    to: List[str],
39
    subject: Optional[str] = None,
40
    text: Optional[str] = None,
41
    html: Optional[str] = None,
42
    cc: Optional[List[str]] = None,
43
    bcc: Optional[List[str]] = None
44
):
45
46
    client.messages.send(
47
        inbox_id=inbox_id,
48
        to=to,
49
        subject=subject or "",
50
        text=text or "",
51
        html=html or "",
52
        cc=cc or [],
53
        bcc=bcc or []
54
    )
55
    return f"Sent message from {inbox_id} to {to}"
56
57
@controller.action('Reply to message')
58
def reply_to_message(
59
    inbox_id: str,
60
    message_id: str,
61
    text: Optional[str] = None,
62
    html: Optional[str] = None,
63
    to: Optional[str] = None,
64
    cc: Optional[List[str]] = None,
65
    bcc: Optional[List[str]] = None
66
):
67
    client.messages.reply(
68
        inbox_id=inbox_id,
69
        message_id=message_id,
70
        text=text or "",
71
        html=html or "",
72
        to=to or "",
73
        cc=cc or [],
74
        bcc=bcc or [],
75
    )
76
    return f"Replied to message {message_id}"

1
@app.websocket("/ws/{email_address}")
2
async def websocket_endpoint(websocket: WebSocket, email_address: str):
3
    await email_manager.connect(email_address, websocket)
4
    try:
5
        while True:
6
            print("Waiting for WebSocket message...")
7
            data = await websocket.receive_json()
8
            print(f"Received data: {data}")
9
10
            if data.get('type') == 'new_email':
11
                await email_manager.process_email_update(email_address, data)
12
                await websocket.send_json({
13
                    "status": "success",
14
                    "message": "Email processed successfully"
15
                })
16
                print("Processing complete, closing connection")
17
                await websocket.close()
18
                break  # Exit the loop
19
    except Exception as e:
20
        print(f"Error in websocket connection: {e}")
21
    finally:
22
        await email_manager.disconnect(email_address)

1
if __name__ == "__main__":
2
    import uvicorn
3
    uvicorn.run(app, host="0.0.0.0", port=8000)