Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

tests/run_agent/test_interpreter_shutdown_turn_exit.py

@@ -0,0 +1,194 @@
+"""Interpreter-shutdown handling in the conversation loop's outer retry path.
+
+When the process starts tearing down (TUI quit, SIGTERM, one-shot exit) while
+a turn — most commonly the post-turn background-review fork's daemon thread —
+is still mid-request, every further API attempt raises ``RuntimeError:
+cannot schedule new futures after interpreter shutdown``.
+
+Before the fix, the outer loop treated that as a retryable API error: it
+printed an un-gated ``❌ Error during OpenAI-compatible API call #N`` line
+per attempt (spamming the user's shell AFTER the TUI already exited) and
+retried until the iteration budget or interpreter froze the thread.
+
+Now the loop recognizes the shutdown signal via the shared predicate in
+``tools.interpreter_shutdown`` (same class as cron delivery #55924/#58720
+and concurrent tool submission), logs one warning, and abandons the turn —
+no print, no traceback, no retry.
+"""
+
+from types import SimpleNamespace
+
+
+def _text_response(text: str):
+    return SimpleNamespace(
+        choices=[
+            SimpleNamespace(
+                message=SimpleNamespace(content=text, reasoning=None, tool_calls=[]),
+                finish_reason="stop",
+            )
+        ],
+        usage=None,
+    )
+
+
+class _ShutdownThenTextCompletions:
+    """First call raises the CPython shutdown error; later calls would succeed.
+
+    The 'would succeed' part is the sabotage detector: if the loop wrongly
+    retries after the shutdown signal, call #2 returns a normal response and
+    the assertions on call count / failed flag below fail loudly.
+    """
+
+    def __init__(self):
+        self.calls = 0
+
+    def create(self, **kwargs):
+        self.calls += 1
+        if self.calls == 1:
+            raise RuntimeError(
+                "cannot schedule new futures after interpreter shutdown"
+            )
+        return _text_response("should never be reached")
+
+
+class _AlwaysFailingCompletions:
+    def __init__(self):
+        self.calls = 0
+
+    def create(self, **kwargs):
+        self.calls += 1
+        raise Exception("API down")
+
+
+def _make_agent(monkeypatch, completions):
+    from run_agent import AIAgent
+
+    client = SimpleNamespace(chat=SimpleNamespace(completions=completions))
+    monkeypatch.setattr("run_agent.OpenAI", lambda **kwargs: client)
+    monkeypatch.setattr("run_agent.get_tool_definitions", lambda *a, **k: [])
+
+    agent = AIAgent(
+        model="test-model",
+        api_key="test-key",
+        base_url="http://localhost:8080/v1",
+        platform="cli",
+        max_iterations=4,
+        quiet_mode=True,
+        skip_memory=True,
+    )
+    agent._disable_streaming = True
+    return agent
+
+
+def test_shutdown_error_exits_loop_without_retry(monkeypatch, capsys):
+    completions = _ShutdownThenTextCompletions()
+    agent = _make_agent(monkeypatch, completions)
+
+    result = agent.run_conversation("hello")
+
+    # Precondition: the shutdown error actually fired on call #1.
+    assert completions.calls >= 1
+    # The core contract: NO retry after the shutdown signal.
+    assert completions.calls == 1, (
+        "conversation loop retried an API call after interpreter-shutdown "
+        f"signal (made {completions.calls} calls)"
+    )
+    assert result["failed"] is True
+    assert "shutting down" in result["final_response"]
+
+    # And no ❌ spam on the user's terminal.
+    out = capsys.readouterr()
+    assert "❌" not in out.out
+    assert "cannot schedule new futures" not in out.out
+
+
+def test_shutdown_variant_without_interpreter_word_also_exits(monkeypatch):
+    """CPython's plain-ThreadPoolExecutor variant omits 'interpreter'."""
+
+    class _Completions:
+        def __init__(self):
+            self.calls = 0
+
+        def create(self, **kwargs):
+            self.calls += 1
+            raise RuntimeError("cannot schedule new futures after shutdown")
+
+    completions = _Completions()
+    agent = _make_agent(monkeypatch, completions)
+
+    result = agent.run_conversation("hello")
+
+    assert completions.calls == 1
+    assert result["failed"] is True
+
+
+def test_suppress_status_output_gates_error_print_for_ordinary_api_errors(
+    monkeypatch, capsys
+):
+    """suppress_status_output routes ❌ lines to the log, not stdout.
+
+    This is the leak path from the field report: the background-review fork
+    runs with suppress_status_output=True (which gates _vprint and the
+    buffered retry trace), yet the bare print() in the outer error handler
+    bypassed it.
+    """
+    completions = _AlwaysFailingCompletions()
+    agent = _make_agent(monkeypatch, completions)
+    agent.suppress_status_output = True
+
+    result = agent.run_conversation("hello")
+
+    # Precondition: the ordinary (non-shutdown) error path actually retried
+    # up to the budget — this test exercises the print gating, not early exit.
+    assert completions.calls > 1
+    assert "API down" in result["final_response"]
+
+    out = capsys.readouterr()
+    assert "❌" not in out.out
+
+
+def test_non_quiet_mode_still_prints_error(monkeypatch, capsys):
+    completions = _AlwaysFailingCompletions()
+    agent = _make_agent(monkeypatch, completions)
+    agent.quiet_mode = False
+
+    agent.run_conversation("hello")
+
+    out = capsys.readouterr()
+    assert "❌" in out.out
+
+
+class TestSharedPredicate:
+    def test_matches_interpreter_variant(self):
+        from tools.interpreter_shutdown import interpreter_shutting_down
+
+        exc = RuntimeError("cannot schedule new futures after interpreter shutdown")
+        assert interpreter_shutting_down(exc) is True
+
+    def test_matches_plain_executor_variant(self):
+        from tools.interpreter_shutdown import interpreter_shutting_down
+
+        exc = RuntimeError("cannot schedule new futures after shutdown")
+        assert interpreter_shutting_down(exc) is True
+
+    def test_ignores_unrelated_errors(self):
+        from tools.interpreter_shutdown import interpreter_shutting_down
+
+        assert interpreter_shutting_down(RuntimeError("boom")) is False
+        assert interpreter_shutting_down(None) is False
+
+    def test_cron_wrapper_delegates(self):
+        from cron.scheduler import _interpreter_shutting_down
+
+        exc = RuntimeError("cannot schedule new futures after shutdown")
+        assert _interpreter_shutting_down(exc) is True
+        assert _interpreter_shutting_down(RuntimeError("boom")) is False
+
+    def test_tool_executor_wrapper_delegates(self):
+        from agent.tool_executor import _is_interpreter_shutdown_submit_error
+
+        # The tool-executor predicate previously matched ONLY the fuller
+        # variant; via the shared home it now catches both.
+        exc = RuntimeError("cannot schedule new futures after shutdown")
+        assert _is_interpreter_shutdown_submit_error(exc) is True
+        assert _is_interpreter_shutdown_submit_error(RuntimeError("boom")) is False