Give Browser Use Agents a Real Email API

import os
import asyncio
import httpx
from browser_use import Agent
from browser_use.tools import Tool
from langchain_openai import ChatOpenAI

MULTIMAIL_API_KEY = os.environ["MULTIMAIL_API_KEY"]
BASE = "https://api.multimail.dev"
HEADERS = {"Authorization": f"Bearer {MULTIMAIL_API_KEY}"}


def send_email(to: str, subject: str, body: str) -> dict:
    """Send an email from the agent mailbox."""
    resp = httpx.post(
        f"{BASE}/send_email",
        headers=HEADERS,
        json={
            "to": to,
            "subject": subject,
            "body": body,
            "from_mailbox": "[email protected]",
        },
    )
    resp.raise_for_status()
    return resp.json()


def check_inbox(limit: int = 10) -> dict:
    """Return recent inbox messages."""
    resp = httpx.get(
        f"{BASE}/check_inbox",
        headers=HEADERS,
        params={"limit": limit},
    )
    resp.raise_for_status()
    return resp.json()


agent = Agent(
    task="Check the inbox and reply to any messages asking about pricing.",
    llm=ChatOpenAI(model="gpt-4o"),
    tools=[
        Tool.from_function(send_email),
        Tool.from_function(check_inbox),
    ],
)

asyncio.run(agent.run())

import os
import asyncio
import httpx
from browser_use import Agent
from browser_use.tools import Tool
from langchain_openai import ChatOpenAI

"cm"># Mailbox must be configured with oversight_mode=gated_send
"cm"># Set once: POST /create_mailbox with {"oversight_mode": "gated_send"}

MULTIMAIL_API_KEY = os.environ["MULTIMAIL_API_KEY"]
BASE = "https://api.multimail.dev"
HEADERS = {"Authorization": f"Bearer {MULTIMAIL_API_KEY}"}


def send_email_for_approval(to: str, subject: str, body: str) -> dict:
    """
    Submit email for human approval.
    Returns immediately with status=pending.
    Delivery waits for approval webhook.
    """
    resp = httpx.post(
        f"{BASE}/send_email",
        headers=HEADERS,
        json={
            "to": to,
            "subject": subject,
            "body": body,
            "from_mailbox": "[email protected]",
        },
    )
    resp.raise_for_status()
    return resp.json()  "cm"># {"status": "pending", "message_id": "msg_..."}


def list_pending_approvals() -> dict:
    """Check which outbound messages are waiting for human approval."""
    resp = httpx.get(f"{BASE}/list_pending", headers=HEADERS)
    resp.raise_for_status()
    return resp.json()


agent = Agent(
    task=(
        "Draft follow-up emails to leads from the CRM, "
        "then report how many are pending approval."
    ),
    llm=ChatOpenAI(model="gpt-4o"),
    tools=[
        Tool.from_function(send_email_for_approval),
        Tool.from_function(list_pending_approvals),
    ],
)

asyncio.run(agent.run())

import os
import asyncio
import httpx
from fastapi import FastAPI, Request
from browser_use import Agent
from browser_use.tools import Tool
from langchain_openai import ChatOpenAI

app = FastAPI()
MULTIMAIL_API_KEY = os.environ["MULTIMAIL_API_KEY"]
BASE = "https://api.multimail.dev"
HEADERS = {"Authorization": f"Bearer {MULTIMAIL_API_KEY}"}


@app.post("/webhook/inbound")
async def handle_inbound(request: Request):
    payload = await request.json()
    message_id = payload["message_id"]
    sender = payload["from"]
    subject = payload["subject"]
    body = payload["body_text"]

    def reply(text: str) -> dict:
        """Reply to the inbound message."""
        return httpx.post(
            f"{BASE}/reply_email",
            headers=HEADERS,
            json={"message_id": message_id, "body": text},
        ).json()

    def tag(tags: list[str]) -> dict:
        """Tag the inbound message."""
        return httpx.post(
            f"{BASE}/tag_email",
            headers=HEADERS,
            json={"message_id": message_id, "tags": tags},
        ).json()

    agent = Agent(
        task=(
            f"Email from {sender}, subject &"cm">#039;{subject}'.\n"
            f"Body: {body}\n\n"
            "1. Tag it &"cm">#039;inbound-webhook'.\n"
            "2. If it&"cm">#039;s a support request, tag it 'support' and reply with a confirmation.\n"
            "3. Otherwise reply that the message was received."
        ),
        llm=ChatOpenAI(model="gpt-4o"),
        tools=[Tool.from_function(reply), Tool.from_function(tag)],
    )
    asyncio.create_task(agent.run())
    return {"status": "processing"}

import os
import asyncio
import httpx
from browser_use import Agent
from browser_use.tools import Tool
from langchain_openai import ChatOpenAI

MULTIMAIL_API_KEY = os.environ["MULTIMAIL_API_KEY"]
BASE = "https://api.multimail.dev"
HEADERS = {"Authorization": f"Bearer {MULTIMAIL_API_KEY}"}


def get_thread(thread_id: str) -> dict:
    """Fetch all messages in a thread."""
    return httpx.get(
        f"{BASE}/get_thread",
        headers=HEADERS,
        params={"thread_id": thread_id},
    ).json()


def search_contacts(query: str) -> dict:
    """Search contacts by name or email."""
    return httpx.get(
        f"{BASE}/search_contacts",
        headers=HEADERS,
        params={"q": query},
    ).json()


def reply_email(message_id: str, body: str) -> dict:
    """Reply to a specific message."""
    return httpx.post(
        f"{BASE}/reply_email",
        headers=HEADERS,
        json={"message_id": message_id, "body": body},
    ).json()


agent = Agent(
    task=(
        "Fetch thread thd_01JQXA7KBRM3P and read the full conversation. "
        "Search contacts to find history with the sender. "
        "Reply to the latest message summarizing agreed next steps."
    ),
    llm=ChatOpenAI(model="gpt-4o"),
    tools=[
        Tool.from_function(get_thread),
        Tool.from_function(search_contacts),
        Tool.from_function(reply_email),
    ],
)

asyncio.run(agent.run())