@miller-tech/uap 1.64.2 → 1.64.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "1.64.2",
+  "version": "1.64.4",
   "description": "Autonomous AI agent memory system with CLAUDE.md protocol enforcement",
   "type": "module",
   "main": "dist/index.js",

package/tools/agents/scripts/anthropic_proxy.py

@@ -1005,6 +1005,14 @@ class SessionMonitor:
     # back into a structured tool_use, which would continue the very loop the
     # breaker is ending. Reset to False at the start of every request.
     suppress_text_tool_extraction: bool = False
+    # Tool-turn count at which the TURN-COUNT FINALIZE BREAKER last fired. The
+    # count is derived from the (only-growing) conversation, so without this the
+    # breaker would re-fire on EVERY turn once the ceiling is first crossed —
+    # permanently stripping tools and stalling a legitimately long agentic task.
+    # Gating on (last + ceiling) makes it a PERIODIC nudge (80, 160, 240, ...)
+    # with tools restored in between, so long tasks complete while a true runaway
+    # still gets bounded (and the contamination/prune/cycle breakers catch faster).
+    last_hard_finalize_turn_count: int = 0
     finalize_continuation_count: int = 0
     finalize_hard_stop_count: int = 0  # monotonic, not reset by fresh user text
     finalize_synthetic_tool_id: str = ""
@@ -4095,7 +4103,14 @@ def build_openai_request(
         # genuine runaway trips it; see PROXY_HARD_FINALIZE_TURNS.
         if PROXY_HARD_FINALIZE_TURNS > 0:
             _agent_tool_turns = _count_agent_tool_turns(anthropic_body)
-            if _agent_tool_turns >= PROXY_HARD_FINALIZE_TURNS:
+            # PERIODIC, not permanent: fire once each time the count crosses
+            # another `ceiling` worth of tool turns past the last firing. Without
+            # the `last + ceiling` gate this fires on EVERY turn past the first
+            # crossing (the count only grows), permanently denying tools and
+            # stalling a long-but-legitimate task. Between fires tools are restored
+            # so the agent keeps making progress.
+            if _agent_tool_turns >= monitor.last_hard_finalize_turn_count + PROXY_HARD_FINALIZE_TURNS:
+                monitor.last_hard_finalize_turn_count = _agent_tool_turns
                 openai_body.pop("tool_choice", None)
                 openai_body.pop("tools", None)
                 openai_body.pop("grammar", None)
@@ -4103,11 +4118,12 @@ def build_openai_request(
                 msgs.append({
                     "role": "user",
                     "content": (
-                        f"You have made {_agent_tool_turns} tool calls without "
-                        "converging on a final answer. STOP now. No tools are "
-                        "available this turn. Reply with a brief plain-text summary "
-                        "of what you accomplished and what remains. Do NOT emit any "
-                        "tool call or tool-call-like syntax."
+                        f"You have made {_agent_tool_turns} tool calls. Pause for a "
+                        "progress checkpoint: in a brief plain-text summary, state "
+                        "what is done and the single most important next step. No "
+                        "tools are available this turn — do NOT emit any tool call "
+                        "or tool-call-like syntax. If the task is complete, say so; "
+                        "otherwise you will continue on the next turn."
                     ),
                 })
                 openai_body["messages"] = msgs
@@ -4330,6 +4346,19 @@ def build_openai_request(
 
     _apply_thinking_grammar(openai_body)
 
+    # qwen3.5-enhanced.jinja (the MTP/130 config template) rejects an assistant
+    # PREFILL (trailing assistant message) unless thinking is disabled VIA
+    # chat_template_kwargs — the top-level `enable_thinking` flag is not read by
+    # this template, so a prefill otherwise 400s ("Assistant response prefill is
+    # incompatible with enable_thinking"). There is nothing to think about on a
+    # continuation, so disable thinking the way the template actually reads.
+    _final_msgs = openai_body.get("messages") or []
+    if _final_msgs and isinstance(_final_msgs[-1], dict) and _final_msgs[-1].get("role") == "assistant":
+        ctk = openai_body.setdefault("chat_template_kwargs", {})
+        if isinstance(ctk, dict):
+            ctk["enable_thinking"] = False
+        openai_body.pop("enable_thinking", None)
+
     return openai_body
 
 

package/tools/agents/tests/test_turn_count_breaker_periodic.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""The TURN-COUNT FINALIZE BREAKER must fire PERIODICALLY, not on every turn once
+the ceiling is first crossed.
+
+`_count_agent_tool_turns` is derived from the (only-growing) conversation, so the
+naive `count >= ceiling` check re-fires on every request past the first crossing —
+permanently stripping tools and stalling a legitimately long agentic task (observed
+live: msgs 206→208→…→214, breaker every turn, then the client gives up). Gating on
+`count >= last_hard_finalize_turn_count + ceiling` makes it fire at ceiling, 2x,
+3x… with tools restored in between.
+"""
+
+import importlib.util
+import unittest
+from pathlib import Path
+
+
+def _load():
+    p = Path(__file__).resolve().parents[1] / "scripts" / "anthropic_proxy.py"
+    spec = importlib.util.spec_from_file_location("anthropic_proxy", p)
+    m = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(m)
+    return m
+
+
+proxy = _load()
+CEILING = 80
+
+
+def _fire_turns(counts):
+    """Replay the breaker's gating decision (as in build_openai_request) over a
+    sequence of cumulative tool-turn counts; return the counts at which it fired."""
+    m = proxy.SessionMonitor(context_window=100000)
+    fired = []
+    for count in counts:
+        if count >= m.last_hard_finalize_turn_count + CEILING:
+            m.last_hard_finalize_turn_count = count
+            fired.append(count)
+    return fired
+
+
+class TestTurnCountBreakerPeriodic(unittest.TestCase):
+    def test_monitor_has_the_field_defaulting_zero(self):
+        m = proxy.SessionMonitor(context_window=100000)
+        self.assertEqual(m.last_hard_finalize_turn_count, 0)
+
+    def test_fires_periodically_not_every_turn(self):
+        # cumulative tool turns 1..244 (grows by 1 each request)
+        fired = _fire_turns(range(1, 245))
+        # periodic at the ceiling multiples — NOT every turn past 80
+        self.assertEqual(fired, [80, 160, 240])
+
+    def test_does_not_refire_between_crossings(self):
+        # turns 80..159 -> fires once at 80, then silent until 160
+        fired = _fire_turns(range(80, 160))
+        self.assertEqual(fired, [80])
+
+    def test_first_fire_at_ceiling(self):
+        self.assertEqual(_fire_turns(range(1, 81)), [80])
+        self.assertEqual(_fire_turns(range(1, 80)), [])  # never reaches ceiling
+
+
+if __name__ == "__main__":
+    unittest.main()