coderouter-cli 2.10.0__py3-none-any.whl → 2.11.1__py3-none-any.whl

coderouter/adapters/anthropic_native.py

@@ -53,11 +53,16 @@ from coderouter.translation.anthropic import (
     AnthropicResponse,
     AnthropicStreamEvent,
 )
-from coderouter.translation.convert import (
-    stream_anthropic_to_chat_chunks,
-    to_anthropic_request,
-    to_chat_response,
-)
+
+# NOTE: `coderouter.translation.convert` is intentionally NOT imported here
+# at module scope (see H-7). The import chain is:
+#   translation/__init__.py -> convert.py -> adapters/__init__.py
+#     -> registry.py -> anthropic_native.py -> translation.convert (again)
+# A top-level import here closes that cycle and makes standalone imports of
+# `coderouter.translation.*` fail with a partial-initialization ImportError
+# unless `coderouter.adapters` happened to be imported first. The three
+# symbols used from `convert` are imported lazily inside `generate()` /
+# `stream()` instead, which breaks the cycle without changing behavior.
 
 logger = get_logger(__name__)
 
@@ -210,6 +215,12 @@ class AnthropicAdapter(BaseAdapter):
         ``to_chat_response``. The ``coderouter_provider`` tag is preserved
         on both sides.
         """
+        # Local import to avoid a circular import at module load time (H-7):
+        # convert.py transitively imports coderouter.adapters, which imports
+        # this module. Importing convert.py here (call time, not load time)
+        # keeps `coderouter.translation.*` importable standalone.
+        from coderouter.translation.convert import to_anthropic_request, to_chat_response
+
         anth_req = to_anthropic_request(request)
         anth_resp = await self.generate_anthropic(anth_req, overrides=overrides)
         chat_resp = to_chat_response(anth_resp)
@@ -241,6 +252,13 @@ class AnthropicAdapter(BaseAdapter):
             - Anthropic ``event: error`` → translator raises
               AdapterError(retryable=False), same treatment as above.
         """
+        # Local import to avoid a circular import at module load time (H-7);
+        # see the matching comment in generate() above.
+        from coderouter.translation.convert import (
+            stream_anthropic_to_chat_chunks,
+            to_anthropic_request,
+        )
+
         anth_req = to_anthropic_request(request)
         events = self.stream_anthropic(anth_req, overrides=overrides)
         async for chunk in stream_anthropic_to_chat_chunks(events, provider_name=self.name):

coderouter/cli.py

@@ -624,6 +624,24 @@ def _resolve_config_path(explicit: str | None) -> Path:
     return candidates[-1]
 
 
+def _write_verdict_line(*, write: bool, files_written: int) -> None:
+    """Print the one-line "did we touch the disk?" verdict.
+
+    Called on **every** exit path of :func:`_run_apply_or_dry_run`.
+    The v1.x regression this guards against: an ``--apply`` run that
+    silently rewrote providers.yaml while the summary said "already
+    applied" and printed neither a diff nor a ``Backup:`` line. Making
+    the statement unconditional means no future early-return can go
+    quiet about a write again.
+    """
+    if not write:
+        print("  0 files written (dry-run).")
+    elif files_written == 0:
+        print("  0 files written — no file contents changed.")
+    else:
+        print(f"  {files_written} file(s) written.")
+
+
 def _run_apply_or_dry_run(
     *,
     report: object,
@@ -655,9 +673,13 @@ def _run_apply_or_dry_run(
         )
     except MissingDependencyError as exc:
         print(f"doctor --apply: {exc}", file=sys.stderr)
+        _write_verdict_line(write=write, files_written=0)
         return 1
     except DoctorApplyError as exc:
+        # Every merge happens before the first byte is written, so an
+        # abort here always leaves the disk untouched.
         print(f"doctor --apply: {exc}", file=sys.stderr)
+        _write_verdict_line(write=write, files_written=0)
         return 1
 
     label = "Apply" if write else "Dry-run"
@@ -680,6 +702,8 @@ def _run_apply_or_dry_run(
                 f"  All {result.no_op_patches} patch(es) already applied "
                 f"— providers.yaml is up to date."
             )
+        _write_verdict_line(write=write, files_written=len(result.written_paths))
+        _print_reformat_notice(result, write=write)
         return 0
 
     print(
@@ -694,16 +718,41 @@ def _run_apply_or_dry_run(
         print()
         print(diff, end="" if diff.endswith("\n") else "\n")
 
+    _write_verdict_line(write=write, files_written=len(result.written_paths))
     if write:
         for orig, bak in result.backups.items():
             print(f"  Backup: {orig} → {bak}")
     else:
+        _print_reformat_notice(result, write=write)
         print()
         print("  (dry-run — no files were modified. Re-run with --apply to write.)")
 
     return 0
 
 
+def _print_reformat_notice(result: object, *, write: bool) -> None:
+    """Dry-run-only heads-up about cosmetic re-serialization deltas.
+
+    ``reformat_only`` holds targets whose re-dump differs from disk
+    without any patch having changed a value — today that is explicit
+    ``key: null`` scalars, which ruamel re-emits as empty scalars.
+    These bytes are never written, so the note is purely so an operator
+    comparing "the diff I expected" with "the file I have" is not
+    surprised. Suppressed under ``--apply``, where nothing about them
+    is actionable.
+    """
+    reformat = getattr(result, "reformat_only", None) or {}
+    if write or not reformat:
+        return
+    print(
+        f"  note: {len(reformat)} file(s) would re-serialize with cosmetic "
+        "differences (e.g. explicit `null` → empty scalar). These are NOT "
+        "written — --apply only rewrites files whose values actually changed."
+    )
+    for path in sorted(reformat):
+        print(f"    - {path}")
+
+
 
 
 def _run_audit(args: argparse.Namespace) -> int:

coderouter/config/loader.py

@@ -7,6 +7,17 @@ Search order (first hit wins):
     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.
 """
 
 from __future__ import annotations
@@ -17,6 +28,14 @@ from pathlib import Path
 import yaml
 
 from coderouter.config.schemas import CodeRouterConfig
+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.
+_cwd_config_warning_emitted = False
 
 
 def _candidate_paths(explicit: str | os.PathLike[str] | None) -> list[Path]:
@@ -30,6 +49,51 @@ def _candidate_paths(explicit: str | os.PathLike[str] | None) -> list[Path]:
     return paths
 
 
+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.
+
+    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.
+    """
+    global _cwd_config_warning_emitted
+    if _cwd_config_warning_emitted:
+        return
+    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:
+        return
+
+    _cwd_config_warning_emitted = True
+    logger.warning(
+        "cwd-config-loaded",
+        extra={
+            "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."
+            ),
+        },
+    )
+
+
 def load_config(path: str | os.PathLike[str] | None = None) -> CodeRouterConfig:
     """Load providers.yaml + apply ALLOW_PAID env override."""
     candidates = _candidate_paths(path)
@@ -40,6 +104,7 @@ def load_config(path: str | os.PathLike[str] | None = None) -> CodeRouterConfig:
             f"providers.yaml not found. Searched:\n  {searched}\n"
             f"Hint: copy examples/providers.yaml to ~/.coderouter/providers.yaml"
         )
+    _warn_if_cwd_config(chosen, explicit=path)
 
     with chosen.open("r", encoding="utf-8") as f:
         raw = yaml.safe_load(f) or {}

coderouter/config/schemas.py

@@ -17,7 +17,18 @@ import re
 import warnings
 from typing import Any, Literal, Self
 
-from pydantic import BaseModel, ConfigDict, Field, HttpUrl, model_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    HttpUrl,
+    field_validator,
+    model_validator,
+)
+
+from coderouter.logging import get_logger
+
+logger = get_logger(__name__)
 
 
 class Capabilities(BaseModel):
@@ -343,6 +354,17 @@ class AgentCliConfig(BaseModel):
         return self
 
 
+# [Unreleased]/planned v2.12.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+=")
+
+
 class ProviderConfig(BaseModel):
     """A single provider entry from providers.yaml.
 
@@ -490,15 +512,82 @@ class ProviderConfig(BaseModel):
     restart_command: str | None = Field(
         default=None,
         description=(
-            "v2.0-J (Self-healing): shell command to restart this "
-            "provider's backend process. Examples: 'ollama serve', "
+            "v2.0-J (Self-healing): command to restart this provider's "
+            "backend process. Examples: 'ollama serve', "
             "'open -a LM\\ Studio'. Only executed when the profile's "
             "backend_health_action is 'exclude' and the provider "
             "transitions to UNHEALTHY. Unset = no automatic restart "
-            "(recovery probe still runs, waiting for manual 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``."
         ),
     )
 
+    @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).
+
+        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.
+        """
+        cmd = self.restart_command
+        if not cmd:
+            return self
+        stripped = cmd.strip()
+        reasons: list[str] = []
+        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):
+            reasons.append("leading environment-variable assignment (FOO=bar ...)")
+        if reasons:
+            logger.warning(
+                "restart-command-shell-syntax",
+                extra={
+                    "provider": self.name,
+                    "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."
+                    ),
+                },
+            )
+        return self
+
     @model_validator(mode="after")
     def _check_output_filters_known(self) -> ProviderConfig:
         """v1.0-A: fail at config-load on a typo'd filter name.
@@ -1414,6 +1503,29 @@ class LauncherBackendConfig(BaseModel):
             binary: ~/llama.cpp/build/bin/llama-server
           vllm:
             binary: ~/.venv/bin/python
+
+    **Backend variants** (v2.11.0+, docs/designs/launcher-multi-build.md):
+    a key may also be ``<base>-<variant>`` to register an additional build of
+    the same backend — typically llama.cpp compiled for a specific GPU
+    runtime. Each variant appears as its own entry in the Launcher's backend
+    select, gets its own ``--list-devices`` probe (device IDs differ per
+    build: ``CUDA0`` and ``Vulkan0`` are not the same GPU) and can carry its
+    own ``option_profiles``. ``binary`` is **required** for a variant::
+
+        backends:
+          llama.cpp:                    # 素のビルド (binary 省略可 = PATH)
+            binary: ~/llm/apps/llama.cpp/build/bin/llama-server
+          llama.cpp-cuda:
+            binary: ~/llm/apps/llama.cpp/build-cuda/bin/llama-server
+          llama.cpp-vulkan:
+            binary: ~/llm/apps/llama.cpp/build-vulkan/bin/llama-server
+          llama.cpp-rocm:
+            binary: ~/llm/apps/llama.cpp/build-rocm/bin/llama-server
+
+    Variants are an advanced option: the matching GPU runtime (CUDA Toolkit /
+    Vulkan runtime + ICD / ROCm) must already be installed by the operator.
+    CodeRouter never selects a variant implicitly — omit them and both the UI
+    and the resulting argv are identical to before.
     """
 
     model_config = ConfigDict(extra="forbid")
@@ -1544,9 +1656,39 @@ class SwapModelSpec(BaseModel):
             "only widens *catalog* matching for ``SwapManager.match``."
         ),
     )
-    backend: Literal["llama.cpp", "vllm", "mlx"] = Field(
-        ..., description="Same backend set as the manual launcher UI / _build_cmd.",
+    backend: str = Field(
+        ...,
+        description=(
+            "Same backend set as the manual launcher UI / _build_cmd: "
+            "'llama.cpp' / 'vllm' / 'mlx', optionally with a '-<variant>' "
+            "suffix naming a specific build declared in launcher.backends "
+            "(e.g. 'llama.cpp-cuda' to pin this model to the CUDA build). "
+            "Validated by the field validator below plus "
+            "LauncherConfig._check_swap_backends_declared."
+        ),
     )
+
+    @field_validator("backend")
+    @classmethod
+    def _check_backend_name(cls, v: str) -> str:
+        """基底名 or 既知基底名 + 妥当なバリアントのみ許す。
+
+        以前は ``Literal["llama.cpp","vllm","mlx"]`` だった。バリアント
+        (``llama.cpp-cuda``) を通すため str に緩めたので、代わりに形式検証を
+        ここで行う。既存の 3 値はそのまま通る (後方互換)。
+        """
+        from coderouter.launcher_devices import (
+            KNOWN_BASE_BACKENDS,
+            is_valid_backend_name,
+        )
+
+        if not is_valid_backend_name(v):
+            raise ValueError(
+                f"backend {v!r} is not valid. Expected one of "
+                f"{list(KNOWN_BASE_BACKENDS)} or '<base>-<variant>' "
+                "(e.g. 'llama.cpp-cuda')."
+            )
+        return v
     model_path: str = Field(
         ...,
         description=(
@@ -1802,10 +1944,13 @@ class LauncherConfig(BaseModel):
         default_factory=dict,
         description=(
             "Per-backend binary path overrides. "
-            "Keys are backend names ('llama.cpp', 'vllm'). "
-            "When a key is absent, the default executable is used "
-            "('llama-server' / 'python') and resolved via PATH. "
-            "Useful when running a from-source build or a venv-specific binary."
+            "Keys are backend names ('llama.cpp', 'vllm', 'mlx') or backend "
+            "variants ('llama.cpp-cuda', 'llama.cpp-vulkan', ...) naming an "
+            "additional build of the same backend — see "
+            "LauncherBackendConfig. When a base key is absent, the default "
+            "executable is used ('llama-server' / 'python') and resolved via "
+            "PATH. Variants must set 'binary' explicitly and additionally "
+            "appear in the Launcher's backend select."
         ),
     )
     option_profiles: dict[str, list[LauncherOptionProfile]] = Field(
@@ -1813,6 +1958,10 @@ class LauncherConfig(BaseModel):
         description=(
             "Named option presets per backend. "
             "Keys should be backend names: 'llama.cpp', 'vllm'. "
+            "A backend-variant key ('llama.cpp-cuda') is also accepted: its "
+            "presets are appended to the base backend's list, and a preset "
+            "whose 'name' collides replaces the inherited one in place "
+            "(see launcher_devices.resolve_option_profiles). "
             "Each key maps to an ordered list of named presets. "
             "A free-form 'extra args' field is always available in the UI "
             "for one-off overrides without touching this config."
@@ -1929,15 +2078,82 @@ class LauncherConfig(BaseModel):
             )
         return self
 
+    @model_validator(mode="after")
+    def _check_backend_names_and_variant_binaries(self) -> LauncherConfig:
+        """``backends`` のキー形式と、バリアントの ``binary`` 必須を検証する。
+
+        設計: docs/designs/launcher-multi-build.md §5.2。
+
+        1. キーは既知基底名 (``llama.cpp`` / ``vllm`` / ``mlx``) そのもの、
+           または ``<既知基底名>-<バリアント>`` (``llama.cpp-cuda`` 等) のみ。
+           **破壊的変更**: これまで ``llamacpp:`` のような typo は黙って無視
+           されていた (バックエンド一覧が固定 3 キーだったため)。今後は
+           ロード時エラーになる。
+        2. **バリアントは ``binary`` 必須**。``llama.cpp-cuda: {}`` を許すと
+           既定名フォールバックで PATH の ``llama-server`` が使われ、CUDA
+           ビルドを指定したつもりで素のビルドが静かに動く —— 本機能で最も
+           気づきにくい事故なのでロード時に殺す。基底名は従来どおり
+           ``binary`` 省略可 (PATH 解決)。
+        """
+        from coderouter.launcher_devices import (
+            KNOWN_BASE_BACKENDS,
+            is_valid_backend_name,
+            is_variant,
+        )
+
+        for name, bc in self.backends.items():
+            if not is_valid_backend_name(name):
+                raise ValueError(
+                    f"launcher.backends: invalid backend key {name!r}. "
+                    f"Expected one of {list(KNOWN_BASE_BACKENDS)} or "
+                    "'<base>-<variant>' where variant matches "
+                    "[a-z0-9][a-z0-9._-]* (e.g. 'llama.cpp-cuda')."
+                )
+            if is_variant(name) and not bc.binary:
+                raise ValueError(
+                    f"launcher.backends[{name!r}]: 'binary' is required for a "
+                    "backend variant. Without it the launcher would fall back "
+                    "to the base default on PATH and silently run a different "
+                    "build than the one you selected."
+                )
+        return self
+
+    @model_validator(mode="after")
+    def _check_swap_backends_declared(self) -> LauncherConfig:
+        """swap のモデルがバリアントを指すなら ``backends`` に実在すること。
+
+        設計 §5.2-3。基底名 (``llama.cpp`` 等) は ``backends`` に書かなくても
+        PATH 解決で動くので従来どおり不要。バリアントは実行ファイルパスが
+        ``backends`` にしか無いので、宣言漏れをロード時に弾く。
+        """
+        if self.swap is None:
+            return self
+        from coderouter.launcher_devices import is_variant
+
+        for spec in self.swap.models:
+            if is_variant(spec.backend) and spec.backend not in self.backends:
+                raise ValueError(
+                    f"launcher.swap.models[{spec.name!r}]: backend "
+                    f"{spec.backend!r} is a variant but is not declared in "
+                    "launcher.backends (its binary path is unknown)."
+                )
+        return self
+
     @model_validator(mode="after")
     def _check_swap_option_profiles_exist(self) -> LauncherConfig:
-        """§5.4 #2: a swap model's ``option_profile`` must be a real preset."""
+        """§5.4 #2: a swap model's ``option_profile`` must be a real preset.
+
+        バリアント backend の場合は基底名のプロファイルも継承されるので
+        (:func:`resolve_option_profiles`)、マージ後の一覧で判定する。
+        """
         if self.swap is None:
             return self
+        from coderouter.launcher_devices import resolve_option_profiles
+
         for spec in self.swap.models:
             if spec.option_profile is None:
                 continue
-            profiles = self.option_profiles.get(spec.backend, [])
+            profiles = resolve_option_profiles(self.option_profiles, spec.backend)
             if not any(p.name == spec.option_profile for p in profiles):
                 raise ValueError(
                     f"launcher.swap.models[{spec.name!r}]: option_profile "