Skip to content

Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.

feat(toin): add TOIN + CCR integration to IntelligentContextManager

chopratejasfef02fa0537f
diff --git a/docs/transforms.md b/docs/transforms.md
index e83c2966e..307a54354 100644
--- a/docs/transforms.md
+++ b/docs/transforms.md
@@ -249,9 +249,16 @@ Based on how much over budget you are:
| < 10% over | COMPRESS_FIRST | Try deeper compression |
| >= 10% over | DROP_BY_SCORE | Drop lowest-scored messages |
-### TOIN Integration
+### TOIN + CCR Integration
+
+IntelligentContextManager is a **message-level compressor**. Just like SmartCrusher compresses items in a JSON array, IntelligentContext "compresses" messages in a conversation by dropping low-value ones.
+
+**Bidirectional TOIN integration:**
-When TOIN is available, scoring uses learned patterns:
+1. **Scoring uses TOIN patterns**: Learned retrieval rates and field semantics inform importance scores
+2. **Drops are recorded to TOIN**: When messages are dropped, TOIN learns the pattern
+3. **CCR stores originals**: Dropped messages are stored in CCR for potential retrieval
+4. **Retrievals feed back to TOIN**: If users retrieve dropped messages, TOIN learns to score those patterns higher
```python
from headroom.telemetry import get_toin
@@ -259,12 +266,22 @@ from headroom.telemetry import get_toin
toin = get_toin()
manager = IntelligentContextManager(config, toin=toin)
-# TOIN provides:
-# - retrieval_rate: How often this tool's output is retrieved (high = important)
+# TOIN provides (for scoring):
+# - retrieval_rate: How often this message pattern is retrieved (high = important)
# - field_semantics: Learned field types (error_indicator, identifier, etc.)
# - commonly_retrieved_fields: Fields that users frequently need
+
+# TOIN receives (from drops):
+# - Message pattern signatures (role counts, has_tools, has_errors)
+# - Token counts (original vs marker size)
+# - Retrieval feedback when users access CCR
```
+**What this means:**
+- When you drop a message pattern and users frequently retrieve it, TOIN learns to score it higher next time
+- When you drop a pattern and no one retrieves it, that confirms it was safe to drop
+- The feedback loop improves drop decisions across all users, not just in one session
+
### Example: Before vs After
**RollingWindow (position-based):**
diff --git a/headroom/transforms/intelligent_context.py b/headroom/transforms/intelligent_context.py
index 0bc5a4c54..bbfb23edf 100644
--- a/headroom/transforms/intelligent_context.py
+++ b/headroom/transforms/intelligent_context.py
@@ -16,10 +16,20 @@ Strategy Selection (in order of preference):
- SUMMARIZE: When <summarize_threshold over budget and summarization_enabled,
create anchored summaries of older messages (requires summarize_fn callback)
- DROP_BY_SCORE: When significantly over budget, drop lowest-scored messages
+
+TOIN + CCR Integration:
+IntelligentContextManager is a message-level compressor. Just like SmartCrusher
+compresses items in a JSON array, IntelligentContext "compresses" messages in
+a conversation by dropping low-value ones. This means:
+- Dropped messages are stored in CCR for potential retrieval
+- Drops are recorded to TOIN so it learns which message patterns shouldn't be dropped
+- When users ask about dropped content, TOIN learns from that retrieval signal
"""
from __future__ import annotations
+import hashlib
+import json
import logging
from enum import Enum
from typing import TYPE_CHECKING, Any
@@ -32,6 +42,7 @@ from .base import Transform
from .scoring import MessageScore, MessageScorer
if TYPE_CHECKING:
+ from ..cache.compression_store import CompressionStore
from ..telemetry.toin import ToolIntelligenceNetwork
from .content_router import ContentRouter
from .progressive_summarizer import ProgressiveSummarizer, SummarizeFn
@@ -39,6 +50,74 @@ if TYPE_CHECKING:
logger = logging.getLogger(__name__)
+def _create_message_signature(messages: list[dict[str, Any]]) -> Any:
+ """Create a ToolSignature for dropped messages.
+
+ This allows TOIN to track patterns of which message types get dropped
+ and later retrieved, learning to preserve important message patterns.
+
+ Args:
+ messages: List of messages being dropped.
+
+ Returns:
+ A ToolSignature for TOIN tracking.
+ """
+ try:
+ from ..telemetry.models import ToolSignature
+
+ # Create signature based on message structure
+ # Group by role to create a pattern signature
+ role_counts: dict[str, int] = {}
+ has_tool_content = False
+ has_error_indicators = False
+ total_content_length = 0
+
+ for msg in messages:
+ role = msg.get("role", "unknown")
+ role_counts[role] = role_counts.get(role, 0) + 1
+
+ content = msg.get("content", "")
+ if isinstance(content, str):
+ total_content_length += len(content)
+ # Check for error patterns (learned from TOIN, but basic heuristic here)
+ content_lower = content.lower()
+ if any(
+ indicator in content_lower
+ for indicator in ["error", "fail", "exception", "traceback"]
+ ):
+ has_error_indicators = True
+ elif isinstance(content, list):
+ # Anthropic format with content blocks
+ for block in content:
+ if isinstance(block, dict):
+ if block.get("type") in ("tool_result", "tool_use"):
+ has_tool_content = True
+
+ # Check for tool calls
+ if msg.get("tool_calls") or msg.get("role") == "tool":
+ has_tool_content = True
+
+ # Create deterministic hash from structure
+ structure = {
+ "roles": sorted(role_counts.items()),
+ "has_tools": has_tool_content,
+ "has_errors": has_error_indicators,
+ "avg_length_bucket": total_content_length // 1000, # Bucket by KB
+ }
+ structure_str = json.dumps(structure, sort_keys=True)
+ structure_hash = hashlib.sha256(f"message_drop:{structure_str}".encode()).hexdigest()[:24]
+
+ return ToolSignature(
+ structure_hash=structure_hash,
+ field_count=len(role_counts),
+ has_nested_objects=has_tool_content,
+ has_arrays=False,
+ max_depth=1,
+ )
+ except ImportError:
+ return None
+
+
class ContextStrategy(Enum):
"""Strategy for handling over-budget context."""
@@ -107,6 +186,9 @@ class IntelligentContextManager(Transform):
# Lazy-loaded progressive summarizer for SUMMARIZE strategy
self._progressive_summarizer: ProgressiveSummarizer | None = None
+ # Lazy-loaded compression store for CCR integration
+ self._compression_store: CompressionStore | None = None
+
def should_apply(
self,
messages: list[dict[str, Any]],
@@ -310,6 +392,23 @@ class IntelligentContextManager(Transform):
if candidate["type"] == "tool_unit":
tool_units_dropped += 1
+ # ========== TOIN + CCR INTEGRATION ==========
+ # Before removing messages, store them in CCR and record to TOIN
+ ccr_ref_id: str | None = None
+ if indices_to_drop:
+ # Calculate total tokens being dropped
+ tokens_dropped = sum(
+ tokenizer.count_message(result_messages[idx])
+ for idx in indices_to_drop
+ if idx < len(result_messages)
+ )
+
+ # Store dropped messages in CCR for potential retrieval
+ ccr_ref_id = self._store_dropped_in_ccr(result_messages, indices_to_drop)
+
+ # Record the drop event to TOIN for cross-user learning
+ self._record_drops_to_toin(result_messages, indices_to_drop, tokens_dropped)
+
# Remove dropped messages (reverse order)
for idx in sorted(indices_to_drop, reverse=True):
if idx < len(result_messages):
@@ -327,7 +426,15 @@ class IntelligentContextManager(Transform):
current_tokens,
)
- marker = create_dropped_context_marker("intelligent_cap", dropped_count)
+ # Create marker with CCR reference if available
+ if ccr_ref_id:
+ marker = (
+ f"[Earlier context compressed: {dropped_count} message(s) dropped by "
+ f"importance scoring. Full content available via ccr_retrieve "
+ f"tool with reference '{ccr_ref_id}'.]"
+ )
+ else:
+ marker = create_dropped_context_marker("intelligent_cap", dropped_count)
markers_inserted.append(marker)
# Insert marker after system messages
@@ -777,3 +884,138 @@ class IntelligentContextManager(Transform):
except Exception as e:
logger.warning("SUMMARIZE: summarization failed: %s", e)
return messages, [], 0
+
+ def _get_compression_store(self) -> CompressionStore | None:
+ """Get or create compression store for CCR integration (lazy load)."""
+ if self._compression_store is None:
+ try:
+ from ..cache.compression_store import get_compression_store
+
+ self._compression_store = get_compression_store()
+ except ImportError:
+ logger.debug("CompressionStore not available for CCR integration")
+ return self._compression_store
+
+ def _store_dropped_in_ccr(
+ self,
+ messages: list[dict[str, Any]],
+ indices_to_drop: set[int],
+ ) -> str | None:
+ """Store dropped messages in CCR for potential retrieval.
+
+ This allows the LLM to retrieve the full context of dropped messages
+ if it needs them later, making the drop reversible.
+
+ Args:
+ messages: Full message list.
+ indices_to_drop: Set of indices being dropped.
+
+ Returns:
+ CCR reference ID if stored, None otherwise.
+ """
+ store = self._get_compression_store()
+ if store is None:
+ return None
+
+ # Collect the messages being dropped
+ dropped_messages = []
+ for idx in sorted(indices_to_drop):
+ if idx < len(messages):
+ dropped_messages.append(messages[idx])
+
+ if not dropped_messages:
+ return None
+
+ try:
+ # Serialize dropped messages for storage
+ dropped_content = json.dumps(dropped_messages, indent=2, default=str)
+
+ # Create a summary for the compressed version
+ summary_parts = []
+ role_counts: dict[str, int] = {}
+ for msg in dropped_messages:
+ role = msg.get("role", "unknown")
+ role_counts[role] = role_counts.get(role, 0) + 1
+
+ for role, count in sorted(role_counts.items()):
+ summary_parts.append(f"{count} {role}")
+
+ summary = f"[Dropped {len(dropped_messages)} messages: {', '.join(summary_parts)}. Use ccr_retrieve to access full content.]"
+
+ # Store in CCR
+ ref_id = store.store(
+ original=dropped_content,
+ compressed=summary,
+ tool_name="intelligent_context_drop",
+ tool_call_id=f"drop_{hashlib.sha256(dropped_content.encode()).hexdigest()[:12]}",
+ )
+
+ logger.debug(
+ "CCR: stored %d dropped messages under ref %s",
+ len(dropped_messages),
+ ref_id,
+ )
+ return ref_id
+
+ except Exception as e:
+ logger.warning("CCR: failed to store dropped messages: %s", e)
+ return None
+
+ def _record_drops_to_toin(
+ self,
+ messages: list[dict[str, Any]],
+ indices_to_drop: set[int],
+ tokens_dropped: int,
+ ) -> None:
+ """Record message drops to TOIN for cross-user learning.
+
+ This allows TOIN to learn patterns about which message types
+ are frequently dropped and later retrieved, helping it adjust
+ importance scores for similar patterns.
+
+ Args:
+ messages: Full message list.
+ indices_to_drop: Set of indices being dropped.
+ tokens_dropped: Total tokens being dropped.
+ """
+ if self.toin is None:
+ return
+
+ # Collect dropped messages for signature creation
+ dropped_messages = []
+ for idx in sorted(indices_to_drop):
+ if idx < len(messages):
+ dropped_messages.append(messages[idx])
+
+ if not dropped_messages:
+ return
+
+ try:
+ signature = _create_message_signature(dropped_messages)
+ if signature is None:
+ return
+
+ # Record the compression (drop) event
+ # compressed_count is 1 since we replace N messages with 1 marker
+ # But we record the marker size (~50 tokens) as the "compressed" version
+ marker_tokens = 50 # Approximate marker size
+
+ self.toin.record_compression(
+ tool_signature=signature,
+ original_count=len(dropped_messages),
+ compressed_count=1, # The marker message
+ original_tokens=tokens_dropped,
+ compressed_tokens=marker_tokens,
+ strategy="intelligent_context_drop",
+ query_context="message_level_compression",
+ )
+
+ logger.debug(
+ "TOIN: recorded drop of %d messages (%d tokens) with signature %s",
+ len(dropped_messages),
+ tokens_dropped,
+ signature.structure_hash[:12],
+ )
+
+ except Exception as e:
+ logger.warning("TOIN: failed to record message drops: %s", e)
diff --git a/tests/test_proxy_intelligent_context.py b/tests/test_proxy_intelligent_context.py
new file mode 100644
index 000000000..40d8ca56a
--- /dev/null
+++ b/tests/test_proxy_intelligent_context.py
@@ -0,0 +1,542 @@
+"""Integration tests for IntelligentContextManager in the proxy server.
+
+These tests verify that IntelligentContextManager is correctly wired into
+the proxy server and that it provides smarter context management than
+the legacy RollingWindow.
+
+Tests cover:
+1. Configuration options work correctly
+2. IntelligentContextManager is used when enabled (default)
+3. RollingWindow is used when intelligent_context=False
+4. Score-based dropping works differently than age-based
+5. TOIN integration provides learned patterns
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from headroom.config import IntelligentContextConfig
+from headroom.proxy.server import HeadroomProxy, ProxyConfig
+from headroom.tokenizer import Tokenizer
+from headroom.tokenizers import EstimatingTokenCounter
+from headroom.transforms import IntelligentContextManager, RollingWindow
+
+# =============================================================================
+# Test Fixtures
+# =============================================================================
+
+
+def tokenizer() -> Tokenizer:
+ """Create a tokenizer for testing."""
+ return Tokenizer(EstimatingTokenCounter())
+
+
+def simple_messages() -> list[dict[str, Any]]:
+ """Simple conversation for testing."""
+ return [
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Hello!"},
+ {"role": "assistant", "content": "Hi there! How can I help?"},
+ {"role": "user", "content": "Tell me about Python."},
+ {"role": "assistant", "content": "Python is a programming language."},
+ ]
+
+
+def messages_with_tools() -> list[dict[str, Any]]:
+ """Conversation with tool calls."""
+ return [
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "Search for something."},
+ {
+ "role": "assistant",
+ "content": "Let me search.",
+ "tool_calls": [
+ {
+ "id": "call_1",
+ "type": "function",
+ "function": {"name": "search", "arguments": "{}"},
+ }
+ ],
+ },
+ {"role": "tool", "tool_call_id": "call_1", "content": '{"results": ["item1", "item2"]}'},
+ {"role": "assistant", "content": "Found results."},
+ {"role": "user", "content": "Thanks!"},
+ {"role": "assistant", "content": "You're welcome!"},
+ ]
+
+
+def long_messages() -> list[dict[str, Any]]:
+ """Long conversation that will exceed token limits."""
+ messages = [{"role": "system", "content": "You are a helpful assistant. " * 50}]
+ for i in range(20):
+ messages.append({"role": "user", "content": f"Question {i}: " + "x" * 500})
+ messages.append({"role": "assistant", "content": f"Answer {i}: " + "y" * 500})
+ return messages
+
+
+# =============================================================================
+# Test ProxyConfig
+# =============================================================================
+
+
+class TestProxyConfigIntelligentContext:
+ """Test that ProxyConfig has correct intelligent context options."""
+
+ def test_intelligent_context_enabled_by_default(self):
+ """intelligent_context should be True by default."""
+ config = ProxyConfig()
+ assert config.intelligent_context is True
+
+ def test_intelligent_context_scoring_enabled_by_default(self):
+ """intelligent_context_scoring should be True by default."""
+ config = ProxyConfig()
+ assert config.intelligent_context_scoring is True
+
+ def test_intelligent_context_compress_first_enabled_by_default(self):
+ """intelligent_context_compress_first should be True by default."""
+ config = ProxyConfig()
+ assert config.intelligent_context_compress_first is True
+
+ def test_can_disable_intelligent_context(self):
+ """Should be able to disable intelligent_context."""
+ config = ProxyConfig(intelligent_context=False)
+ assert config.intelligent_context is False
+
+ def test_can_disable_scoring(self):
+ """Should be able to disable importance scoring."""
+ config = ProxyConfig(intelligent_context_scoring=False)
+ assert config.intelligent_context_scoring is False
+
+
+# =============================================================================
+# Test Proxy Initialization
+# =============================================================================
+
+
+class TestProxyIntelligentContextInit:
+ """Test that proxy initializes with correct context manager."""
+
+ def test_uses_intelligent_context_by_default(self):
+ """Proxy should use IntelligentContextManager by default."""
+ config = ProxyConfig(optimize=True, intelligent_context=True)
+ proxy = HeadroomProxy(config)
+
+ # Check that the context manager status is set correctly
+ assert proxy._context_manager_status == "intelligent"
+
+ # Check that the pipeline contains IntelligentContextManager
+ transforms = proxy.anthropic_pipeline.transforms
+ context_managers = [t for t in transforms if isinstance(t, IntelligentContextManager)]
+ assert len(context_managers) == 1
+
+ def test_uses_rolling_window_when_disabled(self):
+ """Proxy should use RollingWindow when intelligent_context=False."""
+ config = ProxyConfig(optimize=True, intelligent_context=False)
+ proxy = HeadroomProxy(config)
+
+ # Check that the context manager status is set correctly
+ assert proxy._context_manager_status == "rolling_window"
+
+ # Check that the pipeline contains RollingWindow, not IntelligentContextManager
+ transforms = proxy.anthropic_pipeline.transforms
+ rolling_windows = [t for t in transforms if isinstance(t, RollingWindow)]
+ intelligent_managers = [t for t in transforms if isinstance(t, IntelligentContextManager)]
+ assert len(rolling_windows) == 1
+ assert len(intelligent_managers) == 0
+
+ def test_smart_routing_mode_uses_intelligent_context(self):
+ """Smart routing mode should also use IntelligentContextManager."""
+ config = ProxyConfig(optimize=True, smart_routing=True, intelligent_context=True)
+ proxy = HeadroomProxy(config)
+
+ assert proxy._context_manager_status == "intelligent"
+ transforms = proxy.anthropic_pipeline.transforms
+ context_managers = [t for t in transforms if isinstance(t, IntelligentContextManager)]
+ assert len(context_managers) == 1
+
+ def test_legacy_mode_uses_intelligent_context(self):
+ """Legacy (non-smart-routing) mode should also use IntelligentContextManager."""
+ config = ProxyConfig(optimize=True, smart_routing=False, intelligent_context=True)
+ proxy = HeadroomProxy(config)
+
+ assert proxy._context_manager_status == "intelligent"
+ transforms = proxy.anthropic_pipeline.transforms
+ context_managers = [t for t in transforms if isinstance(t, IntelligentContextManager)]
+ assert len(context_managers) == 1
+
+
+# =============================================================================
+# Test IntelligentContextManager Configuration
+# =============================================================================
+
+
+class TestIntelligentContextManagerConfig:
+ """Test that IntelligentContextManager receives correct config."""
+
+ def test_keep_last_turns_passed_correctly(self):
+ """keep_last_turns from ProxyConfig should be passed to context manager."""
+ config = ProxyConfig(intelligent_context=True, keep_last_turns=5)
+ proxy = HeadroomProxy(config)
+
+ transforms = proxy.anthropic_pipeline.transforms
+ icm = next(t for t in transforms if isinstance(t, IntelligentContextManager))
+
+ assert icm.config.keep_last_turns == 5
+
+ def test_scoring_disabled_when_configured(self):
+ """importance_scoring should be disabled when scoring=False."""
+ config = ProxyConfig(intelligent_context=True, intelligent_context_scoring=False)
+ proxy = HeadroomProxy(config)
+
+ transforms = proxy.anthropic_pipeline.transforms
+ icm = next(t for t in transforms if isinstance(t, IntelligentContextManager))
+
+ assert icm.config.use_importance_scoring is False
+ assert icm.config.toin_integration is False
+
+ def test_compress_first_threshold_set_correctly(self):
+ """compress_threshold should be 0.10 when compress_first=True, 0.0 otherwise."""
+ # With compress_first enabled
+ config = ProxyConfig(intelligent_context=True, intelligent_context_compress_first=True)
+ proxy = HeadroomProxy(config)
+ transforms = proxy.anthropic_pipeline.transforms
+ icm = next(t for t in transforms if isinstance(t, IntelligentContextManager))
+ assert icm.config.compress_threshold == 0.10
+
+ # With compress_first disabled
+ config2 = ProxyConfig(intelligent_context=True, intelligent_context_compress_first=False)
+ proxy2 = HeadroomProxy(config2)
+ transforms2 = proxy2.anthropic_pipeline.transforms
+ icm2 = next(t for t in transforms2 if isinstance(t, IntelligentContextManager))
+ assert icm2.config.compress_threshold == 0.0
+
+
+# =============================================================================
+# Test Context Management Behavior
+# =============================================================================
+
+
+class TestIntelligentContextBehavior:
+ """Test that IntelligentContextManager behaves correctly."""
+
+ def test_under_budget_no_changes(self, simple_messages, tokenizer):
+ """Messages under budget should not be modified."""
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=2,
+ )
+ )
+
+ result = icm.apply(
+ simple_messages,
+ tokenizer,
+ model_limit=128000, # Very high limit
+ output_buffer=4000,
+ )
+
+ # Should not modify messages when under budget
+ assert len(result.messages) == len(simple_messages)
+ assert result.tokens_before == result.tokens_after
+
+ def test_over_budget_drops_messages(self, long_messages, tokenizer):
+ """Messages over budget should be dropped."""
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=2,
+ )
+ )
+
+ # Use a small limit to force dropping
+ result = icm.apply(
+ long_messages,
+ tokenizer,
+ model_limit=5000,
+ output_buffer=1000,
+ )
+
+ # Should have fewer messages
+ assert len(result.messages) < len(long_messages)
+ assert result.tokens_after < result.tokens_before
+
+ def test_protects_system_message(self, long_messages, tokenizer):
+ """System message should never be dropped."""
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=1,
+ )
+ )
+
+ result = icm.apply(
+ long_messages,
+ tokenizer,
+ model_limit=3000,
+ output_buffer=500,
+ )
+
+ # System message should still be present
+ system_messages = [m for m in result.messages if m.get("role") == "system"]
+ assert len(system_messages) == 1
+
+ def test_protects_last_turns(self, long_messages, tokenizer):
+ """Last N turns should be protected."""
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=2,
+ )
+ )
+
+ result = icm.apply(
+ long_messages,
+ tokenizer,
+ model_limit=5000,
+ output_buffer=1000,
+ )
+
+ # Last messages should be the same as original
+ original_last_user = None
+ for msg in reversed(long_messages):
+ if msg.get("role") == "user":
+ original_last_user = msg["content"]
+ break
+
+ result_last_user = None
+ for msg in reversed(result.messages):
+ if msg.get("role") == "user":
+ result_last_user = msg["content"]
+ break
+
+ assert original_last_user == result_last_user
+
+ def test_tool_unit_atomicity(self, messages_with_tools, tokenizer):
+ """Tool calls and responses should be dropped together."""
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=1,
+ )
+ )
+
+ # Force dropping by using very small limit
+ result = icm.apply(
+ messages_with_tools,
+ tokenizer,
+ model_limit=500,
+ output_buffer=100,
+ )
+
+ # Check that we don't have orphaned tool responses
+ tool_call_ids = set()
+ for msg in result.messages:
+ if msg.get("tool_calls"):
+ for tc in msg["tool_calls"]:
+ tool_call_ids.add(tc.get("id"))
+
+ for msg in result.messages:
+ if msg.get("role") == "tool":
+ tool_call_id = msg.get("tool_call_id")
+ # Either the tool response is dropped, or its call is present
+ if tool_call_id:
+ # This is a simplified check - in reality we'd check parent
+ pass # Tool responses should have corresponding calls
+
+ def test_inserts_dropped_context_marker(self, long_messages, tokenizer):
+ """Should insert a marker when messages are dropped."""
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=2,
+ )
+ )
+
+ result = icm.apply(
+ long_messages,
+ tokenizer,
+ model_limit=5000,
+ output_buffer=1000,
+ )
+
+ # Check for dropped context marker (either standard or CCR-aware format)
+ marker_found = False
+ for msg in result.messages:
+ content = msg.get("content", "")
+ if isinstance(content, str) and (
+ "headroom:dropped_context" in content or "Earlier context compressed:" in content
+ ):
+ marker_found = True
+ break
+
+ assert marker_found, "Dropped context marker should be inserted"
+
+
+# =============================================================================
+# Test Score-Based vs Age-Based Dropping
+# =============================================================================
+
+
+class TestScoreBasedDropping:
+ """Test that score-based dropping is different from age-based."""
+
+ def test_scoring_enabled_uses_importance(self, tokenizer):
+ """With scoring enabled, should use importance scores."""
+ # Create messages with substantial content to exceed budget
+ # Need ~600+ tokens to exceed 500 limit - 100 output buffer = 400 effective
+ messages = [
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "CRITICAL ERROR: " + "x" * 500}, # High importance
+ {"role": "assistant", "content": "I see the critical error. " + "y" * 500},
+ {"role": "user", "content": "Just a simple question. " + "z" * 500}, # Low importance
+ {"role": "assistant", "content": "Sure, I can help. " + "a" * 500},
+ {"role": "user", "content": "Another simple question. " + "b" * 500}, # Low importance
+ {"role": "assistant", "content": "Here's the answer. " + "c" * 500},
+ ]
+
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=1,
+ use_importance_scoring=True,
+ )
+ )
+
+ result = icm.apply(
+ messages,
+ tokenizer,
+ model_limit=300, # Tight budget forces dropping
+ output_buffer=50,
+ )
+
+ # With importance scoring, lower-scored messages are dropped first
+ # This is different from RollingWindow which drops oldest first
+ assert len(result.messages) < len(messages)
+
+ def test_scoring_disabled_uses_position(self, tokenizer):
+ """With scoring disabled, should use position-based dropping."""
+ # Create messages with substantial content to exceed budget
+ # Need ~600+ tokens to exceed budget
+ messages = [
+ {"role": "system", "content": "You are a helpful assistant."},
+ {"role": "user", "content": "First message. " + "x" * 500},
+ {"role": "assistant", "content": "First response. " + "y" * 500},
+ {"role": "user", "content": "Second message. " + "z" * 500},
+ {"role": "assistant", "content": "Second response. " + "a" * 500},
+ {"role": "user", "content": "Third message. " + "b" * 500},
+ {"role": "assistant", "content": "Third response. " + "c" * 500},
+ ]
+
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=1,
+ use_importance_scoring=False, # Position-based
+ )
+ )
+
+ result = icm.apply(
+ messages,
+ tokenizer,
+ model_limit=300, # Tight budget forces dropping
+ output_buffer=50,
+ )
+
+ # With position-based, oldest messages should be dropped first
+ # (similar to RollingWindow behavior)
+ assert len(result.messages) < len(messages)
+
+
+# =============================================================================
+# Test TOIN Integration
+# =============================================================================
+
+
+class TestTOINIntegration:
+ """Test that TOIN integration works correctly."""
+
+ def test_toin_passed_when_scoring_enabled(self):
+ """TOIN should be passed to IntelligentContextManager when scoring enabled."""
+ config = ProxyConfig(intelligent_context=True, intelligent_context_scoring=True)
+ proxy = HeadroomProxy(config)
+
+ transforms = proxy.anthropic_pipeline.transforms
+ icm = next(t for t in transforms if isinstance(t, IntelligentContextManager))
+
+ # TOIN should be set
+ assert icm.toin is not None
+
+ def test_toin_not_passed_when_scoring_disabled(self):
+ """TOIN should not be passed when scoring disabled."""
+ config = ProxyConfig(intelligent_context=True, intelligent_context_scoring=False)
+ proxy = HeadroomProxy(config)
+
+ transforms = proxy.anthropic_pipeline.transforms
+ icm = next(t for t in transforms if isinstance(t, IntelligentContextManager))
+
+ # TOIN should not be set
+ assert icm.toin is None
+
+
+# =============================================================================
+# Test Transforms Applied Tracking
+# =============================================================================
+
+
+class TestTransformsApplied:
+ """Test that transforms_applied is populated correctly."""
+
+ def test_reports_intelligent_cap_when_dropping(self, long_messages, tokenizer):
+ """Should report 'intelligent_cap' in transforms_applied."""
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=2,
+ )
+ )
+
+ result = icm.apply(
+ long_messages,
+ tokenizer,
+ model_limit=5000,
+ output_buffer=1000,
+ )
+
+ # Should have intelligent_cap in transforms_applied
+ assert any("intelligent_cap" in t for t in result.transforms_applied)
+
+ def test_no_transforms_when_under_budget(self, simple_messages, tokenizer):
+ """Should not report transforms when under budget."""
+ icm = IntelligentContextManager(
+ config=IntelligentContextConfig(
+ enabled=True,
+ keep_system=True,
+ keep_last_turns=2,
+ )
+ )
+
+ result = icm.apply(
+ simple_messages,
+ tokenizer,
+ model_limit=128000,
+ output_buffer=4000,
+ )
+
+ # No transforms should be applied
+ assert len(result.transforms_applied) == 0
diff --git a/tests/test_transforms/test_intelligent_context.py b/tests/test_transforms/test_intelligent_context.py
index fa06a17f7..558c5225a 100644
--- a/tests/test_transforms/test_intelligent_context.py
+++ b/tests/test_transforms/test_intelligent_context.py
@@ -273,9 +273,11 @@ class TestApplyBasic:
# Should have marker inserted
assert len(result.markers_inserted) > 0
- # Marker should be in messages
+ # Marker should be in messages (either standard or CCR-aware format)
marker_found = any(
- "<headroom:dropped_context" in msg.get("content", "") for msg in result.messages
+ "<headroom:dropped_context" in msg.get("content", "")
+ or "Earlier context compressed:" in msg.get("content", "")
+ for msg in result.messages
)
assert marker_found