@miller-tech/uap 1.15.8 → 1.15.10

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -306,6 +306,44 @@ def _load_tool_call_grammar(path: str) -> str:
 
 
 TOOL_CALL_GBNF = _load_tool_call_grammar(PROXY_TOOL_CALL_GRAMMAR_PATH)
+TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE = True
+
+
+def _is_grammar_tools_incompatibility(status_code: int, error_text: str) -> bool:
+    if status_code != 400:
+        return False
+    lowered = (error_text or "").lower()
+    return "custom grammar constraints" in lowered and "with tools" in lowered
+
+
+def _maybe_disable_grammar_for_tools_error(
+    request_body: dict,
+    status_code: int,
+    error_text: str,
+    source: str,
+) -> bool:
+    global TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE
+
+    if "grammar" not in request_body or not request_body.get("tools"):
+        return False
+    if not _is_grammar_tools_incompatibility(status_code, error_text):
+        return False
+
+    request_body.pop("grammar", None)
+    if TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE:
+        TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE = False
+        logger.warning(
+            "Tool-call grammar rejected by upstream for tool turns; "
+            "disabling grammar-on-tools for this proxy process (%s)",
+            source,
+        )
+    else:
+        logger.warning(
+            "Tool-call grammar already disabled for tool turns; retrying %s without grammar",
+            source,
+        )
+
+    return True
 
 
 def _apply_tool_call_grammar(
@@ -319,6 +357,9 @@ def _apply_tool_call_grammar(
     if not request_body.get("tools"):
         return
 
+    if not TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE:
+        return
+
     effective_tool_choice = (
         tool_choice if tool_choice is not None else request_body.get("tool_choice")
     )
@@ -938,7 +979,7 @@ async def lifespan(app: FastAPI):
         _resolve_prune_target_fraction() * 100,
     )
     logger.info(
-        "Guardrails: malformed=%s stream_strict=%s force_non_stream=%s args_preflight=%s tool_narrowing=%s thinking_off_on_tools=%s dampener=%s(%d/%d/%d/%d->%d) contamination_breaker=%s(%d forced=%d required_miss=%d) analysis_only_route=%s(min_tools=%d,max_msgs=%d) grammar=%s(required_only=%s loaded=%s path=%s)",
+        "Guardrails: malformed=%s stream_strict=%s force_non_stream=%s args_preflight=%s tool_narrowing=%s thinking_off_on_tools=%s dampener=%s(%d/%d/%d/%d->%d) contamination_breaker=%s(%d forced=%d required_miss=%d) analysis_only_route=%s(min_tools=%d,max_msgs=%d) grammar=%s(required_only=%s loaded=%s tools_compatible=%s path=%s)",
         PROXY_MALFORMED_TOOL_GUARDRAIL,
         PROXY_MALFORMED_TOOL_STREAM_STRICT,
         PROXY_FORCE_NON_STREAM,
@@ -961,6 +1002,7 @@ async def lifespan(app: FastAPI):
         PROXY_TOOL_CALL_GRAMMAR,
         PROXY_TOOL_CALL_GRAMMAR_REQUIRED_ONLY,
         bool(TOOL_CALL_GBNF),
+        TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE,
         PROXY_TOOL_CALL_GRAMMAR_PATH,
     )
 
@@ -2437,16 +2479,14 @@ def _classify_tool_response_issue(
     has_tool_calls = _openai_has_tool_calls(openai_resp)
     if not has_tool_calls:
         if required_tool_choice:
-            text = _openai_message_text(openai_resp).strip()
-            if not text or len(text) <= 48:
-                return ToolResponseIssue(
-                    kind="required_tool_miss",
-                    reason="required tool turn returned no tool calls",
-                    retry_hint=(
-                        "A tool call is mandatory for this turn. Emit exactly one valid tool call now "
-                        "with a strict JSON object in `arguments`."
-                    ),
-                )
+            return ToolResponseIssue(
+                kind="required_tool_miss",
+                reason="required tool turn returned no tool calls",
+                retry_hint=(
+                    "A tool call is mandatory for this turn. Emit exactly one valid tool call now "
+                    "with a strict JSON object in `arguments`."
+                ),
+            )
         return ToolResponseIssue()
 
     if not PROXY_TOOL_ARGS_PREFLIGHT:
@@ -2524,6 +2564,49 @@ def _looks_malformed_tool_payload(text: str) -> bool:
         return True
     if lowered.count("</parameter") >= 1 and lowered.count('{"description"') >= 1:
         return True
+    if _looks_repetitive_policy_echo(text):
+        return True
+    return False
+
+
+def _looks_repetitive_policy_echo(text: str) -> bool:
+    if not text:
+        return False
+
+    lowered = text.lower()
+    compact = re.sub(r"\s+", " ", lowered).strip()
+    if not compact:
+        return False
+
+    policy_phrase_markers = (
+        "at least 2 new test cases",
+        "tests must be in test/",
+        "describe/it/expect using vitest",
+    )
+    if any(compact.count(marker) >= 4 for marker in policy_phrase_markers):
+        return True
+
+    lines = [
+        re.sub(r"\s+", " ", line.strip().lower())
+        for line in text.splitlines()
+        if line.strip()
+    ]
+    if lines:
+        line_counts: dict[str, int] = {}
+        for line in lines:
+            if len(line) < 24:
+                continue
+            line_counts[line] = line_counts.get(line, 0) + 1
+        if line_counts and max(line_counts.values()) >= 8:
+            return True
+
+    repeated_phrase_match = re.search(
+        r"((?:[a-z0-9_./-]+\s+){2,8}[a-z0-9_./-]+)(?:\s+\1){7,}",
+        compact,
+    )
+    if repeated_phrase_match:
+        return True
+
     return False
 
 
@@ -3481,6 +3564,20 @@ async def messages(request: Request):
             headers={"Content-Type": "application/json"},
         )
 
+        if strict_resp.status_code != 200:
+            error_text = strict_resp.text[:1000]
+            if _maybe_disable_grammar_for_tools_error(
+                strict_body,
+                strict_resp.status_code,
+                error_text,
+                "strict-stream",
+            ):
+                strict_resp = await client.post(
+                    f"{LLAMA_CPP_BASE}/chat/completions",
+                    json=strict_body,
+                    headers={"Content-Type": "application/json"},
+                )
+
         if strict_resp.status_code != 200:
             error_text = strict_resp.text[:1000]
             logger.error(
@@ -3621,6 +3718,35 @@ async def messages(request: Request):
             error_body = await resp.aread()
             await resp.aclose()
             error_text = error_body.decode("utf-8", errors="replace")[:1000]
+            if _maybe_disable_grammar_for_tools_error(
+                openai_body,
+                resp.status_code,
+                error_text,
+                "stream",
+            ):
+                resp = await client.send(
+                    client.build_request(
+                        "POST",
+                        f"{LLAMA_CPP_BASE}/chat/completions",
+                        json=openai_body,
+                        headers={"Content-Type": "application/json"},
+                    ),
+                    stream=True,
+                )
+                if resp.status_code == 200:
+                    return StreamingResponse(
+                        stream_anthropic_response(resp, model, monitor, body),
+                        media_type="text/event-stream",
+                        headers={
+                            "Cache-Control": "no-cache",
+                            "Connection": "keep-alive",
+                        },
+                    )
+
+                error_body = await resp.aread()
+                await resp.aclose()
+                error_text = error_body.decode("utf-8", errors="replace")[:1000]
+
             logger.error("Upstream HTTP %d: %s", resp.status_code, error_text)
 
             # Parse the error for a user-friendly message
@@ -3708,6 +3834,20 @@ async def messages(request: Request):
             headers={"Content-Type": "application/json"},
         )
 
+        if resp.status_code != 200:
+            error_text = resp.text[:1000]
+            if _maybe_disable_grammar_for_tools_error(
+                openai_body,
+                resp.status_code,
+                error_text,
+                "non-stream",
+            ):
+                resp = await client.post(
+                    f"{LLAMA_CPP_BASE}/chat/completions",
+                    json=openai_body,
+                    headers={"Content-Type": "application/json"},
+                )
+
         # Option B: Handle non-streaming errors too
         if resp.status_code != 200:
             error_text = resp.text[:1000]
@@ -3851,6 +3991,7 @@ async def context_status(request: Request):
             "required_only": PROXY_TOOL_CALL_GRAMMAR_REQUIRED_ONLY,
             "path": PROXY_TOOL_CALL_GRAMMAR_PATH,
             "loaded": bool(TOOL_CALL_GBNF),
+            "tools_compatible": TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE,
         },
         # Loop protection stats
         "loop_protection": {

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -518,10 +518,12 @@ class TestMalformedToolGuardrail(unittest.TestCase):
         old_enabled = getattr(proxy, "PROXY_TOOL_CALL_GRAMMAR")
         old_required_only = getattr(proxy, "PROXY_TOOL_CALL_GRAMMAR_REQUIRED_ONLY")
         old_grammar = getattr(proxy, "TOOL_CALL_GBNF")
+        old_tools_compatible = getattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE")
         try:
             setattr(proxy, "PROXY_TOOL_CALL_GRAMMAR", True)
             setattr(proxy, "PROXY_TOOL_CALL_GRAMMAR_REQUIRED_ONLY", True)
             setattr(proxy, "TOOL_CALL_GBNF", 'root ::= "<tool_call>"')
+            setattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE", True)
 
             openai_body = {
                 "model": "test",
@@ -548,6 +550,56 @@ class TestMalformedToolGuardrail(unittest.TestCase):
             setattr(proxy, "PROXY_TOOL_CALL_GRAMMAR", old_enabled)
             setattr(proxy, "PROXY_TOOL_CALL_GRAMMAR_REQUIRED_ONLY", old_required_only)
             setattr(proxy, "TOOL_CALL_GBNF", old_grammar)
+            setattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE", old_tools_compatible)
+
+    def test_apply_tool_call_grammar_skips_when_upstream_tools_are_incompatible(self):
+        old_enabled = getattr(proxy, "PROXY_TOOL_CALL_GRAMMAR")
+        old_required_only = getattr(proxy, "PROXY_TOOL_CALL_GRAMMAR_REQUIRED_ONLY")
+        old_grammar = getattr(proxy, "TOOL_CALL_GBNF")
+        old_tools_compatible = getattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE")
+        try:
+            setattr(proxy, "PROXY_TOOL_CALL_GRAMMAR", True)
+            setattr(proxy, "PROXY_TOOL_CALL_GRAMMAR_REQUIRED_ONLY", True)
+            setattr(proxy, "TOOL_CALL_GBNF", 'root ::= "<tool_call>"')
+            setattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE", False)
+
+            request = {
+                "tools": [{"type": "function", "function": {"name": "Read"}}],
+                "tool_choice": "required",
+            }
+            proxy._apply_tool_call_grammar(request)
+
+            self.assertNotIn("grammar", request)
+        finally:
+            setattr(proxy, "PROXY_TOOL_CALL_GRAMMAR", old_enabled)
+            setattr(proxy, "PROXY_TOOL_CALL_GRAMMAR_REQUIRED_ONLY", old_required_only)
+            setattr(proxy, "TOOL_CALL_GBNF", old_grammar)
+            setattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE", old_tools_compatible)
+
+    def test_maybe_disable_grammar_for_tools_error_strips_grammar_and_disables_flag(
+        self,
+    ):
+        old_tools_compatible = getattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE")
+        try:
+            setattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE", True)
+
+            request = {
+                "tools": [{"type": "function", "function": {"name": "Read"}}],
+                "grammar": 'root ::= "<tool_call>"',
+            }
+
+            retried = proxy._maybe_disable_grammar_for_tools_error(
+                request,
+                400,
+                '{"error":{"message":"Cannot use custom grammar constraints with tools."}}',
+                "unit-test",
+            )
+
+            self.assertTrue(retried)
+            self.assertNotIn("grammar", request)
+            self.assertFalse(getattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE"))
+        finally:
+            setattr(proxy, "TOOL_CALL_GRAMMAR_TOOLS_COMPATIBLE", old_tools_compatible)
 
     def test_clean_guardrail_response_does_not_promise_future_tool_call(self):
         guardrail = proxy._build_clean_guardrail_openai_response(
@@ -753,6 +805,54 @@ class TestMalformedToolGuardrail(unittest.TestCase):
         )
         self.assertEqual(issue.kind, "required_tool_miss")
 
+    def test_required_tool_turn_with_long_text_without_tool_call_is_flagged(self):
+        openai_resp = {
+            "choices": [
+                {
+                    "finish_reason": "stop",
+                    "message": {
+                        "content": (
+                            "I reviewed the repository and here is a long explanation that still "
+                            "does not include any valid tool call payload for this required turn."
+                        ),
+                        "tool_calls": [],
+                    },
+                }
+            ]
+        }
+        anthropic_body = {
+            "tools": [{"name": "Edit", "input_schema": {"type": "object"}}],
+        }
+
+        issue = proxy._classify_tool_response_issue(
+            openai_resp, anthropic_body, required_tool_choice=True
+        )
+        self.assertEqual(issue.kind, "required_tool_miss")
+
+    def test_preflight_flags_repetitive_policy_echo_without_tool_call(self):
+        repeated = " (describe/it/expect using vitest" * 24
+        openai_resp = {
+            "choices": [
+                {
+                    "finish_reason": "stop",
+                    "message": {
+                        "content": (
+                            "- At least 2 new test cases before claiming done. "
+                            "- Tests must be in test/ following existing patterns."
+                            f"{repeated}"
+                        ),
+                        "tool_calls": [],
+                    },
+                }
+            ]
+        }
+        anthropic_body = {
+            "tools": [{"name": "Read", "input_schema": {"type": "object"}}],
+        }
+
+        issue = proxy._classify_tool_response_issue(openai_resp, anthropic_body)
+        self.assertEqual(issue.kind, "malformed_payload")
+
     def test_markup_repair_sanitizes_tool_arguments(self):
         openai_resp = {
             "choices": [