Skip to content

"Vibe-Trading: Your Personal Trading Agent"

test(loop): cover the run-stall watchdog state transitions

Haozhe Wub8a018545e71
diff --git a/agent/tests/test_agent_loop_stall_watchdog.py b/agent/tests/test_agent_loop_stall_watchdog.py
new file mode 100644
index 000000000..d0e6a7d35
--- /dev/null
+++ b/agent/tests/test_agent_loop_stall_watchdog.py
@@ -0,0 +1,185 @@
+"""Behaviour tests for the run-stall watchdog.
+
+The watchdog is the only thing that ends a run hung inside a tool or a
+provider call, so its state transitions are covered here directly rather
+than through a full ``run()``: a zombie run writes no ``state.json`` and no
+``end`` trace record, which is exactly what these tests assert it now does.
+"""
+
+from __future__ import annotations
+
+import json
+import threading
+import time
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from src.agent.loop import AgentLoop
+from src.agent.tools import ToolRegistry
+from src.agent.trace import TraceWriter
+from src.core.state import RunStateStore
+
+
+class _FastEvent(threading.Event):
+ """An Event whose ``wait`` never actually sleeps.
+
+ The watchdog polls on a five-second floor, so a real wait would make
+ every test in this file take ten seconds to observe two iterations.
+ Collapsing the sleep keeps the watchdog's own logic under test.
+ """
+
+ def wait(self, timeout: float | None = None) -> bool:
+ return super().wait(0.01)
+
+
+def loop_and_run_dir(tmp_path: Path) -> tuple[AgentLoop, Path]:
+ """Build an AgentLoop with a real run directory and a fast done-event."""
+ agent = AgentLoop(registry=ToolRegistry(), llm=SimpleNamespace(), max_iterations=1)
+ run_dir = tmp_path / "run"
+ run_dir.mkdir()
+ agent.memory.run_dir = str(run_dir)
+ agent._run_done = _FastEvent()
+ return agent, run_dir
+
+
+def _events(agent: AgentLoop) -> list[tuple[str, dict]]:
+ """Attach a capturing event callback and return the list it fills."""
+ captured: list[tuple[str, dict]] = []
+ agent._event_callback = lambda name, data: captured.append((name, data))
+ return captured
+
+
+def test_watchdog_fails_a_run_with_no_forward_progress(
+ loop_and_run_dir: tuple[AgentLoop, Path],
+) -> None:
+ """No LLM completion and no tool result must end the run as failed."""
+ agent, run_dir = loop_and_run_dir
+ captured = _events(agent)
+ agent._last_activity_wall = time.time() - 10_000
+ trace = TraceWriter(run_dir)
+
+ agent._stall_watchdog(trace, run_dir, RunStateStore(), stall_timeout=1.0)
+ trace.close()
+
+ names = [name for name, _ in captured]
+ assert names == ["stall_warning", "stalled"]
+ assert agent._stall_reason is not None
+ assert "stall watchdog" in agent._stall_reason
+ # The loop must exit at its next boundary rather than stay "running".
+ assert agent._cancel_event.is_set()
+
+ state = json.loads((run_dir / "state.json").read_text(encoding="utf-8"))
+ assert state["status"] == "failed"
+ assert "stall watchdog" in state["reason"]
+
+ end_records = [rec for rec in TraceWriter.read(run_dir) if rec.get("type") == "end"]
+ assert len(end_records) == 1
+ assert end_records[0]["status"] == "failed"
+ assert end_records[0]["stalled"] is True
+
+
+def test_forward_progress_clears_the_pending_warning(
+ loop_and_run_dir: tuple[AgentLoop, Path],
+) -> None:
+ """A warned-but-recovered run must warn afresh, never fail on the stale flag.
+
+ Guards the ``warned = False`` reset: without it, one warning plus any
+ later idle poll would fail a run that had made progress in between.
+ """
+ agent, run_dir = loop_and_run_dir
+ captured = _events(agent)
+ trace = TraceWriter(run_dir)
+ agent._last_activity_wall = time.time() - 10_000
+
+ polls = {"n": 0}
+ original_wait = agent._run_done.wait
+
+ def _wait(timeout: float | None = None) -> bool:
+ # Poll 1: idle -> warn. Poll 2: progress just landed -> reset.
+ # Poll 3: idle again -> must warn a second time, not fail.
+ polls["n"] += 1
+ if polls["n"] == 2:
+ agent._last_activity_wall = time.time()
+ elif polls["n"] == 3:
+ agent._last_activity_wall = time.time() - 10_000
+ elif polls["n"] >= 4:
+ agent._run_done.set()
+ return original_wait(timeout)
+
+ agent._run_done.wait = _wait # type: ignore[method-assign]
+ agent._stall_watchdog(trace, run_dir, RunStateStore(), stall_timeout=1.0)
+ trace.close()
+
+ assert [name for name, _ in captured] == ["stall_warning", "stall_warning"]
+ assert agent._stall_reason is None
+ assert not agent._cancel_event.is_set()
+ assert not (run_dir / "state.json").exists()
+
+
+def test_watchdog_exits_when_the_run_completes(
+ loop_and_run_dir: tuple[AgentLoop, Path],
+) -> None:
+ """A finished run must not be touched, however long it was idle."""
+ agent, run_dir = loop_and_run_dir
+ captured = _events(agent)
+ agent._last_activity_wall = time.time() - 10_000
+ agent._run_done.set()
+ trace = TraceWriter(run_dir)
+
+ agent._stall_watchdog(trace, run_dir, RunStateStore(), stall_timeout=1.0)
+ trace.close()
+
+ assert captured == []
+ assert agent._stall_reason is None
+ assert not agent._cancel_event.is_set()
+ assert not (run_dir / "state.json").exists()
+
+
+def test_watchdog_of_a_finished_run_does_not_fail_the_next_one(
+ loop_and_run_dir: tuple[AgentLoop, Path],
+) -> None:
+ """A reused AgentLoop must not let run N's watchdog kill run N+1.
+
+ The thread captures its done-event locally, so replacing
+ ``self._run_done`` for the next run leaves the old watchdog watching the
+ old event -- which is already set.
+ """
+ agent, run_dir = loop_and_run_dir
+ captured = _events(agent)
+ first_run_done = agent._run_done
+ agent._last_activity_wall = time.time() - 10_000
+ trace = TraceWriter(run_dir)
+
+ original_wait = first_run_done.wait
+
+ def _wait(timeout: float | None = None) -> bool:
+ # Run 1 finishes and run 2 installs a fresh event mid-poll. Watching
+ # ``self._run_done`` instead of the captured local would now see an
+ # unset event and fail run 2 on run 1's idle clock.
+ first_run_done.set()
+ agent._run_done = _FastEvent()
+ agent._last_activity_wall = time.time() - 10_000
+ return original_wait(timeout)
+
+ first_run_done.wait = _wait # type: ignore[method-assign]
+ agent._stall_watchdog(trace, run_dir, RunStateStore(), stall_timeout=1.0)
+ trace.close()
+
+ assert captured == []
+ assert agent._stall_reason is None
+ assert not agent._cancel_event.is_set()
+ assert not (run_dir / "state.json").exists()
+
+
+def test_stall_timeout_env_alias_resolves_and_zero_disables() -> None:
+ """The documented off switch must be reachable by its real env name."""
+ from src.config.env_schema import AgentTuningConfig
+
+ assert AgentTuningConfig().vibe_trading_run_stall_timeout_seconds == 1800.0
+ disabled = AgentTuningConfig(VIBE_TRADING_RUN_STALL_TIMEOUT_SECONDS="0")
+ assert disabled.vibe_trading_run_stall_timeout_seconds == 0.0
+ tightened = AgentTuningConfig(VIBE_TRADING_RUN_STALL_TIMEOUT_SECONDS="600")
+ assert tightened.vibe_trading_run_stall_timeout_seconds == 600.0