Files
hermes-agent/tests/agent/test_compression_refusal_restores_transcript.py
yoniebans ab842ab611 test(agent): agent cases over the persistence interface
The agent tests seed and read the store through the storage fixtures.
2026-11-17 17:51:20 +01:00

165 lines
6.3 KiB
Python

"""Regression: a refused compression candidate hands back the original transcript.
Context engines may mutate the message list they receive (the documented legacy
contract), and that mutation must only become visible if the pass commits. Callers
that pass their own commit fence (gateway session hygiene) or disable the
compression timeout hand the live list to the engine without the facade's deep
snapshot, so every refusal in ``compress_context`` has to put the pre-compression
snapshot back before returning. The compressor-abort, empty-transcript and
would-grow refusals returned the mutated list instead.
"""
from __future__ import annotations
import json
import logging
import os
from pathlib import Path
from unittest.mock import patch
import pytest
from agent.conversation_compression import CompressionCommitFence
from tests.fixtures.storage_holder import raw_holder
from tests.fixtures.storage_read import session_row
from tests.fixtures.storage_seed import seed_session
from tests.gateway.fixtures.storage_handles import close_storage_handles, storage_handle
def _build_agent(db, session_id: str):
with patch.dict(os.environ, {"OPENROUTER_API_KEY": "test-key"}):
from run_agent import AIAgent
agent = AIAgent(
api_key="test-key",
base_url="https://openrouter.ai/api/v1",
model="test/model",
quiet_mode=True,
persistence=db,
session_id=session_id,
skip_context_files=True,
skip_memory=True,
)
# Skip the one-time aux-model feasibility probe (may hit the network).
agent._compression_feasibility_checked = True
return agent
def _aborting_engine(compressor):
def _compress(msgs, **_kw):
msgs.clear()
compressor._last_compress_aborted = True
compressor._last_summary_error = "summary provider unavailable"
return msgs
return _compress
def _empty_transcript_engine(_compressor):
def _compress(msgs, **_kw):
msgs.clear()
return []
return _compress
def _growing_engine(compressor):
def _compress(msgs, **_kw):
# A real compressor records the candidate's effect before the commit checks see it.
compressor._active_compression_telemetry = compressor._last_compression_telemetry = (
compressor._begin_compression_telemetry(current_tokens=120_000)
)
compressor._active_compression_telemetry.update(messages_after=2, tokens_after=9, tokens_reclaimed=99)
msgs.pop()
return list(msgs) + [{"role": "assistant", "content": "GROWN " * 20_000}]
return _compress
def _growing_in_place_engine(_compressor):
def _compress(msgs, **_kw):
msgs[:] = [{"role": "assistant", "content": "GROWN " * 20_000}]
return msgs
return _compress
def _raising_engine(_compressor):
def _compress(msgs, **_kw):
msgs.clear()
raise RuntimeError("context engine failed")
return _compress
@pytest.mark.parametrize(
"make_engine",
[_aborting_engine, _empty_transcript_engine, _growing_engine, _growing_in_place_engine],
ids=["compressor_aborted", "empty_transcript", "would_grow", "would_grow_in_place"],
)
def test_refused_candidate_from_mutating_engine_returns_original_transcript(
tmp_path: Path, make_engine, caplog
) -> None:
db = storage_handle(tmp_path)
session_id = "REFUSED_CANDIDATE"
seed_session(db, session_id, "test")
agent = _build_agent(db, session_id)
compressor = agent.context_compressor
messages = [{"role": "user", "content": f"m{i} " + "x" * 200} for i in range(21)]
original = [dict(m) for m in messages]
try:
with patch.object(type(compressor), "compress", side_effect=make_engine(compressor)), patch.object(
agent, "commit_memory_session", wraps=agent.commit_memory_session
) as commit_memory_session, patch.object(
db.messages, "compact", wraps=db.messages.compact
) as compact:
# A caller-owned fence selects the direct path that gateway session hygiene uses.
with caplog.at_level(logging.INFO, logger="agent.conversation_compression"):
returned, _sp = agent._compress_context(
messages, "sys", approx_tokens=120_000, commit_fence=CompressionCommitFence()
)
commit_memory_session.assert_not_called()
compact.assert_not_called()
assert returned == original
assert messages == original
assert agent.session_id == session_id
with raw_holder(db)._read_ctx() as conn:
assert conn.execute(
"SELECT COUNT(*) FROM sessions WHERE parent_session_id = ?", (session_id,)
).fetchone()[0] == 0
assert session_row(db, session_id)["end_reason"] is None
assert db.coordination.get_compression_lock_holder(session_id=session_id) is None
# The record must not claim an effect the refused candidate never had on the transcript.
prefix = "context compression attempt telemetry: "
[record] = [json.loads(r.getMessage()[len(prefix):]) for r in caplog.records if r.getMessage().startswith(prefix)]
assert record["commit_status"] == "aborted"
assert [record.get(k) for k in ("messages_after", "tokens_after", "tokens_reclaimed")] == [None] * 3
finally:
agent.close()
def test_raising_mutating_engine_restores_original_transcript(tmp_path: Path) -> None:
db = storage_handle(tmp_path)
session_id = "RAISING_ENGINE"
seed_session(db, session_id, "test")
agent = _build_agent(db, session_id)
compressor = agent.context_compressor
messages = [{"role": "user", "content": f"m{i} " + "x" * 200} for i in range(21)]
original = [dict(m) for m in messages]
try:
with patch.object(type(compressor), "compress", side_effect=_raising_engine(compressor)):
with pytest.raises(RuntimeError, match="context engine failed"):
agent._compress_context(
messages, "sys", approx_tokens=120_000, commit_fence=CompressionCommitFence()
)
assert messages == original
assert agent.session_id == session_id
assert session_row(db, session_id)["end_reason"] is None
assert db.coordination.get_compression_lock_holder(session_id=session_id) is None
finally:
agent.close()