Skip to content

The agent that grows with you

4.4 KB
Raw Blame
"""Diagnostic suppression preserves real producer outcomes and control paths."""

import asyncio
from decimal import Decimal
from types import SimpleNamespace
from unittest.mock import AsyncMock, patch

import pytest

from agent import empty_response_guard
from agent.status_output import StatusOutputMixin
from agent.turn_api_call import nous_rate_limit_guard
from agent.turn_empty_response import _terminal_empty
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


class Agent(StatusOutputMixin):
    suppress_status_output = True
    log_prefix = ""
    provider = "nous"
    model = "model"
    base_url = "https://example.invalid/v1"
    _fallback_chain = []
    _empty_content_retries = 3

    def _try_activate_fallback(self):
        return False

    def _persist_session(self, *args):
        self.persisted = True

    def _extract_reasoning(self, *args):
        return ""

    def _drop_trailing_empty_response_scaffolding(self, *args):
        pass

    def _build_assistant_message(self, *args):
        return {"role": "assistant"}


@pytest.mark.parametrize("enabled", [False, True])
def test_real_retry_producers_keep_final_failure_and_persistence(tmp_path, monkeypatch, caplog, enabled):
    from gateway import run

    (tmp_path / "config.yaml").write_text(f"display: {{suppress_warning_notifications: {str(not enabled).lower()}}}")
    monkeypatch.setattr(run, "_hermes_home", tmp_path)
    sent = []
    async def send(chat_id, text, **kwargs):
        sent.append(text)
        return SimpleNamespace(success=True)
    adapter = SimpleNamespace(send=send)
    source = SessionSource(platform=Platform.SLACK, chat_id="D1", user_id="U1")
    gateway = object.__new__(GatewayRunner)
    ctx = TurnContext(source=source, user_config=_load_gateway_config(), _run_still_current=lambda: True,
                      _status_adapter=adapter, _status_chat_id="D1", _status_thread_metadata={})
    agent = Agent()
    agent.status_callback = TurnRunner(gateway, ctx)._status_callback_sync
    monkeypatch.setattr(run, "safe_schedule_threadsafe", lambda coro, *a, **k: asyncio.run(coro))
    setattr(agent, empty_response_guard._STREAK_COST_ATTR, Decimal("1.25"))
    messages = []
    final = _terminal_empty(agent, SimpleNamespace(), "stop", messages)
    assert bool(sent) is enabled
    assert messages[-1]["_empty_terminal_sentinel"] is True
    assert "Empty response" in caplog.text
    result = {"final_response": final, "messages": messages, "failed": True}
    response, silent, _ = asyncio.run(gateway._hmwa_shape_agent_response(
        result, source, [], SimpleNamespace(session_id="session"), None, None, None, "session", "slack", 0))
    assert response and response != "(empty)" and not silent
    sent.clear()
    with patch("agent.nous_rate_guard.nous_rate_limit_remaining", return_value=60), \
         patch("hermes_cli.anon_auth.apply_model_switch"), \
         patch("hermes_cli.anon_auth.route_is_welcome_host", return_value=False):
        verdict = nous_rate_limit_guard(agent, _retry=SimpleNamespace(), api_messages=[], messages=[],
            conversation_history=[], active_system_prompt="", retry_count=0, compression_attempts=0, api_call_count=0)
    assert bool(sent) is enabled
    assert verdict.result["failed"] and agent.persisted
    assert "/retry" in verdict.result["final_response"]
    assert not agent._retry_status_buffer


@pytest.mark.parametrize("yaml_text,expected", [
    ("display: broken", True), ("display: [broken]", True),
    ("display: {platforms: broken}", True),
    ("display: {suppress_warning_notifications: true, platforms: broken}", False),
])
def test_bad_config_containers_do_not_abort_startup_warning(tmp_path, monkeypatch, yaml_text, expected):
    from gateway import run

    (tmp_path / "config.yaml").write_text(yaml_text)
    monkeypatch.setenv("HERMES_HOME", str(tmp_path))
    monkeypatch.setattr(run, "_hermes_home", tmp_path)
    gateway = object.__new__(GatewayRunner)
    gateway._session_db_init_error = "database is locked"
    gateway._session_db_handle_cache = None
    gateway._home_channel_transports = lambda: [(Platform.SLACK, None, None, None)]
    gateway._send_home_channel_message = AsyncMock()
    asyncio.run(gateway._send_session_db_warning_notifications())
    assert gateway._send_home_channel_message.await_count == int(expected)