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:
@@ -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
@@ -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:
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user