@miller-tech/uap 1.88.0 → 1.89.0

package/package.json

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

package/tools/agents/scripts/confidence_escalation.py

@@ -42,6 +42,7 @@ class Settings:
     signal: str
     threshold: float
     fusion_n: int
+    remom_quorum: int
     auto_fusion_chars: int
     model: str
     endpoint: str
@@ -59,7 +60,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,6 +71,7 @@ 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", ""),
@@ -321,6 +323,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:
@@ -370,6 +392,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_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,56 @@ 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)
+
+
 if __name__ == "__main__":
     unittest.main()