@miller-tech/uap 1.93.1 → 1.94.0

package/package.json

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

@@ -1799,6 +1799,60 @@ def _summarize_pruned_block(dropped: list[dict]) -> str:
     return header + "\n" + "\n".join(breadcrumbs)
 
 
+def _truncate_oversized_message_content(messages: list, budget_tokens: int) -> bool:
+    """Truncate the largest message content in-place until the total fits
+    budget_tokens. Used when message-DROPPING cannot reduce below the window —
+    e.g. Claude Code's auto-compact sends a single `<transcript>` message LARGER
+    than the whole context window, so keeping even the last 2 messages overflows
+    and the pruner would otherwise thrash (prune -> still >100% -> retry).
+
+    Truncatable content = plain-string content, `text` blocks, and `tool_result`
+    blocks. Each truncated block keeps a head+tail slice (70/30) around a marker
+    so a summarization request still sees the start and end. Returns True if it
+    got the total under budget, False if nothing left worth truncating.
+    """
+    MARKER = "\n...[TRUNCATED FOR CONTEXT WINDOW]...\n"
+
+    def _texts(msg):
+        # yield (kind, block_or_None, text) for each truncatable content in msg
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            yield ("str", None, content)
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict):
+                    if block.get("type") == "text":
+                        yield ("text", block, block.get("text", "") or "")
+                    elif block.get("type") == "tool_result":
+                        yield ("tool_result", block, _extract_text(block.get("content", "")))
+
+    for _ in range(40):  # bounded: each pass truncates the single largest block
+        total = sum(estimate_message_tokens(m) for m in messages)
+        if total <= budget_tokens:
+            return True
+        biggest = None  # (len, msg, kind, block, text)
+        for msg in messages:
+            for kind, block, text in _texts(msg):
+                if biggest is None or len(text) > biggest[0]:
+                    biggest = (len(text), msg, kind, block, text)
+        if biggest is None or biggest[0] < 400:
+            return False  # nothing left worth truncating
+        _, msg, kind, block, text = biggest
+        excess_tokens = total - budget_tokens
+        cut_chars = int(excess_tokens * CHARS_PER_TOKEN) + len(MARKER) + 512
+        keep = max(400, len(text) - cut_chars)
+        head = int(keep * 0.7)
+        tail = keep - head
+        new_text = text[:head] + MARKER + (text[-tail:] if tail > 0 else "")
+        if kind == "str":
+            msg["content"] = new_text
+        elif kind == "text":
+            block["text"] = new_text
+        elif kind == "tool_result":
+            block["content"] = new_text
+    return sum(estimate_message_tokens(m) for m in messages) <= budget_tokens
+
+
 def prune_conversation(
     anthropic_body: dict,
     context_window: int,
@@ -1834,7 +1888,19 @@ def prune_conversation(
     """
     messages = anthropic_body.get("messages", [])
     if len(messages) <= 4:
-        # Too few messages to prune meaningfully
+        # Too few messages to prune by DROPPING — but a single message can still
+        # exceed the whole window (Claude Code's auto-compact sends a
+        # `<transcript>` larger than the context window). Message-dropping can't
+        # help and returning as-is wedges the request in a prune->still-over->
+        # retry loop, so truncate the oversized content in-place to fit.
+        if messages and estimate_total_tokens(anthropic_body) > context_window:
+            budget = max(1, int(context_window * target_fraction))
+            logger.warning(
+                "Few-message request (%d msgs) exceeds window %d -- truncating oversized content to fit",
+                len(messages),
+                context_window,
+            )
+            _truncate_oversized_message_content(messages, budget)
         return anthropic_body
 
     target_tokens = int(context_window * target_fraction)
@@ -1877,26 +1943,25 @@ def prune_conversation(
     )
 
     if protected_tokens >= message_budget:
-        # Even protected messages exceed budget -- truncate tool_result content
-        # in the tail to fit
+        # Even the protected (undroppable) messages exceed budget. Message-
+        # dropping can't help, so truncate the largest content in-place to fit.
+        # Covers tool_result AND oversized user/text messages (the auto-compact
+        # <transcript> larger than the whole window) — the tool_result-only
+        # version left such a message intact, so pruning never converged and the
+        # request wedged in a prune->still-over->retry loop.
         logger.warning(
-            "Protected messages (%d tokens) exceed budget (%d) -- truncating tool results",
+            "Protected messages (%d tokens) exceed budget (%d) -- truncating oversized content",
             protected_tokens,
             message_budget,
         )
-        for msg in protected_tail:
-            content = msg.get("content", [])
-            if isinstance(content, list):
-                for block in content:
-                    if isinstance(block, dict) and block.get("type") == "tool_result":
-                        result_text = _extract_text(block.get("content", ""))
-                        if len(result_text) > 2000:
-                            block["content"] = (
-                                result_text[:1000]
-                                + "\n...[TRUNCATED]...\n"
-                                + result_text[-500:]
-                            )
-        anthropic_body["messages"] = protected_head + protected_tail
+        protected = protected_head + protected_tail
+        fit = _truncate_oversized_message_content(protected, message_budget)
+        if not fit:
+            logger.warning(
+                "Post-truncation still over budget (%d msgs) -- forwarding truncated best-effort",
+                len(protected),
+            )
+        anthropic_body["messages"] = protected
         return anthropic_body
 
     remaining_budget = message_budget - protected_tokens
@@ -8671,6 +8736,30 @@ async def _passthrough_anthropic_request(
     )
 
 
+@app.post("/v1/messages/count_tokens")
+async def count_tokens(request: Request):
+    """Anthropic-compatible token counter.
+
+    Claude Code calls POST /v1/messages/count_tokens to measure a request
+    against the context window and decide when to auto-compact. Returning 404
+    (unimplemented) blinds the client to the real window, so it sent auto-compact
+    `<transcript>` requests LARGER than the window -> single-oversized-message
+    overflow wedge. We estimate with the SAME accounting the pruner uses
+    (estimate_total_tokens) so the client's view matches the proxy's window math.
+    """
+    try:
+        body = await request.json()
+    except Exception:
+        return Response(
+            content=json.dumps(
+                {"type": "error", "error": {"type": "invalid_request_error", "message": "invalid JSON body"}}
+            ),
+            status_code=400,
+            media_type="application/json",
+        )
+    return {"input_tokens": estimate_total_tokens(body)}
+
+
 @app.post("/v1/messages")
 async def messages(request: Request):
     """Handle Anthropic Messages API requests (streaming and non-streaming).

package/tools/agents/tests/test_anthropic_proxy_streaming.py

@@ -3372,9 +3372,14 @@ class TestPruningImprovements(unittest.TestCase):
                 {"role": "user", "content": "last"},
             ],
         }
-        # With keep_last=4, more middle messages should be prunable
-        result_8 = proxy.prune_conversation(dict(body), 2000, target_fraction=0.50, keep_last=8)
-        result_4 = proxy.prune_conversation(dict(body), 2000, target_fraction=0.50, keep_last=4)
+        # With keep_last=4, more middle messages should be prunable.
+        # deepcopy so the two calls are independent: prune_conversation truncates
+        # oversized message content IN PLACE (always has for tool_result; now
+        # also for text/string), so a shared shallow copy would let the first
+        # call's truncation leak into the second. Real requests never share objects.
+        import copy as _copy
+        result_8 = proxy.prune_conversation(_copy.deepcopy(body), 2000, target_fraction=0.50, keep_last=8)
+        result_4 = proxy.prune_conversation(_copy.deepcopy(body), 2000, target_fraction=0.50, keep_last=4)
         # keep_last=4 should result in fewer or equal messages
         self.assertLessEqual(
             len(result_4.get("messages", [])),

package/tools/agents/tests/test_overflow_truncate_count_tokens.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Single-oversized-message overflow wedge + count_tokens.
+
+Claude Code's auto-compact sends a single `<transcript>` message that can be
+LARGER than the whole context window. The pruner reduces context by DROPPING
+messages, so with one giant undroppable message it can't get under the window
+and thrashes (prune -> still >100% -> retry). Two fixes:
+
+1. `_truncate_oversized_message_content` truncates the largest content in-place
+   (head+tail keep) so pruning always converges — covers plain-string / `text`
+   / `tool_result` content, not just tool_result (the old gap).
+2. `POST /v1/messages/count_tokens` returns `{"input_tokens": N}` (was 404) so
+   the client can size its auto-compact to the real window in the first place.
+"""
+
+import asyncio
+import importlib.util
+import unittest
+from pathlib import Path
+
+
+def _load():
+    p = Path(__file__).resolve().parents[1] / "scripts" / "anthropic_proxy.py"
+    spec = importlib.util.spec_from_file_location("anthropic_proxy", p)
+    m = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(m)
+    return m
+
+
+proxy = _load()
+
+
+class _FakeReq:
+    def __init__(self, payload):
+        self._p = payload
+
+    async def json(self):
+        return self._p
+
+
+class _BadReq:
+    async def json(self):
+        raise ValueError("bad json")
+
+
+class TestTruncateOversized(unittest.TestCase):
+    def test_giant_string_message_truncated_to_budget(self):
+        msgs = [{"role": "user", "content": "HEAD" + ("x" * 700_000) + "TAIL"}]
+        budget = 50_000  # tokens
+        fit = proxy._truncate_oversized_message_content(msgs, budget)
+        total = sum(proxy.estimate_message_tokens(m) for m in msgs)
+        self.assertTrue(fit)
+        self.assertLessEqual(total, budget)
+        content = msgs[0]["content"]
+        self.assertIn("[TRUNCATED FOR CONTEXT WINDOW]", content)
+        self.assertTrue(content.startswith("HEAD"))   # head preserved
+        self.assertTrue(content.rstrip().endswith("TAIL"))  # tail preserved
+
+    def test_text_block_and_tool_result_truncated(self):
+        msgs = [
+            {"role": "user", "content": [{"type": "text", "text": "A" * 400_000}]},
+            {"role": "user", "content": [{"type": "tool_result", "content": "B" * 400_000}]},
+        ]
+        budget = 30_000
+        fit = proxy._truncate_oversized_message_content(msgs, budget)
+        total = sum(proxy.estimate_message_tokens(m) for m in msgs)
+        self.assertTrue(fit)
+        self.assertLessEqual(total, budget)
+
+    def test_small_messages_untouched(self):
+        msgs = [{"role": "user", "content": "hello"}]
+        before = msgs[0]["content"]
+        fit = proxy._truncate_oversized_message_content(msgs, 50_000)
+        self.assertTrue(fit)
+        self.assertEqual(msgs[0]["content"], before)  # nothing truncated
+
+    def test_prune_conversation_converges_on_transcript_over_window(self):
+        # 2-message request, one is a transcript LARGER than the whole window —
+        # message-dropping can't help; must converge via content truncation.
+        window = 100_000
+        body = {
+            "system": "You are a summarizer.",
+            "messages": [
+                {"role": "user", "content": "Summarize this transcript:"},
+                {"role": "user", "content": "<transcript>" + ("t" * 500_000) + "</transcript>"},
+            ],
+            "max_tokens": 2048,
+        }
+        out = proxy.prune_conversation(body, window, target_fraction=0.5, keep_last=8)
+        total = proxy.estimate_total_tokens(out)
+        self.assertLessEqual(total, window)  # fits — no wedge
+
+
+class TestCountTokens(unittest.TestCase):
+    def test_returns_input_tokens_matching_estimator(self):
+        payload = {
+            "model": "m",
+            "system": "sys prompt here",
+            "messages": [{"role": "user", "content": "hello world, count me"}],
+            "max_tokens": 10,
+        }
+        res = asyncio.run(proxy.count_tokens(_FakeReq(payload)))
+        self.assertEqual(res, {"input_tokens": proxy.estimate_total_tokens(payload)})
+        self.assertGreater(res["input_tokens"], 0)
+
+    def test_invalid_json_returns_400(self):
+        res = asyncio.run(proxy.count_tokens(_BadReq()))
+        self.assertEqual(res.status_code, 400)
+
+
+if __name__ == "__main__":
+    unittest.main()