@miller-tech/uap 1.20.50 → 1.20.51

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -3288,7 +3288,11 @@ def _resolve_state_machine_tool_choice(
     return None, "unknown_phase"
 
 
-def _maybe_inject_recon_convergence(openai_body: dict, monitor: "SessionMonitor") -> None:
+def _maybe_inject_recon_convergence(
+    openai_body: dict,
+    monitor: "SessionMonitor",
+    full_tools: list[dict] | None = None,
+) -> None:
     """Nudge a session stuck in prolonged exploration toward its deliverable.
 
     Fires when `consecutive_no_write_turns` crosses
@@ -3298,6 +3302,13 @@ def _maybe_inject_recon_convergence(openai_body: dict, monitor: "SessionMonitor"
     of turns and never converging to the synthesis/write step. Two
     escalation tiers: a firm "switch to synthesis" directive, then a hard
     "STOP, write it now" once the streak is 2x over threshold.
+
+    `full_tools` is the request's tool list *before* `_narrow_tools_for_request`
+    pruned it. When the directive fires, any write/deliverable tool that
+    narrowing dropped is re-injected into `openai_body["tools"]` — narrowing
+    scores tools against the (exploration-heavy) recon prompt and runs before
+    this guardrail, so it routinely strips the very write tool the directive
+    tells the model to use, leaving the directive impossible to satisfy.
     """
     if PROXY_RECON_CONVERGENCE_THRESHOLD <= 0:
         return
@@ -3327,9 +3338,28 @@ def _maybe_inject_recon_convergence(openai_body: dict, monitor: "SessionMonitor"
     msgs = openai_body.get("messages", [])
     msgs.append({"role": "user", "content": directive})
     openai_body["messages"] = msgs
+
+    # Re-inject any write/deliverable tool that narrowing dropped, so the
+    # "write your deliverable" directive is actually satisfiable. Without
+    # this the model is told to write but has no write tool to call, picks
+    # another read tool, and the streak climbs unbounded.
+    restored: list[str] = []
+    if full_tools:
+        present = {
+            (t.get("function", {}).get("name", "") or "").lower()
+            for t in openai_body.get("tools", [])
+        }
+        for tool in full_tools:
+            name = (tool.get("function", {}).get("name", "") or "")
+            if name.lower() in _WRITE_TOOL_CLASS and name.lower() not in present:
+                openai_body.setdefault("tools", []).append(tool)
+                present.add(name.lower())
+                restored.append(name)
+
     logger.warning(
-        "RECON CONVERGENCE: injected %s directive (no_write_streak=%d, ctx=%.0f%%)",
-        tier, streak, util * 100,
+        "RECON CONVERGENCE: injected %s directive (no_write_streak=%d, ctx=%.0f%%, "
+        "restored_write_tools=%s)",
+        tier, streak, util * 100, restored or "none",
     )
 
 
@@ -3575,10 +3605,14 @@ def build_openai_request(
             )
 
     # Convert Anthropic tools to OpenAI function-calling tools
+    full_openai_tools: list[dict] = []
     if has_tools:
         openai_body["tools"] = _convert_anthropic_tools_to_openai(
             anthropic_body.get("tools", [])
         )
+        # Keep the full (pre-narrowing) list so the recon-convergence
+        # guardrail can restore a write tool that narrowing dropped.
+        full_openai_tools = openai_body["tools"]
         openai_body["tools"] = _narrow_tools_for_request(
             anthropic_body, openai_body["tools"]
         )
@@ -3842,8 +3876,9 @@ def build_openai_request(
 
     # Recon-convergence guardrail (B1) — runs on every built request so a
     # session wandering in exploration without producing a write is nudged
-    # toward its deliverable regardless of tool-turn phase.
-    _maybe_inject_recon_convergence(openai_body, monitor)
+    # toward its deliverable regardless of tool-turn phase. Passed the full
+    # pre-narrowing toolset so it can restore a dropped write tool.
+    _maybe_inject_recon_convergence(openai_body, monitor, full_openai_tools)
 
     return openai_body
 

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -5479,6 +5479,84 @@ class TestReconConvergence(unittest.TestCase):
         proxy._maybe_inject_recon_convergence(body, m)
         self.assertEqual(len(body["messages"]), 1)
 
+    @staticmethod
+    def _tool(name: str) -> dict:
+        return {"type": "function", "function": {"name": name, "description": f"{name} tool"}}
+
+    def test_dropped_write_tool_is_restored_when_directive_fires(self):
+        """The core fix: if narrowing left no write tool in the request,
+        a firing directive re-injects it from the full pre-narrowing set."""
+        proxy.PROXY_RECON_CONVERGENCE_THRESHOLD = 40
+        m = proxy.SessionMonitor(context_window=131072)
+        m.consecutive_no_write_turns = 45
+        # narrowed toolset — exploration tools only, no write tool
+        body = {
+            "messages": [{"role": "user", "content": "go"}],
+            "tools": [self._tool("Read"), self._tool("Grep"), self._tool("Bash")],
+        }
+        # full pre-narrowing set DID include a write tool
+        full = body["tools"] + [self._tool("Edit")]
+        proxy._maybe_inject_recon_convergence(body, m, full)
+        names = [t["function"]["name"] for t in body["tools"]]
+        self.assertIn("Edit", names)
+
+    def test_present_write_tool_not_duplicated(self):
+        """If a write tool already survived narrowing, it is not added twice."""
+        proxy.PROXY_RECON_CONVERGENCE_THRESHOLD = 40
+        m = proxy.SessionMonitor(context_window=131072)
+        m.consecutive_no_write_turns = 45
+        body = {
+            "messages": [{"role": "user", "content": "go"}],
+            "tools": [self._tool("Read"), self._tool("Edit")],
+        }
+        full = list(body["tools"])
+        proxy._maybe_inject_recon_convergence(body, m, full)
+        names = [t["function"]["name"] for t in body["tools"]]
+        self.assertEqual(names.count("Edit"), 1)
+
+    def test_no_write_tool_anywhere_is_safe(self):
+        """A recon agent whose toolset has no write tool at all: nothing to
+        restore, no crash."""
+        proxy.PROXY_RECON_CONVERGENCE_THRESHOLD = 40
+        m = proxy.SessionMonitor(context_window=131072)
+        m.consecutive_no_write_turns = 45
+        body = {
+            "messages": [{"role": "user", "content": "go"}],
+            "tools": [self._tool("Read"), self._tool("Bash")],
+        }
+        proxy._maybe_inject_recon_convergence(body, m, list(body["tools"]))
+        names = [t["function"]["name"] for t in body["tools"]]
+        self.assertEqual(names, ["Read", "Bash"])
+
+    def test_full_tools_omitted_is_safe(self):
+        """Called without full_tools (default None) — directive still fires,
+        no tool restoration attempted, no crash."""
+        proxy.PROXY_RECON_CONVERGENCE_THRESHOLD = 40
+        m = proxy.SessionMonitor(context_window=131072)
+        m.consecutive_no_write_turns = 45
+        body = {
+            "messages": [{"role": "user", "content": "go"}],
+            "tools": [self._tool("Read")],
+        }
+        proxy._maybe_inject_recon_convergence(body, m)
+        self.assertEqual(len(body["messages"]), 2)
+        self.assertEqual([t["function"]["name"] for t in body["tools"]], ["Read"])
+
+    def test_no_restore_below_threshold(self):
+        """Below threshold the directive does not fire, so no write tool is
+        restored even if narrowing dropped one."""
+        proxy.PROXY_RECON_CONVERGENCE_THRESHOLD = 40
+        m = proxy.SessionMonitor(context_window=131072)
+        m.consecutive_no_write_turns = 39
+        body = {
+            "messages": [{"role": "user", "content": "go"}],
+            "tools": [self._tool("Read")],
+        }
+        full = body["tools"] + [self._tool("Write")]
+        proxy._maybe_inject_recon_convergence(body, m, full)
+        names = [t["function"]["name"] for t in body["tools"]]
+        self.assertEqual(names, ["Read"])
+
 
 class TestPrunerRework(unittest.TestCase):
     """Tests for the reworked context pruner (B2 + B3): contiguous