@miller-tech/uap 1.88.0 → 1.90.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miller-tech/uap",
-  "version": "1.88.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

@@ -42,10 +42,12 @@ class Settings:
     signal: str
     threshold: float
     fusion_n: int
+    remom_quorum: int
     auto_fusion_chars: int
     model: str
     endpoint: str
     api_key: str
+    allow_self_judge: bool = False
 
     @classmethod
     def from_env(cls) -> "Settings":
@@ -59,7 +61,7 @@ class Settings:
                 return default
 
         recipe = os.environ.get("PROXY_RECIPE", "auto").lower()
-        if recipe not in {"auto", "single", "confidence", "fusion"}:
+        if recipe not in {"auto", "single", "confidence", "fusion", "ratings", "remom", "workflow"}:
             recipe = "auto"
         signal = os.environ.get("PROXY_CONFIDENCE_SIGNAL", "heuristic").lower()
         if signal not in {"heuristic", "selfverify"}:
@@ -70,15 +72,37 @@ class Settings:
             signal=signal,
             threshold=num("PROXY_CONFIDENCE_THRESHOLD", 0.5, float),
             fusion_n=max(2, min(6, num("PROXY_FUSION_N", 3, int))),
+            remom_quorum=max(1, min(6, num("PROXY_REMOM_QUORUM", 2, int))),
             auto_fusion_chars=num("PROXY_AUTO_FUSION_CHARS", 600, int),
             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:
@@ -220,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).
@@ -227,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)
@@ -235,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"
 
@@ -321,6 +346,26 @@ def parse_judge_index(text: str, n: int):
     return i if 0 <= i < n else None
 
 
+def build_synthesis_payload(anthropic_body: dict, candidate_texts: list[str], settings: Settings) -> dict:
+    q = latest_user_text(anthropic_body)
+    listing = "\n\n".join(f"[{i}]\n{t}" for i, t in enumerate(candidate_texts))
+    prompt = (
+        "Synthesize a SINGLE best answer to the REQUEST by merging the correct, "
+        "complementary parts of the candidate answers below. Resolve disagreements "
+        "and keep the required output format. Reply with ONLY the final answer."
+        "\n\nREQUEST:\n" + q + "\n\nCANDIDATES:\n" + listing
+    )
+    return {"model": settings.model, "max_tokens": anthropic_body.get("max_tokens", 4096),
+            "messages": [{"role": "user", "content": prompt}]}
+
+
+async def _fanout_candidates(primary_resp, openai_body, settings, call_primary):
+    """[primary] + up to fusion_n-1 temperature-varied breadth candidates."""
+    variants = build_fusion_variants(openai_body or {}, settings.fusion_n)
+    results = await asyncio.gather(*[call_primary(v) for v in variants], return_exceptions=True)
+    return [primary_resp] + [r for r in results if isinstance(r, dict)]
+
+
 def should_escalate(text: str, settings: Settings, has_tools: bool) -> bool:
     """Back-compat (heuristic confidence path)."""
     if not settings.enabled or not settings.backend_configured() or has_tools:
@@ -329,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:
@@ -348,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
@@ -370,6 +421,42 @@ async def apply_recipe(primary_resp, anthropic_body, openai_body, settings, has_
             if idx is not None:
                 return candidates[idx]
             return primary_resp  # fallback to best valid evidence
+
+        if recipe == "ratings":
+            # Bounded ensemble: rate each candidate independently, pick the best.
+            candidates = await _fanout_candidates(primary_resp, openai_body, settings, call_primary)
+            if len(candidates) <= 1 or not settings.backend_configured() or call_judge is None:
+                return primary_resp
+            rs = await asyncio.gather(
+                *[call_judge(build_verify_payload(anthropic_body, extract_text(c), settings))
+                  for c in candidates],
+                return_exceptions=True,
+            )
+            scored = []
+            for c, jr2 in zip(candidates, rs):
+                sc = parse_verify_score(extract_text(jr2)) if isinstance(jr2, dict) else None
+                scored.append((sc if sc is not None else text_confidence(extract_text(c)), c))
+            return max(scored, key=lambda x: x[0])[1]
+
+        if recipe == "remom":
+            # Breadth -> quorum -> synthesis into the output contract; fall back
+            # to the best valid evidence if synthesis fails (no API error).
+            candidates = await _fanout_candidates(primary_resp, openai_body, settings, call_primary)
+            valid = [c for c in candidates if extract_text(c).strip()]
+            if len(valid) >= settings.remom_quorum and settings.backend_configured() and call_judge is not None:
+                synth = await call_judge(
+                    build_synthesis_payload(anthropic_body, [extract_text(c) for c in valid], settings)
+                )
+                if isinstance(synth, dict) and extract_text(synth).strip():
+                    return synth
+            return max(valid, key=lambda c: len(extract_text(c))) if valid else primary_resp
+
+        if recipe == "workflow":
+            # Workflows (planner/patcher/verifier under a contract) are the
+            # deliver convergence loop's job — it owns the real execution +
+            # acceptance gates and repo state a stateless serving turn lacks.
+            # Pass through; the harness routes workflow tasks through uap deliver.
+            return primary_resp
     except Exception:
         return primary_resp
     return primary_resp

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

@@ -15,10 +15,10 @@ spec.loader.exec_module(ce)
 
 
 def S(enabled=True, recipe="auto", signal="heuristic", threshold=0.5, fusion_n=3,
-      auto_chars=600, model="opus", endpoint="http://x/", key="k"):
+      auto_chars=600, model="opus", endpoint="http://x/", key="k", remom_quorum=2):
     return ce.Settings(enabled=enabled, recipe=recipe, signal=signal, threshold=threshold,
-                       fusion_n=fusion_n, auto_fusion_chars=auto_chars, model=model,
-                       endpoint=endpoint, api_key=key)
+                       fusion_n=fusion_n, remom_quorum=remom_quorum, auto_fusion_chars=auto_chars,
+                       model=model, endpoint=endpoint, api_key=key)
 
 
 def resp(text):
@@ -180,5 +180,93 @@ class CrossProcessSignalTest(unittest.TestCase):  # reactor -> proxy
         self.assertEqual(r, "fusion")  # reactor signal overrides the simple self-classification
 
 
+
+class ApplyRatingsTest(unittest.TestCase):  # Ratings
+    def test_picks_highest_rated_candidate(self):
+        async def primary(v): return resp("cand-1")
+        scores = iter(["3", "9"])  # primary rated 3, fanout rated 9
+        async def judge(p): return resp(next(scores))
+        out = run(ce.apply_recipe(resp("cand-0"), body(), {"model": "q", "messages": []},
+                                  S(recipe="ratings", fusion_n=2), False, primary, judge))
+        self.assertEqual(ce.extract_text(out), "cand-1")
+
+
+class ApplyReMoMTest(unittest.TestCase):  # ReMoM
+    def test_synthesizes_when_quorum_met(self):
+        async def primary(v): return resp("evidence B")
+        async def judge(p): return resp("MERGED ANSWER")
+        out = run(ce.apply_recipe(resp("evidence A"), body(), {"model": "q", "messages": []},
+                                  S(recipe="remom", fusion_n=2), False, primary, judge))
+        self.assertEqual(ce.extract_text(out), "MERGED ANSWER")
+
+    def test_falls_back_to_best_evidence_when_synthesis_fails(self):
+        async def primary(v): return resp("a longer, more complete candidate answer")
+        async def judge(p): return None  # synthesis failed
+        out = run(ce.apply_recipe(resp("short"), body(), {"model": "q", "messages": []},
+                                  S(recipe="remom", fusion_n=2), False, primary, judge))
+        self.assertEqual(ce.extract_text(out), "a longer, more complete candidate answer")
+
+
+class WorkflowTest(unittest.TestCase):
+    def test_workflow_passes_through(self):  # Workflows = deliver's job
+        async def primary(v): return resp("x")
+        async def judge(p): return resp("y")
+        out = run(ce.apply_recipe(resp("PRIMARY"), body(), {}, S(recipe="workflow"), False, primary, judge))
+        self.assertEqual(ce.extract_text(out), "PRIMARY")
+
+
+class SettingsExtTest(unittest.TestCase):
+    def test_remom_quorum_default(self):
+        import os, tempfile
+        for k in ("PROXY_REMOM_QUORUM",): os.environ.pop(k, None)
+        self.assertEqual(ce.Settings.from_env().remom_quorum, 2)
+
+    def test_new_recipes_valid(self):
+        import os
+        for r in ("ratings", "remom", "workflow"):
+            os.environ["PROXY_RECIPE"] = r
+            try:
+                self.assertEqual(ce.Settings.from_env().recipe, r)
+            finally:
+                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()