fix(ui): refuse a tool decision that arrives before its prompt

An approval sent before the agent had opened its permission prompt was reported
as delivered, then overwritten when the prompt opened, so the run waited out its
whole timeout and denied the tool. resolve_tool_confirmation now returns False
when nothing is pending, as its docstring always said, so the /tool_decision
endpoint answers 409 and the caller retries.

This made "Gaia Agent Tests" fail on main whenever the test's answer won the
race; the test now polls on a deadline and says plainly when no answer landed.

Author: kovtcharov-amd

hub/agents/gaia/python/tests/test_server_query.py

@@ -1089,15 +1089,19 @@ def test_a_gated_tool_runs_once_the_decision_arrives(built):
     client, agents = built
     run_id = str(uuid.uuid4())
 
+    answered = threading.Event()
+
     def answer_when_asked():
         # The decision endpoint 409s until the prompt is actually pending, so
         # poll rather than sleep a guessed interval.
-        for _ in range(400):
+        deadline = time.monotonic() + 30
+        while time.monotonic() < deadline:
             response = client.post(
                 f"/v1/gaia/query/{run_id}/tool_decision",
                 json={"decision": "allow"},
             )
             if response.status_code == 200:
+                answered.set()
                 return
             time.sleep(0.01)
 
@@ -1116,6 +1120,7 @@ def arm(**kw):
         )
 
     assert response.status_code == 200, response.text
+    assert answered.is_set(), "the decision was never accepted while the prompt was open"
     events = _events(response)
     types = [e.get("type") for e in events]
     assert "needs_confirmation" in types, f"the prompt must reach the client: {types}"

src/gaia/ui/sse_handler.py

@@ -1232,12 +1232,14 @@ def resolve_tool_confirmation(
                     self._confirm_id,
                 )
                 return False
+            if self._confirm_event is None:
+                # Nothing is waiting: an answer stored now would be overwritten
+                # when the prompt opens, so report it undelivered and let the
+                # caller retry.
+                logger.warning("Dropped a tool decision: no confirmation is pending")
+                return False
             if always and self._confirm_tool:
                 self.grant_call_for_session(self._confirm_tool, self._confirm_args)
-            if self._confirm_event is None:
-                # No pending confirmation — initialise state anyway so callers can
-                # inspect _confirm_result and _confirm_event after the call.
-                self._confirm_event = threading.Event()
             self._confirm_result = (approved or always) and not timed_out
             self._confirm_timed_out = timed_out
             self._confirm_event.set()

tests/unit/chat/ui/test_sse_confirmation.py

@@ -197,13 +197,32 @@ def run_confirm():
 
 
 class TestResolveToolConfirmationNoPending:
-    """resolve_tool_confirmation with no pending request just sets the event."""
-
-    def test_no_pending_sets_event(self, handler):
-        """Calling resolve with no pending confirm just sets the event/result."""
-        handler.resolve_tool_confirmation(approved=True)
-        assert handler._confirm_result is True
-        assert handler._confirm_event.is_set()
+    """A decision with nothing pending is refused, so the caller can retry."""
+
+    def test_no_pending_is_not_delivered(self, handler):
+        assert handler.resolve_tool_confirmation(approved=True) is False
+        assert handler._confirm_event is None
+
+    def test_an_early_answer_does_not_satisfy_a_later_prompt(self, handler):
+        """Reported as delivered, it was then overwritten when the prompt opened,
+        and the run waited out its whole timeout."""
+        assert handler.resolve_tool_confirmation(approved=True) is False
+
+        result = {}
+        thread = threading.Thread(
+            target=lambda: result.setdefault(
+                "approved",
+                handler.confirm_tool_execution("run_shell_command", {}, timeout=10),
+            ),
+            daemon=True,
+        )
+        thread.start()
+        deadline = time.monotonic() + 5
+        while handler._confirm_event is None and time.monotonic() < deadline:
+            time.sleep(0.01)
+        assert handler.resolve_tool_confirmation(approved=True) is True
+        thread.join(timeout=5)
+        assert result == {"approved": True}
 
 
 # ===========================================================================