@miller-tech/uap 1.15.10 → 1.15.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "1.15.10",
+  "version": "1.15.12",
   "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"
@@ -1321,19 +1343,56 @@ def _last_user_has_tool_result(anthropic_body: dict) -> bool:
     return False
 
 
+def _sanitize_tool_schema_for_llama(schema):
+    """Remove JSON Schema keywords that generate unsupported regex grammar.
+
+    llama.cpp's tool grammar generator can fail on regex-heavy schema fields
+    such as "pattern" and "patternProperties" (for example "\\w").
+    """
+
+    removed = 0
+
+    def _walk(node):
+        nonlocal removed
+        if isinstance(node, dict):
+            cleaned = {}
+            for key, value in node.items():
+                if key in {"pattern", "patternProperties"}:
+                    removed += 1
+                    continue
+                cleaned[key] = _walk(value)
+            return cleaned
+        if isinstance(node, list):
+            return [_walk(item) for item in node]
+        return node
+
+    return _walk(schema), removed
+
+
 def _convert_anthropic_tools_to_openai(anthropic_tools: list[dict]) -> list[dict]:
     converted = []
+    removed_pattern_fields = 0
     for tool in anthropic_tools:
+        input_schema, removed = _sanitize_tool_schema_for_llama(
+            tool.get("input_schema", {})
+        )
+        removed_pattern_fields += removed
         converted.append(
             {
                 "type": "function",
                 "function": {
                     "name": tool.get("name", ""),
                     "description": tool.get("description", ""),
-                    "parameters": tool.get("input_schema", {}),
+                    "parameters": input_schema,
                 },
             }
         )
+    if removed_pattern_fields > 0:
+        logger.warning(
+            "TOOL SCHEMA SANITIZE: removed %d regex pattern fields from %d tools",
+            removed_pattern_fields,
+            len(anthropic_tools),
+        )
     return converted
 
 
@@ -3550,9 +3609,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)
@@ -3623,10 +3683,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,109 @@ class TestProxyConfigTuning(unittest.TestCase):
             setattr(proxy, "PROXY_CONTEXT_PRUNE_TARGET_FRACTION", old_target)
 
 
+class TestToolSchemaSanitization(unittest.TestCase):
+    def test_convert_tools_strips_pattern_fields(self):
+        anthropic_tools = [
+            {
+                "name": "Sample",
+                "description": "test",
+                "input_schema": {
+                    "type": "object",
+                    "properties": {
+                        "id": {
+                            "type": "string",
+                            "pattern": "^[\\w-]+$",
+                        }
+                    },
+                    "required": ["id"],
+                },
+            }
+        ]
+
+        converted = proxy._convert_anthropic_tools_to_openai(anthropic_tools)
+        params = converted[0]["function"]["parameters"]
+        self.assertEqual(params["properties"]["id"]["type"], "string")
+        self.assertNotIn("pattern", params["properties"]["id"])
+
+    def test_convert_tools_strips_pattern_properties_fields(self):
+        anthropic_tools = [
+            {
+                "name": "Sample",
+                "description": "test",
+                "input_schema": {
+                    "type": "object",
+                    "patternProperties": {
+                        "^x-": {"type": "string"},
+                    },
+                    "properties": {
+                        "meta": {
+                            "type": "object",
+                            "properties": {
+                                "tag": {
+                                    "type": "string",
+                                    "pattern": "^[a-z]+$",
+                                }
+                            },
+                        }
+                    },
+                },
+            }
+        ]
+
+        converted = proxy._convert_anthropic_tools_to_openai(anthropic_tools)
+        params = converted[0]["function"]["parameters"]
+        self.assertNotIn("patternProperties", params)
+        self.assertNotIn("pattern", params["properties"]["meta"]["properties"]["tag"])
+
+
+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 = {