The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
fix(compression): a handoff row no longer collapses the tail cut onto itself
Teknium52a01bd2f2ff
diff --git a/agent/context_compressor.py b/agent/context_compressor.pyindex 500ec52035f..b01a7edd87a 100644--- a/agent/context_compressor.py+++ b/agent/context_compressor.py@@ -36,7 +36,7 @@ from agent.context_compressor_prune import ProactivePruneMixinfrom agent.context_compressor_summary import SummaryDispatchMixinfrom agent.context_compressor_retry import retryable_user_textfrom agent.context_compressor_tail import (- demote_stale_tail_tools, lean_tail_budget, is_demoted_stub, skill_view_names_by_call_id,+ demote_stale_tail_tools, lean_tail_budget, is_demoted_stub, skill_view_names_by_call_id, tail_cut_pricer,elide_keeping_skill_safety_rule, with_skill_safety_rule, without_skill_safety_rule,)from agent.context_compressor_telemetry import CompressionTelemetryMixin@@ -3119,14 +3119,14 @@ class ContextCompressor(def _walk_tail_budget(self, messages: list[dict[str, Any]], head_end: int, ceiling: int, min_tail: int, *, cut_at_break: bool,+ price: Optional[Callable[[int], int]] = None,) -> tuple[int, int]:"""Accumulate message tokens newest-first until ``ceiling`` (once ``min_tail`` rows are kept).Returns ``(cut_idx, accumulated)``; ``cut_idx`` is the first protected index. On the budgetbreak the cut stays at the last accepted row, or moves onto the breaking row when``cut_at_break``. Only the newest assistant turn's thinking is charged (#73624) unless the route- echoes stale thinking every turn — must agree with the preflight estimate (#84371)."""- n = len(messages)- price = self._tail_row_pricer(messages)+ echoes stale thinking every turn — must agree with the preflight estimate (#84371); ``price`` overrides it."""+ n, price = len(messages), price or self._tail_row_pricer(messages)accumulated = 0cut = n # start from beyond the endfor i in range(n - 1, head_end - 1, -1):@@ -4999,11 +4999,11 @@ Write only the summary body. Do not include any preamble or prefix."""# token-respecting floor exists then. Required user/assistant anchors and atomic tool groups# are applied below and may still necessarily exceed the ceiling.walk_floor = 0 if soft_ceiling >= min_tail * _estimate_msg_budget_tokens({}) else min_tail- cut_idx, accumulated = self._walk_tail_budget(messages, head_end, soft_ceiling, walk_floor, cut_at_break=False)- # Whole transcript fits soft_ceiling: re-cut with the raw budget so a worthwhile middle- # exists (else #40803 loop).+ price = tail_cut_pricer(self, messages, head_end)+ cut_idx, accumulated = self._walk_tail_budget(messages, head_end, soft_ceiling, walk_floor, cut_at_break=False, price=price)+ # Whole transcript fits soft_ceiling: re-cut with the raw budget so a worthwhile middle exists (else #40803 loop).if cut_idx <= head_end and 0 < accumulated <= soft_ceiling:- cut_idx, _ = self._walk_tail_budget(messages, head_end, token_budget, min_tail, cut_at_break=True)+ cut_idx, _ = self._walk_tail_budget(messages, head_end, token_budget, min_tail, cut_at_break=True, price=price)fallback_cut = n - min_tail# The newest row never leaves the tail, whatever its role. When it alone exceeds the ceiling the walk acceptsdiff --git a/agent/context_compressor_tail.py b/agent/context_compressor_tail.pyindex e819c45d505..96cc270090e 100644--- a/agent/context_compressor_tail.py+++ b/agent/context_compressor_tail.py@@ -118,6 +118,20 @@ SKILL_SAFETY_RULE = ()+def tail_cut_pricer(compressor: Any, messages: list[dict[str, Any]], head_end: int):+ """Tail-cut walk price ``index -> tokens`` in which rows at or before the newest handoff cost nothing.++ The handoff scan folds every row up to the newest in-transcript handoff into the summary window (the tail starts+ past it), so none of them can stay in the protected tail. Charging them let the handoff row alone break the soft+ ceiling: the walk stopped on it, the window held only that handoff, and compress() returned the+ ``empty_post_handoff_window`` no-op at every trigger while the session grew past its window."""+ price = compressor._tail_row_pricer(messages)+ newest = next(+ (i for i in range(len(messages) - 1, head_end - 1, -1) if compressor._is_context_summary_message(messages[i])), -1,+ )+ return price if newest < 0 else (lambda i: 0 if i <= newest else price(i))++def with_skill_safety_rule(summary: str, head: list[dict[str, Any]], tail: list[dict[str, Any]],) -> tuple[str, list[dict[str, Any]], list[dict[str, Any]]]:diff --git a/tests/agent/test_compressor_handoff_tail_price.py b/tests/agent/test_compressor_handoff_tail_price.pynew file mode 100644index 00000000000..40645aec37b--- /dev/null+++ b/tests/agent/test_compressor_handoff_tail_price.py@@ -0,0 +1,76 @@+"""A handoff row never stays in the protected tail, so it must not decide where the tail cut lands.++The handoff scan folds every row up to the newest in-transcript handoff into the summary window. When the+tail walk charged that handoff, a summary row that alone pushed the transcript over the soft ceiling ended+the walk on itself: the planned window held only the handoff and compress() returned the+``empty_post_handoff_window`` no-op at every trigger (live: four no-ops in a row, prompt 47k -> 66.7k on a+64k window, after a manual compress followed by one automatic compaction).+"""++from unittest.mock import patch++from agent.context_compressor import SUMMARY_PREFIX, ContextCompressor, _estimate_msg_budget_tokens+++def _compressor() -> ContextCompressor:+ with patch("agent.context_compressor.get_model_context_length", return_value=64_000):+ return ContextCompressor(+ model="test-model", quiet_mode=True, config_context_length=64_000, protect_first_n=3,+ protect_last_n=20, summary_target_ratio=0.20, threshold_percent=0.50, tail_mode="lean",+ )+++def _handoff(body_words: int = 1_800) -> dict:+ return {"role": "user", "content": f"{SUMMARY_PREFIX}\n## Goal\n" + " ".join(["earlier"] * body_words),+ "_compressed_summary": True}+++def _turns(n: int, words: int = 330) -> list[dict]:+ rows = []+ for i in range(n):+ rows.append({"role": "user", "content": f"question {i} " + " ".join(["ask"] * 40)})+ rows.append({"role": "assistant", "content": f"answer {i} " + " ".join(["reply"] * words)})+ return rows+++def _over_ceiling_only_with_handoff(cc: ContextCompressor, head: list[dict]) -> list[dict]:+ """Rows after the handoff fit the soft ceiling; adding the handoff breaks it."""+ soft = cc._tail_soft_ceiling(cc.tail_token_budget)+ handoff = _handoff()+ for n in range(4, 80):+ turns = _turns(n)+ after = sum(map(_estimate_msg_budget_tokens, turns))+ if after <= soft < after + _estimate_msg_budget_tokens(handoff):+ return [*head, handoff, *turns]+ raise AssertionError("fixture could not straddle the soft ceiling")+++def test_leading_handoff_does_not_collapse_the_window_to_itself():+ cc = _compressor()+ messages = _over_ceiling_only_with_handoff(cc, head=[])+ with patch.object(cc, "_generate_summary", return_value="NEW SUMMARY BODY"):+ result = cc.compress(messages, current_tokens=60_000)++ telemetry = cc._last_compression_telemetry or {}+ assert telemetry.get("failure_class") is None+ assert cc._last_compression_made_progress is True+ assert len(result) < len(messages)+ assert sum(1 for m in result if cc._is_context_summary_message(m)) == 1+ assert result[-1]["content"] == messages[-1]["content"]+++def test_handoff_behind_a_protected_head_folds_the_turns_after_it():+ """Gateway manual compress keeps protect_first_n=3: the handoff sits at index 3 of the next transcript."""+ cc = _compressor()+ head = [+ {"role": "user", "content": "first request"},+ {"role": "assistant", "content": "first answer"},+ {"role": "user", "content": "second request"},+ ]+ messages = _over_ceiling_only_with_handoff(cc, head=head)+ start, end = cc._compress_window(messages)+ handoff_idx = len(head)+ assert start == 0+ # The window reaches past the old handoff into the turns after it, not just the rows in front of it.+ assert end > handoff_idx + 1+ assert cc.has_content_to_compress(messages) is True