Merge branch 'main' into tmi/issue-1088-static-mount-per-request

Author: itomek

hub/agents/python/email/gaia_agent_email/agent.py

@@ -66,6 +66,7 @@ class never passes ``use_claude=True`` / ``use_chatgpt=True`` to
 from gaia.agents.base.memory import MemoryMixin
 from gaia.agents.base.tools import _TOOL_REGISTRY
 from gaia.connectors.errors import ConnectorsError
+from gaia.connectors.formatting import format_connector_error
 from gaia.connectors.providers.base import ConnectorRequirement
 from gaia.database.mixin import DatabaseMixin
 from gaia.llm.lemonade_client import DEFAULT_MODEL_NAME
@@ -489,6 +490,13 @@ def _triage_all_backends(self, *, max_messages: int) -> dict:
         because local inference is slow (~9-31 s/email) and a doubled budget
         would blow the user's expected wait. Every returned item gains a
         ``mailbox`` tag and its id is remembered for downstream action routing.
+
+        When one backend raises ``ConnectorsError`` (e.g. an agent grant was
+        revoked while the connection remains live), the error is recorded as a
+        per-mailbox notice in ``mailbox_errors`` and the loop continues with the
+        remaining backends. Non-``ConnectorsError`` exceptions still propagate —
+        a genuine bug must fail loudly. The available set stays connection-derived;
+        grant enforcement happens at the token layer.
         """
         from gaia_agent_email.tools import read_tools
         from gaia_agent_email.tools.read_tools import (
@@ -509,17 +517,24 @@ def _triage_all_backends(self, *, max_messages: int) -> dict:
         backends = self._backends
         per_backend = max(1, max_messages // len(backends))
         merged: list[dict] = []
+        mailbox_errors: list[dict] = []
         for provider, backend in backends.items():
             if len(merged) >= max_messages:
                 break
-            out = triage_inbox_impl(
-                backend,
-                max_messages=per_backend,
-                session_preferences=prefs,
-                force_llm=force_llm,
-                classifier=classifier,
-                debug=debug_flag,
-            )
+            try:
+                out = triage_inbox_impl(
+                    backend,
+                    max_messages=per_backend,
+                    session_preferences=prefs,
+                    force_llm=force_llm,
+                    classifier=classifier,
+                    debug=debug_flag,
+                )
+            except ConnectorsError as exc:
+                msg = format_connector_error(exc)
+                mailbox_errors.append({"mailbox": provider, "error": msg})
+                logger.warning("email triage: skipping %s mailbox — %s", provider, msg)
+                continue
             for item in out["results"]:
                 item["mailbox"] = provider
                 self._remember_message_mailbox(item.get("id"), provider)
@@ -541,7 +556,17 @@ def _triage_all_backends(self, *, max_messages: int) -> dict:
         self._apply_behavioral_promotions()
         # Re-group the merged, capped list so the bucketed view matches what the
         # caller actually sees.
-        return {"results": merged, "grouped": group_by_category(merged)}
+        if mailbox_errors and len(mailbox_errors) == len(self._backends):
+            # Every connected mailbox failed — surface it loudly rather than
+            # returning ok with zero results (which reads as "empty inbox").
+            raise ConnectorsError(
+                "All connected mailboxes failed during triage: "
+                + "; ".join(f"{e['mailbox']}: {e['error']}" for e in mailbox_errors)
+            )
+        result: dict = {"results": merged, "grouped": group_by_category(merged)}
+        if mailbox_errors:
+            result["mailbox_errors"] = mailbox_errors
+        return result
 
     def _apply_behavioral_promotions(self) -> None:
         """Promote qualifying senders to priority based on observed reply behavior.
@@ -593,6 +618,10 @@ def _pre_scan_all_backends(self, *, max_messages: int) -> dict:
         (urgent / actionable / suggested_archives) gains a ``mailbox`` tag and
         its message_id is remembered for action routing. Per-section caps and
         the envelope shape are preserved by merging the per-backend envelopes.
+
+        When one backend raises ``ConnectorsError`` (e.g. a revoked agent grant),
+        the error is recorded in ``mailbox_errors`` and the loop continues with
+        the remaining backends. Non-``ConnectorsError`` exceptions still propagate.
         """
         from gaia_agent_email.tools.read_tools import (
             PRE_SCAN_ACTIONABLE_CAP,
@@ -613,16 +642,25 @@ def _pre_scan_all_backends(self, *, max_messages: int) -> dict:
         informational_count = 0
         scanned = 0
         merged_prefs_applied: dict = {}
+        mailbox_errors: list[dict] = []
         for provider, backend in backends.items():
             if scanned >= max_messages:
                 break
-            out = pre_scan_inbox_impl(
-                backend,
-                max_messages=per_backend,
-                session_preferences=prefs,
-                force_llm=force_llm,
-                debug=debug_flag,
-            )
+            try:
+                out = pre_scan_inbox_impl(
+                    backend,
+                    max_messages=per_backend,
+                    session_preferences=prefs,
+                    force_llm=force_llm,
+                    debug=debug_flag,
+                )
+            except ConnectorsError as exc:
+                msg = format_connector_error(exc)
+                mailbox_errors.append({"mailbox": provider, "error": msg})
+                logger.warning(
+                    "email pre-scan: skipping %s mailbox — %s", provider, msg
+                )
+                continue
             # Count messages actually returned, not the cap — an under-filled
             # backend would otherwise trip the budget guard and skip a later one.
             backend_totals = out.get("totals", {})
@@ -649,7 +687,7 @@ def _pre_scan_all_backends(self, *, max_messages: int) -> dict:
                 self._remember_message_mailbox(item.get("thread_id"), provider)
                 suggested_archives.append(item)
             informational_count += int(out.get("informational_count", 0))
-        return {
+        result = {
             "kind": "email_pre_scan",
             "urgent": urgent[: max(0, PRE_SCAN_URGENT_CAP)],
             "actionable": actionable[: max(0, PRE_SCAN_ACTIONABLE_CAP)],
@@ -664,6 +702,16 @@ def _pre_scan_all_backends(self, *, max_messages: int) -> dict:
                 "suggested_archives": len(suggested_archives),
             },
         }
+        if mailbox_errors and len(mailbox_errors) == len(self._backends):
+            # Every connected mailbox failed — surface it loudly rather than
+            # returning ok with zero results (which reads as "empty inbox").
+            raise ConnectorsError(
+                "All connected mailboxes failed during pre-scan: "
+                + "; ".join(f"{e['mailbox']}: {e['error']}" for e in mailbox_errors)
+            )
+        if mailbox_errors:
+            result["mailbox_errors"] = mailbox_errors
+        return result
 
     # -- Phase I3 batch-organize counter -----------------------------------
 

hub/agents/python/email/gaia_agent_email/config.py

@@ -249,11 +249,17 @@ def resolve_mail_backends(self) -> List[Tuple[str, Any]]:
           - ``"google"`` / ``"microsoft"`` → only that provider, and only when
             it is actually connected.
 
-        Connector-derived: the connected set comes from
-        ``connected_mailbox_providers()`` (the keyring), in registry order
-        (google before microsoft). Fails loudly — an explicit filter naming an
-        unconnected provider, or nothing connected at all, raises
-        ``ConfigurationError`` rather than silently triaging one mailbox.
+        Connector-derived (intentional): the available set is the set of
+        CONNECTED providers, not the set of providers the agent is granted for.
+        Grant enforcement is the connectors layer's job — ``get_access_token_sync``
+        raises ``AuthRequiredError(AGENT_NOT_GRANTED)`` eagerly when the token is
+        fetched. The agent catches ``ConnectorsError`` per mailbox in
+        ``_triage_all_backends`` / ``_pre_scan_all_backends`` and surfaces a clean,
+        actionable per-mailbox notice rather than aborting the whole scan.
+
+        Fails loudly — an explicit filter naming an unconnected provider, or
+        nothing connected at all, raises ``ConfigurationError`` rather than
+        silently triaging one mailbox.
 
         The per-provider eval seam (``gmail_backend`` / ``outlook_backend``) is
         honored via ``_build_mail_backend``. An injected backend also marks its
@@ -322,6 +328,12 @@ def resolve_calendar_backend(self) -> Any:
         interchangeably. An unsupported explicit provider raises
         ``ConfigurationError`` (fail loudly).
 
+        Grant enforcement is the connectors layer's job — a calendar backend
+        whose agent grant has been revoked raises ``AuthRequiredError`` when the
+        first calendar tool call fetches the token. The existing per-tool
+        ``ConnectorsError`` handler in ``CalendarToolsMixin`` surfaces that as a
+        clean actionable envelope without requiring any grant reasoning here.
+
         Live backend imports are local to keep the module import graph free of
         the ``connectors`` dependency chain at ``config`` import time.
         """