mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-17 04:11:35 +00:00
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.
114 lines
5.3 KiB
Python
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"]
|