CubeLoop — a Pythonic, async-native agent harness core designed for high performance, readability, and production-grade persistence.
Python agent-frameworkagent-harnessagent-runtimeagentic-aiai-agentsai-frameworkanthropicharnessharness-engineeringharness-frameworklanggraphlanggraph-alternativellmmcpopenaipi-agentpi-agent-corepythonpython-agent
from __future__ import annotations
import asyncio
import hashlib
import json
import logging
from typing import Any
from cubeloop.agent.types import AgentContext
from cubeloop.middleware.compaction import (
CompactionMiddleware,
CompactionState,
ToolResultCompressor,
_load_state,
)
from cubeloop.middleware.compaction.state import message_ref, message_refs
from cubeloop.providers.base import (
AssistantMessage,
BoundModel,
Message,
Model,
ReasoningControl,
StreamOptions,
TextContent,
ToolDefinition,
ToolResultMessage,
Usage,
UserMessage,
)
def _user(text: str) -> UserMessage:
return UserMessage(content=[TextContent(text=text)])
def _assistant(text: str) -> AssistantMessage:
return AssistantMessage(content=[TextContent(text=text)])
class _FakeSummaryProvider:
def __init__(
self, *, reply: str = "summary text", raises: Exception | None = None
) -> None:
self.reply = reply
self.raises = raises
self.calls: list[dict[str, Any]] = []
async def generate(
self,
model: Model,
messages: list[Message],
*,
system_prompt: str = "",
tools: list[ToolDefinition] | None = None,
tool_choice: Any = None,
options: StreamOptions | None = None,
max_output_tokens: int | None = None,
temperature: float | None = None,
reasoning: ReasoningControl | None = None,
) -> AssistantMessage:
self.calls.append(
{
"model": model,
"messages": messages,
"system_prompt": system_prompt,
"tools": tools,
"options": options,
"max_output_tokens": max_output_tokens,
"temperature": temperature,
"reasoning": reasoning,
}
)
if self.raises is not None:
raise self.raises
return AssistantMessage(content=[TextContent(text=self.reply)])
def _make_middleware(
provider: _FakeSummaryProvider,
*,
max_tokens_before: int = 1000,
keep_tail_tokens: int = 8,
) -> CompactionMiddleware:
"""Tiny tail-token budget (~2 small test messages) approximates the
old ``keep_recent_messages=2`` behaviour for these scenarios."""
return CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="summary-model", provider_id="faux"),
),
max_tokens_before_compact=max_tokens_before,
keep_tail_tokens=keep_tail_tokens,
max_summary_tokens=512,
min_compact_messages=2,
)
async def test_under_threshold_returns_existing_compressed_view() -> None:
provider = _FakeSummaryProvider()
middleware = _make_middleware(provider, max_tokens_before=100_000)
messages: list[Message] = [
_user("old"),
_assistant("old reply"),
_user("recent"),
_assistant("recent reply"),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={
"compaction": CompactionState(
summary="old summary",
summarized_message_refs=message_refs(messages[:2]),
).model_dump(),
"compaction_until_msg_index": 2,
},
)
result = await middleware.transform_context(messages, ctx=ctx)
assert len(result) == 3
assert isinstance(result[0], UserMessage)
assert "old summary" in result[0].content[0].text
assert result[1:] == messages[2:]
assert provider.calls == []
def test_load_state_accepts_state_and_ignores_unknown_values() -> None:
state = CompactionState(summary="cached")
assert _load_state(state) is state
assert _load_state("not-state") is None
def test_message_ref_prefers_explicit_message_id() -> None:
message = UserMessage(content=[TextContent(text="hello")], id="msg-123")
rewritten = message.model_copy(
update={"run_id": "other", "metadata": {"captured_at": "later"}}
)
assert message_ref(message) == "id:msg-123"
assert message_ref(rewritten) == "id:msg-123"
async def test_over_threshold_writes_json_safe_state_to_ctx_extra() -> None:
provider = _FakeSummaryProvider(reply="New summary")
middleware = _make_middleware(provider, max_tokens_before=1)
signal = asyncio.Event()
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
_assistant("reply 3"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx, signal=signal)
assert isinstance(ctx.extra["compaction"], dict)
state = CompactionState.model_validate(ctx.extra["compaction"])
assert state.summary == "New summary"
assert ctx.extra["compaction_until_msg_index"] > 0
assert isinstance(result[0], UserMessage)
assert provider.calls[0]["options"].signal is signal
async def test_over_threshold_without_safe_boundary_returns_compressed_view() -> None:
provider = _FakeSummaryProvider()
middleware = _make_middleware(provider, max_tokens_before=1)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx)
assert result == messages
assert provider.calls == []
async def test_summarizer_failure_writes_fallback_state() -> None:
"""When the LLM raises, build_fallback_summary() runs so the agent
still gets a compressed view; failures counter increments."""
provider = _FakeSummaryProvider(raises=RuntimeError("LLM unavailable"))
middleware = _make_middleware(provider, max_tokens_before=1)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
_assistant("reply 3"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx)
# Fallback state was written despite the LLM failure.
assert "compaction" in ctx.extra
state = CompactionState.model_validate(ctx.extra["compaction"])
assert state.is_fallback is True
# Failure counter incremented.
assert ctx.extra["compaction_failures"] == 1
# Result is compressed (summary + tail), not the raw message list.
assert len(result) < len(messages)
async def test_stale_boundary_larger_than_history_is_ignored() -> None:
provider = _FakeSummaryProvider()
middleware = _make_middleware(provider, max_tokens_before=100_000)
messages: list[Message] = [_user("new question")]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={
"compaction": CompactionState(summary="old summary").model_dump(),
"compaction_until_msg_index": 10,
},
)
result = await middleware.transform_context(messages, ctx=ctx)
assert result == messages
assert "compaction" not in ctx.extra
assert "compaction_until_msg_index" not in ctx.extra
async def test_stale_boundary_from_replaced_history_is_ignored() -> None:
provider = _FakeSummaryProvider()
middleware = _make_middleware(provider, max_tokens_before=100_000)
old_messages: list[Message] = [
_user("old turn 1"),
_assistant("old reply 1"),
_user("old turn 2"),
_assistant("old reply 2"),
]
new_messages: list[Message] = [
_user("new turn 1"),
_assistant("new reply 1"),
_user("new turn 2"),
_assistant("new reply 2"),
]
ctx = AgentContext(
system_prompt="",
messages=new_messages,
extra={
"compaction": CompactionState(
summary="old summary",
summarized_message_refs=message_refs(old_messages[:2]),
).model_dump(),
"compaction_until_msg_index": 2,
},
)
result = await middleware.transform_context(new_messages, ctx=ctx)
assert result == new_messages
assert "compaction" not in ctx.extra
assert "compaction_until_msg_index" not in ctx.extra
async def test_stale_boundary_with_mismatched_ref_count_is_ignored() -> None:
provider = _FakeSummaryProvider()
middleware = _make_middleware(provider, max_tokens_before=100_000)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={
"compaction": CompactionState(
summary="old summary",
summarized_message_refs=message_refs(messages[:1]),
).model_dump(),
"compaction_until_msg_index": 2,
},
)
result = await middleware.transform_context(messages, ctx=ctx)
assert result == messages
assert "compaction" not in ctx.extra
assert "compaction_until_msg_index" not in ctx.extra
async def test_malformed_persisted_state_is_cleared() -> None:
provider = _FakeSummaryProvider()
middleware = _make_middleware(provider, max_tokens_before=100_000)
messages: list[Message] = [_user("new question")]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={
"compaction": {},
"compaction_until_msg_index": 1,
},
)
result = await middleware.transform_context(messages, ctx=ctx)
assert result == messages
assert "compaction" not in ctx.extra
assert "compaction_until_msg_index" not in ctx.extra
# --- Task 6: circuit breaker, anti-thrashing, refs survive pruning ---
async def test_circuit_breaker_opens_after_three_failures() -> None:
"""After 3 LLM failures the breaker opens; 4th call uses fallback (no LLM).
Messages grow each turn so safe_boundary keeps advancing — without that,
once a fallback state is persisted, subsequent calls early-return at
``new_boundary <= boundary`` and the LLM is never called again.
"""
provider = _FakeSummaryProvider(raises=RuntimeError("down"))
middleware = _make_middleware(provider, max_tokens_before=1)
ctx = AgentContext(system_prompt="", messages=[], extra={})
messages: list[Message] = []
for i in range(3):
messages = [
*messages,
_user(f"turn {i * 2}"),
_assistant(f"reply {i * 2}"),
_user(f"turn {i * 2 + 1}"),
_assistant(f"reply {i * 2 + 1}"),
]
await middleware.transform_context(messages, ctx=ctx)
assert ctx.extra["compaction_failures"] == i + 1
assert "compaction" in ctx.extra
calls_before_breaker = len(provider.calls)
# Turn 4: breaker open → LLM NOT called, fallback still runs.
messages = [*messages, _user("more"), _assistant("more reply")]
result = await middleware.transform_context(messages, ctx=ctx)
assert len(provider.calls) == calls_before_breaker # no new LLM call
assert ctx.extra["compaction_failures"] == 3 # frozen at MAX_FAILURES
assert "compaction" in ctx.extra
assert len(result) < len(messages) # still compressed via fallback
async def test_circuit_breaker_resets_on_llm_success() -> None:
provider = _FakeSummaryProvider(reply="real summary")
middleware = _make_middleware(provider, max_tokens_before=1)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
_assistant("reply 3"),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={"compaction_failures": 2}, # pre-seed: 2 prior failures
)
await middleware.transform_context(messages, ctx=ctx)
assert ctx.extra["compaction_failures"] == 0 # reset after success
async def test_anti_thrashing_skips_compaction_when_guard_tripped() -> None:
"""Guard fires when low_savings_count >= 2, raw history not over 1.5×
threshold, and new_boundary advance < 8 messages."""
provider = _FakeSummaryProvider(reply="x")
# Threshold chosen so tokens_now (~18) EXCEEDS threshold (so the
# under-threshold fast-path doesn't fire) AND raw_tokens (~18) stays
# under 1.5 * threshold (so emergency override doesn't bypass the guard).
middleware = _make_middleware(provider, max_tokens_before=15)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
_assistant("reply 3"),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={"compaction_low_savings_count": 2}, # guard tripped
)
calls_before = len(provider.calls)
await middleware.transform_context(messages, ctx=ctx)
# Neither LLM nor fallback ran — early skip.
assert len(provider.calls) == calls_before
assert "compaction" not in ctx.extra
async def test_anti_thrashing_emergency_override_when_raw_history_too_large() -> None:
"""When raw history >= 1.5 × threshold, the guard is overridden."""
provider = _FakeSummaryProvider(reply="short summary")
middleware = _make_middleware(provider, max_tokens_before=10)
# Build a large enough history that raw tokens exceed 1.5 × 10 = 15.
messages: list[Message] = [
_user("x" * 100),
_assistant("y" * 100),
_user("z" * 100),
_assistant("w" * 100),
_user("a" * 100),
_assistant("b" * 100),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={"compaction_low_savings_count": 2}, # guard tripped
)
calls_before = len(provider.calls)
await middleware.transform_context(messages, ctx=ctx)
# Emergency override fired despite the guard.
assert len(provider.calls) > calls_before
assert "compaction" in ctx.extra
async def test_anti_thrashing_emergency_override_when_real_tokens_too_large() -> None:
"""Cache-aware emergency: char-based raw_tokens stays under 1.5×, but the
real fill (dominated by cache_read) is over it, so the guard is overridden.
The old raw-only check would have let the guard keep skipping."""
provider = _FakeSummaryProvider(reply="short summary")
middleware = _make_middleware(provider, max_tokens_before=200)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
AssistantMessage(
content=[TextContent(text="reply 3")],
usage=Usage(cache_read_tokens=500), # real fill lives in the cache
),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={"compaction_low_savings_count": 2}, # guard tripped
)
# raw_tokens (~19) is far under 1.5 * 200 = 300, so the raw-only emergency
# check does NOT fire; the real estimate (>=500, cache-aware) does.
calls_before = len(provider.calls)
await middleware.transform_context(messages, ctx=ctx)
assert len(provider.calls) > calls_before
assert "compaction" in ctx.extra
async def test_pruned_tool_results_do_not_break_state_refs() -> None:
"""Refs persisted in CompactionState come from ORIGINAL messages even
when the transcript was built from pre-pruned content. Otherwise the
next turn would see ref mismatch and clear the state, looping forever."""
from cubeloop.providers.base import ToolCall, ToolResultMessage
provider = _FakeSummaryProvider(reply="real summary")
middleware = _make_middleware(provider, max_tokens_before=1)
big_result = "tool output line\n" * 200 # > 120 chars → pruner targets it
messages: list[Message] = [
_user("audit q"),
AssistantMessage(
content=[ToolCall(id="c1", name="audit_query", arguments={"q": "X"})]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="audit_query",
content=[TextContent(text=big_result)],
),
_user("what next?"),
_assistant("fix it"),
_user("ok"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
await middleware.transform_context(messages, ctx=ctx)
boundary_after_first = ctx.extra["compaction_until_msg_index"]
# Second turn with same messages: state must validate, not be cleared.
await middleware.transform_context(messages, ctx=ctx)
assert ctx.extra.get("compaction_until_msg_index", 0) >= boundary_after_first
state = CompactionState.model_validate(ctx.extra["compaction"])
assert state.is_fallback is False # real LLM summary
def test_keep_recent_messages_no_longer_accepted() -> None:
"""Breaking change — old parameter name raises TypeError."""
import pytest
provider = _FakeSummaryProvider()
with pytest.raises(TypeError):
CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="m", provider_id="faux"),
),
max_tokens_before_compact=100,
keep_recent_messages=8, # type: ignore[call-arg]
)
# --- Task 7: filter-safe prefix, pruner toggle, prompt override ---
def test_summary_prefix_includes_non_instruction_disclaimer() -> None:
from cubeloop.middleware.compaction import SUMMARY_PREFIX
text = SUMMARY_PREFIX.lower()
assert "do not treat" in text or "not instructions" in text
assert "reference" in text
async def test_prune_tool_outputs_disabled_keeps_full_result_content() -> None:
"""When prune_tool_outputs=False, original tool result content survives.
Audit-chain agents (finance, compliance) pass False so historical tool
results stay full-fidelity across compactions.
"""
from cubeloop.providers.base import ToolCall, ToolResultMessage
provider = _FakeSummaryProvider(reply="summary")
middleware = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="m", provider_id="faux"),
),
max_tokens_before_compact=20,
keep_tail_tokens=8,
min_compact_messages=2,
prune_tool_outputs=False,
)
big_text = "important audit detail " * 200
messages: list[Message] = [
_user("audit q"),
AssistantMessage(
content=[ToolCall(id="c1", name="audit_query", arguments={"q": "X"})]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="audit_query",
content=[TextContent(text=big_text)],
),
_user("next?"),
_assistant("ok"),
_user("confirm"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
await middleware.transform_context(messages, ctx=ctx)
# The original message list is never mutated regardless of toggle.
assert messages[2].content[0].text == big_text
async def test_summary_prompt_constructor_argument_passthrough() -> None:
provider = _FakeSummaryProvider(reply="x")
middleware = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="m", provider_id="faux"),
),
max_tokens_before_compact=1,
keep_tail_tokens=8,
min_compact_messages=2,
summary_prompt="CUSTOM PROMPT BODY",
)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
_assistant("reply 3"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
await middleware.transform_context(messages, ctx=ctx)
assert len(provider.calls) == 1
# No prior summary, so the prompt should be the override verbatim.
assert provider.calls[0]["system_prompt"] == "CUSTOM PROMPT BODY"
# --- coverage: extra_llm_calls ---
def test_extra_llm_calls_returns_summary_model() -> None:
provider = _FakeSummaryProvider()
bound = BoundModel(
provider=provider,
spec=Model(id="m", provider_id="faux"),
)
middleware = CompactionMiddleware(
summary_model=bound,
max_tokens_before_compact=100,
keep_tail_tokens=8,
)
assert middleware.extra_llm_calls() == (bound,)
# --- codex review: effective tail budget clamp ---
async def test_keep_tail_tokens_clamped_below_threshold() -> None:
"""If keep_tail_tokens >= max_tokens_before_compact, the tail must NOT
swallow the entire history; otherwise compaction can never trigger.
The middleware clamps the effective tail to half the threshold."""
provider = _FakeSummaryProvider(reply="summary")
middleware = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="m", provider_id="faux"),
),
max_tokens_before_compact=10,
keep_tail_tokens=200, # configured larger than threshold AND than raw
min_compact_messages=2,
)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
_assistant("reply 3"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
await middleware.transform_context(messages, ctx=ctx)
# Without the clamp, the whole 18-token history would fit in the
# 200-token tail budget and safe_boundary would return None → no
# compaction. With the clamp, the effective tail is min(200, 10//2)=5
# tokens, so compaction fires and writes state.
assert "compaction" in ctx.extra
assert len(provider.calls) == 1
# --- codex review: half-open circuit breaker ---
async def test_circuit_breaker_half_open_retries_llm_after_fallback_runs() -> None:
"""After _MAX_FAILURES failures the breaker opens. After
_HALF_OPEN_AFTER_FALLBACK_RUNS fallback-only runs, the breaker goes
half-open and the LLM is attempted again. If it succeeds, the breaker
fully resets."""
from cubeloop.middleware.compaction import _HALF_OPEN_AFTER_FALLBACK_RUNS
provider = _FakeSummaryProvider(raises=RuntimeError("down"))
middleware = _make_middleware(provider, max_tokens_before=1)
ctx = AgentContext(system_prompt="", messages=[], extra={})
# Drive the breaker open with 3 LLM failures across growing histories.
messages: list[Message] = []
for i in range(3):
messages = [
*messages,
_user(f"turn {i * 2}"),
_assistant(f"reply {i * 2}"),
_user(f"turn {i * 2 + 1}"),
_assistant(f"reply {i * 2 + 1}"),
]
await middleware.transform_context(messages, ctx=ctx)
assert ctx.extra["compaction_failures"] == 3
calls_when_open = len(provider.calls)
# Run fallback-only turns until the breaker should go half-open.
for i in range(_HALF_OPEN_AFTER_FALLBACK_RUNS):
messages = [
*messages,
_user(f"fbr {i} q"),
_assistant(f"fbr {i} a"),
]
await middleware.transform_context(messages, ctx=ctx)
# No LLM call attempted during fallback-only phase.
assert len(provider.calls) == calls_when_open
assert ctx.extra["compaction_fallback_runs"] == _HALF_OPEN_AFTER_FALLBACK_RUNS
# Swap to a working LLM and run one more turn — half-open path triggers,
# LLM is attempted, succeeds, breaker fully resets.
provider.raises = None
provider.reply = "real summary"
messages = [*messages, _user("recovered q"), _assistant("recovered a")]
await middleware.transform_context(messages, ctx=ctx)
assert len(provider.calls) == calls_when_open + 1
assert ctx.extra["compaction_failures"] == 0
assert ctx.extra["compaction_fallback_runs"] == 0
async def test_half_open_failure_re_opens_breaker() -> None:
"""Half-open retry that fails snaps the breaker back to MAX_FAILURES."""
from cubeloop.middleware.compaction import _HALF_OPEN_AFTER_FALLBACK_RUNS
provider = _FakeSummaryProvider(raises=RuntimeError("down"))
middleware = _make_middleware(provider, max_tokens_before=1)
ctx = AgentContext(system_prompt="", messages=[], extra={})
messages: list[Message] = []
# 3 failures → breaker opens.
for i in range(3):
messages = [
*messages,
_user(f"t{i}a"),
_assistant(f"r{i}a"),
_user(f"t{i}b"),
_assistant(f"r{i}b"),
]
await middleware.transform_context(messages, ctx=ctx)
# Fallback-only runs until half-open is ready.
for i in range(_HALF_OPEN_AFTER_FALLBACK_RUNS):
messages = [*messages, _user(f"f{i}"), _assistant(f"a{i}")]
await middleware.transform_context(messages, ctx=ctx)
# Half-open turn: LLM still failing.
calls_before_retry = len(provider.calls)
messages = [*messages, _user("retry q"), _assistant("retry a")]
await middleware.transform_context(messages, ctx=ctx)
# LLM was attempted (half-open allowed one try) and failed.
assert len(provider.calls) == calls_before_retry + 1
# Breaker re-opens (failures back to MAX, not MAX+1).
assert ctx.extra["compaction_failures"] == 3
# --- coverage: _load_int with bad type ---
async def test_corrupt_failure_counter_treated_as_zero() -> None:
"""Non-numeric values in ctx.extra are treated as 0 — defensive parsing.
Covers both the ``isinstance`` reject path (wrong type) and the
``ValueError`` catch path (string that can't be parsed as int).
"""
provider = _FakeSummaryProvider()
middleware = _make_middleware(provider, max_tokens_before=1)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
_assistant("reply 3"),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={
"compaction_failures": "not-an-int", # ValueError in int()
"compaction_low_savings_count": ["bad", "shape"], # isinstance reject
"compaction_fallback_runs": None, # isinstance reject
},
)
await middleware.transform_context(messages, ctx=ctx)
# Compaction proceeded as if all counters were 0.
assert "compaction" in ctx.extra
assert ctx.extra["compaction_failures"] == 0 # success path
async def test_state_invalidation_clears_guard_counters() -> None:
"""When the persisted summary is invalidated (history replaced), the
breaker / anti-thrash counters must also reset — otherwise a fresh
conversation would skip the LLM on its first compaction because the
previous conversation hit MAX_FAILURES."""
provider = _FakeSummaryProvider(reply="summary")
middleware = _make_middleware(provider, max_tokens_before=1)
# New messages — refs in ctx.extra won't match, so state is invalidated.
messages: list[Message] = [
_user("brand new 1"),
_assistant("reply 1"),
_user("brand new 2"),
_assistant("reply 2"),
_user("brand new 3"),
_assistant("reply 3"),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={
"compaction": CompactionState(
summary="stale from previous conversation",
summarized_message_refs=["sha256:does-not-match"],
).model_dump(),
"compaction_until_msg_index": 1,
"compaction_failures": 3, # stale breaker — would gate LLM
"compaction_low_savings_count": 2, # stale guard — would skip
"compaction_fallback_runs": 99,
},
)
await middleware.transform_context(messages, ctx=ctx)
# The LLM was called (breaker counter cleared); fresh state written.
assert len(provider.calls) == 1
assert ctx.extra["compaction_failures"] == 0
# The new summary is real, not a fallback.
state = CompactionState.model_validate(ctx.extra["compaction"])
assert state.is_fallback is False
# Stale guard counters were cleared BEFORE the turn; the new turn may
# legitimately set them to small values. The point is that the STALE
# values (2 and 99) did not carry through.
assert ctx.extra.get("compaction_low_savings_count", 0) < 2
assert ctx.extra.get("compaction_fallback_runs", 0) < 99
# --- codex round 3: tail clamp only fires when tail would swallow history ---
async def test_keep_tail_tokens_below_threshold_honoured_verbatim() -> None:
"""A configured tail smaller than the threshold must NOT be silently
reduced. Codex P2: the original ``// 2`` clamp was over-eager."""
provider = _FakeSummaryProvider(reply="summary")
middleware = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="m", provider_id="faux"),
),
max_tokens_before_compact=100,
keep_tail_tokens=80, # below threshold — must be honoured as-is
min_compact_messages=2,
)
# Build messages that, combined with a tail of 80 tokens, leave enough
# prefix to summarise. With keep_tail clamped to 50 (the OLD bug), the
# tail would protect more recent history than the caller wanted.
messages: list[Message] = [_user("x" * 60) for _ in range(8)]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
await middleware.transform_context(messages, ctx=ctx)
# State written → boundary captured.
boundary = ctx.extra.get("compaction_until_msg_index")
assert boundary is not None and boundary > 0
# Compute what tail_start should be with the un-clamped 80-token budget.
# _user("x"*60) → 30 tokens each (60 chars / 2). tail budget 80 →
# last 2 messages fit (60 tokens, third would push to 90 > 80).
# Boundary should land at ≤ 6 (last 2 in tail).
# With the old `// 2` clamp (50 tokens), only 1 message fits; boundary
# would land at 7 — much more aggressive.
assert boundary <= 6
async def test_keep_tail_tokens_above_threshold_still_clamped() -> None:
"""Safety net is still active for the truly-broken configuration."""
provider = _FakeSummaryProvider(reply="summary")
middleware = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="m", provider_id="faux"),
),
max_tokens_before_compact=10,
keep_tail_tokens=200, # above threshold — clamp engages
min_compact_messages=2,
)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
_assistant("reply 3"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
await middleware.transform_context(messages, ctx=ctx)
# Clamp let compaction fire.
assert "compaction" in ctx.extra
assert len(provider.calls) == 1
async def test_under_threshold_does_not_silently_prune_tool_outputs() -> None:
"""Codex round 5 P2: when the un-pruned history is already under the
compaction threshold, the middleware must return the ORIGINAL messages,
not the pruned view. Otherwise old tool outputs are silently replaced
with one-liner placeholders on every turn, with no state recording the
loss."""
from cubeloop.providers.base import ToolCall, ToolResultMessage
provider = _FakeSummaryProvider()
# Big threshold so the un-pruned history stays under it.
middleware = _make_middleware(provider, max_tokens_before=100_000)
big_text = "important detail " * 200 # >> _PRUNE_KEEP_CHARS
messages: list[Message] = [
_user("q"),
AssistantMessage(
content=[ToolCall(id="c1", name="read_file", arguments={"p": "x"})]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="read_file",
content=[TextContent(text=big_text)],
),
_user("more"),
_assistant("done"),
_user("another"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx)
# No compaction happened.
assert provider.calls == []
assert "compaction" not in ctx.extra
# The original tool result content is intact in the returned view.
tool_result_msg = next(m for m in result if isinstance(m, ToolResultMessage))
assert tool_result_msg.content[0].text == big_text
async def test_no_safe_boundary_does_not_silently_prune_tool_outputs() -> None:
"""Codex round 6 P2: when over threshold but safe_boundary returns None
(no valid split point), the middleware must return original messages
rather than the pruned view."""
from cubeloop.providers.base import ToolCall, ToolResultMessage
provider = _FakeSummaryProvider()
# Threshold low enough that the conversation exceeds it.
middleware = _make_middleware(provider, max_tokens_before=10, keep_tail_tokens=1000)
big_text = "x" * 5000 # > _PRUNE_KEEP_CHARS
# Only 2 messages — too short for safe_boundary to find a valid split.
messages: list[Message] = [
AssistantMessage(
content=[ToolCall(id="c1", name="read_file", arguments={"p": "x"})]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="read_file",
content=[TextContent(text=big_text)],
),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx)
# No compaction (no valid boundary), no LLM call.
assert provider.calls == []
assert "compaction" not in ctx.extra
# The big tool result content must NOT have been silently pruned.
tool_result_msg = next(m for m in result if isinstance(m, ToolResultMessage))
assert tool_result_msg.content[0].text == big_text
async def test_anti_thrash_guard_skip_does_not_silently_prune() -> None:
"""Codex round 6 P2: when the anti-thrash guard fires, the returned view
must come from the un-pruned messages so the main model still sees the
full tool outputs."""
from cubeloop.providers.base import ToolCall, ToolResultMessage
provider = _FakeSummaryProvider()
big_text = "x" * 5000 # 2500 tokens via approx_tokens
# Threshold chosen so raw_tokens (~2515) > threshold (compaction
# triggers) but raw < 1.5 × threshold (emergency override skipped) and
# the boundary advance stays under _ANTI_THRASH_NEW_MSGS=8.
middleware = _make_middleware(provider, max_tokens_before=2000)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
AssistantMessage(
content=[ToolCall(id="c1", name="read_file", arguments={"p": "x"})]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="read_file",
content=[TextContent(text=big_text)],
),
_user("turn 3"),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={"compaction_low_savings_count": 2}, # guard tripped
)
result = await middleware.transform_context(messages, ctx=ctx)
# Guard fired — no LLM call, no state written.
assert provider.calls == []
assert "compaction" not in ctx.extra
# The original big tool result is intact in the returned view.
tool_result_msg = next(m for m in result if isinstance(m, ToolResultMessage))
assert tool_result_msg.content[0].text == big_text
# --- tool_result_compressor integration tests ---
def _make_middleware_with_compressor(
provider: _FakeSummaryProvider,
compressor: ToolResultCompressor,
*,
max_tokens_before: int = 20,
keep_tail_tokens: int = 8,
) -> CompactionMiddleware:
return CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="summary-model", provider_id="faux"),
),
max_tokens_before_compact=max_tokens_before,
keep_tail_tokens=keep_tail_tokens,
max_summary_tokens=512,
min_compact_messages=2,
tool_result_compressor=compressor,
)
async def test_compressor_preserved_text_appended_to_summary() -> None:
"""Preserved tool results appear in the summary message text."""
from cubeloop.providers.base import ToolCall, ToolResultMessage
provider = _FakeSummaryProvider(reply="conversation summary")
def compressor(msg: ToolResultMessage) -> str | None:
if msg.tool_name == "chip_metrics":
return "AAPL: $185.32"
return None
middleware = _make_middleware_with_compressor(provider, compressor)
big = "x" * 5000
messages: list[Message] = [
_user("show me AAPL"),
AssistantMessage(
content=[ToolCall(id="c1", name="chip_metrics", arguments={})]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="chip_metrics",
content=[TextContent(text=big)],
),
_user("and MSFT?"),
_assistant("looking up"),
_user("thanks"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx)
summary_msg = result[0]
assert isinstance(summary_msg, UserMessage)
assert "conversation summary" in summary_msg.content[0].text
assert "AAPL: $185.32" in summary_msg.content[0].text
assert "chip_metrics" in summary_msg.content[0].text
async def test_compressor_preserved_excluded_from_summarizer_input() -> None:
"""Preserved messages are not fed to the summarizer LLM."""
from cubeloop.providers.base import ToolCall, ToolResultMessage
provider = _FakeSummaryProvider(reply="summary")
def compressor(msg: ToolResultMessage) -> str | None:
if msg.tool_name == "chip_metrics":
return "kept"
return None
middleware = _make_middleware_with_compressor(provider, compressor)
big = "x" * 5000
messages: list[Message] = [
_user("query"),
AssistantMessage(
content=[ToolCall(id="c1", name="chip_metrics", arguments={})]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="chip_metrics",
content=[TextContent(text=big)],
),
_user("next"),
_assistant("ok"),
_user("go"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
await middleware.transform_context(messages, ctx=ctx)
assert len(provider.calls) == 1
transcript_text = provider.calls[0]["messages"][0].content[0].text
# The preserved tool result should not appear in the summarizer transcript.
assert big not in transcript_text
async def test_compressor_none_return_uses_default_pruning() -> None:
"""When compressor returns None for all messages, behavior is identical
to not having a compressor."""
from cubeloop.providers.base import ToolCall, ToolResultMessage
provider = _FakeSummaryProvider(reply="summary")
def compressor(msg: ToolResultMessage) -> str | None:
return None
middleware = _make_middleware_with_compressor(provider, compressor)
big = "x" * 5000
messages: list[Message] = [
_user("q"),
AssistantMessage(content=[ToolCall(id="c1", name="bash", arguments={})]),
ToolResultMessage(
tool_call_id="c1",
tool_name="bash",
content=[TextContent(text=big)],
),
_user("next"),
_assistant("ok"),
_user("go"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx)
summary_msg = result[0]
assert isinstance(summary_msg, UserMessage)
# No preserved section in the summary
assert "Preserved tool results" not in summary_msg.content[0].text
async def test_compressor_preserved_persists_across_compaction_rounds() -> None:
"""Preserved results from earlier rounds survive in subsequent compressed views."""
from cubeloop.providers.base import ToolCall, ToolResultMessage
provider = _FakeSummaryProvider(reply="round 1 summary")
def compressor(msg: ToolResultMessage) -> str | None:
if msg.tool_name == "chip_metrics":
return "preserved data"
return None
middleware = _make_middleware_with_compressor(
provider, compressor, max_tokens_before=20, keep_tail_tokens=4
)
# Round 1
messages: list[Message] = [
_user("q1"),
AssistantMessage(
content=[ToolCall(id="c1", name="chip_metrics", arguments={})]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="chip_metrics",
content=[TextContent(text="x" * 5000)],
),
_user("q2"),
_assistant("r2"),
_user("q3"),
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
await middleware.transform_context(messages, ctx=ctx)
# Verify preserved results are in state
state = CompactionState.model_validate(ctx.extra["compaction"])
assert len(state.preserved_tool_results) == 1
assert state.preserved_tool_results[0].text == "preserved data"
assert state.preserved_tool_results[0].tool_name == "chip_metrics"
# Round 2 — under threshold, returns compressed view with preserved data
provider2 = _FakeSummaryProvider(reply="round 2 summary")
middleware2 = _make_middleware_with_compressor(
provider2, compressor, max_tokens_before=100_000, keep_tail_tokens=4
)
result = await middleware2.transform_context(messages, ctx=ctx)
summary_msg = result[0]
assert "preserved data" in summary_msg.content[0].text
async def test_trailing_synthetic_control_does_not_age_current_tool_results() -> None:
"""A call-local control must not make same-turn tool evidence look old.
This is the production failure shape: one assistant proposes two tools, both
return large results, and an earlier transform appends a small synthetic
user control. The ordinary four-message history has no legal boundary at
``min_compact_messages=4``; the control must not manufacture one.
"""
from cubeloop.providers.base import (
ToolCall,
ToolResultMessage,
synthetic_user_message,
)
provider = _FakeSummaryProvider(reply="summary must not run")
middleware = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="summary-model", provider_id="faux"),
),
max_tokens_before_compact=55_000,
keep_tail_tokens=8_000,
max_summary_tokens=1_024,
min_compact_messages=4,
)
report_a = "CURRENT_REPORT_A_SENTINEL|" + "A" * 106_277
report_b = "CURRENT_REPORT_B_SENTINEL|" + "B" * 38_796
control = synthetic_user_message(
'{"candidate_schema_version":1,"required_action":"evaluate current evidence"}',
source="freshness_candidate",
)
messages: list[Message] = [
_user("Compare the latest two reports."),
AssistantMessage(
content=[
ToolCall(id="c1", name="report_a", arguments={}),
ToolCall(id="c2", name="report_b", arguments={}),
]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="report_a",
content=[TextContent(text=report_a)],
),
ToolResultMessage(
tool_call_id="c2",
tool_name="report_b",
content=[TextContent(text=report_b)],
),
control,
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx)
assert result == messages
assert result[-1] == control
assert report_a in result[2].content[0].text
assert report_b in result[3].content[0].text
assert provider.calls == []
assert "compaction" not in ctx.extra
async def test_trailing_controls_count_toward_compaction_threshold() -> None:
"""Controls stay in the size calculation even though they do not set the tail."""
from cubeloop.middleware.compaction.tokens import real_context_estimate
from cubeloop.providers.base import synthetic_user_message
provider = _FakeSummaryProvider(reply="combined view crossed threshold")
middleware = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="summary-model", provider_id="faux"),
),
max_tokens_before_compact=20,
keep_tail_tokens=4,
max_summary_tokens=128,
min_compact_messages=2,
)
history: list[Message] = [
_user("u1"),
_assistant("a1"),
_user("u2"),
_assistant("a2"),
_user("u3"),
_assistant("a3"),
]
control = synthetic_user_message("C" * 100, source="large_call_control")
messages = [*history, control]
assert real_context_estimate(history) < 20
assert real_context_estimate(messages) >= 20
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx)
assert len(provider.calls) == 1
assert "compaction" in ctx.extra
assert result[-1] == control
async def test_old_prefix_compacts_without_pruning_current_multi_tool_evidence() -> (
None
):
"""Older turns may compact while a current multi-tool turn stays raw."""
from cubeloop.providers.base import (
ToolCall,
ToolResultMessage,
synthetic_user_message,
)
provider = _FakeSummaryProvider(reply="old prefix summary")
middleware = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="summary-model", provider_id="faux"),
),
max_tokens_before_compact=8_000,
keep_tail_tokens=6_000,
max_summary_tokens=512,
min_compact_messages=4,
)
report_a = "RAW_CURRENT_A|" + "A" * 5_000
report_b = "RAW_CURRENT_B|" + "B" * 5_000
control_a = synthetic_user_message("policy A", source="policy_a")
control_b = synthetic_user_message("policy B", source="policy_b")
messages: list[Message] = [
_user("old user 1 " * 700),
_assistant("old answer 1 " * 700),
_user("old user 2 " * 700),
_assistant("old answer 2 " * 700),
_user("current request"),
AssistantMessage(
content=[
ToolCall(id="c1", name="report_a", arguments={}),
ToolCall(id="c2", name="report_b", arguments={}),
]
),
ToolResultMessage(
tool_call_id="c1",
tool_name="report_a",
content=[TextContent(text=report_a)],
),
ToolResultMessage(
tool_call_id="c2",
tool_name="report_b",
content=[TextContent(text=report_b)],
),
control_a,
control_b,
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
result = await middleware.transform_context(messages, ctx=ctx)
assert len(provider.calls) == 1
assert isinstance(result[0], UserMessage)
assert result[0].metadata.get("synthetic_source") == "compaction_summary"
assert result[-2:] == [control_a, control_b]
result_a = next(
message
for message in result
if isinstance(message, ToolResultMessage) and message.tool_call_id == "c1"
)
result_b = next(
message
for message in result
if isinstance(message, ToolResultMessage) and message.tool_call_id == "c2"
)
assert result_a.content[0].text == report_a
assert result_b.content[0].text == report_b
def test_split_only_detaches_trailing_synthetic_user_messages() -> None:
"""Plain user tails and synthetic tool results remain ordinary history."""
from cubeloop.middleware.compaction import (
_split_trailing_synthetic_user_controls,
)
from cubeloop.providers.base import (
ToolCall,
ToolResultMessage,
synthetic_user_message,
)
synthetic_result = ToolResultMessage(
tool_call_id="c1",
tool_name="audit",
content=[TextContent(text="synthetic cleanup result")],
metadata={"synthetic": True},
)
tool_history: list[Message] = [
_user("q"),
AssistantMessage(content=[ToolCall(id="c1", name="audit", arguments={})]),
synthetic_result,
]
history, controls = _split_trailing_synthetic_user_controls(tool_history)
assert history == tool_history
assert controls == []
plain_tail = [*tool_history, _user("real user tail")]
history, controls = _split_trailing_synthetic_user_controls(plain_tail)
assert history == plain_tail
assert controls == []
control_a = synthetic_user_message("a", source="a")
control_b = synthetic_user_message("b", source="b")
history, controls = _split_trailing_synthetic_user_controls(
[*plain_tail, control_a, control_b]
)
assert history == plain_tail
assert controls == [control_a, control_b]
async def test_compaction_state_refs_survive_trailing_control_becoming_internal() -> (
None
):
"""Suffix splitting does not change persisted prefix indices or refs."""
from cubeloop.providers.base import synthetic_user_message
provider = _FakeSummaryProvider(reply="stable summary")
compacting = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="summary-model", provider_id="faux"),
),
max_tokens_before_compact=1,
keep_tail_tokens=4,
max_summary_tokens=128,
min_compact_messages=2,
)
control = synthetic_user_message("continue", source="continuation")
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
_user("turn 3"),
_assistant("reply 3"),
control,
]
ctx = AgentContext(system_prompt="", messages=messages, extra={})
first = await compacting.transform_context(messages, ctx=ctx)
boundary = ctx.extra["compaction_until_msg_index"]
persisted_state = ctx.extra["compaction"]
assert first[-1] == control
under_threshold = CompactionMiddleware(
summary_model=BoundModel(
provider=_FakeSummaryProvider(),
spec=Model(id="summary-model", provider_id="faux"),
),
max_tokens_before_compact=1_000_000,
keep_tail_tokens=4,
min_compact_messages=2,
)
repeated = await under_threshold.transform_context(messages, ctx=ctx)
assert repeated[0].metadata.get("synthetic_source") == "compaction_summary"
assert repeated[-1] == control
assert ctx.extra["compaction_until_msg_index"] == boundary
assert ctx.extra["compaction"] == persisted_state
with_response = [*messages, _assistant("response after control")]
resumed = await under_threshold.transform_context(with_response, ctx=ctx)
assert resumed[0].metadata.get("synthetic_source") == "compaction_summary"
assert control in resumed
assert resumed[-1] == with_response[-1]
assert ctx.extra["compaction_until_msg_index"] == boundary
assert ctx.extra["compaction"] == persisted_state
# --- #233: a dropped summary must not take the trigger down with it ---
def test_message_ref_ignores_volatile_bookkeeping() -> None:
"""Identity is the message's content, not its bookkeeping.
``run_id`` / ``timestamp`` / ``metadata`` are rewritten after the message is
stored — the framework re-stamps ``run_id`` on messages it re-touches (the
injected ``todo_stale_reminder`` nudges did this every turn) and hosts write
per-turn snapshots into ``UserMessage.metadata``. Hashing them made refs
drift, which is what dropped the state in #233.
"""
baseline = UserMessage(content=[TextContent(text="hello")], run_id="run-1")
restamped = UserMessage(
content=[TextContent(text="hello")],
run_id="run-2",
timestamp=1_231.5,
)
snapshot_a = UserMessage(
content=[TextContent(text="hello")],
metadata={"memory_snapshot": {"captured_at": "2026-10-13T11:43:58Z"}},
)
snapshot_b = UserMessage(
content=[TextContent(text="hello")],
metadata={"memory_snapshot": {"captured_at": "2026-10-13T12:13:44Z"}},
)
assert message_ref(baseline) == message_ref(restamped)
assert message_ref(snapshot_a) == message_ref(snapshot_b)
# Content and tool linkage are identity and must still be hashed.
assert message_ref(baseline) != message_ref(
UserMessage(content=[TextContent(text="hello!")], run_id="run-1")
)
result = [
ToolResultMessage(
tool_call_id="c1", tool_name="t", content=[TextContent(text="x")]
),
ToolResultMessage(
tool_call_id="c2", tool_name="t", content=[TextContent(text="x")]
),
]
assert message_ref(result[0]) != message_ref(result[1])
def test_unset_message_id_does_not_change_the_content_hash() -> None:
"""Rows stored before ``id`` existed must keep their ref.
``model_dump`` now includes ``id: ""``. The hash fallback drops that key,
so a checkpoint written by the previous release still matches.
"""
message = UserMessage(content=[TextContent(text="hello")], run_id="run-1")
payload = message.model_dump(mode="json", exclude_none=True)
assert payload["id"] == ""
payload.pop("id")
for field in ("run_id", "timestamp", "metadata"):
payload.pop(field, None)
encoded = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
assert message_ref(message) == "sha256:" + hashlib.sha256(encoded).hexdigest()
def _stale_state_for(messages: list[Message]) -> CompactionState:
"""A state whose refs describe a *different* history — the shape of #233."""
return CompactionState(
summary="stale summary from a history that no longer matches",
summarized_message_refs=["sha256:does-not-match"],
)
async def test_over_limit_raw_history_is_compacted_after_state_invalidation() -> None:
"""The trigger must size the raw history it is about to send.
Regression (#233): ``real_context_estimate`` anchors on the most recent
usage-bearing assistant and adds only what follows it, so it reports the
size of the summary-era prompt — not the raw history that replaces it once
the state is dropped. On the real conversation it returned 57,278 for both
the compacted view and the 901-message raw history (actual send:
>= 256,001 tokens). The check saw 57,278 < 80,281 and returned the
over-limit history without compacting.
"""
provider = _FakeSummaryProvider(reply="summary")
middleware = CompactionMiddleware(
summary_model=BoundModel(
provider=provider,
spec=Model(id="summary-model", provider_id="faux"),
),
# The production values from #233.
max_tokens_before_compact=80_281,
keep_tail_tokens=8,
min_compact_messages=2,
)
messages: list[Message] = [
_user("turn 1"),
_assistant("reply 1"),
# 200_000 chars ≈ 100_000 approx tokens: on its own well over the
# 80_281 threshold. It sits BEFORE the anchor, which is exactly why the
# anchor-based estimate cannot see it.
_user("x" * 200_000),
AssistantMessage(
content=[TextContent(text="ok")],
usage=Usage(input_tokens=57_000),
),
_user("continue"),
_assistant("reply"),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={
"compaction": _stale_state_for(messages).model_dump(),
"compaction_until_msg_index": 3,
},
)
result = await middleware.transform_context(messages, ctx=ctx)
# The state was dropped, so compaction had to run on the raw history.
assert len(provider.calls) == 1
assert ctx.extra["compaction_until_msg_index"] > 0
assert len(result) < len(messages)
assert result[0].metadata.get("synthetic_source") == "compaction_summary"
# The over-limit prefix is gone; only the protected tail survived.
assert not any(
isinstance(block, TextContent) and len(block.text) > 100_000
for message in result
if isinstance(message, (UserMessage, AssistantMessage))
for block in message.content
if isinstance(block, TextContent)
)
async def test_char_floor_does_not_re_trigger_on_a_valid_compacted_view() -> None:
"""The floor covers only the dropped-state fallback.
With a live summary the view is already compacted: the raw history behind it
must not drive the trigger, or every turn would re-summarise. Guards against
the fix for #233 being applied unconditionally.
"""
provider = _FakeSummaryProvider(reply="summary")
middleware = _make_middleware(
provider, max_tokens_before=80_281, keep_tail_tokens=8
)
messages: list[Message] = [
# A raw prefix that is far over the threshold, but already summarised.
_user("x" * 200_000),
_assistant("reply 1"),
_user("turn 2"),
_assistant("reply 2"),
# The live tail — small, and with no usage of its own.
_user("continue"),
_assistant("reply 3"),
]
boundary = 4
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={
"compaction": CompactionState(
summary="live summary",
summarized_message_refs=message_refs(messages[:boundary]),
).model_dump(),
"compaction_until_msg_index": boundary,
},
)
result = await middleware.transform_context(messages, ctx=ctx)
assert provider.calls == []
assert len(result) == 3
assert result[0].metadata.get("synthetic_source") == "compaction_summary"
assert "live summary" in result[0].content[0].text
assert result[1:] == messages[boundary:]
assert ctx.extra["compaction_until_msg_index"] == boundary
async def test_dropping_compaction_state_is_logged(caplog: Any) -> None:
"""A dropped summary means a raw-history send; it must not be silent."""
provider = _FakeSummaryProvider(reply="summary")
middleware = _make_middleware(provider, max_tokens_before=1_000_000)
messages: list[Message] = [
_user("brand new 1"),
_assistant("reply 1"),
_user("brand new 2"),
_assistant("reply 2"),
]
ctx = AgentContext(
system_prompt="",
messages=messages,
extra={
"compaction": _stale_state_for(messages).model_dump(),
"compaction_until_msg_index": 2,
},
)
with caplog.at_level(logging.WARNING):
await middleware.transform_context(messages, ctx=ctx)
assert any(
"dropping compaction state" in record.getMessage() for record in caplog.records
)