@miller-tech/uap 1.210.3 → 1.210.4

package/package.json

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

package/tools/agents/scripts/anthropic_proxy.py

@@ -54,8 +54,10 @@ Configuration (Environment Variables)
     PROXY_MAX_CONNECTIONS   Max concurrent connections to upstream
                             Default: 20
 
-    PROXY_CONTEXT_WINDOW   Override context window size (auto-detected from
-                           upstream /slots endpoint if not set)
+    PROXY_CONTEXT_WINDOW   Startup FALLBACK for the context window, used only
+                           when the upstream /slots probe fails. The detected
+                           rail wins (re-checked every 60s) and is what
+                           /v1/models advertises. Not a cap.
                            Default: 0 (auto-detect)
 
     PROXY_CONTEXT_PRUNE_THRESHOLD   Fraction of context window at which
@@ -2407,6 +2409,11 @@ class SessionMonitor:
 
 session_monitors: dict[str, SessionMonitor] = {}
 default_context_window = 0
+# True only when `default_context_window` came from the SERVER (a /slots read)
+# or from an explicit operator setting — never when it is the hardcoded
+# fallback. /v1/models publishes the window to clients as fact, and a guess
+# published as fact is the failure `_model_entry` exists to prevent.
+_context_window_measured: bool = False
 last_session_id = ""
 _last_ctx_recheck_ts: float = 0.0
 _CTX_RECHECK_INTERVAL: float = 60.0  # Re-detect context window every 60s
@@ -2476,13 +2483,41 @@ def _cleanup_stale_monitors(now_ts: float) -> None:
         session_monitors.pop(sid, None)
 
 
+def _effective_context_window() -> int:
+    """The window this proxy actually ENFORCES, in tokens (0 = unknown).
+
+    The detected value wins over the env pin because the pin goes stale: the
+    upstream server can restart with a different --ctx-size, and
+    `_maybe_recheck_context_window` tracks that. `PROXY_CONTEXT_WINDOW` is the
+    fallback for when detection has not run or could not reach the server.
+
+    This is the idiom already used at the count_tokens compaction-forcing call
+    sites; it exists as a function so the process-wide consumers — the forcing
+    scale and the /v1/models advertisement — resolve the window from ONE
+    source. They did not: /v1/models stamped the raw env value while everything
+    else used the detected rail. Live on 2026-08-16 that meant the endpoint
+    advertised 65,536 while the proxy enforced 199,680, and the two errors
+    compounded. A client sizing itself to 65,536 while receiving counts
+    inflated 1.73x for compaction forcing compacts at ~35k REAL tokens — 18%
+    of the rail it was given.
+
+    NOT every window in the process: a request carrying a model profile
+    overrides `monitor.context_window` (see `messages`), and the pruner reads
+    that per-session value. This function is the process default, not a claim
+    about every session.
+    """
+    if default_context_window > 0:
+        return default_context_window
+    return max(PROXY_CONTEXT_WINDOW, 0)
+
+
 async def _maybe_recheck_context_window() -> None:
     """Periodically re-query the upstream server's context window.
 
     Handles server restarts with different --ctx-size mid-session.
     Non-blocking: skips if the check interval hasn't elapsed.
     """
-    global default_context_window, _last_ctx_recheck_ts
+    global default_context_window, _last_ctx_recheck_ts, _context_window_measured
     now = time.time()
     if now - _last_ctx_recheck_ts < _CTX_RECHECK_INTERVAL:
         return
@@ -2496,6 +2531,8 @@ async def _maybe_recheck_context_window() -> None:
             slots = resp.json()
             if slots and isinstance(slots, list):
                 n_ctx = slots[0].get("n_ctx", 0)
+                if n_ctx > 0:
+                    _context_window_measured = True
                 if n_ctx > 0 and n_ctx != default_context_window:
                     old = default_context_window
                     default_context_window = n_ctx
@@ -2533,10 +2570,17 @@ async def detect_context_window(client: httpx.AsyncClient) -> int:
 
     Queries the /slots endpoint (llama.cpp) to get the actual n_ctx value.
     Falls back to PROXY_CONTEXT_WINDOW env var, then to a safe default.
+
+    The probe runs FIRST, which is what this docstring always claimed but the
+    code did not do: it returned the env value without asking the server, so a
+    stale setting governed until the first /v1/messages request triggered the
+    60s recheck — and SDK clients read /v1/models before ever sending a message.
+    The env value is a hand-maintained copy of this same number (the operator
+    file that carries it says "re-derive it whenever --parallel or --ctx-size
+    moves"), so asking the server is strictly better information; the setting
+    stays as the answer for when the server cannot be reached.
     """
-    if PROXY_CONTEXT_WINDOW > 0:
-        logger.info("Using configured context window: %d tokens", PROXY_CONTEXT_WINDOW)
-        return PROXY_CONTEXT_WINDOW
+    global _context_window_measured
 
     try:
         slots_url = LLAMA_CPP_BASE.replace("/v1", "/slots")
@@ -2551,13 +2595,21 @@ async def detect_context_window(client: httpx.AsyncClient) -> int:
                         n_ctx,
                         len(slots),
                     )
+                    _context_window_measured = True
                     return n_ctx
     except Exception as exc:
         logger.warning("Failed to auto-detect context window: %s", exc)
 
-    # Safe default: 128K (common for modern models)
+    if PROXY_CONTEXT_WINDOW > 0:
+        logger.info("Using configured context window: %d tokens", PROXY_CONTEXT_WINDOW)
+        _context_window_measured = True  # an operator setting is an assertion
+        return PROXY_CONTEXT_WINDOW
+
+    # Safe default: 128K (common for modern models). NOT measured — the pruner
+    # may use it as a backstop, but it must never be published as fact.
     default = 131072
     logger.warning("Using default context window: %d tokens", default)
+    _context_window_measured = False
     return default
 
 
@@ -11485,7 +11537,7 @@ async def count_tokens(request: Request):
                 "fires at ~%d real tokens, before the pruner",
                 scale,
                 PROXY_CLIENT_ASSUMED_WINDOW,
-                default_context_window if default_context_window > 0 else PROXY_CONTEXT_WINDOW,
+                _effective_context_window(),
                 int(PROXY_CLIENT_ASSUMED_WINDOW * 0.925 / scale),
             )
         return {"input_tokens": scaled}
@@ -11510,7 +11562,7 @@ def _count_tokens_scale() -> float:
             return max(1.0, float(raw))
         except ValueError:
             return 1.0
-    window = default_context_window if default_context_window > 0 else PROXY_CONTEXT_WINDOW
+    window = _effective_context_window()
     if window <= 0:
         return 1.0
     frac = (
@@ -12845,9 +12897,10 @@ def _model_entry(model_id: str) -> dict:
     nothing and leave the client on its own defaults.
     """
     entry = {"id": model_id, "object": "model"}
-    if PROXY_CONTEXT_WINDOW > 0 and not _should_passthrough_model(model_id):
+    window = _effective_context_window() if _context_window_measured else 0
+    if window > 0 and not _should_passthrough_model(model_id):
         for key in _CONTEXT_WINDOW_KEYS:
-            entry[key] = PROXY_CONTEXT_WINDOW
+            entry[key] = window
     return entry
 
 
@@ -12867,6 +12920,12 @@ async def models():
     ANTHROPIC_PASSTHROUGH_MODELS=__local_only__ is set, all IDs (including
     the Claude ones below) are served by the local llama.cpp backend.
     """
+    # Refresh the rail before answering. This endpoint is the FIRST thing SDK
+    # clients call (it is in _PROXY_AUTH_OPEN_PATHS precisely so discovery
+    # works), and clients cache the model list — so answering from a window
+    # that only refreshes on /v1/messages means the number a client keeps for
+    # the whole session is the one from before any traffic existed.
+    await _maybe_recheck_context_window()
     return {"data": [_model_entry(mid) for mid in ADVERTISED_MODEL_IDS]}
 
 

package/tools/agents/tests/test_models_context_window.py

@@ -11,6 +11,7 @@ window at all.
 
 A client that cannot discover the window cannot size its history to it.
 """
+import asyncio
 import importlib.util
 import os
 import unittest
@@ -19,9 +20,18 @@ from pathlib import Path
 proxy_path = Path(__file__).resolve().parents[3] / "tools" / "agents" / "scripts" / "anthropic_proxy.py"
 
 
-def load_proxy(window="130048", passthrough=None):
-    """Import a fresh proxy module under the given env (constants bind at import)."""
+def load_proxy(window="130048", passthrough=None, measured=True):
+    """Import a fresh proxy module under the given env (constants bind at import).
+
+    `measured` mirrors what a real startup leaves behind: True once /slots (or
+    an explicit setting) supplied the window, False when it is the hardcoded
+    guess. /v1/models only publishes a measured window.
+    """
     os.environ["PROXY_CONTEXT_WINDOW"] = window
+    # Pin the forcing scale: `auto` is the default, but a developer shell or a
+    # systemd unit exporting a fixed value would silently change what
+    # _count_tokens_scale returns and fail these tests for unrelated reasons.
+    os.environ["PROXY_COUNT_TOKENS_SCALE"] = "auto"
     if passthrough is None:
         os.environ.pop("ANTHROPIC_PASSTHROUGH_MODELS", None)
     else:
@@ -29,6 +39,7 @@ def load_proxy(window="130048", passthrough=None):
     spec = importlib.util.spec_from_file_location("anthropic_proxy_ctx", proxy_path)
     mod = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(mod)
+    mod._context_window_measured = measured
     return mod
 
 
@@ -36,6 +47,7 @@ class ModelsAdvertiseContextWindowTest(unittest.TestCase):
     def tearDown(self):
         os.environ.pop("PROXY_CONTEXT_WINDOW", None)
         os.environ.pop("ANTHROPIC_PASSTHROUGH_MODELS", None)
+        os.environ.pop("PROXY_COUNT_TOKENS_SCALE", None)
 
     def test_local_model_carries_the_window(self):
         ap = load_proxy()
@@ -57,21 +69,77 @@ class ModelsAdvertiseContextWindowTest(unittest.TestCase):
         # Stamping the local llama.cpp figure on it would make clients truncate
         # needlessly — worse than the bug being fixed.
         ap = load_proxy(passthrough=None)  # default patterns: Claude passes through
+        ap.default_context_window = 199680  # exercise the DETECTED arm, not the fallback
         for mid in ("claude-sonnet-4-6", "claude-haiku-4-5-20251001"):
             self.assertNotIn("context_length", ap._model_entry(mid), mid)
 
     def test_local_only_sentinel_means_every_id_is_local(self):
         ap = load_proxy(passthrough="__local_only__")
+        ap.default_context_window = 199680
         for mid in ap.ADVERTISED_MODEL_IDS:
-            self.assertEqual(ap._model_entry(mid).get("context_length"), 130048, mid)
+            self.assertEqual(ap._model_entry(mid).get("context_length"), 199680, mid)
 
-    def test_unset_window_advertises_nothing(self):
-        # Better to say nothing than to assert a wrong number.
-        ap = load_proxy(window="0")
+    def test_unknown_window_advertises_nothing(self):
+        # Better to say nothing than to assert a wrong number. "Unknown" means
+        # BOTH: no setting and no detected rail.
+        ap = load_proxy(window="0", measured=False)
+        ap.default_context_window = 0
         self.assertEqual(
             ap._model_entry("qwen36-35b-a3b-iq4xs"), {"id": "qwen36-35b-a3b-iq4xs", "object": "model"}
         )
 
+    def test_a_guessed_window_is_never_published_as_fact(self):
+        # detect_context_window falls back to a hardcoded 131072 when the
+        # upstream is unreachable. The pruner may use that as a backstop, but
+        # advertising it would state a number nobody measured — the very
+        # failure this endpoint exists to prevent. Boot with llama down.
+        ap = load_proxy(window="0", measured=False)
+        ap.default_context_window = 131072
+        self.assertEqual(
+            ap._model_entry("qwen36-35b-a3b-iq4xs"), {"id": "qwen36-35b-a3b-iq4xs", "object": "model"}
+        )
+
+    def test_advertises_the_detected_rail_when_no_pin_is_set(self):
+        # Detection (from /slots) is the normal case: PROXY_CONTEXT_WINDOW=0 is
+        # what tells the launcher to auto-detect. Advertising nothing there left
+        # exactly the clients this endpoint exists for — the ones that size
+        # themselves from it — back on their own defaults.
+        ap = load_proxy(window="0")
+        ap.default_context_window = 199680
+        self.assertEqual(ap._model_entry("qwen36-35b-a3b-iq4xs")["context_length"], 199680)
+
+    def test_detected_rail_wins_over_a_stale_pin(self):
+        # THE BUG (live, 2026-08-16): the pin said 65,536 while the proxy
+        # enforced the detected 199,680. Clients were told the small number and
+        # compacted against it; the pruner guarded the large one. Whatever the
+        # number is, the advertised and enforced windows must be the same one.
+        ap = load_proxy(window="65536")
+        ap.default_context_window = 199680
+        self.assertEqual(ap._model_entry("qwen36-35b-a3b-iq4xs")["context_length"], 199680)
+        self.assertEqual(ap._effective_context_window(), 199680)
+
+    def test_pin_is_the_fallback_until_detection_lands(self):
+        # At startup, before the first /slots probe, the pin is all there is.
+        ap = load_proxy(window="65536")
+        ap.default_context_window = 0
+        self.assertEqual(ap._model_entry("qwen36-35b-a3b-iq4xs")["context_length"], 65536)
+        self.assertEqual(ap._effective_context_window(), 65536)
+
+    def test_advertised_window_equals_the_forcing_scale_denominator(self):
+        # The compaction-forcing scale and the advertisement are two halves of
+        # one contract: the client is told a window AND handed counts scaled to
+        # make it compact inside that window. Derived from different numbers,
+        # they fight — the 65,536/199,680 split had clients compacting at ~18%
+        # of the rail.
+        ap = load_proxy(window="65536")
+        ap.default_context_window = 199680
+        advertised = ap._model_entry("qwen36-35b-a3b-iq4xs")["context_length"]
+        frac = ap.PROXY_COMPACT_TARGET_FRACTION
+        if not (0 < frac < 1):
+            frac = min(0.9, ap.PROXY_CONTEXT_PRUNE_THRESHOLD * 0.95)
+        expected = ap.PROXY_CLIENT_ASSUMED_WINDOW / (advertised * frac)
+        self.assertAlmostEqual(ap._count_tokens_scale(), max(1.0, expected), places=6)
+
     def test_entry_always_keeps_the_openai_shape(self):
         ap = load_proxy()
         for mid in ap.ADVERTISED_MODEL_IDS:
@@ -80,5 +148,54 @@ class ModelsAdvertiseContextWindowTest(unittest.TestCase):
             self.assertEqual(e["object"], "model")
 
 
+class DetectContextWindowTest(unittest.TestCase):
+    """Startup resolution: ask the server first, settings are the fallback."""
+
+    def tearDown(self):
+        os.environ.pop("PROXY_CONTEXT_WINDOW", None)
+        os.environ.pop("PROXY_COUNT_TOKENS_SCALE", None)
+
+    @staticmethod
+    def _client(n_ctx=None, fail=False):
+        class _Resp:
+            status_code = 200
+
+            def json(self):
+                return [{"n_ctx": n_ctx}, {"n_ctx": n_ctx}]
+
+        class _Client:
+            async def get(self, url, timeout=None):
+                if fail:
+                    raise RuntimeError("connection refused")
+                return _Resp()
+
+        return _Client()
+
+    def test_probes_the_server_even_when_a_fallback_is_configured(self):
+        # Previously the configured value short-circuited the probe, so a stale
+        # setting governed /v1/models until the first /v1/messages — and SDK
+        # clients read /v1/models before sending anything.
+        ap = load_proxy(window="65536", measured=False)
+        w = asyncio.run(ap.detect_context_window(self._client(n_ctx=199680)))
+        self.assertEqual(w, 199680)
+        self.assertTrue(ap._context_window_measured)
+
+    def test_falls_back_to_the_configured_value_when_the_probe_fails(self):
+        ap = load_proxy(window="65536", measured=False)
+        w = asyncio.run(ap.detect_context_window(self._client(fail=True)))
+        self.assertEqual(w, 65536)
+        # An operator setting is an assertion, so it may be published.
+        self.assertTrue(ap._context_window_measured)
+
+    def test_last_resort_guess_is_marked_unmeasured(self):
+        ap = load_proxy(window="0", measured=True)
+        w = asyncio.run(ap.detect_context_window(self._client(fail=True)))
+        self.assertEqual(w, 131072)
+        self.assertFalse(ap._context_window_measured)
+        self.assertEqual(
+            ap._model_entry("qwen36-35b-a3b-iq4xs"), {"id": "qwen36-35b-a3b-iq4xs", "object": "model"}
+        )
+
+
 if __name__ == "__main__":
     unittest.main()