Skip to content

The agent that grows with you

3.6 KB
Raw Blame
"""A child whose worker never returns after the heartbeat declares it stale must not hold
the parent forever (#109749: sync delegation in a -Q one-shot kept the Bot Chat lease)."""

from __future__ import annotations

import threading
from types import SimpleNamespace

from tools import delegate_tool


class _WedgedAfterFinalAnswer:
    """Frozen activity (final answer already written); the worker only unwinds when released."""

    def __init__(self) -> None:
        self.tool_progress_callback = None
        self._credential_pool = None
        self._delegate_saved_tool_names = []
        self._delegate_role = "leaf"
        self._delegate_depth = 1
        self._subagent_id = None
        self.session_id = "wedged-child"
        self.release = threading.Event()
        self.interrupted = threading.Event()

    def run_conversation(self, **_kwargs):
        self.release.wait()
        return {"final_response": "VERDICT", "completed": True, "api_calls": 28, "messages": []}

    def get_activity_summary(self):
        return {"api_call_count": 28, "current_tool": None, "last_activity_ts": 1000.0, "max_iterations": 50}

    def hard_interrupt(self, *_args, **_kwargs):
        self.interrupted.set()

    def close(self):
        self.release.set()


def test_stale_heartbeat_ends_the_wait_without_a_configured_timeout(monkeypatch):
    child = _WedgedAfterFinalAnswer()
    parent = SimpleNamespace(
        session_id="parent", _current_task_id=None, _active_children=[child],
        _active_children_lock=threading.Lock(), _touch_activity=lambda _d: None, _interrupt_requested=False,
    )
    monkeypatch.setattr(delegate_tool, "_HEARTBEAT_INTERVAL", 0.01)
    monkeypatch.setattr(delegate_tool, "_HEARTBEAT_STALE_CYCLES_IDLE", 2)
    monkeypatch.setattr(delegate_tool, "_get_child_timeout", lambda: None)
    monkeypatch.setattr(delegate_tool, "_get_worktree_isolation", lambda: False)
    # Safety valve so an unfixed tree fails (status "completed") instead of hanging the suite.
    valve = threading.Timer(30.0, child.release.set)
    valve.daemon = True
    valve.start()
    try:
        entry = delegate_tool._run_single_child(0, "review", child=child, parent_agent=parent)
    finally:
        valve.cancel()
        child.release.set()

    assert entry["status"] == "timeout", entry
    assert "stopped making progress" in entry["error"]
    assert child.interrupted.is_set()


def test_stale_verdict_under_a_configured_cap_reports_the_stale_threshold_not_the_cap(monkeypatch):
    """The stale verdict pre-empts the cap, so the entry must name the threshold that actually ended
    the wait — not a 3600s cap the child never reached."""
    child = _WedgedAfterFinalAnswer()
    parent = SimpleNamespace(
        session_id="parent", _current_task_id=None, _active_children=[child],
        _active_children_lock=threading.Lock(), _touch_activity=lambda _d: None, _interrupt_requested=False,
    )
    monkeypatch.setattr(delegate_tool, "_HEARTBEAT_INTERVAL", 0.01)
    monkeypatch.setattr(delegate_tool, "_HEARTBEAT_STALE_CYCLES_IDLE", 2)
    monkeypatch.setattr(delegate_tool, "_get_child_timeout", lambda: 3600)
    monkeypatch.setattr(delegate_tool, "_get_worktree_isolation", lambda: False)
    valve = threading.Timer(30.0, child.release.set)
    valve.daemon = True
    valve.start()
    try:
        entry = delegate_tool._run_single_child(0, "review", child=child, parent_agent=parent)
    finally:
        valve.cancel()
        child.release.set()

    assert entry["status"] == "timeout", entry
    assert "stopped making progress" in entry["error"] and "3600" not in entry["error"], entry["error"]
    assert entry["timeout_seconds"] == 2 * 0.01