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.

fix(memory): bound the TrafficLearner pending-pattern accumulator (memory leak) (#2579)

Abhay Singh1f5fefffd3e8
diff --git a/headroom/memory/traffic_learner.py b/headroom/memory/traffic_learner.py
index bcecefef0..abd200ff3 100644
--- a/headroom/memory/traffic_learner.py
+++ b/headroom/memory/traffic_learner.py
@@ -26,6 +26,7 @@ import os
import re
import sqlite3
import time
+from collections import OrderedDict
from dataclasses import dataclass, field
from datetime import datetime, timezone
from enum import Enum
@@ -450,6 +451,7 @@ class TrafficLearner:
max_history: int = 20,
dedup_window: int = 100,
min_evidence: int = 5,
+ max_pending_patterns: int = 2048,
) -> None:
"""Initialize the traffic learner.
@@ -468,12 +470,19 @@ class TrafficLearner:
self.agent_type = agent_type
self._max_history = max_history
self._min_evidence = min_evidence
+ self._max_pending_patterns = max_pending_patterns
# Recent tool call history for error→recovery matching
self._tool_history: list[dict[str, Any]] = []
- # Pattern accumulator: hash → (pattern, count)
- self._pattern_counts: dict[str, tuple[ExtractedPattern, int]] = {}
+ # Pattern accumulator: hash → (pattern, count). LRU-ordered and capped:
+ # a pattern that is seen once but never reaches ``min_evidence`` would
+ # otherwise linger here forever, so this dict grew unbounded over a
+ # long-lived proxy's traffic (the sibling ``_saved_hashes`` is trimmed
+ # to ``dedup_window`` for the same reason; this one was missed). Evicting
+ # the least-recently-corroborated pending pattern is safe: if it recurs
+ # it simply restarts accumulation.
+ self._pattern_counts: OrderedDict[str, tuple[ExtractedPattern, int]] = OrderedDict()
# Dedup: hashes of patterns already saved to DB
self._saved_hashes: set[str] = set()
@@ -1250,7 +1259,13 @@ class TrafficLearner:
existing, count = self._pattern_counts[h]
count += 1
self._pattern_counts[h] = (existing, count)
+ # Mark as most-recently-corroborated so it survives LRU eviction.
+ self._pattern_counts.move_to_end(h)
else:
+ # Bound the pending accumulator so one-off patterns can't grow it
+ # without limit; drop the least-recently-corroborated pending entry.
+ if len(self._pattern_counts) >= self._max_pending_patterns:
+ self._pattern_counts.popitem(last=False)
self._pattern_counts[h] = (pattern, 1)
return # First sighting — wait for more evidence
diff --git a/tests/test_memory/test_traffic_learner.py b/tests/test_memory/test_traffic_learner.py
index eee21450b..fae5bc8fe 100644
--- a/tests/test_memory/test_traffic_learner.py
+++ b/tests/test_memory/test_traffic_learner.py
@@ -362,6 +362,56 @@ class TestTrafficLearner:
stats = learner.get_stats()
assert stats["patterns_extracted"] >= 3
+ def test_pending_accumulator_is_bounded(self):
+ """One-off patterns that never reach ``min_evidence`` must not grow the
+ pending ``_pattern_counts`` accumulator without bound — the sibling
+ ``_saved_hashes`` is already trimmed to ``dedup_window`` and this one was
+ missed, so a long-lived proxy leaked memory across varied traffic. It is
+ now LRU-capped at ``max_pending_patterns``.
+
+ Sync test (drives the async accumulate via ``asyncio.run``) so it runs
+ without the pytest-asyncio plugin.
+ """
+ import asyncio
+
+ learner = TrafficLearner(backend=None, min_evidence=5, max_pending_patterns=8)
+
+ async def feed_one_offs() -> None:
+ for i in range(500):
+ await learner._accumulate(
+ ExtractedPattern(
+ category=PatternCategory.PREFERENCE,
+ content=f"one-off pattern number {i}",
+ importance=0.5,
+ )
+ )
+
+ asyncio.run(feed_one_offs())
+ assert len(learner._pattern_counts) <= 8 # capped, not 500
+
+ def test_pending_accumulator_lru_still_promotes_corroborated_pattern(self):
+ """Capping the accumulator must not break promotion: a pattern
+ corroborated to ``min_evidence`` without interruption is still removed
+ from pending and recorded in ``_saved_hashes``."""
+ import asyncio
+
+ learner = TrafficLearner(backend=None, min_evidence=3, max_pending_patterns=100)
+ pattern = ExtractedPattern(
+ category=PatternCategory.PREFERENCE,
+ content="corroborated preference",
+ importance=0.5,
+ )
+
+ async def corroborate() -> None:
+ await learner._accumulate(pattern) # count 1
+ await learner._accumulate(pattern) # count 2
+ assert pattern.content_hash in learner._pattern_counts
+ await learner._accumulate(pattern) # count 3 == min_evidence -> promote
+
+ asyncio.run(corroborate())
+ assert pattern.content_hash not in learner._pattern_counts # removed on promotion
+ assert pattern.content_hash in learner._saved_hashes
+
@pytest.mark.asyncio
async def test_dedup(self, learner: TrafficLearner):
"""Test that identical patterns are deduplicated."""