The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Warning delivery is independent of normal replies and operational state."""
import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock
import pytest
from agent.credits_tracker import AgentNotice
from agent.status_output import StatusOutputMixin
from gateway.config import Platform
from gateway.run import GatewayRunner, _load_gateway_config
from gateway.run_turn_runner import TurnRunner
from gateway.session import SessionSource
from gateway.turn_context import TurnContext
from tests.gateway.test_session_hygiene import HygieneCaptureAdapter
class RecordingAdapter(HygieneCaptureAdapter):
config = SimpleNamespace(extra={})
def __init__(self):
super().__init__()
self.sent = []
async def send(self, chat_id, content, **kwargs):
self.sent.append((chat_id, content, kwargs))
return SimpleNamespace(success=True, message_id=str(len(self.sent)))
class Emitter(StatusOutputMixin):
suppress_status_output = True
log_prefix = ""
@pytest.mark.parametrize("platform", [Platform.SLACK, Platform.TELEGRAM, Platform.LOCAL])
@pytest.mark.parametrize("configured,enabled", [
("", True), ("display: null", True),
("display: {suppress_warning_notifications: null}", True),
("display: {suppress_warning_notifications: true}", False),
('display: {suppress_warning_notifications: "true"}', False),
("display: {suppress_warning_notifications: typo}", True),
("display: {suppress_warning_notifications: []}", True),
("display: broken", True),
("display: [broken]", True),
("display: {platforms: broken}", True),
("display: {suppress_warning_notifications: true, platforms: {slack: {suppress_warning_notifications: false}}}", True),
])
def test_warning_opt_out_preserves_other_delivery(tmp_path, monkeypatch, platform, configured, enabled):
from gateway import run
thread_id = "1700.1" # threaded vs. unthreaded delivery is covered in test_warning_notifications_transport
(tmp_path / "config.yaml").write_text(configured)
monkeypatch.setattr(run, "_hermes_home", tmp_path)
config = _load_gateway_config()
if "platforms: {slack" in configured and platform != Platform.SLACK:
enabled = False
adapter = RecordingAdapter()
source = SessionSource(platform=platform, chat_id="chat", user_id="user", thread_id=thread_id)
gateway = object.__new__(GatewayRunner)
gateway.config = None
gateway._delivery_adapter_for = lambda source: adapter
gateway._thread_metadata_for_source = lambda source: {"thread_id": source.thread_id} if source.thread_id else {}
ctx = TurnContext(source=source, user_config=config, _run_still_current=lambda: True,
_status_adapter=adapter, _status_chat_id=source.chat_id,
_status_thread_metadata=gateway._thread_metadata_for_source(source))
turn = TurnRunner(gateway, ctx)
monkeypatch.setattr(run, "safe_schedule_threadsafe", lambda coro, *a, **k: asyncio.run(coro))
emitter = Emitter()
emitter.status_callback = turn._status_callback_sync
emitter.notice_callback = turn._notice_callback_sync
# These are engine rails, not text filtering on the adapter's general send.
diagnostics = [
("warn", "Context overflow blocked; use /compress"),
("lifecycle", "⚠ Compression aborted: summary failed; history preserved"),
("lifecycle", "↻ Switched to fallback: secondary (provider)"),
("lifecycle", "Content filter terminated stream; switching to fallback..."),
("lifecycle", "🔐 Authentication failed and could not be refreshed — switching to fallback provider..."),
("lifecycle", "ℹ️ Estimated cost of these empty attempts: ~$1.25"),
("lifecycle", "⏳ Your Nous account has hit its rate limit; it resets in 1m."),
("lifecycle", "📐 Compression could not reduce the request further — removed retained vision payloads and retrying..."),
]
for kind, text in diagnostics:
if kind == "warn":
emitter._emit_warning(text)
else:
emitter._emit_diagnostic_status(text)
emitter._pending_fallback_notice = "↻ Switched to fallback: secondary (provider)"
emitter._emit_pending_fallback_notice()
assert emitter._pending_fallback_notice is None
emitter._emit_notice(AgentNotice("Credit access paused", level="error", key="credits.depleted"))
turn.progress_callback("subagent.complete", status="failed", goal="research", summary="provider unavailable")
warning_count = len(diagnostics) + 3
assert len(adapter.sent) == (warning_count if enabled else 0)
emitter._emit_status("still on it")
asyncio.run(gateway._deliver_platform_notice(source, "No home channel is set"))
for text in ("⚠ The requested analysis", "Approval required", "Compression aborted: manual command result", "The task failed"):
asyncio.run(adapter.send(source.chat_id, text))
assert len(adapter.sent) == (warning_count if enabled else 0) + 6
assert all(row[0] == source.chat_id for row in adapter.sent)
@pytest.mark.parametrize("enabled", [True, False])
def test_direct_warning_delivery_keeps_failure_state(tmp_path, monkeypatch, enabled):
from gateway import run
(tmp_path / "config.yaml").write_text(f"display: {{suppress_warning_notifications: {str(not enabled).lower()}}}")
monkeypatch.setenv("HERMES_HOME", str(tmp_path))
monkeypatch.setattr(run, "_hermes_home", tmp_path)
adapter = RecordingAdapter()
source = SessionSource(platform=Platform.SLACK, chat_id="chat", user_id="user")
gateway = object.__new__(GatewayRunner)
gateway._delivery_adapter_for = lambda source: adapter
gateway._session_db_init_error = "database is locked"
gateway._session_db_handle_cache = None
gateway._home_channel_transports = lambda: [(Platform.SLACK, None, SimpleNamespace(chat_id="chat"), adapter)]
gateway._send_home_channel_message = AsyncMock()
asyncio.run(gateway._hmwa_hygiene_notify(source, {}, "Compression failed", "failure"))
asyncio.run(gateway._run_agent_inactivity_warning(SimpleNamespace(agent_warning=60, agent_timeout=120), source, {}))
asyncio.run(gateway._send_session_db_warning_notifications())
assert len(adapter.sent) == (2 if enabled else 0)
assert gateway._send_home_channel_message.await_count == int(enabled)
assert gateway._session_db_init_error == "database is locked"