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

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",
+    "foreign_device_ids",
     "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",
+    "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,36 @@ class DeviceSelection:
         return args
 
 
+def foreign_device_ids(device_ids: Sequence[str], probe: DeviceProbe) -> list[str]:
+    """``device_ids`` のうち **別ビルドの名前空間**に属するものを返す。
+
+    バックエンドバリアントを切り替えるとデバイス ID の名前空間も変わる
+    (``CUDA0`` と ``Vulkan0`` は同じ GPU を指さない)。CUDA ビルドで
+    ``CUDA0`` を選んだまま Vulkan ビルドで起動すると ``--device CUDA0`` が
+    Vulkan ビルドに渡って起動失敗するので、spawn 前に弾くための判定。
+
+    判定は **id の完全一致ではなくバックエンド接頭辞** (:func:`backend_of` —
+    ``"CUDA0"`` → ``"CUDA"``) で行う。理由は 2 つある:
+
+    1. 検出したいのは「ビルド違い」= 名前空間そのものの不一致であって、
+       同一ビルド内の番号ズレではない。UI はチェックボックスから id を渡す
+       ので番号ズレは実際には起きない。
+    2. 完全一致にすると ``--list-devices`` の出力形式が将来変わって
+       :func:`parse_list_devices` が一部の行だけ取りこぼした場合に、**正しい
+       id を誤って拒否してしまう**。接頭辞単位なら 1 行でも同じ接頭辞が
+       拾えていれば通る。
+
+    ``probe.ok`` が False (``--list-devices`` 自体が失敗) のときと、デバイス
+    を 1 つも拾えなかったときは **常に空リスト** を返す。列挙できない環境で
+    機能を殺さないための best-effort 原則 (``hardware.py`` の 5-deps 不変則と
+    同じ姿勢)。
+    """
+    if not probe.ok or not probe.devices:
+        return []
+    known_prefixes = {backend_of(d.id) for d in probe.devices}
+    return [d for d in device_ids if backend_of(d) not in known_prefixes]
+
+
 # ---------------------------------------------------------------------------
 # 2.3 tensor-split 自動提案
 # ---------------------------------------------------------------------------
@@ -357,6 +507,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 +562,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 +577,7 @@ class SweepStep:
             "results_path": self.results_path,
             "summary": self.summary,
             "error": self.error,
+            "backend": self.backend,
         }
 
 
@@ -400,7 +585,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 +594,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/routing/fallback.py

@@ -2911,7 +2911,15 @@ class FallbackEngine:
                     chat_req = to_chat_request(effective_request)
                     chat_req.stream = False
                     chat_resp = await adapter.generate(chat_req, overrides=overrides)
-                    resp = to_anthropic_response(chat_resp, allowed_tool_names=tool_names)
+                    # H-4: the translation hop runs the tool-call repair
+                    # scanners over the whole assistant message. That is CPU
+                    # work, not I/O, so it is pushed onto a worker thread —
+                    # a pathological message must not stall the event loop
+                    # for every other in-flight request. `to_anthropic_response`
+                    # itself stays synchronous (many callers depend on it).
+                    resp = await asyncio.to_thread(
+                        to_anthropic_response, chat_resp, allowed_tool_names=tool_names
+                    )
             except AdapterError as exc:
                 # v1.9-C: record the failure with its observed latency.
                 # Auth-flavored failures (401 / 403) carry no useful
@@ -3223,7 +3231,11 @@ class FallbackEngine:
                     chat_req = to_chat_request(effective_request)
                     chat_req.stream = False
                     chat_resp = await adapter.generate(chat_req, overrides=overrides)
-                    anth_resp = to_anthropic_response(chat_resp, allowed_tool_names=tool_names)
+                    # H-4: same as the non-streaming branch — keep the
+                    # CPU-bound repair scan off the event loop.
+                    anth_resp = await asyncio.to_thread(
+                        to_anthropic_response, chat_resp, allowed_tool_names=tool_names
+                    )
                     event_iter = synthesize_anthropic_stream_from_response(anth_resp)
                     first = await anext(event_iter)
                 else:

coderouter/translation/anthropic.py

@@ -321,7 +321,20 @@ class AnthropicResponse(BaseModel):
     role: Literal["assistant"] = "assistant"
     model: str
     content: list[dict[str, Any]]
-    stop_reason: Literal["end_turn", "max_tokens", "stop_sequence", "tool_use"] | None = None
+    # H-6: intentionally `str | None`, NOT a closed `Literal[...]`. Anthropic
+    # adds new stop_reason values over time (observed additions: pause_turn
+    # for long-running server-side-tool turns, refusal for safety-classifier
+    # stops, model_context_window_exceeded); a closed Literal rejects any
+    # response using a value minted after this code was written, which
+    # pydantic surfaces as a ValidationError that the adapter turns into a
+    # retryable AdapterError — silently discarding an already-billed,
+    # perfectly valid response and falling back to another provider. Known
+    # values as of writing: end_turn, max_tokens, stop_sequence, tool_use,
+    # pause_turn, refusal, model_context_window_exceeded. Other models in
+    # this module already use `extra="allow"` for the same forward-
+    # compatibility reason; this keeps that policy consistent for a
+    # declared field, which `extra="allow"` alone does not cover.
+    stop_reason: str | None = None
     stop_sequence: str | None = None
     usage: AnthropicUsage = Field(default_factory=AnthropicUsage)
 

coderouter/translation/convert.py

@@ -846,6 +846,13 @@ _REVERSE_FINISH_REASON_MAP = {
     "max_tokens": "length",
     "tool_use": "tool_calls",
     "stop_sequence": "stop",
+    # H-6: forward-compat stop_reason values (see translation/anthropic.py).
+    # The `.get(..., "stop")` fallback at each call site already keeps these
+    # from raising; mapping them explicitly just makes the OpenAI-shaped
+    # finish_reason semantically accurate instead of a generic "stop".
+    "pause_turn": "stop",
+    "refusal": "content_filter",
+    "model_context_window_exceeded": "length",
 }