coderouter-cli 2.16.0__py3-none-any.whl → 2.18.0__py3-none-any.whl

coderouter/adapters/anthropic_native.py

@@ -46,6 +46,7 @@ from coderouter.adapters.base import (
     StreamChunk,
     StreamTruncatedError,
 )
+from coderouter.adapters.slot_affinity import apply_slot_affinity
 from coderouter.credentials import resolve_provider_credential
 from coderouter.logging import (
     get_logger,
@@ -243,6 +244,9 @@ class AnthropicAdapter(BaseAdapter):
         body.update(dumped)
         body["model"] = self.config.model
         body["stream"] = stream
+        apply_slot_affinity(
+            body, slots=self.config.slot_affinity_slots, key=req.session_key
+        )
         return body
 
     # ------------------------------------------------------------------

coderouter/adapters/base.py

@@ -65,6 +65,9 @@ class ChatRequest(BaseModel):
 
     # CodeRouter-specific extension (not sent upstream)
     profile: str | None = Field(default=None, exclude=True)
+    # v2.18.0: conversation key for KV-slot affinity (see
+    # ``ProviderConfig.slot_affinity_slots``). Never serialized.
+    session_key: str | None = Field(default=None, exclude=True)
 
 
 class ChatResponse(BaseModel):
@@ -200,6 +203,23 @@ class StreamTruncatedError(AdapterError):
         self.tool_call_in_flight = tool_call_in_flight
 
 
+# v2.17.0: the provider did not produce its first real streamed output within
+# ``ProviderConfig.ttft_timeout_s``. Raised by the engine (not the adapter),
+# before any byte reached the client, so the chain falls back normally and the
+# self-healing guards learn from it like any other retryable failure.
+class TTFTTimeoutError(AdapterError):
+    """No first token within ``ttft_timeout_s``."""
+
+    def __init__(self, *, provider: str, ttft_timeout_s: float) -> None:
+        super().__init__(
+            f"timeout: no first token within {ttft_timeout_s:g}s (ttft_timeout_s)",
+            provider=provider,
+            status_code=None,
+            retryable=True,
+        )
+        self.ttft_timeout_s = ttft_timeout_s
+
+
 # v0.6-B: per-call overrides resolved from the active profile. The engine
 # builds one instance per request (since a profile is invariant across its
 # chain) and threads it through every adapter call on that chain. Adapters

coderouter/adapters/openai_compat.py

@@ -30,6 +30,7 @@ from coderouter.adapters.base import (
     StreamChunk,
     StreamTruncatedError,
 )
+from coderouter.adapters.slot_affinity import apply_slot_affinity
 from coderouter.credentials import resolve_provider_credential
 from coderouter.logging import (
     get_logger,
@@ -182,6 +183,11 @@ class OpenAICompatAdapter(BaseAdapter):
             value = getattr(request, field, None)
             if value is not None:
                 body[field] = value
+        apply_slot_affinity(
+            body,
+            slots=self.config.slot_affinity_slots,
+            key=getattr(request, "session_key", None),
+        )
         if stream:
             # Request a terminal usage chunk. Providers that honor this
             # (OpenAI, OpenRouter, Ollama >=0.x) will send one extra chunk

coderouter/adapters/slot_affinity.py

@@ -0,0 +1,54 @@
+"""v2.18.0: KV-slot affinity for llama-server (``id_slot``).
+
+llama-server started with ``--parallel N`` serves N slots, each holding its
+own prompt cache. Without a hint it picks a free slot, so consecutive turns
+of one conversation can land on different slots and re-prefill the whole
+prompt. Sending ``id_slot`` pins a conversation to one slot.
+
+The slot is ``sha256(key) % N`` — stable across processes and restarts
+(Python's ``hash`` is salted per process).
+"""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Mapping
+from typing import Any
+
+# Request classes whose prompt shares the main conversation's prefix: they
+# belong on the main conversation's slot. Everything else (sub-agents,
+# auxiliary calls such as the auto-mode classifier or titles, workflows) has
+# its own prompt and gets its own key, so it neither waits on the main slot
+# nor evicts its cache.
+_MAIN_CLASSES = frozenset({"", "main", "compaction"})
+
+
+def affinity_key(hints: Mapping[str, str]) -> str | None:
+    """Conversation key for slot affinity, from Claude Code's hint headers.
+
+    ``None`` when there is no session id. ``main`` / ``compaction`` (and a
+    missing class) share ``<session>``; other classes get
+    ``<session>:<class>:<agent_type>``.
+    """
+    session = hints.get("session_id")
+    if not session:
+        return None
+    request_class = hints.get("request_class", "").lower()
+    if request_class in _MAIN_CLASSES:
+        return session
+    return f"{session}:{request_class}:{hints.get('agent_type', '').lower()}"
+
+
+def slot_for(key: str, slots: int) -> int:
+    digest = hashlib.sha256(key.encode("utf-8")).digest()
+    return int.from_bytes(digest[:8], "big") % slots
+
+
+def apply_slot_affinity(body: dict[str, Any], *, slots: int | None, key: str | None) -> None:
+    """Set ``body["id_slot"]`` when affinity is configured and a key exists.
+
+    An ``id_slot`` already present (e.g. from ``extra_body``) wins.
+    """
+    if not slots or not key or "id_slot" in body:
+        return
+    body["id_slot"] = slot_for(key, slots)

coderouter/cli.py

@@ -483,7 +483,8 @@ def _build_parser() -> argparse.ArgumentParser:
         help=(
             "v2.16.0: do not write the Claude Code gateway settings "
             "(ENABLE_TOOL_SEARCH=false, CLAUDE_CODE_AUTO_MODE_SERVER=0, "
-            "and --max-context-tokens). Use when the chain is "
+            "CLAUDE_CODE_GATEWAY_HINT_HEADERS=1 and --max-context-tokens). "
+            "Use when the chain is "
             "api.anthropic.com only."
         ),
     )

coderouter/config/schemas.py

@@ -550,6 +550,45 @@ class ProviderConfig(BaseModel):
         description="If true, only used when ALLOW_PAID=true (plan.md §2.3).",
     )
     timeout_s: float = Field(default=30.0, ge=1.0, le=86400.0)
+    # v2.17.0: time-to-first-token cut-off for streaming requests. When the
+    # provider has not produced its first real output (text / tool_use /
+    # thinking delta) within this many seconds of the attempt starting, the
+    # attempt is abandoned and the chain moves on — before any byte reached
+    # the client. Never applied to the last provider of a chain (nothing to
+    # move on to), nor to non-streaming requests (``timeout_s`` covers
+    # those). Before the first *event* it always applies; between the first
+    # event and the first real output it needs
+    # ``empty_response_action: fallback`` on the profile, which is what
+    # withholds those opening events from the client. ``None`` (default)
+    # disables it. Typical use: a local llama-server still loading a model
+    # or chewing through a long prompt while a cloud fallback could answer.
+    # v2.18.0: KV-slot affinity for llama-server started with
+    # ``--parallel N``. When set to N and the request carries a conversation
+    # key (Claude Code's ``x-claude-code-session-id`` hint header), the body
+    # gets ``id_slot = stable_hash(key) % N`` so every turn of a conversation
+    # lands on the same slot and reuses its prompt cache instead of
+    # re-prefilling on whichever slot is free. llama.cpp only (other servers
+    # ignore or reject ``id_slot``); ``None`` (default) sends nothing.
+    slot_affinity_slots: int | None = Field(
+        default=None,
+        ge=1,
+        le=256,
+        description=(
+            "v2.18.0: llama-server --parallel N. Pins each conversation to "
+            "slot hash(session) % N via id_slot so its KV cache is reused. "
+            "llama.cpp only. None disables."
+        ),
+    )
+    ttft_timeout_s: float | None = Field(
+        default=None,
+        gt=0.0,
+        le=3600.0,
+        description=(
+            "v2.17.0: seconds to wait for the first real streamed output "
+            "before falling back to the next provider (not applied to the "
+            "last provider in a chain). None disables."
+        ),
+    )
 
     # v2.6 language-tax track: path to a LOCAL ``tokenizer.json`` for this
     # provider's model, used to measure the CJK over-count vs the char/4
@@ -1617,6 +1656,21 @@ class RuleMatcher(BaseModel):
     # declares any tools); ``False`` is rejected by ``_exactly_one``
     # since a "no-tools" rule would shadow the default fall-through.
     has_tools: bool | None = None
+    # v2.18.0: Claude Code gateway hint headers. Claude Code 2.1.273+ sends
+    # these to a custom ANTHROPIC_BASE_URL when
+    # ``CLAUDE_CODE_GATEWAY_HINT_HEADERS=1`` is set (``coderouter
+    # vscode-init`` sets it). They say what a request *is* — something the
+    # body heuristics above can only guess:
+    #   * ``request_class`` — ``x-claude-code-request-class``: ``main`` /
+    #     ``subagent`` / ``workflow`` / ``compaction`` / ``auxiliary``
+    #     (auto-mode classifier, titles, …). Case-insensitive exact match.
+    #   * ``agent_type`` — ``x-claude-code-agent-type`` (e.g. ``Explore``),
+    #     case-insensitive exact match.
+    #   * ``compaction: True`` — ``x-claude-code-compaction`` is truthy.
+    # Without the headers these matchers simply never match.
+    request_class: str | None = None
+    agent_type: str | None = None
+    compaction: bool | None = None
 
     _MATCHER_FIELDS: tuple[str, ...] = (
         "has_image",
@@ -1627,12 +1681,15 @@ class RuleMatcher(BaseModel):
         "content_token_count_min",
         "has_tools",
         "cjk_ratio_min",
+        "request_class",
+        "agent_type",
+        "compaction",
     )
 
     # Boolean matcher fields carry meaning only at ``True`` — the runtime
     # evaluator uses ``is True`` — so a ``False`` value is a dead rule that
     # never matches. ``_exactly_one`` rejects it explicitly (see below).
-    _BOOL_MATCHER_FIELDS: tuple[str, ...] = ("has_image", "has_tools")
+    _BOOL_MATCHER_FIELDS: tuple[str, ...] = ("has_image", "has_tools", "compaction")
 
     @model_validator(mode="after")
     def _exactly_one(self) -> Self:

coderouter/doctor_claude_code.py

@@ -125,6 +125,18 @@ def check(version: Version | None, env: Mapping[str, str]) -> list[ClaudeCodeFin
             )
         )
 
+    if env.get("CLAUDE_CODE_GATEWAY_HINT_HEADERS", "").lower() in ("1", "true"):
+        out.append(ClaudeCodeFinding("ok", "CLAUDE_CODE_GATEWAY_HINT_HEADERS=1"))
+    else:
+        out.append(
+            ClaudeCodeFinding(
+                "info",
+                "CLAUDE_CODE_GATEWAY_HINT_HEADERS is not set: auto_router rules "
+                "on request_class / agent_type / compaction (v2.18.0) never "
+                "match without it.",
+            )
+        )
+
     if env.get("CLAUDE_CODE_AUTO_MODE_SERVER") == "0":
         out.append(ClaudeCodeFinding("ok", "CLAUDE_CODE_AUTO_MODE_SERVER=0"))
     else:

coderouter/ingress/anthropic_errors.py

@@ -33,6 +33,13 @@ terminal error 429                    429     ``rate_limit_error``
 anything else                         502     ``api_error``
 ====================================  ======  ========================
 
+v2.17.0: every mapped response also carries ``x-should-retry`` — the header
+Claude Code reads (with ``retry-after``) to decide whether to spend its retry
+budget. ``false`` for the 4xx rows (resending the same request cannot
+help), ``true`` for 429, and for 502 ``true`` only when at least one
+upstream failure was retryable — a chain that failed purely on, say, 401s
+will fail the same way on every retry.
+
 Upstream 401 / 403 deliberately fall into the last row: they describe
 CodeRouter's *own* upstream credentials, not the client's, and handing a
 401 to Claude Code would send the user to ``/login`` for nothing.
@@ -164,17 +171,26 @@ def map_no_providers_error(exc: NoProvidersAvailableError) -> AnthropicErrorResp
             msg = upstream_message(err)
             if not msg.lower().startswith(PROMPT_TOO_LONG_PREFIX):
                 msg = f"{PROMPT_TOO_LONG_PREFIX}: {msg}"
-            return AnthropicErrorResponse(400, "invalid_request_error", msg)
+            return AnthropicErrorResponse(
+                400, "invalid_request_error", msg, {"x-should-retry": "false"}
+            )
 
     terminal = errors[-1] if errors else None
     if terminal is not None and terminal.status_code is not None:
         status = terminal.status_code
         if status in (400, 422) and not terminal.retryable:
-            return AnthropicErrorResponse(400, "invalid_request_error", upstream_message(terminal))
+            return AnthropicErrorResponse(
+                400,
+                "invalid_request_error",
+                upstream_message(terminal),
+                {"x-should-retry": "false"},
+            )
         if status == 413:
-            return AnthropicErrorResponse(413, "request_too_large", upstream_message(terminal))
+            return AnthropicErrorResponse(
+                413, "request_too_large", upstream_message(terminal), {"x-should-retry": "false"}
+            )
         if status == 429:
-            headers: dict[str, str] = {}
+            headers: dict[str, str] = {"x-should-retry": "true"}
             retry_after = getattr(terminal, "retry_after", None)
             if retry_after:
                 headers["retry-after"] = retry_after
@@ -182,4 +198,7 @@ def map_no_providers_error(exc: NoProvidersAvailableError) -> AnthropicErrorResp
                 429, "rate_limit_error", upstream_message(terminal), headers
             )
 
-    return AnthropicErrorResponse(502, "api_error", redact(str(exc)))
+    retry = any(e.retryable for e in errors)
+    return AnthropicErrorResponse(
+        502, "api_error", redact(str(exc)), {"x-should-retry": "true" if retry else "false"}
+    )

coderouter/ingress/anthropic_routes.py

@@ -31,6 +31,7 @@ from fastapi import APIRouter, Header, HTTPException, Request
 from fastapi.responses import JSONResponse, Response, StreamingResponse
 
 from coderouter.adapters.base import StreamTruncatedError
+from coderouter.adapters.slot_affinity import affinity_key
 from coderouter.guards.context_budget import ContextBudgetRejectError
 from coderouter.guards.tool_loop import ToolCountExceededError, ToolLoopBreakError
 from coderouter.ingress.anthropic_errors import (
@@ -49,7 +50,7 @@ from coderouter.routing import (
     MidStreamError,
     NoProvidersAvailableError,
 )
-from coderouter.routing.auto_router import RESERVED_PROFILE_NAME, classify
+from coderouter.routing.auto_router import RESERVED_PROFILE_NAME, classify, extract_gateway_hints
 from coderouter.routing.fallback_trace import (
     SSE_FALLBACK_EVENT,
     current_fallback_trace,
@@ -226,6 +227,11 @@ async def messages(
     if anthropic_beta:
         anth_req.anthropic_beta = anthropic_beta
 
+    # v2.18.0: Claude Code gateway hint headers — routing matchers below,
+    # and the conversation key for llama-server KV-slot affinity.
+    gateway_hints = extract_gateway_hints(request.headers)
+    anth_req.session_key = affinity_key(gateway_hints)
+
     # Profile selection — body field wins over header (same policy as OpenAI route).
     if anth_req.profile is None and x_coderouter_profile:
         anth_req.profile = x_coderouter_profile
@@ -253,7 +259,7 @@ async def messages(
     # AnthropicRequest), so both OpenAI and Anthropic ingress use the same
     # classifier without a shared request shim.
     if anth_req.profile is None and config.default_profile == RESERVED_PROFILE_NAME:
-        anth_req.profile = classify(payload, config)
+        anth_req.profile = classify(payload, config, gateway_hints)
 
     if anth_req.profile is not None:
         try:
@@ -276,7 +282,9 @@ async def messages(
         )
         if ts_action == "reject":
             return _anthropic_error_response(
-                AnthropicErrorResponse(400, "invalid_request_error", REJECT_MESSAGE)
+                AnthropicErrorResponse(
+                    400, "invalid_request_error", REJECT_MESSAGE, {"x-should-retry": "false"}
+                )
             )
         if ts_action == "expand":
             anth_req = expand_tool_search(anth_req)
@@ -290,7 +298,9 @@ async def messages(
         # v2.16.0: ``context_budget_action: reject`` — Anthropic's own
         # overflow answer, so Claude Code compacts the conversation.
         return _anthropic_error_response(
-            AnthropicErrorResponse(400, "invalid_request_error", str(exc))
+            AnthropicErrorResponse(
+                400, "invalid_request_error", str(exc), {"x-should-retry": "false"}
+            )
         )
 
     if anth_req.stream:
@@ -362,7 +372,9 @@ async def messages(
             # swap) — same answer as the pre-dispatch check above.
             await _aclose_quietly(source)
             return _anthropic_error_response(
-                AnthropicErrorResponse(400, "invalid_request_error", str(exc))
+                AnthropicErrorResponse(
+                400, "invalid_request_error", str(exc), {"x-should-retry": "false"}
+            )
             )
         except (ToolLoopBreakError, ToolCountExceededError, MidStreamError) as exc:
             # Policy errors and mid-stream failures keep their existing
@@ -415,7 +427,9 @@ async def messages(
     except ContextBudgetRejectError as exc:
         # See the streaming branch: the engine can re-run the guard.
         return _anthropic_error_response(
-            AnthropicErrorResponse(400, "invalid_request_error", str(exc))
+            AnthropicErrorResponse(
+                400, "invalid_request_error", str(exc), {"x-should-retry": "false"}
+            )
         )
     except NoProvidersAvailableError as exc:
         # v2.16.0: Anthropic-shaped error with the upstream's own wording

coderouter/ingress/openai_routes.py

@@ -32,9 +32,10 @@ from fastapi import APIRouter, Header, HTTPException, Request
 from fastapi.responses import JSONResponse, StreamingResponse
 
 from coderouter.adapters.base import ChatRequest
+from coderouter.adapters.slot_affinity import affinity_key
 from coderouter.logging import get_logger
 from coderouter.routing import FallbackEngine, NoProvidersAvailableError
-from coderouter.routing.auto_router import RESERVED_PROFILE_NAME, classify
+from coderouter.routing.auto_router import RESERVED_PROFILE_NAME, classify, extract_gateway_hints
 from coderouter.routing.fallback_trace import current_fallback_trace
 
 router = APIRouter()
@@ -199,6 +200,10 @@ async def chat_completions(
     except Exception as exc:  # pydantic.ValidationError, etc.
         raise HTTPException(status_code=422, detail=str(exc)) from exc
 
+    # v2.18.0: gateway hint headers (routing matchers + KV-slot affinity key).
+    gateway_hints = extract_gateway_hints(request.headers)
+    chat_req.session_key = affinity_key(gateway_hints)
+
     # Header-based override (body wins if both are set — see module docstring)
     if chat_req.profile is None and x_coderouter_profile:
         chat_req.profile = x_coderouter_profile
@@ -226,7 +231,7 @@ async def chat_completions(
     # When inactive, the engine still falls through to
     # ``config.default_profile`` on its own — same semantics as pre-v1.6.
     if chat_req.profile is None and config.default_profile == RESERVED_PROFILE_NAME:
-        chat_req.profile = classify(payload, config)
+        chat_req.profile = classify(payload, config, gateway_hints)
 
     # Validate profile exists before we kick off any upstream call
     if chat_req.profile is not None:

coderouter/routing/auto_router.py

@@ -36,6 +36,7 @@ from __future__ import annotations
 
 import logging
 import re
+from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any
 
 from coderouter.config.schemas import AutoRouterConfig, AutoRouteRule, RuleMatcher
@@ -169,6 +170,32 @@ def _has_tools_in_body(body: dict[str, Any]) -> bool:
     return isinstance(functions, list) and len(functions) > 0
 
 
+# v2.18.0: Claude Code gateway hint headers → hint keys.
+_HINT_HEADERS: dict[str, str] = {
+    "x-claude-code-request-class": "request_class",
+    "x-claude-code-agent-type": "agent_type",
+    "x-claude-code-compaction": "compaction",
+    "x-claude-code-session-id": "session_id",
+    "x-claude-code-prompt-id": "prompt_id",
+}
+_TRUTHY = frozenset({"1", "true", "yes", "on"})
+
+
+def extract_gateway_hints(headers: Mapping[str, str]) -> dict[str, str]:
+    """Pull Claude Code's gateway hint headers out of a request.
+
+    Returns only the hints that are present (lower-cased keys from
+    :data:`_HINT_HEADERS`). Header lookup is case-insensitive whenever the
+    mapping is (Starlette's ``Headers`` is).
+    """
+    out: dict[str, str] = {}
+    for header, key in _HINT_HEADERS.items():
+        value = headers.get(header)
+        if value:
+            out[key] = value.strip()
+    return out
+
+
 def _match_rule(
     rule: AutoRouteRule,
     message: dict[str, Any] | None,
@@ -176,8 +203,17 @@ def _match_rule(
     model: str | None,
     estimated_tokens: int,
     has_tools: bool,
+    hints: Mapping[str, str] | None = None,
 ) -> bool:
     m = rule.match
+    if m.request_class is not None:
+        value = (hints or {}).get("request_class")
+        return value is not None and value.lower() == m.request_class.lower()
+    if m.agent_type is not None:
+        value = (hints or {}).get("agent_type")
+        return value is not None and value.lower() == m.agent_type.lower()
+    if m.compaction is True:
+        return (hints or {}).get("compaction", "").lower() in _TRUTHY
     if m.has_image is True:
         return message is not None and _has_image(message)
     if m.code_fence_ratio_min is not None:
@@ -237,7 +273,11 @@ def _extract_model(body: dict[str, Any]) -> str | None:
     return None
 
 
-def classify(body: dict[str, Any], config: CodeRouterConfig) -> str:
+def classify(
+    body: dict[str, Any],
+    config: CodeRouterConfig,
+    hints: Mapping[str, str] | None = None,
+) -> str:
     """Resolve an incoming request body to a profile name.
 
     Rule order (first match wins) is determined by:
@@ -252,6 +292,10 @@ def classify(body: dict[str, Any], config: CodeRouterConfig) -> str:
 
     Emits one of two log events: ``auto-router-resolved`` on match, or
     ``auto-router-fallthrough`` on default-rule fall.
+
+    v2.18.0: ``hints`` carries Claude Code's gateway hint headers (see
+    :func:`extract_gateway_hints`) for the ``request_class`` /
+    ``agent_type`` / ``compaction`` matchers.
     """
     user_msg = _latest_user_message(body)
     text = _extract_text(user_msg) if user_msg is not None else ""
@@ -294,7 +338,7 @@ def classify(body: dict[str, Any], config: CodeRouterConfig) -> str:
     # present — they short out via ``_match_rule``'s message-None
     # handling.
     for rule in rules:
-        if _match_rule(rule, user_msg, text, model, estimated_tokens, has_tools):
+        if _match_rule(rule, user_msg, text, model, estimated_tokens, has_tools, hints):
             _emit_resolved(rule, user_msg, text, model, estimated_tokens, has_tools)
             return rule.profile
 

coderouter/routing/capability.py

@@ -194,12 +194,13 @@ def strip_thinking(request: AnthropicRequest) -> AnthropicRequest:
 
     # model_dump() serializes extras; roundtripping via validate rebuilds a
     # clean instance without the dropped key. exclude=True fields (profile,
-    # anthropic_beta) are omitted by model_dump, so we reassign them.
+    # anthropic_beta, session_key) are omitted by model_dump, so we reassign them.
     dumped = request.model_dump()
     dumped.pop("thinking", None)
     stripped = AnthropicRequest.model_validate(dumped)
     stripped.profile = request.profile
     stripped.anthropic_beta = request.anthropic_beta
+    stripped.session_key = request.session_key
     return stripped
 
 
@@ -450,6 +451,7 @@ def emulate_tool_choice(request: AnthropicRequest) -> AnthropicRequest:
     emulated = AnthropicRequest.model_validate(dumped)
     emulated.profile = request.profile
     emulated.anthropic_beta = request.anthropic_beta
+    emulated.session_key = request.session_key
     return emulated
 
 
@@ -522,6 +524,7 @@ def strip_cache_control(request: AnthropicRequest) -> tuple[AnthropicRequest, in
     stripped = AnthropicRequest.model_validate(dumped)
     stripped.profile = request.profile
     stripped.anthropic_beta = request.anthropic_beta
+    stripped.session_key = request.session_key
     return stripped, removed
 
 

coderouter/routing/fallback.py

@@ -47,6 +47,7 @@ from coderouter.adapters.base import (
     ProviderCallOverrides,
     StreamChunk,
     StreamTruncatedError,
+    TTFTTimeoutError,
 )
 from coderouter.adapters.registry import build_adapter
 from coderouter.config.schemas import CodeRouterConfig, ProviderConfig
@@ -111,6 +112,7 @@ from coderouter.routing.fallback_trace import (
     REASON_PAID_GATE,
     REASON_SELF_HEALING_EXCLUDED,
     REASON_STREAM_TRUNCATED,
+    REASON_TTFT_TIMEOUT,
     REASON_UNKNOWN_PROVIDER,
     FallbackTrace,
     begin_fallback_trace,
@@ -898,6 +900,38 @@ def _emit_cache_observed_streaming(
     )
 
 
+async def _await_within_ttft(
+    awaitable: Any,
+    *,
+    deadline: float | None,
+    provider: str,
+    ttft_timeout_s: float | None,
+) -> Any:
+    """v2.17.0: await ``awaitable`` but give up at the TTFT ``deadline``.
+
+    ``deadline`` is a ``time.monotonic()`` instant (``None`` = no limit). On
+    expiry raises :class:`TTFTTimeoutError` — a retryable ``AdapterError``, so
+    every existing pre-content fallback branch handles it unchanged. The
+    cancelled await unwinds the adapter's generator, which releases its
+    upstream connection.
+    """
+    if deadline is None:
+        return await awaitable
+    remaining = deadline - time.monotonic()
+    if remaining <= 0:
+        close = getattr(awaitable, "close", None)
+        if close is not None:
+            close()
+        raise TTFTTimeoutError(provider=provider, ttft_timeout_s=ttft_timeout_s or 0.0)
+    try:
+        async with asyncio.timeout(remaining):
+            return await awaitable
+    except TimeoutError as exc:
+        raise TTFTTimeoutError(
+            provider=provider, ttft_timeout_s=ttft_timeout_s or 0.0
+        ) from exc
+
+
 class NoProvidersAvailableError(CodeRouterError):
     """Raised when every provider in the chain has failed (or was filtered out)."""
 
@@ -3354,7 +3388,7 @@ class FallbackEngine:
         # keeps the default byte-for-byte identical to v2.14.0.
         last_empty_stream_truncated = False
 
-        for adapter, will_degrade in chain:
+        for chain_idx, (adapter, will_degrade) in enumerate(chain):
             is_native = isinstance(adapter, AnthropicAdapter)
             downgrading = (not is_native) and bool(request.tools)
             effective_request = request
@@ -3414,6 +3448,14 @@ class FallbackEngine:
             # only the non-streaming generate_anthropic recorded, so the
             # busiest path produced no adaptive signal.
             attempt_started = time.monotonic()
+            # v2.17.0: TTFT cut-off. Never on the last provider — there is
+            # nothing left to fall back to, so waiting is the better answer.
+            ttft_s = getattr(adapter.config, "ttft_timeout_s", None)
+            ttft_deadline = (
+                attempt_started + ttft_s
+                if ttft_s is not None and chain_idx < len(chain) - 1
+                else None
+            )
             event_iter: AsyncIterator[AnthropicStreamEvent]
             first: AnthropicStreamEvent
             try:
@@ -3422,11 +3464,21 @@ class FallbackEngine:
                 # mypy narrows for stream_anthropic (not on BaseAdapter).
                 if isinstance(adapter, AnthropicAdapter):
                     event_iter = adapter.stream_anthropic(effective_request, overrides=overrides)
-                    first = await anext(event_iter)
+                    first = await _await_within_ttft(
+                        anext(event_iter),
+                        deadline=ttft_deadline,
+                        provider=adapter.name,
+                        ttft_timeout_s=ttft_s,
+                    )
                 elif downgrading:
                     # v0.3-D downgrade: run non-streaming, repair, replay.
                     chat_req = to_chat_request(effective_request)
                     chat_req.stream = False
+                    # v2.17.0: no TTFT deadline here. This branch is a
+                    # *non-streaming* call (the tool-turn downgrade), so its
+                    # "first output" is the whole answer — a TTFT cut would
+                    # become a total-generation limit and throw away slow
+                    # but healthy local replies. ``timeout_s`` bounds it.
                     chat_resp = await adapter.generate(chat_req, overrides=overrides)
                     # H-4: same as the non-streaming branch — keep the
                     # CPU-bound repair scan off the event loop.
@@ -3441,7 +3493,12 @@ class FallbackEngine:
                     event_iter = stream_chat_to_anthropic_events(
                         adapter.stream(chat_req, overrides=overrides)
                     )
-                    first = await anext(event_iter)
+                    first = await _await_within_ttft(
+                        anext(event_iter),
+                        deadline=ttft_deadline,
+                        provider=adapter.name,
+                        ttft_timeout_s=ttft_s,
+                    )
             except StopAsyncIteration:
                 # M2: record the empty-stream failure.
                 self._adaptive.record_attempt(
@@ -3557,7 +3614,18 @@ class FallbackEngine:
                                 yield buffered_ev
                             buffer = []
                     try:
-                        pending = await iterator.__anext__()
+                        if content_started:
+                            pending = await iterator.__anext__()
+                        else:
+                            # v2.17.0: the TTFT deadline also covers the
+                            # withheld preamble — first *real* output is
+                            # what counts, not the first event.
+                            pending = await _await_within_ttft(
+                                iterator.__anext__(),
+                                deadline=ttft_deadline,
+                                provider=adapter.name,
+                                ttft_timeout_s=ttft_s,
+                            )
                     except StopAsyncIteration:
                         break
             except AdapterError as exc:
@@ -3609,8 +3677,28 @@ class FallbackEngine:
                     # message — so the hop is recorded as ``stream-truncated``
                     # and the empty-response log is skipped. The adapter has
                     # already emitted ``stream-truncation-detected``.
-                    truncated = isinstance(exc, StreamTruncatedError)
-                    if truncated:
+                    #
+                    # v2.17.0: a TTFT cut-off lands here too, and its buffer
+                    # is just as unterminated (opening events, no
+                    # ``message_stop``). Treat it like a truncation so the
+                    # chain-exhausted flush below never replays it as a
+                    # "complete empty answer" — that would hand the client a
+                    # 200 stream that never ends. Close the abandoned upstream
+                    # stream now rather than waiting for GC.
+                    ttft_cut = isinstance(exc, TTFTTimeoutError)
+                    truncated = isinstance(exc, StreamTruncatedError) or ttft_cut
+                    if ttft_cut:
+                        aclose_iter = getattr(event_iter, "aclose", None)
+                        if aclose_iter is not None:
+                            with contextlib.suppress(Exception):
+                                await aclose_iter()
+                        trace.record_failure(
+                            adapter.name,
+                            REASON_TTFT_TIMEOUT,
+                            detail=describe_adapter_error(exc),
+                            stream=True,
+                        )
+                    elif truncated:
                         trace.record_failure(
                             adapter.name,
                             REASON_STREAM_TRUNCATED,

coderouter/routing/fallback_trace.py

@@ -111,6 +111,8 @@ REASON_EMPTY_STREAM: Final = "empty-stream"
 # ``connection`` (the transport itself broke). Produced only when the profile
 # sets ``stream_truncation_action: error``.
 REASON_STREAM_TRUNCATED: Final = "stream-truncated"
+# v2.17.0: no first real output within the provider's ``ttft_timeout_s``.
+REASON_TTFT_TIMEOUT: Final = "ttft-timeout"
 
 # -- degrade reasons (pre-existing strings; never produce a hop) -----------
 # Kept here so the whole ``reason`` vocabulary is readable in one place.
@@ -141,6 +143,7 @@ ATTEMPT_FAILURE_REASONS: Final[frozenset[str]] = frozenset(
         REASON_EMPTY_RESPONSE,
         REASON_EMPTY_STREAM,
         REASON_STREAM_TRUNCATED,
+        REASON_TTFT_TIMEOUT,
     }
 )
 
@@ -207,6 +210,8 @@ def describe_adapter_error(exc: AdapterError) -> str:
         # Not a transport fault — the HTTP body ended cleanly; it was the
         # LLM protocol inside it that never closed.
         return "no-terminator"
+    if reason == REASON_TTFT_TIMEOUT:
+        return "no-first-token"
     return f"transport={reason}"
 
 
@@ -227,10 +232,12 @@ def classify_adapter_error(exc: AdapterError) -> str:
     ``adapters.base`` is a TYPE_CHECKING-only import at module scope here
     (the runtime import order would otherwise cycle through the registry).
     """
-    from coderouter.adapters.base import StreamTruncatedError
+    from coderouter.adapters.base import StreamTruncatedError, TTFTTimeoutError
 
     if isinstance(exc, StreamTruncatedError):
         return REASON_STREAM_TRUNCATED
+    if isinstance(exc, TTFTTimeoutError):
+        return REASON_TTFT_TIMEOUT
     status = exc.status_code
     if status is None:
         message = str(exc).lower()

coderouter/translation/anthropic.py

@@ -277,6 +277,9 @@ class AnthropicRequest(BaseModel):
     # beta-gated body fields like `context_management`, `cache_control`,
     # `thinking` beyond what the default minor version accepts.
     anthropic_beta: str | None = Field(default=None, exclude=True)
+    # v2.18.0: conversation key for KV-slot affinity (Claude Code's
+    # ``x-claude-code-session-id``). Never serialized.
+    session_key: str | None = Field(default=None, exclude=True)
 
     @model_validator(mode="before")
     @classmethod

coderouter/translation/convert.py

@@ -285,6 +285,8 @@ def to_chat_request(req: AnthropicRequest) -> ChatRequest:
     )
     # Propagate CodeRouter routing hint.
     chat_req.profile = req.profile
+    # v2.18.0: carry the KV-slot affinity key across the translation.
+    chat_req.session_key = req.session_key
     return chat_req
 
 
@@ -1114,6 +1116,8 @@ def to_anthropic_request(chat_req: ChatRequest) -> AnthropicRequest:
     )
     # Propagate CodeRouter routing hint.
     req.profile = chat_req.profile
+    # v2.18.0: KV-slot affinity key (exclude=True, so set by hand).
+    req.session_key = chat_req.session_key
     return req
 
 

coderouter/vscode_init.py

@@ -127,16 +127,25 @@ _MANAGED_ENV_KEYS: tuple[str, ...] = (
 #   is given. Since 2.1.285 Claude Code assumes a 1M window behind a
 #   gateway for Opus 4.7+ / Sonnet 5+ / Fable ids, so auto-compaction would
 #   wait far past what a local model holds.
+# * ``CLAUDE_CODE_GATEWAY_HINT_HEADERS=1`` (v2.18.0) — makes Claude Code send
+#   ``x-claude-code-request-class`` / ``-agent-type`` / ``-compaction`` …, which
+#   the auto router's ``request_class`` / ``agent_type`` / ``compaction``
+#   matchers read. Harmless when no rule uses them.
 CLAUDE_CODE_ENV_KEYS: tuple[str, ...] = (
     "ENABLE_TOOL_SEARCH",
     "CLAUDE_CODE_AUTO_MODE_SERVER",
+    "CLAUDE_CODE_GATEWAY_HINT_HEADERS",
     "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
 )
 
 
 def claude_code_env(*, max_context_tokens: int | None = None) -> dict[str, str]:
     """v2.16.0: the Claude Code env vars ``vscode-init`` writes by default."""
-    env = {"ENABLE_TOOL_SEARCH": "false", "CLAUDE_CODE_AUTO_MODE_SERVER": "0"}
+    env = {
+        "ENABLE_TOOL_SEARCH": "false",
+        "CLAUDE_CODE_AUTO_MODE_SERVER": "0",
+        "CLAUDE_CODE_GATEWAY_HINT_HEADERS": "1",
+    }
     if max_context_tokens is not None:
         if max_context_tokens <= 0:
             raise ValueError("max_context_tokens must be positive")

{coderouter_cli-2.16.0.dist-info → coderouter_cli-2.18.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: coderouter-cli
-Version: 2.16.0
+Version: 2.18.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

{coderouter_cli-2.16.0.dist-info → coderouter_cli-2.18.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 coderouter/__init__.py,sha256=ghdjPrLtnRzY8fyQ4CJZI1UJKADyNTLtA3G7se8H7Ns,696
 coderouter/__main__.py,sha256=-LCgxJnvgUV240HjQKv7ly-mn2NuKHpC4nCpvTHjeSU,130
-coderouter/cli.py,sha256=-QPJ2wTJIpa4TvIFObNaV4hyv_OeDtoLebc692ZWYQA,44775
+coderouter/cli.py,sha256=qqwMv5dmWU6bq6okgbIK6YuDHPkWYhv5Y3jAXSY44-U,44825
 coderouter/cli_stats.py,sha256=CCjzc1G4hTRHZ2gG1XhxhDpUkJnnl3NXbcbp1T18jpg,29894
 coderouter/cost.py,sha256=32h6uzb4nxh2eA5d2Hn3kD9yJbtis6CFDAbeIy5KRkM,7431
 coderouter/credentials.py,sha256=R_PdrcA941_jJX_U8hxrjPDTCVVzLd4dsw2c00KwAwE,12991
 coderouter/doctor.py,sha256=0EUqKaEw2GaqX6zGKjR-bVDdlmBznFIklSz3yIoQbE0,91969
 coderouter/doctor_apply.py,sha256=tZT3bEd1G6t67YRhf1TGY4NlSvZuJJbnEqN-3AKy8Hc,29972
-coderouter/doctor_claude_code.py,sha256=15ZdyUg0M_wZGEBN9Q3eb_D75lncqxQi1dNV6irWh2U,6621
+coderouter/doctor_claude_code.py,sha256=DuG4abNQWigo0IlJQJWHYGJ0lsu2oL3cNek4DvAYPXA,7091
 coderouter/env_security.py,sha256=FEBZnXfJ0xE39kmMMn39zk0W_DRRnmcB_REmP9f4xWo,14796
 coderouter/errors.py,sha256=Xmq67lheyw8iv3Ox39jh2c4tvNI5RcUR4QkoxVDN6l4,1130
 coderouter/gguf_introspect.py,sha256=Scu0JjUfLHj7T7TL0HQIm1AZcGYrXsjkaMMSN9HkTro,16121
@@ -21,17 +21,18 @@ coderouter/rollback.py,sha256=Bqxx1MALTDLYc0BtGMEMqRyiZIWFoAZJH_RBQw-M5ow,7675
 coderouter/secret_redaction.py,sha256=Rg71gqKN6jnybZ6UvCvXIvnThI9uRBvmOqC2grSUSUk,23159
 coderouter/token_estimation.py,sha256=7klQYA4FIg1vtjQGWAhwiBhiLwyz8KTetrLVXFJLGIc,16957
 coderouter/token_estimation_accurate.py,sha256=GTfzrBVnvAGjeVzmzAeUdOYZvWZKLAxcxPpFiJGlzjk,4609
-coderouter/vscode_init.py,sha256=rs3S0FOuPFZhhDvE547Zonhj98al66Jc8G1wvBnFq40,35915
+coderouter/vscode_init.py,sha256=eSkp2mOLhwCbv8EUdZ8Bkb3K2wMkjgHBCzVfZl7-MWo,36316
 coderouter/adapters/__init__.py,sha256=7dIDSZ-FE_0iSqLSDc_lK1idRdLTKcM2hP9tCJipgPI,463
-coderouter/adapters/anthropic_native.py,sha256=fYM4uXdYYvXfYBgz2dPjdPwv-yKY7XfnXp18YZNCsjg,30185
-coderouter/adapters/base.py,sha256=8TxlhYwrLk6hFg3_j84yoJq-55QxDmyfo0BLeTcRMro,14573
-coderouter/adapters/openai_compat.py,sha256=-6jD8RLjlocmnGCkGWm6C0j5fLumadJb9J-wZW4a-GQ,24121
+coderouter/adapters/anthropic_native.py,sha256=PXxgnERTm8bsCYrxpOaaJmPVq0FJVfocBjZ7HLNZA2c,30367
+coderouter/adapters/base.py,sha256=83mFELqGq8i1E4uESTSjBgdPGSB1rj8FM9WRfNlIjPE,15484
+coderouter/adapters/openai_compat.py,sha256=DKFIgZFpqzYyqsN49-MB1CA23CdV_1t19QHkvBhhlGI,24350
 coderouter/adapters/registry.py,sha256=XNc1wmFv_oZlqKS0rA693TRDdbq1sZ-OIcofXOVOtq0,3680
+coderouter/adapters/slot_affinity.py,sha256=iu4nqOFmwBoh7i3a1tR4jYgioq3Re2GH66Xr1XiDfvs,2067
 coderouter/config/__init__.py,sha256=FODEn74fN-qZnt4INPSHswqhOlEgpL6-_onxsitSx8g,274
 coderouter/config/capability_registry.py,sha256=RZgzHF54dXy0CCDocRCz2ee21qXGbbgTSKTkRI9iLL4,16936
 coderouter/config/env_file.py,sha256=CoMK27fuAXm-NtoLzXb8yN2E-wDFjHQuFwiIlmgTBQw,10356
 coderouter/config/loader.py,sha256=7FoJXWaO_vN9FAjUStJDwI4aAYcUQQgMJtq5BNy8Pnc,12419
-coderouter/config/schemas.py,sha256=pabFnhY070rWhzl9JF9jqyfRGhrD4VSwIC-xWsHGskc,148608
+coderouter/config/schemas.py,sha256=Xwkx8-6f6Ch0JMVnoUzBJLeD_ykIOOHt_p9KxRfx_EE,151645
 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
@@ -46,13 +47,13 @@ coderouter/guards/memory_pressure.py,sha256=9Xm-b7rv9Td5kPNmAFoL3sNmaOR5zT8NLdn6
 coderouter/guards/self_healing.py,sha256=XeUlgFWGqMQ5E9YvvzR2CsHRJOAJEyDChqRN0xmZ0vo,16841
 coderouter/guards/tool_loop.py,sha256=EzeMcmU7BLeTW2jsRVevU81l5rhWcn1oUr7EpzgXjVM,15209
 coderouter/ingress/__init__.py,sha256=WQsCH2CGJCAhy0mS6GSEdeYZRkkQu2OHDsP4CJWTLug,155
-coderouter/ingress/anthropic_errors.py,sha256=SYmcqHeQWuiAsgBjquOemmv_KIr23WTyWtjohuzLOLg,7352
-coderouter/ingress/anthropic_routes.py,sha256=O2ejNl8SdXaMt-EArgsPa47NHxzvIRtVOeHMr5kJApM,39963
+coderouter/ingress/anthropic_errors.py,sha256=q8F4LmH57f8Jh2hoV4Mmnvf9sZH32uiXhQXPRBZPjCE,8122
+coderouter/ingress/anthropic_routes.py,sha256=2ADG_JgvmZteTm4rJfjdM5FU4IA9Wdtd9gZXm2-vI8Y,40561
 coderouter/ingress/app.py,sha256=ZOx7dSvMxaWS4CzXOOEwgzFuycAVgAeWKCN6lFNF-F0,22433
 coderouter/ingress/dashboard_routes.py,sha256=nPW5_pJe27-hzqCs4sqVVn0BrgXB_7Wcd4qZ6cirvWo,26736
 coderouter/ingress/launcher_routes.py,sha256=uP_Otp9JE0fydUt1YP-wYcnS8Kj5RPLNIFf88YpfkPM,141535
 coderouter/ingress/metrics_routes.py,sha256=4s_f9CY8nVIdQBfXxyUMlN7r5_cXHOaAu7PvNbUuoxg,4609
-coderouter/ingress/openai_routes.py,sha256=9DHVtGe1mpcUBH3ziDL4RGpEA-LzjyANpBIN3Kfbpxc,14193
+coderouter/ingress/openai_routes.py,sha256=Nc_Vh8rjLtc88oNbXfU9fwm-XZs0tTHVg-D5GEAuh_I,14484
 coderouter/ingress/tool_search.py,sha256=JYnJ8SUqPmBfZmsl41TdBQNnux0mwbidKdsr5qn15Hk,3753
 coderouter/ingress/ui_auth.py,sha256=uCWB5IaMQRNFYdY39FQ5DDVhsoRQJoqimZNSAu_QK_Q,3742
 coderouter/metrics/__init__.py,sha256=7Es351DPS7yLM0yVF_F0eesmiD83n7Zzhie44chht38,1465
@@ -64,11 +65,11 @@ coderouter/plugins/loader.py,sha256=KLnKgO6_GE7OJulwo292cTYPvxqWZlLL8S0k_O3ZDcg,
 coderouter/plugins/registry.py,sha256=8UDmRpHnRdB-ES_xpprvrvbDlhIhonOvFFXobR6MGJA,3739
 coderouter/routing/__init__.py,sha256=oLQXPvKfrwy0OiGYNXngM9G_OxmJVLShv-nqyDaqSOs,441
 coderouter/routing/adaptive.py,sha256=G2o377twGSjbUh65wiIFx6klnpFGjsD_nI3oDvcBwhY,21257
-coderouter/routing/auto_router.py,sha256=y4v0c8u5F9f98Vmhx1vRcKPiOgAvpzbFqr6TIh058h0,13341
+coderouter/routing/auto_router.py,sha256=XkRTf0oT4zdTTeJagZdvnyW6hOdgtZ_arwb8NN1h01Y,14980
 coderouter/routing/budget.py,sha256=PblmVKJGs_BwNa9uDHAA8hmZ4XIVKv38mHAeU0V3OMs,8451
-coderouter/routing/capability.py,sha256=rRQhzTgQYFTFDNYcSLKvq3xjdw6B1w7T-3jS7PTMI14,27864
-coderouter/routing/fallback.py,sha256=0tN6LPFijZ5cZ-Fc2VpipIVvFHpgCgNCx1COXfenxgs,172687
-coderouter/routing/fallback_trace.py,sha256=0BysXY1CZqSvVTuePbgmHbu1AKkHLMX7hsuG6rKlDdE,19787
+coderouter/routing/capability.py,sha256=_RM9I6qG_oQLN_ZN4n7Xd7__g-CtClX9cdhtKvuJUvA,28018
+coderouter/routing/fallback.py,sha256=vx1Vrl_vy7-dLxkKvipfba_pbhQPbuhRVFjmuMMWyaI,176825
+coderouter/routing/fallback_trace.py,sha256=LwUw56mhVIkP4Gu-fNvZmOjL8hXxY1ci6b1MuGjl5m0,20099
 coderouter/state/__init__.py,sha256=XoGcPmmBQSiZWML2S0juSveQ78xfhtdeCliNnVyzu7E,1088
 coderouter/state/audit_log.py,sha256=CEFNJht2WZ8mqesI8CzeuL63NfzFzAZ7wF88auyl6l0,11444
 coderouter/state/replay.py,sha256=Z_YHKroTKZdrL8qObFxcoLOAQWWXZvXFdLfxzvBhEJg,11230
@@ -76,12 +77,12 @@ coderouter/state/request_log.py,sha256=JlEvkWHwGtoLesnqr0XJy9CyXQDX4ZRHFMTPJ_0Fe
 coderouter/state/store.py,sha256=h-rsMJq8GILsOfCP94nI40cuHaj4Vqycsm9UNN77REI,7445
 coderouter/state/suggest_rules.py,sha256=FvdhEvao5NvdKp9zs8AkcoFKHY4yqqXY2HekvSjpDFA,16670
 coderouter/translation/__init__.py,sha256=PYXN7XVEwpG1uC8RLy6fvnGbzEZhhrEuUapH8IYOtG8,1788
-coderouter/translation/anthropic.py,sha256=ZQQGS9itN_3o7IKD68lKr5gR_Kem32Jsd7OcGjJzv8Q,13468
-coderouter/translation/convert.py,sha256=VrstDAMsUpcQ1VgMTn_-ETp1OjGX8v0ZGhCkcd4icyU,53037
+coderouter/translation/anthropic.py,sha256=49OMMIKBRZqsWhl0VhlMck8R-W34vxaTgpIlKI0kvVg,13655
+coderouter/translation/convert.py,sha256=9lkfk8ByfbgiVh2WP6Hwh8UorOtrTxZBknvu_dsHnnI,53261
 coderouter/translation/tool_repair.py,sha256=1p8rmdyyscGX2g0DDOYitMnLv-nKfR1SLuLaRB4z7GM,64244
 coderouter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-coderouter_cli-2.16.0.dist-info/METADATA,sha256=qGzoESa_lbm11v64IwRodTt2j1HC7uOd2-hvsXN1ETg,18221
-coderouter_cli-2.16.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-coderouter_cli-2.16.0.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
-coderouter_cli-2.16.0.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
-coderouter_cli-2.16.0.dist-info/RECORD,,
+coderouter_cli-2.18.0.dist-info/METADATA,sha256=kaaVhGuXqVYMlOZ5Yjug5iLaiKj02s-Yd1ae5ySPcJc,18221
+coderouter_cli-2.18.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+coderouter_cli-2.18.0.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
+coderouter_cli-2.18.0.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
+coderouter_cli-2.18.0.dist-info/RECORD,,