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.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
Implement COMPRESS_FIRST strategy for IntelligentContextManager
chopratejas57b2de525ceb
diff --git a/headroom/transforms/intelligent_context.py b/headroom/transforms/intelligent_context.pyindex 41e352ebf..81aa201c0 100644--- a/headroom/transforms/intelligent_context.py+++ b/headroom/transforms/intelligent_context.py@@ -8,6 +8,12 @@ All importance signals are derived from:1. Computed metrics (recency, density, references)2. TOIN-learned patterns (field_semantics, retrieval_rate)3. Embedding similarity (optional)++Strategy Selection:+- NONE: Under budget, no action needed+- COMPRESS_FIRST: When <compress_threshold over budget, try deeper compression+ of tool outputs using ContentRouter before dropping messages+- DROP_BY_SCORE: When significantly over budget, drop lowest-scored messages"""from __future__ import annotations@@ -25,6 +31,7 @@ from .scoring import MessageScore, MessageScorerif TYPE_CHECKING:from ..telemetry.toin import ToolIntelligenceNetwork+ from .content_router import ContentRouterlogger = logging.getLogger(__name__)@@ -85,6 +92,9 @@ class IntelligentContextManager(Transform):recency_decay_rate=self.config.recency_decay_rate,)+ # Lazy-loaded content router for COMPRESS_FIRST strategy+ self._content_router: ContentRouter | None = None+def should_apply(self,messages: list[dict[str, Any]],@@ -145,8 +155,52 @@ class IntelligentContextManager(Transform):strategy = self._select_strategy(current_tokens, available)logger.debug(f"IntelligentContextManager: selected strategy {strategy.value}")- # Get protected indices and tool units+ # Get protected indicesprotected = self._get_protected_indices(result_messages)++ # ========== COMPRESS_FIRST STRATEGY ==========+ # Try to compress tool messages before dropping anything+ if strategy == ContextStrategy.COMPRESS_FIRST:+ result_messages, compress_transforms, tokens_saved = self._apply_compress_first(+ result_messages, tokenizer, protected+ )+ transforms_applied.extend(compress_transforms)++ # Recheck token count after compression+ current_tokens = tokenizer.count_messages(result_messages)++ # If now under budget, we're done!+ if current_tokens <= available:+ logger.info(+ "IntelligentContextManager: COMPRESS_FIRST succeeded, "+ "saved %d tokens: %d -> %d",+ tokens_saved,+ tokens_before,+ current_tokens,+ )+ return TransformResult(+ messages=result_messages,+ tokens_before=tokens_before,+ tokens_after=current_tokens,+ transforms_applied=transforms_applied,+ markers_inserted=markers_inserted,+ warnings=warnings,+ )++ # Still over budget, fall through to DROP_BY_SCORE+ logger.debug(+ "IntelligentContextManager: COMPRESS_FIRST saved %d tokens but still "+ "over budget (%d > %d), proceeding to DROP_BY_SCORE",+ tokens_saved,+ current_tokens,+ available,+ )+ strategy = ContextStrategy.DROP_BY_SCORE+ # Need to recalculate protected indices after compression+ protected = self._get_protected_indices(result_messages)++ # ========== DROP_BY_SCORE STRATEGY ==========+ # Get tool units for atomic droppingtool_units = find_tool_units(result_messages)tool_unit_indices = self._get_tool_unit_indices(tool_units)@@ -258,6 +312,223 @@ class IntelligentContextManager(Transform):return ContextStrategy.DROP_BY_SCORE+ def _get_content_router(self) -> ContentRouter | None:+ """Get or create content router for COMPRESS_FIRST strategy (lazy load)."""+ if self._content_router is None:+ try:+ from .content_router import ContentRouter, ContentRouterConfig++ # Configure for aggressive compression in COMPRESS_FIRST context+ router_config = ContentRouterConfig(+ enable_code_aware=True,+ enable_llmlingua=True,+ enable_smart_crusher=True,+ enable_search_compressor=True,+ enable_log_compressor=True,+ skip_user_messages=True,+ protect_recent_code=0, # Don't protect in COMPRESS_FIRST+ protect_analysis_context=False, # We're over budget+ min_section_tokens=20,+ ccr_enabled=True,+ )+ self._content_router = ContentRouter(config=router_config)+ except ImportError:+ logger.debug("ContentRouter not available for COMPRESS_FIRST")+ return self._content_router++ def _apply_compress_first(+ self,+ messages: list[dict[str, Any]],+ tokenizer: Tokenizer,+ protected: set[int],+ ) -> tuple[list[dict[str, Any]], list[str], int]:+ """Apply deeper compression to tool messages using ContentRouter.++ This is the COMPRESS_FIRST strategy: try to compress tool outputs+ more aggressively before falling back to dropping messages.++ Args:+ messages: List of messages to compress.+ tokenizer: Tokenizer for counting.+ protected: Set of protected message indices.++ Returns:+ Tuple of (compressed_messages, transforms_applied, tokens_saved).+ """+ router = self._get_content_router()+ if router is None:+ return messages, [], 0++ compressed_messages = deep_copy_messages(messages)+ transforms_applied: list[str] = []+ total_tokens_saved = 0++ for i, msg in enumerate(compressed_messages):+ # Skip protected messages+ if i in protected:+ continue++ role = msg.get("role")+ content = msg.get("content")++ # Focus on tool messages (highest compression potential)+ if role == "tool" and isinstance(content, str) and len(content) > 100:+ try:+ # Get source hint from tool call context+ tool_call_id = msg.get("tool_call_id", "")+ source_hint = self._get_tool_source_hint(messages, tool_call_id)++ # Compress using ContentRouter+ result = router.compress(+ content,+ source_hint=source_hint,+ context="", # No specific context in compress-first mode+ )++ # Check if compression was effective+ if result.compression_ratio < 0.9: # At least 10% savings+ tokens_before = tokenizer.count_text(content)+ tokens_after = tokenizer.count_text(result.compressed)+ tokens_saved = tokens_before - tokens_after++ if tokens_saved > 0:+ compressed_messages[i] = {+ **msg,+ "content": result.compressed,+ }+ transforms_applied.append(+ f"compress_first:{result.strategy_used.value}:{i}"+ )+ total_tokens_saved += tokens_saved+ logger.debug(+ "COMPRESS_FIRST: message %d compressed %d→%d tokens (%s)",+ i,+ tokens_before,+ tokens_after,+ result.strategy_used.value,+ )+ except Exception as e:+ logger.debug("COMPRESS_FIRST: compression failed for message %d: %s", i, e)+ continue++ # Also try to compress assistant messages with tool results in content blocks+ elif role == "assistant" and isinstance(content, list):+ compressed_blocks, block_transforms, block_saved = self._compress_content_blocks(+ content, router, tokenizer+ )+ if block_saved > 0:+ compressed_messages[i] = {**msg, "content": compressed_blocks}+ transforms_applied.extend(block_transforms)+ total_tokens_saved += block_saved++ if total_tokens_saved > 0:+ logger.info(+ "COMPRESS_FIRST: saved %d tokens across %d compressions",+ total_tokens_saved,+ len(transforms_applied),+ )++ return compressed_messages, transforms_applied, total_tokens_saved++ def _get_tool_source_hint(self, messages: list[dict[str, Any]], tool_call_id: str) -> str:+ """Extract source hint from the tool call that produced this result.++ Args:+ messages: List of all messages.+ tool_call_id: The ID of the tool call to find.++ Returns:+ Source hint string (e.g., "tool:grep", "file:main.py").+ """+ if not tool_call_id:+ return ""++ # Find the assistant message with this tool call+ for msg in messages:+ if msg.get("role") == "assistant" and msg.get("tool_calls"):+ for tc in msg.get("tool_calls", []):+ if tc.get("id") == tool_call_id:+ func = tc.get("function", {})+ tool_name = func.get("name", "")++ # Import here to avoid circular imports+ try:+ import json++ from .content_router import generate_source_hint++ args_str = func.get("arguments", "{}")+ try:+ args = (+ json.loads(args_str) if isinstance(args_str, str) else args_str+ )+ except json.JSONDecodeError:+ args = {}++ return generate_source_hint(tool_name, args)+ except ImportError:+ return f"tool:{tool_name}" if tool_name else ""+ return ""++ def _compress_content_blocks(+ self,+ content_blocks: list[Any],+ router: ContentRouter,+ tokenizer: Tokenizer,+ ) -> tuple[list[Any], list[str], int]:+ """Compress content blocks (Anthropic format) using ContentRouter.++ Args:+ content_blocks: List of content blocks.+ router: ContentRouter instance.+ tokenizer: Tokenizer for counting.++ Returns:+ Tuple of (compressed_blocks, transforms_applied, tokens_saved).+ """+ compressed_blocks: list[Any] = []+ transforms_applied: list[str] = []+ total_saved = 0++ for block in content_blocks:+ if not isinstance(block, dict):+ compressed_blocks.append(block)+ continue++ block_type = block.get("type")++ # Handle tool_result blocks+ if block_type == "tool_result":+ tool_content = block.get("content", "")++ if isinstance(tool_content, str) and len(tool_content) > 200:+ try:+ result = router.compress(tool_content, context="")++ if result.compression_ratio < 0.9:+ tokens_before = tokenizer.count_text(tool_content)+ tokens_after = tokenizer.count_text(result.compressed)+ saved = tokens_before - tokens_after++ if saved > 0:+ compressed_blocks.append(+ {+ **block,+ "content": result.compressed,+ }+ )+ transforms_applied.append(+ f"compress_first:block:{result.strategy_used.value}"+ )+ total_saved += saved+ continue+ except Exception:+ pass++ compressed_blocks.append(block)++ return compressed_blocks, transforms_applied, total_saved+def _get_protected_indices(self, messages: list[dict[str, Any]]) -> set[int]:"""Get indices that should never be dropped."""protected: set[int] = set()diff --git a/tests/test_transforms/test_intelligent_context.py b/tests/test_transforms/test_intelligent_context.pyindex 26adbcf9b..781f49dd9 100644--- a/tests/test_transforms/test_intelligent_context.py+++ b/tests/test_transforms/test_intelligent_context.py@@ -714,3 +714,568 @@ class TestCustomWeights:# Should complete successfullyassert len(result.messages) < len(long_conversation)+++# =============================================================================+# Test COMPRESS_FIRST Strategy - Integration Tests+# =============================================================================+++class TestCompressFirstStrategy:+ """Integration tests for COMPRESS_FIRST strategy.++ These tests verify that:+ 1. COMPRESS_FIRST is selected when slightly over budget+ 2. ContentRouter actually compresses tool messages+ 3. Compression can bring context under budget+ 4. Fallback to DROP_BY_SCORE works when compression isn't enough+ """++ @pytest.fixture+ def conversation_with_large_tool_outputs(self) -> list[dict[str, Any]]:+ """Conversation with large JSON tool outputs (compressible)."""+ import json++ # Generate a large JSON array that SmartCrusher can compress+ large_results = [+ {+ "id": i,+ "name": f"Item {i}",+ "status": "active" if i % 2 == 0 else "inactive",+ "value": i * 100,+ "description": f"This is a description for item number {i} with some extra text",+ }+ for i in range(100)+ ]++ return [+ {"role": "system", "content": "You are a helpful assistant with search tools."},+ {"role": "user", "content": "Search for items in the database."},+ {+ "role": "assistant",+ "content": "I'll search the database for you.",+ "tool_calls": [+ {+ "id": "call_db_1",+ "type": "function",+ "function": {+ "name": "database_search",+ "arguments": '{"query": "items"}',+ },+ }+ ],+ },+ {+ "role": "tool",+ "tool_call_id": "call_db_1",+ "content": json.dumps(large_results),+ },+ {"role": "assistant", "content": "I found 100 items in the database."},+ {"role": "user", "content": "Great, can you show me more details?"},+ ]++ @pytest.fixture+ def conversation_with_search_output(self) -> list[dict[str, Any]]:+ """Conversation with grep-style search output (compressible)."""+ # Generate search results in grep format+ search_lines = [+ f"src/module{i}.py:{i * 10}: def function_{i}(self, param):" for i in range(50)+ ]++ return [+ {"role": "system", "content": "You are a code assistant."},+ {"role": "user", "content": "Search for function definitions."},+ {+ "role": "assistant",+ "content": "Searching...",+ "tool_calls": [+ {+ "id": "call_grep_1",+ "type": "function",+ "function": {+ "name": "Grep",+ "arguments": '{"pattern": "def function"}',+ },+ }+ ],+ },+ {+ "role": "tool",+ "tool_call_id": "call_grep_1",+ "content": "\n".join(search_lines),+ },+ {"role": "assistant", "content": "Found 50 function definitions."},+ {"role": "user", "content": "Thanks!"},+ ]++ def test_compress_first_selected_for_small_overage(self, tokenizer: Tokenizer):+ """COMPRESS_FIRST should be selected when <10% over budget."""+ config = IntelligentContextConfig(compress_threshold=0.10)+ manager = IntelligentContextManager(config=config)++ # 5% over budget should select COMPRESS_FIRST+ strategy = manager._select_strategy(current_tokens=2100, available=2000)+ assert strategy == ContextStrategy.COMPRESS_FIRST++ # 9% over budget should still select COMPRESS_FIRST+ strategy = manager._select_strategy(current_tokens=2180, available=2000)+ assert strategy == ContextStrategy.COMPRESS_FIRST++ # 15% over budget should select DROP_BY_SCORE+ strategy = manager._select_strategy(current_tokens=2300, available=2000)+ assert strategy == ContextStrategy.DROP_BY_SCORE++ def test_compress_first_compresses_json_tool_output(+ self,+ conversation_with_large_tool_outputs: list[dict[str, Any]],+ tokenizer: Tokenizer,+ ):+ """COMPRESS_FIRST should compress JSON tool outputs using ContentRouter."""+ config = IntelligentContextConfig(compress_threshold=0.15)+ manager = IntelligentContextManager(config=config)++ tokens_before = tokenizer.count_messages(conversation_with_large_tool_outputs)++ # Set limit to be slightly over (within COMPRESS_FIRST range)+ # We want tokens_before to be ~5-10% over the limit+ target_limit = int(tokens_before / 1.05) # ~5% over++ result = manager.apply(+ conversation_with_large_tool_outputs,+ tokenizer,+ model_limit=target_limit,+ output_buffer=50,+ )++ # Should have compression transforms or be under budget+ if result.tokens_after <= target_limit - 50:+ # If under budget, compression worked!+ assert result.tokens_after < result.tokens_before+ else:+ # May have needed to drop as well+ assert result.tokens_after <= result.tokens_before++ def test_compress_first_with_search_output(+ self,+ conversation_with_search_output: list[dict[str, Any]],+ tokenizer: Tokenizer,+ ):+ """COMPRESS_FIRST should work with search-style output."""+ config = IntelligentContextConfig(compress_threshold=0.15)+ manager = IntelligentContextManager(config=config)++ tokens_before = tokenizer.count_messages(conversation_with_search_output)+ target_limit = int(tokens_before / 1.08) # ~8% over++ result = manager.apply(+ conversation_with_search_output,+ tokenizer,+ model_limit=target_limit,+ output_buffer=50,+ )++ # Should reduce tokens+ assert result.tokens_after <= result.tokens_before++ def test_compress_first_fallback_to_drop(+ self,+ tokenizer: Tokenizer,+ ):+ """When compression isn't enough, should fall back to dropping."""+ import json++ # Create a conversation with multiple tool calls where even compression+ # won't be enough - use small non-JSON content that can't compress well+ messages = [+ {"role": "system", "content": "You are a helpful assistant."},+ {"role": "user", "content": "Do multiple searches."},+ ]++ # Add 10 tool calls with results that won't compress much+ for i in range(10):+ messages.append(+ {+ "role": "assistant",+ "content": f"Searching for item {i}...",+ "tool_calls": [+ {+ "id": f"call_{i}",+ "type": "function",+ "function": {+ "name": "search",+ "arguments": json.dumps({"q": f"item{i}"}),+ },+ }+ ],+ }+ )+ messages.append(+ {+ "role": "tool",+ "tool_call_id": f"call_{i}",+ "content": f"Found result for item {i}: some important data here that cannot be compressed easily",+ }+ )++ messages.append({"role": "assistant", "content": "Here are all the results."})+ messages.append({"role": "user", "content": "Thanks!"})++ # Use keep_last_turns=1 to allow more messages to be dropped+ config = IntelligentContextConfig(+ compress_threshold=0.50, # High threshold+ keep_last_turns=1, # Only protect last turn+ )+ manager = IntelligentContextManager(config=config)++ tokens_before = tokenizer.count_messages(messages)++ # Very small limit that will require dropping+ very_small_limit = tokens_before // 4++ result = manager.apply(+ messages,+ tokenizer,+ model_limit=very_small_limit,+ output_buffer=50,+ )++ # Should have reduced tokens+ assert result.tokens_after < result.tokens_before+ # Should have dropped some messages+ assert len(result.messages) < len(messages)++ def test_compress_first_preserves_message_structure(+ self,+ conversation_with_large_tool_outputs: list[dict[str, Any]],+ tokenizer: Tokenizer,+ ):+ """COMPRESS_FIRST should preserve message structure integrity."""+ config = IntelligentContextConfig(compress_threshold=0.20)+ manager = IntelligentContextManager(config=config)++ tokens_before = tokenizer.count_messages(conversation_with_large_tool_outputs)+ target_limit = int(tokens_before / 1.05)++ result = manager.apply(+ conversation_with_large_tool_outputs,+ tokenizer,+ model_limit=target_limit,+ output_buffer=50,+ )++ # Verify structure+ for msg in result.messages:+ assert "role" in msg+ role = msg["role"]+ assert role in ("system", "user", "assistant", "tool")++ # Tool messages should have tool_call_id+ if role == "tool":+ assert "tool_call_id" in msg or "content" in msg++ # Assistant messages with tool_calls should have that structure+ if role == "assistant" and "tool_calls" in msg:+ for tc in msg["tool_calls"]:+ assert "id" in tc+ assert "function" in tc++ def test_compress_first_no_compression_when_under_budget(+ self, simple_conversation: list[dict[str, Any]], tokenizer: Tokenizer+ ):+ """COMPRESS_FIRST should not be applied when under budget."""+ manager = IntelligentContextManager()++ result = manager.apply(+ simple_conversation,+ tokenizer,+ model_limit=128000,+ output_buffer=4000,+ )++ # No compression transforms should be applied+ compression_transforms = [+ t for t in result.transforms_applied if t.startswith("compress_first:")+ ]+ assert len(compression_transforms) == 0+ assert result.tokens_before == result.tokens_after++ def test_content_router_lazy_loading(self):+ """ContentRouter should be lazy-loaded only when needed."""+ manager = IntelligentContextManager()++ # Initially None+ assert manager._content_router is None++ # Get router+ router = manager._get_content_router()++ # Should now be set+ assert manager._content_router is not None+ assert router is manager._content_router++ # Second call should return same instance+ router2 = manager._get_content_router()+ assert router is router2++ def test_source_hint_extraction(self):+ """Source hints should be extracted from tool calls."""+ manager = IntelligentContextManager()++ messages = [+ {+ "role": "assistant",+ "tool_calls": [+ {+ "id": "call_1",+ "function": {+ "name": "Read",+ "arguments": '{"file_path": "/src/main.py"}',+ },+ }+ ],+ },+ {+ "role": "assistant",+ "tool_calls": [+ {+ "id": "call_2",+ "function": {+ "name": "Grep",+ "arguments": '{"pattern": "def"}',+ },+ }+ ],+ },+ ]++ # Test file read hint+ hint1 = manager._get_tool_source_hint(messages, "call_1")+ assert "file:" in hint1 or hint1 == "" # May not have content_router import++ # Test grep hint+ hint2 = manager._get_tool_source_hint(messages, "call_2")+ assert "grep" in hint2.lower() or hint2 == ""++ # Test unknown tool call+ hint3 = manager._get_tool_source_hint(messages, "unknown")+ assert hint3 == ""+++class TestCompressFirstWithContentBlocks:+ """Tests for COMPRESS_FIRST with Anthropic-style content blocks."""++ @pytest.fixture+ def conversation_with_content_blocks(self) -> list[dict[str, Any]]:+ """Conversation with Anthropic-style content blocks."""+ import json++ large_result = json.dumps([{"id": i, "data": f"item_{i}" * 20} for i in range(50)])++ return [+ {"role": "system", "content": "You are helpful."},+ {"role": "user", "content": "Search for data."},+ {+ "role": "assistant",+ "content": [+ {"type": "text", "text": "Here are the results:"},+ {+ "type": "tool_result",+ "tool_use_id": "tool_1",+ "content": large_result,+ },+ ],+ },+ {"role": "user", "content": "Thanks!"},+ ]++ def test_compress_first_handles_content_blocks(+ self,+ conversation_with_content_blocks: list[dict[str, Any]],+ tokenizer: Tokenizer,+ ):+ """COMPRESS_FIRST should handle content blocks format."""+ config = IntelligentContextConfig(compress_threshold=0.20)+ manager = IntelligentContextManager(config=config)++ tokens_before = tokenizer.count_messages(conversation_with_content_blocks)+ target_limit = int(tokens_before / 1.08)++ result = manager.apply(+ conversation_with_content_blocks,+ tokenizer,+ model_limit=target_limit,+ output_buffer=50,+ )++ # Should complete without error+ assert result.messages is not None+ assert result.tokens_after <= result.tokens_before+++class TestCompressFirstIntegrationWithTOIN:+ """Integration tests for COMPRESS_FIRST with TOIN patterns."""++ def test_compress_first_works_without_toin(self, tokenizer: Tokenizer):+ """COMPRESS_FIRST should work without TOIN integration."""+ import json++ messages = [+ {"role": "system", "content": "System"},+ {"role": "user", "content": "Search"},+ {+ "role": "assistant",+ "tool_calls": [+ {+ "id": "c1",+ "type": "function",+ "function": {"name": "search", "arguments": "{}"},+ }+ ],+ "content": "",+ },+ {+ "role": "tool",+ "tool_call_id": "c1",+ "content": json.dumps([{"x": i} for i in range(50)]),+ },+ {"role": "assistant", "content": "Done"},+ {"role": "user", "content": "Thanks"},+ ]++ # Without TOIN+ config = IntelligentContextConfig(+ compress_threshold=0.15,+ toin_integration=False,+ )+ manager = IntelligentContextManager(config=config, toin=None)++ tokens_before = tokenizer.count_messages(messages)+ target_limit = int(tokens_before / 1.08)++ result = manager.apply(+ messages,+ tokenizer,+ model_limit=target_limit,+ output_buffer=50,+ )++ # Should work+ assert result.messages is not None+ assert result.tokens_after <= result.tokens_before+++class TestCompressFirstEdgeCases:+ """Edge case tests for COMPRESS_FIRST strategy."""++ def test_empty_tool_content(self, tokenizer: Tokenizer):+ """COMPRESS_FIRST should handle empty tool content gracefully."""+ messages = [+ {"role": "system", "content": "System"},+ {"role": "user", "content": "Do something"},+ {+ "role": "assistant",+ "tool_calls": [+ {+ "id": "c1",+ "type": "function",+ "function": {"name": "tool", "arguments": "{}"},+ }+ ],+ "content": "",+ },+ {"role": "tool", "tool_call_id": "c1", "content": ""},+ {"role": "assistant", "content": "Done"},+ ]++ config = IntelligentContextConfig(compress_threshold=0.50)+ manager = IntelligentContextManager(config=config)++ # Very small limit to trigger compression+ result = manager.apply(+ messages,+ tokenizer,+ model_limit=50,+ output_buffer=10,+ )++ # Should handle gracefully+ assert result.messages is not None++ def test_non_json_tool_content(self, tokenizer: Tokenizer):+ """COMPRESS_FIRST should handle non-JSON tool content."""+ messages = [+ {"role": "system", "content": "System"},+ {"role": "user", "content": "Read a file"},+ {+ "role": "assistant",+ "tool_calls": [+ {+ "id": "c1",+ "type": "function",+ "function": {"name": "Read", "arguments": '{"file_path": "test.py"}'},+ }+ ],+ "content": "",+ },+ {+ "role": "tool",+ "tool_call_id": "c1",+ "content": "def hello():\n print('Hello World')\n" * 20,+ },+ {"role": "assistant", "content": "Here's the file"},+ {"role": "user", "content": "Thanks"},+ ]++ config = IntelligentContextConfig(compress_threshold=0.20)+ manager = IntelligentContextManager(config=config)++ tokens_before = tokenizer.count_messages(messages)+ target_limit = int(tokens_before / 1.08)++ result = manager.apply(+ messages,+ tokenizer,+ model_limit=target_limit,+ output_buffer=50,+ )++ # Should handle gracefully+ assert result.messages is not None+ assert result.tokens_after <= result.tokens_before++ def test_protected_tool_messages_not_compressed(self, tokenizer: Tokenizer):+ """Protected tool messages should not be compressed."""+ import json++ messages = [+ {"role": "system", "content": "System"},+ {"role": "user", "content": "Search"},+ {+ "role": "assistant",+ "tool_calls": [+ {"id": "c1", "type": "function", "function": {"name": "s", "arguments": "{}"}}+ ],+ "content": "",+ },+ {+ "role": "tool",+ "tool_call_id": "c1",+ "content": json.dumps([{"x": i} for i in range(100)]),+ },+ {"role": "assistant", "content": "Found results"},+ {"role": "user", "content": "More please"},+ ]++ # Protect last 5 turns (should include the tool message)+ config = IntelligentContextConfig(+ keep_last_turns=5,+ compress_threshold=0.50,+ )+ manager = IntelligentContextManager(config=config)++ # Get protected indices+ protected = manager._get_protected_indices(messages)++ # The recent messages should be protected+ # With 6 messages and keep_last_turns=5, most should be protected+ assert len(protected) > 0