@miller-tech/uap 1.20.39 → 1.20.41

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -6502,6 +6502,15 @@ def _extract_thinking_block(text: str) -> tuple[str | None, str]:
     present, returns ``(None, text)`` unchanged. Multiple thinking blocks
     are concatenated. Trailing whitespace after each block is consumed so
     the remaining text starts cleanly with the model's actual answer.
+
+    Truncated / unclosed ``<think>`` blocks (max_tokens cutting off
+    mid-thinking) are also handled: everything from the dangling
+    ``<think>`` to end-of-text is treated as partial thinking content,
+    and anything before it is preserved as the body. Without this, the
+    open tag and the model's partial reasoning would leak into the
+    Anthropic-spec ``text`` content block — a 100% Anthropic-compatibility
+    violation since real Anthropic responses never embed ``<think>`` in
+    ``text``.
     """
     if "<think>" not in text:
         return None, text
@@ -6510,8 +6519,24 @@ def _extract_thinking_block(text: str) -> tuple[str | None, str]:
         parts.append(m.group(1).strip())
         return ""
     remaining = _THINKING_BLOCK_RE.sub(collect, text)
+    # After stripping balanced pairs, check for a dangling unclosed
+    # <think>... open tag and treat it as partial thinking content.
+    # First occurrence wins; any further '<think>' substrings in the
+    # captured partial are folded into the same partial block.
+    if "<think>" in remaining:
+        idx = remaining.find("<think>")
+        partial = remaining[idx + len("<think>"):].strip()
+        if partial:
+            parts.append(partial)
+        # rstrip mirrors the balanced regex's \s* consumption after </think>:
+        # whitespace separating body from thinking is structural, not part of
+        # the body.
+        remaining = remaining[:idx].rstrip()
     if not parts:
-        return None, text
+        # Saw "<think>" in original text but no extractable content (e.g.
+        # bare "<think>" alone or "<think></think>"). Return cleaned body
+        # so the open tag does not leak.
+        return None, remaining.lstrip()
     return "\n\n".join(p for p in parts if p), remaining.lstrip()
 
 
@@ -8225,7 +8250,7 @@ async def models():
             {"id": "claude-haiku-4-5-20251001", "object": "model"},
             {"id": "claude-sonnet-4-6", "object": "model"},
             {"id": "claude-opus-4-7", "object": "model"},
-            {"id": "qwen35-a3b-iq4xs", "object": "model"},
+            {"id": "qwen36-27b-iq4xs", "object": "model"},
         ]
     }
 

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -5028,9 +5028,13 @@ class TestModelsEndpoint(unittest.TestCase):
         self.assertIn("claude-sonnet-4-6", ids)
         self.assertIn("claude-opus-4-7", ids)
 
-        # Local model (kept because requests for it actually route locally
-        # even with __local_only__ passthrough sentinel set)
-        self.assertIn("qwen35-a3b-iq4xs", ids)
+        # Local model — what llama-server actually serves. Updated
+        # 2026-05-15 from qwen35-a3b-iq4xs after the switch from 35B-A3B
+        # MoE to Qwen3.6-27B dense (see project_active_server memory).
+        # Requests for this ID route locally even with __local_only__
+        # passthrough sentinel set.
+        self.assertIn("qwen36-27b-iq4xs", ids)
+        self.assertNotIn("qwen35-a3b-iq4xs", ids)
 
     def test_models_endpoint_drops_stale_4_6_dated_variants(self):
         """The pre-2026-05 list advertised claude-opus-4-6-20260101,
@@ -5057,3 +5061,77 @@ class TestModelsEndpoint(unittest.TestCase):
         for entry in result["data"]:
             self.assertIn("id", entry)
             self.assertEqual(entry["object"], "model")
+
+
+class TestThinkingBlockExtraction(unittest.TestCase):
+    """Tests for _extract_thinking_block — guarantees Anthropic-spec text
+    content blocks never contain Qwen <think> tags, including the truncated
+    / unclosed case (max_tokens cutting off mid-thinking).
+
+    Reproduces the OK_HAIKU regression observed 2026-05-14: a request with
+    max_tokens=40 against a Qwen upstream produced an Anthropic response
+    whose text block started with `<think>\\nHere's a thinking process:...`
+    because the model never reached `</think>` before being cut off."""
+
+    def test_balanced_single_block_extracts_to_thinking(self):
+        text = "<think>let me reason</think>The answer is 42."
+        thinking, body = proxy._extract_thinking_block(text)
+        self.assertEqual(thinking, "let me reason")
+        self.assertEqual(body, "The answer is 42.")
+
+    def test_balanced_multiple_blocks_concatenate(self):
+        text = "<think>step one</think>partial<think>step two</think>final"
+        thinking, body = proxy._extract_thinking_block(text)
+        self.assertEqual(thinking, "step one\n\nstep two")
+        # Both blocks stripped; body is the residual prose joined.
+        self.assertEqual(body, "partialfinal")
+
+    def test_no_think_tag_returns_text_unchanged(self):
+        text = "Hello world."
+        thinking, body = proxy._extract_thinking_block(text)
+        self.assertIsNone(thinking)
+        self.assertEqual(body, text)
+
+    def test_unclosed_think_captures_partial_and_strips_open_tag(self):
+        """Truncation case (max_tokens cuts mid-thinking). The open
+        <think> tag and partial reasoning MUST NOT leak into the
+        Anthropic-spec text content block."""
+        text = "<think>\nHere's a thinking process:\n\n1.  Analyze user input"
+        thinking, body = proxy._extract_thinking_block(text)
+        # Partial reasoning captured as thinking content
+        self.assertIsNotNone(thinking)
+        self.assertIn("thinking process", thinking)
+        # CRITICAL: body must be empty / contain no <think> tag
+        self.assertEqual(body, "")
+        self.assertNotIn("<think>", body)
+
+    def test_pre_text_then_unclosed_think_preserves_pre_text(self):
+        text = "Pre-thinking prose. <think>partial reasoning"
+        thinking, body = proxy._extract_thinking_block(text)
+        self.assertEqual(thinking, "partial reasoning")
+        # Pre-think prose is preserved as body
+        self.assertEqual(body, "Pre-thinking prose.")
+        self.assertNotIn("<think>", body)
+
+    def test_bare_open_tag_alone_strips_cleanly(self):
+        """Edge: response is literally just '<think>' with nothing else
+        (extremely degenerate truncation). The tag must be stripped from
+        the body so it doesn't appear in the client-facing response."""
+        text = "<think>"
+        thinking, body = proxy._extract_thinking_block(text)
+        # No partial content -> no thinking block; body empty, no tag leak
+        self.assertIsNone(thinking)
+        self.assertEqual(body, "")
+        self.assertNotIn("<think>", body)
+
+    def test_balanced_then_dangling_unclosed_handles_both(self):
+        """Multi-step truncation: model emitted one complete <think>
+        block, started a second one, then was cut off."""
+        text = "<think>first thoughts</think>partial answer<think>second thought, cut off mid-way"
+        thinking, body = proxy._extract_thinking_block(text)
+        # Both balanced and unclosed contributions appear
+        self.assertIn("first thoughts", thinking)
+        self.assertIn("second thought, cut off mid-way", thinking)
+        # Body has the prose between the two blocks
+        self.assertEqual(body, "partial answer")
+        self.assertNotIn("<think>", body)