coderouter-cli 2.7.2__py3-none-any.whl → 2.7.4__py3-none-any.whl

coderouter/config/schemas.py

@@ -718,6 +718,57 @@ class FallbackChain(BaseModel):
         ),
     )
 
+    # --- ⑧ (empty-response): per-request empty-response fallback ------------
+    #
+    # Some local backends (observed: gemma4:26b on ``no_tool_temptation``
+    # prompts) return a 200 with a structurally-valid but *content-empty*
+    # Anthropic response — no tool_use and no non-whitespace text — for a
+    # fraction of requests. The drift guard's ``empty_response_rate`` is a
+    # windowed aggregate (default threshold 0.3, ``min_window_fill`` 6): it
+    # promotes/reloads a backend once the *rate* is bad, but cannot rescue a
+    # single blank turn in-flight. This knob adds a per-request in-flight
+    # fallback that re-dispatches the *same* request to the next provider in
+    # the chain the moment an empty response is detected.
+    #
+    # Design: "empty" is judged on *content*, not usage.output_tokens (which
+    # some backends report unreliably). A response is empty when its content
+    # list is empty, or every block is either a whitespace-only ``text`` block
+    # or a ``thinking`` block — i.e. nothing the client can act on. A single
+    # ``tool_use`` block or one non-whitespace ``text`` block makes it non-empty.
+    #
+    #   * ``off``      — no detection, no fallback, no log. Backward-compatible
+    #                    default (byte-for-byte identical to pre-⑧ behavior).
+    #   * ``warn``     — detect + emit an ``empty-response-detected`` log line
+    #                    only; the empty response is returned unchanged.
+    #   * ``fallback`` — on an empty response, log ``empty-response-detected``
+    #                    and continue to the next provider (the empty response
+    #                    is *not* recorded as an error). If every provider in
+    #                    the chain returns empty, the last empty response is
+    #                    returned as-is (a 200 blank is a legitimate answer)
+    #                    with ``chain_exhausted=True`` on the log line. On the
+    #                    streaming path, ``fallback`` buffers events until real
+    #                    content is observed, so an empty stream can be swapped
+    #                    to the next provider without the client seeing bytes.
+    #
+    # Default ``off`` preserves complete backward compatibility; the original
+    # request object is never mutated, so a later provider always receives the
+    # untouched request.
+    empty_response_action: Literal["off", "warn", "fallback"] = Field(
+        default="off",
+        description=(
+            "⑧ (empty-response): action when a provider returns a 200 with "
+            "empty content (no tool_use and no non-whitespace text; a "
+            "thinking-only response counts as empty). ``off`` (default) does "
+            "nothing. ``warn`` emits an ``empty-response-detected`` log only "
+            "and returns the empty response. ``fallback`` re-dispatches the "
+            "same request to the next provider (empty is not counted as an "
+            "error); if the whole chain returns empty, the last empty response "
+            "is returned unchanged. Streaming buffers events until real "
+            "content appears so empty streams can be swapped provider-side "
+            "without the client seeing any bytes."
+        ),
+    )
+
     # --- S2 (shim): tool_choice capability gate + emulation -----------------
     #
     # Anthropic clients (Claude Code, SDKs) can pin the model to a specific

coderouter/ingress/launcher_routes.py

@@ -655,6 +655,28 @@ async def api_backends(request: Request) -> dict[str, Any]:
     return {"backends": result}
 
 
+def _launcher_provider_config(backend: str, port: int) -> Any:
+    """Build the provider entry for a launcher-started backend.
+
+    ``model`` is left EMPTY on purpose: llama-server / vllm / mlx decide
+    which model is actually loaded, and the empty-model /v1/models
+    passthrough then surfaces the upstream's real model id to benchmark
+    clients — swap the GGUF, no config edit needed.
+
+    Name embeds backend + port (``launcher-llamacpp-8085``) so restarting
+    on the same port REPLACES the entry instead of piling up duplicates.
+    """
+    from coderouter.config.schemas import ProviderConfig
+
+    safe_backend = backend.replace(".", "")
+    return ProviderConfig(
+        name=f"launcher-{safe_backend}-{port}",
+        base_url=f"http://localhost:{port}/v1",
+        model="",
+        timeout_s=120.0,
+    )
+
+
 @router.post("/api/launcher/start")
 async def api_start(req: StartRequest, request: Request) -> dict[str, Any]:
     """Start a new backend process."""
@@ -717,7 +739,35 @@ async def api_start(req: StartRequest, request: Request) -> dict[str, Any]:
     _background_tasks.add(_task)
     _task.add_done_callback(_background_tasks.discard)
 
-    return {"id": proc_id, "pid": p.pid, "command": cmd}
+    # Provider auto-sync: register the just-started backend as a routable
+    # provider so requests can reach it without hand-editing providers.yaml
+    # (in-memory only — see FallbackEngine.register_provider docstring).
+    # Sync failure must never fail the start itself.
+    provider_sync: dict[str, Any] | None = None
+    engine = getattr(request.app.state, "engine", None)
+    if engine is not None and hasattr(engine, "register_provider"):
+        try:
+            provider_sync = engine.register_provider(
+                _launcher_provider_config(req.backend, req.port)
+            )
+            proc.log_tail.append(
+                "[launcher] provider sync: "
+                f"{provider_sync['provider']} -> profile "
+                f"'{provider_sync['profile']}' (in-memory)"
+            )
+        except Exception as exc:
+            logger.warning(
+                "launcher provider sync failed",
+                extra={"backend": req.backend, "port": req.port, "error": str(exc)},
+            )
+            proc.log_tail.append(f"[launcher] provider sync failed: {exc}")
+
+    return {
+        "id": proc_id,
+        "pid": p.pid,
+        "command": cmd,
+        "provider_sync": provider_sync,
+    }
 
 
 @router.post("/api/launcher/stop/{proc_id}")

coderouter/ingress/openai_routes.py

@@ -78,22 +78,99 @@ def _resolve_stream_timeout_s(engine: FallbackEngine, profile: str | None) -> fl
     return max(_STREAM_TIMEOUT_MIN_S, float(per_call) * _STREAM_TIMEOUT_MULTIPLIER)
 
 
+# --- /v1/models upstream passthrough -------------------------------------
+#
+# Providers with an *empty* ``model`` field are passthrough providers: the
+# upstream (llama-server, LM Studio, ...) decides which model is loaded and
+# CodeRouter never sends a model name. For those providers the historic
+# behaviour — returning the provider *name* — makes external benchmarks
+# indistinguishable across loaded GGUFs (the launcher_gui setup always
+# reported ``llama-cpp-local`` regardless of the selected model). We now ask
+# the upstream's own ``/models`` endpoint for its real model id(s) and
+# surface those instead.
+#
+# Guards: only for ``kind == "openai_compat"`` with ``model == ""``; a short
+# per-upstream TTL cache keeps repeated SDK probes cheap; ANY failure (refused
+# connection, timeout, unexpected shape) falls back to the historic
+# provider-name entry, so this is strictly additive. Providers with a
+# configured model keep the exact previous behaviour.
+
+_UPSTREAM_MODELS_TTL_S = 30.0
+_UPSTREAM_MODELS_TIMEOUT_S = 2.0
+# base_url -> (expires_monotonic, ids)
+_upstream_models_cache: dict[str, tuple[float, list[str]]] = {}
+
+
+async def _fetch_upstream_model_ids(base_url: str) -> list[str]:
+    """GET {base_url}/models and return the upstream model ids.
+
+    Raises on any transport / shape problem — the caller treats every
+    exception as "fall back to the provider-name entry".
+    """
+    import httpx  # local import keeps module import time flat
+
+    url = base_url.rstrip("/") + "/models"
+    async with httpx.AsyncClient(timeout=_UPSTREAM_MODELS_TIMEOUT_S) as client:
+        resp = await client.get(url)
+        resp.raise_for_status()
+        payload = resp.json()
+    ids = [
+        str(item["id"])
+        for item in payload.get("data", [])
+        if isinstance(item, dict) and item.get("id")
+    ]
+    if not ids:
+        raise ValueError(f"upstream {url} returned no model ids")
+    return ids
+
+
+async def _upstream_model_ids_cached(base_url: str) -> list[str]:
+    """TTL-cached wrapper around :func:`_fetch_upstream_model_ids`."""
+    now = time.monotonic()
+    hit = _upstream_models_cache.get(base_url)
+    if hit is not None and hit[0] > now:
+        return hit[1]
+    ids = await _fetch_upstream_model_ids(base_url)
+    _upstream_models_cache[base_url] = (now + _UPSTREAM_MODELS_TTL_S, ids)
+    return ids
+
+
 @router.get("/models")
 async def list_models(request: Request) -> dict[str, object]:
-    """Minimal /v1/models so OpenAI SDKs that probe it don't choke."""
+    """/v1/models: provider names, with upstream passthrough for empty-model
+    providers (see the passthrough note above)."""
     config = request.app.state.config
-    return {
-        "object": "list",
-        "data": [
+    created = int(time.time())
+    data: list[dict[str, object]] = []
+    for p in config.providers:
+        if p.model == "" and p.kind == "openai_compat":
+            try:
+                ids = await _upstream_model_ids_cached(str(p.base_url))
+            except Exception:  # any failure means "no passthrough"
+                logger.debug(
+                    "models passthrough failed; falling back to provider name",
+                    extra={"provider": p.name},
+                )
+            else:
+                data.extend(
+                    {
+                        "id": model_id,
+                        "object": "model",
+                        "created": created,
+                        "owned_by": f"coderouter/{p.name}",
+                    }
+                    for model_id in ids
+                )
+                continue
+        data.append(
             {
                 "id": p.name,
                 "object": "model",
-                "created": int(time.time()),
+                "created": created,
                 "owned_by": "coderouter",
             }
-            for p in config.providers
-        ],
-    }
+        )
+    return {"object": "list", "data": data}
 
 
 @router.post("/chat/completions", response_model=None)

coderouter/logging.py

@@ -1372,6 +1372,46 @@ def log_partial_stitch_surfaced(
     )
 
 
+# ---------------------------------------------------------------------------
+# ⑧ (empty-response): per-request empty-response fallback log shape
+#
+# Fired when a provider returns a 200 with content-empty output (no
+# tool_use and no non-whitespace text). The single event lane carries the
+# ``action`` (warn|fallback) that triggered it, whether the empty response
+# came from the streaming or non-streaming path, and ``chain_exhausted``
+# — True only when every provider in the chain returned empty and the last
+# empty response is being returned to the client as-is.
+# ---------------------------------------------------------------------------
+
+
+def log_empty_response_detected(
+    logger: logging.Logger,
+    provider: str,
+    *,
+    action: str,
+    stream: bool,
+    chain_exhausted: bool = False,
+) -> None:
+    """Emit an ``empty-response-detected`` warn line.
+
+    Fired when ``empty_response_action`` is ``warn`` or ``fallback`` and a
+    provider returns a structurally-valid but content-empty response. The
+    ``action`` field records which knob value produced the line; ``stream``
+    distinguishes the SSE path from the non-streaming path; ``chain_exhausted``
+    is True only when the whole chain returned empty and the last empty
+    response is being returned unchanged.
+    """
+    logger.warning(
+        "empty-response-detected",
+        extra={
+            "provider": provider,
+            "action": action,
+            "stream": stream,
+            "chain_exhausted": chain_exhausted,
+        },
+    )
+
+
 # ---------------------------------------------------------------------------
 # v2.0-I: Continuous probe log shapes
 #

coderouter/metrics/collector.py

@@ -52,6 +52,7 @@ Event inventory (dispatch table in :meth:`MetricsCollector._dispatch`)
     ``drift-promoted`` (v2.0-G)  → ``drift_promoted_total``
     ``drift-reload-attempted``   → ``drift_reload_total`` / success
     ``partial-stitch-surfaced``  → ``partial_stitch_surfaced_total`` (v2.0-H)
+    ``empty-response-detected``  → ``empty_responses_total`` + per-provider (⑧)
     ``probe-completed`` (v2.0-I) → ``probe_total`` / ``probe_success`` / ``probe_failure``
                                    + per-provider latency gauge
     ``probe-round-completed``    → ``probe_rounds_total`` (v2.0-I)
@@ -109,6 +110,7 @@ _KNOWN_EVENTS: Final[frozenset[str]] = frozenset(
         "drift-promoted",
         "drift-reload-attempted",
         "partial-stitch-surfaced",
+        "empty-response-detected",
         "probe-completed",
         "probe-round-completed",
         "probe-capabilities-drift",
@@ -272,6 +274,13 @@ class MetricsCollector(logging.Handler):
         # client instead of a generic error event.
         self._partial_stitch_surfaced_total: int = 0
 
+        # ⑧ (empty-response): count of per-request empty-response detections
+        # (both ``warn`` and ``fallback`` actions). Aggregate + per-provider
+        # so a dashboard can spot which backend blanks out. Counts every
+        # detection event, including the terminal chain-exhausted one.
+        self._empty_responses_total: int = 0
+        self._empty_responses_by_provider: Counter[str] = Counter()
+
         # v2.0-I: continuous probe counters. Per-provider probe attempts
         # and outcomes, plus a round counter for the dashboard's
         # "probes/min" panel.
@@ -329,6 +338,7 @@ class MetricsCollector(logging.Handler):
             "drift-promoted": self._on_drift_promoted,
             "drift-reload-attempted": self._on_drift_reload_attempted,
             "partial-stitch-surfaced": self._on_partial_stitch_surfaced,
+            "empty-response-detected": self._on_empty_response_detected,
             "probe-completed": self._on_probe_completed,
             "probe-round-completed": self._on_probe_round_completed,
             "probe-capabilities-drift": self._on_probe_capabilities_drift,
@@ -670,6 +680,17 @@ class MetricsCollector(logging.Handler):
         self._partial_stitch_surfaced_total += 1
         self._push_recent("partial-stitch-surfaced", extras, record)
 
+    def _on_empty_response_detected(
+        self, extras: dict[str, Any], record: logging.LogRecord
+    ) -> None:
+        # ⑧ (empty-response): a content-empty 200 was detected under a
+        # ``warn`` / ``fallback`` action.
+        self._empty_responses_total += 1
+        provider = _str(extras.get("provider"))
+        if provider:
+            self._empty_responses_by_provider[provider] += 1
+        self._push_recent("empty-response-detected", extras, record)
+
     def _on_probe_completed(
         self, extras: dict[str, Any], record: logging.LogRecord
     ) -> None:
@@ -888,6 +909,11 @@ class MetricsCollector(logging.Handler):
                     "drift_reload_success_total": self._drift_reload_success_total,
                     # v2.0-H (L6): partial stitch surfaced.
                     "partial_stitch_surfaced_total": self._partial_stitch_surfaced_total,
+                    # ⑧ (empty-response): per-request empty-response fallback.
+                    "empty_responses_total": self._empty_responses_total,
+                    "empty_responses_by_provider": dict(
+                        self._empty_responses_by_provider
+                    ),
                     # v2.0-I: continuous probe counters.
                     "probe_total": dict(self._probe_total),
                     "probe_success": dict(self._probe_success),
@@ -1042,6 +1068,9 @@ class MetricsCollector(logging.Handler):
             self._tokens_saved_by_mechanism.clear()
             # v2.0-H (L6)
             self._partial_stitch_surfaced_total = 0
+            # ⑧ (empty-response)
+            self._empty_responses_total = 0
+            self._empty_responses_by_provider.clear()
             # v2.0-I
             self._probe_total.clear()
             self._probe_success.clear()

coderouter/routing/fallback.py

@@ -76,6 +76,7 @@ from coderouter.logging import (
     log_chain_memory_pressure_blocked,
     log_chain_paid_gate_blocked,
     log_demote_unhealthy_provider,
+    log_empty_response_detected,
     log_memory_pressure_detected,
     log_skip_budget_exceeded,
     log_skip_memory_pressure,
@@ -973,6 +974,82 @@ def _warn_if_uniform_auth_failure(errors: list[AdapterError], *, profile: str) -
     )
 
 
+# ---------------------------------------------------------------------------
+# ⑧ (empty-response): content-based emptiness judgement + stream buffering
+# ---------------------------------------------------------------------------
+
+
+def _block_field(block: Any, key: str) -> Any:
+    """Read ``key`` from a content block whether it is a dict or a model.
+
+    Anthropic content blocks reach the engine as plain dicts (openai_compat
+    translation, most test fakes) or as pydantic-ish objects (native
+    passthrough). This mirrors the accessor pattern already used by the
+    drift fingerprint at the success-path tail.
+    """
+    if isinstance(block, dict):
+        return block.get(key)
+    return getattr(block, key, None)
+
+
+def _anthropic_response_is_empty(resp: AnthropicResponse) -> bool:
+    """Return True when ``resp`` carries no client-actionable content.
+
+    "Empty" is judged on content, never on ``usage.output_tokens`` (some
+    backends report that unreliably). A response is empty when:
+        - its ``content`` list is empty / falsy, or
+        - every block is either a whitespace-only ``text`` block or a
+          ``thinking`` block.
+
+    A single ``tool_use`` block, or one ``text`` block with any
+    non-whitespace character, makes the response non-empty. Unknown block
+    types are treated conservatively as *content* (non-empty) so a novel
+    actionable block is never silently swallowed.
+    """
+    content = getattr(resp, "content", None)
+    if not content:
+        return True
+    for block in content:
+        btype = _block_field(block, "type")
+        if btype == "text":
+            text = _block_field(block, "text") or ""
+            if text.strip():
+                return False
+            # whitespace-only text → keep scanning
+            continue
+        if btype == "thinking":
+            # thinking-only carries nothing the client can act on
+            continue
+        # tool_use or any other (unknown → conservatively non-empty) block
+        return False
+    return True
+
+
+def _stream_event_is_real_content(event: AnthropicStreamEvent) -> bool:
+    """Return True when ``event`` is the first byte of actionable content.
+
+    Real content is either a ``content_block_start`` opening a ``tool_use``
+    block, or a ``content_block_delta`` carrying a non-whitespace text
+    delta. ``message_start`` / ``ping`` / empty-text openers do not count —
+    they are the buffered preamble that an empty stream also emits.
+    """
+    data = getattr(event, "data", None) or {}
+    etype = data.get("type") if isinstance(data, dict) else None
+    if etype == "content_block_start":
+        block = data.get("content_block") or {}
+        return isinstance(block, dict) and block.get("type") == "tool_use"
+    if etype == "content_block_delta":
+        delta = data.get("delta") or {}
+        if isinstance(delta, dict):
+            # text_delta with non-whitespace text is real content;
+            # input_json_delta (tool args) is real content too.
+            if delta.get("type") == "text_delta":
+                return bool((delta.get("text") or "").strip())
+            if delta.get("type") == "input_json_delta":
+                return True
+    return False
+
+
 class FallbackEngine:
     """Sequential fallback router — the core of CodeRouter.
 
@@ -1096,6 +1173,80 @@ class FallbackEngine:
         # v2.0-K: persistent state store (None = in-memory only).
         self._state_store: StateStore | None = None
 
+    def register_provider(
+        self, provider: ProviderConfig, profile_name: str = "launcher"
+    ) -> dict[str, Any]:
+        """Register (or update) a provider at runtime — launcher auto-sync.
+
+        Motivation: the embedded launcher can start a llama.cpp / vllm /
+        mlx backend on an arbitrary port, but routing is driven entirely
+        by providers.yaml — historically the operator had to hand-edit the
+        config or the new backend was simply unreachable (observed in the
+        wild as "launcher started on 8085, providers.yaml pointed at
+        8080"). This method closes that gap in-process:
+
+        - the provider entry is appended to ``config.providers`` (or, when
+          a provider with the same *name* already exists, its config entry
+          and cached adapter are REPLACED — the launcher restarting a
+          backend on the same port lands here),
+        - an adapter is built and cached alongside the static ones,
+        - the ``profile_name`` chain is created on demand, and the
+          provider is moved to the FRONT of that chain (most recently
+          launched backend wins the launcher profile).
+
+        Deliberately **in-memory only** — no providers.yaml rewrite. A
+        YAML round-trip would destroy operator comments (and a
+        comment-preserving writer means a new dependency), and the
+        launcher's process registry is itself in-memory by design: both
+        the process and its provider entry share the lifetime of this
+        server process. ``default_profile`` is never touched — routing to
+        the launcher profile stays an explicit opt-in
+        (``X-CodeRouter-Profile: launcher`` or body ``profile``).
+
+        Returns a small summary dict for the launcher API response.
+        """
+        from coderouter.config.schemas import FallbackChain
+
+        replaced = False
+        for i, existing in enumerate(self.config.providers):
+            if existing.name == provider.name:
+                self.config.providers[i] = provider
+                replaced = True
+                break
+        if not replaced:
+            self.config.providers.append(provider)
+        self._adapters[provider.name] = build_adapter(provider)
+
+        try:
+            chain = self.config.profile_by_name(profile_name)
+        except KeyError:
+            chain = FallbackChain(name=profile_name, providers=[provider.name])
+            self.config.profiles.append(chain)
+        else:
+            if provider.name in chain.providers:
+                chain.providers.remove(provider.name)
+            chain.providers.insert(0, provider.name)
+
+        logger.info(
+            "launcher provider sync: registered %s -> %s (profile %r)",
+            provider.name,
+            provider.base_url,
+            profile_name,
+            extra={
+                "provider": provider.name,
+                "base_url": str(provider.base_url),
+                "profile": profile_name,
+                "replaced": replaced,
+            },
+        )
+        return {
+            "provider": provider.name,
+            "base_url": str(provider.base_url),
+            "profile": profile_name,
+            "replaced": replaced,
+            "persisted": False,  # in-memory only, by design (see docstring)
+        }
+
     @property
     def plugins(self) -> PluginRegistry:
         """Return the plugin registry, lazily building an empty one if absent.
@@ -1717,6 +1868,20 @@ class FallbackEngine:
             getattr(profile, "cache_control_action", "off"),
         )
 
+    def _resolve_empty_response_action(self, profile_name: str | None) -> str:
+        """⑧ (empty-response): resolve ``empty_response_action`` for a profile.
+
+        Defaults to ``off`` so a missing / stub profile (e.g. a
+        ``__new__``-constructed test engine) yields the backward-compatible
+        no-op. Resolved once at the top of each Anthropic entry point.
+        """
+        chosen = profile_name or self.config.default_profile
+        try:
+            profile = self.config.profile_by_name(chosen)
+        except (KeyError, ValueError):
+            return "off"
+        return getattr(profile, "empty_response_action", "off")
+
     def _resolve_chain(self, profile_name: str | None) -> list[BaseAdapter]:
         """Return the list of adapters to try, in order, for this profile.
 
@@ -2431,6 +2596,11 @@ class FallbackEngine:
         tool_choice_action, cache_control_action = self._resolve_shim_actions(
             request.profile
         )
+        # ⑧ (empty-response): resolve the per-request empty-response action
+        # once. ``last_empty_resp`` holds the most recent content-empty 200
+        # under ``fallback`` so a fully-empty chain returns it verbatim.
+        empty_response_action = self._resolve_empty_response_action(request.profile)
+        last_empty_resp: AnthropicResponse | None = None
 
         for adapter, will_degrade in chain:
             is_native = isinstance(adapter, AnthropicAdapter)
@@ -2585,6 +2755,26 @@ class FallbackEngine:
                 stream=False,
                 response_fingerprint=_fp(_fp_text) if _fp_text else None,
             )
+            # ⑧ (empty-response): per-request empty-response handling. Runs
+            # after the drift observation above (which still gets the real
+            # output_tokens=0 signal for the windowed empty_response_rate)
+            # but before the cache-observed / observer fanout, so a
+            # ``fallback`` swap does not emit a "completed" line for a
+            # response the client never sees.
+            if empty_response_action != "off" and _anthropic_response_is_empty(resp):
+                if empty_response_action == "fallback":
+                    # Remember this empty response so a fully-empty chain can
+                    # return it verbatim, then try the next provider. Not
+                    # recorded in ``errors`` — a 200 blank is not a failure.
+                    last_empty_resp = resp
+                    log_empty_response_detected(
+                        logger, adapter.name, action="fallback", stream=False
+                    )
+                    continue
+                # ``warn``: log only; fall through and return the empty resp.
+                log_empty_response_detected(
+                    logger, adapter.name, action="warn", stream=False
+                )
             # v1.9-A: pair every successful Anthropic response with a
             # cache-observed log line. Native Anthropic / LM Studio
             # /v1/messages report cache_read_input_tokens /
@@ -2625,6 +2815,20 @@ class FallbackEngine:
             )
             return resp
 
+        # ⑧ (empty-response): the chain is exhausted. Under ``fallback``,
+        # if every provider that answered returned an empty 200, return the
+        # last empty response verbatim (a 200 blank is a legitimate answer)
+        # rather than raising — errors is empty in that case anyway.
+        if last_empty_resp is not None:
+            log_empty_response_detected(
+                logger,
+                last_empty_resp.coderouter_provider or "unknown",
+                action="fallback",
+                stream=False,
+                chain_exhausted=True,
+            )
+            return last_empty_resp
+
         profile = request.profile or self.config.default_profile
         _warn_if_uniform_auth_failure(errors, profile=profile)
         raise NoProvidersAvailableError(profile=profile, errors=errors)
@@ -2676,6 +2880,15 @@ class FallbackEngine:
         tool_choice_action, cache_control_action = self._resolve_shim_actions(
             request.profile
         )
+        # ⑧ (empty-response): resolve the per-request empty-response action.
+        # Only ``fallback`` changes the streaming path (it buffers events
+        # until real content appears); ``off`` / ``warn`` stream unchanged.
+        # ``last_empty_stream_buffer`` holds the buffered preamble of the
+        # most recent empty stream so a fully-empty chain can flush it and
+        # terminate normally rather than raising.
+        empty_response_action = self._resolve_empty_response_action(request.profile)
+        empty_fallback = empty_response_action == "fallback"
+        last_empty_stream_buffer: list[AnthropicStreamEvent] | None = None
 
         for adapter, will_degrade in chain:
             is_native = isinstance(adapter, AnthropicAdapter)
@@ -2828,15 +3041,59 @@ class FallbackEngine:
             self._observe_provider_success(
                 adapter.name, profile=request.profile
             )
-            acc.observe(first)
-            yield first
+            # ⑧ (empty-response): under ``fallback`` we withhold the opening
+            # events (message_start / empty content_block_start / ping) from
+            # the client until the *first real content* event is observed.
+            # Because no bytes have reached the client, an empty stream can
+            # still be swapped for the next provider. ``off`` / ``warn`` keep
+            # the legacy immediate-yield behavior (byte-for-byte unchanged).
+            #
+            # ``content_started`` flips True the moment real content is seen
+            # (or immediately, when the action is not ``fallback``); from
+            # then on events pass straight through and the mid-stream guard
+            # is live exactly as before.
+            content_started = not empty_fallback
+            buffer: list[AnthropicStreamEvent] = []
             # Mid-stream guard identical to stream() — any error after the
-            # first event is terminal.
+            # first *forwarded* event is terminal.
             try:
-                async for ev in event_iter:
+                # Seed the loop with the already-fetched ``first`` event,
+                # then drain the rest of the iterator.
+                pending = first
+                iterator = event_iter.__aiter__()
+                while True:
+                    ev = pending
                     acc.observe(ev)
-                    yield ev
+                    if content_started:
+                        yield ev
+                    else:
+                        buffer.append(ev)
+                        if _stream_event_is_real_content(ev):
+                            # Real content arrived — flush the withheld
+                            # preamble in order, then switch to passthrough.
+                            content_started = True
+                            for buffered_ev in buffer:
+                                yield buffered_ev
+                            buffer = []
+                    try:
+                        pending = await iterator.__anext__()
+                    except StopAsyncIteration:
+                        break
             except AdapterError as exc:
+                if not content_started:
+                    # Empty-stream failure before any real content under
+                    # ``fallback``: nothing reached the client, so treat it
+                    # like an empty response and try the next provider. Do
+                    # NOT raise MidStreamError (that would surface to the
+                    # client). Record the error-only observation for adaptive.
+                    self._adaptive.record_attempt(
+                        adapter.name, latency_ms=None, success=False
+                    )
+                    log_empty_response_detected(
+                        logger, adapter.name, action="fallback", stream=True
+                    )
+                    last_empty_stream_buffer = buffer
+                    continue
                 # M2: mid-stream failure — record an error-only
                 # observation (no latency; first-event success already
                 # recorded) so adaptive error rate reflects the breakage.
@@ -2868,6 +3125,17 @@ class FallbackEngine:
                 raise MidStreamError(
                     adapter.name, exc, partial_content=acc.partial_content
                 ) from exc
+            # ⑧ (empty-response): the stream ended cleanly but no real
+            # content was ever observed under ``fallback`` — the preamble is
+            # still buffered (never sent). Treat as an empty response: keep
+            # the buffer for a possible chain-exhausted flush and try the
+            # next provider.
+            if empty_fallback and not content_started:
+                log_empty_response_detected(
+                    logger, adapter.name, action="fallback", stream=True
+                )
+                last_empty_stream_buffer = buffer
+                continue
             # v2.0-G (L4): drift detection observation (stream success).
             # P1-4: compute response fingerprint for goal_progress_stall.
             _stream_fp_text = " ".join(
@@ -2923,6 +3191,23 @@ class FallbackEngine:
             )
             return
 
+        # ⑧ (empty-response): the chain is exhausted under ``fallback`` and
+        # every provider produced an empty stream. Flush the last buffered
+        # (empty) preamble so the client gets a well-formed, terminating SSE
+        # sequence (message_start … message_stop) instead of an error — a
+        # 200 blank is a legitimate answer. errors is empty in that case.
+        if last_empty_stream_buffer is not None:
+            log_empty_response_detected(
+                logger,
+                "unknown",
+                action="fallback",
+                stream=True,
+                chain_exhausted=True,
+            )
+            for buffered_ev in last_empty_stream_buffer:
+                yield buffered_ev
+            return
+
         profile = request.profile or self.config.default_profile
         _warn_if_uniform_auth_failure(errors, profile=profile)
         raise NoProvidersAvailableError(profile=profile, errors=errors)

{coderouter_cli-2.7.2.dist-info → coderouter_cli-2.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 2.7.2
+Version: 2.7.4
 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
@@ -220,6 +220,8 @@ providers:
 | **オプションプロファイル** | `providers.yaml` に名前付きプリセットを定義 → ドロップダウンで選択するだけ |
 | **複数プロセス管理** | llama.cpp と vllm を同時に起動し、ポートごとに独立管理 |
 | **ログビューア** | 各プロセスの 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 編集不要 — 外部ベンチからモデルを識別できる |
 
 ```yaml
 # providers.yaml に追記するだけで有効になる

{coderouter_cli-2.7.2.dist-info → coderouter_cli-2.7.4.dist-info}/RECORD

@@ -10,7 +10,7 @@ coderouter/errors.py,sha256=Xmq67lheyw8iv3Ox39jh2c4tvNI5RcUR4QkoxVDN6l4,1130
 coderouter/gguf_introspect.py,sha256=FZO14STLSp94Rfo5AInGwYUOpfjiXOW6CH5RiczTWDE,9514
 coderouter/hardware.py,sha256=gn3_9qbVcGRR81yKMn1lJE_8-YDRau0LxIH_M-f7pxE,8356
 coderouter/language_tax.py,sha256=LTbE3tIfoJuV2O3T0NixRKhzq_dEOTUuPEerJv2q9uk,9360
-coderouter/logging.py,sha256=ZHEgkWG1J7VkgL6pNzGJHRXRq_LB_Hcbl0VOG0phke8,54609
+coderouter/logging.py,sha256=91cveN8SCJEMNz9DGi6TrFSlc8cx0wdUkOdSLWLA-z8,56144
 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
@@ -23,7 +23,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=JmoUl5gCRucib940I3oFVMp8Om9Cz_C5iQAPeuJ32rc,74490
+coderouter/config/schemas.py,sha256=f46bpmSzZ_zJRhHbo9-inp-mAW86WZAg6hfSxgPaEcc,77741
 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
@@ -41,11 +41,11 @@ coderouter/ingress/__init__.py,sha256=WQsCH2CGJCAhy0mS6GSEdeYZRkkQu2OHDsP4CJWTLu
 coderouter/ingress/anthropic_routes.py,sha256=1ThXzx8VgxRV7UCi3NF5ey7kbr0ADPKTXyQuYS5gK1w,27063
 coderouter/ingress/app.py,sha256=h6s-UWsbGP22rku4pPVlvRdrtbMj4KoEEUZoQQOrTTw,19370
 coderouter/ingress/dashboard_routes.py,sha256=1SqNNrVTfQiZcx5n2MvjAzWirittX0e61tCt-MKp4Ag,25617
-coderouter/ingress/launcher_routes.py,sha256=1bU245mEauCMpEOsq0LY-8FKKQIJWJhDe3CXgag_ut0,55968
+coderouter/ingress/launcher_routes.py,sha256=QzG0l0c2ZmAcQai3E-xs3cV5fUYf3ajjZauvI9pKDh4,57959
 coderouter/ingress/metrics_routes.py,sha256=M22dwOGn24P05Ge4W3c7d7mYytSGWjIR-pPSPOAiHJY,3965
-coderouter/ingress/openai_routes.py,sha256=Mjsk3jwot4qP9f5xshrmR1iuHMW-9sQdsfHMN_Sx5hc,9294
+coderouter/ingress/openai_routes.py,sha256=TrugsQNJfNPgKKLzfT1aXzrs4emWYGE4XebEBuaZoWk,12505
 coderouter/metrics/__init__.py,sha256=7Es351DPS7yLM0yVF_F0eesmiD83n7Zzhie44chht38,1465
-coderouter/metrics/collector.py,sha256=_Zp1wUOZhLA9afEdCwlxdV5QP4Z5sCjm1ya8jL0xkhI,59708
+coderouter/metrics/collector.py,sha256=wdGuX5yOBWEHCz1KVIfaUBZP5NXW3U34yyYlLGwgoCE,61212
 coderouter/metrics/prometheus.py,sha256=THYkvrcpQK3ZNW-BV0h3O-PoT2ppNZ0dapQuu1nyHwE,24410
 coderouter/plugins/__init__.py,sha256=76hMLe5dV_ilripHXzWn3HSYoIALjzlw4EJVyI-GyIM,1974
 coderouter/plugins/base.py,sha256=n9hsck2NCSqi6oeHIumKC5zhQ8JGwCXUz7J5AZQCQss,5772
@@ -56,7 +56,7 @@ coderouter/routing/adaptive.py,sha256=G2o377twGSjbUh65wiIFx6klnpFGjsD_nI3oDvcBwh
 coderouter/routing/auto_router.py,sha256=y4v0c8u5F9f98Vmhx1vRcKPiOgAvpzbFqr6TIh058h0,13341
 coderouter/routing/budget.py,sha256=PblmVKJGs_BwNa9uDHAA8hmZ4XIVKv38mHAeU0V3OMs,8451
 coderouter/routing/capability.py,sha256=rRQhzTgQYFTFDNYcSLKvq3xjdw6B1w7T-3jS7PTMI14,27864
-coderouter/routing/fallback.py,sha256=iuCCyIT0ARCI8r6iLQPaMYwt27WhwC1bPSiqE-OFCSM,129102
+coderouter/routing/fallback.py,sha256=L5hwe76DRlmHTR39dXafi27T5zRrgLlgX9uINddcSGk,142983
 coderouter/state/__init__.py,sha256=XoGcPmmBQSiZWML2S0juSveQ78xfhtdeCliNnVyzu7E,1088
 coderouter/state/audit_log.py,sha256=n7vuDsTfd5iuNUJhlRQPakJ2tMSsT9EfgPCzs1GEaac,10941
 coderouter/state/replay.py,sha256=Z_YHKroTKZdrL8qObFxcoLOAQWWXZvXFdLfxzvBhEJg,11230
@@ -67,8 +67,8 @@ coderouter/translation/__init__.py,sha256=PYXN7XVEwpG1uC8RLy6fvnGbzEZhhrEuUapH8I
 coderouter/translation/anthropic.py,sha256=aZkcYH4x82b0x7efJgJb9RWn9Hbyc9pEOthXe4vjUdU,11113
 coderouter/translation/convert.py,sha256=VV4kpu4dvLmGBmJfQnCLY5ryy_AnQcV2NuwjqRtaR8Q,52633
 coderouter/translation/tool_repair.py,sha256=DGOKArM53yfVbIfiAveoul1vGq9NEKmjagf43Qh4IkM,57630
-coderouter_cli-2.7.2.dist-info/METADATA,sha256=z-Kd6V1JathVCNb3Gg2UzvZmpXbBmCUahQ2XrjmbdZ0,14857
-coderouter_cli-2.7.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-coderouter_cli-2.7.2.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
-coderouter_cli-2.7.2.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
-coderouter_cli-2.7.2.dist-info/RECORD,,
+coderouter_cli-2.7.4.dist-info/METADATA,sha256=55ucKwRohGC6WEQr_NyGWjRjzhVgE7rOYgl4rfDNNkw,15388
+coderouter_cli-2.7.4.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+coderouter_cli-2.7.4.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
+coderouter_cli-2.7.4.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
+coderouter_cli-2.7.4.dist-info/RECORD,,