hermes-agent/tests/agent/test_recovery_diagnostic_producers.py
Victor Kyriazakos cd3de040ab feat(notifications): opt-in suppression of user-channel warning notifications
Squash of the 54 commits on victor-kyriazakos:feat/user-channel-warning-suppression
(PR #112302, head f45c640e55) so the contributor's authorship survives a rebase-merge;
the commits interleave with a cron delivery-ledger rework that the salvage removes in
follow-up commits, so per-commit cherry-picks were not practical.

Adds display.suppress_warning_notifications (global + per-platform, default false):
one resolver (gateway/warning_notifications.py), BasePlatformAdapter.emit_warning /
emit_media_warning / warning_text, a notification_category classification carried
through wakes, queues and persistence, and render/present boundaries for CLI/TUI.
2026-09-18 01:43:35 +05:30

114 lines
5.3 KiB
Python

"""Real recovery producers retain work/evidence while hiding diagnostic copies."""
import json
from unittest.mock import patch
import pytest
from agent.status_output import StatusOutputMixin
from agent.turn_overflow import _Recovery, _recover_payload_too_large
from agent.turn_retry_state import TurnRetryState
class Agent(StatusOutputMixin):
log_prefix = ""
platform = "cli"
suppress_status_output = False
_mute_post_response = False
_executing_tools = False
model = "fixture"
tools = []
max_iterations = 1
def __init__(self):
self.printed, self.observed, self.persisted = [], [], []
self._print_fn = lambda *a, **k: self.printed.append(" ".join(map(str, a)))
self.status_callback = lambda k, t: self.observed.append((k, t))
def _has_stream_consumers(self):
return False
def _compress_context(self, messages, *a, **k):
return self.compressed, "system"
def _persist_session(self, *args):
self.persisted.append(args)
@pytest.fixture(params=[None, False, True])
def policy(request, tmp_path, monkeypatch):
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
monkeypatch.setenv("HERMES_MANAGED_DIR", str(tmp_path / "managed"))
config = {} if request.param is None else {"display": {"suppress_warning_notifications": request.param}}
(tmp_path / "config.yaml").write_text(json.dumps(config))
return request.param is True
@pytest.mark.parametrize("local", [False, True])
def test_outer_loop_diagnostic_preserves_verdict_and_trace(policy, local, capsys, caplog):
from agent.turn_loop_errors import handle_outer_loop_error
import agent.conversation_loop as loop
agent = Agent()
# Traceback classification executes normally using a real frame filename.
with patch.object(loop, "_LOCAL_PROCESSING_MODULES", {"test_recovery_diagnostic_producers"} if local else set()):
try:
raise RuntimeError("raw engine diagnostic detail")
except RuntimeError as exc:
verdict = handle_outer_loop_error(agent, e=exc, _outer_error_count=0,
api_call_count=1, messages=[], conversation_history=[],
_turn_exit_reason=None, failed=False, final_response="")
output = capsys.readouterr().out + "\n".join(agent.printed)
assert ("raw engine diagnostic detail" in output) is not policy
assert verdict.action == "break"
assert bool(verdict.final_response)
assert verdict.failed is (not local)
assert "Outer loop error" in caplog.text
assert "raw engine diagnostic detail" in caplog.text
def test_missing_requirements_keeps_tool_inventory(policy, monkeypatch, capsys):
from agent.agent_init import _load_tools
import model_tools
agent = Agent()
agent.quiet_mode = agent.save_trajectories = agent._use_prompt_caching = False
agent.ephemeral_system_prompt = None
monkeypatch.setattr("hermes_cli.plugins.discover_plugins", lambda: None)
monkeypatch.setattr(model_tools, "get_tool_definitions", lambda **kw: [{"function": {"name": "offline_tool"}}])
monkeypatch.setattr(model_tools, "check_toolset_requirements", lambda: {"fixture_dependency": False})
_load_tools(agent, None, None)
output = capsys.readouterr().out + "\n".join(agent.printed)
assert ("Some tools may not work due to missing requirements" in output) is not policy
assert "Loaded 1 tools" in output
assert agent.valid_tool_names == {"offline_tool"}
@pytest.mark.parametrize("shape", ["message_count", "token_count", "payload_bytes"])
def test_retry_buffer_classification_survives_terminal_flush(policy, shape, monkeypatch):
from gateway.warning_notifications import DiagnosticText
agent = Agent()
messages = [{"role": "user", "content": "a" * 4000}, {"role": "assistant", "content": "b" * 4000}]
agent.compressed = messages[:1] if shape == "message_count" else [
{"role": m["role"], "content": m["content"][:10]} for m in messages]
st = _Recovery(agent=agent, messages=messages, api_messages=messages,
system_message="system", active_system_prompt="system", conversation_history=[],
approx_tokens=2000, compression_attempts=0, effective_task_id="offline",
api_call_count=1, max_compression_attempts=3)
retry = TurnRetryState()
monkeypatch.setattr("agent.conversation_compression.conversation_history_after_compression", lambda a, m, h: h)
monkeypatch.setattr("agent.turn_overflow.time.sleep", lambda _: None)
if shape == "payload_bytes":
_recover_payload_too_large(st, retry)
assert retry.restart_with_compressed_messages
else:
_, shrank, _ = st.compress_scored_by_tokens(2000)
assert shrank
assert agent._retry_status_buffer
assert all(isinstance(text, DiagnosticText) for _, text in agent._retry_status_buffer)
outcome = st.fail_turn("Requested task failed.", notices=("diagnostic terminal detail",), log=("offline terminal failure",))
assert outcome.result["failed"] is True
assert outcome.result["final_response"] == "Requested task failed."
assert len(agent.persisted) == 1
assert not agent._retry_status_buffer
assert bool(agent.printed) is not policy
assert agent.observed # operator callback retained even when presentation hides
agent.printed.clear()
agent._emit_status("ordinary compaction progress")
assert agent.printed == ["ordinary compaction progress"]