coderouter-cli 2.11.2__py3-none-any.whl → 2.12.0__py3-none-any.whl

coderouter/config/schemas.py

@@ -27,6 +27,7 @@ from pydantic import (
 )
 
 from coderouter.logging import get_logger
+from coderouter.token_estimation import set_include_tool_content
 
 logger = get_logger(__name__)
 
@@ -2306,6 +2307,36 @@ class CodeRouterConfig(BaseModel):
         ),
     )
 
+    # H-5 escape hatch: token-estimation scope.
+    #
+    # Deliberately top-level rather than per-``FallbackChain``, even
+    # though ``context_budget_action`` lives on the chain. The shared
+    # char/4 estimator has four consumers and three of them run with no
+    # profile in hand: the auto-router runs *before* a profile exists
+    # (it is what picks one), ``POST /v1/messages/count_tokens`` answers
+    # a client question that must not depend on which chain would have
+    # served it, and language-tax measurement is profile-agnostic. A
+    # per-profile switch would let the router and the guard disagree
+    # about the size of the very same request — exactly the class of bug
+    # this key exists to let operators back out of.
+    token_estimation_include_tool_content: bool = Field(
+        default=True,
+        description=(
+            "v2.12 (H-5): count ``tool_result`` / ``tool_use`` / "
+            "``thinking`` content blocks in the shared char/4 token "
+            "estimator. True (default) is the correct behavior — up to "
+            "v2.11.x these blocks estimated to 0 chars, under-counting a "
+            "Claude Code style session by 5x at 20 turns and ~29x at 200. "
+            "Image blocks stay at 0 either way. Set to false as an escape "
+            "hatch to restore v2.11.x-identical estimates (and therefore "
+            "v2.11.x context-budget firing, auto-router "
+            "``content_token_count_min`` matching and "
+            "``/v1/messages/count_tokens`` numbers) if the corrected "
+            "estimate disrupts a tuned deployment. Compatibility shim "
+            "only — scheduled for removal in a future release."
+        ),
+    )
+
     # v2.0-I: Continuous probing — background health checks for idle periods.
     continuous_probe: Literal["off", "active"] = Field(
         default="off",
@@ -2816,6 +2847,25 @@ class CodeRouterConfig(BaseModel):
             )
         return self
 
+    @model_validator(mode="after")
+    def _apply_token_estimation_scope(self) -> CodeRouterConfig:
+        """Publish ``token_estimation_include_tool_content`` process-wide.
+
+        The char/4 estimator is a dependency-free leaf module that every
+        consumer imports directly as a plain function; there is no
+        object graph to thread a flag through, and three of the four
+        consumers have no profile/config handle at their call site. So
+        the loaded config pushes the setting into the module once, here.
+
+        Idempotent and deterministic: the value always reflects the most
+        recently constructed config, which in a server process is the
+        single config that was loaded at startup. Declared last so a
+        config that fails any other validator never takes effect. Tests
+        that flip it should restore the default (True) afterwards.
+        """
+        set_include_tool_content(self.token_estimation_include_tool_content)
+        return self
+
     def provider_by_name(self, name: str) -> ProviderConfig:
         """Look up a provider config by name. Raises KeyError if not found."""
         for p in self.providers:

coderouter/guards/context_budget.py

@@ -38,6 +38,11 @@ Uses the shared :func:`~coderouter.token_estimation.estimate_tokens_from_anthrop
 (char/4 heuristic, 5-deps invariant). See that module's docstring
 for the CJK caveat and recommended threshold compensation.
 
+Since H-5 the estimator also counts ``tool_result`` / ``tool_use`` /
+``thinking`` blocks, so a Claude-Code-shaped session now reports a
+number 5-29x larger than it did in v2.11.x — i.e. the guard finally
+fires on the sessions it was written for.
+
 Trim algorithm
 ==============
 
@@ -49,6 +54,16 @@ Trim algorithm
      ``tool_use`` assistant message (and vice versa).
   5. After removal, re-estimate; if still over ``trim_target``,
      reduce ``preserve_last_n`` by 1 and retry (minimum floor: 2).
+  6. The result is **never** an empty message list — see
+     :func:`_normalize_head`.
+
+Cost
+====
+
+The incremental loop pre-computes each message's character count once
+and subtracts as units are dropped, so a trim is O(total chars) rather
+than O(messages x total chars). Before that change an 800-message trim
+blocked the event loop for ~0.2s.
 """
 
 from __future__ import annotations
@@ -57,6 +72,9 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
 from coderouter.token_estimation import (
+    chars_to_tokens,
+    count_message_chars,
+    count_system_chars,
     estimate_tokens_from_anthropic_request,
 )
 
@@ -398,7 +416,37 @@ def _group_removable_units(
     return units
 
 
-def _normalize_head(messages: list[Any]) -> list[Any]:
+def _role_of(msg: Any) -> Any:
+    """Role of a message (Pydantic model or dict)."""
+    if hasattr(msg, "role"):
+        return msg.role
+    if isinstance(msg, dict):
+        return msg.get("role")
+    return None
+
+
+def _is_clean_user(msg: Any) -> bool:
+    """True for a ``user`` message that does not open with a tool_result."""
+    return _role_of(msg) == "user" and not _has_tool_result(msg)
+
+
+#: Content of the synthetic head inserted when no real clean ``user``
+#: message can be re-attached within budget. Short on purpose (~17
+#: tokens): its only job is to give Anthropic the valid opening turn the
+#: wire format demands while telling the model why history is missing.
+TRIM_PLACEHOLDER_HEAD_TEXT = "[earlier conversation trimmed to fit the context budget]"
+
+
+def _synthetic_head() -> dict[str, Any]:
+    """A minimal, always-affordable clean ``user`` message."""
+    return {"role": "user", "content": TRIM_PLACEHOLDER_HEAD_TEXT}
+
+
+def _normalize_head(
+    messages: list[Any],
+    *,
+    fallback_head: Any | None = None,
+) -> list[Any]:
     """Drop leading messages until the first is a clean ``user`` message.
 
     Anthropic requires the first message to be a ``user`` message, and a
@@ -407,18 +455,77 @@ def _normalize_head(messages: list[Any]) -> list[Any]:
     any assistant message and any user message that contains a
     tool_result, stopping at the first ``user`` message with no
     tool_result block.
+
+    **Never returns an empty list for a non-empty input.** In a
+    tool-heavy agent session the preserved tail can legitimately look
+    like ``[assistant(tool_use), user(tool_result), assistant(tool_use),
+    user(tool_result)]`` — every single message matches the drop
+    condition, and the naive loop returned ``[]``. ``AnthropicRequest``
+    declares no ``min_length`` on ``messages``, so pydantic happily
+    forwarded that and the upstream API answered 400, destroying the
+    session the guard exists to protect. (Latent before H-5 only
+    because ``tool_result`` blocks estimated to 0 chars, so trim never
+    fired on exactly those conversations.)
+
+    When no surviving message can serve as the head, ``fallback_head``
+    is prepended. The caller picks it under the token budget — see
+    :func:`_pick_fallback_head`; this function deliberately does no
+    budget arithmetic of its own.
     """
-    start = 0
-    n = len(messages)
-    while start < n:
-        msg = messages[start]
-        role = msg.role if hasattr(msg, "role") else (
-            msg.get("role") if isinstance(msg, dict) else None
-        )
-        if role == "user" and not _has_tool_result(msg):
-            break
-        start += 1
-    return messages[start:]
+    if not messages:
+        return list(messages)
+
+    for start, msg in enumerate(messages):
+        if _is_clean_user(msg):
+            return messages[start:]
+
+    # Every surviving message is an assistant turn or a tool_result-
+    # carrying user turn: normalizing by dropping would empty the list.
+    if fallback_head is not None:
+        return [fallback_head, *messages]
+    return list(messages)
+
+
+def _pick_fallback_head(
+    messages: list[Any],
+    msg_chars: list[int],
+    dropped: set[int],
+    *,
+    before: int,
+    kept_chars: int,
+    target_tokens: int,
+) -> Any:
+    """Choose a head message that keeps the result inside the budget.
+
+    Called only when nothing in the surviving window is a clean ``user``
+    message, so *something* has to be put in front or the request is a
+    guaranteed 400.
+
+    Selection order:
+
+    1. The **most recent** dropped clean ``user`` message that still
+       fits under ``target_tokens`` — recency matters because it is
+       usually the operator's latest standing instruction.
+    2. Failing that, a synthetic placeholder (:func:`_synthetic_head`).
+
+    The budget check is the whole point. Re-attaching the *newest*
+    candidate unconditionally is a trap: the most recent clean user
+    message in an agent session is very often a huge pasted file, and
+    restoring it undoes the entire trim. Measured on the canonical
+    "200 KB paste then 25 tool calls" shape, that path turned a
+    67,066-token request into a 67,061-token request against a 24,576
+    target — reported as ``status="trimmed"`` and then rejected
+    upstream. A budget-blind restore does not avoid the 400, it
+    guarantees it.
+    """
+    for idx in sorted(dropped, reverse=True):
+        if idx >= before:
+            continue
+        if not _is_clean_user(messages[idx]):
+            continue
+        if chars_to_tokens(kept_chars + msg_chars[idx]) <= target_tokens:
+            return messages[idx]
+    return _synthetic_head()
 
 
 def _do_trim(
@@ -437,12 +544,23 @@ def _do_trim(
     hard floor that is never removed. After trimming, the head is
     normalized so the first surviving message is a ``user`` message
     without a leading ``tool_result`` (avoids upstream 400s). Bug H5.
+
+    The loop is incremental in *characters*: every message's character
+    contribution is computed exactly once up front and subtracted as
+    units are dropped, instead of rebuilding the kept list and
+    re-walking the whole conversation on every iteration (the old
+    O(messages x chars) shape cost ~0.2s of event-loop time for an
+    800-message session). Because the char/4 heuristic floor-divides
+    the grand total exactly once, the running sum stays bit-identical
+    to a full recompute.
     """
     if not messages:
         return messages
 
-    already = estimate_tokens_from_anthropic_request(system=system, messages=messages)
-    if already <= target_tokens:
+    system_chars = count_system_chars(system)
+    msg_chars = [count_message_chars(m) for m in messages]
+    total_chars = system_chars + sum(msg_chars)
+    if chars_to_tokens(total_chars) <= target_tokens:
         # Nothing to do — return the input unchanged.
         return messages
 
@@ -453,14 +571,41 @@ def _do_trim(
     # Indices we have decided to drop; peel atomic units from the front.
     dropped: set[int] = set()
     for unit in units:
-        kept = [messages[i] for i in range(len(messages)) if i not in dropped]
-        estimated = estimate_tokens_from_anthropic_request(system=system, messages=kept)
-        if estimated <= target_tokens:
+        if chars_to_tokens(total_chars) <= target_tokens:
             break
+        unit_chars = sum(msg_chars[i] for i in unit)
+        if unit_chars <= 0:
+            # Dropping this unit would not move the estimate at all
+            # (e.g. an image-only turn, which counts as 0 chars by
+            # design). Destroying history for no budget gain is pure
+            # loss — skip it and try the next unit.
+            continue
         dropped.update(unit)
-
-    trimmed = [messages[i] for i in range(len(messages)) if i not in dropped]
-    return _normalize_head(trimmed)
+        total_chars -= unit_chars
+
+    kept_indices = [i for i in range(len(messages)) if i not in dropped]
+    trimmed = [messages[i] for i in kept_indices]
+    if not trimmed:
+        # Structural fail-safe: never hand back an empty history.
+        return list(messages[-max(preserve_last_n, 1) :])
+
+    if any(_is_clean_user(m) for m in trimmed):
+        # A real head survives — no fallback needed, and computing one
+        # would only cost time.
+        return _normalize_head(trimmed)
+
+    # Nothing in the surviving window can open the request. Pick a head
+    # that fits the remaining budget (``total_chars`` already reflects
+    # every drop above), falling back to a synthetic marker.
+    fallback_head = _pick_fallback_head(
+        messages,
+        msg_chars,
+        dropped,
+        before=kept_indices[0],
+        kept_chars=total_chars,
+        target_tokens=target_tokens,
+    )
+    return _normalize_head(trimmed, fallback_head=fallback_head)
 
 
 __all__ = [

coderouter/ingress/launcher_routes.py

@@ -714,11 +714,21 @@ async def _backend_ready(backend: str, port: int, *, probe_timeout_s: float) ->
     Falling through to the bare TCP connect here would silently re-introduce
     the bug readiness gating was added to fix (provider registered before the
     model finished loading).
+
+    The probe targets ``127.0.0.1`` literally, never ``localhost``. On a host
+    where ``localhost`` resolves to ``::1`` first — the default on GitHub's
+    macOS runners, and common on Macs generally — an httpx request to
+    ``http://localhost:<port>`` fails with ``Address family not supported``
+    against a backend listening on IPv4 only, which is what ``llama-server``
+    does by default (``--host 127.0.0.1``). Readiness then never succeeds and
+    the spawn times out with ``status='loading'`` even though the backend is
+    up and serving. The bare TCP fallback below already used ``127.0.0.1``;
+    this branch was the odd one out.
     """
     if base_backend(backend) in ("llama.cpp", "vllm"):
         try:
             async with httpx.AsyncClient(timeout=probe_timeout_s) as client:
-                resp = await client.get(f"http://localhost:{port}/health")
+                resp = await client.get(f"http://127.0.0.1:{port}/health")
             return resp.status_code == 200
         except Exception:
             return False

coderouter/token_estimation.py

@@ -6,6 +6,8 @@ Provides a shared char/4 token estimator used by:
     matcher for longContext auto-switch (v1.10).
   - :mod:`coderouter.guards.context_budget` — L1 context overflow
     detection (v2.0-F).
+  - ``POST /v1/messages/count_tokens`` (:mod:`coderouter.ingress.anthropic_routes`).
+  - :mod:`coderouter.language_tax` — CJK tax measurement.
 
 No external dependencies. The heuristic is ``total_chars // 4``:
 
@@ -18,6 +20,58 @@ No external dependencies. The heuristic is ``total_chars // 4``:
     this is a known gap; operators can lower the warn/trim thresholds
     to compensate (e.g. 0.60 / 0.70 instead of 0.80 / 0.90).
 
+Which content blocks are counted (H-5, v2.12)
+=============================================
+
+Up to v2.11.x only ``text`` blocks were counted. Agent clients
+(Claude Code, Cline, OpenClaw, …) put almost all of their context in
+``tool_result`` and ``tool_use`` blocks, so the estimate was off by
+5x at 20 turns and ~29x at 200 turns for a tool-heavy session. The
+extractor now dispatches on the block ``type``:
+
+===================== ===========================================
+block type            contribution
+===================== ===========================================
+``text``              ``text`` verbatim
+``tool_result``       ``content`` — ``str`` verbatim, or the same
+                      per-type rules applied recursively to the
+                      block list (so a nested ``image`` is still 0)
+``tool_use``          ``name`` + ``json.dumps(input)``
+``thinking``          the ``thinking`` string (it is replayed back
+                      to the model on the next turn, so it really
+                      does occupy the context window)
+``image``             **0** — deliberately
+``redacted_thinking`` 0 (opaque ciphertext, not model-visible text)
+anything else         0 (forward-compatible default)
+===================== ===========================================
+
+The ``image`` exclusion is load-bearing, not an oversight: a naive
+``json.dumps(block)`` of a request carrying a 400 KB base64 PNG
+over-estimates by ~35x (11,789 → 410,781 tokens measured), which
+would make the context-budget guard shred the history of any session
+that ever pasted a screenshot. Images are billed on their own axis
+and must stay at 0.
+
+Known cross-path inconsistency (out of scope for H-5)
+-----------------------------------------------------
+``POST /v1/messages/count_tokens`` additionally appends the JSON of
+the request's ``tools`` array before counting (see
+``ingress/anthropic_routes.py``), while
+:func:`estimate_tokens_from_anthropic_request` /
+:func:`estimate_tokens_from_body` do **not** count tool *definitions*
+at all. A request with large tool schemas therefore gets a bigger
+number from ``count_tokens`` than the context-budget guard sees. This
+is pre-existing behavior and is intentionally left unchanged here —
+tracked as a follow-up, not part of the H-5 fix.
+
+Escape hatch
+------------
+:func:`set_include_tool_content` (wired to the top-level config key
+``token_estimation_include_tool_content``) restores the exact v2.11.x
+numbers by skipping ``tool_result`` / ``tool_use`` / ``thinking``
+again. It exists only to unblock operators surprised by the new
+(correct) guard/routing behavior and is scheduled for removal.
+
 Future (v2.0+): detect ``tiktoken`` at import time and offer a
 precision mode. The public API is stable either way — callers get
 an ``int`` estimate regardless of the backend.
@@ -25,6 +79,7 @@ an ``int`` estimate regardless of the backend.
 
 from __future__ import annotations
 
+import json
 from typing import Any
 
 # ---------------------------------------------------------------------------
@@ -40,40 +95,153 @@ CHARS_PER_TOKEN_HEURISTIC: int = 4
 #: operators who use it should declare explicitly or via registry).
 DEFAULT_MAX_CONTEXT_TOKENS: int = 128_000
 
+#: Depth cap for the recursive block walk. ``tool_result.content`` is
+#: the only legal nesting level in the Anthropic wire format; the cap
+#: just makes a hand-crafted / buggy payload unable to blow the stack.
+_MAX_BLOCK_DEPTH: int = 4
+
+#: Block types that never contribute characters, whatever the flags.
+#: ``image`` is base64 (or a URL) billed on a separate axis;
+#: ``redacted_thinking`` is opaque ciphertext the model never reads as
+#: text. Counting either one over-estimates catastrophically.
+_ZERO_CHAR_BLOCK_TYPES: frozenset[str] = frozenset(
+    {"image", "image_url", "redacted_thinking"}
+)
+
+#: Block types gated behind the ``include_tool_content`` switch.
+_TOOL_BLOCK_TYPES: frozenset[str] = frozenset({"tool_result", "tool_use", "thinking"})
+
+
+# ---------------------------------------------------------------------------
+# Process-wide opt-out (v2.11.x compatibility escape hatch)
+# ---------------------------------------------------------------------------
+
+#: Module-level default for :func:`set_include_tool_content`. Set from
+#: ``CodeRouterConfig.token_estimation_include_tool_content`` at config
+#: load time. A module global (rather than a parameter threaded through
+#: every call site) is required because three of the four consumers —
+#: the auto-router, ``count_tokens`` and language-tax — run *outside*
+#: any profile context and must all agree on one number per process.
+_INCLUDE_TOOL_CONTENT: bool = True
+
+
+def set_include_tool_content(enabled: bool) -> None:
+    """Set the process-wide default for tool-content counting.
+
+    Called from ``CodeRouterConfig``'s validator so a single config key
+    controls every consumer of this module consistently. ``False``
+    reproduces v2.11.x estimates exactly.
+    """
+    global _INCLUDE_TOOL_CONTENT
+    _INCLUDE_TOOL_CONTENT = bool(enabled)
+
+
+def get_include_tool_content() -> bool:
+    """Return the current process-wide tool-content counting default."""
+    return _INCLUDE_TOOL_CONTENT
+
+
+def _resolve_include(include_tool_content: bool | None) -> bool:
+    return _INCLUDE_TOOL_CONTENT if include_tool_content is None else include_tool_content
+
 
 # ---------------------------------------------------------------------------
 # Text extraction helpers
 # ---------------------------------------------------------------------------
 
 
-def _extract_text_from_content(content: Any) -> str:
+def _tool_use_text(block: dict[str, Any]) -> str:
+    """Serialize a ``tool_use`` block's name + input for char counting.
+
+    ``input`` is arbitrary JSON, so its wire size is the honest proxy
+    for how much context it occupies. ``ensure_ascii=False`` keeps CJK
+    arguments at their real character count instead of inflating them
+    into ``\\uXXXX`` escapes.
+    """
+    pieces: list[str] = []
+    name = block.get("name")
+    if isinstance(name, str):
+        pieces.append(name)
+    raw_input = block.get("input")
+    if raw_input is not None:
+        try:
+            pieces.append(json.dumps(raw_input, ensure_ascii=False))
+        except (TypeError, ValueError):
+            pieces.append(str(raw_input))
+    return "\n".join(pieces)
+
+
+def _extract_text_from_content(
+    content: Any,
+    *,
+    include_tool_content: bool | None = None,
+    _depth: int = 0,
+) -> str:
     """Extract concatenated text from a message's ``content`` field.
 
     Handles:
       - ``str`` (short form) → returned verbatim.
-      - ``list[dict]`` (multimodal blocks) → text-type blocks
-        concatenated with newlines. Image / tool_use / tool_result
-        blocks contribute 0 chars (billed differently or don't
-        consume text-token budget).
+      - ``list[dict]`` (multimodal blocks) → dispatched per block
+        ``type``; see the module docstring's table for the exact rules.
+        ``image`` blocks always contribute 0 chars; ``tool_result`` /
+        ``tool_use`` / ``thinking`` contribute their text unless
+        ``include_tool_content`` is False.
       - ``None`` / other → empty string.
+
+    ``include_tool_content=None`` (the default) resolves to the
+    process-wide setting from :func:`set_include_tool_content`.
     """
+    include = _resolve_include(include_tool_content)
     if isinstance(content, str):
         return content
-    if isinstance(content, list):
-        pieces: list[str] = []
-        for block in content:
-            if not isinstance(block, dict):
+    if not isinstance(content, list):
+        return ""
+
+    pieces: list[str] = []
+    for block in content:
+        if not isinstance(block, dict):
+            continue
+        btype = block.get("type")
+
+        if btype == "text":
+            text = block.get("text")
+            if isinstance(text, str):
+                pieces.append(text)
+            continue
+        if btype is None:
+            # Fallback for blocks without explicit type but with text
+            text = block.get("text")
+            if isinstance(text, str):
+                pieces.append(text)
+            continue
+        if btype in _ZERO_CHAR_BLOCK_TYPES:
+            # Deliberate 0: see module docstring (35x over-estimate).
+            continue
+        if btype not in _TOOL_BLOCK_TYPES or not include:
+            # Unknown/forward-compat blocks contribute nothing, and the
+            # escape hatch drops the tool blocks back to v2.11.x's 0.
+            continue
+
+        if btype == "tool_result":
+            if _depth >= _MAX_BLOCK_DEPTH:
                 continue
-            btype = block.get("type")
-            if btype == "text":
-                text = block.get("text")
-                if isinstance(text, str):
-                    pieces.append(text)
-            elif btype is None and "text" in block and isinstance(block["text"], str):
-                # Fallback for blocks without explicit type but with text
-                pieces.append(block["text"])
-        return "\n".join(pieces)
-    return ""
+            inner = _extract_text_from_content(
+                block.get("content"),
+                include_tool_content=True,
+                _depth=_depth + 1,
+            )
+            if inner:
+                pieces.append(inner)
+        elif btype == "tool_use":
+            rendered = _tool_use_text(block)
+            if rendered:
+                pieces.append(rendered)
+        elif btype == "thinking":
+            thinking = block.get("thinking")
+            if isinstance(thinking, str):
+                pieces.append(thinking)
+
+    return "\n".join(pieces)
 
 
 def _count_system_chars(system: Any) -> int:
@@ -106,12 +274,56 @@ def _extract_system_text(system: Any) -> str:
     return ""
 
 
+def _message_content(msg: Any) -> Any:
+    """Pull ``content`` off a Pydantic message model or a plain dict."""
+    if hasattr(msg, "content"):
+        return msg.content
+    if isinstance(msg, dict):
+        return msg.get("content")
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Public API: character-level primitives
+# ---------------------------------------------------------------------------
+#
+# The guard's trim loop needs per-message character counts so it can
+# subtract as it drops instead of re-walking the whole conversation
+# after every removal (O(n^2) → O(n)). Counting *chars* rather than
+# per-message tokens keeps the incremental sum bit-identical to a full
+# recompute: the heuristic floor-divides the grand total exactly once.
+
+
+def count_system_chars(system: Any) -> int:
+    """Public alias of the system-prompt character count."""
+    return _count_system_chars(system)
+
+
+def count_message_chars(msg: Any, *, include_tool_content: bool | None = None) -> int:
+    """Characters a single message contributes to the estimate."""
+    return len(
+        _extract_text_from_content(
+            _message_content(msg),
+            include_tool_content=include_tool_content,
+        )
+    )
+
+
+def chars_to_tokens(total_chars: int) -> int:
+    """Apply the char/4 heuristic to an already-summed character count."""
+    return total_chars // CHARS_PER_TOKEN_HEURISTIC
+
+
 # ---------------------------------------------------------------------------
 # Public API
 # ---------------------------------------------------------------------------
 
 
-def estimate_tokens_from_body(body: dict[str, Any]) -> int:
+def estimate_tokens_from_body(
+    body: dict[str, Any],
+    *,
+    include_tool_content: bool | None = None,
+) -> int:
     """Estimate the prompt's token count from a raw request body dict.
 
     Works with both Anthropic (``system`` + ``messages``) and OpenAI
@@ -120,7 +332,10 @@ def estimate_tokens_from_body(body: dict[str, Any]) -> int:
     sums character counts, divides by :data:`CHARS_PER_TOKEN_HEURISTIC`.
 
     Image blocks contribute 0 — they're billed differently and don't
-    fill the text-token side of the context window.
+    fill the text-token side of the context window. ``tool_result`` /
+    ``tool_use`` / ``thinking`` blocks DO count (H-5); see the module
+    docstring. Tool *definitions* (``body["tools"]``) are still not
+    counted — known inconsistency with ``count_tokens``.
 
     This is the function formerly known as
     ``coderouter.routing.auto_router._estimate_total_tokens``.
@@ -130,14 +345,20 @@ def estimate_tokens_from_body(body: dict[str, Any]) -> int:
     if isinstance(messages, list):
         for msg in messages:
             if isinstance(msg, dict):
-                total_chars += len(_extract_text_from_content(msg.get("content")))
-    return total_chars // CHARS_PER_TOKEN_HEURISTIC
+                total_chars += len(
+                    _extract_text_from_content(
+                        msg.get("content"),
+                        include_tool_content=include_tool_content,
+                    )
+                )
+    return chars_to_tokens(total_chars)
 
 
 def estimate_tokens_from_anthropic_request(
     *,
     system: Any,
     messages: list[Any],
+    include_tool_content: bool | None = None,
 ) -> int:
     """Estimate token count for an Anthropic-shaped request.
 
@@ -153,6 +374,10 @@ def estimate_tokens_from_anthropic_request(
     messages : list[AnthropicMessage]
         The request's ``messages`` list. Each item should have a
         ``content`` attribute (str or list of blocks).
+    include_tool_content : bool | None
+        ``None`` → process-wide default (see
+        :func:`set_include_tool_content`). ``False`` reproduces the
+        v2.11.x estimate exactly.
     """
     total_chars = _count_system_chars(system)
     for msg in messages:
@@ -164,23 +389,26 @@ def estimate_tokens_from_anthropic_request(
             content = msg.get("content")
         else:
             continue
-        total_chars += len(_extract_text_from_content(content))
-    return total_chars // CHARS_PER_TOKEN_HEURISTIC
+        total_chars += len(
+            _extract_text_from_content(content, include_tool_content=include_tool_content)
+        )
+    return chars_to_tokens(total_chars)
 
 
 def extract_text_from_anthropic_request(
     *,
     system: Any,
     messages: list[Any],
+    include_tool_content: bool | None = None,
 ) -> str:
     """Concatenate all text in an Anthropic-shaped request.
 
     Mirrors :func:`estimate_tokens_from_anthropic_request` but returns
-    the raw text (system prompt + every message's text blocks) instead
-    of a char/4 count. Used by :mod:`coderouter.language_tax` to feed an
-    accurate tokenizer for language-tax measurement. Non-text blocks
-    (images / tool_use / tool_result) contribute nothing — same rule the
-    char/4 estimator uses.
+    the raw text (system prompt + every message's countable blocks)
+    instead of a char/4 count. Used by :mod:`coderouter.language_tax`
+    to feed an accurate tokenizer for language-tax measurement, and by
+    ``POST /v1/messages/count_tokens``. Image blocks contribute nothing
+    — same rule the char/4 estimator uses.
     """
     pieces: list[str] = []
     sys_text = _extract_system_text(system)
@@ -193,7 +421,7 @@ def extract_text_from_anthropic_request(
             content = msg.get("content")
         else:
             continue
-        text = _extract_text_from_content(content)
+        text = _extract_text_from_content(content, include_tool_content=include_tool_content)
         if text:
             pieces.append(text)
     return "\n".join(pieces)
@@ -202,7 +430,12 @@ def extract_text_from_anthropic_request(
 __all__ = [
     "CHARS_PER_TOKEN_HEURISTIC",
     "DEFAULT_MAX_CONTEXT_TOKENS",
+    "chars_to_tokens",
+    "count_message_chars",
+    "count_system_chars",
     "estimate_tokens_from_anthropic_request",
     "estimate_tokens_from_body",
     "extract_text_from_anthropic_request",
+    "get_include_tool_content",
+    "set_include_tool_content",
 ]

{coderouter_cli-2.11.2.dist-info → coderouter_cli-2.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 2.11.2
+Version: 2.12.0
 Summary: Local-first, free-first, fallback-built-in LLM router. Claude Code / OpenAI compatible.
 Project-URL: Homepage, https://github.com/zephel01/CodeRouter
 Project-URL: Repository, https://github.com/zephel01/CodeRouter

{coderouter_cli-2.11.2.dist-info → coderouter_cli-2.12.0.dist-info}/RECORD

@@ -15,7 +15,7 @@ coderouter/launcher_speculative.py,sha256=h0RTGsD1Y56sJVywDJwybrT75_Ta3GF1Jz_B1d
 coderouter/launcher_swap.py,sha256=tMW5ZElDdf9T1VQGsUkvfLiSCdj_oXN_UtkV7DE8ySY,24175
 coderouter/logging.py,sha256=5rfi4_R4aoeeUYDc642dgs61wA0aBX7wvubyB-k3Uyo,58074
 coderouter/output_filters.py,sha256=0ry_rPiS_kC-FnHgaNVP6v7e6Al2djxzu9vBzZ8kEkE,25314
-coderouter/token_estimation.py,sha256=iz22vZEEW2P7uKLB2pYvPNpIbZGbgXRO5MtfkS_-9Sk,7531
+coderouter/token_estimation.py,sha256=7klQYA4FIg1vtjQGWAhwiBhiLwyz8KTetrLVXFJLGIc,16957
 coderouter/token_estimation_accurate.py,sha256=GTfzrBVnvAGjeVzmzAeUdOYZvWZKLAxcxPpFiJGlzjk,4609
 coderouter/vscode_init.py,sha256=fW0chCDTngvWQuJgQ7aqYmE6hnZO3hCk8mAiEkZ9FCo,26741
 coderouter/adapters/__init__.py,sha256=7dIDSZ-FE_0iSqLSDc_lK1idRdLTKcM2hP9tCJipgPI,463
@@ -27,13 +27,13 @@ coderouter/config/__init__.py,sha256=FODEn74fN-qZnt4INPSHswqhOlEgpL6-_onxsitSx8g
 coderouter/config/capability_registry.py,sha256=RZgzHF54dXy0CCDocRCz2ee21qXGbbgTSKTkRI9iLL4,16936
 coderouter/config/env_file.py,sha256=CoMK27fuAXm-NtoLzXb8yN2E-wDFjHQuFwiIlmgTBQw,10356
 coderouter/config/loader.py,sha256=jUoHAbEyjK6Y0HDqhjXHO4tfncMPuzsjfWJokrPb2x8,6876
-coderouter/config/schemas.py,sha256=8MZMW3Iask-ZvkWV2b77UYszqMgJ4ETc6gEU80Ekx9g,131685
+coderouter/config/schemas.py,sha256=AK2lsPMqBa6NYEXNHwxis8Nd9bcW2q_x4ciO3QuYIpk,134441
 coderouter/data/__init__.py,sha256=uNyfD9jaCvTWsBAWtaw1Fr25OSxzv3psGMfBjT1z0Cc,328
 coderouter/data/model-capabilities.yaml,sha256=S9jt6SC6-3s2-icZ_n-a14iEMnc2yB1C2R6q-N_tZWQ,19309
 coderouter/guards/__init__.py,sha256=5qliYBqygvVPneej7nx0uSjxDKsz7t8VzvrDgVBJlvU,1170
 coderouter/guards/_fingerprint.py,sha256=qsgNzIq9jv3FHrKL39nGJARp0cMenpN_QmWoJu87vU4,4835
 coderouter/guards/backend_health.py,sha256=GLUVQ5BhU6i8Cxz_FrgIMs5AZ-YSKAW8veFWgvn9GFI,12565
-coderouter/guards/context_budget.py,sha256=6u08JqBdRQkDz9NIQ-aISXo3w3L804oYFg027s04IwY,17202
+coderouter/guards/context_budget.py,sha256=gw3MkiHDjpLmQTlTdJT6gRAxYEnoU0xmwSvPZk_miOQ,23059
 coderouter/guards/continuous_probe.py,sha256=WIfS-apVMWXGv7bPBxxkJssePa95I4fT0mi4PNqK5iE,12181
 coderouter/guards/drift_actions.py,sha256=A6pY5CR480Ct5rCVyjlBvjPFVc93eu_r5qcUpK9mWKc,3602
 coderouter/guards/drift_detection.py,sha256=lW45EZDGRleDUTstw_CHlfUiwLUrlDHX8g7ncuOYNEw,13962
@@ -45,7 +45,7 @@ coderouter/ingress/__init__.py,sha256=WQsCH2CGJCAhy0mS6GSEdeYZRkkQu2OHDsP4CJWTLu
 coderouter/ingress/anthropic_routes.py,sha256=1ThXzx8VgxRV7UCi3NF5ey7kbr0ADPKTXyQuYS5gK1w,27063
 coderouter/ingress/app.py,sha256=6e_qNlYZIyjLKhY20t0ZNL-x5Fv8R8oaIH_HCdxa9Ic,20921
 coderouter/ingress/dashboard_routes.py,sha256=1SqNNrVTfQiZcx5n2MvjAzWirittX0e61tCt-MKp4Ag,25617
-coderouter/ingress/launcher_routes.py,sha256=g-0Mee1vpY10b82jI51-2fTeR8hxutMCaLYBcicwM_k,133287
+coderouter/ingress/launcher_routes.py,sha256=ipgY1omiSGQn5RBvsuQMLepCJ03w4eafacg2JDVufe8,133937
 coderouter/ingress/metrics_routes.py,sha256=M22dwOGn24P05Ge4W3c7d7mYytSGWjIR-pPSPOAiHJY,3965
 coderouter/ingress/openai_routes.py,sha256=TrugsQNJfNPgKKLzfT1aXzrs4emWYGE4XebEBuaZoWk,12505
 coderouter/metrics/__init__.py,sha256=7Es351DPS7yLM0yVF_F0eesmiD83n7Zzhie44chht38,1465
@@ -71,8 +71,9 @@ coderouter/translation/__init__.py,sha256=PYXN7XVEwpG1uC8RLy6fvnGbzEZhhrEuUapH8I
 coderouter/translation/anthropic.py,sha256=ZQQGS9itN_3o7IKD68lKr5gR_Kem32Jsd7OcGjJzv8Q,13468
 coderouter/translation/convert.py,sha256=VrstDAMsUpcQ1VgMTn_-ETp1OjGX8v0ZGhCkcd4icyU,53037
 coderouter/translation/tool_repair.py,sha256=1p8rmdyyscGX2g0DDOYitMnLv-nKfR1SLuLaRB4z7GM,64244
-coderouter_cli-2.11.2.dist-info/METADATA,sha256=zw-XK_yuV-v6dBPqAohL8iYdQJW_rmbI0UhmVvyfT0s,16897
-coderouter_cli-2.11.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-coderouter_cli-2.11.2.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
-coderouter_cli-2.11.2.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
-coderouter_cli-2.11.2.dist-info/RECORD,,
+coderouter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+coderouter_cli-2.12.0.dist-info/METADATA,sha256=B1BU4vM2YPNzqR8sMFJy7vfPPUqBliwXqqpiLESl7mE,16897
+coderouter_cli-2.12.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+coderouter_cli-2.12.0.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
+coderouter_cli-2.12.0.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
+coderouter_cli-2.12.0.dist-info/RECORD,,