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

coderouter/adapters/anthropic_native.py

@@ -458,6 +458,8 @@ class AnthropicAdapter(BaseAdapter):
                 provider=self.name,
                 status_code=resp.status_code,
                 retryable=resp.status_code in _RETRYABLE_STATUSES,
+                upstream_body=resp.text,
+                retry_after=resp.headers.get("retry-after"),
             )
 
         try:
@@ -570,6 +572,8 @@ class AnthropicAdapter(BaseAdapter):
                         provider=self.name,
                         status_code=resp.status_code,
                         retryable=resp.status_code in _RETRYABLE_STATUSES,
+                        upstream_body=body.decode("utf-8", errors="replace"),
+                        retry_after=resp.headers.get("retry-after"),
                     )
 
                 # Anthropic SSE block shape:

coderouter/adapters/base.py

@@ -101,6 +101,12 @@ class StreamChunk(BaseModel):
     usage: dict[str, Any] | None = None
 
 
+#: v2.16.0: max chars of an upstream error body an :class:`AdapterError`
+#: keeps. Error bodies are small; the cap only bounds a misbehaving upstream
+#: that answers an error status with a large HTML page.
+UPSTREAM_BODY_CAP = 4096
+
+
 class AdapterError(CodeRouterError):
     """Raised when a provider call fails in a way the fallback engine should retry on."""
 
@@ -111,6 +117,8 @@ class AdapterError(CodeRouterError):
         provider: str,
         status_code: int | None = None,
         retryable: bool = True,
+        upstream_body: str | None = None,
+        retry_after: str | None = None,
     ) -> None:
         """Construct an AdapterError.
 
@@ -125,11 +133,23 @@ class AdapterError(CodeRouterError):
             retryable: When True, the fallback engine may try the next
                 provider in the chain. When False, the engine stops
                 and surfaces the error as a terminal failure.
+            upstream_body: v2.16.0 — the upstream's error body (capped at
+                :data:`UPSTREAM_BODY_CAP` chars), kept so the ingress can
+                hand the upstream's own wording back to the client.
+                Claude Code recovers from several 400s (rejected beta
+                headers, tool search, context overflow) only when it can
+                read the upstream message. Never logged by this class.
+            retry_after: v2.16.0 — the upstream's ``Retry-After`` header
+                value, verbatim, when it sent one.
         """
         super().__init__(message)
         self.provider = provider
         self.status_code = status_code
         self.retryable = retryable
+        self.upstream_body = (
+            upstream_body[:UPSTREAM_BODY_CAP] if upstream_body is not None else None
+        )
+        self.retry_after = retry_after
 
     def __str__(self) -> str:
         """Render as ``[provider status=NNN] message`` for log trails."""

coderouter/adapters/openai_compat.py

@@ -244,6 +244,8 @@ class OpenAICompatAdapter(BaseAdapter):
                 provider=self.name,
                 status_code=resp.status_code,
                 retryable=resp.status_code in _RETRYABLE_STATUSES,
+                upstream_body=resp.text,
+                retry_after=resp.headers.get("retry-after"),
             )
 
         try:
@@ -381,6 +383,8 @@ class OpenAICompatAdapter(BaseAdapter):
                         provider=self.name,
                         status_code=resp.status_code,
                         retryable=resp.status_code in _RETRYABLE_STATUSES,
+                        upstream_body=body.decode("utf-8", errors="replace"),
+                        retry_after=resp.headers.get("retry-after"),
                     )
                 async for line in resp.aiter_lines():
                     if not line:

coderouter/cli.py

@@ -165,6 +165,17 @@ def _build_parser() -> argparse.ArgumentParser:
             "for live key values. Exit 0 clean / 2 needs attention / 1 leak."
         ),
     )
+    doctor.add_argument(
+        "--check-claude-code",
+        action="store_true",
+        help=(
+            "v2.16.0: check the local Claude Code install for gateway use — "
+            "known-bad versions (<2.1.301, 2.1.304) and the env vars that "
+            "matter behind a non-Anthropic gateway (ENABLE_TOOL_SEARCH, "
+            "CLAUDE_CODE_MAX_CONTEXT_TOKENS, CLAUDE_CODE_AUTO_MODE_SERVER). "
+            "No network. Exit 0 OK / 2 needs attention."
+        ),
+    )
     doctor.add_argument(
         "--config",
         default=None,
@@ -454,6 +465,28 @@ def _build_parser() -> argparse.ArgumentParser:
             "generation. Tip: keep secrets in a separate .envrc.local."
         ),
     )
+    vscode_init.add_argument(
+        "--max-context-tokens",
+        type=int,
+        default=None,
+        metavar="N",
+        help=(
+            "v2.16.0: also write CLAUDE_CODE_MAX_CONTEXT_TOKENS=N so Claude "
+            "Code compacts before your local model's context fills up "
+            "(since 2.1.285 it assumes 1M behind a gateway). Use the "
+            "smallest context window in the profile's chain."
+        ),
+    )
+    vscode_init.add_argument(
+        "--no-claude-code-env",
+        action="store_true",
+        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 "
+            "api.anthropic.com only."
+        ),
+    )
     vscode_init.add_argument(
         "--dry-run",
         action="store_true",
@@ -595,10 +628,16 @@ def _run_doctor(args: argparse.Namespace) -> int:
     risks AND broken providers can use a single command.
     """
     check_secrets = bool(getattr(args, "check_secrets", False))
-    if args.check_model is None and args.check_env is None and not check_secrets:
+    check_claude_code = bool(getattr(args, "check_claude_code", False))
+    if (
+        args.check_model is None
+        and args.check_env is None
+        and not check_secrets
+        and not check_claude_code
+    ):
         print(
             "doctor: provide --check-model PROVIDER, --check-env [PATH], "
-            "and/or --check-secrets",
+            "--check-secrets and/or --check-claude-code",
             file=sys.stderr,
         )
         return 1
@@ -614,6 +653,14 @@ def _run_doctor(args: argparse.Namespace) -> int:
     if check_secrets:
         worst_exit = max(worst_exit, _run_check_secrets(args.config))
 
+    if check_claude_code:
+        from coderouter.doctor_claude_code import format_report as _cc_format
+        from coderouter.doctor_claude_code import run_check as _cc_run
+
+        cc_report = _cc_run()
+        print(_cc_format(cc_report))
+        worst_exit = max(worst_exit, cc_report.exit_code)
+
     if args.check_model is not None:
         worst_exit = max(worst_exit, _run_check_model(args))
 
@@ -976,6 +1023,7 @@ def _run_vscode_init(args: argparse.Namespace) -> int:
     """
     from coderouter.vscode_init import (
         DEFAULT_PORT,
+        claude_code_env,
         exit_code_for,
         format_result,
         run_vscode_init,
@@ -991,6 +1039,22 @@ def _run_vscode_init(args: argparse.Namespace) -> int:
 
     port = args.port if args.port is not None else DEFAULT_PORT
 
+    extra_env: dict[str, str] | None = None
+    max_ctx = getattr(args, "max_context_tokens", None)
+    if getattr(args, "no_claude_code_env", False):
+        if max_ctx is not None:
+            print(
+                "vscode-init: --max-context-tokens has no effect with --no-claude-code-env",
+                file=sys.stderr,
+            )
+            return 2
+    else:
+        try:
+            extra_env = claude_code_env(max_context_tokens=max_ctx)
+        except ValueError as exc:
+            print(f"vscode-init: {exc}", file=sys.stderr)
+            return 2
+
     try:
         result = run_vscode_init(
             target,
@@ -999,6 +1063,7 @@ def _run_vscode_init(args: argparse.Namespace) -> int:
             with_envrc=args.with_envrc,
             dry_run=args.dry_run,
             force=args.force,
+            extra_env=extra_env,
         )
     except FileNotFoundError as exc:
         # Raised only when target vanishes between the pre-check above

coderouter/config/schemas.py

@@ -1089,7 +1089,13 @@ class FallbackChain(BaseModel):
     #                (``context_budget_preserve_last_n``) are always
     #                kept, and tool_use / tool_result pairs are preserved
     #                atomically to avoid breaking agent loops.
-    context_budget_action: Literal["off", "warn", "trim"] = Field(
+    #   * ``reject`` — v2.16.0: ``warn`` + at ``context_budget_trim_threshold``
+    #                refuse the request with Anthropic's own overflow error
+    #                (HTTP 400, ``prompt is too long: ...``). Claude Code
+    #                answers that by compacting the conversation itself
+    #                (a summary, not a silent cut), so this is the
+    #                recommended action for Claude Code sessions.
+    context_budget_action: Literal["off", "warn", "trim", "reject"] = Field(
         default="off",
         description=(
             "v2.0-F (L1): action when estimated request tokens approach "
@@ -1097,7 +1103,10 @@ class FallbackChain(BaseModel):
             "disables the guard entirely. ``warn`` emits a log and "
             "response header at ``context_budget_warn_threshold``. "
             "``trim`` additionally removes old messages at "
-            "``context_budget_trim_threshold`` to reclaim context space."
+            "``context_budget_trim_threshold`` to reclaim context space. "
+            "``reject`` (v2.16.0) instead answers HTTP 400 "
+            "``prompt is too long`` at that threshold so the client "
+            "compacts the conversation itself (Claude Code does)."
         ),
     )
     context_budget_warn_threshold: float = Field(
@@ -1222,6 +1231,31 @@ class FallbackChain(BaseModel):
     # --- v2.0-H (L6): Mid-stream partial stitching --------------------------
     #   * ``off``      — discard partial content on mid-stream failure (legacy).
     #   * ``surface``  — return partial content as a truncated-but-valid response.
+    # v2.16.0 (tool search): Claude Code 2.1.304+ turns tool search on behind
+    # a custom ANTHROPIC_BASE_URL. The request then carries a server-side
+    # tool-search tool (``type: tool_search_tool_*``) and tools marked
+    # ``defer_loading: true``, which only api.anthropic.com executes. A
+    # local model sees the search tool as an ordinary function (and may
+    # "call" it), while every deferred MCP tool lands in its context anyway.
+    # Claude Code retries without tool search when the gateway answers 400.
+    #   * ``auto``        — ``passthrough`` when every provider in the chain
+    #                       is ``kind: anthropic`` on api.anthropic.com,
+    #                       otherwise ``reject`` (default).
+    #   * ``reject``      — answer 400 so the client turns tool search off.
+    #   * ``expand``      — drop the search tool and the ``defer_loading``
+    #                       flags; every tool is sent up front.
+    #   * ``passthrough`` — forward unchanged (pre-v2.16.0 behaviour).
+    deferred_tools_action: Literal["auto", "reject", "expand", "passthrough"] = Field(
+        default="auto",
+        description=(
+            "v2.16.0: what to do with Claude Code tool search "
+            "(``defer_loading`` tools / ``tool_search_tool_*``). ``auto`` "
+            "passes it through only for chains made entirely of "
+            "api.anthropic.com providers and rejects it (HTTP 400, which "
+            "makes Claude Code retry without tool search) otherwise."
+        ),
+    )
+
     partial_stitch_action: Literal["off", "surface"] = Field(
         default="off",
         description=(

coderouter/doctor_claude_code.py

@@ -0,0 +1,181 @@
+"""``coderouter doctor --check-claude-code`` (v2.16.0).
+
+Local-only checks for a Claude Code install that talks to CodeRouter:
+
+1. **Version.** Known gateway-relevant regressions:
+
+   - before 2.1.301: compaction could repeat when the response's ``model``
+     name differs from the requested one (every translating gateway);
+   - exactly 2.1.304: every request failed behind a gateway that rejects
+     tool search (fixed in 2.1.305).
+
+2. **Environment.** Variables that matter behind a non-Anthropic gateway
+   (see ``coderouter vscode-init``):
+
+   - ``ENABLE_TOOL_SEARCH`` unset → tool search is on by default since
+     2.1.304; CodeRouter refuses it (``deferred_tools_action``) and Claude
+     Code retries without it — works, but costs a round trip per session;
+   - ``CLAUDE_CODE_MAX_CONTEXT_TOKENS`` unset on 2.1.285+ → Claude Code may
+     assume a 1M window and compact far too late for a local model;
+   - ``CLAUDE_CODE_AUTO_MODE_SERVER`` unset → auto mode asks the gateway
+     for a server-side classifier a local backend does not have.
+
+No network, no config file. Exit codes follow the other doctor checks:
+0 = OK, 2 = needs attention, 1 = could not run.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass, field
+
+_VERSION_RE = re.compile(r"(\d+)\.(\d+)\.(\d+)")
+
+Version = tuple[int, int, int]
+
+
+@dataclass
+class ClaudeCodeFinding:
+    level: str  # "ok" | "warn" | "info"
+    message: str
+
+
+@dataclass
+class ClaudeCodeReport:
+    version: Version | None
+    findings: list[ClaudeCodeFinding] = field(default_factory=list)
+    error: str | None = None
+
+    @property
+    def exit_code(self) -> int:
+        if self.error is not None:
+            return 1
+        return 2 if any(f.level == "warn" for f in self.findings) else 0
+
+
+def parse_version(text: str) -> Version | None:
+    m = _VERSION_RE.search(text)
+    if m is None:
+        return None
+    return (int(m.group(1)), int(m.group(2)), int(m.group(3)))
+
+
+def _fmt(v: Version) -> str:
+    return ".".join(str(p) for p in v)
+
+
+def check(version: Version | None, env: Mapping[str, str]) -> list[ClaudeCodeFinding]:
+    """Pure check: findings for a Claude Code version and an environment."""
+    out: list[ClaudeCodeFinding] = []
+    if version is not None:
+        if version < (2, 1, 301):
+            out.append(
+                ClaudeCodeFinding(
+                    "warn",
+                    f"Claude Code {_fmt(version)} is older than 2.1.301: compaction can "
+                    "repeat behind a gateway that reports a different model name. "
+                    "Update Claude Code.",
+                )
+            )
+        elif version == (2, 1, 304):
+            out.append(
+                ClaudeCodeFinding(
+                    "warn",
+                    "Claude Code 2.1.304 fails every request behind a gateway that "
+                    "rejects tool search (fixed in 2.1.305). Update Claude Code, or "
+                    "set ENABLE_TOOL_SEARCH=false.",
+                )
+            )
+        else:
+            out.append(ClaudeCodeFinding("ok", f"Claude Code {_fmt(version)}"))
+
+    if env.get("ENABLE_TOOL_SEARCH", "").lower() in ("false", "0"):
+        out.append(ClaudeCodeFinding("ok", "ENABLE_TOOL_SEARCH=false"))
+    else:
+        out.append(
+            ClaudeCodeFinding(
+                "warn",
+                "ENABLE_TOOL_SEARCH is not false: Claude Code 2.1.304+ starts each "
+                "session with tool search, which only api.anthropic.com runs. "
+                "CodeRouter refuses it and Claude Code retries without it. Set "
+                "ENABLE_TOOL_SEARCH=false (coderouter vscode-init does) to skip "
+                "that round trip.",
+            )
+        )
+
+    if "CLAUDE_CODE_MAX_CONTEXT_TOKENS" in env:
+        out.append(
+            ClaudeCodeFinding(
+                "ok", f"CLAUDE_CODE_MAX_CONTEXT_TOKENS={env['CLAUDE_CODE_MAX_CONTEXT_TOKENS']}"
+            )
+        )
+    elif version is None or version >= (2, 1, 285):
+        out.append(
+            ClaudeCodeFinding(
+                "warn",
+                "CLAUDE_CODE_MAX_CONTEXT_TOKENS is not set: since 2.1.285 Claude Code "
+                "may assume a 1M window behind a gateway and compact long after a "
+                "local model has overflowed. Set it to your smallest local context "
+                "window (coderouter vscode-init --max-context-tokens N), and/or use "
+                "context_budget_action: reject in the profile.",
+            )
+        )
+
+    if env.get("CLAUDE_CODE_AUTO_MODE_SERVER") == "0":
+        out.append(ClaudeCodeFinding("ok", "CLAUDE_CODE_AUTO_MODE_SERVER=0"))
+    else:
+        out.append(
+            ClaudeCodeFinding(
+                "warn",
+                "CLAUDE_CODE_AUTO_MODE_SERVER is not 0: on a gateway, auto mode "
+                "defaults to a server-side classifier that a local backend does not "
+                "provide. Set CLAUDE_CODE_AUTO_MODE_SERVER=0.",
+            )
+        )
+    return out
+
+
+def _claude_version(run: Callable[[list[str]], str] | None = None) -> tuple[Version | None, str | None]:
+    if run is None:
+        exe = shutil.which("claude")
+        if exe is None:
+            return None, "`claude` not found on PATH (version checks skipped)"
+
+        def run(cmd: list[str]) -> str:
+            proc = subprocess.run(cmd, capture_output=True, text=True, timeout=15, check=False)
+            return proc.stdout + proc.stderr
+
+        cmd = [exe, "--version"]
+    else:
+        cmd = ["claude", "--version"]
+    try:
+        text = run(cmd)
+    except (OSError, subprocess.SubprocessError) as exc:
+        return None, f"could not run `claude --version`: {exc}"
+    version = parse_version(text)
+    if version is None:
+        return None, f"could not parse `claude --version` output: {text.strip()[:80]!r}"
+    return version, None
+
+
+def run_check(
+    env: Mapping[str, str] | None = None,
+    run: Callable[[list[str]], str] | None = None,
+) -> ClaudeCodeReport:
+    version, note = _claude_version(run)
+    findings = check(version, os.environ if env is None else env)
+    if note:
+        findings.insert(0, ClaudeCodeFinding("info", note))
+    return ClaudeCodeReport(version=version, findings=findings)
+
+
+def format_report(report: ClaudeCodeReport) -> str:
+    lines = ["Claude Code (behind CodeRouter)"]
+    for f in report.findings:
+        mark = {"ok": "OK  ", "warn": "WARN", "info": "INFO"}.get(f.level, f.level.upper())
+        lines.append(f"  [{mark}] {f.message}")
+    return "\n".join(lines)

coderouter/guards/context_budget.py

@@ -87,6 +87,25 @@ if TYPE_CHECKING:
 # ---------------------------------------------------------------------------
 
 
+class ContextBudgetRejectError(Exception):
+    """v2.16.0: ``context_budget_action: reject`` refused an oversized request.
+
+    The ingress answers with Anthropic's overflow error (HTTP 400,
+    ``prompt is too long: ...``) so the client compacts the conversation
+    itself. Carries the numbers for the message and the log line.
+    """
+
+    def __init__(self, *, estimated_tokens: int, max_context_tokens: int, profile: str) -> None:
+        self.estimated_tokens = estimated_tokens
+        self.max_context_tokens = max_context_tokens
+        self.profile = profile
+        super().__init__(
+            f"prompt is too long: ~{estimated_tokens} tokens > "
+            f"{max_context_tokens} maximum (CodeRouter profile {profile!r}, "
+            "estimated)"
+        )
+
+
 @dataclass(frozen=True, slots=True)
 class ContextBudgetEstimate:
     """Result of a context-budget estimation check."""

coderouter/ingress/anthropic_errors.py

@@ -0,0 +1,185 @@
+"""Anthropic-shaped error responses for the ``/v1/messages`` ingress (v2.16.0).
+
+Before v2.16.0 a request whose whole chain failed came back as FastAPI's
+``{"detail": "profile=...: all providers failed: ..."}`` with HTTP 502,
+whatever the upstreams had said. Claude Code reads Anthropic's error shape
+(``{"type": "error", "error": {"type": ..., "message": ...}}``) and keys
+several recoveries off the upstream's *wording*:
+
+- a 400 that names a rejected beta header, ``context_management`` or tool
+  search makes it resend without that feature (2.1.288 to 2.1.305);
+- a 400 whose message says ``prompt is too long`` triggers reactive
+  compaction instead of ending the turn.
+
+None of that can fire when the message is buried in a 502 ``detail`` string.
+This module turns a :class:`NoProvidersAvailableError` into the status code,
+Anthropic error type and message the client should see, keeping the
+upstream's own words (secret-redacted).
+
+Mapping (first match wins, judged on the chain's errors):
+
+====================================  ======  ========================
+condition                             status  ``error.type``
+====================================  ======  ========================
+any error reads as context overflow   400     ``invalid_request_error``
+                                              (message starts with
+                                              ``prompt is too long:``)
+terminal error 400 / 422, not         400     ``invalid_request_error``
+retryable
+terminal error 413                    413     ``request_too_large``
+terminal error 429                    429     ``rate_limit_error``
+                                              (+ ``retry-after`` passed
+                                              through when sent)
+anything else                         502     ``api_error``
+====================================  ======  ========================
+
+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.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from coderouter.secret_redaction import redact
+
+if TYPE_CHECKING:
+    from coderouter.adapters.base import AdapterError
+    from coderouter.routing.fallback import NoProvidersAvailableError
+
+
+#: Prefix Claude Code matches to start reactive compaction. Anthropic's own
+#: wording is ``prompt is too long: 208000 tokens > 200000 maximum``.
+PROMPT_TOO_LONG_PREFIX = "prompt is too long"
+
+# Upstream wordings for "the prompt does not fit the context window".
+# Sources (2026-10): llama.cpp server ``exceed_context_size_error`` /
+# "the request exceeds the available context size"; vLLM / OpenAI
+# "This model's maximum context length is N tokens"; Ollama "prompt too
+# long"; OpenAI ``context_length_exceeded``; Anthropic "prompt is too long".
+_CONTEXT_OVERFLOW_RE = re.compile(
+    r"exceed_context_size"
+    r"|exceeds? the available context"
+    r"|context_length_exceeded"
+    r"|maximum context length"
+    r"|prompt is too long"
+    r"|prompt too long"
+    r"|context window (?:is )?(?:exceeded|full)"
+    r"|exceeds? (?:the )?(?:model'?s )?context (?:length|window|size)",
+    re.IGNORECASE,
+)
+
+_MAX_MESSAGE_CHARS = 2000
+
+
+@dataclass(frozen=True)
+class AnthropicErrorResponse:
+    """What the ingress should send for a failed chain."""
+
+    status_code: int
+    error_type: str
+    message: str
+    headers: dict[str, str] = field(default_factory=dict)
+
+    def body(self) -> dict[str, Any]:
+        """Anthropic error envelope."""
+        return {
+            "type": "error",
+            "error": {"type": self.error_type, "message": self.message},
+        }
+
+
+def upstream_message(err: AdapterError) -> str:
+    """Best human-readable message for one upstream failure.
+
+    Pulls ``error.message`` out of Anthropic / OpenAI / llama.cpp JSON
+    bodies, falls back to the raw body text, then to the adapter's own
+    message. Always secret-redacted and length-capped.
+    """
+    body = getattr(err, "upstream_body", None)
+    text: str | None = None
+    if body:
+        text = _message_from_body(body)
+    if not text:
+        text = Exception.__str__(err)
+    text = redact(text.strip())
+    if len(text) > _MAX_MESSAGE_CHARS:
+        text = text[:_MAX_MESSAGE_CHARS] + "…"
+    return text
+
+
+def _message_from_body(body: str) -> str | None:
+    try:
+        parsed = json.loads(body)
+    except (json.JSONDecodeError, ValueError):
+        stripped = body.strip()
+        return stripped or None
+    if isinstance(parsed, dict):
+        err = parsed.get("error")
+        if isinstance(err, dict):
+            msg = err.get("message")
+            if isinstance(msg, str) and msg:
+                return msg
+        if isinstance(err, str) and err:
+            return err
+        for key in ("message", "detail"):
+            val = parsed.get(key)
+            if isinstance(val, str) and val:
+                return val
+    return body.strip() or None
+
+
+# "prompt + max_tokens > window": the *completion* budget is what is too big.
+# vLLM / OpenAI: "... However, you requested 33000 tokens (1000 in the
+# messages, 32000 in the completion)". Compacting the prompt cannot fix that,
+# so it must not be reported as "prompt is too long".
+_COMPLETION_BUDGET_RE = re.compile(
+    r"in the completion|max_tokens|max_completion_tokens|n_predict",
+    re.IGNORECASE,
+)
+
+
+def is_context_overflow(err: AdapterError) -> bool:
+    """True when the upstream said the *prompt* does not fit its context."""
+    if err.status_code is not None and err.status_code not in (400, 413, 422):
+        return False
+    haystack = " ".join(
+        part for part in (getattr(err, "upstream_body", None), Exception.__str__(err)) if part
+    )
+    if not _CONTEXT_OVERFLOW_RE.search(haystack):
+        return False
+    return not _COMPLETION_BUDGET_RE.search(haystack)
+
+
+def map_no_providers_error(exc: NoProvidersAvailableError) -> AnthropicErrorResponse:
+    """Decide status / type / message for a chain where every provider failed."""
+    errors = list(exc.errors)
+
+    for err in errors:
+        if is_context_overflow(err):
+            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)
+
+    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))
+        if status == 413:
+            return AnthropicErrorResponse(413, "request_too_large", upstream_message(terminal))
+        if status == 429:
+            headers: dict[str, str] = {}
+            retry_after = getattr(terminal, "retry_after", None)
+            if retry_after:
+                headers["retry-after"] = retry_after
+            return AnthropicErrorResponse(
+                429, "rate_limit_error", upstream_message(terminal), headers
+            )
+
+    return AnthropicErrorResponse(502, "api_error", redact(str(exc)))

coderouter/ingress/anthropic_routes.py

@@ -28,10 +28,21 @@ from collections.abc import AsyncIterator
 from typing import Any
 
 from fastapi import APIRouter, Header, HTTPException, Request
-from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.responses import JSONResponse, Response, StreamingResponse
 
 from coderouter.adapters.base import StreamTruncatedError
+from coderouter.guards.context_budget import ContextBudgetRejectError
 from coderouter.guards.tool_loop import ToolCountExceededError, ToolLoopBreakError
+from coderouter.ingress.anthropic_errors import (
+    AnthropicErrorResponse,
+    map_no_providers_error,
+)
+from coderouter.ingress.tool_search import (
+    REJECT_MESSAGE,
+    expand_tool_search,
+    resolve_action,
+    uses_tool_search,
+)
 from coderouter.logging import get_logger
 from coderouter.routing import (
     FallbackEngine,
@@ -115,6 +126,7 @@ async def _guard_stream(
     *,
     timeout_s: float,
     label: str,
+    deadline: float | None = None,
 ) -> AsyncIterator[str]:
     """M14: enforce an overall timeout + clean cancellation on an SSE stream.
 
@@ -135,7 +147,10 @@ async def _guard_stream(
     wrapper only has to deal with timeout / cancellation / normal completion.
     """
     try:
-        async with asyncio.timeout(timeout_s):
+        # v2.16.0: ``deadline`` (loop time) lets the caller share one overall
+        # ceiling with work it did before the stream started.
+        when = deadline if deadline is not None else asyncio.get_running_loop().time() + timeout_s
+        async with asyncio.timeout_at(when):
             async for frame in source:
                 yield frame
     except TimeoutError:
@@ -177,7 +192,7 @@ async def messages(
     x_coderouter_mode: str | None = Header(default=None, alias=_MODE_HEADER),
     anthropic_version: str | None = Header(default=None, alias=_ANTHROPIC_VERSION_HEADER),
     anthropic_beta: str | None = Header(default=None, alias=_ANTHROPIC_BETA_HEADER),
-) -> StreamingResponse | dict[str, Any]:
+) -> Response | dict[str, Any]:
     """Anthropic Messages API endpoint.
 
     Validates the body into :class:`AnthropicRequest`, resolves the
@@ -250,10 +265,33 @@ async def messages(
                 detail=(f"unknown profile {anth_req.profile!r}. available: {available}"),
             ) from exc
 
+    # v2.16.0: Claude Code tool search (``defer_loading`` tools plus a
+    # server-side ``tool_search_tool_*``) only works on api.anthropic.com.
+    # See ``coderouter.ingress.tool_search``.
+    if uses_tool_search(anth_req):
+        ts_action = resolve_action(config, anth_req.profile)
+        logger.info(
+            "tool-search-request",
+            extra={"action": ts_action, "profile": anth_req.profile or config.default_profile},
+        )
+        if ts_action == "reject":
+            return _anthropic_error_response(
+                AnthropicErrorResponse(400, "invalid_request_error", REJECT_MESSAGE)
+            )
+        if ts_action == "expand":
+            anth_req = expand_tool_search(anth_req)
+
     # v2.0-F (L1): run context budget guard before dispatch so the
     # response header can be set for both streaming and non-streaming.
     # The engine's internal guard re-check is a cheap no-op.
-    anth_req, ctx_budget_status = engine.apply_context_budget(anth_req)
+    try:
+        anth_req, ctx_budget_status = engine.apply_context_budget(anth_req)
+    except ContextBudgetRejectError as exc:
+        # 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))
+        )
 
     if anth_req.stream:
         stream_headers: dict[str, str] = {
@@ -286,9 +324,84 @@ async def messages(
         # disconnect cleanup so a wedged upstream cannot pin the client
         # (or the upstream socket) open forever.
         timeout_s = _resolve_stream_timeout_s(engine, anth_req.profile)
+
+        # v2.16.0: pull the engine's first event *before* committing the
+        # HTTP response. A chain that fails before producing anything (every
+        # provider refused, an upstream said the prompt is too long, a 429)
+        # then gets a real HTTP status and an Anthropic error body — the
+        # same thing api.anthropic.com does — instead of ``200`` plus an
+        # in-stream ``error`` event. Clients key retries and reactive
+        # compaction off that status. Once the first event exists, nothing
+        # changes: the stream is committed exactly as before.
+        source = engine.stream_anthropic(anth_req)
+        first_event: AnthropicStreamEvent | None = None
+        pending_exc: BaseException | None = None
+        # One deadline for the whole stream, prefetch included, so the M14
+        # ceiling stays an *overall* ceiling (review fix: two independent
+        # ``timeout_s`` windows allowed ~2x).
+        deadline = asyncio.get_running_loop().time() + timeout_s
+        # Starlette cancels a StreamingResponse body when the client leaves,
+        # but not an endpoint that is still awaiting. The prefetch runs in
+        # the endpoint, so watch for the disconnect ourselves and cancel the
+        # wait — otherwise a user pressing Esc during a long local prefill
+        # would leave the upstream (and its llama.cpp slot) busy until the
+        # first token arrived.
+        watcher = _DisconnectWatcher(request)
+        watcher.start()
+        try:
+            async with asyncio.timeout_at(deadline) as prefetch_scope:
+                first_event = await anext(source)
+        except StopAsyncIteration:
+            first_event = None
+        except NoProvidersAvailableError as exc:
+            await _aclose_quietly(source)
+            return _anthropic_error_response(map_no_providers_error(exc))
+        except ContextBudgetRejectError as exc:
+            # The engine re-runs the budget guard when the prepared dispatch
+            # is not reused (input-filter plugins, tool-loop inject, model
+            # swap) — same answer as the pre-dispatch check above.
+            await _aclose_quietly(source)
+            return _anthropic_error_response(
+                AnthropicErrorResponse(400, "invalid_request_error", str(exc))
+            )
+        except (ToolLoopBreakError, ToolCountExceededError, MidStreamError) as exc:
+            # Policy errors and mid-stream failures keep their existing
+            # in-stream framing; the iterator below re-raises them.
+            pending_exc = exc
+        except TimeoutError:
+            await _aclose_quietly(source)
+            if not prefetch_scope.expired():
+                # A TimeoutError raised *inside* the engine is not our
+                # ceiling — do not dress it up as one.
+                raise
+            return _anthropic_error_response(
+                AnthropicErrorResponse(
+                    504, "timeout_error", f"no upstream event within {timeout_s:.0f}s"
+                )
+            )
+        except asyncio.CancelledError:
+            await _aclose_quietly(source)
+            if watcher.fired:
+                logger.info("sse-client-disconnect", extra={"label": "anthropic-prefetch"})
+                watcher.uncancel()
+                return Response(status_code=499)
+            raise
+        except BaseException:
+            await _aclose_quietly(source)
+            raise
+        finally:
+            await watcher.stop()
+
         guarded = _guard_stream(
-            _anthropic_sse_iterator(engine, anth_req),
+            _anthropic_sse_iterator(
+                engine,
+                anth_req,
+                source=source,
+                first_event=first_event,
+                pending_exc=pending_exc,
+            ),
             timeout_s=timeout_s,
+            deadline=deadline,
             label="anthropic",
         )
         return StreamingResponse(
@@ -299,8 +412,16 @@ async def messages(
 
     try:
         anth_resp = await engine.generate_anthropic(anth_req)
+    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))
+        )
     except NoProvidersAvailableError as exc:
-        raise HTTPException(status_code=502, detail=str(exc)) from exc
+        # v2.16.0: Anthropic-shaped error with the upstream's own wording
+        # and a status that reflects it (400 / 413 / 429 / 502). See
+        # ``coderouter.ingress.anthropic_errors``.
+        return _anthropic_error_response(map_no_providers_error(exc))
     except ToolLoopBreakError as exc:
         # v1.9-E (L3): the ``break`` action short-circuits the request
         # before any provider is called. Surface as a structured 400 so
@@ -457,8 +578,81 @@ async def count_tokens_route(
     return {"input_tokens": input_tokens}
 
 
+class _DisconnectWatcher:
+    """Cancel the current task when the HTTP client disconnects.
+
+    Used only around the streaming prefetch (see ``messages``). Polls
+    ``request.is_disconnected()`` — a non-blocking check — every
+    ``interval`` seconds from a side task and, on disconnect, cancels the
+    task that created the watcher. ``fired`` tells the caller that a
+    ``CancelledError`` came from here (and ``uncancel`` clears it), as
+    opposed to a real cancellation from the server.
+    """
+
+    def __init__(self, request: Request, interval: float = 0.25) -> None:
+        self._request = request
+        self._interval = interval
+        self._owner = asyncio.current_task()
+        self._task: asyncio.Task[None] | None = None
+        self.fired = False
+
+    def start(self) -> None:
+        if self._owner is not None:
+            self._task = asyncio.create_task(self._run())
+
+    async def _run(self) -> None:
+        while True:
+            await asyncio.sleep(self._interval)
+            try:
+                gone = await self._request.is_disconnected()
+            except Exception:
+                return
+            if gone:
+                self.fired = True
+                if self._owner is not None:
+                    self._owner.cancel()
+                return
+
+    def uncancel(self) -> None:
+        if self._owner is not None:
+            self._owner.uncancel()
+
+    async def stop(self) -> None:
+        if self._task is not None and not self._task.done():
+            self._task.cancel()
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await self._task
+
+
+def _anthropic_error_response(mapped: AnthropicErrorResponse) -> JSONResponse:
+    """Render a mapped failure, carrying the v2.15.0 fallback headers."""
+    headers = dict(mapped.headers)
+    trace = current_fallback_trace()
+    if trace is not None:
+        headers.update(trace.header_values())
+    logger.info(
+        "anthropic-error-response",
+        extra={"status": mapped.status_code, "error_type": mapped.error_type},
+    )
+    return JSONResponse(
+        content=mapped.body(), status_code=mapped.status_code, headers=headers or None
+    )
+
+
+async def _aclose_quietly(source: AsyncIterator[Any]) -> None:
+    aclose = getattr(source, "aclose", None)
+    if aclose is not None:
+        with contextlib.suppress(Exception):
+            await aclose()
+
+
 async def _anthropic_sse_iterator(
-    engine: FallbackEngine, anth_req: AnthropicRequest
+    engine: FallbackEngine,
+    anth_req: AnthropicRequest,
+    *,
+    source: AsyncIterator[AnthropicStreamEvent] | None = None,
+    first_event: AnthropicStreamEvent | None = None,
+    pending_exc: BaseException | None = None,
 ) -> AsyncIterator[str]:
     """Serialize engine.stream_anthropic() onto the Anthropic SSE wire.
 
@@ -466,9 +660,20 @@ async def _anthropic_sse_iterator(
     Anthropic spec (distinct from OpenAI's `data:`-only format).
     Errors map to in-stream `event: error` events — we never switch an
     in-flight HTTP response to a 5xx once headers have shipped.
+
+    v2.16.0: the route may have already pulled the first event (to answer
+    pre-content failures with a real HTTP status). It then passes the
+    started ``source``, that ``first_event``, and any exception the pull
+    raised (``pending_exc``), which is re-raised here so its existing
+    in-stream framing below applies unchanged.
     """
+    events = source if source is not None else engine.stream_anthropic(anth_req)
     try:
-        async for ev in engine.stream_anthropic(anth_req):
+        if pending_exc is not None:
+            raise pending_exc
+        if first_event is not None:
+            yield _format_anthropic_sse(first_event)
+        async for ev in events:
             yield _format_anthropic_sse(ev)
     except NoProvidersAvailableError as exc:
         # No provider produced even the first event — surface as overloaded.

coderouter/ingress/tool_search.py

@@ -0,0 +1,100 @@
+"""Claude Code tool search on non-Anthropic upstreams (v2.16.0).
+
+Claude Code 2.1.304 turned tool search on by default behind a custom
+``ANTHROPIC_BASE_URL``. A tool-search request carries:
+
+- a server-side search tool, ``{"type": "tool_search_tool_regex_...",
+  "name": "tool_search_tool_regex"}`` (or the ``bm25`` variant), which only
+  api.anthropic.com executes, and
+- ordinary tools marked ``"defer_loading": true`` that the API keeps out
+  of the model's context until a search surfaces them.
+
+A local model behind CodeRouter cannot run the search: before v2.16.0 the
+search tool reached it as an ordinary function it could "call", and every
+deferred tool was loaded anyway. Claude Code 2.1.305 retries a request
+without tool search when the gateway answers 400 / 422, so rejecting is the
+cheapest correct answer. Which action applies is the profile's
+``deferred_tools_action`` (see ``FallbackChain``).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+from urllib.parse import urlparse
+
+if TYPE_CHECKING:
+    from coderouter.config.schemas import CodeRouterConfig
+    from coderouter.translation import AnthropicRequest
+
+TOOL_SEARCH_TYPE_PREFIX = "tool_search_tool"
+
+#: Message for the 400. Mentions both trigger words so a client (or a human
+#: reading the log) can tell why tool search was refused.
+REJECT_MESSAGE = (
+    "tool search is not supported by this gateway's upstreams: remove the "
+    "tool_search_tool and defer_loading (CodeRouter deferred_tools_action)"
+)
+
+Action = Literal["reject", "expand", "passthrough"]
+
+
+def _tool_dict(tool: Any) -> dict[str, Any]:
+    if hasattr(tool, "model_dump"):
+        dumped: dict[str, Any] = tool.model_dump()
+        return dumped
+    return dict(tool)
+
+
+def _is_search_tool(t: dict[str, Any]) -> bool:
+    kind = t.get("type")
+    return isinstance(kind, str) and kind.startswith(TOOL_SEARCH_TYPE_PREFIX)
+
+
+def uses_tool_search(req: AnthropicRequest) -> bool:
+    """True when the request carries a search tool or a deferred tool."""
+    for tool in req.tools or []:
+        t = _tool_dict(tool)
+        if _is_search_tool(t) or t.get("defer_loading") is True:
+            return True
+    return False
+
+
+def _is_anthropic_api(provider: Any) -> bool:
+    if getattr(provider, "kind", None) != "anthropic":
+        return False
+    host = urlparse(str(getattr(provider, "base_url", ""))).hostname or ""
+    return host == "anthropic.com" or host.endswith(".anthropic.com")
+
+
+def resolve_action(config: CodeRouterConfig, profile_name: str | None) -> Action:
+    """Resolve the profile's ``deferred_tools_action`` (``auto`` → concrete)."""
+    try:
+        profile = config.profile_by_name(profile_name or config.default_profile)
+    except (KeyError, ValueError):
+        return "reject"
+    action = getattr(profile, "deferred_tools_action", "auto")
+    if action == "reject":
+        return "reject"
+    if action == "expand":
+        return "expand"
+    if action == "passthrough":
+        return "passthrough"
+    providers = {p.name: p for p in config.providers}
+    chain = [providers.get(name) for name in profile.providers]
+    if chain and all(p is not None and _is_anthropic_api(p) for p in chain):
+        return "passthrough"
+    return "reject"
+
+
+def expand_tool_search(req: AnthropicRequest) -> AnthropicRequest:
+    """Drop the search tool(s) and every ``defer_loading`` flag."""
+    from coderouter.translation.anthropic import AnthropicTool
+
+    kept: list[AnthropicTool] = []
+    for tool in req.tools or []:
+        t = _tool_dict(tool)
+        if _is_search_tool(t):
+            continue
+        t.pop("defer_loading", None)
+        kept.append(AnthropicTool.model_validate(t))
+    return req.model_copy(update={"tools": kept or None})

coderouter/routing/fallback.py

@@ -436,6 +436,16 @@ def _apply_context_budget_guard(
     if profile.context_budget_action == "warn" or not estimate.over_trim_threshold:
         return request, "warning"
 
+    # v2.16.0: reject → let the client compact instead of trimming here.
+    if profile.context_budget_action == "reject":
+        from coderouter.guards.context_budget import ContextBudgetRejectError
+
+        raise ContextBudgetRejectError(
+            estimated_tokens=estimate.estimated_tokens,
+            max_context_tokens=estimate.max_context_tokens,
+            profile=profile.name,
+        )
+
     # Over trim threshold + action is trim → trim messages
     trimmed_request, trim_result = trim_to_budget(
         request,

coderouter/vscode_init.py

@@ -112,6 +112,37 @@ _MANAGED_ENV_KEYS: tuple[str, ...] = (
     "CODEROUTER_MODE",
 )
 
+# v2.16.0: Claude Code settings for a gateway that is not api.anthropic.com.
+# Written by default (``--no-claude-code-env`` opts out):
+#
+# * ``ENABLE_TOOL_SEARCH=false`` — 2.1.304 turned tool search on behind a
+#   custom ANTHROPIC_BASE_URL. Only api.anthropic.com runs the search; the
+#   gateway would answer 400 on every session's first request and Claude
+#   Code would retry without it. Saying so up front skips that round trip.
+# * ``CLAUDE_CODE_AUTO_MODE_SERVER=0`` — on gateways auto mode defaults to
+#   the server-side permission classifier, which a local backend does not
+#   provide; ``0`` keeps the classifier client-side (its requests then go
+#   through CodeRouter like any other request).
+# * ``CLAUDE_CODE_MAX_CONTEXT_TOKENS`` — only when ``--max-context-tokens``
+#   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_ENV_KEYS: tuple[str, ...] = (
+    "ENABLE_TOOL_SEARCH",
+    "CLAUDE_CODE_AUTO_MODE_SERVER",
+    "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"}
+    if max_context_tokens is not None:
+        if max_context_tokens <= 0:
+            raise ValueError("max_context_tokens must be positive")
+        env["CLAUDE_CODE_MAX_CONTEXT_TOKENS"] = str(max_context_tokens)
+    return env
+
 
 @dataclass(frozen=True)
 class FileOutcome:
@@ -155,6 +186,7 @@ def run_vscode_init(
     with_envrc: bool = False,
     dry_run: bool = False,
     force: bool = False,
+    extra_env: dict[str, str] | None = None,
 ) -> VSCodeInitResult:
     """Scaffold VSCode workspace settings for CodeRouter.
 
@@ -182,6 +214,9 @@ def run_vscode_init(
         When true, existing conflicting values are overwritten. Without
         this flag, a conflict is reported with a diff and the file is
         left untouched.
+    extra_env:
+        v2.16.0: additional variables to write next to the base ones
+        (the CLI passes :func:`claude_code_env`). Same conflict rules.
 
     Raises
     ------
@@ -205,6 +240,7 @@ def run_vscode_init(
             profile=profile,
             force=force,
             dry_run=dry_run,
+            extra_env=extra_env,
         )
     )
 
@@ -217,6 +253,7 @@ def run_vscode_init(
                 profile=profile,
                 force=force,
                 dry_run=dry_run,
+                extra_env=extra_env,
             )
         )
 
@@ -235,6 +272,7 @@ def _apply_settings_json(
     profile: str | None,
     force: bool,
     dry_run: bool,
+    extra_env: dict[str, str] | None = None,
 ) -> FileOutcome:
     desired_env: dict[str, str] = {
         "ANTHROPIC_BASE_URL": base_url,
@@ -242,6 +280,8 @@ def _apply_settings_json(
     }
     if profile:
         desired_env["CODEROUTER_MODE"] = profile
+    if extra_env:
+        desired_env.update(extra_env)
 
     old_text = ""
     if path.exists():
@@ -401,6 +441,7 @@ def _apply_envrc(
     profile: str | None,
     force: bool,
     dry_run: bool,
+    extra_env: dict[str, str] | None = None,
 ) -> FileOutcome:
     """Write (or refresh) the managed block in ``.envrc``.
 
@@ -413,7 +454,7 @@ def _apply_envrc(
       which now *appends* the block rather than replacing the file. The
       operator's lines survive either way.
     """
-    block = _render_envrc_block(base_url=base_url, profile=profile)
+    block = _render_envrc_block(base_url=base_url, profile=profile, extra_env=extra_env)
 
     old_text = ""
     if path.exists():
@@ -467,7 +508,7 @@ def _apply_envrc(
                 before.rstrip("\n") + ("\n\n" if before.strip() else "")
             ) + block + ("\n\n" + after.lstrip("\n") if after.strip() else "\n")
 
-        conflicts = _unmanaged_conflicts(outside)
+        conflicts = _unmanaged_conflicts(outside, extra_keys=tuple(extra_env or ()))
         if conflicts:
             # direnv applies exports in order, so a duplicate outside the
             # fence would silently win or lose depending on placement.
@@ -568,7 +609,9 @@ def _split_managed_block(text: str) -> tuple[str, str] | None:
     return text[:start], text[end + len(_ENVRC_END) :].lstrip("\n")
 
 
-def _render_envrc_block(*, base_url: str, profile: str | None) -> str:
+def _render_envrc_block(
+    *, base_url: str, profile: str | None, extra_env: dict[str, str] | None = None
+) -> str:
     """The fenced block CodeRouter owns, markers included."""
     lines = [
         _ENVRC_BEGIN,
@@ -579,18 +622,25 @@ def _render_envrc_block(*, base_url: str, profile: str | None) -> str:
     ]
     if profile:
         lines.append(f'export CODEROUTER_MODE="{profile}"')
+    for key, value in (extra_env or {}).items():
+        lines.append(f'export {key}="{value}"')
     lines.append(_ENVRC_END)
     return "\n".join(lines)
 
 
-def _unmanaged_conflicts(outside_text: str) -> list[str]:
-    """Managed variables the operator exports outside our block."""
+def _unmanaged_conflicts(outside_text: str, *, extra_keys: tuple[str, ...] = ()) -> list[str]:
+    """Managed variables the operator exports outside our block.
+
+    v2.16.0: ``extra_keys`` (the Claude Code variables this run writes) are
+    checked too — but only when this run writes them, so an operator who
+    passed ``--no-claude-code-env`` can keep their own exports.
+    """
     found: list[str] = []
     for line in outside_text.splitlines():
         stripped = line.strip()
         if stripped.startswith("#"):
             continue
-        for var in _MANAGED_ENVRC_VARS:
+        for var in (*_MANAGED_ENVRC_VARS, *extra_keys):
             if stripped.startswith((f"export {var}=", f"{var}=")) and var not in found:
                 found.append(var)
     return found

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: coderouter-cli
-Version: 2.15.1
+Version: 2.16.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.15.1.dist-info → coderouter_cli-2.16.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
 coderouter/__init__.py,sha256=ghdjPrLtnRzY8fyQ4CJZI1UJKADyNTLtA3G7se8H7Ns,696
 coderouter/__main__.py,sha256=-LCgxJnvgUV240HjQKv7ly-mn2NuKHpC4nCpvTHjeSU,130
-coderouter/cli.py,sha256=Nbx1ur_HnssFtuM48yPELwhY40veVNnTAfK7OVF2uVc,42400
+coderouter/cli.py,sha256=-QPJ2wTJIpa4TvIFObNaV4hyv_OeDtoLebc692ZWYQA,44775
 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/env_security.py,sha256=FEBZnXfJ0xE39kmMMn39zk0W_DRRnmcB_REmP9f4xWo,14796
 coderouter/errors.py,sha256=Xmq67lheyw8iv3Ox39jh2c4tvNI5RcUR4QkoxVDN6l4,1130
 coderouter/gguf_introspect.py,sha256=Scu0JjUfLHj7T7TL0HQIm1AZcGYrXsjkaMMSN9HkTro,16121
@@ -20,23 +21,23 @@ 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=ZEROtETsHjyBkLzZKPnF-zsBpLJx4ph0vmgyty6kNYQ,33433
+coderouter/vscode_init.py,sha256=rs3S0FOuPFZhhDvE547Zonhj98al66Jc8G1wvBnFq40,35915
 coderouter/adapters/__init__.py,sha256=7dIDSZ-FE_0iSqLSDc_lK1idRdLTKcM2hP9tCJipgPI,463
-coderouter/adapters/anthropic_native.py,sha256=JxOaU-ymU1K3Tnvhufi_li1qChW69XtUszKJ2DdFlDQ,29936
-coderouter/adapters/base.py,sha256=qW0QMbO08Dw2ZDruL9rCvCxA0FXhKnSodlK9g-8Y350,13535
-coderouter/adapters/openai_compat.py,sha256=Kl5AACqOHxTPUn8c-4IFu4ug9_E3loLKTm2yYmvalho,23872
+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/registry.py,sha256=XNc1wmFv_oZlqKS0rA693TRDdbq1sZ-OIcofXOVOtq0,3680
 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=0NM5KtVGsjH8BPBeBfgM-ItfOYQKhyI-P_3EbJjIaps,146436
+coderouter/config/schemas.py,sha256=pabFnhY070rWhzl9JF9jqyfRGhrD4VSwIC-xWsHGskc,148608
 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
 coderouter/guards/_fingerprint.py,sha256=qsgNzIq9jv3FHrKL39nGJARp0cMenpN_QmWoJu87vU4,4835
 coderouter/guards/backend_health.py,sha256=GLUVQ5BhU6i8Cxz_FrgIMs5AZ-YSKAW8veFWgvn9GFI,12565
-coderouter/guards/context_budget.py,sha256=gw3MkiHDjpLmQTlTdJT6gRAxYEnoU0xmwSvPZk_miOQ,23059
+coderouter/guards/context_budget.py,sha256=zbplo_1G54kHITdr4kkgUxjQX20Y8MN2Z4XdxETAGwI,23834
 coderouter/guards/continuous_probe.py,sha256=WIfS-apVMWXGv7bPBxxkJssePa95I4fT0mi4PNqK5iE,12181
 coderouter/guards/drift_actions.py,sha256=A6pY5CR480Ct5rCVyjlBvjPFVc93eu_r5qcUpK9mWKc,3602
 coderouter/guards/drift_detection.py,sha256=lW45EZDGRleDUTstw_CHlfUiwLUrlDHX8g7ncuOYNEw,13962
@@ -45,12 +46,14 @@ 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_routes.py,sha256=wlOb7ChWHMvuERR0lj8TF4MfPis2ZKegceoak4eREes,31131
+coderouter/ingress/anthropic_errors.py,sha256=SYmcqHeQWuiAsgBjquOemmv_KIr23WTyWtjohuzLOLg,7352
+coderouter/ingress/anthropic_routes.py,sha256=O2ejNl8SdXaMt-EArgsPa47NHxzvIRtVOeHMr5kJApM,39963
 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/tool_search.py,sha256=JYnJ8SUqPmBfZmsl41TdBQNnux0mwbidKdsr5qn15Hk,3753
 coderouter/ingress/ui_auth.py,sha256=uCWB5IaMQRNFYdY39FQ5DDVhsoRQJoqimZNSAu_QK_Q,3742
 coderouter/metrics/__init__.py,sha256=7Es351DPS7yLM0yVF_F0eesmiD83n7Zzhie44chht38,1465
 coderouter/metrics/collector.py,sha256=-744UrUS6_aEY7hbwuvoX0Nn7wuOsQ57IIVr52nPe2M,63268
@@ -64,7 +67,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=Hzy-_2_zK64GUqGGcOZP-RgOq8wZ4PdBpVu4OBTx8dM,172282
+coderouter/routing/fallback.py,sha256=0tN6LPFijZ5cZ-Fc2VpipIVvFHpgCgNCx1COXfenxgs,172687
 coderouter/routing/fallback_trace.py,sha256=0BysXY1CZqSvVTuePbgmHbu1AKkHLMX7hsuG6rKlDdE,19787
 coderouter/state/__init__.py,sha256=XoGcPmmBQSiZWML2S0juSveQ78xfhtdeCliNnVyzu7E,1088
 coderouter/state/audit_log.py,sha256=CEFNJht2WZ8mqesI8CzeuL63NfzFzAZ7wF88auyl6l0,11444
@@ -77,8 +80,8 @@ coderouter/translation/anthropic.py,sha256=ZQQGS9itN_3o7IKD68lKr5gR_Kem32Jsd7OcG
 coderouter/translation/convert.py,sha256=VrstDAMsUpcQ1VgMTn_-ETp1OjGX8v0ZGhCkcd4icyU,53037
 coderouter/translation/tool_repair.py,sha256=1p8rmdyyscGX2g0DDOYitMnLv-nKfR1SLuLaRB4z7GM,64244
 coderouter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-coderouter_cli-2.15.1.dist-info/METADATA,sha256=oJXnZHAWbbgbFy7wWTJW4LxBTHkA0NSDMWubhzUqo_0,18221
-coderouter_cli-2.15.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-coderouter_cli-2.15.1.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
-coderouter_cli-2.15.1.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
-coderouter_cli-2.15.1.dist-info/RECORD,,
+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,,