@miller-tech/uap 1.15.0 → 1.15.2

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -162,7 +162,7 @@ PROXY_MALFORMED_TOOL_GUARDRAIL = os.environ.get(
     "no",
 }
 PROXY_MALFORMED_TOOL_RETRY_MAX = int(
-    os.environ.get("PROXY_MALFORMED_TOOL_RETRY_MAX", "1")
+    os.environ.get("PROXY_MALFORMED_TOOL_RETRY_MAX", "2")
 )
 PROXY_MALFORMED_TOOL_RETRY_MAX_TOKENS = int(
     os.environ.get("PROXY_MALFORMED_TOOL_RETRY_MAX_TOKENS", "2048")
@@ -898,6 +898,28 @@ def _extract_text(content) -> str:
     return str(content)
 
 
+_TOOL_CALL_APOLOGY_MARKERS = (
+    "i could not produce a valid tool-call format in this turn",
+    "i will issue exactly one valid tool call next",
+)
+
+_TOOL_CALL_RETRY_MESSAGE = (
+    "Tool-call formatting failed after automatic retries. "
+    "Please retry the same request."
+)
+
+
+def _contains_tool_call_apology(text: str) -> bool:
+    if not text:
+        return False
+    lowered = text.lower()
+    return any(marker in lowered for marker in _TOOL_CALL_APOLOGY_MARKERS)
+
+
+def _sanitize_tool_call_apology_text(text: str) -> str:
+    return _TOOL_CALL_RETRY_MESSAGE if _contains_tool_call_apology(text) else text
+
+
 def _has_tool_definitions(anthropic_body: dict) -> bool:
     tools = anthropic_body.get("tools")
     return isinstance(tools, list) and len(tools) > 0
@@ -1647,6 +1669,9 @@ def _looks_malformed_tool_payload(text: str) -> bool:
         return False
 
     lowered = text.lower()
+    if _contains_tool_call_apology(text):
+        return True
+
     primary_markers = ("</parameter", "<parameter", "<tool_call", "<function=")
     if any(marker in lowered for marker in primary_markers):
         return True
@@ -1705,6 +1730,18 @@ def _build_malformed_retry_body(openai_body: dict, anthropic_body: dict) -> dict
     retry_body["tool_choice"] = "required"
     retry_body["temperature"] = PROXY_MALFORMED_TOOL_RETRY_TEMPERATURE
 
+    malformed_retry_instruction = {
+        "role": "user",
+        "content": (
+            "Your previous response had invalid tool-call formatting. "
+            "Respond with exactly one valid tool call using the provided tools. "
+            "Do not output prose, markdown, XML tags, or schema snippets."
+        ),
+    }
+    existing_messages = retry_body.get("messages")
+    if isinstance(existing_messages, list) and existing_messages:
+        retry_body["messages"] = [*existing_messages, malformed_retry_instruction]
+
     if PROXY_MALFORMED_TOOL_RETRY_MAX_TOKENS > 0:
         current_max = int(
             retry_body.get("max_tokens", PROXY_MALFORMED_TOOL_RETRY_MAX_TOKENS)
@@ -1737,10 +1774,7 @@ def _build_clean_guardrail_openai_response(openai_resp: dict) -> dict:
                 "finish_reason": "stop",
                 "message": {
                     "role": "assistant",
-                    "content": (
-                        "I could not produce a valid tool-call format in this turn. "
-                        "Please continue; I will issue exactly one valid tool call next."
-                    ),
+                    "content": _TOOL_CALL_RETRY_MESSAGE,
                 },
             }
         ],
@@ -1940,7 +1974,17 @@ def openai_to_anthropic_response(openai_resp: dict, model: str) -> dict:
 
     content = []
     if message.get("content"):
-        content.append({"type": "text", "text": message["content"]})
+        raw_text = (
+            message["content"]
+            if isinstance(message["content"], str)
+            else str(message["content"])
+        )
+        sanitized_text = _sanitize_tool_call_apology_text(raw_text)
+        if sanitized_text != raw_text:
+            logger.warning(
+                "SANITIZE: replaced known malformed tool-call apology text in assistant response"
+            )
+        content.append({"type": "text", "text": sanitized_text})
 
     # Convert tool calls
     for tc in message.get("tool_calls", []):

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -164,6 +164,35 @@ class TestMalformedToolGuardrail(unittest.TestCase):
         }
         self.assertTrue(proxy._is_malformed_tool_response(openai_resp, anthropic_body))
 
+    def test_detects_tool_call_apology_text_as_malformed(self):
+        openai_resp = {
+            "choices": [
+                {
+                    "finish_reason": "stop",
+                    "message": {
+                        "content": (
+                            "I could not produce a valid tool-call format in this turn. "
+                            "Please continue; I will issue exactly one valid tool call next."
+                        ),
+                        "tool_calls": [],
+                    },
+                }
+            ]
+        }
+        anthropic_body = {
+            "tools": [{"name": "Read", "input_schema": {"type": "object"}}],
+            "messages": [{"role": "user", "content": "fix this"}],
+        }
+        self.assertTrue(proxy._is_malformed_tool_response(openai_resp, anthropic_body))
+
+    def test_tool_call_apology_helper_detects_phrase(self):
+        apology_text = (
+            "I could not produce a valid tool-call format in this turn. "
+            "Please continue; I will issue exactly one valid tool call next."
+        )
+        self.assertTrue(proxy._contains_tool_call_apology(apology_text))
+        self.assertFalse(proxy._contains_tool_call_apology("normal assistant response"))
+
     def test_clean_tool_call_response_is_not_malformed(self):
         openai_resp = {
             "choices": [
@@ -385,6 +414,7 @@ class TestMalformedToolGuardrail(unittest.TestCase):
             openai_body = {
                 "model": "test",
                 "max_tokens": 4000,
+                "messages": [{"role": "user", "content": "fix the issue"}],
                 "tools": [{"type": "function", "function": {"name": "Read"}}],
             }
             anthropic_body = {
@@ -402,11 +432,45 @@ class TestMalformedToolGuardrail(unittest.TestCase):
             self.assertEqual(retry["max_tokens"], 512)
             self.assertEqual(len(retry["tools"]), 3)
             self.assertFalse(retry["enable_thinking"])
+            self.assertEqual(retry["messages"][-1]["role"], "user")
+            self.assertIn(
+                "invalid tool-call formatting",
+                retry["messages"][-1]["content"],
+            )
         finally:
             setattr(proxy, "PROXY_MALFORMED_TOOL_RETRY_MAX_TOKENS", old_cap)
             setattr(proxy, "PROXY_MALFORMED_TOOL_RETRY_TEMPERATURE", old_temp)
             setattr(proxy, "PROXY_DISABLE_THINKING_ON_TOOL_TURNS", old_disable)
 
+    def test_clean_guardrail_response_does_not_promise_future_tool_call(self):
+        guardrail = proxy._build_clean_guardrail_openai_response(
+            {"model": "test-model"}
+        )
+        text = guardrail["choices"][0]["message"]["content"]
+        self.assertIn("Please retry the same request", text)
+        self.assertNotIn("I will issue exactly one valid tool call next", text)
+
+    def test_openai_to_anthropic_response_sanitizes_tool_call_apology(self):
+        openai_resp = {
+            "choices": [
+                {
+                    "finish_reason": "stop",
+                    "message": {
+                        "content": (
+                            "I could not produce a valid tool-call format in this turn. "
+                            "Please continue; I will issue exactly one valid tool call next."
+                        ),
+                        "tool_calls": [],
+                    },
+                }
+            ]
+        }
+
+        converted = proxy.openai_to_anthropic_response(openai_resp, "test-model")
+        text = converted["content"][0]["text"]
+        self.assertIn("Please retry the same request", text)
+        self.assertNotIn("I will issue exactly one valid tool call next", text)
+
 
 class TestToolTurnControls(unittest.TestCase):
     def test_tool_narrowing_reduces_tool_count(self):