@miller-tech/uap 1.83.0 → 1.84.1

package/package.json

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

package/src/policies/enforcers/delivery_enforcement.py

@@ -65,18 +65,21 @@ def _is_local_model_session() -> bool:
     return any(h in base for h in ("127.0.0.1", "localhost", "0.0.0.0", "::1"))
 
 
-# #2: a plain local-model session cannot effectively route through deliver and
-# deadlocks under block mode (it can read but never write -> recon loop, observed
-# live). Downgrade block->advisory for local sessions so the model can write
-# directly; the local proxy already guards it. Set UAP_DELIVER_LOCAL_ADVISORY=0
-# to keep strict block for local sessions too.
-_LOCAL_ADVISORY = os.environ.get("UAP_DELIVER_LOCAL_ADVISORY", "on").lower() not in {
-    "0",
-    "off",
-    "false",
-    "no",
-    "",
-}
+# #2/#3a: how a LOCAL-model session is handled under block mode. A plain local
+# session deadlocks under strict block (can read, never write -> recon loop,
+# observed live). UAP_DELIVER_LOCAL_MODE selects the resolution:
+#   advisory (default) -> allow direct writes (fast; the proxy guards the model)
+#   deliver            -> keep the block + route:deliver so the change is driven
+#                         through `uap deliver` (VERIFIED path; pairs with
+#                         UAP_DELIVER_AUTOROUTE)
+#   block              -> strict block (no relaxation)
+# Back-compat: UAP_DELIVER_LOCAL_ADVISORY=0 maps to "block".
+def _local_mode() -> str:
+    m = os.environ.get("UAP_DELIVER_LOCAL_MODE", "").lower()
+    if m in {"advisory", "deliver", "block"}:
+        return m
+    adv = os.environ.get("UAP_DELIVER_LOCAL_ADVISORY", "on").lower()
+    return "advisory" if adv not in {"0", "off", "false", "no", ""} else "block"
 
 
 def main() -> None:
@@ -124,8 +127,11 @@ def main() -> None:
     )
 
     mode = os.environ.get("UAP_ENFORCE_DELIVERY", "block").lower()
-    if mode == "block" and _LOCAL_ADVISORY and _is_local_model_session():
-        mode = "advisory"  # #2: unblock plain local-model sessions
+    if mode == "block" and _is_local_model_session():
+        # #3a: route-through-deliver keeps the block (route:deliver -> autoroute
+        # drives the verified deliver loop); advisory unblocks direct writes.
+        if _local_mode() == "advisory":
+            mode = "advisory"
     if mode == "block":
         # R1: emit a machine-actionable routing signal so a capable harness can
         # auto-route the blocked change INTO `uap deliver` instead of leaving the

package/tools/agents/scripts/anthropic_proxy.py

@@ -3351,7 +3351,28 @@ def anthropic_to_openai_response(anthropic_resp: dict) -> dict:
     }
 
 
+# A3: the anthropic->openai tool conversion + schema sanitize walks every tool's
+# (often deeply nested) JSON schema. The tool set is IDENTICAL across every turn
+# of a session, so this recomputed the same result each turn (observed: ~1
+# SCHEMA SANITIZE log per turn). Cache by a stable hash of the tool definitions.
+# Downstream only READS the converted dicts and FILTERS the list (narrowing), so
+# returning the cached object directly is safe.
+_TOOL_CONVERT_CACHE: "OrderedDict[str, list]" = OrderedDict()
+_TOOL_CONVERT_CACHE_MAX = 32
+
+
 def _convert_anthropic_tools_to_openai(anthropic_tools: list[dict]) -> list[dict]:
+    cache_key = None
+    try:
+        cache_key = hashlib.sha1(
+            json.dumps(anthropic_tools, sort_keys=True, default=str).encode("utf-8")
+        ).hexdigest()
+    except Exception:
+        cache_key = None
+    if cache_key is not None and cache_key in _TOOL_CONVERT_CACHE:
+        _TOOL_CONVERT_CACHE.move_to_end(cache_key)
+        return _TOOL_CONVERT_CACHE[cache_key]
+
     converted = []
     removed_pattern_fields = 0
     for tool in anthropic_tools:
@@ -3375,6 +3396,10 @@ def _convert_anthropic_tools_to_openai(anthropic_tools: list[dict]) -> list[dict
             removed_pattern_fields,
             len(anthropic_tools),
         )
+    if cache_key is not None:
+        _TOOL_CONVERT_CACHE[cache_key] = converted
+        if len(_TOOL_CONVERT_CACHE) > _TOOL_CONVERT_CACHE_MAX:
+            _TOOL_CONVERT_CACHE.popitem(last=False)
     return converted
 
 

package/tools/agents/tests/test_delivery_enforcement_worktree.py

@@ -103,3 +103,32 @@ class LocalAdvisoryTest(unittest.TestCase):
     def test_cloud_session_still_blocks(self):
         rc, out = self._run({"ANTHROPIC_BASE_URL":"https://api.anthropic.com"})
         self.assertEqual(rc, 2)
+
+
+class LocalModeTest(unittest.TestCase):
+    def _run(self, env):
+        with _tf.TemporaryDirectory() as td:
+            root = _Path(td); (root/".git").mkdir()
+            f = root/"src"/"a.ts"; f.parent.mkdir(parents=True); f.write_text("x")
+            e = dict(_os.environ); e["UAP_REPO_ROOT"]=str(root)
+            for k in ("ANTHROPIC_BASE_URL","UAP_DELIVER_LOCAL_ADVISORY","UAP_DELIVER_LOCAL_MODE","UAP_DELIVER_ACTIVE"): e.pop(k, None)
+            e.update(env)
+            p = _sp.run([_sys.executable, str(_ENF), "--operation","Write","--args",_json.dumps({"file_path":str(f)})], capture_output=True, text=True, env=e)
+            return p.returncode, _json.loads(p.stdout) if p.stdout.strip() else {}
+
+    def test_local_mode_deliver_routes_through_deliver(self):
+        rc, out = self._run({"ANTHROPIC_BASE_URL":"http://127.0.0.1:4000","UAP_DELIVER_LOCAL_MODE":"deliver"})
+        self.assertEqual(rc, 2)
+        self.assertEqual(out.get("route"), "deliver")
+
+    def test_local_mode_advisory_allows(self):
+        rc, out = self._run({"ANTHROPIC_BASE_URL":"http://127.0.0.1:4000","UAP_DELIVER_LOCAL_MODE":"advisory"})
+        self.assertEqual(rc, 0); self.assertTrue(out["allowed"])
+
+    def test_local_mode_block_strict(self):
+        rc, out = self._run({"ANTHROPIC_BASE_URL":"http://127.0.0.1:4000","UAP_DELIVER_LOCAL_MODE":"block"})
+        self.assertEqual(rc, 2)
+
+    def test_default_is_advisory(self):
+        rc, out = self._run({"ANTHROPIC_BASE_URL":"http://127.0.0.1:4000"})
+        self.assertEqual(rc, 0)

package/tools/agents/tests/test_tool_convert_cache.py

@@ -0,0 +1,49 @@
+"""Tests for A3: per-session tool-conversion cache."""
+import importlib.util
+import unittest
+from pathlib import Path
+
+proxy_path = Path(__file__).resolve().parents[3] / "tools" / "agents" / "scripts" / "anthropic_proxy.py"
+spec = importlib.util.spec_from_file_location("anthropic_proxy", proxy_path)
+ap = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(ap)
+
+TOOLS = [
+    {"name": "Read", "description": "read", "input_schema": {"type": "object",
+        "properties": {"p": {"type": "string", "pattern": "^/.*"}}, "required": ["p"]}},
+    {"name": "Bash", "description": "run", "input_schema": {"type": "object",
+        "properties": {"cmd": {"type": "string"}}}},
+]
+
+
+class ToolConvertCacheTest(unittest.TestCase):
+    def setUp(self):
+        ap._TOOL_CONVERT_CACHE.clear()
+
+    def test_correct_conversion_and_sanitize(self):
+        out = ap._convert_anthropic_tools_to_openai(TOOLS)
+        self.assertEqual(out[0]["function"]["name"], "Read")
+        # regex pattern field stripped by sanitize
+        self.assertNotIn("pattern", out[0]["function"]["parameters"]["properties"]["p"])
+
+    def test_second_call_is_cache_hit_same_object(self):
+        a = ap._convert_anthropic_tools_to_openai(TOOLS)
+        self.assertEqual(len(ap._TOOL_CONVERT_CACHE), 1)
+        b = ap._convert_anthropic_tools_to_openai([dict(t) for t in TOOLS])  # equal-by-value
+        self.assertIs(a, b, "identical tool set must return the cached object")
+
+    def test_different_tools_miss(self):
+        ap._convert_anthropic_tools_to_openai(TOOLS)
+        ap._convert_anthropic_tools_to_openai(TOOLS[:1])
+        self.assertEqual(len(ap._TOOL_CONVERT_CACHE), 2)
+
+    def test_cache_bounded(self):
+        for i in range(ap._TOOL_CONVERT_CACHE_MAX + 5):
+            ap._convert_anthropic_tools_to_openai(
+                [{"name": f"T{i}", "description": "", "input_schema": {"type": "object"}}]
+            )
+        self.assertLessEqual(len(ap._TOOL_CONVERT_CACHE), ap._TOOL_CONVERT_CACHE_MAX)
+
+
+if __name__ == "__main__":
+    unittest.main()