coderouter-cli 2.9.1__py3-none-any.whl → 2.9.3__py3-none-any.whl

coderouter/config/schemas.py

@@ -1518,10 +1518,25 @@ class SwapModelSpec(BaseModel):
         le=65535,
         description=(
             "Fixed port (recommended — §10 Q2). When unset, the swap "
-            "manager picks an OS-assigned ephemeral port and retries "
-            "once on a different port if the backend fails to become "
-            "ready. Best-effort only — no strong TOCTOU guarantee "
-            "(§6.6 known-trap #4)."
+            "manager picks an OS-assigned ephemeral port and retries, "
+            "each time on a freshly picked port, up to "
+            "``LauncherSwapConfig.port_retry_attempts`` additional "
+            "times if the backend fails to become ready. Best-effort "
+            "only — no strong TOCTOU guarantee (§6.6 known-trap #4)."
+        ),
+    )
+    ttl_seconds: float | None = Field(
+        default=None,
+        ge=0.0,
+        description=(
+            "[Unreleased] Per-model override of "
+            "``LauncherSwapConfig.ttl_seconds``. ``None`` (default) = "
+            "use the global value. ``0`` = unload as soon as the last "
+            "in-flight lease for THIS model releases — same meaning as "
+            "the global field's ``0``, just scoped to one catalog "
+            "entry. Lets a large/expensive model unload sooner (or "
+            "stay resident longer) than the rest of the catalog "
+            "without changing the global default."
         ),
     )
     option_profile: str | None = Field(
@@ -1611,8 +1626,10 @@ class LauncherSwapConfig(BaseModel):
             "Seconds of no in-flight requests after which an idle swap "
             "process is auto-stopped. None = TTL disabled (runs until "
             "explicitly stopped). 0 = unload as soon as the last "
-            "in-flight lease releases. §10 Q1: one GLOBAL value for "
-            "Phase 1 — no per-model override yet."
+            "in-flight lease releases. §10 Q1: this is the GLOBAL "
+            "default; a catalog entry's ``SwapModelSpec.ttl_seconds`` "
+            "overrides it for that one model when set "
+            "([Unreleased] per-model TTL override)."
         ),
     )
     readiness_timeout_s: float = Field(
@@ -1631,6 +1648,24 @@ class LauncherSwapConfig(BaseModel):
         le=600.0,
         description="How often the TTL sweeper background task scans for idle processes.",
     )
+    port_retry_attempts: int = Field(
+        default=2,
+        ge=0,
+        le=5,
+        description=(
+            "[Unreleased] Number of ADDITIONAL spawn attempts (each on a "
+            "freshly picked ephemeral port) after the first, used only "
+            "when a catalog entry's ``port`` is unset and the previous "
+            "attempt fails to become ready. 0 = no retry. Ignored when "
+            "``port`` is set — a fixed port never retries (a second "
+            "attempt would just collide on the same port again). This "
+            "does not close the pick-then-bind TOCTOU window (see "
+            "``coderouter.launcher_swap._pick_ephemeral_port``); it only "
+            "bounds how many times the swap manager re-rolls the dice. "
+            "A fixed ``port`` remains the recommended way to eliminate "
+            "the race entirely (§10 Q2)."
+        ),
+    )
     inject_auto_router_rules: bool = Field(
         default=True,
         description=(
@@ -1951,8 +1986,16 @@ class CodeRouterConfig(BaseModel):
         description="Master switch. ALLOW_PAID=false blocks all paid providers (plan.md §2.3).",
     )
     default_profile: str = Field(default="default")
-    providers: list[ProviderConfig] = Field(..., min_length=1)
-    profiles: list[FallbackChain] = Field(..., min_length=1)
+    # [Unreleased]: relaxed from ``Field(..., min_length=1)`` so a
+    # swap-only deployment (``launcher.swap.enabled`` with a non-empty
+    # ``models`` catalog) can omit both fields entirely instead of
+    # writing an unreachable dummy provider/profile just to satisfy the
+    # schema. The "at least one" invariant is NOT dropped — it moves to
+    # ``_check_providers_and_profiles_nonempty`` below, which still
+    # fail-fasts at load for every other deployment shape (same
+    # philosophy as the min_length constraint it replaces).
+    providers: list[ProviderConfig] = Field(default_factory=list)
+    profiles: list[FallbackChain] = Field(default_factory=list)
     mode_aliases: dict[str, str] = Field(
         default_factory=dict,
         description=(
@@ -2159,6 +2202,52 @@ class CodeRouterConfig(BaseModel):
                 )
         return self
 
+    @model_validator(mode="after")
+    def _check_providers_and_profiles_nonempty(self) -> CodeRouterConfig:
+        """[Unreleased]: enforce "at least one" unless launcher.swap covers it.
+
+        ``providers`` / ``profiles`` were relaxed from ``min_length=1`` to
+        ``default_factory=list`` (see the field comments above) so a
+        swap-only deployment can omit them — every request in that shape
+        is routed through a ``launcher-swap-<name>`` profile that
+        :meth:`_inject_swap_profiles_and_auto_router_rules` synthesizes
+        below, and its backing provider is registered at runtime on first
+        spawn (``SwapManager.register_provider``), so there is genuinely
+        nothing to declare statically.
+
+        Runs BEFORE the swap injection (which only ever *adds* profiles,
+        never providers) so it observes the operator's raw, undecorated
+        input rather than the post-injection state — the injected
+        profiles are not a substitute for a real provider declaration in
+        every other deployment shape, only in the swap-only one this
+        validator carves out.
+
+        Outside that carve-out, an empty ``providers`` or ``profiles``
+        list has always been a load-time error (there would be nothing to
+        route to); this validator keeps that fail-fast guarantee instead
+        of silently trading it away when the ``min_length=1`` field
+        constraint was dropped.
+        """
+        swap_cfg = self.launcher.swap if self.launcher is not None else None
+        swap_covers_empty = (
+            swap_cfg is not None and swap_cfg.enabled and bool(swap_cfg.models)
+        )
+        if swap_covers_empty:
+            return self
+        if not self.providers:
+            raise ValueError(
+                "providers: at least one entry is required (empty/omitted "
+                "is only allowed when launcher.swap.enabled=true and "
+                "launcher.swap.models has at least one entry)."
+            )
+        if not self.profiles:
+            raise ValueError(
+                "profiles: at least one entry is required (empty/omitted "
+                "is only allowed when launcher.swap.enabled=true and "
+                "launcher.swap.models has at least one entry)."
+            )
+        return self
+
     @model_validator(mode="after")
     def _inject_swap_profiles_and_auto_router_rules(self) -> CodeRouterConfig:
         """§10 Q7 + design-deviation: bootstrap swap's dedicated profiles.

coderouter/ingress/launcher_routes.py

@@ -171,6 +171,13 @@ class ManagedProcess:
     #     under its per-model lock); a launcher auto-restart racing that
     #     re-spawn would fight over the same fixed port.
     swap_managed: bool = False
+    # [Unreleased]: the swap catalog model name (SwapModelSpec.name) this
+    # process backs, set by SwapManager._spawn via spawn_process's
+    # swap_model kwarg. None for a manually-started process (swap_managed
+    # is False) or if a future swap-managed spawn path omits it. Purely
+    # informational — surfaced by GET /api/launcher/processes so the
+    # /launcher UI can label which catalog entry a running process is.
+    swap_model: str | None = None
     # asyncio subprocess handle — not serialised
     _proc: Any = field(default=None, repr=False, compare=False)
 
@@ -1027,7 +1034,13 @@ async def api_launcher_config_debug(request: Request) -> dict[str, Any]:
 
 @router.get("/api/launcher/processes")
 async def api_processes(request: Request) -> dict[str, Any]:
-    """List all managed processes."""
+    """List all managed processes.
+
+    [Unreleased]: ``swap_managed`` / ``swap_model`` let the ``/launcher``
+    UI (and other API clients) tell an on-demand SwapManager-spawned
+    process apart from a manually-started one, and label which swap
+    catalog model it backs.
+    """
     reg = _registry(request)
     return {
         "processes": [
@@ -1040,6 +1053,8 @@ async def api_processes(request: Request) -> dict[str, Any]:
                 "status": p.status,
                 "pid": p.pid,
                 "returncode": p.returncode,
+                "swap_managed": p.swap_managed,
+                "swap_model": p.swap_model,
             }
             for p in reg.all()
         ]
@@ -1100,6 +1115,7 @@ async def spawn_process(
     draft_model_path: str | None = None,
     mtp_mode: str = "auto",
     swap_managed: bool = False,
+    swap_model: str | None = None,
 ) -> ManagedProcess:
     """Build argv, spawn the child process, and arm readiness/log tailing.
 
@@ -1116,6 +1132,12 @@ async def spawn_process(
     exist. Any other exception from ``create_subprocess_exec`` propagates
     as-is. Callers decide how to surface these (HTTP 400/500 for
     ``api_start``, a retryable ``AdapterError`` for SwapManager).
+
+    ``swap_model`` ([Unreleased]) is purely informational — the swap
+    catalog model name (``SwapModelSpec.name``), recorded on the
+    resulting ``ManagedProcess`` for ``GET /api/launcher/processes`` /
+    the ``/launcher`` UI. Only ``SwapManager._spawn`` passes it; the
+    manual ``POST /api/launcher/start`` path leaves it ``None``.
     """
     options = options if options is not None else {}
     configured_binary: str | None = None
@@ -1178,6 +1200,7 @@ async def spawn_process(
         spec_auto=spec_auto and fallback_cmd is not None,
         fallback_cmd=fallback_cmd,
         swap_managed=swap_managed,
+        swap_model=swap_model,
     )
     proc.log_tail.append(f"[launcher] cmd: {' '.join(cmd)}")
     for note in spec_notes:
@@ -1378,6 +1401,10 @@ _LAUNCHER_HTML = r"""<!doctype html>
   <style>
     .dot { width:.5rem;height:.5rem;border-radius:9999px;display:inline-block; }
     .tabnum { font-variant-numeric:tabular-nums; }
+    .badge-swap { font-size:10px; text-transform:uppercase; letter-spacing:.02em;
+                  background:rgba(99,102,241,.2); color:#a5b4fc; padding:1px 6px;
+                  border-radius:9999px; margin-left:6px; vertical-align:middle;
+                  white-space:nowrap; }
     .log-box { font-family:monospace;font-size:.75rem;line-height:1.4;
                overflow-y:auto;max-height:14rem;white-space:pre-wrap;word-break:break-all; }
     .model-row:hover { background:rgba(255,255,255,.04);cursor:pointer; }
@@ -1851,7 +1878,17 @@ _LAUNCHER_HTML = r"""<!doctype html>
     try {
       const r = await fetch("/api/launcher/processes");
       const d = await r.json();
-      renderProcesses(d.processes || []);
+      const procs = d.processes || [];
+      renderProcesses(procs);
+      // [Unreleased] 404-loop fix: if the process whose logs we're
+      // polling is no longer in the registry (deleted from another
+      // client, swap TTL unload removed it, or the server restarted
+      // under a still-open tab), stop the log polling BEFORE it even
+      // issues a 404 — otherwise poll() would hit
+      // /api/launcher/logs/<stale-id> every POLL_MS forever.
+      if (selectedLogId && !procs.some(p => p.id === selectedLogId)) {
+        markLogGone();
+      }
     } catch (_) {}
   };
 
@@ -1871,8 +1908,14 @@ _LAUNCHER_HTML = r"""<!doctype html>
         ? `<button onclick="deleteProc('${p.id}')" class="btn-sm btn-slate ml-1">✕</button>`
         : "";
       const logBtn = `<button onclick="openLog('${p.id}','${esc(p.name)}')" class="btn-sm btn-indigo ml-1">📋 ログ</button>`;
+      // [Unreleased]: swap badge — marks processes SwapManager spawned
+      // on demand, distinct from manually-started ones. Title shows the
+      // catalog model name when the backend supplied it.
+      const swapBadge = p.swap_managed
+        ? `<span class="badge-swap" title="${esc(p.swap_model ? "swap model: " + p.swap_model : "swap-managed")}">swap</span>`
+        : "";
       return `<tr>
-        <td class="py-2 pr-3 font-medium">${esc(p.name)}</td>
+        <td class="py-2 pr-3 font-medium">${esc(p.name)}${swapBadge}</td>
         <td class="py-2 pr-3 text-slate-400">${esc(p.backend)}</td>
         <td class="py-2 pr-3 text-slate-400 truncate max-w-[10rem]" title="${esc(p.model_path)}">${esc(modelName)}</td>
         <td class="py-2 pr-3 text-right">${p.port}</td>
@@ -1912,6 +1955,11 @@ _LAUNCHER_HTML = r"""<!doctype html>
     if (!selectedLogId) return;
     try {
       const r = await fetch(`/api/launcher/logs/${selectedLogId}?n=200`);
+      // [Unreleased] 404-loop fix: the id is gone from the registry —
+      // stop polling instead of retrying (and 404-spamming the serve
+      // log) every POLL_MS forever. The server keeps answering 404 for
+      // unknown ids (correct); the client just has to take the hint.
+      if (r.status === 404) { markLogGone(); return; }
       const d = await r.json();
       const box = document.getElementById("log-box");
       box.textContent = d.logs.join("\n") || "(ログなし)";
@@ -1921,6 +1969,15 @@ _LAUNCHER_HTML = r"""<!doctype html>
     }
   };
 
+  // [Unreleased] 404-loop fix: the process we were tailing no longer
+  // exists server-side. Clear selectedLogId (which is what stops both
+  // poll()'s refreshLogs call and any manual ↻) but keep the panel open
+  // with a terminal message so the user sees WHY the logs stopped.
+  const markLogGone = () => {
+    selectedLogId = null;
+    document.getElementById("log-box").textContent = "(process removed)";
+  };
+
   window.closeLog = () => {
     selectedLogId = null;
     document.getElementById("log-panel").classList.add("hidden");

coderouter/launcher_swap.py

@@ -85,9 +85,18 @@ class _ModelState:
 def _pick_ephemeral_port() -> int:
     """Ask the OS for a free port. Best-effort only (§6.6 known-trap #4):
 
-    there is an unavoidable TOCTOU window between this call returning
-    and the child actually binding the port. Fixed ``port:`` in the
-    catalog entry avoids the race entirely (§10 Q2, recommended).
+    there is an unavoidable TOCTOU window between this call's bind+close
+    returning a "free" port and the child actually binding that same
+    port a moment later — nothing stops another process (or another
+    concurrent swap spawn) from grabbing it first. Retrying on a fresh
+    port when the child fails to come up
+    (``LauncherSwapConfig.port_retry_attempts``, default 2 additional
+    attempts) narrows the *impact* of losing that race but does NOT
+    close the window itself — a genuinely race-free allocation would
+    need the OS to hand the child an already-bound socket fd, which the
+    current spawn path (argv ``--port N``) does not support. Fixed
+    ``port:`` in the catalog entry avoids the race entirely (§10 Q2,
+    recommended) and remains the only way to eliminate it outright.
     """
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
         s.bind(("127.0.0.1", 0))
@@ -126,6 +135,13 @@ class SwapManager:
         self._readiness_timeout_s = config.readiness_timeout_s
         self._sweep_interval_s = config.sweep_interval_s
         self._sweeper_task: asyncio.Task[None] | None = None
+        # [Unreleased] per-model TTL override: the sweeper must run
+        # whenever EITHER the global TTL is enabled OR at least one
+        # catalog entry sets its own ``ttl_seconds`` (even if the global
+        # value is None/disabled) — see _effective_ttl / start().
+        self._any_ttl_configured = self._ttl_seconds is not None or any(
+            m.ttl_seconds is not None for m in config.models
+        )
 
     # ------------------------------------------------------------------
     # Catalog matching
@@ -214,24 +230,40 @@ class SwapManager:
         async with state.lock:
             await self._unload_locked(state, spec, reason)
 
+    def _effective_ttl(self, spec: SwapModelSpec) -> float | None:
+        """``spec.ttl_seconds`` if set, else the global ``self._ttl_seconds``.
+
+        [Unreleased] per-model TTL override (docs/backends/launcher.md
+        "launcher.swap fields" table). ``None`` at either level keeps
+        its usual meaning ("TTL disabled") — a spec-level override only
+        takes effect when it's not ``None``.
+        """
+        return spec.ttl_seconds if spec.ttl_seconds is not None else self._ttl_seconds
+
     async def sweep_once(self) -> None:
         """One TTL sweep pass: stop every idle, un-leased, expired model.
 
         Takes each model's own lock independently (never more than one
         per-model lock at a time — §6.6 known-trap #7) so a slow unload
-        for model A never delays the sweep of model B.
+        for model A never delays the sweep of model B. Each model's TTL
+        is resolved individually via :meth:`_effective_ttl` — a model
+        whose global TTL is disabled can still expire on its own
+        override, and vice versa.
         """
-        if self._ttl_seconds is None:
+        if not self._any_ttl_configured:
             return
         now = time.monotonic()
         for spec in list(self._catalog.values()):
+            ttl = self._effective_ttl(spec)
+            if ttl is None:
+                continue
             state = self._states.get(spec.name)
             if state is None:
                 continue
             async with state.lock:
                 if state.status != "ready" or state.in_flight > 0:
                     continue
-                if (now - state.last_used) < self._ttl_seconds:
+                if (now - state.last_used) < ttl:
                     continue
                 await self._unload_locked(state, spec, reason="ttl")
 
@@ -240,8 +272,14 @@ class SwapManager:
     # ------------------------------------------------------------------
 
     async def start(self) -> None:
-        """Start the TTL sweeper background task. No-op when TTL is disabled."""
-        if self._ttl_seconds is None or self._sweeper_task is not None:
+        """Start the TTL sweeper background task.
+
+        No-op when TTL is disabled both globally AND on every catalog
+        entry (``self._any_ttl_configured`` — [Unreleased] per-model
+        override means a per-model ``ttl_seconds`` alone is enough to
+        need the sweeper, even with the global TTL off).
+        """
+        if not self._any_ttl_configured or self._sweeper_task is not None:
             return
         self._sweeper_task = asyncio.create_task(self._sweeper_loop())
 
@@ -285,6 +323,35 @@ class SwapManager:
     def _engine(self) -> Any | None:
         return getattr(self._app.state, "engine", None)
 
+    def _remove_from_registry(self, proc_id: str) -> None:
+        """Drop a swap-managed ``ManagedProcess`` from the launcher registry.
+
+        [Unreleased] registry-litter fix: ``stop_process`` only sets
+        ``status="stopped"`` — it never removes the entry, because for
+        MANUALLY started processes the stopped row doubles as visible
+        history in the /launcher UI (with logs and an explicit ✕ delete
+        button). Swap-managed processes have no such contract: every
+        failed readiness attempt (times ``1 + port_retry_attempts``) and
+        every TTL unload would otherwise leave a permanent "stopped" row
+        accumulating unboundedly in ``GET /api/launcher/processes``. So
+        SwapManager removes ITS OWN processes right after it stops them,
+        guarded on ``swap_managed`` so a manual process can never be
+        swept up by mistake. Crash leftovers (a swap process that died
+        on its own, status "error"/"stopped" without SwapManager
+        stopping it) are deliberately NOT removed here — their log tail
+        is the only crash forensics an operator has; the ✕ button still
+        applies.
+        """
+        reg = _registry_for_app(self._app)
+        try:
+            proc = reg.get(proc_id)
+        except KeyError:
+            return
+        if not proc.swap_managed:
+            return
+        with contextlib.suppress(KeyError):
+            reg.remove(proc_id)
+
     def _resolve_options(self, spec: SwapModelSpec) -> dict[str, Any]:
         """Resolve ``spec.option_profile`` into the launcher options dict."""
         if not spec.option_profile or self._launcher_cfg is None:
@@ -346,11 +413,20 @@ class SwapManager:
     async def _spawn_with_retry(
         self, spec: SwapModelSpec
     ) -> tuple[ManagedProcess | None, Exception | None]:
-        """Spawn + wait for readiness. §10 Q2: one retry on a fresh ephemeral
-        port when ``spec.port`` is unset and the first attempt doesn't come
-        up (fixed ports never retry — a second attempt would collide again).
+        """Spawn + wait for readiness.
+
+        §10 Q2: when ``spec.port`` is unset, up to
+        ``1 + LauncherSwapConfig.port_retry_attempts`` attempts total
+        (default: 1 initial + 2 retries = 3), each on a freshly picked
+        ephemeral port via :func:`_pick_ephemeral_port` — see that
+        function's docstring for the residual pick-then-bind TOCTOU
+        window this does NOT close, only bounds the impact of. Fixed
+        ports never retry — a second attempt on the same port would
+        just collide again.
         """
-        attempts = 1 if spec.port is not None else 2
+        attempts = (
+            1 if spec.port is not None else 1 + self._config.port_retry_attempts
+        )
         last_exc: Exception | None = None
         for _attempt in range(attempts):
             port = spec.port if spec.port is not None else _pick_ephemeral_port()
@@ -368,6 +444,10 @@ class SwapManager:
             )
             with contextlib.suppress(Exception):
                 await stop_process(self._app, proc.id)
+            # [Unreleased] registry-litter fix: without this, every failed
+            # readiness attempt leaves one "stopped" row in the registry
+            # forever (1 + port_retry_attempts rows per failed load).
+            self._remove_from_registry(proc.id)
         return None, last_exc
 
     async def _spawn(self, spec: SwapModelSpec, port: int) -> ManagedProcess:
@@ -394,6 +474,10 @@ class SwapManager:
             # provider). H-2: exempt from launcher auto-restart (crash
             # recovery = next-request re-spawn under the per-model lock).
             swap_managed=True,
+            # [Unreleased]: catalog model name, surfaced by
+            # GET /api/launcher/processes as "swap_model" so the /launcher
+            # UI can show which swap catalog entry a process backs.
+            swap_model=spec.name,
         )
 
     async def _await_ready(self, proc: ManagedProcess) -> bool:
@@ -457,6 +541,10 @@ class SwapManager:
             with contextlib.suppress(Exception):
                 await stop_process(self._app, proc_id)
             await self._deregister(spec)
+            # [Unreleased] registry-litter fix: a TTL-unloaded swap process
+            # is not "history" the way a manually stopped one is — leaving
+            # it would grow the registry by one row per load/unload cycle.
+            self._remove_from_registry(proc_id)
         logger.info(
             "swap-unload",
             extra={"model": spec.name, "reason": reason, "proc_id": proc_id},

{coderouter_cli-2.9.1.dist-info → coderouter_cli-2.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 2.9.1
+Version: 2.9.3
 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

{coderouter_cli-2.9.1.dist-info → coderouter_cli-2.9.3.dist-info}/RECORD

@@ -11,7 +11,7 @@ coderouter/gguf_introspect.py,sha256=KeE00CfbYRa4gSTrzuwC6zVuHi20IzLC4nUQa98BEXI
 coderouter/hardware.py,sha256=gn3_9qbVcGRR81yKMn1lJE_8-YDRau0LxIH_M-f7pxE,8356
 coderouter/language_tax.py,sha256=LTbE3tIfoJuV2O3T0NixRKhzq_dEOTUuPEerJv2q9uk,9360
 coderouter/launcher_speculative.py,sha256=kWaHNmhzBsbWuM_lRGDlbWkgJ1suuxBWQNTKhJOC-yg,12644
-coderouter/launcher_swap.py,sha256=Oc9itCKzjSFbE_RWxqcjIJyiYax8o9zZo7czmEI2s-U,19150
+coderouter/launcher_swap.py,sha256=W7qpdB-8Npr8yHGfx0N3SgZ2vDJ6BR9JuxW0I3TaZ-4,23783
 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
@@ -25,7 +25,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=U7AGOm88gtCqUYsRNYc6KVaiP-Cdg5yd_oOzYiiR3rs,114340
+coderouter/config/schemas.py,sha256=FJ0bc23tGbOYA2iQLKmyZN3A8R0vZzSfTY4PT8a5f1s,118933
 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
@@ -43,7 +43,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=kVorBfnWL9Q0a6h-gad2YxgeoZjHFHbL8C4DcHtkigg,82031
+coderouter/ingress/launcher_routes.py,sha256=up9kNAjq1FHgv4_I298u7SkWLcv5T-RLhDcDYbxIp-s,85199
 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
@@ -69,8 +69,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.9.1.dist-info/METADATA,sha256=yfgVyK-eoyV3fde8w8Ngm9TvXw3h61CI3epBZOggdRI,15994
-coderouter_cli-2.9.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-coderouter_cli-2.9.1.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
-coderouter_cli-2.9.1.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
-coderouter_cli-2.9.1.dist-info/RECORD,,
+coderouter_cli-2.9.3.dist-info/METADATA,sha256=ofXxvu6VaPHY-an5OdALTE8qZKIdJvfFK28heY_3ZOM,15994
+coderouter_cli-2.9.3.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+coderouter_cli-2.9.3.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
+coderouter_cli-2.9.3.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
+coderouter_cli-2.9.3.dist-info/RECORD,,