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

coderouter/config/schemas.py

@@ -17,7 +17,14 @@ 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,
+)
 
 
 class Capabilities(BaseModel):
@@ -1414,6 +1421,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 +1574,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 +1862,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 +1876,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 +1996,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 "

coderouter/ingress/launcher_routes.py

@@ -47,6 +47,7 @@ from coderouter.launcher_devices import (
     SweepPlan,
     SweepState,
     SweepStep,
+    base_backend,
     build_auto_sweep_configs,
     build_sweep_steps,
     detect_llama_devices,
@@ -54,8 +55,11 @@ from coderouter.launcher_devices import (
     is_port_free,
     load_latest_results,
     render_bench_command,
+    resolve_option_profiles,
     selectable_devices,
     suggest_tensor_split,
+    unknown_device_ids,
+    variant_of,
 )
 from coderouter.launcher_speculative import resolve_speculative
 from coderouter.logging import get_logger
@@ -281,6 +285,9 @@ def _scan_models(model_dirs: list[str]) -> list[dict[str, Any]]:
 # ---------------------------------------------------------------------------
 
 
+# 基底バックエンド名 → 既定の実行ファイル名。キーは常に**基底名**であり、
+# ``llama.cpp-cuda`` のようなバリアント名は入らない。参照側は必ず
+# ``base_backend()`` を通してから引くこと(launcher_devices §2.0)。
 _BACKEND_DEFAULTS: dict[str, str] = {
     "llama.cpp": "llama-server",
     "vllm": "python",
@@ -315,8 +322,15 @@ def _assert_no_model_override(backend: str, tokens: list[str]) -> None:
     ``tokens`` is the flat list of argument tokens sourced from ``options``
     keys or ``shlex.split(extra_args)``. Matching is exact on the flag name;
     ``--model=foo`` style is caught by comparing the part before ``=``.
+
+    ``backend`` may be a variant name (``llama.cpp-cuda``), so the lookup goes
+    through :func:`base_backend`. A missing entry must NOT silently disable the
+    guard — an unknown base falls back to the union of every banned set, i.e.
+    the strictest possible check (fail-closed).
     """
-    banned = _MODEL_FLAGS.get(backend, frozenset())
+    banned = _MODEL_FLAGS.get(base_backend(backend))
+    if banned is None:
+        banned = frozenset().union(*_MODEL_FLAGS.values())
     for token in tokens:
         name = token.split("=", 1)[0]
         if name in banned:
@@ -328,11 +342,36 @@ def _assert_no_model_override(backend: str, tokens: list[str]) -> None:
 
 
 def _resolve_binary(backend: str, configured: str | None) -> str:
-    """Return the executable to use, expanding ~ and env vars."""
-    raw = configured or _BACKEND_DEFAULTS.get(backend, backend)
+    """Return the executable to use, expanding ~ and env vars.
+
+    ``backend`` may be a variant name; the default-executable fallback is
+    keyed by :func:`base_backend` so ``llama.cpp-cuda`` without a configured
+    ``binary`` would fall back to ``llama-server`` rather than to the literal
+    backend name. In practice variants require ``binary`` (validated at config
+    load — see ``LauncherConfig``), so that fallback should be unreachable.
+    """
+    raw = configured or _BACKEND_DEFAULTS.get(base_backend(backend), backend)
     return str(Path(raw).expanduser())
 
 
+def _backend_names(backends_cfg: dict[str, Any] | None) -> list[str]:
+    """Launcher が提示するバックエンド名の一覧 (順序が UI の並び順)。
+
+    基底 3 つを常に先頭に (従来どおりの順)、そのあとに ``launcher.backends``
+    に書かれたバリアントを記述順で並べる。設計 §6。
+
+    ``launcher.backends`` にバリアントを書かない利用者には従来と同じ 3 要素が
+    返るので、UI の選択肢も API 応答も完全に不変 —— 特化ビルドは「書いた人に
+    だけ見える上級者向けオプション」であり、バッジや注記ではなく構造でそれを
+    担保する。
+    """
+    names = list(_BACKEND_DEFAULTS)
+    for name in backends_cfg or {}:
+        if name not in names:
+            names.append(name)
+    return names
+
+
 def _resolve_backends_sync(
     backends_cfg: dict[str, Any] | None,
 ) -> dict[str, dict[str, Any]]:
@@ -340,9 +379,16 @@ def _resolve_backends_sync(
 
     Performs blocking filesystem I/O (``is_file`` / ``shutil.which``),
     so async-route callers must invoke it via ``asyncio.to_thread``.
+
+    Covers the base backends plus any variant declared in
+    ``launcher.backends`` (see :func:`_backend_names`). Each entry gains
+    ``base`` / ``variant`` so the UI can label a variant without re-parsing
+    the name client-side.
     """
     result: dict[str, dict[str, Any]] = {}
-    for backend, default_bin in _BACKEND_DEFAULTS.items():
+    for backend in _backend_names(backends_cfg):
+        base = base_backend(backend)
+        default_bin = _BACKEND_DEFAULTS.get(base, backend)
         configured: str | None = None
         if backends_cfg:
             bc = backends_cfg.get(backend)
@@ -360,6 +406,9 @@ def _resolve_backends_sync(
             "default": default_bin,
             "is_custom": configured is not None,
             "found": found,
+            # 以下 2 キーはバリアント機能で追加 (基底名では variant=None)。
+            "base": base,
+            "variant": variant_of(backend),
         }
     return result
 
@@ -436,6 +485,8 @@ def _suggest_launch_flags(backend: str, size_gb: float,
       - mlx       : 統合メモリ前提で起動時フラグ不要 (空文字)
     あくまで目安。他プロセスのメモリ使用や量子化方式までは考慮しない。
     """
+    # バリアント名 (llama.cpp-cuda 等) でも同じフラグ体系なので基底名で判定。
+    backend = base_backend(backend)
     if backend == "mlx":
         # MLX は統合メモリ + Metal 前提。llama.cpp の -ngl に相当する
         # レイヤーオフロードの概念がなく、mlx_lm.server は起動時の
@@ -552,20 +603,23 @@ def _build_cmd(
     model-override guard, and never apply to vllm/mlx (device 非対応)。
     """
     exe = _resolve_binary(backend, binary)
+    # argv の形はバリアントによらず基底バックエンドで決まる
+    # (llama.cpp-cuda も llama.cpp と同じフラグ体系)。
+    base = base_backend(backend)
 
-    if backend == "llama.cpp":
+    if base == "llama.cpp":
         cmd: list[str] = [exe, "-m", model_path, "--port", str(port)]
         if device_args:
             cmd.extend(device_args)
         if spec_tokens:
             cmd.extend(spec_tokens)
-    elif backend == "vllm":
+    elif base == "vllm":
         cmd = [
             exe, "-m", "vllm.entrypoints.openai.api_server",
             "--model", model_path,
             "--port", str(port),
         ]
-    elif backend == "mlx":
+    elif base == "mlx":
         cmd = [
             exe, "-m", "mlx_lm.server",
             "--model", model_path,
@@ -574,7 +628,8 @@ def _build_cmd(
     else:
         raise ValueError(
             f"Unknown backend: {backend!r}. "
-            "Expected 'llama.cpp', 'vllm' or 'mlx'."
+            "Expected 'llama.cpp', 'vllm' or 'mlx' "
+            "(optionally with a '-<variant>' suffix)."
         )
 
     # H8: reject model-path re-specification via options keys.
@@ -653,8 +708,14 @@ async def _backend_ready(backend: str, port: int, *, probe_timeout_s: float) ->
     documented health endpoint) fall back to a bare TCP connect: it can't
     distinguish "loaded" from "listening", but it is a strict improvement
     over registering the provider before the port is even open.
+
+    ``backend`` may be a variant name (``llama.cpp-cuda``): the check goes
+    through :func:`base_backend` so a variant keeps the ``/health`` probe.
+    Falling through to the bare TCP connect here would silently re-introduce
+    the bug readiness gating was added to fix (provider registered before the
+    model finished loading).
     """
-    if backend in ("llama.cpp", "vllm"):
+    if base_backend(backend) in ("llama.cpp", "vllm"):
         try:
             async with httpx.AsyncClient(timeout=probe_timeout_s) as client:
                 resp = await client.get(f"http://localhost:{port}/health")
@@ -1032,15 +1093,30 @@ async def api_models(request: Request) -> dict[str, Any]:
 
 @router.get("/api/launcher/option-profiles")
 async def api_option_profiles(request: Request) -> dict[str, Any]:
-    """Return option_profiles from providers.yaml launcher config."""
+    """Return option_profiles from providers.yaml launcher config.
+
+    A backend-variant key inherits the base backend's presets: the response
+    for ``llama.cpp-cuda`` is the ``llama.cpp`` list followed by the
+    variant-specific list, with same-``name`` presets replaced in place
+    (:func:`resolve_option_profiles`). Every declared backend gets an entry
+    so the UI can key on the selected backend name directly, and a config
+    without variants yields exactly the pre-feature payload.
+    """
     cfg = request.app.state.config
     launcher_cfg = getattr(cfg, "launcher", None)
     if not launcher_cfg:
         return {"profiles": {}, "_note": "launcher: block not found in providers.yaml"}
     if not launcher_cfg.option_profiles:
         return {"profiles": {}, "_note": "option_profiles is empty — add option_profiles: under launcher: in providers.yaml"}
+    names = list(launcher_cfg.option_profiles)
+    for name in _backend_names(launcher_cfg.backends):
+        if name not in names:
+            names.append(name)
     result: dict[str, list[dict]] = {}
-    for backend, profiles in launcher_cfg.option_profiles.items():
+    for backend in names:
+        profiles = resolve_option_profiles(launcher_cfg.option_profiles, backend)
+        if not profiles and backend not in launcher_cfg.option_profiles:
+            continue  # 継承もローカル定義も無いバックエンドはキーを作らない
         result[backend] = [{"name": p.name, "args": p.args} for p in profiles]
     return {"profiles": result}
 
@@ -1323,10 +1399,12 @@ async def api_start(req: StartRequest, request: Request) -> dict[str, Any]:
     _require_launcher_token(request)
     cfg = request.app.state.config
     launcher_cfg = getattr(cfg, "launcher", None)
+    _assert_backend_declared(launcher_cfg, req.backend)
     # デバイス選択 → CLI 断片(llama.cpp のみ・選択された場合のみ)。未指定なら
     # None を渡し、既存の argv と完全一致(後方互換)。
     device_args: list[str] | None = None
-    if req.backend == "llama.cpp" and req.device_ids:
+    if base_backend(req.backend) == "llama.cpp" and req.device_ids:
+        await _assert_device_ids_known(launcher_cfg, req.backend, req.device_ids)
         device_args = DeviceSelection(
             device_ids=list(req.device_ids), tensor_split=list(req.tensor_split)
         ).to_cli_args()
@@ -1436,7 +1514,11 @@ async def api_suggest(request: Request, model_path: str = "",
 
 
 def _configured_binary_for(launcher_cfg: Any, backend: str) -> str | None:
-    """launcher.backends[backend].binary を取り出す(未設定なら None)。"""
+    """launcher.backends[backend].binary を取り出す(未設定なら None)。
+
+    ``backend`` はバリアント名 (``llama.cpp-cuda``) でもよい —— ``backends`` は
+    バリアント名もキーに取るので、そのまま引ける。
+    """
     if launcher_cfg and getattr(launcher_cfg, "backends", None):
         bc = launcher_cfg.backends.get(backend)
         if bc and bc.binary:
@@ -1444,6 +1526,61 @@ def _configured_binary_for(launcher_cfg: Any, backend: str) -> str | None:
     return None
 
 
+def _assert_backend_declared(launcher_cfg: Any, backend: str) -> None:
+    """バリアント名は ``launcher.backends`` に宣言済みでなければ 400。
+
+    設計 §8。バリアントの実行ファイルパスは ``launcher.backends`` にしか無い
+    ので、宣言されていない名前を受け取ったら**フォールバックせずに拒否**する。
+    基底名 (``llama.cpp`` 等) は PATH 解決で動くため従来どおり宣言不要。
+
+    これは同時に「API はバックエンド名しか受け取らず、実行ファイルパスは常に
+    オペレータの静的設定から来る」という不変則の実装でもある (§11)。
+    """
+    if not variant_of(backend):
+        return
+    declared = getattr(launcher_cfg, "backends", None) or {}
+    if backend not in declared:
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                f"Unknown backend variant {backend!r}: not declared in "
+                "launcher.backends. Add it (with a 'binary' path) to "
+                "providers.yaml first."
+            ),
+        )
+
+
+async def _assert_device_ids_known(
+    launcher_cfg: Any, backend: str, device_ids: list[str]
+) -> None:
+    """選択デバイス ID がそのビルドに実在しなければ 400 (設計 §7.2)。
+
+    デバイス ID の名前空間はビルドごとに違う (``CUDA0`` と ``Vulkan0`` は同じ
+    GPU を指さない)。CUDA ビルドで ``CUDA0`` を選んだまま Vulkan ビルドで起動
+    すると ``--device CUDA0`` が渡って llama-server が起動失敗するので、spawn
+    前に弾く。
+
+    ``--list-devices`` 自体が失敗した環境では検証をスキップする
+    (:func:`unknown_device_ids` の best-effort 契約)。
+    """
+    if not device_ids:
+        return
+    configured = _configured_binary_for(launcher_cfg, backend)
+    binary = _resolve_binary(backend, configured)
+    probe = await asyncio.to_thread(detect_llama_devices, binary)
+    unknown = unknown_device_ids(list(device_ids), probe)
+    if unknown:
+        known = [d.id for d in probe.devices]
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                f"Device id(s) {unknown} do not exist in backend {backend!r} "
+                f"(detected: {known}). Device ids are build-specific — "
+                "re-select devices after switching build."
+            ),
+        )
+
+
 @router.get("/api/launcher/devices")
 async def api_devices(
     request: Request, backend: str = "llama.cpp", refresh: int = 0
@@ -1504,6 +1641,9 @@ class SweepConfigItem(BaseModel):
     label: str
     device_ids: list[str] = Field(default_factory=list)
     tensor_split: list[float] = Field(default_factory=list)
+    # バリアント横断スイープ: このステップだけ別ビルドで起動する。None なら
+    # ``SweepRequest.backend`` を使う=従来と完全に同一の argv。
+    backend: str | None = None
 
 
 class SweepRequest(BaseModel):
@@ -1621,12 +1761,15 @@ class _SweepRunner:
         step.state = SweepState.STARTING
         self.log_tail.append(f"[sweep] {step.label}: starting")
         device_args = step.selection.to_cli_args() or None
+        # ステップ個別のバックエンド(バリアント横断スイープ)。未指定なら
+        # プラン既定 = 従来の挙動。
+        step_backend = step.backend or self.plan.backend
         try:
             mp = await spawn_process(
                 self.app,
                 self.launcher_cfg,
                 name=f"sweep-{step.label}",
-                backend=self.plan.backend,
+                backend=step_backend,
                 model_path=self.plan.model_path,
                 port=self.plan.port,
                 options=self.plan.options,
@@ -1768,6 +1911,13 @@ async def api_sweep_start(req: SweepRequest, request: Request) -> dict[str, Any]
             status_code=400, detail=f"Port {req.port} is not free."
         )
 
+    # バリアント横断スイープ: 各構成が別ビルドを指せる。宣言されていない
+    # バリアント名は通常起動と同じく 400 で弾く(フォールバックしない)。
+    _assert_backend_declared(launcher_cfg, req.backend)
+    for item in req.configs:
+        if item.backend:
+            _assert_backend_declared(launcher_cfg, item.backend)
+
     labeled = [
         (
             item.label,
@@ -1775,6 +1925,7 @@ async def api_sweep_start(req: SweepRequest, request: Request) -> dict[str, Any]
                 device_ids=list(item.device_ids),
                 tensor_split=list(item.tensor_split),
             ),
+            item.backend,
         )
         for item in req.configs
     ]
@@ -1927,6 +2078,10 @@ _LAUNCHER_HTML = r"""<!doctype html>
 
       <div>
         <label class="block text-xs text-slate-400 mb-1">バックエンド</label>
+        <!-- 選択肢は fetchBackends() が /api/launcher/backends の応答から
+             動的生成する。providers.yaml に llama.cpp-cuda のようなバリアント
+             を書くとここに増える。書かなければ基底 3 つのまま(従来と同一)。
+             初期値は JS が届く前でも表示が崩れないための土台。 -->
         <select id="f-backend" onchange="onBackendChange()">
           <option value="llama.cpp">llama.cpp</option>
           <option value="vllm">vllm</option>
@@ -2031,7 +2186,13 @@ _LAUNCHER_HTML = r"""<!doctype html>
     </p>
     <div class="grid grid-cols-1 md:grid-cols-2 gap-3">
       <div>
-        <label class="block text-xs text-slate-400 mb-1">構成候補</label>
+        <div class="flex items-center justify-between mb-1">
+          <label class="block text-xs text-slate-400">構成候補</label>
+          <!-- 宣言済みの llama.cpp バリアントを全部プローブして横断構成を作る。
+               「CUDA ビルドと Vulkan ビルドどちらが速いか」を 1 回で回すための入口。 -->
+          <button id="btn-cross-variant" onclick="buildCrossVariantConfigs()"
+                  class="btn-sm btn-slate hidden">⚙ ビルド横断</button>
+        </div>
         <div id="sweep-configs" class="text-xs text-slate-400 space-y-1 bg-slate-800/40 rounded p-2 max-h-40 overflow-y-auto">
           <span class="text-slate-600">先に「🔍 検出」でデバイスを取得してください</span>
         </div>
@@ -2254,12 +2415,30 @@ _LAUNCHER_HTML = r"""<!doctype html>
       if (!r.ok) throw new Error(`HTTP ${r.status}`);
       const d = await r.json();
       allBackends = d.backends || {};
+      populateBackendSelect();
+      updateCrossVariantButton();
     } catch (e) {
       console.error("[Launcher] fetchBackends failed:", e);
     }
     renderBinaryHint();  // always call outside try-catch so errors surface
   };
 
+  // バックエンドセレクトをサーバ応答から作り直す。バリアント
+  // (llama.cpp-cuda 等) には ⚙ を付けて「対応ランタイムを自分で入れる
+  // 上級者向け」であることを示す。バリアントが 0 個なら従来と同じ 3 択。
+  const populateBackendSelect = () => {
+    const sel = document.getElementById("f-backend");
+    const names = Object.keys(allBackends);
+    if (!names.length) return;
+    const prev = sel.value;
+    sel.innerHTML = names.map((n) => {
+      const info = allBackends[n] || {};
+      const label = info.variant ? `${n} ⚙` : n;
+      return `<option value="${esc(n)}">${esc(label)}</option>`;
+    }).join("");
+    sel.value = names.includes(prev) ? prev : names[0];
+  };
+
   const renderBinaryHint = () => {
     const backend = document.getElementById("f-backend").value;
     const hint = document.getElementById("binary-hint");
@@ -2276,10 +2455,20 @@ _LAUNCHER_HTML = r"""<!doctype html>
     const pathColor = info.found
       ? (info.is_custom ? "#818cf8" : "#4ade80")  // indigo-400 / green-400
       : "#f87171";  // red-400
-    hint.innerHTML = dot
+    // バリアント (特化ビルド) は対応 GPU ランタイムをユーザー自身が入れて
+    // いる前提なので、選択中はその旨を一行添える。基底名では出さない
+    // (通常利用者の画面を汚さない)。
+    const runtimeNote = info.variant
+      ? `<div style="color:#fbbf24;margin-top:2px">⚙ ${esc(info.variant)} ビルド`
+        + ` — 対応ランタイム(CUDA / Vulkan / ROCm)が導入済みの環境でのみ動作します</div>`
+      : "";
+    hint.innerHTML = "<div style=\"display:flex;align-items:center;overflow:hidden\">"
+      + dot
       + `<span style="font-family:monospace;color:${pathColor};overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${esc(info.resolved)}</span>`
-      + `<span style="color:#64748b;margin-left:6px;white-space:nowrap;flex-shrink:0">(${label} — ${statusText})</span>`;
-    hint.style.cssText = "display:flex;align-items:center;gap:0;overflow:hidden";
+      + `<span style="color:#64748b;margin-left:6px;white-space:nowrap;flex-shrink:0">(${label} — ${statusText})</span>`
+      + "</div>"
+      + runtimeNote;
+    hint.style.cssText = "overflow:hidden";
     // Enable/disable launch button based on binary availability
     if (!info.found) {
       btn.disabled = true;
@@ -2320,6 +2509,20 @@ _LAUNCHER_HTML = r"""<!doctype html>
   };
 
   window.onBackendChange = () => {
+    // ★ デバイス id の名前空間はビルドごとに違う ("CUDA0" と "Vulkan0" は
+    //   同じ GPU ではない)。バックエンド/バリアントを切り替えたら選択を破棄
+    //   して検出やり直しにする。残したままだと --device CUDA0 が Vulkan
+    //   ビルドに渡って起動失敗する (サーバ側でも 400 で弾くが、UI 側で
+    //   先に消しておくのが本筋)。
+    _devices = [];
+    _deviceSel = {};
+    _deviceOk = false;
+    _autoConfigs = [];
+    const box = document.getElementById("device-list");
+    if (box) {
+      box.innerHTML =
+        '<span class="text-slate-600">「検出」を押してデバイスを取得</span>';
+    }
     populateProfileSelect();
     renderBinaryHint();
     updateDeviceBlock();
@@ -2360,7 +2563,17 @@ _LAUNCHER_HTML = r"""<!doctype html>
   let _deviceOk = false;
   let _autoConfigs = [];    // サーバ生成のスイープ構成候補
 
-  const isLlama = () => document.getElementById("f-backend").value === "llama.cpp";
+  // バックエンド名は "llama.cpp" だけでなく "llama.cpp-cuda" のようなバリアント
+  // 名も来る (docs/designs/launcher-multi-build.md)。素の === 比較にすると
+  // バリアント選択時にデバイス欄が出なくなるので基底名で判定する。
+  const baseBackend = (name) => {
+    for (const b of ["llama.cpp", "vllm", "mlx"]) {
+      if (name === b || name.startsWith(b + "-")) return b;
+    }
+    return name;
+  };
+  const isLlama = () =>
+    baseBackend(document.getElementById("f-backend").value) === "llama.cpp";
 
   // デバイス id → バックエンド接頭辞(末尾数字を除く)。launcher_devices の
   // backend_of と同じ規則。"CUDA0"→"CUDA" / "Vulkan2"→"Vulkan" / "MTL0"→"MTL"。
@@ -2488,15 +2701,58 @@ _LAUNCHER_HTML = r"""<!doctype html>
   // 0 MiB 除外・バックエンド単位のグループ化・跨バックエンド混成の除外は
   // すべてサーバ側ロジックに一本化されている。
   const buildSweepConfigs = () => {
+    const backend = document.getElementById("f-backend").value;
     _sweepConfigs = (_autoConfigs || []).map(c => ({
       label: c.label,
       device_ids: c.device_ids || [],
       tensor_split: c.tensor_split || [],
+      backend: backend,
       checked: true,
     }));
     renderSweepConfigs();
   };
 
+  // 宣言済みの llama.cpp バリアントを全部プローブし、ビルド横断の構成を作る。
+  // ラベルにビルド名を前置するので {config} 経由でベンチ結果も見分けられる。
+  // ビルド間の混成構成は作らない(1 プロセスは 1 実行ファイルなので原理的に不可)。
+  window.buildCrossVariantConfigs = async () => {
+    const names = Object.keys(allBackends).filter(n => baseBackend(n) === "llama.cpp");
+    if (names.length < 2) {
+      showSweepErr("横断できるビルドが 1 つしかありません。providers.yaml の "
+                   + "launcher.backends に llama.cpp-cuda などを追加してください");
+      return;
+    }
+    showSweepErr("");
+    const box = document.getElementById("sweep-configs");
+    box.innerHTML = '<span class="text-slate-600">全ビルドを検出中…</span>';
+    const collected = [];
+    for (const name of names) {
+      try {
+        const r = await fetch("/api/launcher/devices?backend=" + encodeURIComponent(name));
+        const d = await r.json();
+        if (!r.ok || !d.ok) continue;   // 検出できないビルドは黙って飛ばす
+        const prefix = (allBackends[name] || {}).variant || name;
+        for (const c of (d.auto_configs || [])) {
+          collected.push({
+            label: prefix + " / " + c.label,
+            device_ids: c.device_ids || [],
+            tensor_split: c.tensor_split || [],
+            backend: name,
+            checked: true,
+          });
+        }
+      } catch (_) {}
+    }
+    if (!collected.length) {
+      showSweepErr("どのビルドでもデバイスを検出できませんでした");
+      renderSweepConfigs();
+      return;
+    }
+    _sweepConfigs = collected;
+    renderSweepConfigs();
+    statusMsg(`ビルド横断構成 ${collected.length} 件を生成 (${names.length} ビルド)`);
+  };
+
   const renderSweepConfigs = () => {
     const box = document.getElementById("sweep-configs");
     if (!_sweepConfigs.length) {
@@ -2512,6 +2768,15 @@ _LAUNCHER_HTML = r"""<!doctype html>
     ).join("");
   };
 
+  // 「⚙ ビルド横断」ボタンは llama.cpp のビルドが 2 つ以上宣言されている
+  // ときだけ出す(バリアントを書いていない利用者の画面は従来どおり)。
+  const updateCrossVariantButton = () => {
+    const btn = document.getElementById("btn-cross-variant");
+    if (!btn) return;
+    const n = Object.keys(allBackends).filter(x => baseBackend(x) === "llama.cpp").length;
+    btn.classList.toggle("hidden", n < 2);
+  };
+
   window.onSweepCfgToggle = () => {
     document.querySelectorAll('#sweep-configs input[data-cfg]').forEach(cb => {
       _sweepConfigs[parseInt(cb.getAttribute("data-cfg"))].checked = cb.checked;
@@ -2529,7 +2794,8 @@ _LAUNCHER_HTML = r"""<!doctype html>
     const model = document.getElementById("f-model").value.trim();
     if (!model) { showSweepErr("起動フォームでモデルパスを選択してください"); return; }
     const configs = _sweepConfigs.filter(c => c.checked)
-      .map(c => ({label: c.label, device_ids: c.device_ids, tensor_split: c.tensor_split}));
+      .map(c => ({label: c.label, device_ids: c.device_ids,
+                  tensor_split: c.tensor_split, backend: c.backend || null}));
     if (!configs.length) { showSweepErr("構成を 1 つ以上選択してください"); return; }
     const port = parseInt(document.getElementById("sweep-port").value);
     const cmd = document.getElementById("sweep-cmd").value.trim();
@@ -2597,7 +2863,8 @@ _LAUNCHER_HTML = r"""<!doctype html>
       const tok = sm.tokens_per_sec != null ? sm.tokens_per_sec : "—";
       const ttft = sm.ttft_ms != null ? sm.ttft_ms : "—";
       const dev = (s.device_ids || []).join(",")
-        + ((s.tensor_split || []).length ? " · " + s.tensor_split.join(",") : "");
+        + ((s.tensor_split || []).length ? " · " + s.tensor_split.join(",") : "")
+        + (s.backend ? "  [" + s.backend + "]" : "");
       const exit = s.bench_exit_code != null ? s.bench_exit_code : "—";
       return `<tr>
         <td class="py-2 pr-3">${esc(s.label)}</td>
@@ -2628,7 +2895,7 @@ _LAUNCHER_HTML = r"""<!doctype html>
 
     // デバイス選択 (llama.cpp のみ)。未選択なら空 → サーバ側で --device 不付与。
     let deviceIds = [], tensorSplit = [];
-    if (backend === "llama.cpp") {
+    if (baseBackend(backend) === "llama.cpp") {
       deviceIds = selectedDeviceIds();
       const ts = document.getElementById("f-tsplit").value.trim();
       if (ts && deviceIds.length > 1) {

coderouter/launcher_devices.py

@@ -23,13 +23,14 @@ import socket
 import subprocess  # controlled: fixed argv, no shell
 import threading
 import time
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field
 from enum import StrEnum
 from pathlib import Path
 from typing import Any
 
 __all__ = [
+    "KNOWN_BASE_BACKENDS",
     "DeviceProbe",
     "DeviceSelection",
     "LlamaDevice",
@@ -37,21 +38,140 @@ __all__ = [
     "SweepState",
     "SweepStep",
     "backend_of",
+    "base_backend",
     "build_auto_sweep_configs",
+    "build_cross_variant_sweep_configs",
     "build_sweep_steps",
     "detect_llama_devices",
     "group_by_backend",
     "is_port_free",
+    "is_valid_backend_name",
+    "is_variant",
     "load_latest_results",
     "parse_list_devices",
     "render_bench_command",
     "reset_device_cache",
+    "resolve_option_profiles",
     "selectable_devices",
     "suggest_tensor_split",
     "summarize_results",
+    "unknown_device_ids",
+    "variant_of",
 ]
 
 
+# ---------------------------------------------------------------------------
+# 2.0 バックエンド名の正規化 (基底名 + バリアント)
+# ---------------------------------------------------------------------------
+
+# llama.cpp を CUDA / Vulkan / ROCm 向けに個別ビルドしている環境では、同じ
+# "llama.cpp" でもビルドごとに実行ファイルも列挙されるデバイスも違う。これを
+# 設定・UI・API の全面で扱うため、バックエンド名に "<基底名>-<バリアント>"
+# 形式を認める:
+#
+#   llama.cpp          基底名 (素のビルド / PATH の llama-server)
+#   llama.cpp-cuda     build-cuda/bin/llama-server
+#   llama.cpp-vulkan   build-vulkan/bin/llama-server
+#   llama.cpp-rocm     build-rocm/bin/llama-server
+#
+# ★重要: バックエンド名は実行ファイルの選択だけでなく「どのフラグ体系か」
+# 「readiness を /health で見るか」「MTP を使えるか」といった挙動の分岐にも
+# 使われている。それらの分岐は必ず :func:`base_backend` を通して判定すること。
+# 素の文字列比較のままバリアント名が届くと、モデル上書きガードが無効化され
+# たり readiness が TCP connect に退行したりと、例外を出さずに壊れる
+# (docs/designs/launcher-multi-build.md §4 に全分岐の一覧がある)。
+KNOWN_BASE_BACKENDS: tuple[str, ...] = ("llama.cpp", "vllm", "mlx")
+
+# バリアント部分に許す文字。プロバイダ名・プロファイル名・ログに混ざっても
+# 壊れない集合に限定し、パス区切りやシェルメタ文字を通さない。
+_VARIANT_RE = re.compile(r"^[a-z0-9][a-z0-9._-]*$")
+
+
+def base_backend(name: str) -> str:
+    """``"llama.cpp-cuda"`` → ``"llama.cpp"``。基底名そのものはそのまま返す。
+
+    既知基底名との**最長一致**で判定する。``name.split("-", 1)[0]`` にしない
+    のは意図的で、基底名自体がハイフンを含むようになった日に静かに誤判定する
+    のを防ぐため。既知基底名で始まらない名前は加工せずそのまま返し、呼び出し
+    側の既存 "Unknown backend" 経路に委ねる。
+    """
+    best = ""
+    for base in KNOWN_BASE_BACKENDS:
+        if name == base:
+            return base
+        if name.startswith(base + "-") and len(base) > len(best):
+            best = base
+    return best or name
+
+
+def variant_of(name: str) -> str | None:
+    """``"llama.cpp-cuda"`` → ``"cuda"``。基底名そのものなら ``None``。
+
+    ``"llama.cpp-"`` のようにバリアント部が空の場合も ``None`` を返す
+    (妥当性判定は :func:`is_valid_backend_name` が担う)。
+    """
+    base = base_backend(name)
+    if base == name or not name.startswith(base + "-"):
+        return None
+    return name[len(base) + 1 :] or None
+
+
+def is_variant(name: str) -> bool:
+    """``name`` が ``<既知基底名>-<バリアント>`` 形式かどうか。"""
+    return variant_of(name) is not None
+
+
+def is_valid_backend_name(name: str) -> bool:
+    """既知基底名そのもの、または既知基底名 + 妥当なバリアントかどうか。
+
+    ``launcher.backends`` のキー検証に使う。``"llamacpp"`` (typo) や
+    ``"llama.cpp-CUDA"`` (大文字) / ``"llama.cpp-"`` (空) は False。
+    """
+    if name in KNOWN_BASE_BACKENDS:
+        return True
+    variant = variant_of(name)
+    return variant is not None and _VARIANT_RE.match(variant) is not None
+
+
+def resolve_option_profiles[P](
+    profiles_by_backend: Mapping[str, Sequence[P]], backend: str
+) -> list[P]:
+    """バックエンド(バリアント可)に適用する option_profiles を解決する。
+
+    基底名のリスト(継承)を先に、バリアント固有のリストを後に連結する。
+    ``name`` が衝突したらバリアント固有が**同じ位置で置き換える** —— 並び順を
+    安定させ、末尾に重複を作らないため。``backend`` が基底名そのものなら
+    ``profiles_by_backend.get(backend, [])`` と完全に同一の結果になる
+    (後方互換)。
+
+    要素は ``.name`` 属性を持つ任意の型でよい。pydantic の
+    ``LauncherOptionProfile`` と GUI の dataclass ``OptionProfile`` の双方から
+    使うため、この層は pydantic に依存しない (モジュール冒頭の方針どおり)。
+    """
+    base = base_backend(backend)
+    inherited = list(profiles_by_backend.get(base, []))
+    if backend == base:
+        return inherited
+    own = list(profiles_by_backend.get(backend, []))
+    if not own:
+        return inherited
+
+    by_name = {p.name: p for p in own}  # type: ignore[attr-defined]
+    merged: list[P] = []
+    replaced: set[str] = set()
+    for p in inherited:
+        name = p.name  # type: ignore[attr-defined]
+        if name in by_name:
+            merged.append(by_name[name])  # 継承分と同じ位置で差し替え
+            replaced.add(name)
+        else:
+            merged.append(p)
+    merged.extend(
+        p for p in own if p.name not in replaced  # type: ignore[attr-defined]
+    )
+    return merged
+
+
 # ---------------------------------------------------------------------------
 # 2.1 デバイス検出
 # ---------------------------------------------------------------------------
@@ -249,6 +369,24 @@ class DeviceSelection:
         return args
 
 
+def unknown_device_ids(device_ids: Sequence[str], probe: DeviceProbe) -> list[str]:
+    """``device_ids`` のうち ``probe`` に存在しないものを返す(空なら健全)。
+
+    バックエンドバリアントを切り替えるとデバイス ID の名前空間も変わる
+    (``CUDA0`` と ``Vulkan0`` は同じ GPU を指さない)。CUDA ビルドで
+    ``CUDA0`` を選んだまま Vulkan ビルドで起動すると ``--device CUDA0`` が
+    Vulkan ビルドに渡って起動失敗するので、spawn 前に弾くための判定。
+
+    ``probe.ok`` が False (``--list-devices`` 自体が失敗) のときは **常に空
+    リスト** を返す。デバイスを列挙できない環境で機能を殺さないための
+    best-effort 原則 (``hardware.py`` の 5-deps 不変則と同じ姿勢)。
+    """
+    if not probe.ok:
+        return []
+    known = {d.id for d in probe.devices}
+    return [d for d in device_ids if d not in known]
+
+
 # ---------------------------------------------------------------------------
 # 2.3 tensor-split 自動提案
 # ---------------------------------------------------------------------------
@@ -357,6 +495,36 @@ def build_auto_sweep_configs(
     return configs
 
 
+def build_cross_variant_sweep_configs(
+    probes: Sequence[tuple[str, Sequence[LlamaDevice]]],
+    *,
+    by: str = "total",
+) -> list[tuple[str, str, DeviceSelection]]:
+    """複数ビルド(バリアント)を横断するスイープ構成を生成する。
+
+    ``probes`` は ``[(backend_name, devices), ...]`` —— 各バリアントを
+    ``--list-devices`` でプローブした結果。返すのは
+    ``[(label, backend_name, DeviceSelection), ...]`` で、ラベルには
+    バリアント名を前置する (``"cuda / CUDA0 単体"``)。``{config}`` プレース
+    ホルダ経由でベンチ結果 JSON もビルド別に見分けられる。
+
+    ``build_auto_sweep_configs`` を各ビルドに対して呼ぶだけなので、
+    「バックエンド跨ぎの混成構成は作らない」という既存規則はビルド内でも
+    そのまま維持される。ビルド間の混成 (CUDA ビルドの CUDA0 と Vulkan
+    ビルドの Vulkan2 を同時に、など) は **原理的に不可能** ——1 プロセスは
+    1 つの実行ファイルでしか動かないので、ここでも作らない。
+
+    これで「同一モデルを CUDA ビルドと Vulkan ビルドで順に起動してベンチし、
+    どちらが速いか比較する」が 1 回のスイープで回る。
+    """
+    out: list[tuple[str, str, DeviceSelection]] = []
+    for backend, devices in probes:
+        prefix = variant_of(backend) or backend
+        for label, selection in build_auto_sweep_configs(devices, by=by):
+            out.append((f"{prefix} / {label}", backend, selection))
+    return out
+
+
 # ---------------------------------------------------------------------------
 # 2.4 スイープ計画・状態
 # ---------------------------------------------------------------------------
@@ -382,6 +550,10 @@ class SweepStep:
     error: str | None = None
     started_at: float = 0.0
     ended_at: float = 0.0
+    # ステップ個別のバックエンド(バリアント横断スイープ用)。None なら
+    # ``SweepPlan.backend`` を使う=従来と完全に同じ argv。末尾の任意
+    # フィールドなので既存の位置指定コンストラクタ呼び出しは無影響。
+    backend: str | None = None
 
     def as_dict(self) -> dict[str, Any]:
         return {
@@ -393,6 +565,7 @@ class SweepStep:
             "results_path": self.results_path,
             "summary": self.summary,
             "error": self.error,
+            "backend": self.backend,
         }
 
 
@@ -400,7 +573,7 @@ class SweepStep:
 class SweepPlan:
     steps: list[SweepStep]
     model_path: str
-    backend: str  # 当面 "llama.cpp"
+    backend: str  # プラン既定。step.backend が None のとき使われる
     port: int
     bench_cmd_template: str
     results_dir: str | None = None
@@ -409,9 +582,20 @@ class SweepPlan:
 
 
 def build_sweep_steps(
-    labeled: Sequence[tuple[str, DeviceSelection]],
+    labeled: Sequence[tuple[str, DeviceSelection]]
+    | Sequence[tuple[str, DeviceSelection, str | None]],
 ) -> list[SweepStep]:
-    return [SweepStep(label=lbl, selection=sel) for lbl, sel in labeled]
+    """``(label, selection)`` または ``(label, selection, backend)`` から生成。
+
+    3 要素形はバリアント横断スイープ用 (ステップごとに実行ファイルが違う)。
+    2 要素形は従来どおり ``backend=None`` になり、プラン既定で動く。
+    """
+    steps: list[SweepStep] = []
+    for item in labeled:
+        lbl, sel = item[0], item[1]
+        backend = item[2] if len(item) == 3 else None
+        steps.append(SweepStep(label=lbl, selection=sel, backend=backend))
+    return steps
 
 
 # ---------------------------------------------------------------------------

coderouter/launcher_speculative.py

@@ -45,6 +45,7 @@ import re
 from pathlib import Path
 
 from coderouter.gguf_introspect import try_read_gguf_metadata
+from coderouter.launcher_devices import base_backend
 
 __all__ = ["find_draft_companion", "resolve_speculative"]
 
@@ -248,7 +249,10 @@ def resolve_speculative(
 
     # 1. Non-llama.cpp backends do not support speculation. Reject explicit
     #    use; otherwise (auto default, no draft) stay a silent no-op.
-    if backend != _LLAMA_CPP:
+    #    ``backend`` may be a variant (``llama.cpp-cuda``) — every llama.cpp
+    #    build supports speculation, so compare the base name. A plain ``!=``
+    #    here would silently drop the spec flags for variants.
+    if base_backend(backend) != _LLAMA_CPP:
         if draft_model_path or mtp_mode == "off":
             raise ValueError(
                 "draft_model_path / mtp_mode are only supported for llama.cpp"

coderouter/launcher_swap.py

@@ -50,6 +50,7 @@ from coderouter.ingress.launcher_routes import (
     spawn_process,
     stop_process,
 )
+from coderouter.launcher_devices import resolve_option_profiles
 from coderouter.logging import get_logger
 
 logger = get_logger(__name__)
@@ -353,10 +354,18 @@ class SwapManager:
             reg.remove(proc_id)
 
     def _resolve_options(self, spec: SwapModelSpec) -> dict[str, Any]:
-        """Resolve ``spec.option_profile`` into the launcher options dict."""
+        """Resolve ``spec.option_profile`` into the launcher options dict.
+
+        ``spec.backend`` may be a variant (``llama.cpp-cuda``), in which case
+        the base backend's presets are inherited — the same merge the manual
+        UI applies, so a swap entry can reference a shared preset without
+        duplicating it under every variant key.
+        """
         if not spec.option_profile or self._launcher_cfg is None:
             return {}
-        profiles = self._launcher_cfg.option_profiles.get(spec.backend, [])
+        profiles = resolve_option_profiles(
+            self._launcher_cfg.option_profiles, spec.backend
+        )
         for p in profiles:
             if p.name == spec.option_profile:
                 return dict(p.args)

coderouter/vscode_init.py

@@ -57,8 +57,10 @@ DEFAULT_PORT = 8088
 # Bogus token — CodeRouter's chat ingress does not validate ANTHROPIC_AUTH_TOKEN
 # (real API keys are managed on the ``providers.yaml`` side). Using a
 # fixed sentinel here means we never accidentally embed the operator's
-# real token into a workspace file.
-DEFAULT_TOKEN = "dummy"  # noqa: S105 — intentional placeholder, not a secret
+# real token into a workspace file. (Not annotated with `noqa: S105`
+# because this project doesn't enable that ruff rule — RUF100 would
+# then flag the unused directive.)
+DEFAULT_TOKEN = "dummy"
 
 # VSCode reads terminal env from a separate key per host OS. Writing all
 # three means the same ``.vscode/`` folder works whether the developer

{coderouter_cli-2.10.0.dist-info → coderouter_cli-2.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 2.10.0
+Version: 2.11.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
@@ -224,6 +224,7 @@ providers:
 | **ログビューア** | 各プロセスの stdout/stderr をブラウザ内でリアルタイム確認 |
 | **provider 自動同期** (v2.7.4) | 起動したバックエンドを provider として自動登録(`launcher-llamacpp-8085` 等)。providers.yaml 無編集で `X-CodeRouter-Profile: launcher` からルーティング可能。メモリ内のみ・serve と同寿命 |
 | **モデル名パススルー** (v2.7.4) | `model: ""` の provider は `/v1/models` が上流のロード中モデル ID(gguf 名)をそのまま返す。gguf を差し替えても config 編集不要 — 外部ベンチからモデルを識別できる |
+| **特化ビルドの切り替え** (v2.11.0) | `llama.cpp-cuda` / `-vulkan` / `-rocm` を `backends` に登録すると、起動ごとにどのビルドの `llama-server` を使うか選べる。ビルド別にデバイス検出・option_profiles・ベンチスイープが独立(書かなければ従来どおり) |
 
 ```yaml
 # providers.yaml に追記するだけで有効になる

{coderouter_cli-2.10.0.dist-info → coderouter_cli-2.11.0.dist-info}/RECORD

@@ -10,14 +10,14 @@ coderouter/errors.py,sha256=Xmq67lheyw8iv3Ox39jh2c4tvNI5RcUR4QkoxVDN6l4,1130
 coderouter/gguf_introspect.py,sha256=KeE00CfbYRa4gSTrzuwC6zVuHi20IzLC4nUQa98BEXI,10387
 coderouter/hardware.py,sha256=gn3_9qbVcGRR81yKMn1lJE_8-YDRau0LxIH_M-f7pxE,8356
 coderouter/language_tax.py,sha256=LTbE3tIfoJuV2O3T0NixRKhzq_dEOTUuPEerJv2q9uk,9360
-coderouter/launcher_devices.py,sha256=SoGpzknRqvnmvg_IeXy1TkeE7aLc_MOFqLzXdd3CjVs,19275
-coderouter/launcher_speculative.py,sha256=kWaHNmhzBsbWuM_lRGDlbWkgJ1suuxBWQNTKhJOC-yg,12644
-coderouter/launcher_swap.py,sha256=W7qpdB-8Npr8yHGfx0N3SgZ2vDJ6BR9JuxW0I3TaZ-4,23783
+coderouter/launcher_devices.py,sha256=_5R7dA8tHEhwLn9VkXccLEXPJREfpHu90nYd6-cm8Xs,28180
+coderouter/launcher_speculative.py,sha256=h0RTGsD1Y56sJVywDJwybrT75_Ta3GF1Jz_B1d42aPg,12931
+coderouter/launcher_swap.py,sha256=tMW5ZElDdf9T1VQGsUkvfLiSCdj_oXN_UtkV7DE8ySY,24175
 coderouter/logging.py,sha256=5rfi4_R4aoeeUYDc642dgs61wA0aBX7wvubyB-k3Uyo,58074
 coderouter/output_filters.py,sha256=0ry_rPiS_kC-FnHgaNVP6v7e6Al2djxzu9vBzZ8kEkE,25314
 coderouter/token_estimation.py,sha256=iz22vZEEW2P7uKLB2pYvPNpIbZGbgXRO5MtfkS_-9Sk,7531
 coderouter/token_estimation_accurate.py,sha256=GTfzrBVnvAGjeVzmzAeUdOYZvWZKLAxcxPpFiJGlzjk,4609
-coderouter/vscode_init.py,sha256=fAcxJmwGXX8u0ylW0GHGACe_Co9VL6wdAKNFw7-ulwg,19952
+coderouter/vscode_init.py,sha256=ATQ1FzeQRAXfBBNcPwpEHRP4l4Yjn4hYgE-TjkcVvck,20034
 coderouter/adapters/__init__.py,sha256=7dIDSZ-FE_0iSqLSDc_lK1idRdLTKcM2hP9tCJipgPI,463
 coderouter/adapters/anthropic_native.py,sha256=CT9Hitun-c3z83YHT2zZXgwZpY3_t6eRnOfAmNud2aw,23610
 coderouter/adapters/base.py,sha256=ykKMaiIVVGr23oFFXilK2iP_YhI8-CtsEiJyFXaC9bE,10396
@@ -27,7 +27,7 @@ coderouter/config/__init__.py,sha256=FODEn74fN-qZnt4INPSHswqhOlEgpL6-_onxsitSx8g
 coderouter/config/capability_registry.py,sha256=RZgzHF54dXy0CCDocRCz2ee21qXGbbgTSKTkRI9iLL4,16936
 coderouter/config/env_file.py,sha256=CoMK27fuAXm-NtoLzXb8yN2E-wDFjHQuFwiIlmgTBQw,10356
 coderouter/config/loader.py,sha256=FUEe8m4Tnmj_aul0vSctD8vKvNW-oLRoMRbTpSKqSmc,4077
-coderouter/config/schemas.py,sha256=X2LeonDTTIkesbqzmmo3QYcD1dwmjGiCalMyS5X-A1o,120986
+coderouter/config/schemas.py,sha256=nPwaG4uIdhqoOs74nay4fPTNvEHxpsx7RhqFTZzBX-E,127468
 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
@@ -45,7 +45,7 @@ coderouter/ingress/__init__.py,sha256=WQsCH2CGJCAhy0mS6GSEdeYZRkkQu2OHDsP4CJWTLu
 coderouter/ingress/anthropic_routes.py,sha256=1ThXzx8VgxRV7UCi3NF5ey7kbr0ADPKTXyQuYS5gK1w,27063
 coderouter/ingress/app.py,sha256=6e_qNlYZIyjLKhY20t0ZNL-x5Fv8R8oaIH_HCdxa9Ic,20921
 coderouter/ingress/dashboard_routes.py,sha256=1SqNNrVTfQiZcx5n2MvjAzWirittX0e61tCt-MKp4Ag,25617
-coderouter/ingress/launcher_routes.py,sha256=lU2EILVAi-lvHBHIxyixsMTRZlp-Rv7-2sw-eW4ccYg,119687
+coderouter/ingress/launcher_routes.py,sha256=CGD_Uq8jz1qwFPQD-HXfHdB7-nD1rvPaHkpXzmTzB1w,133287
 coderouter/ingress/metrics_routes.py,sha256=M22dwOGn24P05Ge4W3c7d7mYytSGWjIR-pPSPOAiHJY,3965
 coderouter/ingress/openai_routes.py,sha256=TrugsQNJfNPgKKLzfT1aXzrs4emWYGE4XebEBuaZoWk,12505
 coderouter/metrics/__init__.py,sha256=7Es351DPS7yLM0yVF_F0eesmiD83n7Zzhie44chht38,1465
@@ -71,8 +71,8 @@ coderouter/translation/__init__.py,sha256=PYXN7XVEwpG1uC8RLy6fvnGbzEZhhrEuUapH8I
 coderouter/translation/anthropic.py,sha256=uEScq-icLn6ZXFWaxsKROv7feaq3zD0ZogjbTJ3Y7gQ,12578
 coderouter/translation/convert.py,sha256=VV4kpu4dvLmGBmJfQnCLY5ryy_AnQcV2NuwjqRtaR8Q,52633
 coderouter/translation/tool_repair.py,sha256=DGOKArM53yfVbIfiAveoul1vGq9NEKmjagf43Qh4IkM,57630
-coderouter_cli-2.10.0.dist-info/METADATA,sha256=quMG0dkYOOZpkWxidZQIxREB-vHl3-U7VktyA00bE4Y,16578
-coderouter_cli-2.10.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-coderouter_cli-2.10.0.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
-coderouter_cli-2.10.0.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
-coderouter_cli-2.10.0.dist-info/RECORD,,
+coderouter_cli-2.11.0.dist-info/METADATA,sha256=KIJ1syHgU0_eFQlBpZvaasysCEzQE5LLsITNQYP9x3o,16897
+coderouter_cli-2.11.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+coderouter_cli-2.11.0.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
+coderouter_cli-2.11.0.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
+coderouter_cli-2.11.0.dist-info/RECORD,,