"""Tests for payload/context-length → compression retry logic in AIAgent. Verifies that: - HTTP 413 errors trigger history compression and retry - HTTP 400 context-length errors trigger compression (not generic 4xx abort) - Preflight compression proactively compresses oversized sessions before API calls """ import pytest #pytestmark = pytest.mark.skip(reason="Hangs in non-interactive environments") from types import SimpleNamespace from unittest.mock import MagicMock, patch from agent.context_compressor import SUMMARY_PREFIX from run_agent import AIAgent import run_agent # --------------------------------------------------------------------------- # Fast backoff for compression retry tests # --------------------------------------------------------------------------- @pytest.fixture(autouse=True) def _no_compression_sleep(monkeypatch): """Short-circuit the 2s time.sleep between compression retries. Production code has ``time.sleep(2)`` in multiple places after a 413/context compression, for rate-limit smoothing. Tests assert behavior, not timing. """ import time as _time monkeypatch.setattr(_time, "sleep", lambda *_a, **_k: None) monkeypatch.setattr(run_agent, "jittered_backoff", lambda *a, **k: 0.0) # --------------------------------------------------------------------------- # Helpers # --------------------------------------------------------------------------- def _make_tool_defs(*names: str) -> list: return [ { "type": "function", "function": { "name": n, "description": f"{n} tool", "parameters": {"type": "object", "properties": {}}, }, } for n in names ] def _mock_response(content="Hello", finish_reason="stop", tool_calls=None, usage=None): msg = SimpleNamespace( content=content, tool_calls=tool_calls, reasoning_content=None, reasoning=None, ) choice = SimpleNamespace(message=msg, finish_reason=finish_reason) resp = SimpleNamespace(choices=[choice], model="test/model") resp.usage = SimpleNamespace(**usage) if usage else None return resp def _make_413_error(*, use_status_code=True, message="Request entity too large"): """Create an exception that mimics a 413 HTTP error.""" err = Exception(message) if use_status_code: err.status_code = 413 return err @pytest.fixture() def agent(): with ( patch("run_agent.get_tool_definitions", return_value=_make_tool_defs("web_search")), patch("run_agent.check_toolset_requirements", return_value={}), patch("run_agent.OpenAI"), ): a = AIAgent( api_key="test-key-1234567890", base_url="https://openrouter.ai/api/v1", quiet_mode=True, skip_context_files=True, skip_memory=True, ) a.client = MagicMock() a._cached_system_prompt = "You are helpful." a._use_prompt_caching = False a.tool_delay = 0 # Default matches production (`compression.enabled` defaults to True). # Overflow-recovery tests below verify that 413 / context-overflow # errors DO trigger compression; the disabled-path behavior is # covered explicitly by TestOverflowWithCompactionDisabled. a.compression_enabled = True a.save_trajectories = False return a # --------------------------------------------------------------------------- # Tests # --------------------------------------------------------------------------- def test_current_user_turn_is_persisted_before_provider_call(agent): """The inbound user turn is flushed before provider/tool work can crash.""" observed = [] def _record_persist(messages, conversation_history): observed.append(("persist", list(messages), list(conversation_history or []))) def _provider_crash(*_args, **_kwargs): observed.append(("provider", [], [])) raise RuntimeError("provider died after turn-start persistence") agent.client.chat.completions.create.side_effect = _provider_crash with ( patch.object(agent, "_persist_session", side_effect=_record_persist), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): result = agent.run_conversation( "new message that must survive a crash", conversation_history=[{"role": "user", "content": "old message"}], ) assert result.get("failed") is True assert observed[0][0] == "persist" assert observed[1][0] == "provider" persisted_messages = observed[0][1] assert persisted_messages[-1] == { "role": "user", "content": "new message that must survive a crash", } class TestHTTP413Compression: """413 errors should trigger compression, not abort as generic 4xx.""" def test_413_triggers_compression(self, agent): """A 413 error should call _compress_context and retry, not abort.""" # First call raises 413; second call succeeds after compression. err_413 = _make_413_error() ok_resp = _mock_response(content="Success after compression", finish_reason="stop") agent.client.chat.completions.create.side_effect = [err_413, ok_resp] # Prefill so there are multiple messages for compression to reduce prefill = [ {"role": "user", "content": "previous question"}, {"role": "assistant", "content": "previous answer"}, ] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): # Compression reduces 3 messages down to 1 mock_compress.return_value = ( [{"role": "user", "content": "hello"}], "compressed prompt", ) result = agent.run_conversation("hello", conversation_history=prefill) mock_compress.assert_called_once() assert result["completed"] is True assert result["final_response"] == "Success after compression" def test_413_not_treated_as_generic_4xx(self, agent): """413 must NOT hit the generic 4xx abort path; it should attempt compression.""" err_413 = _make_413_error() ok_resp = _mock_response(content="Recovered", finish_reason="stop") agent.client.chat.completions.create.side_effect = [err_413, ok_resp] prefill = [ {"role": "user", "content": "previous question"}, {"role": "assistant", "content": "previous answer"}, ] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "hello"}], "compressed", ) result = agent.run_conversation("hello", conversation_history=prefill) # If 413 were treated as generic 4xx, result would have "failed": True assert result.get("failed") is not True assert result["completed"] is True def test_413_error_message_detection(self, agent): """413 detected via error message string (no status_code attr).""" err = _make_413_error(use_status_code=False, message="error code: 413") ok_resp = _mock_response(content="OK", finish_reason="stop") agent.client.chat.completions.create.side_effect = [err, ok_resp] prefill = [ {"role": "user", "content": "previous question"}, {"role": "assistant", "content": "previous answer"}, ] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "hello"}], "compressed", ) result = agent.run_conversation("hello", conversation_history=prefill) mock_compress.assert_called_once() assert result["completed"] is True def test_413_clears_conversation_history_on_persist(self, agent): """After 413-triggered compression, _persist_session must receive None history. Bug: _compress_context() creates a new session and resets _last_flushed_db_idx=0, but if conversation_history still holds the original (pre-compression) list, _flush_messages_to_session_db computes flush_from = max(len(history), 0) which exceeds len(compressed_messages), so messages[flush_from:] is empty and nothing is written to the new session → "Session found but has no messages" on resume. """ err_413 = _make_413_error() ok_resp = _mock_response(content="OK", finish_reason="stop") agent.client.chat.completions.create.side_effect = [err_413, ok_resp] big_history = [ {"role": "user" if i % 2 == 0 else "assistant", "content": f"msg {i}"} for i in range(200) ] persist_calls = [] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object( agent, "_persist_session", side_effect=lambda msgs, hist: persist_calls.append((list(msgs), hist)), ), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "summary"}], "compressed prompt", ) agent.run_conversation("hello", conversation_history=big_history) assert any(hist is None for _msgs, hist in persist_calls), ( "Expected at least one post-compression _persist_session call " "with conversation_history=None" ) def test_context_overflow_clears_conversation_history_on_persist(self, agent): """After context-overflow compression, _persist_session must receive None history.""" err_400 = Exception( "Error code: 400 - This endpoint's maximum context length is 128000 tokens. " "However, you requested about 270460 tokens." ) err_400.status_code = 400 ok_resp = _mock_response(content="OK", finish_reason="stop") agent.client.chat.completions.create.side_effect = [err_400, ok_resp] big_history = [ {"role": "user" if i % 2 == 0 else "assistant", "content": f"msg {i}"} for i in range(200) ] persist_calls = [] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object( agent, "_persist_session", side_effect=lambda msgs, hist: persist_calls.append((list(msgs), hist)), ), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "summary"}], "compressed prompt", ) agent.run_conversation("hello", conversation_history=big_history) assert any(hist is None for _msgs, hist in persist_calls) def test_400_context_length_triggers_compression(self, agent): """A 400 with 'maximum context length' should trigger compression, not abort as generic 4xx. OpenRouter returns HTTP 400 (not 413) for context-length errors. Before the fix, this was caught by the generic 4xx handler which aborted immediately — now it correctly triggers compression+retry. """ err_400 = Exception( "Error code: 400 - {'error': {'message': " "\"This endpoint's maximum context length is 204800 tokens. " "However, you requested about 270460 tokens.\", 'code': 400}}" ) err_400.status_code = 400 ok_resp = _mock_response(content="Recovered after compression", finish_reason="stop") agent.client.chat.completions.create.side_effect = [err_400, ok_resp] prefill = [ {"role": "user", "content": "previous question"}, {"role": "assistant", "content": "previous answer"}, ] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "hello"}], "compressed prompt", ) result = agent.run_conversation("hello", conversation_history=prefill) mock_compress.assert_called_once() # Must NOT have "failed": True (which would mean the generic 4xx handler caught it) assert result.get("failed") is not True assert result["completed"] is True assert result["final_response"] == "Recovered after compression" def test_400_reduce_length_triggers_compression(self, agent): """A 400 with 'reduce the length' should trigger compression.""" err_400 = Exception( "Error code: 400 - Please reduce the length of the messages" ) err_400.status_code = 400 ok_resp = _mock_response(content="OK", finish_reason="stop") agent.client.chat.completions.create.side_effect = [err_400, ok_resp] prefill = [ {"role": "user", "content": "previous question"}, {"role": "assistant", "content": "previous answer"}, ] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "hello"}], "compressed", ) result = agent.run_conversation("hello", conversation_history=prefill) mock_compress.assert_called_once() assert result["completed"] is True def test_context_length_retry_rebuilds_request_after_compression(self, agent): """Retry must send the compressed transcript, not the stale oversized payload.""" err_400 = Exception( "Error code: 400 - {'error': {'message': " "\"This endpoint's maximum context length is 128000 tokens. " "Please reduce the length of the messages.\"}}" ) err_400.status_code = 400 ok_resp = _mock_response(content="Recovered after real compression", finish_reason="stop") request_payloads = [] def _side_effect(**kwargs): request_payloads.append(kwargs) if len(request_payloads) == 1: raise err_400 return ok_resp agent.client.chat.completions.create.side_effect = _side_effect prefill = [ {"role": "user", "content": "previous question"}, {"role": "assistant", "content": "previous answer"}, ] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "compressed summary"}], "compressed prompt", ) result = agent.run_conversation("hello", conversation_history=prefill) assert result["completed"] is True assert len(request_payloads) == 2 assert len(request_payloads[1]["messages"]) < len(request_payloads[0]["messages"]) assert request_payloads[1]["messages"][0] == { "role": "system", "content": "compressed prompt", } assert request_payloads[1]["messages"][1] == { "role": "user", "content": "compressed summary", } def test_413_cannot_compress_further(self, agent): """When compression can't reduce messages, return partial result.""" err_413 = _make_413_error() agent.client.chat.completions.create.side_effect = [err_413] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): # Compression returns same number of messages → can't compress further mock_compress.return_value = ( [{"role": "user", "content": "hello"}], "same prompt", ) result = agent.run_conversation("hello") assert result["completed"] is False assert result.get("partial") is True assert "413" in result["error"] class TestPreflightCompression: """Preflight compression should compress history before the first API call.""" def test_compress_context_emits_lifecycle_status_before_work(self, agent): """Direct context compression should tell gateway users why the turn paused.""" # This test calls _compress_context directly and asserts the FIRST # status event is the lifecycle "Compacting context" message. With # compaction enabled the lazy feasibility probe would emit an # aux-provider warning first (no aux key in the hermetic test env), # displacing events[0]. The flag value is irrelevant to what this # test asserts, so disable it to suppress the probe. agent.compression_enabled = False events = [] agent.status_callback = lambda ev, msg: events.append((ev, msg)) def _fake_compress(messages, current_tokens=None, focus_topic=None): events.append(("compress", "started")) return [{"role": "user", "content": f"{SUMMARY_PREFIX}\nPrevious conversation"}] with ( patch.object(agent.context_compressor, "compress", side_effect=_fake_compress), patch.object(agent, "_build_system_prompt", return_value="new system prompt"), patch("run_agent.estimate_request_tokens_rough", return_value=42), ): compressed, new_system_prompt = agent._compress_context( [{"role": "user", "content": "hello"}], "system prompt", approx_tokens=1234, ) assert compressed == [{"role": "user", "content": f"{SUMMARY_PREFIX}\nPrevious conversation"}] assert new_system_prompt == "new system prompt" assert events[0][0] == "lifecycle" assert "Compacting context" in events[0][1] assert events[1] == ("compress", "started") def test_preflight_compresses_oversized_history(self, agent): """When loaded history exceeds the model's context threshold, compress before API call.""" agent.compression_enabled = True # Set a small context so the history is "oversized", but large enough # that the compressed result (2 short messages) fits in a single pass. agent.context_compressor.context_length = 2000 agent.context_compressor.threshold_tokens = 200 # Build a history that will be large enough to trigger preflight # (each message ~50 chars ≈ 13 tokens, 40 messages ≈ 520 tokens > 200 threshold) big_history = [] for i in range(20): big_history.append({"role": "user", "content": f"Message number {i} with some extra text padding"}) big_history.append({"role": "assistant", "content": f"Response number {i} with extra padding here"}) ok_resp = _mock_response(content="After preflight", finish_reason="stop") agent.client.chat.completions.create.side_effect = [ok_resp] status_messages = [] agent.status_callback = lambda ev, msg: status_messages.append((ev, msg)) with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): # Simulate compression reducing messages to a small set that fits mock_compress.return_value = ( [ {"role": "user", "content": f"{SUMMARY_PREFIX}\nPrevious conversation"}, {"role": "user", "content": "hello"}, ], "new system prompt", ) result = agent.run_conversation("hello", conversation_history=big_history) # Preflight compression is a multi-pass loop (up to 3 passes for very # large sessions, breaking when no further reduction is possible). # First pass must have received the full oversized history. assert mock_compress.call_count >= 1, "Preflight compression never ran" first_call_messages = mock_compress.call_args_list[0].args[0] assert len(first_call_messages) >= 40, ( f"First preflight pass should see the full history, got " f"{len(first_call_messages)} messages" ) assert result["completed"] is True assert result["final_response"] == "After preflight" assert any( ev == "lifecycle" and "Preflight compression" in msg for ev, msg in status_messages ) def test_preflight_defers_when_recent_real_usage_fit(self, agent): """A noisy rough estimate should not re-compact a recently fitting request.""" agent.compression_enabled = True agent.context_compressor.context_length = 200_000 agent.context_compressor.threshold_tokens = 100_000 agent.context_compressor.last_prompt_tokens = 58_000 agent.context_compressor.last_real_prompt_tokens = 58_000 agent.context_compressor.last_rough_tokens_when_real_prompt_fit = 113_000 big_history = [] for i in range(20): big_history.append({"role": "user", "content": f"Message {i} padded"}) big_history.append({"role": "assistant", "content": f"Response {i} padded"}) ok_resp = _mock_response( content="Used real fit", finish_reason="stop", usage={"prompt_tokens": 59_000, "completion_tokens": 100, "total_tokens": 59_100}, ) agent.client.chat.completions.create.side_effect = [ok_resp] status_messages = [] agent.status_callback = lambda ev, msg: status_messages.append((ev, msg)) with ( patch("agent.turn_context.estimate_request_tokens_rough", return_value=114_000), patch("agent.conversation_loop.estimate_request_tokens_rough", return_value=114_000), patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): result = agent.run_conversation("hello", conversation_history=big_history) mock_compress.assert_not_called() assert result["completed"] is True assert result["final_response"] == "Used real fit" assert not any( ev == "lifecycle" and "Preflight compression" in msg for ev, msg in status_messages ) def test_preflight_compresses_when_rough_growth_after_fit_is_large(self, agent): """Large rough growth after a fitting request still triggers preflight.""" agent.compression_enabled = True agent.context_compressor.context_length = 200_000 agent.context_compressor.threshold_tokens = 100_000 agent.context_compressor.last_prompt_tokens = 58_000 agent.context_compressor.last_real_prompt_tokens = 58_000 agent.context_compressor.last_rough_tokens_when_real_prompt_fit = 113_000 big_history = [] for i in range(20): big_history.append({"role": "user", "content": f"Message {i} padded"}) big_history.append({"role": "assistant", "content": f"Response {i} padded"}) ok_resp = _mock_response( content="Compressed after growth", finish_reason="stop", usage={"prompt_tokens": 50_000, "completion_tokens": 100, "total_tokens": 50_100}, ) agent.client.chat.completions.create.side_effect = [ok_resp] # First rough estimate must clear the threshold so preflight fires # (rough growth since the last fitting request is large, so the # deferral path is NOT taken). Every estimate after compaction is # sub-threshold. Use a callable side_effect rather than a fixed list # so we don't have to predict how many times the loop re-estimates — # the post-response real-token estimate is an extra call that a # 2-element list would exhaust (StopIteration). _rough_calls = {"n": 0} def _rough_estimate(*_args, **_kwargs): _rough_calls["n"] += 1 return 125_000 if _rough_calls["n"] == 1 else 40_000 with ( patch("agent.turn_context.estimate_request_tokens_rough", side_effect=_rough_estimate), patch("agent.conversation_loop.estimate_request_tokens_rough", side_effect=_rough_estimate), patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": f"{SUMMARY_PREFIX}\nPrevious conversation"}], "new system prompt", ) result = agent.run_conversation("hello", conversation_history=big_history) mock_compress.assert_called_once() assert result["completed"] is True def test_no_preflight_when_under_threshold(self, agent): """When history fits within context, no preflight compression needed.""" agent.compression_enabled = True # Large context — history easily fits agent.context_compressor.context_length = 1000000 agent.context_compressor.threshold_tokens = 850000 small_history = [ {"role": "user", "content": "hi"}, {"role": "assistant", "content": "hello"}, ] ok_resp = _mock_response(content="No compression needed", finish_reason="stop") agent.client.chat.completions.create.side_effect = [ok_resp] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): result = agent.run_conversation("hello", conversation_history=small_history) mock_compress.assert_not_called() assert result["completed"] is True def test_no_preflight_when_compression_disabled(self, agent): """Preflight should not run when compression is disabled.""" agent.compression_enabled = False agent.context_compressor.context_length = 100 agent.context_compressor.threshold_tokens = 85 big_history = [ {"role": "user", "content": "x" * 1000}, {"role": "assistant", "content": "y" * 1000}, ] * 10 ok_resp = _mock_response(content="OK", finish_reason="stop") agent.client.chat.completions.create.side_effect = [ok_resp] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): result = agent.run_conversation("hello", conversation_history=big_history) mock_compress.assert_not_called() def test_preflight_respects_anti_thrash(self, agent): """Preflight must call ``should_compress()`` so anti-thrash applies. Regression for #29335 — preflight used to bypass ``should_compress()`` and re-trigger every turn even when the prior two passes each saved <10% (the canonical infinite-compression-loop signal). """ agent.compression_enabled = True agent.context_compressor.context_length = 2000 agent.context_compressor.threshold_tokens = 200 big_history = [] for i in range(20): big_history.append({"role": "user", "content": f"Message {i} padded"}) big_history.append({"role": "assistant", "content": f"Response {i} padded"}) ok_resp = _mock_response(content="No preflight", finish_reason="stop") agent.client.chat.completions.create.side_effect = [ok_resp] with ( patch.object(agent.context_compressor, "should_compress", return_value=False) as mock_should, patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): result = agent.run_conversation("hello", conversation_history=big_history) # The gate consulted should_compress — anti-thrash had a chance to vote. mock_should.assert_called() # And vetoed: even though tokens >= threshold, no compression ran. mock_compress.assert_not_called() assert result["completed"] is True def test_preflight_seeds_display_tokens_when_compression_aborts(self, agent): """Display must reflect the real context size even when compression no-ops. Regression: the CLI status bar reads ``last_prompt_tokens``, which only updated from a *successful* API response. When the loaded history was oversized but compression failed to reduce it (e.g. the auxiliary summary model timed out), the bar stayed stuck at the old, smaller value while the preflight estimate reported a much larger number — looking permanently out of sync. """ agent.compression_enabled = True agent.context_compressor.context_length = 200_000 agent.context_compressor.threshold_tokens = 130_000 # Simulate a stale display value from an earlier, smaller turn. agent.context_compressor.last_prompt_tokens = 74_400 big_history = [] for i in range(20): big_history.append({"role": "user", "content": f"Message {i} padded text"}) big_history.append({"role": "assistant", "content": f"Response {i} padded text"}) ok_resp = _mock_response(content="After preflight", finish_reason="stop") agent.client.chat.completions.create.side_effect = [ok_resp] with ( patch("agent.turn_context.estimate_request_tokens_rough", return_value=144_669), patch("agent.conversation_loop.estimate_request_tokens_rough", return_value=144_669), # Compression no-ops (returns input unchanged) — mirrors an aux # summary-model timeout where the messages can't be reduced. patch.object(agent, "_compress_context", side_effect=lambda msgs, *a, **k: (msgs, agent._cached_system_prompt)), patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): result = agent.run_conversation("hello", conversation_history=big_history) assert result["completed"] is True # The display token count was revised up to the fresh preflight estimate, # not left at the stale 74_400. assert agent.context_compressor.last_prompt_tokens == 144_669 def test_preflight_seed_only_revises_upward(self, agent): """A larger tracked value must not be clobbered by a smaller estimate.""" agent.compression_enabled = True agent.context_compressor.context_length = 200_000 agent.context_compressor.threshold_tokens = 130_000 # A real, larger usage figure is already tracked. agent.context_compressor.last_prompt_tokens = 160_000 big_history = [] for i in range(20): big_history.append({"role": "user", "content": f"Message {i} padded text"}) big_history.append({"role": "assistant", "content": f"Response {i} padded text"}) ok_resp = _mock_response(content="After preflight", finish_reason="stop") agent.client.chat.completions.create.side_effect = [ok_resp] with ( patch("agent.turn_context.estimate_request_tokens_rough", return_value=144_669), patch("agent.conversation_loop.estimate_request_tokens_rough", return_value=144_669), patch.object(agent, "_compress_context", side_effect=lambda msgs, *a, **k: (msgs, agent._cached_system_prompt)), patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): agent.run_conversation("hello", conversation_history=big_history) # Smaller estimate must not overwrite the larger tracked value. assert agent.context_compressor.last_prompt_tokens == 160_000 class TestToolResultPreflightCompression: """Compression should trigger when tool results push context past the threshold.""" def test_large_tool_results_trigger_compression(self, agent): """When tool results push estimated tokens past threshold, compress before next call.""" agent.compression_enabled = True agent.context_compressor.context_length = 200_000 agent.context_compressor.threshold_tokens = 130_000 # below the 135k reported usage agent.context_compressor.last_prompt_tokens = 130_000 agent.context_compressor.last_completion_tokens = 5_000 tc = SimpleNamespace( id="tc1", type="function", function=SimpleNamespace(name="web_search", arguments='{"query":"test"}'), ) tool_resp = _mock_response( content=None, finish_reason="stop", tool_calls=[tc], usage={"prompt_tokens": 130_000, "completion_tokens": 5_000, "total_tokens": 135_000}, ) ok_resp = _mock_response( content="Done after compression", finish_reason="stop", usage={"prompt_tokens": 50_000, "completion_tokens": 100, "total_tokens": 50_100}, ) agent.client.chat.completions.create.side_effect = [tool_resp, ok_resp] large_result = "x" * 100_000 with ( patch("run_agent.handle_function_call", return_value=large_result), patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "hello"}], "compressed prompt", ) result = agent.run_conversation("hello") mock_compress.assert_called_once() assert result["completed"] is True def test_anthropic_prompt_too_long_safety_net(self, agent): """Anthropic 'prompt is too long' error triggers compression as safety net.""" err_400 = Exception( "Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', " "'message': 'prompt is too long: 233153 tokens > 200000 maximum'}}" ) err_400.status_code = 400 ok_resp = _mock_response(content="Recovered", finish_reason="stop") agent.client.chat.completions.create.side_effect = [err_400, ok_resp] prefill = [ {"role": "user", "content": "previous"}, {"role": "assistant", "content": "answer"}, ] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "hello"}], "compressed", ) result = agent.run_conversation("hello", conversation_history=prefill) mock_compress.assert_called_once() assert result["completed"] is True # --------------------------------------------------------------------------- # Disabled auto-compaction on overflow (port of anomalyco/opencode#30749) # --------------------------------------------------------------------------- class TestOverflowWithCompactionDisabled: """When ``compression.enabled`` is False, NO automatic compaction may fire — including the provider/request-size overflow recovery paths. Ported from anomalyco/opencode#30749: the proactive token-threshold path already honoured the setting, but provider overflow errors (413 payload-too-large, context-overflow, long-context-tier 429) still silently compressed + rotated the session. The fix surfaces a terminal error so the user can compact manually, start fresh, or switch models. """ @staticmethod def _prefill(): return [ {"role": "user", "content": "previous question"}, {"role": "assistant", "content": "previous answer"}, ] def test_413_does_not_compress_when_disabled(self, agent): """413 must NOT call _compress_context when compaction is disabled.""" agent.compression_enabled = False err_413 = _make_413_error() # If the guard fails, a second (success) response would be consumed. agent.client.chat.completions.create.side_effect = [err_413, _mock_response()] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session") as mock_persist, patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): result = agent.run_conversation("hello", conversation_history=self._prefill()) mock_compress.assert_not_called() mock_persist.assert_called() assert result.get("failed") is True assert result.get("compaction_disabled") is True assert "auto-compaction is disabled" in result["error"] def test_context_overflow_does_not_compress_when_disabled(self, agent): """400 'prompt is too long' must NOT compress when compaction disabled.""" agent.compression_enabled = False err_400 = Exception( "Error code: 400 - {'type': 'error', 'error': {'type': " "'invalid_request_error', 'message': 'prompt is too long: " "233153 tokens > 200000 maximum'}}" ) err_400.status_code = 400 agent.client.chat.completions.create.side_effect = [err_400, _mock_response()] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): result = agent.run_conversation("hello", conversation_history=self._prefill()) mock_compress.assert_not_called() assert result.get("compaction_disabled") is True def test_413_still_compresses_when_enabled(self, agent): """Control: with compaction enabled, 413 still triggers compression. Guards against the disabled-path guard accidentally swallowing the enabled path. """ agent.compression_enabled = True err_413 = _make_413_error() ok_resp = _mock_response(content="Recovered", finish_reason="stop") agent.client.chat.completions.create.side_effect = [err_413, ok_resp] with ( patch.object(agent, "_compress_context") as mock_compress, patch.object(agent, "_persist_session"), patch.object(agent, "_save_trajectory"), patch.object(agent, "_cleanup_task_resources"), ): mock_compress.return_value = ( [{"role": "user", "content": "hello"}], "compressed", ) result = agent.run_conversation("hello", conversation_history=self._prefill()) mock_compress.assert_called_once() assert result["completed"] is True assert result.get("compaction_disabled") is not True