@miller-tech/uap 1.15.11 → 1.15.13

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -1343,19 +1343,65 @@ 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
+    property_map_keys = {"properties", "definitions", "$defs", "dependentSchemas"}
+
+    def _walk(node, parent_key=None):
+        nonlocal removed
+        if isinstance(node, dict):
+            cleaned = {}
+            for key, value in node.items():
+                key_is_property_name = parent_key in property_map_keys
+                if (
+                    key == "pattern"
+                    and isinstance(value, str)
+                    and not key_is_property_name
+                ):
+                    removed += 1
+                    continue
+                if key == "patternProperties" and not key_is_property_name:
+                    removed += 1
+                    continue
+                cleaned[key] = _walk(value, key)
+            return cleaned
+        if isinstance(node, list):
+            return [_walk(item, parent_key) 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
 
 

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -100,6 +100,85 @@ 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"])
+
+    def test_convert_tools_keeps_property_named_pattern(self):
+        anthropic_tools = [
+            {
+                "name": "ScheduleTool",
+                "description": "test",
+                "input_schema": {
+                    "type": "object",
+                    "required": ["pattern", "subject"],
+                    "properties": {
+                        "pattern": {
+                            "type": "string",
+                            "description": "User-provided matching pattern",
+                        },
+                        "subject": {"type": "string"},
+                    },
+                },
+            }
+        ]
+
+        converted = proxy._convert_anthropic_tools_to_openai(anthropic_tools)
+        params = converted[0]["function"]["parameters"]
+        self.assertIn("pattern", params["required"])
+        self.assertEqual(params["properties"]["pattern"]["type"], "string")
+
+
 class TestStreamGuardedPathSelection(unittest.TestCase):
     def test_required_tool_turn_uses_guarded_non_stream(self):
         old_force = getattr(proxy, "PROXY_FORCE_NON_STREAM")