multi agent

tests/test_agents_reflector.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from agents.models import Observation, ReflectionOutcome, VerificationVerdict
+from agents.reflector import Reflector
+from runtime.executor import StepResult
+from runtime.planner import PlannedStep
+
+
+def _observation() -> Observation:
+    return Observation(scene_summary="Screen 1080x1920\n  [button] Reply")
+
+
+def _planned_step() -> PlannedStep:
+    return PlannedStep(
+        action="tap",
+        description="Tap the send button",
+        args={"element_id": "btn_send"},
+    )
+
+
+def _success_result() -> StepResult:
+    return StepResult(
+        step=_planned_step(),
+        success=True,
+        attempts=1,
+        result={"tapped": True},
+    )
+
+
+def _not_achieved_verdict() -> VerificationVerdict:
+    return VerificationVerdict(result="not_achieved", reasoning="Scene unchanged.")
+
+
+def test_reflect_fallback_returns_replan() -> None:
+    reflector = Reflector()
+    outcome = reflector.reflect(
+        observation=_observation(),
+        planned_step=_planned_step(),
+        step_result=_success_result(),
+        verdict=_not_achieved_verdict(),
+    )
+    assert outcome.replan is True
+    assert outcome.action is None
+    assert "fallback" in outcome.reasoning.lower()
+
+
+class _FakeClient:
+    """A fake LLM client that returns a canned outcome."""
+
+    def __init__(self, outcome: dict) -> None:
+        self._outcome = outcome
+        self._calls: list[dict] = []
+
+    def _create_message(self, payload: dict, *, timeout: float) -> dict:
+        self._calls.append(payload)
+        return self._outcome
+
+
+def test_reflect_recovery_action_via_llm() -> None:
+    fake = _FakeClient({
+        "replan": False,
+        "action": {
+            "action": "swipe",
+            "description": "Scroll down to find send button",
+            "args": {"direction": "up"},
+        },
+        "reasoning": "Button may be off-screen.",
+    })
+    reflector = Reflector(client=fake)  # type: ignore[arg-type]
+    outcome = reflector.reflect(
+        observation=_observation(),
+        planned_step=_planned_step(),
+        step_result=_success_result(),
+        verdict=_not_achieved_verdict(),
+    )
+    assert outcome.replan is False
+    assert outcome.action is not None
+    assert outcome.action.action == "swipe"
+    assert len(fake._calls) == 1
+
+
+def test_reflect_replan_via_llm() -> None:
+    fake = _FakeClient({
+        "replan": True,
+        "action": None,
+        "reasoning": "No bounded recovery possible.",
+    })
+    reflector = Reflector(client=fake)  # type: ignore[arg-type]
+    outcome = reflector.reflect(
+        observation=_observation(),
+        planned_step=_planned_step(),
+        step_result=_success_result(),
+        verdict=_not_achieved_verdict(),
+    )
+    assert outcome.replan is True
+    assert outcome.action is None
+
+
+def test_reflect_rejects_identical_action() -> None:
+    """If the LLM proposes the exact same step, reflector should force replan."""
+    fake = _FakeClient({
+        "replan": False,
+        "action": {
+            "action": "tap",
+            "description": "Tap the send button",
+            "args": {"element_id": "btn_send"},
+        },
+        "reasoning": "Try again.",
+    })
+    reflector = Reflector(client=fake)  # type: ignore[arg-type]
+    outcome = reflector.reflect(
+        observation=_observation(),
+        planned_step=_planned_step(),
+        step_result=_success_result(),
+        verdict=_not_achieved_verdict(),
+    )
+    assert outcome.replan is True
+    assert "identical" in outcome.reasoning.lower()
+
+
+def test_reflect_degrades_on_client_failure() -> None:
+    from semantic.llm_client import EnrichmentUnavailable
+
+    class _UnavailableClient:
+        def _create_message(self, *args, **kwargs):  # type: ignore[no-untyped-def]
+            raise EnrichmentUnavailable("timeout")
+
+    reflector = Reflector(client=_UnavailableClient())  # type: ignore[arg-type]
+    outcome = reflector.reflect(
+        observation=_observation(),
+        planned_step=_planned_step(),
+        step_result=_success_result(),
+        verdict=_not_achieved_verdict(),
+    )
+    assert outcome.replan is True
+    assert "fallback" in outcome.reasoning.lower()