@miller-tech/uap 1.76.1 → 1.76.3

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -6339,6 +6339,22 @@ def _looks_malformed_tool_payload(text: str) -> bool:
         if not text.strip():
             return False
 
+    # 2026-06-27: Also strip a trailing UNCLOSED <think> (opener present, no
+    # matching </think>). Under `--reasoning auto` the model frequently runs out
+    # of its token budget mid-reasoning, emitting
+    #   "<think> ...let me write files via multiple sandbox calls... args="
+    # with no </think>. That is TRUNCATED reasoning, not a malformed tool call —
+    # but the balanced-only strip above left it intact, so the meta-tool talk
+    # inside it tripped the structural-marker / apology branches below
+    # (false-positive malformed_payload that stalled agentic builds, e.g. the
+    # Octopus Invaders generation: ~11 false rejections in 40 min). Drop from the
+    # first opener to end; KEEP any text before it so a genuine malformed payload
+    # preceding the reasoning is still detected.
+    if "<think>" in text and "</think>" not in text:
+        text = text[: text.index("<think>")]
+        if not text.strip():
+            return False
+
     # 2026-05-12: Strip orphan </parameter> and </function> closers that
     # have no matching opener. Qwen3.6 leaks these training residuals
     # after its visible answer when forced into tool_choice='required'

package/tools/agents/scripts/tool_call_wrapper.py

@@ -561,14 +561,17 @@ class ToolCallClient:
                     **kwargs,
                 }
 
+                # Non-OpenAI sampling/server params (top_k, min_p, grammar,
+                # chat_template_kwargs) MUST be passed via extra_body — the OpenAI
+                # SDK rejects them as direct kwargs ("unexpected keyword argument
+                # 'top_k'"), which previously made every tool-call test fail before
+                # reaching the model. Collect them into one extra_body dict.
+                extra_body: dict = {}
+
                 # Strategy 5: Thinking mode suppression (model-specific)
                 if request_config.get("suppress_thinking"):
-                    request_params["extra_body"] = {
-                        "chat_template_kwargs": {
-                            "enable_thinking": request_config.get(
-                                "enable_thinking", False
-                            )
-                        }
+                    extra_body["chat_template_kwargs"] = {
+                        "enable_thinking": request_config.get("enable_thinking", False)
                     }
                     # Version check: llama.cpp >= 3761 supports chat_template_kwargs
                     # Older versions will ignore unknown extra_body keys
@@ -582,14 +585,19 @@ class ToolCallClient:
                     f"parallel={request_config.get('parallel_tool_calls', True)}"
                 )
 
+                # `stop` is a standard OpenAI param -> top-level kwarg.
                 if request_config.get("stop_sequences"):
                     request_params["stop"] = request_config["stop_sequences"]
+                # llama.cpp sampling params -> extra_body (forwarded by the SDK).
                 if request_config.get("top_k") is not None:
-                    request_params["top_k"] = request_config["top_k"]
+                    extra_body["top_k"] = request_config["top_k"]
                 if request_config.get("min_p") is not None:
-                    request_params["min_p"] = request_config["min_p"]
+                    extra_body["min_p"] = request_config["min_p"]
                 if grammar_text and tools:
-                    request_params["grammar"] = grammar_text
+                    extra_body["grammar"] = grammar_text
+
+                if extra_body:
+                    request_params["extra_body"] = extra_body
 
                 # Make API call
                 response = self._client.chat.completions.create(**request_params)

package/tools/agents/tests/test_malformed_unclosed_think.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""An UNCLOSED <think> block must NOT be classified as a malformed tool payload.
+
+Under llama-server `--reasoning auto`, Qwen3.6 emits <think> reasoning. When it
+runs out of its token budget mid-thought it produces an *unclosed* block, e.g.
+
+    "<think> The sandbox works. Now write the remaining files via multiple
+     sandbox calls... args="
+
+with no </think>. That is TRUNCATED reasoning, not a malformed tool call — but
+the prior detector only stripped *balanced* <think>...</think>, so the meta-tool
+talk inside the unclosed block tripped the structural-marker branch and the proxy
+rejected/retried the turn (observed: ~11 false rejections in 40 min stalling the
+Octopus Invaders agentic build). `_looks_malformed_tool_payload` now also strips a
+trailing unclosed <think> (keeping any text BEFORE the opener so a genuine
+malformed payload preceding the reasoning is still caught).
+"""
+
+import importlib.util
+import unittest
+from pathlib import Path
+
+
+def _load_proxy_module():
+    proxy_path = Path(__file__).resolve().parents[1] / "scripts" / "anthropic_proxy.py"
+    spec = importlib.util.spec_from_file_location("anthropic_proxy", proxy_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+proxy = _load_proxy_module()
+_malformed = proxy._looks_malformed_tool_payload
+
+
+class TestUnclosedThinkNotMalformed(unittest.TestCase):
+    def test_unclosed_think_with_meta_tool_talk_is_not_malformed(self):
+        # The exact failure shape that stalled the Octopus build.
+        text = (
+            "<think> The sandbox approach works. Now I need to write all the "
+            "remaining files. Let me write them efficiently using multiple "
+            "sandbox calls in parallel. I'll write the files in dependency "
+            "order: 1. config.js (done) 2. args="
+        )
+        self.assertFalse(_malformed(text))
+
+    def test_unclosed_think_with_function_words_is_not_malformed(self):
+        # meta-tool talk that mentions <function= / <parameter inside reasoning
+        text = "<think> I should call <function=Write> with <parameter=path>..."
+        self.assertFalse(_malformed(text))
+
+    def test_balanced_think_still_not_malformed(self):
+        text = "<think> planning... </think>"
+        self.assertFalse(_malformed(text))
+
+    def test_genuine_malformed_payload_without_think_still_detected(self):
+        # No <think> at all — a real leaked tool-call fragment must still trip.
+        self.assertTrue(_malformed("<function=Write><parameter=path>x</parameter>"))
+
+    def test_malformed_payload_BEFORE_unclosed_think_still_detected(self):
+        # Keep text before the opener: a real malformed payload preceding the
+        # reasoning must still be caught.
+        text = "<function=Write><parameter=p>v</parameter> <think> now reasoning..."
+        self.assertTrue(_malformed(text))
+
+    def test_clean_prose_with_no_tool_markup_is_not_malformed(self):
+        self.assertFalse(_malformed("Here is the summary of what I did."))
+
+
+if __name__ == "__main__":
+    unittest.main()