@miller-tech/uap 1.89.0 → 1.90.0

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -7979,6 +7979,28 @@ def openai_to_anthropic_response(
             }
         )
 
+    # Empty-output guard (no-tool path). Qwen-style models emit their whole
+    # response inside a <think> block even with enable_thinking=False; when the
+    # client did NOT opt into thinking (expose_thinking=False) the block is
+    # consumed and -- if the model produced nothing after </think> -- the
+    # response collapses to an empty text block. That empty body is useless to
+    # the client and silently breaks downstream consumers (notably the
+    # Fusion/Confidence judge, whose escalate call is a no-tool turn -- an empty
+    # judge reply makes apply_recipe fall back to the primary, so recipes
+    # degrade to single). When there is no text and no tool_use content but we
+    # DID capture thinking, surface the de-tagged thinking as the body rather
+    # than returning nothing.
+    _has_text = any(
+        b.get("type") == "text" and (b.get("text") or "").strip() for b in content
+    )
+    _has_tool_use = any(b.get("type") == "tool_use" for b in content)
+    if not _has_text and not _has_tool_use and thinking_chunks:
+        content.append({"type": "text", "text": "\n\n".join(thinking_chunks)})
+        logger.warning(
+            "EMPTY-OUTPUT GUARD: no-tool turn produced only <think> content; "
+            "promoted de-tagged thinking to the text body (would otherwise be empty)"
+        )
+
     stop_reason_map = {
         "stop": "end_turn",
         "length": "max_tokens",

package/tools/agents/scripts/confidence_escalation.py

@@ -47,6 +47,7 @@ class Settings:
     model: str
     endpoint: str
     api_key: str
+    allow_self_judge: bool = False
 
     @classmethod
     def from_env(cls) -> "Settings":
@@ -76,11 +77,32 @@ class Settings:
             model=os.environ.get("PROXY_ESCALATE_MODEL", ""),
             endpoint=os.environ.get("PROXY_ESCALATE_ENDPOINT", ""),
             api_key=os.environ.get("PROXY_ESCALATE_API_KEY", ""),
+            allow_self_judge=flag("PROXY_ALLOW_SELF_JUDGE"),
         )
 
     def backend_configured(self) -> bool:
         return bool(self.model and self.endpoint)
 
+    def judge_is_self(self, primary_model: str = "") -> bool:
+        """True when the configured judge model name matches the primary
+        (generator) model -- i.e. qwen judging qwen."""
+        pm = (primary_model or "").strip().lower()
+        jm = (self.model or "").strip().lower()
+        return bool(pm) and bool(jm) and pm == jm
+
+    def judge_available(self, primary_model: str = "") -> bool:
+        """A judge backend that is configured AND distinct from the primary
+        model. A same-model judge (qwen judging qwen) was MEASURED to add no
+        quality lift, so judge-dependent recipes (fusion / ratings / remom and
+        confidence-escalation) require a distinct judge by default and otherwise
+        downgrade to single. Set PROXY_ALLOW_SELF_JUDGE=1 to force self-judging.
+        When the primary model is unknown the judge is treated as distinct."""
+        if not self.backend_configured():
+            return False
+        if self.allow_self_judge:
+            return True
+        return not self.judge_is_self(primary_model)
+
 
 # ---- helpers --------------------------------------------------------------
 def latest_user_text(anthropic_body: dict) -> str:
@@ -222,6 +244,7 @@ def select_recipe(anthropic_body: dict, settings: Settings, has_tools: bool) ->
         return "single"
     if settings.recipe != "auto":
         return settings.recipe
+    pm = (anthropic_body or {}).get("model", "")
     text = latest_user_text(anthropic_body)
     # Prefer the harness reactor's ACTUAL routeResult signal when fresh; else the
     # proxy's own signal extraction (faithful port of query-complexity).
@@ -229,7 +252,7 @@ def select_recipe(anthropic_body: dict, settings: Settings, has_tools: bool) ->
     if rsig is not None:
         rec = rsig.get("recipe")
         if rec in {"single", "confidence", "fusion"}:
-            if rec == "fusion" and not settings.backend_configured():
+            if rec == "fusion" and not settings.judge_available(pm):
                 return "confidence"
             return rec
         complexity = rsig.get("complexity") or query_complexity(text)
@@ -237,9 +260,9 @@ def select_recipe(anthropic_body: dict, settings: Settings, has_tools: bool) ->
     else:
         complexity = query_complexity(text)
         shape = task_shape(text)
-    if settings.backend_configured() and (complexity == "complex" or shape == "reasoning"):
+    if settings.judge_available(pm) and (complexity == "complex" or shape == "reasoning"):
         return "fusion"
-    if settings.backend_configured() and len(text) >= settings.auto_fusion_chars:
+    if settings.judge_available(pm) and len(text) >= settings.auto_fusion_chars:
         return "fusion"
     return "confidence"
 
@@ -351,8 +374,8 @@ def should_escalate(text: str, settings: Settings, has_tools: bool) -> bool:
 
 
 # ---- orchestration (injected callables) -----------------------------------
-async def _confidence_score(text, anthropic_body, settings, call_judge):
-    if settings.signal == "selfverify" and settings.backend_configured() and call_judge is not None:
+async def _confidence_score(text, anthropic_body, settings, call_judge, primary_model=""):
+    if settings.signal == "selfverify" and settings.judge_available(primary_model) and call_judge is not None:
         jr = await call_judge(build_verify_payload(anthropic_body, text, settings))
         score = parse_verify_score(extract_text(jr)) if isinstance(jr, dict) else None
         if score is not None:
@@ -370,10 +393,16 @@ async def apply_recipe(primary_resp, anthropic_body, openai_body, settings, has_
         if recipe == "single" or not isinstance(primary_resp, dict):
             return primary_resp
         primary_text = extract_text(primary_resp)
+        primary_model = (openai_body or {}).get("model", "")
+        # Judge-dependent recipes need a configured, DISTINCT (non-self) judge.
+        # A same-model judge adds no measured lift, so downgrade to single BEFORE
+        # spending fan-out / judge calls.
+        if recipe in {"fusion", "ratings", "remom"} and not settings.judge_available(primary_model):
+            return primary_resp
 
         if recipe == "confidence":
-            conf = await _confidence_score(primary_text, anthropic_body, settings, call_judge)
-            if conf < settings.threshold and settings.backend_configured() and call_judge is not None:
+            conf = await _confidence_score(primary_text, anthropic_body, settings, call_judge, primary_model)
+            if conf < settings.threshold and settings.judge_available(primary_model) and call_judge is not None:
                 esc = await call_judge(build_escalation_payload(anthropic_body, settings))
                 if isinstance(esc, dict):
                     return esc

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -3790,6 +3790,34 @@ class TestGenerationHangRecovery(unittest.TestCase):
         asyncio.run(_run())
 
 
+class EmptyOutputGuardTest(unittest.TestCase):
+    """#1: a no-tool turn whose entire response was inside <think> must never
+    collapse to an empty body (would silently break the Fusion/Confidence judge)."""
+
+    def test_all_think_no_tool_promotes_thinking_to_body(self):
+        openai_resp = {"choices": [{"message": {"content": "<think>the answer is 42</think>"},
+                                    "finish_reason": "stop"}]}
+        out = proxy.openai_to_anthropic_response(openai_resp, "qwen", expose_thinking=False)
+        texts = [b.get("text", "") for b in out["content"] if b.get("type") == "text"]
+        self.assertTrue(any("42" in t for t in texts))             # body is non-empty
+        self.assertTrue(all(b.get("type") != "thinking" for b in out["content"]))
+
+    def test_normal_post_think_body_unaffected(self):
+        openai_resp = {"choices": [{"message": {"content": "<think>reason</think>FINAL"},
+                                    "finish_reason": "stop"}]}
+        out = proxy.openai_to_anthropic_response(openai_resp, "qwen", expose_thinking=False)
+        texts = "".join(b.get("text", "") for b in out["content"] if b.get("type") == "text")
+        self.assertEqual(texts, "FINAL")                           # guard does not fire
+
+    def test_tool_only_response_not_padded(self):
+        openai_resp = {"choices": [{"message": {"content": "<think>x</think>",
+                        "tool_calls": [{"id": "a", "function": {"name": "bash",
+                        "arguments": "{}"}}]}, "finish_reason": "tool_calls"}]}
+        out = proxy.openai_to_anthropic_response(openai_resp, "qwen", expose_thinking=False)
+        self.assertTrue(any(b.get("type") == "tool_use" for b in out["content"]))
+        self.assertFalse(any(b.get("type") == "text" for b in out["content"]))
+
+
 if __name__ == "__main__":
     unittest.main()
 

package/tools/agents/tests/test_confidence_escalation.py

@@ -231,5 +231,42 @@ class SettingsExtTest(unittest.TestCase):
                 os.environ.pop("PROXY_RECIPE", None)
 
 
+class JudgeGatingTest(unittest.TestCase):  # #2 stronger non-self judge
+    def test_judge_available_distinct_vs_self(self):
+        s = S(model="opus")  # judge=opus, primary=qwen -> distinct
+        self.assertTrue(s.judge_available("qwen"))
+        self.assertFalse(s.judge_available("opus"))          # self-judge blocked
+        self.assertFalse(S(model="qwen").judge_available("qwen"))
+        self.assertTrue(s.judge_available(""))               # unknown primary -> allow
+        self.assertFalse(S(model="", endpoint="").judge_available("qwen"))  # unconfigured
+
+    def test_allow_self_judge_override(self):
+        s = ce.Settings(enabled=True, recipe="fusion", signal="heuristic", threshold=0.5,
+                        fusion_n=2, remom_quorum=2, auto_fusion_chars=600, model="qwen",
+                        endpoint="http://x/", api_key="k", allow_self_judge=True)
+        self.assertTrue(s.judge_available("qwen"))
+
+    def test_self_judge_downgrades_fusion_without_calling_judge(self):
+        async def primary(v): raise AssertionError("fan-out must not run on self-judge")
+        async def judge(p): raise AssertionError("judge must not be called on self-judge")
+        # judge model == primary model ("qwen") -> downgrade to single
+        out = run(ce.apply_recipe(resp("c0"), body(), {"model": "qwen", "messages": []},
+                                  S(recipe="fusion", fusion_n=2, model="qwen"), False, primary, judge))
+        self.assertEqual(ce.extract_text(out), "c0")
+
+    def test_distinct_judge_still_runs_fusion(self):
+        async def primary(v): return resp("c1")
+        async def judge(p): return resp("1")
+        out = run(ce.apply_recipe(resp("c0"), body(), {"model": "qwen", "messages": []},
+                                  S(recipe="fusion", fusion_n=2, model="opus"), False, primary, judge))
+        self.assertEqual(ce.extract_text(out), "c1")
+
+    def test_select_recipe_skips_fusion_on_self_judge(self):
+        b = {"model": "qwen", "messages": [{"role": "user",
+             "content": "prove the theorem and analyze why x is even"}]}
+        self.assertEqual(ce.select_recipe(b, S(recipe="auto", model="qwen"), False), "confidence")
+        self.assertEqual(ce.select_recipe(b, S(recipe="auto", model="opus"), False), "fusion")
+
+
 if __name__ == "__main__":
     unittest.main()