@miller-tech/uap 1.20.27 → 1.20.32

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -656,6 +656,8 @@ class SessionMonitor:
     tool_state_review_cycles: int = 0
     last_tool_fingerprint: str = ""
     cycling_tool_names: list = field(default_factory=list)
+    session_banned_tools: set = field(default_factory=set)  # tools banned for entire session after repeated cycling
+    tool_cycle_counts: dict = field(default_factory=dict)  # {tool_name: cycle_count} across resets
     last_response_garbled: bool = False  # previous turn had garbled/malformed output
     finalize_turn_active: bool = False
     finalize_continuation_count: int = 0
@@ -1346,6 +1348,43 @@ def prune_conversation(
 http_client: httpx.AsyncClient | None = None
 
 
+def _is_loading_model_503(resp: httpx.Response) -> bool:
+    """Check if response is a 503 'Loading model' from llama.cpp."""
+    if resp.status_code != 503:
+        return False
+    try:
+        return "loading model" in resp.text.lower()
+    except Exception:
+        return False
+
+
+async def _wait_for_upstream_health(
+    client: httpx.AsyncClient,
+    max_wait: float = 60.0,
+    poll_interval: float = 5.0,
+) -> bool:
+    """Poll upstream /health until ready or timeout. Returns True if healthy."""
+    health_url = LLAMA_CPP_BASE.replace("/v1", "/health")
+    elapsed = 0.0
+    while elapsed < max_wait:
+        try:
+            resp = await client.get(health_url, timeout=5.0)
+            if resp.status_code == 200:
+                data = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else {}
+                if data.get("status") == "ok" or resp.status_code == 200:
+                    if elapsed > 0:
+                        logger.info(
+                            "UPSTREAM HEALTH: recovered after %.0fs wait", elapsed
+                        )
+                    return True
+        except Exception:
+            pass
+        await asyncio.sleep(poll_interval)
+        elapsed += poll_interval
+    logger.error("UPSTREAM HEALTH: not ready after %.0fs", max_wait)
+    return False
+
+
 async def _post_with_retry(
     client: httpx.AsyncClient,
     url: str,
@@ -1355,7 +1394,19 @@ async def _post_with_retry(
     last_exc: Exception | None = None
     for attempt in range(PROXY_UPSTREAM_RETRY_MAX):
         try:
-            return await client.post(url, json=payload, headers=headers)
+            resp = await client.post(url, json=payload, headers=headers)
+            # Cycle 19 Option 1: if 503 "Loading model", wait for health then retry
+            if _is_loading_model_503(resp):
+                logger.warning(
+                    "Upstream 503 Loading model (attempt %d/%d) – waiting for health",
+                    attempt + 1,
+                    PROXY_UPSTREAM_RETRY_MAX,
+                )
+                healthy = await _wait_for_upstream_health(client, max_wait=60.0)
+                if healthy and attempt < PROXY_UPSTREAM_RETRY_MAX - 1:
+                    continue  # retry the request now that upstream is healthy
+                return resp  # return the 503 if health wait timed out
+            return resp
         except (httpx.ConnectError, httpx.RemoteProtocolError, httpx.ReadTimeout) as exc:
             last_exc = exc
             if attempt < PROXY_UPSTREAM_RETRY_MAX - 1:
@@ -2240,6 +2291,16 @@ def _resolve_state_machine_tool_choice(
                 for part in fp.split("|"):
                     raw_names.append(part.split(":")[0])
             monitor.cycling_tool_names = list(dict.fromkeys(raw_names))
+            # Cycle 18 Option 2: track per-tool cycle counts and ban after 3 cycles
+            for name in monitor.cycling_tool_names:
+                monitor.tool_cycle_counts[name] = monitor.tool_cycle_counts.get(name, 0) + 1
+                if monitor.tool_cycle_counts[name] >= 3 and name not in monitor.session_banned_tools:
+                    monitor.session_banned_tools.add(name)
+                    logger.warning(
+                        "TOOL BAN: '%s' banned for session after %d cycle detections",
+                        name,
+                        monitor.tool_cycle_counts[name],
+                    )
             logger.warning(
                 "TOOL STATE MACHINE: entering review (cycle=%s repeat=%d stagnation=%d cycles=%d cycling_tools=%s)",
                 cycle_looping,
@@ -2629,14 +2690,15 @@ def build_openai_request(
                     cycling_names,
                     cycles,
                 )
-            # Narrow tools to exclude cycling tools
+            # Narrow tools to exclude cycling tools + session-banned tools
             # Option 1 (Cycle 13): if any cycling tool is read-only, exclude entire class
             # Option 1 (Cycle 14): persist exclusion during act phase too, not just review
+            # Option 2 (Cycle 18): always exclude session-banned tools
             if (
-                monitor.cycling_tool_names
+                (monitor.cycling_tool_names or monitor.session_banned_tools)
                 and "tools" in openai_body
             ):
-                exclude_set = set(monitor.cycling_tool_names)
+                exclude_set = set(monitor.cycling_tool_names) | monitor.session_banned_tools
                 # Expand to full read-only class if any cycling tool is read-only
                 if any(n.lower() in {c.lower() for c in _READ_ONLY_TOOL_CLASS} for n in exclude_set):
                     exclude_set |= _READ_ONLY_TOOL_CLASS
@@ -2648,13 +2710,15 @@ def build_openai_request(
                 ]
                 if narrowed:
                     openai_body["tools"] = narrowed
-                    logger.warning(
-                        "CYCLE BREAK: narrowed tools from %d to %d (excluded %s, read_only_class=%s)",
-                        original_count,
-                        len(narrowed),
-                        monitor.cycling_tool_names,
-                        any(n.lower() in {c.lower() for c in _READ_ONLY_TOOL_CLASS} for n in monitor.cycling_tool_names),
-                    )
+                    # Only log on first activation or phase transitions to reduce noise
+                    if state_reason in {"cycle_detected", "stagnation"}:
+                        logger.warning(
+                            "CYCLE BREAK: narrowed tools from %d to %d (excluded %s, read_only_class=%s)",
+                            original_count,
+                            len(narrowed),
+                            monitor.cycling_tool_names,
+                            any(n.lower() in {c.lower() for c in _READ_ONLY_TOOL_CLASS} for n in monitor.cycling_tool_names),
+                        )
                 else:
                     logger.warning(
                         "CYCLE BREAK: cannot narrow tools — all tools are cycling, keeping original set",
@@ -3092,6 +3156,47 @@ _TOOL_CALL_XML_RE = re.compile(
 )
 
 
+def _repair_tool_call_json(raw: str) -> str | None:
+    """Attempt to repair common garbled JSON in tool call payloads.
+
+    Returns repaired JSON string, or None if repair is not possible.
+    Handles: trailing braces, unbalanced brackets, truncated strings.
+    """
+    s = raw.strip()
+    if not s.startswith("{"):
+        return None
+    # Strip trailing garbage (runaway braces/brackets)
+    while s.endswith("}}") and s.count("{") < s.count("}"):
+        s = s[:-1]
+    while s.endswith("]]") and s.count("[") < s.count("]"):
+        s = s[:-1]
+    # Balance braces
+    open_b = s.count("{") - s.count("}")
+    if open_b > 0:
+        s += "}" * open_b
+    elif open_b < 0:
+        # Too many closing braces — trim from end
+        for _ in range(-open_b):
+            idx = s.rfind("}")
+            if idx > 0:
+                s = s[:idx] + s[idx + 1:]
+    # Try to parse
+    try:
+        json.loads(s)
+        return s
+    except json.JSONDecodeError:
+        pass
+    # Try truncating at last valid comma + closing
+    for end in range(len(s) - 1, max(0, len(s) - 200), -1):
+        candidate = s[:end].rstrip().rstrip(",") + "}" * max(0, s[:end].count("{") - s[:end].count("}"))
+        try:
+            json.loads(candidate)
+            return candidate
+        except json.JSONDecodeError:
+            continue
+    return None
+
+
 def _extract_tool_calls_from_text(text: str) -> tuple[list[dict], str]:
     """Parse ``<tool_call>{...}</tool_call>`` blocks out of *text*.
 
@@ -3112,7 +3217,18 @@ def _extract_tool_calls_from_text(text: str) -> tuple[list[dict], str]:
         try:
             payload = json.loads(raw_json)
         except json.JSONDecodeError:
-            continue
+            # Cycle 15 Option 1: attempt JSON repair before giving up
+            repaired = _repair_tool_call_json(raw_json)
+            if repaired:
+                try:
+                    payload = json.loads(repaired)
+                    logger.info(
+                        "TOOL CALL EXTRACTION: repaired garbled JSON in <tool_call> block"
+                    )
+                except json.JSONDecodeError:
+                    continue
+            else:
+                continue
         if not isinstance(payload, dict):
             continue
 
@@ -4380,9 +4496,11 @@ def _build_malformed_retry_body(
     retry_body = dict(openai_body)
     retry_body["stream"] = False
     retry_body["tool_choice"] = tool_choice
-    # Escalate temperature down on successive retries for more deterministic output
+    # Cycle 15 Option 3: vary temperature across retries to break degenerate patterns.
+    # Attempt 1: use configured retry temp (default 0.0) for deterministic first try.
+    # Attempt 2+: increase to 0.5 to escape the degenerate local minimum.
     if total_attempts > 1 and attempt > 1:
-        retry_body["temperature"] = 0.0
+        retry_body["temperature"] = 0.5
     else:
         retry_body["temperature"] = PROXY_MALFORMED_TOOL_RETRY_TEMPERATURE
 
@@ -5922,6 +6040,27 @@ async def messages(request: Request):
 
         if strict_resp.status_code != 200:
             error_text = strict_resp.text[:1000]
+            # Cycle 19 Option 2: For 503 "Loading model", don't advance state
+            # machine — return retriable 503 with Retry-After header so the
+            # client can retry without wasting state machine budget.
+            if _is_loading_model_503(strict_resp):
+                logger.warning(
+                    "Upstream 503 Loading model (strict-stream) — returning retriable 503 without advancing state",
+                )
+                return Response(
+                    content=json.dumps(
+                        {
+                            "type": "error",
+                            "error": {
+                                "type": "overloaded_error",
+                                "message": "Upstream model is loading. Retry in 10 seconds.",
+                            },
+                        }
+                    ),
+                    status_code=503,
+                    headers={"Retry-After": "10"},
+                    media_type="application/json",
+                )
             logger.error(
                 "Upstream HTTP %d (strict-stream): %s",
                 strict_resp.status_code,

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -4662,3 +4662,159 @@ class TestMalformedPayloadLoopFix(unittest.TestCase):
         }
         openai = proxy.build_openai_request(body, monitor)
         self.assertAlmostEqual(openai.get("temperature", 1.0), 0.3, places=1)
+
+
+class TestToolCallJsonRepair(unittest.TestCase):
+    """Tests for Cycle 15 Option 1: JSON repair in tool call extraction."""
+
+    def test_repairs_trailing_braces(self):
+        """Runaway closing braces are trimmed and JSON parsed."""
+        garbled = '{"name":"bash","arguments":{"command":"ls"}}}}'
+        repaired = proxy._repair_tool_call_json(garbled)
+        self.assertIsNotNone(repaired)
+        parsed = json.loads(repaired)
+        self.assertEqual(parsed["name"], "bash")
+
+    def test_repairs_unbalanced_open_braces(self):
+        """Missing closing braces are added."""
+        garbled = '{"name":"read","arguments":{"file_path":"/foo"}'
+        repaired = proxy._repair_tool_call_json(garbled)
+        self.assertIsNotNone(repaired)
+        parsed = json.loads(repaired)
+        self.assertEqual(parsed["name"], "read")
+
+    def test_returns_none_for_total_garbage(self):
+        """Completely invalid JSON returns None."""
+        result = proxy._repair_tool_call_json("not json at all")
+        self.assertIsNone(result)
+
+    def test_extracts_repaired_tool_call_from_text(self):
+        """End-to-end: garbled <tool_call> XML is extracted after repair."""
+        text = '<tool_call>\n{"name":"bash","arguments":{"command":"pwd"}}}\n</tool_call>'
+        extracted, remaining = proxy._extract_tool_calls_from_text(text)
+        self.assertEqual(len(extracted), 1)
+        self.assertEqual(extracted[0]["function"]["name"], "bash")
+
+
+class TestRetryTemperatureVariance(unittest.TestCase):
+    """Tests for Cycle 15 Option 3: retry temperature variance."""
+
+    def test_retry_attempt_1_uses_configured_temp(self):
+        """First retry attempt uses PROXY_MALFORMED_TOOL_RETRY_TEMPERATURE."""
+        body = proxy._build_malformed_retry_body(
+            {"messages": [{"role": "user", "content": "test"}], "tools": []},
+            {"messages": [{"role": "user", "content": "test"}], "tools": []},
+            retry_hint="fix it",
+            tool_choice="required",
+            attempt=1,
+            total_attempts=3,
+            is_garbled=False,
+        )
+        self.assertEqual(body["temperature"], proxy.PROXY_MALFORMED_TOOL_RETRY_TEMPERATURE)
+
+    def test_retry_attempt_2_uses_higher_temp(self):
+        """Second retry attempt uses temp=0.5 to break degenerate patterns."""
+        body = proxy._build_malformed_retry_body(
+            {"messages": [{"role": "user", "content": "test"}], "tools": []},
+            {"messages": [{"role": "user", "content": "test"}], "tools": []},
+            retry_hint="fix it",
+            tool_choice="required",
+            attempt=2,
+            total_attempts=3,
+            is_garbled=False,
+        )
+        self.assertEqual(body["temperature"], 0.5)
+
+
+class TestCycle18SessionBanAndLogNoise(unittest.TestCase):
+    """Tests for Cycle 18: session tool banning and log noise reduction."""
+
+    def test_tool_banned_after_3_cycle_detections(self):
+        """Option 2: tool gets session-banned after cycling 3 times."""
+        monitor = proxy.SessionMonitor(context_window=262144)
+        # Simulate 3 separate cycle detections for 'task'
+        monitor.tool_cycle_counts["task"] = 2
+        monitor.cycling_tool_names = ["task"]
+
+        # This is what happens inside the cycle detection — manually trigger
+        for name in monitor.cycling_tool_names:
+            monitor.tool_cycle_counts[name] = monitor.tool_cycle_counts.get(name, 0) + 1
+            if monitor.tool_cycle_counts[name] >= 3:
+                monitor.session_banned_tools.add(name)
+
+        self.assertIn("task", monitor.session_banned_tools)
+        self.assertEqual(monitor.tool_cycle_counts["task"], 3)
+
+    def test_session_ban_survives_state_reset(self):
+        """Option 2: session_banned_tools persists through reset_tool_turn_state."""
+        monitor = proxy.SessionMonitor(context_window=262144)
+        monitor.session_banned_tools.add("task")
+        monitor.tool_cycle_counts["task"] = 3
+
+        monitor.reset_tool_turn_state(reason="test")
+
+        # Session bans survive resets — they're session-level, not phase-level
+        self.assertIn("task", monitor.session_banned_tools)
+        self.assertEqual(monitor.tool_cycle_counts["task"], 3)
+
+    def test_banned_tools_excluded_even_without_cycling(self):
+        """Option 2: session-banned tools are excluded even when cycling_tool_names is empty."""
+        old_vals = {}
+        for k in ["PROXY_TOOL_STATE_MACHINE", "PROXY_TOOL_STATE_MIN_MESSAGES",
+                   "PROXY_TOOL_STATE_FORCED_BUDGET"]:
+            old_vals[k] = getattr(proxy, k)
+        try:
+            setattr(proxy, "PROXY_TOOL_STATE_MACHINE", True)
+            setattr(proxy, "PROXY_TOOL_STATE_MIN_MESSAGES", 3)
+            setattr(proxy, "PROXY_TOOL_STATE_FORCED_BUDGET", 6)
+
+            body = {
+                "model": "test",
+                "messages": [
+                    {"role": "user", "content": "do"},
+                    {"role": "assistant", "content": [
+                        {"type": "tool_use", "id": "t1", "name": "bash", "input": {"command": "ls"}}
+                    ]},
+                    {"role": "user", "content": [
+                        {"type": "tool_result", "tool_use_id": "t1", "content": "ok"}
+                    ]},
+                ],
+                "tools": [
+                    {"name": "task", "description": "Task", "input_schema": {"type": "object"}},
+                    {"name": "bash", "description": "Bash", "input_schema": {"type": "object"}},
+                    {"name": "read", "description": "Read", "input_schema": {"type": "object"}},
+                ],
+            }
+            monitor = proxy.SessionMonitor(context_window=262144)
+            monitor.session_banned_tools.add("task")
+            monitor.cycling_tool_names = []  # no active cycling
+
+            openai = proxy.build_openai_request(body, monitor)
+            remaining = [t["function"]["name"] for t in openai.get("tools", [])]
+            self.assertNotIn("task", remaining)
+            self.assertIn("bash", remaining)
+        finally:
+            for k, v in old_vals.items():
+                setattr(proxy, k, v)
+
+
+class TestUpstream503Resilience(unittest.TestCase):
+    """Tests for Cycle 19: upstream 503 Loading model resilience."""
+
+    def test_is_loading_model_503_detects_loading(self):
+        """Detects 503 Loading model response."""
+        resp = httpx.Response(
+            503,
+            text='{"error":{"message":"Loading model","type":"unavailable_error","code":503}}',
+        )
+        self.assertTrue(proxy._is_loading_model_503(resp))
+
+    def test_is_loading_model_503_ignores_other_503(self):
+        """Does not match 503 with different message."""
+        resp = httpx.Response(503, text='{"error":{"message":"Server busy"}}')
+        self.assertFalse(proxy._is_loading_model_503(resp))
+
+    def test_is_loading_model_503_ignores_200(self):
+        """Does not match 200 even with loading text."""
+        resp = httpx.Response(200, text='{"status":"loading model"}')
+        self.assertFalse(proxy._is_loading_model_503(resp))