Add Gmail SMTP email backend

send_email can now deliver via Gmail SMTP (delivers to ANY recipient with just a Google App Password — no domain verification) as well as Resend, selected by EMAIL_BACKEND (auto-detects if unset). The blocking smtplib call runs via asyncio.to_thread so the realtime audio loop is never stalled. All existing guards (visitor-identity check, placeholder rejection, per-session dedupe, outbox recording) are preserved. The four Gmail settings keys are exposed in the dashboard Settings panel.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/reachy_mini_receptionist/main.py

@@ -819,6 +819,10 @@ def _mount_dashboard_api(
         "GEMINI_API_KEY":              {"secret": True,  "restart": True},
         "STT_DISABLE_BIAS":            {"secret": False, "restart": True},
         "STT_LANGUAGE":                {"secret": False, "restart": True},
+        "EMAIL_BACKEND":               {"secret": False, "restart": False},
+        "GMAIL_ADDRESS":               {"secret": False, "restart": False},
+        "GMAIL_APP_PASSWORD":          {"secret": True,  "restart": False},
+        "GMAIL_FROM_NAME":             {"secret": False, "restart": False},
         "RESEND_API_KEY":              {"secret": True,  "restart": False},
         "RESEND_FROM":                 {"secret": False, "restart": False},
         "RECEPTION_ICS_URL":           {"secret": False, "restart": False},

src/reachy_mini_receptionist/tools/send_email.py

@@ -1,20 +1,28 @@
 """Tool: send_email
 
-Sends an email via Resend's transactional email API. Falls back to the
-in-memory outbox when ``RESEND_API_KEY`` is unset, so demos / CI keep
-working without delivery credentials.
+Delivers via one of two backends (selectable with ``EMAIL_BACKEND``):
+  * ``gmail``  — Gmail SMTP. Delivers to ANY recipient with just a Google
+                 App Password; no domain verification needed.
+  * ``resend`` — Resend's transactional HTTP API.
+Unset/unknown ``EMAIL_BACKEND`` auto-detects: prefer Gmail if its creds are
+present, else Resend, else falls back to the in-memory outbox only — so
+demos / CI keep working without any delivery credentials.
 
 The outbox is ALWAYS written so the dashboard's Mailbox Out panel reflects
 reality regardless of delivery mode. Entries carry ``delivered`` and
 ``error`` fields so the UI can flag failed sends.
 
 Environment variables:
+    EMAIL_BACKEND   ``gmail`` or ``resend``. Unset → auto-detect (see above).
+    GMAIL_ADDRESS   The Gmail / Google Workspace address to send from.
+    GMAIL_APP_PASSWORD
+                    A Google App Password (16 chars; requires 2-Step
+                    Verification enabled). Delivers to ANY recipient — no
+                    domain to verify. https://myaccount.google.com/apppasswords
+    GMAIL_FROM_NAME Display name for the sender (default "Reachy Reception").
     RESEND_API_KEY  Resend API key (``re_...``). Get one free at
-                    https://resend.com/api-keys. Without this set, the
-                    tool writes to the outbox only and returns
-                    ``success=True, delivered=False`` so the conversation
-                    flow can continue.
-    RESEND_FROM     Sender address. Defaults to ``onboarding@resend.dev``
+                    https://resend.com/api-keys.
+    RESEND_FROM     Resend sender address. Defaults to ``onboarding@resend.dev``
                     (Resend's sandbox sender; this only delivers to the
                     email address registered on your Resend account).
                     For production, verify a domain at
@@ -23,9 +31,10 @@ Environment variables:
 """
 from __future__ import annotations
 
-import logging
 import os
 import time
+import asyncio
+import logging
 from typing import Any, Dict, List, Optional
 
 import httpx
@@ -80,6 +89,92 @@ def _record_outbox(
     return entry
 
 
+# ---------------------------------------------------------------------------
+# Delivery backends — each returns (delivered, error, provider_message_id)
+# ---------------------------------------------------------------------------
+async def _send_via_resend(
+    to: str, subject: str, body: str
+) -> tuple[bool, Optional[str], Optional[str]]:
+    """Deliver via Resend's HTTP API. Assumes RESEND_API_KEY is set."""
+    api_key = os.getenv("RESEND_API_KEY")
+    sender = os.getenv("RESEND_FROM", "onboarding@resend.dev")
+    payload = {"from": sender, "to": [to], "subject": subject, "text": body}
+    try:
+        async with httpx.AsyncClient(timeout=_HTTP_TIMEOUT_SECONDS) as client:
+            resp = await client.post(
+                _RESEND_API_URL,
+                headers={
+                    "Authorization": f"Bearer {api_key}",
+                    "Content-Type": "application/json",
+                },
+                json=payload,
+            )
+    except Exception as e:
+        return False, f"{type(e).__name__}: {e}", None
+    if resp.status_code >= 400:
+        try:
+            parsed = resp.json()
+            err_msg = parsed.get("message") or parsed.get("name") or resp.text
+        except Exception:
+            err_msg = resp.text
+        return False, f"HTTP {resp.status_code}: {err_msg}", None
+    try:
+        return True, None, resp.json().get("id")
+    except Exception:
+        return True, None, None
+
+
+async def _send_via_gmail(
+    to: str, subject: str, body: str
+) -> tuple[bool, Optional[str], Optional[str]]:
+    """Deliver via Gmail SMTP.
+
+    Runs the blocking smtplib call off the event loop with asyncio.to_thread
+    so the realtime audio pipeline is never stalled while a mail is in flight.
+    """
+    return await asyncio.to_thread(_send_via_gmail_sync, to, subject, body)
+
+
+def _send_via_gmail_sync(
+    to: str, subject: str, body: str
+) -> tuple[bool, Optional[str], Optional[str]]:
+    import ssl
+    import smtplib
+    from email.message import EmailMessage
+
+    address = (os.getenv("GMAIL_ADDRESS") or "").strip()
+    # App passwords are displayed grouped as "abcd efgh ijkl mnop" — tolerate
+    # the spaces so a pasted value still authenticates.
+    app_password = (os.getenv("GMAIL_APP_PASSWORD") or "").replace(" ", "").strip()
+    from_name = (os.getenv("GMAIL_FROM_NAME") or "Reachy Reception").strip()
+    if not address or not app_password:
+        return False, "GMAIL_ADDRESS / GMAIL_APP_PASSWORD not set", None
+
+    msg = EmailMessage()
+    msg["From"] = f"{from_name} <{address}>" if from_name else address
+    msg["To"] = to
+    msg["Subject"] = subject
+    msg.set_content(body)
+
+    try:
+        context = ssl.create_default_context()
+        with smtplib.SMTP_SSL(
+            "smtp.gmail.com", 465, timeout=_HTTP_TIMEOUT_SECONDS, context=context
+        ) as server:
+            server.login(address, app_password)
+            server.send_message(msg)
+    except smtplib.SMTPAuthenticationError as e:
+        return (
+            False,
+            "Gmail auth failed — check GMAIL_ADDRESS and the 16-char "
+            f"GMAIL_APP_PASSWORD (2-Step Verification must be on): {e}",
+            None,
+        )
+    except Exception as e:
+        return False, f"{type(e).__name__}: {e}", None
+    return True, None, msg.get("Message-ID")
+
+
 # ---------------------------------------------------------------------------
 # Tool class
 # ---------------------------------------------------------------------------
@@ -293,40 +388,50 @@ class SendEmail(Tool):
                 except Exception as e:
                     logger.debug("release_email_claim failed: %s", e)
 
-        api_key = os.getenv("RESEND_API_KEY")
-        if not api_key:
+        # ---- Delivery backend selection ---------------------------------
+        # EMAIL_BACKEND=gmail | resend. Unset/unknown -> auto-detect: prefer
+        # Gmail (delivers to ANY recipient with just an app password — no
+        # domain verification), then Resend, else outbox-only dry run.
+        # Existing Resend-only deployments keep working unchanged.
+        backend = (os.getenv("EMAIL_BACKEND") or "").strip().lower()
+        gmail_ready = bool(
+            (os.getenv("GMAIL_ADDRESS") or "").strip()
+            and (os.getenv("GMAIL_APP_PASSWORD") or "").strip()
+        )
+        resend_ready = bool((os.getenv("RESEND_API_KEY") or "").strip())
+        if backend not in ("gmail", "resend"):
+            backend = "gmail" if gmail_ready else ("resend" if resend_ready else "")
+
+        # No usable credentials for the chosen backend -> outbox-only dry run.
+        # (Do NOT release the email claim — this is treated as a successful
+        # record, so the dedupe guard must still hold for the session.)
+        if (
+            backend == ""
+            or (backend == "gmail" and not gmail_ready)
+            or (backend == "resend" and not resend_ready)
+        ):
             entry = _record_outbox(to, subject, body, delivered=False, error=None)
             logger.info(
-                "[EMAIL DRY-RUN → %s] %s  (RESEND_API_KEY unset; outbox only)",
+                "[EMAIL DRY-RUN → %s] %s  (no email backend configured; outbox only)",
                 to, subject,
             )
             return {
                 "success": True,
-                "message": f"Email recorded for {to} (Resend not configured — outbox only)",
+                "message": (
+                    f"Email recorded for {to} (no email backend configured — "
+                    f"outbox only)"
+                ),
                 "timestamp": entry["timestamp"],
                 "delivered": False,
             }
 
-        sender = os.getenv("RESEND_FROM", "onboarding@resend.dev")
-        payload = {
-            "from": sender,
-            "to": [to],
-            "subject": subject,
-            "text": body,
-        }
+        # ---- Deliver via the selected backend ---------------------------
+        if backend == "gmail":
+            delivered, err, message_id = await _send_via_gmail(to, subject, body)
+        else:
+            delivered, err, message_id = await _send_via_resend(to, subject, body)
 
-        try:
-            async with httpx.AsyncClient(timeout=_HTTP_TIMEOUT_SECONDS) as client:
-                resp = await client.post(
-                    _RESEND_API_URL,
-                    headers={
-                        "Authorization": f"Bearer {api_key}",
-                        "Content-Type": "application/json",
-                    },
-                    json=payload,
-                )
-        except Exception as e:
-            err = f"{type(e).__name__}: {e}"
+        if not delivered:
             entry = _record_outbox(to, subject, body, delivered=False, error=err)
             logger.warning("[EMAIL FAILED → %s] %s | %s", to, subject, err)
             _release_claim()
@@ -337,34 +442,12 @@ class SendEmail(Tool):
                 "delivered": False,
             }
 
-        if resp.status_code >= 400:
-            try:
-                parsed = resp.json()
-                err_msg = parsed.get("message") or parsed.get("name") or resp.text
-            except Exception:
-                err_msg = resp.text
-            err = f"HTTP {resp.status_code}: {err_msg}"
-            entry = _record_outbox(to, subject, body, delivered=False, error=err)
-            logger.warning("[EMAIL FAILED → %s] %s | %s", to, subject, err)
-            _release_claim()
-            return {
-                "success": False,
-                "error": err,
-                "timestamp": entry["timestamp"],
-                "delivered": False,
-            }
-
-        try:
-            message_id = resp.json().get("id")
-        except Exception:
-            message_id = None
-
         entry = _record_outbox(
             to, subject, body,
             delivered=True, error=None,
             provider_message_id=message_id,
         )
-        logger.info("[EMAIL → %s] %s  (resend id=%s)", to, subject, message_id)
+        logger.info("[EMAIL → %s] %s  (%s id=%s)", to, subject, backend, message_id)
         return {
             "success": True,
             "message": f"Email sent to {to}",