coderouter-cli 2.7.0__tar.gz → 2.7.1__tar.gz

{coderouter_cli-2.7.0 → coderouter_cli-2.7.1}/CHANGELOG.md

@@ -6,6 +6,57 @@ versioning follows [SemVer](https://semver.org/).
 
 ---
 
+## [v2.7.1] — 2026-07-04 (Native-endpoint shims + benchmarked tool-repair upgrade)
+
+Two feature PRs driven by the 2026-07-04 competitive re-survey and the new
+tool-call repair benchmark: **PR #39** (native `/v1/messages` endpoint gap
+shims) and **PR #40** (lenient tool-call repair). All new behavior is
+**opt-in with `off` defaults** (except the previously-404 `count_tokens`
+endpoint, which is additive), no config-schema breaking changes, and the
+Core runtime stays at **5 dependencies**.
+
+### Added
+
+- **`POST /v1/messages/count_tokens`** (was 404). Anthropic-shape
+  `{"input_tokens": N}`; accurate when the provider declares
+  `tokenizer_path`, char/4 heuristic otherwise. Fills a gap native backends
+  leave open (Ollama's Anthropic-compatible API ships without
+  `count_tokens` / `tool_choice` / prompt caching). (PR #39)
+- **`tool_choice_action: off | warn | emulate`** (profile option) +
+  `Capabilities.tool_choice` + registry field + `provider_supports_tool_choice()`.
+  `emulate` rewrites forced tool_choice (`any` / `tool`) into a system-prompt
+  instruction for non-supporting backends; the original request is preserved
+  for fallback to capable providers. New capability-degraded reason:
+  `unsupported-backend`. (PR #39)
+- **`cache_control_action: off | strip`** (profile option). `strip` removes
+  `cache_control` markers before sending to non-supporting providers
+  (logged as `cache-control-stripped`; deliberately no tokens-saved
+  accounting). (PR #39)
+- **Lenient tool-call repair** (`translation/tool_repair.py`): second-pass
+  parsing for malformed JSON (double braces, trailing commas, single quotes,
+  unquoted keys), key aliases (`tool`/`tool_name`, `parameters`/`input`/`args`),
+  and XML-flavoured forms — all gated on `allowed_tool_names`. Residue
+  cleanup (empty fences, `[,]`). Benchmark: recall 80.6% → **100%** on a
+  55-case corpus; live fail-rate at default temperature 17% → **1%**
+  (qwen2.5-coder:7b × 100 requests). (PR #40)
+
+### Fixed
+
+- **Two real false positives in the previous repairer** (python-fence dict
+  literals and documentation JSON with allowed tool names were converted
+  into executable calls — same class as the v2.7.0 code-eating regression).
+  Now fixed and gated by an expanded 12-case negative corpus. (PR #40)
+
+### Docs
+
+- README repositioned for the native `/v1/messages` era: repair + guards
+  lead, wire translation demoted to last (passthrough note); new section
+  "why a router when Ollama connects directly?".
+
+Tests: **1481 passed, 0 failed** (1401 → 1481; +37 shim, +43 lenient-repair).
+
+---
+
 ## [v2.7.0] — 2026-07-02 (Reliability & security: full-source review fixes)
 
 22 reliability and security fixes from a full-source review (26,600 lines),

{coderouter_cli-2.7.0 → coderouter_cli-2.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 2.7.0
+Version: 2.7.1
 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
@@ -70,8 +70,8 @@ Description-Content-Type: text/markdown
         │
         ▼
   ┌─ CodeRouter ─┐
-  │  翻訳 + 修復  │──→  ① ローカル (Ollama — 無料・最速)
-  │  ガード + 監視 │──→  ② 無料クラウド (OpenRouter / NIM)
+  │  修復 + ガード │──→  ① ローカル (Ollama — 無料・最速)
+  │  監視 + 診断  │──→  ② 無料クラウド (OpenRouter / NIM)
   │  自動フォールバック │──→  ③ 有料 (Claude — opt-in 時のみ)
   └──────────────┘
 ```
@@ -79,13 +79,31 @@ Description-Content-Type: text/markdown
 **やってくれること:**
 
 - ローカルモデルが壊した tool calling を Claude Code に届く前に修復する
+- 8 時間回しても止まらないように 6 種類のガードで守る
 - 1 つ目が落ちたら自動で次のプロバイダに切り替える
 - 有料 API は明示的に許可したときだけ使う (デフォルトは無料のみ)
-- 8 時間回しても止まらないように 6 種類のガードで守る
 - 何がおかしいか `coderouter doctor` コマンド一発で診断する
 
 ---
 
+## 「Ollama に直結できるのに、なぜルーター?」
+
+2026 年、Ollama (v0.14+) / LM Studio (0.4.1+) / llama.cpp / vLLM は Anthropic 互換 `/v1/messages` を標準装備しました。`ANTHROPIC_BASE_URL` を直接向ければ Claude Code は一応動きます。
+
+**でも直結では、こうなります:**
+
+| 直結の現実 | CodeRouter 経由 |
+|---|---|
+| 壊れた tool call は壊れたまま届く | 届く前に修復 |
+| backend が落ちたらセッション終了 | ローカル → 無料 → 有料へ自動フォールバック |
+| 長時間で context 溢れ・drift・ループ | 6 系統ガード + self-healing |
+| モデル名がハードコード (リタイアで即エラー) | プロファイルで抽象化、差し替え 1 行 |
+| 何が悪いか分からない | `doctor` 6 プローブ + `/dashboard` + audit/replay |
+
+直結で困っていないなら CodeRouter は不要です。**長時間・無人・弱いモデル**のどれかに当てはまったら、戻ってきてください。
+
+---
+
 ## インストール (3 行)
 
 ```bash
@@ -120,8 +138,9 @@ ANTHROPIC_BASE_URL=http://localhost:8088 ANTHROPIC_AUTH_TOKEN=dummy claude
 
 | あなたの状況 | CodeRouter は？ |
 |---|---|
-| Claude Code + ローカル Ollama で tool calling が壊れる | **必須** — wire 変換 + tool 修復 |
-| Claude Code + ローカルで長時間回すと止まる | **便利** — 6 系統ガード + self-healing |
+| Claude Code + ローカル Ollama で tool calling が壊れる | **必須** — tool 修復 (+ 必要なら wire 変換) |
+| Claude Code + ローカルで長時間回すと止まる | **必須級** — 6 系統ガード + self-healing |
+| Ollama v0.14+ / LM Studio にネイティブ直結で動いてる | **便利** — 直結に無い fallback / ガード / 診断を追加 (passthrough で翻訳ゼロ) |
 | codex / gemini-cli + Ollama 直繋ぎで動いてる | オプション — フォールバックが欲しいなら |
 | Claude API を直接叩いてて問題ない | 不要 |
 
@@ -131,14 +150,14 @@ ANTHROPIC_BASE_URL=http://localhost:8088 ANTHROPIC_AUTH_TOKEN=dummy claude
 
 ## 主な機能
 
-### 接続と修復
+### 修復と接続
 
 | 機能 | 何をしてくれるか |
 |---|---|
-| **Wire 翻訳** | Claude Code (Anthropic形式) ↔ Ollama (OpenAI形式) を自動変換 |
 | **Tool-call 修復** | ローカルモデルがテキストで吐いた JSON を正しい tool_use ブロックに復元 |
 | **3 層フォールバック** | ローカル → 無料クラウド → 有料の順に自動切替 |
-| **出力フィルタ** | `<think>` タグ漏れ、stop marker 漏れを自動除去 |
+| **出力フィルタ** | `<think>` タグ漏れ、stop marker 漏れ、byte-fallback (`<0xNN>`) を自動除去/修復 |
+| **Wire 翻訳** | Anthropic 形式 ↔ OpenAI 形式を自動変換 (ネイティブ `/v1/messages` 対応 backend は passthrough で翻訳ゼロ) |
 
 ### 長時間運用ガード
 

{coderouter_cli-2.7.0 → coderouter_cli-2.7.1}/README.md

@@ -25,8 +25,8 @@
         │
         ▼
   ┌─ CodeRouter ─┐
-  │  翻訳 + 修復  │──→  ① ローカル (Ollama — 無料・最速)
-  │  ガード + 監視 │──→  ② 無料クラウド (OpenRouter / NIM)
+  │  修復 + ガード │──→  ① ローカル (Ollama — 無料・最速)
+  │  監視 + 診断  │──→  ② 無料クラウド (OpenRouter / NIM)
   │  自動フォールバック │──→  ③ 有料 (Claude — opt-in 時のみ)
   └──────────────┘
 ```
@@ -34,13 +34,31 @@
 **やってくれること:**
 
 - ローカルモデルが壊した tool calling を Claude Code に届く前に修復する
+- 8 時間回しても止まらないように 6 種類のガードで守る
 - 1 つ目が落ちたら自動で次のプロバイダに切り替える
 - 有料 API は明示的に許可したときだけ使う (デフォルトは無料のみ)
-- 8 時間回しても止まらないように 6 種類のガードで守る
 - 何がおかしいか `coderouter doctor` コマンド一発で診断する
 
 ---
 
+## 「Ollama に直結できるのに、なぜルーター?」
+
+2026 年、Ollama (v0.14+) / LM Studio (0.4.1+) / llama.cpp / vLLM は Anthropic 互換 `/v1/messages` を標準装備しました。`ANTHROPIC_BASE_URL` を直接向ければ Claude Code は一応動きます。
+
+**でも直結では、こうなります:**
+
+| 直結の現実 | CodeRouter 経由 |
+|---|---|
+| 壊れた tool call は壊れたまま届く | 届く前に修復 |
+| backend が落ちたらセッション終了 | ローカル → 無料 → 有料へ自動フォールバック |
+| 長時間で context 溢れ・drift・ループ | 6 系統ガード + self-healing |
+| モデル名がハードコード (リタイアで即エラー) | プロファイルで抽象化、差し替え 1 行 |
+| 何が悪いか分からない | `doctor` 6 プローブ + `/dashboard` + audit/replay |
+
+直結で困っていないなら CodeRouter は不要です。**長時間・無人・弱いモデル**のどれかに当てはまったら、戻ってきてください。
+
+---
+
 ## インストール (3 行)
 
 ```bash
@@ -75,8 +93,9 @@ ANTHROPIC_BASE_URL=http://localhost:8088 ANTHROPIC_AUTH_TOKEN=dummy claude
 
 | あなたの状況 | CodeRouter は？ |
 |---|---|
-| Claude Code + ローカル Ollama で tool calling が壊れる | **必須** — wire 変換 + tool 修復 |
-| Claude Code + ローカルで長時間回すと止まる | **便利** — 6 系統ガード + self-healing |
+| Claude Code + ローカル Ollama で tool calling が壊れる | **必須** — tool 修復 (+ 必要なら wire 変換) |
+| Claude Code + ローカルで長時間回すと止まる | **必須級** — 6 系統ガード + self-healing |
+| Ollama v0.14+ / LM Studio にネイティブ直結で動いてる | **便利** — 直結に無い fallback / ガード / 診断を追加 (passthrough で翻訳ゼロ) |
 | codex / gemini-cli + Ollama 直繋ぎで動いてる | オプション — フォールバックが欲しいなら |
 | Claude API を直接叩いてて問題ない | 不要 |
 
@@ -86,14 +105,14 @@ ANTHROPIC_BASE_URL=http://localhost:8088 ANTHROPIC_AUTH_TOKEN=dummy claude
 
 ## 主な機能
 
-### 接続と修復
+### 修復と接続
 
 | 機能 | 何をしてくれるか |
 |---|---|
-| **Wire 翻訳** | Claude Code (Anthropic形式) ↔ Ollama (OpenAI形式) を自動変換 |
 | **Tool-call 修復** | ローカルモデルがテキストで吐いた JSON を正しい tool_use ブロックに復元 |
 | **3 層フォールバック** | ローカル → 無料クラウド → 有料の順に自動切替 |
-| **出力フィルタ** | `<think>` タグ漏れ、stop marker 漏れを自動除去 |
+| **出力フィルタ** | `<think>` タグ漏れ、stop marker 漏れ、byte-fallback (`<0xNN>`) を自動除去/修復 |
+| **Wire 翻訳** | Anthropic 形式 ↔ OpenAI 形式を自動変換 (ネイティブ `/v1/messages` 対応 backend は passthrough で翻訳ゼロ) |
 
 ### 長時間運用ガード
 

{coderouter_cli-2.7.0 → coderouter_cli-2.7.1}/coderouter/config/capability_registry.py

@@ -115,6 +115,20 @@ class RegistryCapabilities(BaseModel):
             "startup check)."
         ),
     )
+    tool_choice: bool | None = Field(
+        default=None,
+        description=(
+            "S2 (shim): does the upstream honor a forced Anthropic "
+            "``tool_choice`` (``{type: any}`` / ``{type: tool}``) on the "
+            "wire? When True, the fallback engine's ``tool_choice_action`` "
+            "leaves the request untouched. ``None`` (default) = no opinion "
+            "→ the gate falls back to ``provider.kind == 'anthropic'``. "
+            "``False`` hard-disables even on an anthropic-kind provider "
+            "(useful when a specific model regresses). Independent from "
+            "``providers.yaml capabilities.tool_choice`` (explicit "
+            "per-provider opt-in, highest precedence)."
+        ),
+    )
     cache_control: bool | None = Field(
         default=None,
         description=(
@@ -201,6 +215,7 @@ class ResolvedCapabilities:
     max_context_tokens: int | None = None
     claude_code_suitability: Literal["ok", "degraded"] | None = None
     cache_control: bool | None = None
+    tool_choice: bool | None = None
 
 
 # ---------------------------------------------------------------------------
@@ -253,6 +268,7 @@ class CapabilityRegistry:
         resolved_max_ctx: int | None = None
         resolved_suitability: Literal["ok", "degraded"] | None = None
         resolved_cache_control: bool | None = None
+        resolved_tool_choice: bool | None = None
 
         thinking_locked = False
         reasoning_locked = False
@@ -260,6 +276,7 @@ class CapabilityRegistry:
         max_ctx_locked = False
         suitability_locked = False
         cache_control_locked = False
+        tool_choice_locked = False
 
         for rule in self._rules:
             if not rule.kind_matches(kind):
@@ -285,6 +302,9 @@ class CapabilityRegistry:
             if not cache_control_locked and caps.cache_control is not None:
                 resolved_cache_control = caps.cache_control
                 cache_control_locked = True
+            if not tool_choice_locked and caps.tool_choice is not None:
+                resolved_tool_choice = caps.tool_choice
+                tool_choice_locked = True
             if (
                 thinking_locked
                 and reasoning_locked
@@ -292,6 +312,7 @@ class CapabilityRegistry:
                 and max_ctx_locked
                 and suitability_locked
                 and cache_control_locked
+                and tool_choice_locked
             ):
                 break
 
@@ -302,6 +323,7 @@ class CapabilityRegistry:
             max_context_tokens=resolved_max_ctx,
             claude_code_suitability=resolved_suitability,
             cache_control=resolved_cache_control,
+            tool_choice=resolved_tool_choice,
         )
 
     # ------------------------------------------------------------------

{coderouter_cli-2.7.0 → coderouter_cli-2.7.1}/coderouter/config/schemas.py

@@ -43,6 +43,18 @@ class Capabilities(BaseModel):
     # you explicitly want the raw reasoning text to flow to the client
     # (e.g. CodeRouter is fronting a reasoning-aware downstream).
     reasoning_passthrough: bool = False
+    # S2 (shim): Anthropic's ``tool_choice`` forcing modes (``{type: any}``
+    # / ``{type: tool, name: ...}``). Only a subset of backends honor a
+    # forced tool_choice on the wire; openai_compat translation drops it.
+    # This narrow per-model flag mirrors ``thinking`` / ``prompt_cache``:
+    # when unset (None), the capability gate falls back to the registry and
+    # then to a ``kind == "anthropic"`` heuristic (see
+    # ``coderouter/routing/capability.py``). Motivation: let the fallback
+    # engine's ``tool_choice_action`` emulate forced tool calls via a
+    # system-prompt directive on backends that would otherwise silently
+    # ignore the field. Backward compatible — None leaves v2.x behavior
+    # untouched (no gate, no emulation).
+    tool_choice: bool | None = None
     # v1.0+ fields, declared early so providers.yaml can future-proof
     reasoning_control: Literal["none", "openai", "anthropic", "provider_specific"] = "none"
     mcp: Literal["none", "anthropic", "provider_specific"] = "none"
@@ -706,6 +718,72 @@ class FallbackChain(BaseModel):
         ),
     )
 
+    # --- S2 (shim): tool_choice capability gate + emulation -----------------
+    #
+    # Anthropic clients (Claude Code, SDKs) can pin the model to a specific
+    # tool with ``tool_choice: {type: "tool", name: "X"}`` or force *some*
+    # tool with ``{type: "any"}``. Native Anthropic honors this; most
+    # openai_compat backends silently ignore it after translation, so the
+    # model may answer with plain text where the client expected a tool
+    # call. This knob decides what the fallback engine does when a forced
+    # tool_choice request is routed to a provider that does not support it
+    # (per ``provider_supports_tool_choice``):
+    #
+    #   * ``off``     — no detection / no mutation / no log. Backward-compat
+    #                   default (identical to pre-shim behavior).
+    #   * ``warn``    — emit a ``capability-degraded`` log line only; the
+    #                   request is sent unchanged.
+    #   * ``emulate`` — strip the ``tool_choice`` field and inject an English
+    #                   directive into the system prompt instructing the
+    #                   model to call the requested tool. Best-effort
+    #                   forcing for backends without native support. The
+    #                   original request object is left untouched so a later
+    #                   capable provider in the chain still receives the real
+    #                   ``tool_choice``.
+    tool_choice_action: Literal["off", "warn", "emulate"] = Field(
+        default="off",
+        description=(
+            "S2 (shim): action when a request carries a forced "
+            "``tool_choice`` (``{type: any}`` or ``{type: tool}``) and the "
+            "target provider does not support it. ``off`` (default) leaves "
+            "the request unchanged. ``warn`` emits a ``capability-degraded`` "
+            "log only. ``emulate`` strips ``tool_choice`` and injects a "
+            "system-prompt directive to coax the model into calling the "
+            "tool. Per-provider — capable providers are never mutated."
+        ),
+    )
+
+    # --- S3 (shim): cache_control strip -------------------------------------
+    #
+    # By default cache_control markers are simply lost during Anthropic →
+    # OpenAI translation and the ``capability-degraded`` gate logs it
+    # (v0.5-B, observability only). Some strict openai_compat backends,
+    # however, 400 when an unexpected ``cache_control`` key rides along on a
+    # content block (rather than silently ignoring it). ``strip`` proactively
+    # removes those keys from a deep copy of the request before dispatch to
+    # a non-supporting provider, so the marker never reaches the wire.
+    #
+    #   * ``off``   — legacy behavior: leave the request as-is and rely on
+    #                 the existing ``capability-degraded`` observability log.
+    #   * ``strip`` — deep-copy the request and remove every ``cache_control``
+    #                 key from system / tools / message blocks before sending
+    #                 to a non-supporting provider; emit a
+    #                 ``cache-control-stripped`` log with the marker count.
+    #                 Does NOT emit a tokens-saved event (this is not token
+    #                 savings, just a wire-compatibility strip).
+    cache_control_action: Literal["off", "strip"] = Field(
+        default="off",
+        description=(
+            "S3 (shim): action when a request carries ``cache_control`` "
+            "markers and the target provider does not support them. ``off`` "
+            "(default) keeps legacy behavior (marker dropped in translation, "
+            "``capability-degraded`` log only). ``strip`` removes the "
+            "``cache_control`` keys from a deep copy before dispatch and "
+            "emits a ``cache-control-stripped`` log. Per-provider — capable "
+            "providers are never mutated."
+        ),
+    )
+
     @model_validator(mode="after")
     def _check_context_budget_thresholds_ordered(self) -> FallbackChain:
         """v2.0-F (mE): cross-field sanity of the context-budget ratios.

{coderouter_cli-2.7.0 → coderouter_cli-2.7.1}/coderouter/ingress/anthropic_routes.py

@@ -38,6 +38,8 @@ from coderouter.routing import (
     NoProvidersAvailableError,
 )
 from coderouter.routing.auto_router import RESERVED_PROFILE_NAME, classify
+from coderouter.token_estimation import extract_text_from_anthropic_request
+from coderouter.token_estimation_accurate import count_tokens, is_accuracy_available
 from coderouter.translation import (
     AnthropicRequest,
     AnthropicStreamEvent,
@@ -316,6 +318,112 @@ async def messages(
     return anth_resp.model_dump(exclude_none=True)
 
 
+def _resolve_count_tokens_tokenizer_path(
+    config: Any, profile: str | None
+) -> str | None:
+    """S1 (shim): best-effort resolve a local tokenizer.json for counting.
+
+    Routing for ``count_tokens`` is not a full chain resolution — we only
+    need *a* representative tokenizer for the profile the request would use.
+    We take the first provider of the resolved profile (or the default
+    profile) and return its ``tokenizer_path`` when declared. Any resolution
+    hiccup (unknown profile, empty chain, stub config in tests) returns
+    ``None``, which makes :func:`count_tokens` fall back to the char/4
+    heuristic — a graceful degrade rather than an error.
+    """
+    try:
+        chosen = profile or config.default_profile
+        chain_cfg = config.profile_by_name(chosen)
+        for pname in getattr(chain_cfg, "providers", []) or []:
+            pconf = next((p for p in config.providers if p.name == pname), None)
+            if pconf is not None:
+                tok = getattr(pconf, "tokenizer_path", None)
+                if tok:
+                    return tok
+                # First provider resolved but declares no tokenizer — stop
+                # here (don't scan the whole chain for an unrelated one).
+                return None
+    except (AttributeError, KeyError, ValueError, TypeError):
+        return None
+    return None
+
+
+@router.post("/messages/count_tokens", response_model=None)
+async def count_tokens_route(
+    payload: dict[str, Any],
+    request: Request,
+    x_coderouter_profile: str | None = Header(default=None, alias=_PROFILE_HEADER),
+    x_coderouter_mode: str | None = Header(default=None, alias=_MODE_HEADER),
+) -> dict[str, Any]:
+    """Anthropic ``POST /v1/messages/count_tokens`` — local token estimate.
+
+    Mirrors Anthropic's count_tokens endpoint: the request body has the
+    same shape as ``/v1/messages`` (minus the ``max_tokens`` requirement)
+    and the response is ``{"input_tokens": N}``. CodeRouter answers this
+    entirely locally — there is no upstream round-trip — using the same
+    text-extraction the language-tax / context-budget guards use, feeding
+    an accurate local tokenizer when the routed provider declares one and
+    the ``accuracy`` extra is installed, otherwise the char/4 heuristic.
+
+    Validation is deliberately looser than :class:`AnthropicRequest` (no
+    ``max_tokens`` needed): ``model`` and a non-empty ``messages`` list are
+    required, everything else optional. Profile selection follows the same
+    body > profile-header > mode-header precedence as ``/messages`` so the
+    tokenizer resolves against the provider the real request would hit.
+    """
+    config = request.app.state.config
+
+    if not isinstance(payload, dict):
+        raise HTTPException(status_code=400, detail="request body must be a JSON object")
+
+    messages = payload.get("messages")
+    if not isinstance(messages, list) or not messages:
+        raise HTTPException(
+            status_code=400,
+            detail="'messages' is required and must be a non-empty list",
+        )
+    if "model" not in payload:
+        raise HTTPException(status_code=400, detail="'model' is required")
+
+    # Profile selection — body field wins over header, mode header last
+    # (same policy as /messages). Kept minimal: we only need the profile to
+    # pick a representative tokenizer, so an unknown mode/profile degrades
+    # to the default rather than 400'ing the count.
+    profile = payload.get("profile") or x_coderouter_profile
+    if profile is None and x_coderouter_mode:
+        try:
+            profile = config.resolve_mode(x_coderouter_mode)
+        except (KeyError, AttributeError):
+            profile = None
+
+    # Combine system + messages (+ tool JSON length) into one text blob and
+    # count. tools contribute their JSON length as a coarse proxy for the
+    # schema tokens Anthropic would bill.
+    text = extract_text_from_anthropic_request(
+        system=payload.get("system"),
+        messages=messages,
+    )
+    tools = payload.get("tools")
+    if isinstance(tools, list) and tools:
+        with contextlib.suppress(TypeError, ValueError):
+            text = f"{text}\n{json.dumps(tools, ensure_ascii=False)}"
+
+    tokenizer_path = _resolve_count_tokens_tokenizer_path(config, profile)
+    input_tokens = count_tokens(text, tokenizer_path=tokenizer_path)
+    # Report the method count_tokens *actually* used: the accurate backend
+    # only engages when a path is declared AND the optional ``tokenizers``
+    # dependency is importable (see token_estimation_accurate). Otherwise
+    # count_tokens transparently falls back to char/4 — so we must too, or
+    # the log would misreport a heuristic count as tokenizer-accurate.
+    method = "tokenizer" if (tokenizer_path and is_accuracy_available()) else "heuristic"
+
+    logger.info(
+        "count-tokens-served",
+        extra={"method": method, "input_tokens": input_tokens},
+    )
+    return {"input_tokens": input_tokens}
+
+
 async def _anthropic_sse_iterator(
     engine: FallbackEngine, anth_req: AnthropicRequest
 ) -> AsyncIterator[str]:

{coderouter_cli-2.7.0 → coderouter_cli-2.7.1}/coderouter/logging.py

@@ -129,6 +129,7 @@ CapabilityDegradedReason = Literal[
     "provider-does-not-support",
     "translation-lossy",
     "non-standard-field",
+    "unsupported-backend",
 ]
 """Why a capability was degraded.
 
@@ -142,6 +143,10 @@ CapabilityDegradedReason = Literal[
 - ``non-standard-field``: upstream emits a field that is not in the spec
   the ingress speaks, so we strip it on the response-side boundary.
   v0.5-C reasoning field.
+- ``unsupported-backend``: the request asks for a semantic the target
+  backend does not honor (S2 forced ``tool_choice``); with action
+  ``warn`` the request is sent unchanged, with ``emulate`` a separate
+  ``tool-choice-emulated`` line records the substituted directive.
 """