@miller-tech/uap 1.20.38 → 1.20.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "1.20.38",
+  "version": "1.20.40",
   "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()
 
 
@@ -8206,14 +8231,25 @@ def _parse_anthropic_sse_to_message(raw: bytes) -> dict | None:
 
 @app.get("/v1/models")
 async def models():
-    """Return available model list (spoofs Anthropic model IDs for client compatibility)."""
+    """Return available model list.
+
+    Advertises Shannon's three canonical Claude model IDs (haiku 4.5,
+    sonnet 4.6, opus 4.7) for client compatibility — Anthropic SDKs
+    typically check /v1/models for the requested ID before sending a
+    Messages request, and failing that check produces a confusing 404 even
+    though the proxy itself would happily accept the request.
+
+    Whether requests for those Claude IDs actually round-trip to
+    api.anthropic.com depends on ANTHROPIC_PASSTHROUGH_MODELS /
+    DEFAULT_PASSTHROUGH_MODEL_PATTERNS. When the local-only sentinel
+    ANTHROPIC_PASSTHROUGH_MODELS=__local_only__ is set, all IDs (including
+    the Claude ones below) are served by the local llama.cpp backend.
+    """
     return {
         "data": [
-            {"id": "claude-opus-4-6-20260101", "object": "model"},
-            {"id": "claude-sonnet-4-6-20250514", "object": "model"},
-            {"id": "gpt-5.4", "object": "model"},
-            {"id": "gpt-5.3-codex", "object": "model"},
-            {"id": "claude-opus-4-6-20250616", "object": "model"},
+            {"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"},
         ]
     }

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -5003,3 +5003,131 @@ class TestOpenAIPassthroughConversion(unittest.TestCase):
         self.assertEqual(tc["function"]["name"], "Bash")
         # Arguments are JSON-stringified per OpenAI spec
         self.assertEqual(json.loads(tc["function"]["arguments"]), {"command": "pwd"})
+
+
+class TestModelsEndpoint(unittest.TestCase):
+    """Tests for the /v1/models discovery endpoint.
+
+    Pins the exact set of model IDs the proxy advertises so an accidental
+    list rewrite that drops a Shannon-required ID fails CI loudly. Driven
+    by Shannon-keygraph's .env defaults (ANTHROPIC_SMALL/MEDIUM/LARGE_MODEL)
+    which expect haiku-4-5, sonnet-4-6, opus-4-7 to be discoverable."""
+
+    def test_models_endpoint_returns_shannon_canonical_set(self):
+        """The advertised list must contain Shannon's canonical Claude IDs
+        plus the local model. Order is not asserted (clients shouldn't
+        depend on it), but membership is."""
+        import asyncio
+        result = asyncio.run(proxy.models())
+
+        self.assertIn("data", result)
+        ids = {entry["id"] for entry in result["data"]}
+
+        # Shannon-required Claude IDs (must include — per project policy)
+        self.assertIn("claude-haiku-4-5-20251001", ids)
+        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)
+
+    def test_models_endpoint_drops_stale_4_6_dated_variants(self):
+        """The pre-2026-05 list advertised claude-opus-4-6-20260101,
+        claude-sonnet-4-6-20250514, claude-opus-4-6-20250616 and
+        unrelated gpt-5 entries. None of those should reappear: the dated
+        4-6 variants are superseded by 4-7, and the proxy doesn't route
+        to OpenAI so the gpt-5 entries were noise."""
+        import asyncio
+        result = asyncio.run(proxy.models())
+        ids = {entry["id"] for entry in result["data"]}
+
+        self.assertNotIn("claude-opus-4-6-20260101", ids)
+        self.assertNotIn("claude-sonnet-4-6-20250514", ids)
+        self.assertNotIn("claude-opus-4-6-20250616", ids)
+        self.assertNotIn("gpt-5.4", ids)
+        self.assertNotIn("gpt-5.3-codex", ids)
+
+    def test_models_endpoint_returns_object_model_for_each_entry(self):
+        """Each entry must follow the {id, object: 'model'} shape the
+        Anthropic and OpenAI SDKs both expect."""
+        import asyncio
+        result = asyncio.run(proxy.models())
+
+        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)