From 86f69e8c2a4cf446db69454e0dfe13898e871c8c Mon Sep 17 00:00:00 2001 From: Teknium <127238744+teknium1@users.noreply.github.com> Date: Sat, 9 May 2026 12:48:03 -0700 Subject: [PATCH] fix(agent): hydrate memory-nudge counters from conversation_history (#22774) Gateway creates a fresh AIAgent per inbound message in several common scenarios: cache miss, idle eviction (1h TTL), config-signature mismatch, process restart. A freshly-built AIAgent has _turns_since_memory=0 and _user_turn_count=0, so the memory.nudge_interval trigger ('_turns_since_memory >= _memory_nudge_interval') can never be reached when these reconstructions happen on roughly the cadence of the interval. A user can chat for hours on Telegram without ever seeing a self-improvement review fire. Reconstruct the counters from conversation_history at the top of run_conversation(), right after the existing _hydrate_todo_store call. Idempotent guard ('if self._user_turn_count == 0') means a cached agent that already accumulated counters keeps them; only freshly-built agents hydrate. Modulo arithmetic preserves the original 1-in-N cadence rather than firing a review immediately on resume. 7 regression tests pinning the contract (mid-cycle history, modulo wrap, idempotency, zero-interval skip, role==user filtering, production-code anchor). Closes #22357. --- run_agent.py | 24 +++- .../test_memory_nudge_counter_hydration.py | 129 ++++++++++++++++++ 2 files changed, 152 insertions(+), 1 deletion(-) create mode 100644 tests/run_agent/test_memory_nudge_counter_hydration.py diff --git a/run_agent.py b/run_agent.py index aaceb79c752..6fe17d8a7fa 100644 --- a/run_agent.py +++ b/run_agent.py @@ -11127,7 +11127,29 @@ class AIAgent: # recover the todo state from the most recent todo tool response in history) if conversation_history and not self._todo_store.has_items(): self._hydrate_todo_store(conversation_history) - + + # Hydrate per-session nudge counters from persisted history. + # Gateway creates a fresh AIAgent per inbound message (cache miss / + # 1h idle eviction / config-signature mismatch / process restart), so + # _turns_since_memory and _user_turn_count start at 0 every turn and + # the memory.nudge_interval trigger may never be reached. Reconstruct + # an effective count from prior user turns in conversation_history. + # Idempotent: a cached agent that already accumulated counters keeps + # them; only a freshly-built agent with empty in-memory state hydrates. + # See issue #22357. + if conversation_history and self._user_turn_count == 0: + prior_user_turns = sum( + 1 for m in conversation_history if m.get("role") == "user" + ) + if prior_user_turns > 0: + self._user_turn_count = prior_user_turns + if self._memory_nudge_interval > 0 and self._turns_since_memory == 0: + # % preserves original 1-in-N cadence rather than firing a + # review immediately on resume (which would surprise users + # whose session happened to land just past a multiple of N). + self._turns_since_memory = prior_user_turns % self._memory_nudge_interval + + # Prefill messages (few-shot priming) are injected at API-call time only, # never stored in the messages list. This keeps them ephemeral: they won't # be saved to session DB, session logs, or batch trajectories, but they're diff --git a/tests/run_agent/test_memory_nudge_counter_hydration.py b/tests/run_agent/test_memory_nudge_counter_hydration.py new file mode 100644 index 00000000000..abf97d265a6 --- /dev/null +++ b/tests/run_agent/test_memory_nudge_counter_hydration.py @@ -0,0 +1,129 @@ +"""Regression test for issue #22357 — gateway memory-nudge counter hydration. + +The gateway creates a fresh AIAgent for each inbound message in several +common scenarios (cache miss, 1h idle eviction at gateway/run.py +_AGENT_CACHE_IDLE_TTL_SECS, config-signature mismatch, process restart). +A freshly built AIAgent has _turns_since_memory=0 and _user_turn_count=0. + +Without hydration from conversation_history, the memory.nudge_interval +trigger (`_turns_since_memory >= _memory_nudge_interval`) can never be +reached: every turn looks like turn 1 to the counter, so a user can chat +for hours without ever seeing a "💾 Self-improvement review:" message. + +This test pins the hydration behavior added at the top of run_conversation(). +""" + +from __future__ import annotations + + +def _make_minimal_agent(): + """Build the smallest object that can run the hydration block. + + The hydration code only touches attributes — no I/O, no API calls. + We can just set up a SimpleNamespace-like object with the right fields + and call run_conversation's prelude logic via a thin wrapper. + + The hydration block itself is straightforward enough that we test it + by replicating it inline against the same inputs — that's the only + way to test ~10 lines deep inside a 500+ line method without rewriting + the whole agent loop. + """ + + +def _run_hydration(conversation_history, memory_nudge_interval=10, + prior_turn_count=0, prior_turns_since_memory=0): + """Replicate the hydration block from run_agent.py:11128-11150. + Keeping this in sync with the production code is a one-line job; the + block has no dependencies on anything except primitives + history. + """ + user_turn_count = prior_turn_count + turns_since_memory = prior_turns_since_memory + + if conversation_history and user_turn_count == 0: + prior_user_turns = sum( + 1 for m in conversation_history if m.get("role") == "user" + ) + if prior_user_turns > 0: + user_turn_count = prior_user_turns + if memory_nudge_interval > 0 and turns_since_memory == 0: + turns_since_memory = prior_user_turns % memory_nudge_interval + + return user_turn_count, turns_since_memory + + +def test_no_history_leaves_counters_at_zero(): + user_turn, since_mem = _run_hydration([], memory_nudge_interval=10) + assert user_turn == 0 + assert since_mem == 0 + + +def test_seven_user_turns_history_hydrates_to_seven(): + """Mid-cycle history: 7 prior user turns, interval 10 → counter at 7.""" + history = [] + for i in range(7): + history.append({"role": "user", "content": f"q{i}"}) + history.append({"role": "assistant", "content": f"a{i}"}) + + user_turn, since_mem = _run_hydration(history, memory_nudge_interval=10) + + assert user_turn == 7 + assert since_mem == 7 # 7 % 10 = 7, next 3 turns will trigger review + + +def test_thirteen_turns_history_wraps_via_modulo(): + """13 prior user turns, interval 10 → counter at 3 (post-wrap), preserving cadence.""" + history = [{"role": "user", "content": f"q{i}"} for i in range(13)] + + user_turn, since_mem = _run_hydration(history, memory_nudge_interval=10) + + assert user_turn == 13 + assert since_mem == 3 # 13 % 10 = 3, next 7 turns to trigger + + +def test_idempotent_when_counters_already_set(): + """A cached agent with existing counters must NOT have them clobbered. + + Without the `_user_turn_count == 0` guard, cached agents would lose + their accumulated state every time they re-entered the function. + """ + history = [{"role": "user", "content": "q1"}, {"role": "assistant", "content": "a1"}] + user_turn, since_mem = _run_hydration( + history, memory_nudge_interval=10, + prior_turn_count=15, prior_turns_since_memory=5, + ) + # Existing counters preserved (cache hit case) + assert user_turn == 15 + assert since_mem == 5 + + +def test_zero_nudge_interval_disables_hydration_of_review_counter(): + """When memory.nudge_interval=0 (review disabled), don't touch the counter.""" + history = [{"role": "user", "content": "q1"}] + user_turn, since_mem = _run_hydration(history, memory_nudge_interval=0) + assert user_turn == 1 + assert since_mem == 0 # untouched when interval is 0 + + +def test_assistant_only_history_does_not_advance_user_turn_count(): + """Defensive: only role==user messages contribute. Other roles are noise.""" + history = [ + {"role": "system", "content": "sys"}, + {"role": "assistant", "content": "a"}, + {"role": "tool", "content": "t"}, + ] + user_turn, since_mem = _run_hydration(history, memory_nudge_interval=10) + assert user_turn == 0 + assert since_mem == 0 + + +def test_production_code_contains_hydration_block(): + """Smoke test: confirm the hydration code is actually wired into + run_conversation(). If someone deletes it, tests above still pass + against the inline replica — this fails them awake. + """ + from pathlib import Path + src = Path(__file__).resolve().parents[2] / "run_agent.py" + content = src.read_text(encoding="utf-8") + # Anchor on the unique comment + the modulo line. + assert "Hydrate per-session nudge counters from persisted history" in content + assert "self._turns_since_memory = prior_user_turns % self._memory_nudge_interval" in content