@miller-tech/uap 1.15.9 → 1.15.11

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -1134,6 +1134,28 @@ def _has_tool_definitions(anthropic_body: dict) -> bool:
     return isinstance(tools, list) and len(tools) > 0
 
 
+def _should_use_guarded_non_stream(
+    is_stream: bool,
+    anthropic_body: dict,
+    openai_body: dict,
+) -> bool:
+    if not is_stream:
+        return False
+
+    if PROXY_FORCE_NON_STREAM:
+        return True
+
+    has_tools = _has_tool_definitions(anthropic_body)
+    if PROXY_MALFORMED_TOOL_STREAM_STRICT and has_tools:
+        return True
+
+    return (
+        has_tools
+        and openai_body.get("tool_choice") == "required"
+        and (PROXY_MALFORMED_TOOL_GUARDRAIL or PROXY_GUARDRAIL_RETRY)
+    )
+
+
 def _message_has_tool_result(content) -> bool:
     return isinstance(content, list) and any(
         isinstance(block, dict) and block.get("type") == "tool_result"
@@ -2479,16 +2501,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:
@@ -2566,6 +2586,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
 
 
@@ -3509,9 +3572,10 @@ async def messages(request: Request):
             media_type="application/json",
         )
 
-    use_guarded_non_stream = is_stream and (
-        PROXY_FORCE_NON_STREAM
-        or (PROXY_MALFORMED_TOOL_STREAM_STRICT and "tools" in body)
+    use_guarded_non_stream = _should_use_guarded_non_stream(
+        is_stream,
+        body,
+        openai_body,
     )
     if use_guarded_non_stream:
         strict_body = dict(openai_body)
@@ -3582,10 +3646,14 @@ async def messages(request: Request):
             logger.info(
                 "FORCED NON-STREAM: served stream response via guarded non-stream path"
             )
-        else:
+        elif PROXY_MALFORMED_TOOL_STREAM_STRICT and _has_tool_definitions(body):
             logger.info(
                 "STRICT STREAM GUARDRAIL: served stream response via guarded non-stream path"
             )
+        else:
+            logger.info(
+                "REQUIRED TOOL STREAM GUARDRAIL: served stream response via guarded non-stream path"
+            )
 
         return StreamingResponse(
             stream_anthropic_message(anthropic_resp),

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -100,6 +100,54 @@ class TestProxyConfigTuning(unittest.TestCase):
             setattr(proxy, "PROXY_CONTEXT_PRUNE_TARGET_FRACTION", old_target)
 
 
+class TestStreamGuardedPathSelection(unittest.TestCase):
+    def test_required_tool_turn_uses_guarded_non_stream(self):
+        old_force = getattr(proxy, "PROXY_FORCE_NON_STREAM")
+        old_strict = getattr(proxy, "PROXY_MALFORMED_TOOL_STREAM_STRICT")
+        old_guard = getattr(proxy, "PROXY_MALFORMED_TOOL_GUARDRAIL")
+        old_retry = getattr(proxy, "PROXY_GUARDRAIL_RETRY")
+        try:
+            setattr(proxy, "PROXY_FORCE_NON_STREAM", False)
+            setattr(proxy, "PROXY_MALFORMED_TOOL_STREAM_STRICT", False)
+            setattr(proxy, "PROXY_MALFORMED_TOOL_GUARDRAIL", True)
+            setattr(proxy, "PROXY_GUARDRAIL_RETRY", True)
+
+            selected = proxy._should_use_guarded_non_stream(
+                True,
+                {"tools": [{"name": "Read", "input_schema": {"type": "object"}}]},
+                {"tool_choice": "required"},
+            )
+            self.assertTrue(selected)
+        finally:
+            setattr(proxy, "PROXY_FORCE_NON_STREAM", old_force)
+            setattr(proxy, "PROXY_MALFORMED_TOOL_STREAM_STRICT", old_strict)
+            setattr(proxy, "PROXY_MALFORMED_TOOL_GUARDRAIL", old_guard)
+            setattr(proxy, "PROXY_GUARDRAIL_RETRY", old_retry)
+
+    def test_auto_tool_turn_keeps_true_stream_when_strict_off(self):
+        old_force = getattr(proxy, "PROXY_FORCE_NON_STREAM")
+        old_strict = getattr(proxy, "PROXY_MALFORMED_TOOL_STREAM_STRICT")
+        old_guard = getattr(proxy, "PROXY_MALFORMED_TOOL_GUARDRAIL")
+        old_retry = getattr(proxy, "PROXY_GUARDRAIL_RETRY")
+        try:
+            setattr(proxy, "PROXY_FORCE_NON_STREAM", False)
+            setattr(proxy, "PROXY_MALFORMED_TOOL_STREAM_STRICT", False)
+            setattr(proxy, "PROXY_MALFORMED_TOOL_GUARDRAIL", True)
+            setattr(proxy, "PROXY_GUARDRAIL_RETRY", True)
+
+            selected = proxy._should_use_guarded_non_stream(
+                True,
+                {"tools": [{"name": "Read", "input_schema": {"type": "object"}}]},
+                {"tool_choice": "auto"},
+            )
+            self.assertFalse(selected)
+        finally:
+            setattr(proxy, "PROXY_FORCE_NON_STREAM", old_force)
+            setattr(proxy, "PROXY_MALFORMED_TOOL_STREAM_STRICT", old_strict)
+            setattr(proxy, "PROXY_MALFORMED_TOOL_GUARDRAIL", old_guard)
+            setattr(proxy, "PROXY_GUARDRAIL_RETRY", old_retry)
+
+
 class TestMalformedToolGuardrail(unittest.TestCase):
     def test_detects_malformed_tool_payload(self):
         openai_resp = {
@@ -805,6 +853,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": [