pcode 0.1.0__py3-none-any.whl

pcode/meridian.py

@@ -0,0 +1,233 @@
+"""Anthropic-compatible Meridian transport with client-owned tool execution."""
+
+import hashlib
+import os
+from dataclasses import replace
+from functools import cached_property
+
+import httpx2
+from anthropic import AsyncAnthropic
+from pydantic_ai import RunContext
+from pydantic_ai.capabilities import AbstractCapability
+from pydantic_ai.messages import ModelRequest, UserPromptPart
+from pydantic_ai.models import ModelRequestContext
+from pydantic_ai.models.anthropic import AnthropicModel
+from pydantic_ai.providers.anthropic import AnthropicProvider
+
+DEFAULT_BASE_URL = "http://127.0.0.1:3456"
+
+
+def meridian_base_url() -> str:
+    value = os.environ.get("PCODE_MERIDIAN_BASE_URL", "").strip() or DEFAULT_BASE_URL
+    try:
+        url = httpx2.URL(value)
+        if url.scheme not in {"http", "https"} or not url.host or url.userinfo:
+            raise ValueError
+        if url.query or url.fragment:
+            raise ValueError
+    except (ValueError, httpx2.InvalidURL):
+        raise ValueError(
+            "PCODE_MERIDIAN_BASE_URL must be an HTTP(S) URL without credentials, query, or fragment"
+        ) from None
+    return value.rstrip("/")
+
+
+def _failed_url(error: BaseException) -> str | None:
+    """URL of the request an SDK error came from, found along its cause chain."""
+    seen = set()
+    while error is not None and id(error) not in seen and len(seen) < 16:
+        seen.add(id(error))
+        try:
+            # httpx raises RuntimeError, not AttributeError, for an unset request.
+            url = getattr(getattr(error, "request", None), "url", None)
+        except Exception:
+            url = None
+        if url is not None:
+            return str(url)
+        error = error.__cause__ or error.__context__
+    return None
+
+
+def failure_hint(error: BaseException) -> str | None:
+    """What to do about a failed Meridian request, or None for any other provider."""
+    from pcode.diagnostics import error_details, transport_types
+    from pcode.meridian_process import managed_base_url
+
+    url = _failed_url(error)
+    if url is None:
+        return None
+    managed = managed_base_url()
+    try:
+        external = meridian_base_url()
+    except ValueError:
+        external = None
+    base = next((b for b in (managed, external) if b and url.startswith(b + "/")), None)
+    if base is None:
+        return None
+    detail = error_details(error)
+    while detail and "status" not in detail:
+        detail = detail.get("cause", detail.get("context", {}))
+    if detail.get("status") == 401:
+        if "api key" in detail.get("provider_message", "").lower():
+            return f"Meridian at {base} rejected pcode's key. Check PCODE_MERIDIAN_API_KEY."
+        return "Meridian could not use your Claude login. Run /login meridian, then retry."
+    if transport_types(error) & {"APIConnectionError", "ConnectError"}:
+        if base == managed:
+            return "pcode's Meridian stopped and is being restarted. Retry in a moment."
+        return (
+            f"Meridian is not answering at {base}. Start it with `meridian`, or restart "
+            "pcode with meridian_managed set to auto or on so it runs its own."
+        )
+    return None
+
+
+def thinking_passthrough(base_url: str, api_key: str | None) -> bool | None:
+    """Whether the proxy forwards readable thinking; None when it cannot say.
+
+    A read-only settings lookup with a short timeout: this never changes a
+    shared proxy's configuration.
+    """
+    headers = {"x-api-key": api_key} if api_key else {}
+    try:
+        response = httpx2.get(
+            base_url.rstrip("/") + "/settings/api/features",
+            headers=headers,
+            timeout=0.5,
+            trust_env=False,
+        )
+        value = response.json().get("passthrough", {}).get("thinkingPassthrough")
+    except (httpx2.HTTPError, ValueError, AttributeError):
+        return None
+    return value if isinstance(value, bool) else None
+
+
+class MeridianProvider(AnthropicProvider):
+    @property
+    def name(self) -> str:
+        return "meridian"
+
+    def __init__(self) -> None:
+        from pcode.meridian_process import managed_endpoint
+
+        endpoint = managed_endpoint()
+        base_url = endpoint[0] if endpoint else meridian_base_url()
+        api_key = (
+            endpoint[1]
+            if endpoint
+            else os.environ.get("PCODE_MERIDIAN_API_KEY", "").strip() or "meridian-local"
+        )
+
+        # Never inherit upstream Anthropic credentials or global HTTP proxies.
+        def make_client():
+            return httpx2.AsyncClient(trust_env=False, timeout=600)
+
+        client = make_client()
+        super().__init__(
+            anthropic_client=AsyncAnthropic(
+                base_url=base_url,
+                api_key=api_key,
+                auth_token="",
+                http_client=client,
+                default_headers={"x-meridian-agent": "passthrough"},
+                # The SDK default of 2 would retry 408/409/429/5xx and connection
+                # errors silently, outside the runtime's visible retry budget and
+                # against the transient-error policy in `diagnostics.py`. The
+                # runtime owns transport retries here, as it does for API keys.
+                max_retries=0,
+            )
+        )
+        # Empty token prevents environment lookup during construction; None then
+        # suppresses the SDK's otherwise empty Bearer header on requests.
+        self.client.auth_token = None
+        self._own_http_client = client
+        self._http_client_factory = make_client
+
+
+class MeridianModel(AnthropicModel):
+    @cached_property
+    def profile(self):
+        # Meridian answers any Anthropic server tool (`web_search_*`, `web_fetch_*`)
+        # with a 400: the Claude Max path cannot emit server_tool_use blocks. Drop
+        # them from the profile so the web capabilities fall back to local tools.
+        #
+        # Tool search fails quietly rather than with a 400. Meridian re-registers
+        # client tools with the Agent SDK, which drops `defer_loading` and
+        # `tool_reference`: the model sees every deferred schema, but no search
+        # result it could produce counts as discovery, so Pydantic AI refuses each
+        # deferred call as "not available yet". Use the local `search_tools` and
+        # no wire deferral: hidden tools are withheld, then sent in full once found.
+        from pydantic_ai.native_tools import WebFetchTool, WebSearchTool
+        from pydantic_ai.native_tools._tool_search import ToolSearchTool
+        from pydantic_ai.profiles import SUPPORTED_NATIVE_TOOLS, merge_profile
+        from pydantic_ai.profiles.anthropic import AnthropicModelProfile
+
+        profile = super().profile
+        native = profile.get("supported_native_tools", SUPPORTED_NATIVE_TOOLS)
+        unsupported = {WebSearchTool, WebFetchTool, ToolSearchTool}
+        return merge_profile(
+            profile,
+            AnthropicModelProfile(
+                supported_native_tools=native - unsupported,
+                tool_deferral_mode=None,
+                tool_addition_mode=None,
+            ),
+        )
+
+
+def meridian_model(model: str) -> AnthropicModel:
+    name = model.removeprefix("meridian:")
+    if not name.strip():
+        raise ValueError("Meridian requires a model ID: meridian:<model-id>")
+    return MeridianModel(name, provider=MeridianProvider())
+
+
+def compaction_summary(messages) -> str | None:
+    """The summary text when compaction has replaced the start of `messages`."""
+    from pcode.compaction import SUMMARY_PREFIX
+
+    first = messages[0] if messages else None
+    if not isinstance(first, ModelRequest):
+        return None
+    for part in first.parts:
+        if isinstance(part, UserPromptPart) and isinstance(part.content, str):
+            if part.content.startswith(SUMMARY_PREFIX):
+                return part.content
+    return None
+
+
+def session_identity(conversation_id: str, messages) -> str:
+    """Meridian session for this history, which changes each time it is compacted.
+
+    Meridian classifies a compacted history whose recent messages still match as a
+    continuation and resumes the uncompacted transcript, so the summary never
+    reaches the model. A session keyed on the summary starts fresh instead, once
+    per compaction; an uncompacted history keeps the plain conversation ID.
+    """
+    summary = compaction_summary(messages)
+    if summary is None:
+        return conversation_id
+    return f"{conversation_id}.{hashlib.sha256(summary.encode()).hexdigest()[:16]}"
+
+
+class MeridianSessionIdentity(AbstractCapability):
+    """Bind requests, not shared clients, to the current conversation.
+
+    Harness children inherit the model but get fresh Pydantic conversation IDs.
+    This also preserves identity across saved-session resume and model switches,
+    and moves to a new session after compaction (see `session_identity`).
+    """
+
+    async def before_model_request(
+        self, ctx: RunContext, request_context: ModelRequestContext
+    ) -> ModelRequestContext:
+        if request_context.model.system != "meridian":
+            return request_context
+        settings = dict(request_context.model_settings or {})
+        headers = dict(settings.get("extra_headers") or {})
+        # Headers are case-insensitive; never leave an alternate-cased stale ID.
+        headers = {k: v for k, v in headers.items() if k.lower() != "x-litellm-session-id"}
+        headers["x-litellm-session-id"] = session_identity(
+            ctx.conversation_id, request_context.messages
+        )
+        settings["extra_headers"] = headers
+        return replace(request_context, model_settings=settings)

pcode/meridian_process.py

@@ -0,0 +1,337 @@
+"""Process-owned Meridian instances (not a shared daemon)."""
+
+import atexit
+import json
+import os
+import re
+import secrets
+import shutil
+import socket
+import subprocess
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+import httpx2
+
+from pcode.preferences import load_preferences
+
+# Oldest release whose configuration contract this module relies on
+# (`sdk-features.json`, `/settings/api/features`, the MERIDIAN_* variables below).
+# Newer releases start as long as they pass the same readiness checks.
+MINIMUM_VERSION = "1.71.1"
+MODES = ("auto", "on", "off")
+WATCH_INTERVAL_SECONDS = 1.0
+# A crash loop is not worth chasing: stop after this many restarts in the window.
+MAX_RESTARTS = 3
+RESTART_WINDOW_SECONDS = 300.0
+_lock = threading.Lock()
+_instance = None
+
+
+def version_tuple(text: str | None) -> tuple[int, ...] | None:
+    match = re.search(r"\d+(?:\.\d+)+", text or "")
+    return tuple(int(part) for part in match.group().split(".")) if match else None
+
+
+def supported(version: str | None) -> bool:
+    found = version_tuple(version)
+    return found is not None and found >= version_tuple(MINIMUM_VERSION)
+
+
+def meridian_config_dir() -> Path:
+    """The user's own Meridian configuration (profiles, settings)."""
+    return Path(os.environ.get("MERIDIAN_CONFIG_DIR") or Path.home() / ".config" / "meridian")
+
+
+def meridian_profiles() -> list[dict]:
+    """Account profiles from the user's `profiles.json`; tokens are never read out."""
+    try:
+        data = json.loads((meridian_config_dir() / "profiles.json").read_text())
+    except (OSError, ValueError):
+        return []
+    if not isinstance(data, list):
+        return []
+    return [p for p in data if isinstance(p, dict) and isinstance(p.get("id"), str)]
+
+
+def profile_dir(profile: dict) -> str:
+    """The Claude config directory whose login a profile uses."""
+    configured = profile.get("claudeConfigDir")
+    if isinstance(configured, str) and configured:
+        return configured
+    return str(meridian_config_dir() / "profiles" / profile["id"])
+
+
+def default_profile() -> dict | None:
+    """The profile a managed instance uses: the saved active one, else the first."""
+    profiles = meridian_profiles()
+    try:
+        settings = json.loads((meridian_config_dir() / "settings.json").read_text())
+        saved = settings.get("activeProfile") if isinstance(settings, dict) else None
+    except (OSError, ValueError):
+        saved = None
+    return next((p for p in profiles if p["id"] == saved), profiles[0] if profiles else None)
+
+
+def session_store_dir() -> Path:
+    """Meridian's session store, kept across pcode runs so resumes stay warm.
+
+    With a temporary store a restarted Meridian no longer recognises the
+    conversation and replays its whole history as flattened text. Meridian locks
+    the store, so concurrent pcode processes can share it.
+    """
+    state = Path(os.environ.get("XDG_STATE_HOME") or Path.home() / ".local" / "state")
+    return state / "pcode" / "meridian" / "sessions"
+
+
+class ManagedMeridian:
+    def __init__(self):
+        self.process = None
+        self.directory = None
+        self.executable = None
+        self.port = None
+        self.base_url = ""
+        self.api_key = secrets.token_urlsafe(32)
+        self.profile: str | None = None
+        self.restarts: list[float] = []
+        self.failure: str | None = None
+        self._lock = threading.RLock()
+        self._stopped = threading.Event()
+        self._watchdog = None
+
+    def start(self):
+        executable = shutil.which("meridian")
+        if not executable:
+            raise ValueError("Managed Meridian requires meridian on PATH; install it first.")
+        try:
+            version = subprocess.run(
+                [executable, "--version"], capture_output=True, text=True, timeout=10, check=True
+            ).stdout.strip()
+        except (OSError, subprocess.SubprocessError):
+            raise ValueError("Could not verify the installed Meridian version.") from None
+        if not supported(version):
+            raise ValueError(
+                f"Managed Meridian needs {MINIMUM_VERSION} or newer "
+                f"(found {version or 'unknown'}). Run `pcode --upgrade-meridian`."
+            )
+        self.executable = executable
+        self.directory = tempfile.TemporaryDirectory(prefix="pcode-meridian-")
+        root = Path(self.directory.name)
+        (root / "sdk-features.json").write_text(
+            json.dumps({"passthrough": {"thinkingPassthrough": True}})
+        )
+        (root / "plugins").mkdir()
+        (root / "plugins.json").write_text("[]")
+        (root / "workdir").mkdir()
+        profile = default_profile()
+        if profile is not None:
+            # 1.72 reads profiles from ~/.config/meridian whatever MERIDIAN_CONFIG_DIR
+            # says, while 1.76 reads them from the config directory. Link them in
+            # (never copy: a profile can hold a token) so every release sees the
+            # same ones, and name the profile so /login meridian targets its login.
+            for name in ("profiles.json", "profiles"):
+                source = meridian_config_dir() / name
+                if source.exists():
+                    (root / name).symlink_to(source)
+            self.profile = profile["id"]
+        session_store_dir().mkdir(parents=True, exist_ok=True, mode=0o700)
+        with socket.socket() as sock:
+            sock.bind(("127.0.0.1", 0))
+            self.port = sock.getsockname()[1]
+        # The port and key stay fixed across restarts, so clients built against
+        # this instance keep working after the watchdog replaces the process.
+        self.base_url = f"http://127.0.0.1:{self.port}"
+        try:
+            self._spawn()
+        except BaseException:
+            self.close()
+            raise
+        self._watchdog = threading.Thread(
+            target=self._watch, name="pcode-meridian-watchdog", daemon=True
+        )
+        self._watchdog.start()
+        return self
+
+    def _spawn(self):
+        root = Path(self.directory.name)
+        # Do not inherit shared proxy routing, plugins, or administrative settings.
+        # HOME and Claude credentials remain unchanged: Meridian owns upstream auth.
+        env = {
+            k: v for k, v in os.environ.items() if not k.startswith(("MERIDIAN_", "CLAUDE_PROXY_"))
+        }
+        env.update(
+            {
+                "MERIDIAN_HOST": "127.0.0.1",
+                "MERIDIAN_PORT": str(self.port),
+                "MERIDIAN_API_KEY": self.api_key,
+                "MERIDIAN_CONFIG_DIR": str(root),
+                "MERIDIAN_SESSION_DIR": str(session_store_dir()),
+                "MERIDIAN_PLUGIN_DIR": str(root / "plugins"),
+                "MERIDIAN_PLUGIN_CONFIG": str(root / "plugins.json"),
+                "MERIDIAN_DESIGN_TOKEN_PATH": str(root / "design-token.json"),
+                "MERIDIAN_NO_UPDATE_CHECK": "1",
+                "MERIDIAN_TELEMETRY_PERSIST": "0",
+                "MERIDIAN_PASSTHROUGH": "1",
+                # Claude Code counts the files under its cwd on every start
+                # (`rg --files --hidden`, skipped only for $HOME), and Meridian
+                # starts one per request. Tools run in pcode, so give it an
+                # empty directory rather than wherever pcode was launched.
+                "MERIDIAN_WORKDIR": str(root / "workdir"),
+            }
+        )
+        if self.profile:
+            env["MERIDIAN_DEFAULT_PROFILE"] = self.profile
+        # Never let server output corrupt the terminal or expose credentials.
+        self.process = subprocess.Popen(
+            [self.executable],
+            env=env,
+            cwd=root / "workdir",
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        try:
+            self.wait_ready()
+        except BaseException:
+            self._stop_process()
+            raise
+
+    def wait_ready(self):
+        deadline = time.monotonic() + 30
+        with httpx2.Client(trust_env=False, timeout=2) as client:
+            while time.monotonic() < deadline:
+                if self.process.poll() is not None:
+                    raise ValueError(
+                        "Managed Meridian exited during startup (possibly a port conflict)."
+                    )
+                try:
+                    headers = {"x-api-key": self.api_key}
+                    health = client.get(self.base_url + "/health", headers=headers).json()
+                    if health.get("auth", {}).get("loggedIn") is False:
+                        raise ValueError(
+                            "Meridian is not logged in. Run /login meridian, then retry."
+                        )
+                    if health.get("status") == "healthy" and supported(health.get("version")):
+                        response = client.get(
+                            self.base_url + "/settings/api/features", headers=headers
+                        )
+                        response.raise_for_status()
+                        if (
+                            response.json().get("passthrough", {}).get("thinkingPassthrough")
+                            is not True
+                        ):
+                            raise ValueError(
+                                "Managed Meridian did not enable thinking passthrough."
+                            )
+                        return
+                except (httpx2.HTTPError, json.JSONDecodeError):
+                    pass
+                time.sleep(0.1)
+        raise ValueError("Managed Meridian was not ready within 30 seconds; check Claude login.")
+
+    def ensure_running(self):
+        """Replace an exited process on the same port, within the restart budget."""
+        with self._lock:
+            if self.failure:
+                raise ValueError(self.failure)
+            if self._stopped.is_set():
+                raise ValueError("Managed Meridian was stopped. Restart pcode.")
+            if self.process is not None and self.process.poll() is None:
+                return
+            now = time.monotonic()
+            self.restarts = [t for t in self.restarts if now - t < RESTART_WINDOW_SECONDS]
+            if len(self.restarts) >= MAX_RESTARTS:
+                self.failure = (
+                    "Managed Meridian keeps exiting. Run `meridian` in a terminal to see why, "
+                    "then restart pcode."
+                )
+                raise ValueError(self.failure)
+            self.restarts.append(now)
+            self._spawn()
+
+    def _watch(self):
+        # Requests in flight when the process died are not replayed; the
+        # runtime's own retry, or the next prompt, reaches the replacement.
+        while not self._stopped.wait(WATCH_INTERVAL_SECONDS):
+            try:
+                self.ensure_running()
+            except ValueError:
+                if self.failure:
+                    return
+
+    def _stop_process(self):
+        if self.process is not None:
+            if self.process.poll() is None:
+                self.process.terminate()
+                try:
+                    self.process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    self.process.kill()
+                    self.process.wait(timeout=5)
+            self.process = None
+
+    def close(self):
+        self._stopped.set()
+        with self._lock:
+            self._stop_process()
+            if self.directory is not None:
+                self.directory.cleanup()
+                self.directory = None
+
+
+def managed_mode() -> str:
+    """`on`, `off`, or `auto`; `PCODE_MERIDIAN_MANAGED` overrides the saved choice."""
+    override = os.environ.get("PCODE_MERIDIAN_MANAGED", "").strip()
+    if override:
+        if override not in {"0", "1"}:
+            raise ValueError("PCODE_MERIDIAN_MANAGED must be 0 or 1.")
+        return "on" if override == "1" else "off"
+    mode = load_preferences().get("meridian_managed", "auto")
+    return mode if mode in MODES else "auto"
+
+
+def external_proxy_running(base_url: str) -> bool:
+    """True when something that looks like Meridian answers at `base_url`."""
+    try:
+        response = httpx2.get(base_url + "/health", timeout=1, trust_env=False)
+    except httpx2.HTTPError:
+        return False
+    if response.status_code in (401, 403):
+        return True  # A key-protected proxy still counts as the user's own.
+    try:
+        return "status" in response.json()
+    except (ValueError, AttributeError, TypeError):
+        return False
+
+
+def managed_base_url() -> str | None:
+    """The owned instance's URL, if this process started one."""
+    instance = _instance
+    return instance.base_url if instance is not None else None
+
+
+def managed_endpoint():
+    """Return private connection details, or None to use an external proxy.
+
+    `auto` prefers a proxy already answering at the default address, then starts
+    a private instance when `meridian` is installed.
+    """
+    if os.environ.get("PCODE_MERIDIAN_BASE_URL", "").strip():
+        return None
+    mode = managed_mode()
+    if mode == "off":
+        return None
+    global _instance
+    with _lock:
+        if _instance is None:
+            if mode == "auto":
+                from pcode.meridian import DEFAULT_BASE_URL
+
+                if shutil.which("meridian") is None or external_proxy_running(DEFAULT_BASE_URL):
+                    return None
+            _instance = ManagedMeridian().start()
+            atexit.register(_instance.close)
+        _instance.ensure_running()
+        return _instance.base_url, _instance.api_key

pcode/meridian_reminders.py

@@ -0,0 +1,107 @@
+"""Durable reminder helper and append-only limit warnings for Meridian and Claude Code."""
+
+import re
+from collections.abc import Callable
+from dataclasses import replace
+
+from pydantic_ai.messages import ModelRequest, UserPromptPart
+from pydantic_ai_harness.compaction import WarnNearLimits
+
+from pcode.model_metadata import ContextWindowError, context_window, refresh_context
+
+LIMITS_TAG = "[WarnNearLimits]"
+
+
+def last_reminder(messages, tag: str) -> str | None:
+    """Return the most recent reminder text for `tag`, or None when none was sent.
+
+    Detection is by content, not message metadata: Pydantic AI merges consecutive
+    `ModelRequest`s when history is resumed and keeps only its own reserved
+    metadata namespace, so a marker stored there survives a run but not a resume.
+    Only a `UserPromptPart` that *starts* with the tag counts, so a tool result or
+    quoted prompt that merely mentions it is not mistaken for a sent reminder.
+    """
+    for message in reversed(messages):
+        if not isinstance(message, ModelRequest):
+            continue
+        for part in reversed(message.parts):
+            content = getattr(part, "content", None)
+            if isinstance(part, UserPromptPart) and isinstance(content, str):
+                if content.startswith(tag):
+                    return content
+    return None
+
+
+def append_reminder(
+    request_context, tag: str, text: str, normalize: Callable[[str], str] | None = None
+) -> None:
+    """Append `text` as durable history unless the last reminder already says it.
+
+    Appending, rather than moving a mutable tail, keeps previously sent messages
+    byte-identical so the provider's cached prefix stays reusable as the
+    conversation grows. `normalize` collapses differences that should not count
+    as a change (for example, warning percentages within the same decile).
+    """
+    messages = request_context.messages
+    if not messages or not isinstance(messages[-1], ModelRequest):
+        return
+    previous = last_reminder(messages, tag)
+    key = normalize or (lambda value: value)
+    if previous is not None and key(previous) == key(text):
+        return
+    messages.append(ModelRequest(parts=[UserPromptPart(content=text)]))
+
+
+def _decile_key(text: str) -> str:
+    """Treat percentages within the same decile as the same warning."""
+    return re.sub(r"\d+", "#", text) + str([int(p) // 10 for p in re.findall(r"(\d+)%", text)])
+
+
+# Providers that keep the history themselves, where editing a sent message
+# forces a replay: Meridian's lineage check and the `claude:` CLI transcript.
+APPEND_ONLY_SYSTEMS = frozenset({"meridian", "claude"})
+
+
+class MeridianLimitWarnings(WarnNearLimits):
+    """Warn against pcode's resolved window, and never remove text already sent
+    to a provider that keeps the history (`APPEND_ONLY_SYSTEMS`)."""
+
+    async def _for_model(self, model) -> WarnNearLimits:
+        """This capability, bound to the window the footer and compaction use.
+
+        Harness resolves windows from genai-prices, which knows no `meridian:` ids
+        and silently assumes 200k (a 1M Meridian session was told it was 90% full
+        at 162k), and gives `openai-codex:` the direct API's window by model name
+        (1.05M where Codex serves 272k). Explicit windows and models pcode cannot
+        resolve keep Harness's own resolution.
+        """
+        if self.max_context_fraction is None or self.context_window is not None:
+            return self
+        await refresh_context(model)
+        try:
+            window = context_window(model)
+        except ContextWindowError:
+            # Compaction reports the actionable configuration error.
+            window = None
+        return self if window is None else replace(self, context_window=window)
+
+    async def before_model_request(self, ctx, request_context):
+        warnings = await self._for_model(request_context.model)
+        if request_context.model.system not in APPEND_ONLY_SYSTEMS:
+            return await WarnNearLimits.before_model_request(warnings, ctx, request_context)
+        original = request_context.messages
+        if not original or not isinstance(original[-1], ModelRequest):
+            return request_context
+        # Upstream strips prior warnings and appends exactly one request when a
+        # threshold fires. Evaluate on a disposable list; retain the real history.
+        clean_count = len(self._strip_old_warnings(original))
+        candidate = await WarnNearLimits.before_model_request(
+            warnings, ctx, replace(request_context, messages=list(original))
+        )
+        if len(candidate.messages) > clean_count:
+            # Warn at percentage deciles rather than on every token increase.
+            # Keep severity and warning kinds so new limits/escalations still fire.
+            append_reminder(
+                request_context, LIMITS_TAG, candidate.messages[-1].parts[0].content, _decile_key
+            )
+        return request_context