coderouter-cli 2.5.4__py3-none-any.whl → 2.6.0__py3-none-any.whl

coderouter/config/schemas.py

@@ -185,6 +185,19 @@ class ProviderConfig(BaseModel):
     )
     timeout_s: float = Field(default=30.0, ge=1.0, le=600.0)
 
+    # v2.6 language-tax track: path to a LOCAL ``tokenizer.json`` for this
+    # provider's model, used to measure the CJK over-count vs the char/4
+    # baseline (see ``coderouter.language_tax``). Loaded local-file-only —
+    # never contacts the HuggingFace Hub. When unset, language-tax falls
+    # back to char/4 (multiplier 1.0) and the feature is silently inert.
+    tokenizer_path: str | None = Field(
+        default=None,
+        description=(
+            "Local tokenizer.json for accurate (language-tax) token "
+            "counting. No network access. Requires the 'accuracy' extra."
+        ),
+    )
+
     # Provider-specific extras merged into the outbound request body.
     # Use for non-standard fields like Ollama's `think: false`, `keep_alive`,
     # `options.num_ctx`, or any vendor-specific toggle. User-supplied request
@@ -763,6 +776,16 @@ class RuleMatcher(BaseModel):
       ``request.tools`` set). The ``has_tools`` matcher is the
       profile-level lever for steering tool-laden traffic to the right
       chain entirely.
+
+    Variants (v2.6 / language-tax routing):
+
+    - ``cjk_ratio_min: 0.3`` — CJK character ratio of the latest user
+      message is ``>=`` this threshold. Routes CJK-heavy turns (which
+      pay the cloud "language tax" of ~1.2-1.5x more tokens) to a local
+      model that bills nothing per token, while ASCII/code turns fall
+      through to the cloud chain. Per-turn property like
+      ``code_fence_ratio_min``; see
+      :func:`coderouter.language_tax.cjk_char_ratio`.
     """
 
     model_config = ConfigDict(extra="forbid")
@@ -773,6 +796,13 @@ class RuleMatcher(BaseModel):
     content_regex: str | None = None
     model_pattern: str | None = None
     content_token_count_min: int | None = Field(default=None, ge=1)
+    # v2.6 language-tax routing: CJK character ratio of the latest user
+    # message >= this threshold. Lets operators steer CJK-heavy traffic
+    # (which carries the cloud language tax) to a local model that bills
+    # nothing per token. Operates on the latest user message like
+    # ``code_fence_ratio_min`` (a per-turn property), not the whole
+    # request. See ``coderouter.language_tax.cjk_char_ratio``.
+    cjk_ratio_min: float | None = Field(default=None, ge=0.0, le=1.0)
     # [Unreleased]: tool-aware routing (OpenClaw + Raspberry Pi 由来).
     # See class docstring "Variants ([Unreleased] / tool-aware routing)"
     # above for the full rationale. Boolean shape mirrors ``has_image`` —
@@ -789,6 +819,7 @@ class RuleMatcher(BaseModel):
         "model_pattern",
         "content_token_count_min",
         "has_tools",
+        "cjk_ratio_min",
     )
 
     @model_validator(mode="after")

coderouter/cost.py

@@ -58,9 +58,13 @@ in the cost calc.
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 from coderouter.config.schemas import CostConfig
 
+if TYPE_CHECKING:  # avoid an import cycle at runtime; used only for typing
+    from coderouter.language_tax import LanguageTaxBreakdown
+
 
 @dataclass(frozen=True)
 class CostBreakdown:
@@ -82,6 +86,12 @@ class CostBreakdown:
             chart. ``input_usd`` is "fresh input only" (does not
             include cache buckets); cache_read_usd / cache_creation_usd
             are the post-discount / post-premium values.
+        language_tax_multiplier: ``tokens_accurate / tokens_heuristic``
+            for the request text (v2.6 language-tax track). 1.0 when no
+            tax is measurable (English/code, or no accurate tokenizer).
+        language_tax_usd: USD share of ``total_usd`` attributable to the
+            CJK over-count vs CodeRouter's char/4 English baseline.
+            0.0 for free / local providers. See :mod:`coderouter.language_tax`.
     """
 
     total_usd: float = 0.0
@@ -90,6 +100,10 @@ class CostBreakdown:
     output_usd: float = 0.0
     cache_read_usd: float = 0.0
     cache_creation_usd: float = 0.0
+    # v2.6 language-tax track (additive; defaults keep pre-v2.6 behaviour
+    # and equality with a bare ``CostBreakdown()``).
+    language_tax_multiplier: float = 1.0
+    language_tax_usd: float = 0.0
 
 
 _PER_MILLION: float = 1_000_000.0
@@ -102,6 +116,7 @@ def compute_cost_for_attempt(
     output_tokens: int,
     cache_read_input_tokens: int,
     cache_creation_input_tokens: int,
+    language_tax: LanguageTaxBreakdown | None = None,
 ) -> CostBreakdown:
     """Translate per-attempt token counts into a USD :class:`CostBreakdown`.
 
@@ -144,6 +159,21 @@ def compute_cost_for_attempt(
     full_rate_for_cache_read = safe_read * input_rate
     savings_usd = full_rate_for_cache_read - cache_read_usd
 
+    # v2.6 language tax: the share of fresh-input spend attributable to
+    # the CJK over-count vs the char/4 English baseline. Defaults to a
+    # 1.0 multiplier / $0 when no LanguageTaxBreakdown is supplied, so
+    # the pre-v2.6 call shape is unchanged.
+    lt_multiplier = 1.0
+    lt_usd = 0.0
+    if language_tax is not None:
+        lt_multiplier = language_tax.tax_multiplier
+        from coderouter.language_tax import language_tax_usd
+
+        lt_usd = language_tax_usd(
+            language_tax.extra_tokens,
+            input_tokens_per_million=cost_config.input_tokens_per_million,
+        )
+
     return CostBreakdown(
         total_usd=total_usd,
         savings_usd=max(savings_usd, 0.0),
@@ -151,4 +181,6 @@ def compute_cost_for_attempt(
         output_usd=output_usd,
         cache_read_usd=cache_read_usd,
         cache_creation_usd=cache_creation_usd,
+        language_tax_multiplier=lt_multiplier,
+        language_tax_usd=lt_usd,
     )

coderouter/ingress/dashboard_routes.py

@@ -165,6 +165,26 @@ _DASHBOARD_HTML = r"""<!doctype html>
   </main>
 
   <footer class="max-w-7xl mx-auto px-4 md:px-6 pb-8">
+    <!-- Panel: Cost & Language Tax (v2.6) -->
+    <section class="bg-slate-900/60 border border-slate-800 rounded-lg p-4 mb-4">
+      <h2 class="text-sm font-semibold uppercase tracking-wider text-slate-400 mb-3">Cost &amp; Language Tax</h2>
+      <div class="grid grid-cols-3 gap-3">
+        <div class="rounded-md bg-slate-800/50 p-3">
+          <div class="text-xs text-slate-400">Total spend</div>
+          <div class="text-2xl font-semibold tabnum" data-bind="cost_total">$0.00</div>
+        </div>
+        <div class="rounded-md bg-slate-800/50 p-3">
+          <div class="text-xs text-slate-400">Cache savings</div>
+          <div class="text-2xl font-semibold tabnum text-green-400" data-bind="cost_savings">$0.00</div>
+        </div>
+        <div class="rounded-md bg-slate-800/50 p-3">
+          <div class="text-xs text-slate-400">Language tax (CJK)</div>
+          <div class="text-2xl font-semibold tabnum text-amber-400" data-bind="language_tax_total">$0.00</div>
+          <div class="text-xs text-slate-500" data-bind="language_tax_hint">no tokenizer configured</div>
+        </div>
+      </div>
+      <div id="language-tax-by-provider" class="text-xs text-slate-400 tabnum mt-3"></div>
+    </section>
     <section class="bg-slate-900/60 border border-slate-800 rounded-lg p-4">
       <h2 class="text-sm font-semibold uppercase tracking-wider text-slate-400 mb-3">Usage Mix</h2>
       <div id="usage-bar" class="flex h-3 rounded-full overflow-hidden bg-slate-800" role="img" aria-label="usage mix"></div>
@@ -435,6 +455,27 @@ _DASHBOARD_HTML = r"""<!doctype html>
     {"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;"}[c]
   ));
 
+  // v2.6: cost + language-tax panel. The collector zero-fills these, so
+  // a fresh/local-only deployment shows $0.00 across the board.
+  const renderCostTax = (snap) => {
+    const c = snap.counters || {};
+    const usd = (x) => "$" + (Number(x) || 0).toFixed(4);
+    setBind("cost_total", usd(c.cost_total_usd_aggregate));
+    setBind("cost_savings", usd(c.cost_savings_usd_aggregate));
+    const taxTotal = Number(c.language_tax_usd_aggregate) || 0;
+    setBind("language_tax_total", usd(taxTotal));
+    setBind("language_tax_hint",
+      taxTotal > 0 ? "extra paid for CJK vs char/4 baseline"
+                   : "no tax measured (set provider tokenizer_path)");
+    const byProv = c.language_tax_usd || {};
+    const el = document.getElementById("language-tax-by-provider");
+    const rows = Object.entries(byProv).filter(([, v]) => Number(v) > 0);
+    el.innerHTML = rows.length === 0 ? "" :
+      rows.map(([n, v]) =>
+        '<span class="mr-4"><span class="text-slate-500">' + escapeHTML(n) +
+        '</span> ' + usd(v) + '</span>').join("");
+  };
+
   const renderSnapshot = (snap) => {
     const startup = snap.startup || {};
     const cfg = snap.config || {};
@@ -451,6 +492,7 @@ _DASHBOARD_HTML = r"""<!doctype html>
     renderSparkline(snap);
     renderRecent(snap);
     renderUsageMix(snap);
+    renderCostTax(snap);
   };
 
   const renderError = (msg) => {

coderouter/language_tax.py

@@ -0,0 +1,244 @@
+"""Language-tax measurement (Phase 1 PoC, 5-deps invariant).
+
+Why this module exists
+======================
+
+Cloud LLM tokenizers charge CJK text far more tokens-per-character
+than English. CodeRouter's core router uses a ``char/4`` heuristic
+(:mod:`coderouter.token_estimation`) which is *conservative for CJK*
+— i.e. it **under-counts** Japanese/Chinese/Korean text. That gap is
+the "language tax": a Japanese prompt that the heuristic prices at N
+tokens is actually billed at ~1.2-1.5x N by the cloud provider.
+
+Local models are unaffected (no per-token billing), so the tax only
+matters on the cloud leg. This module quantifies it so the cost
+tracker / dashboard can surface "how much extra am I paying to work
+in Japanese?".
+
+Design constraints (mirrors token_estimation_accurate.py)
+=========================================================
+
+* **No new core dependency.** CJK detection is pure ``str`` + Unicode
+  range checks (stdlib only). The *accurate* token count is delegated
+  to :func:`coderouter.token_estimation_accurate.count_tokens`, whose
+  precise backend (HuggingFace ``tokenizers``) is the existing
+  optional ``accuracy`` extra. When that backend is absent every
+  function still returns a sane value — the tax_multiplier simply
+  collapses to 1.0 because both legs use char/4.
+* **Local only / no network.** No tokenizer is ever downloaded; we
+  only pass through a caller-supplied local ``tokenizer.json`` path.
+* **Leaf module.** Imports only ``token_estimation`` /
+  ``token_estimation_accurate`` (both leaves), never the engine or
+  collector — keeps it trivially testable and circular-import-free.
+
+The tax multiplier, defined
+===========================
+
+``tax_multiplier = tokens_accurate / tokens_heuristic``
+
+where ``tokens_heuristic`` is the char/4 estimate (CodeRouter's
+English-calibrated baseline) and ``tokens_accurate`` is the real
+tokenizer count. Reading it:
+
+* English / code text → real tokenizers land near char/4, so the
+  multiplier is ~1.0 (no tax).
+* Japanese prose → real tokenizers emit ~0.5-1.0 tokens/char vs the
+  0.25 the heuristic assumes, so the multiplier lands ~2.0-4.0 on
+  *pure* CJK and ~1.2-1.5 on realistic mixed coding prompts (CJK
+  comments/instructions + ASCII code/identifiers).
+
+Confidence: **MODERATE.** char/4 is itself an approximation of
+English, so the multiplier is "tax relative to CodeRouter's own
+English baseline", not a lab-grade JA-vs-EN figure. It is, however,
+fully measurable with zero network and no guessing — which is why we
+prefer it to a translate-and-compare counterfactual.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from coderouter.token_estimation import (
+    CHARS_PER_TOKEN_HEURISTIC,
+    extract_text_from_anthropic_request,
+)
+from coderouter.token_estimation_accurate import count_tokens
+
+# ---------------------------------------------------------------------------
+# CJK Unicode ranges
+# ---------------------------------------------------------------------------
+#
+# We count a character as "CJK" when it falls in one of the blocks that
+# real tokenizers fragment heavily. Latin, digits, punctuation and
+# whitespace are excluded so that an ASCII-only prompt scores 0.0 and a
+# pure-Japanese prompt scores ~1.0. Half-width katakana and full-width
+# forms are included because they tokenize like their full-width kin.
+#
+# Ranges are (low, high) inclusive code points.
+_CJK_RANGES: tuple[tuple[int, int], ...] = (
+    (0x3040, 0x309F),  # Hiragana
+    (0x30A0, 0x30FF),  # Katakana
+    (0x3400, 0x4DBF),  # CJK Unified Ideographs Extension A
+    (0x4E00, 0x9FFF),  # CJK Unified Ideographs (common Kanji/Hanzi)
+    (0xF900, 0xFAFF),  # CJK Compatibility Ideographs
+    (0xFF00, 0xFFEF),  # Half/Full-width forms (full-width punct, half kana)
+    (0x3000, 0x303F),  # CJK symbols & punctuation (、。「」etc.)
+    (0xAC00, 0xD7A3),  # Hangul syllables (Korean)
+    (0x1100, 0x11FF),  # Hangul Jamo
+    (0x20000, 0x2A6DF),  # CJK Ext. B (rare ideographs)
+)
+
+
+def _is_cjk(cp: int) -> bool:
+    return any(low <= cp <= high for low, high in _CJK_RANGES)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def cjk_char_ratio(text: str) -> float:
+    """Fraction of *non-whitespace* characters in ``text`` that are CJK.
+
+    Whitespace is excluded from the denominator so that indentation /
+    blank lines in a code block don't dilute the score. Returns ``0.0``
+    for empty or whitespace-only / pure-ASCII text and ``1.0`` for pure
+    CJK. The value feeds the Phase-2 ``cjk_ratio_min`` auto-route
+    matcher and the Phase-1 reporting below.
+    """
+    if not text:
+        return 0.0
+    cjk = 0
+    total = 0
+    for ch in text:
+        if ch.isspace():
+            continue
+        total += 1
+        if _is_cjk(ord(ch)):
+            cjk += 1
+    if total == 0:
+        return 0.0
+    return cjk / total
+
+
+@dataclass(frozen=True)
+class LanguageTaxBreakdown:
+    """Per-text language-tax measurement.
+
+    Fields
+        char_count: non-whitespace-inclusive length of the text.
+        cjk_ratio: see :func:`cjk_char_ratio` (0.0-1.0).
+        tokens_heuristic: char/4 estimate (CodeRouter's English
+            baseline). Always available.
+        tokens_accurate: real tokenizer count when a ``tokenizer_path``
+            was supplied *and* the optional backend is installed;
+            otherwise equals ``tokens_heuristic`` (graceful fallback).
+        accurate_available: whether ``tokens_accurate`` came from the
+            precise backend (True) or fell back to char/4 (False).
+        tax_multiplier: ``tokens_accurate / tokens_heuristic``; 1.0
+            when no tax is measurable. See module docstring for the
+            MODERATE-confidence caveat.
+        extra_tokens: ``tokens_accurate - tokens_heuristic`` (>= 0 for
+            CJK; the visible "tax" in tokens).
+    """
+
+    char_count: int = 0
+    cjk_ratio: float = 0.0
+    tokens_heuristic: int = 0
+    tokens_accurate: int = 0
+    accurate_available: bool = False
+    tax_multiplier: float = 1.0
+    extra_tokens: int = 0
+
+
+def estimate_language_tax(
+    text: str,
+    *,
+    tokenizer_path: str | Path | None = None,
+) -> LanguageTaxBreakdown:
+    """Measure the language tax of ``text``.
+
+    With ``tokenizer_path`` pointing at a readable local
+    ``tokenizer.json`` (and the ``accuracy`` extra installed), the
+    accurate leg uses the real tokenizer and the multiplier reflects
+    the true char/4 under-count. Without it, both legs use char/4 and
+    the multiplier is 1.0 — the function never raises and never
+    touches the network.
+    """
+    if not text:
+        return LanguageTaxBreakdown()
+
+    heuristic = len(text) // CHARS_PER_TOKEN_HEURISTIC
+    accurate_raw = count_tokens(text, tokenizer_path=tokenizer_path)
+
+    # When the precise backend is unavailable, count_tokens returns the
+    # same char/4 value, so accurate == heuristic and we report no tax.
+    accurate_available = tokenizer_path is not None and accurate_raw != heuristic
+
+    # Guard against a zero-heuristic (text shorter than 4 chars) to keep
+    # the multiplier finite and meaningful.
+    if heuristic <= 0:
+        multiplier = 1.0
+        extra = max(accurate_raw - 0, 0)
+    else:
+        multiplier = accurate_raw / heuristic
+        extra = accurate_raw - heuristic
+
+    return LanguageTaxBreakdown(
+        char_count=len(text),
+        cjk_ratio=cjk_char_ratio(text),
+        tokens_heuristic=heuristic,
+        tokens_accurate=accurate_raw,
+        accurate_available=accurate_available,
+        tax_multiplier=multiplier,
+        extra_tokens=max(extra, 0),
+    )
+
+
+def language_tax_usd(
+    extra_tokens: int,
+    *,
+    input_tokens_per_million: float | None,
+) -> float:
+    """USD attributable to the language tax for one request leg.
+
+    ``extra_tokens`` is the :attr:`LanguageTaxBreakdown.extra_tokens`
+    delta; pricing is the provider's normal input rate. Returns 0.0 for
+    a free / unpriced (typically local) provider — mirroring
+    :func:`coderouter.cost.compute_cost_for_attempt`'s zero-on-None
+    behaviour so callers never special-case local models.
+    """
+    if not input_tokens_per_million or extra_tokens <= 0:
+        return 0.0
+    return extra_tokens * (input_tokens_per_million / 1_000_000.0)
+
+
+def estimate_language_tax_for_request(
+    system: Any,
+    messages: list[Any],
+    *,
+    tokenizer_path: str | Path | None = None,
+) -> LanguageTaxBreakdown:
+    """Measure the language tax of a whole Anthropic-shaped request.
+
+    Convenience wrapper used by the engine's cost-emit path: pulls the
+    concatenated request text (system + message text blocks) and runs it
+    through :func:`estimate_language_tax`. With no ``tokenizer_path`` the
+    multiplier is 1.0 (inert), so calling this on every request is safe
+    and cheap — the engine only invokes it when a provider declares a
+    local ``tokenizer.json``.
+    """
+    text = extract_text_from_anthropic_request(system=system, messages=messages)
+    return estimate_language_tax(text, tokenizer_path=tokenizer_path)
+
+
+__all__ = [
+    "LanguageTaxBreakdown",
+    "cjk_char_ratio",
+    "estimate_language_tax",
+    "estimate_language_tax_for_request",
+    "language_tax_usd",
+]

coderouter/logging.py

@@ -971,6 +971,10 @@ class CacheObservedPayload(TypedDict):
     streaming: bool
     cost_usd: float
     cost_savings_usd: float
+    # v2.6 language-tax track (optional; default 0.0 / 1.0 at the emit
+    # site keeps pre-v2.6 callers and log consumers working unchanged).
+    language_tax_usd: float
+    language_tax_multiplier: float
 
 
 def log_cache_observed(
@@ -986,6 +990,8 @@ def log_cache_observed(
     streaming: bool,
     cost_usd: float = 0.0,
     cost_savings_usd: float = 0.0,
+    language_tax_usd: float = 0.0,
+    language_tax_multiplier: float = 1.0,
 ) -> None:
     """Emit a ``cache-observed`` info record with the unified shape.
 
@@ -1013,6 +1019,8 @@ def log_cache_observed(
         "streaming": streaming,
         "cost_usd": cost_usd,
         "cost_savings_usd": cost_savings_usd,
+        "language_tax_usd": language_tax_usd,
+        "language_tax_multiplier": language_tax_multiplier,
     }
     logger.info("cache-observed", extra=payload)
 

coderouter/metrics/collector.py

@@ -190,6 +190,13 @@ class MetricsCollector(logging.Handler):
         self._cost_total_usd_aggregate: float = 0.0
         self._cost_savings_usd_aggregate: float = 0.0
 
+        # v2.6: per-provider language-tax spend — the USD share of input
+        # cost attributable to the CJK over-count vs the char/4 baseline.
+        # Zero for English/code workloads and for providers without a
+        # configured tokenizer_path. Surfaced alongside cost_total_usd.
+        self._language_tax_usd: dict[str, float] = {}
+        self._language_tax_usd_aggregate: float = 0.0
+
         # v2.0-F (L1): context budget guard counters. Per-profile counts
         # of warnings (over warn threshold) and trims (messages removed).
         # The ``latest_usage_ratio`` dict records the most recent ratio
@@ -388,6 +395,22 @@ class MetricsCollector(logging.Handler):
                         self._cost_savings_usd.get(provider, 0.0) + savings_usd
                     )
                     self._cost_savings_usd_aggregate += savings_usd
+
+                # v2.6: language-tax spend. Same defensive coercion as the
+                # cost fields; defaults to 0.0 for pre-v2.6 log lines and
+                # English/code traffic, so the aggregate only moves on
+                # CJK-heavy requests against a tokenizer-configured provider.
+                lt_usd_raw = extras.get("language_tax_usd", 0.0)
+                lt_usd = (
+                    float(lt_usd_raw)
+                    if isinstance(lt_usd_raw, int | float)
+                    else 0.0
+                )
+                if lt_usd > 0.0:
+                    self._language_tax_usd[provider] = (
+                        self._language_tax_usd.get(provider, 0.0) + lt_usd
+                    )
+                    self._language_tax_usd_aggregate += lt_usd
             elif event == "context-budget-warning":
                 # v2.0-F (L1): context usage exceeded the warn threshold.
                 # Track per-profile and aggregate, plus latest ratio gauge.
@@ -522,6 +545,10 @@ class MetricsCollector(logging.Handler):
                         "savings_usd": round(
                             self._cost_savings_usd.get(name, 0.0), 6
                         ),
+                        # v2.6: per-provider language-tax spend.
+                        "language_tax_usd": round(
+                            self._language_tax_usd.get(name, 0.0), 6
+                        ),
                     },
                 }
                 for name in providers
@@ -589,6 +616,14 @@ class MetricsCollector(logging.Handler):
                     "cost_savings_usd_aggregate": round(
                         self._cost_savings_usd_aggregate, 6
                     ),
+                    # v2.6: per-provider + aggregate language-tax spend.
+                    "language_tax_usd": {
+                        n: round(v, 6)
+                        for n, v in self._language_tax_usd.items()
+                    },
+                    "language_tax_usd_aggregate": round(
+                        self._language_tax_usd_aggregate, 6
+                    ),
                     # v2.0-F (L1): context budget guard aggregate counters.
                     "context_budget_warnings_total": self._context_budget_warnings_total,
                     "context_budget_trims_total": self._context_budget_trims_total,
@@ -682,6 +717,13 @@ class MetricsCollector(logging.Handler):
             self._cost_savings_usd_aggregate += float(
                 state.get("cost_savings_usd_aggregate", 0.0)
             )
+            for k, v in (state.get("language_tax_usd") or {}).items():
+                self._language_tax_usd[k] = (
+                    self._language_tax_usd.get(k, 0.0) + float(v)
+                )
+            self._language_tax_usd_aggregate += float(
+                state.get("language_tax_usd_aggregate", 0.0)
+            )
             self._chain_paid_gate_blocked_total += int(
                 state.get("chain_paid_gate_blocked_total", 0)
             )
@@ -737,6 +779,9 @@ class MetricsCollector(logging.Handler):
             self._cost_savings_usd.clear()
             self._cost_total_usd_aggregate = 0.0
             self._cost_savings_usd_aggregate = 0.0
+            # v2.6
+            self._language_tax_usd.clear()
+            self._language_tax_usd_aggregate = 0.0
             # v2.0-H (L6)
             self._partial_stitch_surfaced_total = 0
             # v2.0-I

coderouter/routing/auto_router.py

@@ -39,6 +39,7 @@ import re
 from typing import TYPE_CHECKING, Any
 
 from coderouter.config.schemas import AutoRouterConfig, AutoRouteRule, RuleMatcher
+from coderouter.language_tax import cjk_char_ratio
 from coderouter.token_estimation import estimate_tokens_from_body as _estimate_total_tokens
 
 if TYPE_CHECKING:
@@ -181,6 +182,12 @@ def _match_rule(
         return message is not None and _has_image(message)
     if m.code_fence_ratio_min is not None:
         return _code_fence_ratio(text) >= m.code_fence_ratio_min
+    if m.cjk_ratio_min is not None:
+        # v2.6: language-tax routing. CJK ratio of the latest user
+        # message — a per-turn property like code_fence_ratio_min, so it
+        # reuses ``text`` (latest user message) rather than walking the
+        # whole request. Steers CJK-heavy turns to a local, tax-free model.
+        return cjk_char_ratio(text) >= m.cjk_ratio_min
     if m.content_contains is not None:
         return m.content_contains in text
     if m.content_regex is not None:

coderouter/routing/fallback.py

@@ -61,6 +61,10 @@ from coderouter.guards.tool_loop import (
     detect_tool_loop,
     inject_loop_break_hint,
 )
+from coderouter.language_tax import (
+    LanguageTaxBreakdown,
+    estimate_language_tax_for_request,
+)
 from coderouter.logging import (
     classify_cache_outcome,
     get_logger,
@@ -372,6 +376,7 @@ def _emit_cache_observed(
     streaming: bool,
     provider_config: ProviderConfig | None = None,
     budget: BudgetTracker | None = None,
+    language_tax: LanguageTaxBreakdown | None = None,
 ) -> None:
     """Extract usage / cache fields from an AnthropicResponse and log them.
 
@@ -432,6 +437,7 @@ def _emit_cache_observed(
         output_tokens=usage.output_tokens,
         cache_read_input_tokens=cache_read,
         cache_creation_input_tokens=cache_creation,
+        language_tax=language_tax,
     )
 
     # v1.10: feed the per-provider monthly running total. The
@@ -452,6 +458,8 @@ def _emit_cache_observed(
         streaming=streaming,
         cost_usd=cost.total_usd,
         cost_savings_usd=cost.savings_usd,
+        language_tax_usd=cost.language_tax_usd,
+        language_tax_multiplier=cost.language_tax_multiplier,
     )
 
 
@@ -629,6 +637,7 @@ def _emit_cache_observed_streaming(
     request_had_cache_control: bool,
     provider_config: ProviderConfig | None = None,
     budget: BudgetTracker | None = None,
+    language_tax: LanguageTaxBreakdown | None = None,
 ) -> None:
     """Streaming counterpart of :func:`_emit_cache_observed` (v1.9-B2).
 
@@ -661,6 +670,7 @@ def _emit_cache_observed_streaming(
         output_tokens=output_tokens,
         cache_read_input_tokens=cache_read,
         cache_creation_input_tokens=cache_creation,
+        language_tax=language_tax,
     )
 
     # v1.10: same monthly-budget bookkeeping as the non-streaming
@@ -681,6 +691,8 @@ def _emit_cache_observed_streaming(
         streaming=True,
         cost_usd=cost.total_usd,
         cost_savings_usd=cost.savings_usd,
+        language_tax_usd=cost.language_tax_usd,
+        language_tax_multiplier=cost.language_tax_multiplier,
     )
 
 
@@ -2126,6 +2138,14 @@ class FallbackEngine:
             # outcome=unknown.
             # v1.9-D: also enrich the log line with per-attempt
             # USD cost + cache savings via the provider's CostConfig.
+            # v2.6 language tax: only measured when the provider declares
+            # a local tokenizer.json (else inert — no extra work, mult=1.0).
+            _lt = None
+            _tok = getattr(adapter.config, "tokenizer_path", None)
+            if _tok:
+                _lt = estimate_language_tax_for_request(
+                    request.system, request.messages, tokenizer_path=_tok
+                )
             _emit_cache_observed(
                 resp,
                 provider=adapter.name,
@@ -2133,6 +2153,7 @@ class FallbackEngine:
                 streaming=False,
                 provider_config=adapter.config,
                 budget=self._budget,
+                language_tax=_lt,
             )
             # v2.3.0: observer plugin fanout — fire-and-forget, never
             # blocks the engine response. Latency in ms uses the same
@@ -2359,12 +2380,21 @@ class FallbackEngine:
             # both go through ``classify_cache_outcome`` /
             # ``compute_cost_for_attempt`` for symmetric outcome and
             # cost reporting.
+            # v2.6 language tax: same opt-in measurement as the
+            # non-streaming sibling (inert unless tokenizer_path is set).
+            _lt_s = None
+            _tok_s = getattr(adapter.config, "tokenizer_path", None)
+            if _tok_s:
+                _lt_s = estimate_language_tax_for_request(
+                    request.system, request.messages, tokenizer_path=_tok_s
+                )
             _emit_cache_observed_streaming(
                 acc,
                 provider=adapter.name,
                 request_had_cache_control=request_had_cache_control,
                 provider_config=adapter.config,
                 budget=self._budget,
+                language_tax=_lt_s,
             )
             # v2.3.0: streaming observer fanout fires once, after the
             # SSE terminates successfully. We hand the accumulator's

coderouter/token_estimation.py

@@ -91,6 +91,21 @@ def _count_system_chars(system: Any) -> int:
     return 0
 
 
+def _extract_system_text(system: Any) -> str:
+    """Concatenate the system prompt text (str or list-of-blocks form)."""
+    if isinstance(system, str):
+        return system
+    if isinstance(system, list):
+        pieces: list[str] = []
+        for block in system:
+            if isinstance(block, dict):
+                text = block.get("text")
+                if isinstance(text, str):
+                    pieces.append(text)
+        return "\n".join(pieces)
+    return ""
+
+
 # ---------------------------------------------------------------------------
 # Public API
 # ---------------------------------------------------------------------------
@@ -153,9 +168,41 @@ def estimate_tokens_from_anthropic_request(
     return total_chars // CHARS_PER_TOKEN_HEURISTIC
 
 
+def extract_text_from_anthropic_request(
+    *,
+    system: Any,
+    messages: list[Any],
+) -> 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.
+    """
+    pieces: list[str] = []
+    sys_text = _extract_system_text(system)
+    if sys_text:
+        pieces.append(sys_text)
+    for msg in messages:
+        if hasattr(msg, "content"):
+            content = msg.content
+        elif isinstance(msg, dict):
+            content = msg.get("content")
+        else:
+            continue
+        text = _extract_text_from_content(content)
+        if text:
+            pieces.append(text)
+    return "\n".join(pieces)
+
+
 __all__ = [
     "CHARS_PER_TOKEN_HEURISTIC",
     "DEFAULT_MAX_CONTEXT_TOKENS",
     "estimate_tokens_from_anthropic_request",
     "estimate_tokens_from_body",
+    "extract_text_from_anthropic_request",
 ]

coderouter/translation/anthropic.py

@@ -10,9 +10,12 @@ through unchanged if a client sends them.
 
 from __future__ import annotations
 
+import logging
 from typing import Any, Literal
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+logger = logging.getLogger(__name__)
 
 # ============================================================
 # Content blocks
@@ -105,6 +108,113 @@ class AnthropicTool(BaseModel):
     input_schema: dict[str, Any] = Field(default_factory=dict)
 
 
+# ============================================================
+# Role normalization (Claude Code CLI >= 2.1.154 workaround)
+# ============================================================
+
+_SPEC_MESSAGE_ROLES = frozenset({"user", "assistant"})
+
+
+def _content_as_text(content: Any) -> str:
+    """Best-effort plain-text extraction from a message ``content`` field.
+
+    Strings pass through; block lists contribute their ``text`` blocks
+    joined with newlines; anything else yields "".
+    """
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                parts.append(str(block.get("text", "")))
+        return "\n".join(p for p in parts if p)
+    return ""
+
+
+def normalize_message_roles(payload: dict[str, Any]) -> dict[str, Any]:
+    """Normalize non-spec roles inside ``messages`` before validation.
+
+    Claude Code CLI >= 2.1.154 has a regression where it emits messages
+    with ``role: "system"`` (and reportedly ``ctx`` / ``msg``) inside the
+    ``messages`` array. The Anthropic Messages API spec allows only
+    ``user`` / ``assistant`` there, so without this hop those requests
+    die in validation with "Input should be 'user' or 'assistant'"
+    (see anthropics/claude-code#63469, vllm-project/vllm#44000).
+
+    Policy:
+        - ``role: "system"`` → text content merged into the top-level
+          ``system`` field (appended after any existing system prompt;
+          same join rule as ``convert.to_anthropic_request``).
+        - any other non-spec role (``ctx``, ``msg``, ...) → coerced to
+          ``user`` so conversation position is preserved. Anthropic
+          merges consecutive same-role turns, so this is safe.
+        - messages whose salvaged content is empty are dropped entirely
+          (Anthropic rejects empty turns).
+
+    Returns a shallow-copied payload; the caller's dict is not mutated.
+    Non-dict message entries (already-validated models) pass through.
+    """
+    messages = payload.get("messages")
+    if not isinstance(messages, list):
+        return payload
+
+    system_texts: list[str] = []
+    messages_out: list[Any] = []
+    coerced_roles: list[str] = []
+
+    for msg in messages:
+        if not isinstance(msg, dict):
+            # Already a validated AnthropicMessage (internal construction
+            # path, e.g. convert.to_anthropic_request) — spec roles only.
+            messages_out.append(msg)
+            continue
+        role = msg.get("role")
+        if role in _SPEC_MESSAGE_ROLES:
+            messages_out.append(msg)
+            continue
+        if role == "system":
+            text = _content_as_text(msg.get("content"))
+            if text:
+                system_texts.append(text)
+            coerced_roles.append("system")
+            continue
+        # Unknown role (ctx / msg / future surprises): keep its position
+        # in the conversation as a user turn; drop if nothing salvageable.
+        text = _content_as_text(msg.get("content"))
+        coerced_roles.append(str(role))
+        if text:
+            messages_out.append({"role": "user", "content": text})
+
+    if not coerced_roles:
+        return payload
+
+    out = dict(payload)
+    out["messages"] = messages_out
+
+    if system_texts:
+        joined = "\n".join(system_texts)
+        existing = out.get("system")
+        if existing is None:
+            out["system"] = joined
+        elif isinstance(existing, str):
+            out["system"] = f"{existing}\n{joined}" if existing else joined
+        elif isinstance(existing, list):
+            out["system"] = [*existing, {"type": "text", "text": joined}]
+        else:  # unexpected shape — don't lose the client's value
+            out["system"] = existing
+
+    logger.warning(
+        "normalized-nonspec-message-roles",
+        extra={
+            "roles": coerced_roles,
+            "system_merged": bool(system_texts),
+            "hint": "client is likely Claude Code CLI >= 2.1.154 (known regression)",
+        },
+    )
+    return out
+
+
 # ============================================================
 # Request
 # ============================================================
@@ -147,6 +257,19 @@ class AnthropicRequest(BaseModel):
     # `thinking` beyond what the default minor version accepts.
     anthropic_beta: str | None = Field(default=None, exclude=True)
 
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_roles(cls, data: Any) -> Any:
+        """Claude Code >= 2.1.154 sends system/ctx/msg roles in messages.
+
+        Normalize them before field validation so the request doesn't
+        422 at ingress (and doesn't 400 upstream at api.anthropic.com
+        via the native adapter). See ``normalize_message_roles``.
+        """
+        if isinstance(data, dict):
+            return normalize_message_roles(data)
+        return data
+
 
 # ============================================================
 # Response

{coderouter_cli-2.5.4.dist-info → coderouter_cli-2.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 2.5.4
+Version: 2.6.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.5.4.dist-info → coderouter_cli-2.6.0.dist-info}/RECORD

@@ -2,16 +2,17 @@ coderouter/__init__.py,sha256=ghdjPrLtnRzY8fyQ4CJZI1UJKADyNTLtA3G7se8H7Ns,696
 coderouter/__main__.py,sha256=-LCgxJnvgUV240HjQKv7ly-mn2NuKHpC4nCpvTHjeSU,130
 coderouter/cli.py,sha256=KE49IACJVw692H6dlfu1tAah1jQgbwH92F4lCkhRk6U,28168
 coderouter/cli_stats.py,sha256=CCjzc1G4hTRHZ2gG1XhxhDpUkJnnl3NXbcbp1T18jpg,29894
-coderouter/cost.py,sha256=jf70XTTjEfWddHkOohErqSo5TfmIG42zQpBT_5faPNA,5881
+coderouter/cost.py,sha256=32h6uzb4nxh2eA5d2Hn3kD9yJbtis6CFDAbeIy5KRkM,7431
 coderouter/doctor.py,sha256=2luNk6BHSRvpQStJnHcqzNvNi-SKdOuKV0WZdorZhVk,82854
 coderouter/doctor_apply.py,sha256=r_J6xbu5-HivofPNriw4_vjNYs_VRs7GsGTS0oMEX10,24209
 coderouter/env_security.py,sha256=FEBZnXfJ0xE39kmMMn39zk0W_DRRnmcB_REmP9f4xWo,14796
 coderouter/errors.py,sha256=Xmq67lheyw8iv3Ox39jh2c4tvNI5RcUR4QkoxVDN6l4,1130
 coderouter/gguf_introspect.py,sha256=FZO14STLSp94Rfo5AInGwYUOpfjiXOW6CH5RiczTWDE,9514
 coderouter/hardware.py,sha256=gn3_9qbVcGRR81yKMn1lJE_8-YDRau0LxIH_M-f7pxE,8356
-coderouter/logging.py,sha256=U7QiGRaoQXTSGijc-jV9TebnbbzrD-snfnoZy73Nvwo,52737
+coderouter/language_tax.py,sha256=LTbE3tIfoJuV2O3T0NixRKhzq_dEOTUuPEerJv2q9uk,9360
+coderouter/logging.py,sha256=63_aaXuZwk_jboDGUrfFjZV65SGvcqhW3dcj12AqUcA,53126
 coderouter/output_filters.py,sha256=0ry_rPiS_kC-FnHgaNVP6v7e6Al2djxzu9vBzZ8kEkE,25314
-coderouter/token_estimation.py,sha256=1Ai1uT68hahpyr4LBhNyVRGq7y4yXItd6J4k5ApGX7M,5995
+coderouter/token_estimation.py,sha256=iz22vZEEW2P7uKLB2pYvPNpIbZGbgXRO5MtfkS_-9Sk,7531
 coderouter/token_estimation_accurate.py,sha256=GTfzrBVnvAGjeVzmzAeUdOYZvWZKLAxcxPpFiJGlzjk,4609
 coderouter/adapters/__init__.py,sha256=7dIDSZ-FE_0iSqLSDc_lK1idRdLTKcM2hP9tCJipgPI,463
 coderouter/adapters/anthropic_native.py,sha256=qfdjxy4YyLt-0Fj7hUYn1oi1SFjEEbSvpaRBUC2hMf4,21903
@@ -22,7 +23,7 @@ coderouter/config/__init__.py,sha256=FODEn74fN-qZnt4INPSHswqhOlEgpL6-_onxsitSx8g
 coderouter/config/capability_registry.py,sha256=QRJLlzqKTdb2ndpWAHGZQJq23wczEfzSVanKnoqJrg4,15815
 coderouter/config/env_file.py,sha256=CoMK27fuAXm-NtoLzXb8yN2E-wDFjHQuFwiIlmgTBQw,10356
 coderouter/config/loader.py,sha256=FUEe8m4Tnmj_aul0vSctD8vKvNW-oLRoMRbTpSKqSmc,4077
-coderouter/config/schemas.py,sha256=XsOGooItlHSXIfkE6LJbZY6vOo3uRkxUoTOt03mQARI,60423
+coderouter/config/schemas.py,sha256=ROFU3TdH4WanK63US6PRCLAMRUZBKFNlIoguXTYo6L0,62026
 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
@@ -39,12 +40,12 @@ coderouter/guards/tool_loop.py,sha256=EzeMcmU7BLeTW2jsRVevU81l5rhWcn1oUr7EpzgXjV
 coderouter/ingress/__init__.py,sha256=WQsCH2CGJCAhy0mS6GSEdeYZRkkQu2OHDsP4CJWTLug,155
 coderouter/ingress/anthropic_routes.py,sha256=It2f7XGe3fgKQX01J2F5JOCoZr96t_Tx_kY2om99MVo,16894
 coderouter/ingress/app.py,sha256=PcuTvUFNjr04EbsUOu8qdyKTdBzxkIJYB4xpz8dFfMo,12635
-coderouter/ingress/dashboard_routes.py,sha256=rscoj89weHTfc8QmYk-fof-7062rhKFHVHRA8cDImDI,21931
+coderouter/ingress/dashboard_routes.py,sha256=tEIayMHxCzlmpnLyKHgpqrE4W24DTJM97ewTlYvkKqI,24238
 coderouter/ingress/launcher_routes.py,sha256=Jh-E6qFmHnr7ON4W6QanafxQIoojT4F034mybLvhTyQ,47548
 coderouter/ingress/metrics_routes.py,sha256=M22dwOGn24P05Ge4W3c7d7mYytSGWjIR-pPSPOAiHJY,3965
 coderouter/ingress/openai_routes.py,sha256=Zw1efPw9DI6GgV8ZcLrzS6Cda0KLrFkKn2GBZWSe6Vo,6322
 coderouter/metrics/__init__.py,sha256=7Es351DPS7yLM0yVF_F0eesmiD83n7Zzhie44chht38,1465
-coderouter/metrics/collector.py,sha256=Q0_CY0orX8_i0EICBME5sYW2RqL2VD4SpNs8qfCnBM0,47432
+coderouter/metrics/collector.py,sha256=9lKnaFpdlu8R9mRUeyAeJWXR1urRCKt_6sUFn_9ybss,49657
 coderouter/metrics/prometheus.py,sha256=YRqyT931s40zVkIj07D-M2UNfDhIEElVFRz3izdJcnQ,24419
 coderouter/plugins/__init__.py,sha256=76hMLe5dV_ilripHXzWn3HSYoIALjzlw4EJVyI-GyIM,1974
 coderouter/plugins/base.py,sha256=n9hsck2NCSqi6oeHIumKC5zhQ8JGwCXUz7J5AZQCQss,5772
@@ -52,10 +53,10 @@ coderouter/plugins/loader.py,sha256=xAIf6bIuth0QXCzwxO_ja6aSUlLzIqZNbrbQNJDgSE8,
 coderouter/plugins/registry.py,sha256=Tx0QHJHozZ5LTUliGylBdNVcdzHTBV0nedCUwGlbLMM,3236
 coderouter/routing/__init__.py,sha256=g2vhutbozRx5QBThReqwPN3imk5qXdpDiaogILd3IRc,257
 coderouter/routing/adaptive.py,sha256=G2o377twGSjbUh65wiIFx6klnpFGjsD_nI3oDvcBwhY,21257
-coderouter/routing/auto_router.py,sha256=4_sQR0ztSED9FgQSvQqgqSiydyQVY_qOSRvwyZ5BfRc,12909
+coderouter/routing/auto_router.py,sha256=y4v0c8u5F9f98Vmhx1vRcKPiOgAvpzbFqr6TIh058h0,13341
 coderouter/routing/budget.py,sha256=PblmVKJGs_BwNa9uDHAA8hmZ4XIVKv38mHAeU0V3OMs,8451
 coderouter/routing/capability.py,sha256=DCDmiQ-78dkYonCM1WQBCMf6e6XI6VIv_cnuz9hdWT0,18443
-coderouter/routing/fallback.py,sha256=P3f6Yna1EGnLAT-ZS5ADrrZ-qRWc-M5xvwEuan4rmcs,104568
+coderouter/routing/fallback.py,sha256=Tu7vNDvGDD9EeGDEvAVZfJB2KmXM3ZulZbYlB9F-zdM,105962
 coderouter/state/__init__.py,sha256=XoGcPmmBQSiZWML2S0juSveQ78xfhtdeCliNnVyzu7E,1088
 coderouter/state/audit_log.py,sha256=JwGd0OkkDlkh0Fdc6SmnuyViwKzEaFA7Ux_VqHzakWE,8358
 coderouter/state/replay.py,sha256=Z_YHKroTKZdrL8qObFxcoLOAQWWXZvXFdLfxzvBhEJg,11230
@@ -63,11 +64,11 @@ coderouter/state/request_log.py,sha256=bR814sOn--U_sKVtbezwS3bkZaNt4FGnboX75_2LL
 coderouter/state/store.py,sha256=h-rsMJq8GILsOfCP94nI40cuHaj4Vqycsm9UNN77REI,7445
 coderouter/state/suggest_rules.py,sha256=FvdhEvao5NvdKp9zs8AkcoFKHY4yqqXY2HekvSjpDFA,16670
 coderouter/translation/__init__.py,sha256=PYXN7XVEwpG1uC8RLy6fvnGbzEZhhrEuUapH8IYOtG8,1788
-coderouter/translation/anthropic.py,sha256=JpvIWNXHUPVqOGvps7o_6ZADhXuJuvpU7RdMqQFtwwM,6421
+coderouter/translation/anthropic.py,sha256=aZkcYH4x82b0x7efJgJb9RWn9Hbyc9pEOthXe4vjUdU,11113
 coderouter/translation/convert.py,sha256=-qyzFzmmr9hhQV6_Sg75kJnvCZvHe3n7vRdaZtk_JqQ,47269
 coderouter/translation/tool_repair.py,sha256=Ok2PF947Liegc5oaytfptv5MWMkpfJYQie-zdP1y3cY,9946
-coderouter_cli-2.5.4.dist-info/METADATA,sha256=cpwFo9rILUr99bq2K1bRH62s-hhVQqmed4psTvG-XFM,11674
-coderouter_cli-2.5.4.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-coderouter_cli-2.5.4.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
-coderouter_cli-2.5.4.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
-coderouter_cli-2.5.4.dist-info/RECORD,,
+coderouter_cli-2.6.0.dist-info/METADATA,sha256=us2o2_EtIlzd2EjQqAqtKIX1ocpAD3YcaDiZKOG6ktE,11674
+coderouter_cli-2.6.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+coderouter_cli-2.6.0.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
+coderouter_cli-2.6.0.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
+coderouter_cli-2.6.0.dist-info/RECORD,,