fix(guardrails): catch repeating multi-call cycles in the stall guard

Port from can1357/oh-my-pi#10521: their loop guard only hashed single-call
turns, so a model replaying the same multi-call batch every iteration was
never counted; they widened the hash to the whole batch. Hermes has the
same blind spot in a different shape: observe_call tracks a CONSECUTIVE
identical-call streak, so an A,B,A,B,... cycle of identical (args, result)
pairs resets the streak on every alternation and runs to the iteration
budget unflagged (live-reproduced: 60 calls in a 2-cycle, zero notices,
no hard stop).

Add a period-2..4 cycle detector over a bounded per-turn call history:
notice on the STALL_GUARD_IDENTICAL_CALL_THRESHOLD-th identical lap,
hard stop at no_progress_block_after laps under hard_stop_enabled — the
same thresholds the period-1 streak uses. Cycles whose results change
between laps never fire (real progress); cycles made only of poller-exempt
tools are exempt (legitimate waiting), matching single-call semantics.
Widen the streak-stop propagation seam in run_agent.py to carry the new
decision code.
This commit is contained in:
Teknium
2026-09-09 02:38:55 -07:00
parent a565e2d493
commit 1fec70ea48
3 changed files with 123 additions and 2 deletions
+74
View File
@@ -9,6 +9,7 @@ from __future__ import annotations
import hashlib
import json
from collections import deque
from dataclasses import asdict, dataclass, field, fields
from typing import Any, Mapping
@@ -35,6 +36,15 @@ STALL_GUARD_REPEATABLE_TOOLS = frozenset({"process_manage"})
_STALL_GUARD_REPEATABLE_SUFFIXES = ("_get_result", "_poll") # generated / MCP poller conventions
# Nth consecutive identical (tool, args, result) call that fires the notice; 3 tolerates one double-check.
STALL_GUARD_IDENTICAL_CALL_THRESHOLD = 3
# Repeating multi-call cycles (A,B,A,B,... with identical args AND results) defeat the
# consecutive streak above — every alternation resets it, so a model replaying the same
# 2–4 call batch each iteration ran to the budget unflagged (port of can1357/oh-my-pi#10521,
# which widened their loop guard from single-call turns to whole tool-call batches).
# Longest cycle period detected; laps reuse the streak thresholds (notice at
# STALL_GUARD_IDENTICAL_CALL_THRESHOLD laps, halt at no_progress_block_after laps).
_STALL_GUARD_MAX_CYCLE_PERIOD = 4
# History window: enough for block_after laps of the longest cycle plus slack.
_STALL_GUARD_CYCLE_HISTORY = 64
# From the 2nd byte-identical repeat the duplicate payload becomes a reference stub; smaller results
# aren't worth it, errors never are. The args preview keeps WHAT was called if compression evicts the original.
IDENTICAL_RESULT_STUB_MIN_CHARS = 512
@@ -249,6 +259,11 @@ _DECISION_MESSAGES: dict[str, str] = {
"Stopped {tool_name}: the same call with identical arguments returned the same result "
"{count} times in a row. Stop repeating it unchanged; use the result already provided or change strategy."
),
"identical_cycle_halt": (
"Stopped {tool_name}: the same repeating cycle of tool calls (period {period}) with identical "
"arguments and identical results has run {count} times. Repeating the batch unchanged is not "
"progress; use the results already provided or change strategy."
),
"loop_web_search_cap": (
"Blocked web_search: this turn has already made {cap} web searches, the per-turn limit. "
"This looks like a runaway search loop. Work with the results you already have and give the user your answer."
@@ -266,6 +281,13 @@ _IDENTICAL_CALL_NOTICE = (
"proceed with what you have.]"
)
_IDENTICAL_CYCLE_NOTICE = (
"[hermes note: the last {count} rounds repeated the same cycle of {period} tool calls "
"(ending with {tool_name}) with identical arguments and identical results. "
"Do not repeat the batch — change arguments, use a different tool, or "
"proceed with what you have.]"
)
# tool -> (LoopCapConfig field, controller counter attribute, decision code)
_LOOP_CAPS: dict[str, tuple[str, str, str]] = {
"web_search": ("max_web_searches", "_turn_web_search_count", "loop_web_search_cap"),
@@ -298,6 +320,10 @@ class ToolCallGuardrailController:
self._identical_streak_result_hash: str = ""
self._identical_streak_count: int = 0
self._identical_streak_first_call_id: str = ""
# Batch-cycle loop breaker (port of can1357/oh-my-pi#10521): sequence of
# (signature, result_hash, repeatable) for every observed call this turn, so a repeating
# multi-call cycle (A,B,A,B,...) is caught even though it resets the consecutive streak above.
self._call_history: deque[tuple[ToolCallSignature, str, bool]] = deque(maxlen=_STALL_GUARD_CYCLE_HISTORY)
# tool_call_id -> spillover path, so a stub referencing a persisted-output preview can't dangle.
self._persisted_result_paths: dict[str, str] = {}
self._turn_web_search_count = 0
@@ -434,11 +460,59 @@ class ToolCallGuardrailController:
if self.config.hard_stop_enabled and count >= self.config.no_progress_block_after and self._halt_decision is None:
self._decide("halt", "identical_call_streak_halt", tool_name, count, signature)
# Batch-cycle detection (oh-my-pi#10521): a repeating multi-call cycle resets the
# consecutive streak on every alternation, so check the call history for a period-p lap.
if is_plain_str:
self._call_history.append((signature, result_hash, is_stall_guard_repeatable(tool_name)))
else:
self._call_history.clear()
if notice is None and is_plain_str:
cycle = self._detect_identical_cycle()
if cycle is not None:
period, laps = cycle
notice = _IDENTICAL_CYCLE_NOTICE.format(count=laps, period=period, tool_name=tool_name)
if self.config.hard_stop_enabled and laps >= self.config.no_progress_block_after and self._halt_decision is None:
self._decide("halt", "identical_cycle_halt", tool_name, laps, signature, period=period)
stub = None
if is_plain_str and count >= 2 and not failed and len(result) >= IDENTICAL_RESULT_STUB_MIN_CHARS:
stub = self._build_result_reference_stub(tool_name, args)
return IdenticalCallObservation(notice=notice, stub=stub)
def _detect_identical_cycle(self) -> tuple[int, int] | None:
"""Detect a repeating identical-call cycle ending at the latest observed call.
Returns ``(period, laps)`` for the smallest period 2..max whose trailing laps
(identical signature AND result per position) reach the notice threshold, else None.
Period 1 is the consecutive streak's job. A cycle made ONLY of poller-exempt tools
is exempt (an unchanged poll loop is legitimate waiting); one non-exempt call in
the cycle keeps the guard armed, matching the single-call exemption semantics.
"""
history = self._call_history
for period in range(2, _STALL_GUARD_MAX_CYCLE_PERIOD + 1):
if len(history) < period * STALL_GUARD_IDENTICAL_CALL_THRESHOLD:
continue
laps = 1
# Count how many consecutive trailing laps equal the final lap.
while True:
base = len(history) - period * (laps + 1)
if base < 0:
break
lap_equal = all(
history[base + i][:2] == history[len(history) - period + i][:2]
for i in range(period)
)
if not lap_equal:
break
laps += 1
if laps >= STALL_GUARD_IDENTICAL_CALL_THRESHOLD:
tail = [history[len(history) - period + i] for i in range(period)]
if all(repeatable for _, _, repeatable in tail):
continue
# A constant sub-cycle would already have fired at a smaller period.
return period, laps
return None
def record_persisted_result(self, tool_call_id: str, file_path: str) -> None:
"""Remember the spillover path a persisted result was saved to."""
if tool_call_id and file_path:
+2 -2
View File
@@ -1253,9 +1253,9 @@ class AIAgent(
if decision.should_halt:
self._set_tool_guardrail_halt(decision)
else:
# observe_call may have raised the identical-call streak halt (hard_stop_enabled, tool-agnostic).
# observe_call may have raised the identical-call streak or batch-cycle halt (hard_stop_enabled, tool-agnostic).
streak_halt = self._tool_guardrails.halt_decision
if streak_halt is not None and streak_halt.code == "identical_call_streak_halt":
if streak_halt is not None and streak_halt.code in ("identical_call_streak_halt", "identical_cycle_halt"):
function_result = append_toolguard_guidance(function_result, streak_halt)
self._set_tool_guardrail_halt(streak_halt)
if stall_notice:
+47
View File
@@ -387,3 +387,50 @@ def test_ignores_conversational_future_offers():
assert not trailing_continue_intent(
"If you want, I will happily review the PR once CI is green. Just say so!"
)
# ── batch-cycle loop breaker (port of can1357/oh-my-pi#10521) ───────────────
def test_repeating_two_call_cycle_fires_notice_and_halts_under_hard_stop():
"""An A,B,A,B,... cycle of identical (args, result) pairs defeats the
consecutive streak (every alternation resets it) but must still be caught:
notice at the threshold-th lap, halt at no_progress_block_after laps."""
from agent.tool_guardrails import ToolCallGuardrailConfig
c = ToolCallGuardrailController(ToolCallGuardrailConfig(hard_stop_enabled=True))
pairs = (({"command": "make build"}, "error: X\n"),
({"command": "tail -5 build.log"}, "still broken\n"))
first_notice_call = None
calls = 0
for _ in range(30):
for args, result in pairs:
calls += 1
notice = c.observe_call("terminal", args, result).notice
if notice is not None and first_notice_call is None:
first_notice_call = calls
assert "cycle" in notice
if c.halt_decision is not None:
break
# Notice on the last call of the threshold-th lap (period 2 × threshold 3).
assert first_notice_call == 2 * STALL_GUARD_IDENTICAL_CALL_THRESHOLD
assert c.halt_decision is not None
assert c.halt_decision.code == "identical_cycle_halt"
def test_cycle_guard_stays_silent_for_progressing_and_poller_cycles():
"""A cycle whose results change every lap is real work; a cycle made only
of poller-exempt tools is legitimate waiting. Neither may fire."""
from agent.tool_guardrails import ToolCallGuardrailConfig
progressing = ToolCallGuardrailController(ToolCallGuardrailConfig(hard_stop_enabled=True))
for i in range(20):
for args in ({"command": "make"}, {"command": "tail log"}):
assert progressing.observe_call("terminal", args, f"output {i}").notice is None
assert progressing.halt_decision is None
pollers = ToolCallGuardrailController(ToolCallGuardrailConfig(hard_stop_enabled=True))
for _ in range(20):
for args in ({"action": "poll", "session_id": "a"}, {"action": "poll", "session_id": "b"}):
assert pollers.observe_call("process_manage", args, "running").notice is None
assert pollers.halt_decision is None