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

coderouter/cli.py

@@ -600,28 +600,27 @@ def _run_check_model(args: argparse.Namespace) -> int:
 
 
 def _resolve_config_path(explicit: str | None) -> Path:
-    """Mirror loader._candidate_paths and return the file actually used.
-
-    Used by ``--apply`` to write back to the same path the loader
-    picked up when it parsed providers.yaml. Falls through the same
-    search order so a ``CODEROUTER_CONFIG`` env or default-path lookup
-    matches the live config.
+    """Return the file the loader actually read, for ``--apply`` write-back.
+
+    Delegates the search order to
+    :func:`coderouter.config.loader.resolve_config_path` rather than
+    re-implementing it. Re-implementing it here is exactly how the
+    v2.13.0 CWD opt-in change would introduce a silent bug: if the loader
+    gates ``./providers.yaml`` behind ``CODEROUTER_ALLOW_CWD_CONFIG`` but
+    this copy still searched CWD unconditionally, ``doctor --apply`` would
+    write patches back into a file that ``load_config`` never read. Keeping
+    one source of truth makes that impossible.
+
+    When nothing exists, falls back to ``~/.coderouter/providers.yaml``
+    (the loader's last candidate) — the apply step surfaces a clearer
+    error against that path than this resolver would.
     """
-    import os
-
-    candidates: list[Path] = []
-    if explicit:
-        candidates.append(Path(explicit))
-    if env_path := os.environ.get("CODEROUTER_CONFIG"):
-        candidates.append(Path(env_path))
-    candidates.append(Path.cwd() / "providers.yaml")
-    candidates.append(Path.home() / ".coderouter" / "providers.yaml")
-    for p in candidates:
-        if p.is_file():
-            return p
-    # Fall back to the last candidate even if absent — the apply step
-    # will surface a clearer error than this resolver would.
-    return candidates[-1]
+    from coderouter.config.loader import resolve_config_path
+
+    resolved = resolve_config_path(explicit)
+    if resolved is not None:
+        return resolved
+    return Path.home() / ".coderouter" / "providers.yaml"
 
 
 def _write_verdict_line(*, write: bool, files_written: int) -> None:

coderouter/config/loader.py

@@ -3,21 +3,26 @@
 Search order (first hit wins):
     1. Path passed explicitly (CLI --config flag)
     2. $CODEROUTER_CONFIG env var
-    3. ./providers.yaml (current working dir)
+    3. ./providers.yaml (current working dir) — opt-in since v2.13.0,
+       gated behind ``CODEROUTER_ALLOW_CWD_CONFIG`` (truthy: 1/true/yes/on)
     4. ~/.coderouter/providers.yaml
 
 Secrets are resolved by reading the env var named by `api_key_env`.
 
 .. note::
-    **[Unreleased] deprecation notice (planned v2.12.0):** step 3 above
-    (implicit CWD discovery) is slated to become opt-in, gated behind
-    ``CODEROUTER_ALLOW_CWD_CONFIG``. Landing that change without warning
-    first would silently break anyone currently relying on "run from the
-    directory with providers.yaml in it" with no diagnostic. Until that
-    lands, :func:`load_config` emits a one-time ``cwd-config-loaded``
-    warning whenever step 3 is the one that actually resolved — never
-    when an explicit ``--config`` / ``CODEROUTER_CONFIG`` path was used,
-    even if it happens to point at the same file.
+    **v2.13.0 (security):** step 3 above (implicit CWD discovery) is now
+    opt-in, gated behind ``CODEROUTER_ALLOW_CWD_CONFIG``. It was a code
+    execution vector: a hostile ``providers.yaml`` dropped into a repo
+    could steer ``restart_command`` / ``launcher.backends[*].binary`` /
+    ``launcher.bench.command_template`` — all of which name executables —
+    simply because CodeRouter happened to be started from that directory.
+    When the opt-in is enabled and step 3 resolves the config, a one-time
+    ``cwd-config-loaded`` warning fires (never when an explicit
+    ``--config`` / ``CODEROUTER_CONFIG`` path was used, even if it happens
+    to point at the same file). When the opt-in is NOT set but a
+    ``./providers.yaml`` exists and was not explicitly named, a one-time
+    ``cwd-config-skipped`` warning fires so the operator understands why
+    that file was ignored.
 """
 
 from __future__ import annotations
@@ -32,10 +37,25 @@ from coderouter.logging import get_logger
 
 logger = get_logger(__name__)
 
-# Guards the one-time [Unreleased]/v2.12.0 CWD-config deprecation warning
-# (see module docstring) so a process that calls load_config() repeatedly
-# (tests, hot-reload, multiple create_app() calls) only logs it once.
+# Name of the env var that opts CWD ``providers.yaml`` discovery back in
+# (see module docstring). v2.13.0 gates step 3 of the search behind it.
+CWD_CONFIG_ENV = "CODEROUTER_ALLOW_CWD_CONFIG"
+# Truthy vocabulary shared by every CWD-opt-in / ALLOW_PAID style toggle.
+_TRUTHY = {"1", "true", "yes", "on"}
+
+# Guards the one-time ``cwd-config-loaded`` warning (opt-in enabled and the
+# CWD step actually resolved) so a process that calls load_config()
+# repeatedly (tests, hot-reload, multiple create_app() calls) only logs it
+# once.
 _cwd_config_warning_emitted = False
+# Guards the one-time ``cwd-config-skipped`` warning (opt-in NOT set but a
+# ./providers.yaml exists and was ignored) — same once-per-process rationale.
+_cwd_config_skip_warning_emitted = False
+
+
+def cwd_config_allowed() -> bool:
+    """True iff the CWD ``providers.yaml`` opt-in is enabled (v2.13.0)."""
+    return os.environ.get(CWD_CONFIG_ENV, "").strip().lower() in _TRUTHY
 
 
 def _candidate_paths(explicit: str | os.PathLike[str] | None) -> list[Path]:
@@ -44,27 +64,58 @@ def _candidate_paths(explicit: str | os.PathLike[str] | None) -> list[Path]:
         paths.append(Path(explicit))
     if env_path := os.environ.get("CODEROUTER_CONFIG"):
         paths.append(Path(env_path))
-    paths.append(Path.cwd() / "providers.yaml")
+    # v2.13.0: implicit CWD discovery is opt-in — a hostile providers.yaml
+    # dropped into a repo could otherwise steer restart_command / launcher
+    # binaries simply because CodeRouter was started from that directory.
+    if cwd_config_allowed():
+        paths.append(Path.cwd() / "providers.yaml")
     paths.append(Path.home() / ".coderouter" / "providers.yaml")
     return paths
 
 
+def resolve_config_path(
+    explicit: str | os.PathLike[str] | None = None,
+) -> Path | None:
+    """Return the config file the loader would pick, or None if none exists.
+
+    Single source of truth for the search order so callers (e.g.
+    ``coderouter.cli._resolve_config_path`` driving ``doctor --apply``)
+    never re-implement it. Re-implementing it risks writing back to a
+    different file than the one :func:`load_config` actually read — the
+    exact regression the v2.13.0 CWD opt-in would otherwise introduce.
+    """
+    return next((p for p in _candidate_paths(explicit) if p.is_file()), None)
+
+
+def _explicitly_named(
+    path: Path, explicit: str | os.PathLike[str] | None
+) -> bool:
+    """True iff ``path`` matches the literal --config or CODEROUTER_CONFIG value.
+
+    Used to keep the CWD warnings quiet when ``./providers.yaml`` was
+    chosen on purpose (an explicit choice, however coincidental, is not
+    the implicit-discovery behaviour being gated).
+    """
+    if explicit and Path(explicit) == path:
+        return True
+    env_path = os.environ.get("CODEROUTER_CONFIG")
+    return env_path is not None and Path(env_path) == path
+
+
 def _warn_if_cwd_config(
     chosen: Path, *, explicit: str | os.PathLike[str] | None
 ) -> None:
-    """Emit the one-time [Unreleased]/v2.12.0 CWD-config deprecation warning.
+    """Emit the one-time ``cwd-config-loaded`` warning (opt-in is enabled).
 
     Only fires when ``chosen`` was resolved via the *implicit* CWD-search
-    step. Compares ``chosen`` against the *literal* explicit / env
-    candidate paths (not merely whether those inputs were set) so that:
-
-      * an explicit ``--config`` (or ``CODEROUTER_CONFIG``) path that
-        happens to coincide with ``./providers.yaml`` stays quiet — an
-        explicit choice, however coincidental, is not the thing being
-        deprecated; but
-      * an explicit path/env var that was set but did NOT resolve (file
-        missing, so the search fell through to CWD) still warns, because
-        the CWD step is what actually served the config in that case.
+    step — which, since v2.13.0, only runs when
+    ``CODEROUTER_ALLOW_CWD_CONFIG`` is set. Compares ``chosen`` against the
+    *literal* explicit / env candidate paths (not merely whether those
+    inputs were set) so that an explicit ``--config`` (or
+    ``CODEROUTER_CONFIG``) path that happens to coincide with
+    ``./providers.yaml`` stays quiet, while an explicit path/env var that
+    was set but did NOT resolve (file missing, search fell through to CWD)
+    still warns — the CWD step is what actually served the config there.
     """
     global _cwd_config_warning_emitted
     if _cwd_config_warning_emitted:
@@ -72,9 +123,7 @@ def _warn_if_cwd_config(
     cwd_path = Path.cwd() / "providers.yaml"
     if chosen != cwd_path:
         return
-    if explicit and Path(explicit) == chosen:
-        return
-    if (env_path := os.environ.get("CODEROUTER_CONFIG")) and Path(env_path) == chosen:
+    if _explicitly_named(chosen, explicit):
         return
 
     _cwd_config_warning_emitted = True
@@ -84,26 +133,76 @@ def _warn_if_cwd_config(
             "path": str(chosen),
             "hint": (
                 f"loaded providers.yaml from the current working "
-                f"directory ({chosen}). Starting in v2.12.0, this "
-                "implicit CWD discovery becomes opt-in (gated behind "
-                "CODEROUTER_ALLOW_CWD_CONFIG) — pass --config or set "
-                "CODEROUTER_CONFIG to pin the file explicitly and avoid "
-                "a startup break when that lands."
+                f"directory ({chosen}) because CODEROUTER_ALLOW_CWD_CONFIG "
+                "opt-in is enabled. This file's restart_command / "
+                "launcher.backends[*].binary / "
+                "launcher.bench.command_template decide which executables "
+                "run — only enable the opt-in in directories you trust."
             ),
         },
     )
 
 
+def _warn_if_cwd_config_skipped(
+    explicit: str | os.PathLike[str] | None,
+) -> Path | None:
+    """Warn once when a ./providers.yaml exists but was skipped (no opt-in).
+
+    Returns the skipped CWD path (so :func:`load_config` can name it in a
+    later ``FileNotFoundError``), or None when there is nothing to skip:
+    the opt-in is enabled, no ``./providers.yaml`` exists, or the file was
+    explicitly named (``--config`` / ``CODEROUTER_CONFIG``) — in which case
+    it is not being skipped at all.
+    """
+    global _cwd_config_skip_warning_emitted
+    if cwd_config_allowed():
+        return None
+    cwd_path = Path.cwd() / "providers.yaml"
+    if not cwd_path.is_file():
+        return None
+    if _explicitly_named(cwd_path, explicit):
+        return None
+
+    if not _cwd_config_skip_warning_emitted:
+        _cwd_config_skip_warning_emitted = True
+        logger.warning(
+            "cwd-config-skipped",
+            extra={
+                "path": str(cwd_path),
+                "hint": (
+                    f"found providers.yaml in the current working "
+                    f"directory ({cwd_path}) but did NOT load it: implicit "
+                    "CWD discovery is opt-in since v2.13.0 (a hostile "
+                    "providers.yaml can steer restart_command / launcher "
+                    "binaries). To use it, set CODEROUTER_ALLOW_CWD_CONFIG=1 "
+                    "(only in directories you trust) or pass --config "
+                    f"{cwd_path} to name it explicitly."
+                ),
+            },
+        )
+    return cwd_path
+
+
 def load_config(path: str | os.PathLike[str] | None = None) -> CodeRouterConfig:
     """Load providers.yaml + apply ALLOW_PAID env override."""
+    skipped_cwd = _warn_if_cwd_config_skipped(path)
     candidates = _candidate_paths(path)
     chosen: Path | None = next((p for p in candidates if p.is_file()), None)
     if chosen is None:
         searched = "\n  ".join(str(p) for p in candidates)
-        raise FileNotFoundError(
+        message = (
             f"providers.yaml not found. Searched:\n  {searched}\n"
             f"Hint: copy examples/providers.yaml to ~/.coderouter/providers.yaml"
         )
+        if skipped_cwd is not None:
+            message += (
+                f"\nNote: {skipped_cwd} exists but was NOT read — implicit "
+                "CWD discovery is opt-in since v2.13.0. Three ways to use "
+                f"it: pass --config {skipped_cwd}, set "
+                f"CODEROUTER_CONFIG={skipped_cwd}, or set "
+                "CODEROUTER_ALLOW_CWD_CONFIG=1 (only in directories you trust)."
+            )
+        raise FileNotFoundError(message)
     _warn_if_cwd_config(chosen, explicit=path)
 
     with chosen.open("r", encoding="utf-8") as f:

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__)
 
@@ -354,15 +355,20 @@ class AgentCliConfig(BaseModel):
         return self
 
 
-# [Unreleased]/planned v2.12.0: patterns used by ProviderConfig's
+# v2.13.0: patterns used by ProviderConfig's
 # ``_warn_restart_command_shell_syntax`` validator to flag
-# ``restart_command`` values that rely on shell syntax not honored by
-# the planned ``shlex.split`` + ``shell=False`` dispatch (see that
-# validator's docstring and the field description below for the full
-# rationale). Compiled once at module scope since every ProviderConfig
-# validation reuses them.
-_RESTART_COMMAND_SHELL_META_RE = re.compile(r"(&&|\|\||\||;|>|<|\$\(|`)")
-_RESTART_COMMAND_ENV_PREFIX_RE = re.compile(r"^\w+=")
+# ``restart_command`` values that rely on shell syntax not honored by the
+# ``shlex.split`` + ``shell=False`` dispatch (see that validator's
+# docstring and the field description below for the full rationale).
+# Public (no leading underscore) because ``coderouter.guards.self_healing``
+# imports ``RESTART_COMMAND_SHELL_META_RE`` to *refuse* to run any
+# restart_command containing shell metacharacters — under shell=False a
+# value like ``touch a; b`` would create a file literally named ``a;`` and
+# exit 0, i.e. report a "successful" restart while only half-executing.
+# Compiled once at module scope since every ProviderConfig validation
+# reuses them.
+RESTART_COMMAND_SHELL_META_RE = re.compile(r"(&&|\|\||\||;|>|<|\$\(|`)")
+RESTART_COMMAND_ENV_PREFIX_RE = re.compile(r"^\w+=")
 
 
 class ProviderConfig(BaseModel):
@@ -519,54 +525,56 @@ class ProviderConfig(BaseModel):
             "transitions to UNHEALTHY. Unset = no automatic restart "
             "(recovery probe still runs, waiting for manual restart). "
             "\n\n"
-            "[Unreleased]/planned v2.12.0: currently run as "
-            "``subprocess.run(command, shell=True)`` (coderouter/guards/"
-            "self_healing.py), so shell syntax works today — pipelines "
-            "(``pkill ollama && ollama serve``), ``~`` expansion, and "
-            "leading env-var assignments (``OLLAMA_HOST=0.0.0.0 ollama "
-            "serve``) are all honored. A future minor switches this to "
-            "``shlex.split(command)`` + ``shell=False`` (argv dispatch, "
-            "no shell in between), which does NOT support any of the "
-            "above — ``&&`` becomes a literal argument to the first "
-            "command instead of a separator, ``~/...`` paths are not "
-            "expanded, and ``FOO=bar cmd`` fails to exec. If your "
-            "command needs shell features, wrap it in a small script "
-            "and point restart_command at that script instead, e.g. "
-            "``restart_command: /path/to/restart-ollama.sh``."
+            "v2.13.0: run as ``subprocess.run(shlex.split(command), "
+            "shell=False)`` (coderouter/guards/self_healing.py) — argv "
+            "dispatch, no shell in between. Pipelines "
+            "(``pkill ollama && ollama serve``), redirects, ``~`` "
+            "expansion, and leading env-var assignments "
+            "(``OLLAMA_HOST=0.0.0.0 ollama serve``) are NOT supported: "
+            "``~/...`` paths are not expanded and ``FOO=bar cmd`` fails to "
+            "exec. A value containing shell metacharacters (``&&``, ``||``, "
+            "``|``, ``;``, ``>``, ``<``, ``$(...)``, ```...```) is refused "
+            "outright (not run) rather than half-executed. If your command "
+            "needs shell features, wrap it in a small script and point "
+            "restart_command at that script (e.g. "
+            "``restart_command: /path/to/restart-ollama.sh``), or write it "
+            "as ``/bin/sh -c '...'`` explicitly."
         ),
     )
 
     @model_validator(mode="after")
     def _warn_restart_command_shell_syntax(self) -> ProviderConfig:
-        """[Unreleased]/planned v2.12.0 breaking-change heads-up (warning only).
-
-        ``coderouter/guards/self_healing.py`` currently runs
-        ``restart_command`` via ``subprocess.run(command, shell=True)``.
-        The planned v2.12.0 change switches that to
-        ``shlex.split(command)`` + ``shell=False`` — a shell-syntax
-        ``restart_command`` that works fine today would then either
-        crash (``FileNotFoundError`` for ``~/...`` paths or an
-        ``ENV=val cmd`` prefix) or, worse, silently misbehave (``&&`` /
-        ``||`` / ``|`` / ``;`` / redirects becoming literal argv tokens
-        instead of shell operators — a provider "restart" that quietly
-        does the wrong thing is worse than one that errors loudly).
+        """v2.13.0: warn that this ``restart_command`` will not run as written.
+
+        ``coderouter/guards/self_healing.py`` runs ``restart_command`` via
+        ``subprocess.run(shlex.split(command), shell=False)`` — argv
+        dispatch, no shell. A shell-syntax ``restart_command`` therefore
+        does NOT do what the shell would do:
+
+          * shell metacharacters (``&&`` / ``||`` / ``|`` / ``;`` /
+            redirects / ``$(...)`` / backticks) → the value is *refused*
+            (not run) by self_healing, because under shell=False they would
+            otherwise become literal argv tokens and half-execute a
+            provider "restart" that quietly does the wrong thing;
+          * a leading ``~/...`` path or an ``ENV=val cmd`` prefix →
+            ``exec`` fails (``FileNotFoundError``) because there is no shell
+            to expand ``~`` or apply the assignment.
 
         Deliberately never raises: this validator does not enforce
-        anything, it only warns ahead of the wire change so operators
-        can migrate ``restart_command`` to a plain argv (or a wrapper
-        script) before v2.12.0 lands, instead of discovering the break
-        the next time a provider actually goes UNHEALTHY.
+        anything, it only warns so an existing providers.yaml still loads
+        (rather than becoming un-startable). Migrate ``restart_command`` to
+        a plain argv, a wrapper script, or an explicit ``/bin/sh -c '...'``.
         """
         cmd = self.restart_command
         if not cmd:
             return self
         stripped = cmd.strip()
         reasons: list[str] = []
-        if _RESTART_COMMAND_SHELL_META_RE.search(cmd):
+        if RESTART_COMMAND_SHELL_META_RE.search(cmd):
             reasons.append("shell metacharacter (&&, ||, |, ;, >, <, $(...), or `...`)")
         if stripped.startswith("~/"):
             reasons.append("leading '~/' path (no shell expansion under shell=False)")
-        if _RESTART_COMMAND_ENV_PREFIX_RE.match(stripped):
+        if RESTART_COMMAND_ENV_PREFIX_RE.match(stripped):
             reasons.append("leading environment-variable assignment (FOO=bar ...)")
         if reasons:
             logger.warning(
@@ -576,13 +584,13 @@ class ProviderConfig(BaseModel):
                     "restart_command": cmd,
                     "reasons": reasons,
                     "hint": (
-                        "restart_command currently runs via "
-                        "subprocess.run(..., shell=True); a planned "
-                        "v2.12.0 change switches to shlex.split(...) + "
-                        "shell=False, which does not support this "
-                        "command's shell syntax. Rewrite it as plain "
-                        "argv, or wrap it in a script and point "
-                        "restart_command at that script."
+                        "restart_command runs via "
+                        "subprocess.run(shlex.split(...), shell=False) as of "
+                        "v2.13.0, which does not support this command's "
+                        "shell syntax: values with shell metacharacters are "
+                        "refused (not run), and '~/' / 'FOO=bar' prefixes "
+                        "fail to exec. Rewrite it as plain argv, wrap it in "
+                        "a script, or use /bin/sh -c '...'."
                     ),
                 },
             )
@@ -1572,6 +1580,28 @@ class LauncherOptionProfile(BaseModel):
     )
 
 
+class LauncherBenchPreset(BaseModel):
+    """launcher.bench.presets[<key>] の1エントリ。H-2: スイープAPIが受け付けるのはキー名だけ。"""
+
+    model_config = ConfigDict(extra="forbid")
+    name: str = Field(..., min_length=1, description="Launcher UI に出す表示名。")
+    command_template: str = Field(
+        ...,
+        min_length=1,
+        description="外部ベンチコマンドのテンプレ。{port} {config} {base_url} {results_dir} {runs} を単純置換で展開。",
+    )
+    runs: int | None = Field(
+        default=None,
+        ge=1,
+        le=1000,
+        description="このプリセット固有の実行回数。None なら launcher.bench.runs。",
+    )
+    results_dir: str | None = Field(
+        default=None,
+        description="このプリセット固有の results ディレクトリ。None なら launcher.bench.results_dir。リクエストからは指定できない。",
+    )
+
+
 class LauncherBenchConfig(BaseModel):
     """The ``launcher.bench:`` block — defaults for the bench sweep feature.
 
@@ -1613,6 +1643,23 @@ class LauncherBenchConfig(BaseModel):
             "大きな GGUF ロードを考慮した既定 5 分。"
         ),
     )
+    presets: dict[str, LauncherBenchPreset] = Field(
+        default_factory=dict,
+        description="名前付きベンチコマンド。キーが POST /api/launcher/sweep/start の bench_preset が取りうる唯一の値。",
+    )
+    default_preset: str | None = Field(
+        default=None,
+        description="bench_preset 未指定時に使うプリセットキー。None なら command_template 由来の暗黙 default。",
+    )
+
+    @model_validator(mode="after")
+    def _check_default_preset(self) -> Self:
+        if self.default_preset is not None and self.default_preset not in self.presets:
+            raise ValueError(
+                f"launcher.bench.default_preset={self.default_preset!r} is not a key of "
+                f"launcher.bench.presets (known: {sorted(self.presets) or 'none'})"
+            )
+        return self
 
 
 class SwapModelSpec(BaseModel):
@@ -2306,6 +2353,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 +2893,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: