tokenbiryani 0.2.0__py3-none-any.whl

tokenbiryani/core/account.py

@@ -0,0 +1,258 @@
+"""Account runtime: health state machine, rolling stats, and cost accounting."""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Deque, Dict, Optional, Set
+
+from ..config import AccountConfig, ModelPrice
+from ..proxy.errors import AccountAction, Classification
+from .breaker import BreakerState, CircuitBreaker
+from .limits import LimitMirror, TokenEstimate
+
+WINDOW = 50
+
+
+class AccountState(str, Enum):
+    #: serving traffic, headroom available
+    READY = "ready"
+    #: waiting on a reset; self-heals, nothing for an operator to do
+    COOLING = "cooling"
+    #: auth failure, spend cap, or a tripped breaker — needs a look
+    DISABLED = "disabled"
+
+
+@dataclass
+class Usage:
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_read_tokens: int = 0
+    cache_creation_tokens: int = 0
+
+    @classmethod
+    def from_body(cls, body: Optional[Dict[str, Any]]) -> Usage:
+        raw = (body or {}).get("usage") or {}
+
+        def get(name: str) -> int:
+            try:
+                return int(raw.get(name) or 0)
+            except (TypeError, ValueError):
+                return 0
+
+        return cls(
+            input_tokens=get("input_tokens"),
+            output_tokens=get("output_tokens"),
+            cache_read_tokens=get("cache_read_input_tokens"),
+            cache_creation_tokens=get("cache_creation_input_tokens"),
+        )
+
+    @property
+    def billed_input(self) -> int:
+        return self.input_tokens + self.cache_read_tokens + self.cache_creation_tokens
+
+    def cost(self, price: Optional[ModelPrice]) -> Optional[float]:
+        if price is None:
+            return None
+        return (
+            self.input_tokens * price.input
+            + self.output_tokens * price.output
+            + self.cache_read_tokens * price.cache_read
+            + self.cache_creation_tokens * price.cache_write
+        ) / 1_000_000.0
+
+
+@dataclass
+class AccountRuntime:
+    config: AccountConfig
+    mirror: LimitMirror = field(default_factory=LimitMirror)
+    breaker: CircuitBreaker = field(default_factory=CircuitBreaker)
+
+    cooling_until: float = 0.0
+    disabled_reason: Optional[str] = None
+    unsupported_models: Set[str] = field(default_factory=set)
+
+    #: The `anthropic-ratelimit-*` headers seen on the last real response from this
+    #: account, kept verbatim so the header check has something true to inspect.
+    #:
+    #: It cannot use a `/v1/models` probe: that endpoint carries no limit headers, so
+    #: checking against it reports all nine missing for a perfectly healthy account.
+    #: Empty means no request has been through this account yet — which is a third
+    #: answer, distinct from "checked and fine" and "checked and broken".
+    last_limit_headers: Dict[str, str] = field(default_factory=dict)
+
+    inflight: int = 0
+    outcomes: Deque[bool] = field(default_factory=lambda: deque(maxlen=WINDOW))
+    latencies: Deque[float] = field(default_factory=lambda: deque(maxlen=WINDOW))
+
+    requests_total: int = 0
+    failures_total: int = 0
+    error_kinds: Dict[str, int] = field(default_factory=dict)
+    spend_usd: float = 0.0
+    input_tokens_total: int = 0
+    output_tokens_total: int = 0
+    cache_read_total: int = 0
+    cache_creation_total: int = 0
+
+    @property
+    def id(self) -> str:
+        return self.config.id
+
+    # ---- state ---------------------------------------------------------------
+
+    def observe_headers(self, headers: Dict[str, str], now: float) -> None:
+        """Update the mirror, and remember the limit headers it was given."""
+        self.mirror.update_from_headers(headers, now)
+        seen = {
+            str(k).lower(): str(v)
+            for k, v in headers.items()
+            if str(k).lower().startswith("anthropic-ratelimit-")
+        }
+        if seen:
+            self.last_limit_headers = seen
+
+    def state(self, now: float) -> AccountState:
+        if not self.config.enabled:
+            return AccountState.DISABLED
+        if self.disabled_reason:
+            return AccountState.DISABLED
+        if self.breaker.state(now) is BreakerState.OPEN:
+            return AccountState.DISABLED
+        if now < self.cooling_until:
+            return AccountState.COOLING
+        return AccountState.READY
+
+    def cooling_for(self, now: float) -> Optional[float]:
+        """Seconds until this account is usable again, from any known cause."""
+        candidates = []
+        if now < self.cooling_until:
+            candidates.append(self.cooling_until - now)
+        if self.breaker.state(now) is BreakerState.OPEN and self.breaker.opened_at is not None:
+            candidates.append(self.breaker.opened_at + self.breaker.cooldown_seconds - now)
+        reset = self.mirror.next_reset(now)
+        if reset is not None and not self.mirror.headroom(now):
+            candidates.append(reset)
+        return min(candidates) if candidates else None
+
+    def eligible(self, model: str, estimate: TokenEstimate, now: float) -> Optional[str]:
+        """Return None if this account may serve the request, else why not."""
+        if self.state(now) is AccountState.DISABLED:
+            return self.disabled_reason or "disabled"
+        if self.state(now) is AccountState.COOLING:
+            remaining = self.cooling_for(now) or 0.0
+            return f"cooling, {remaining:.0f}s remaining"
+        if not self.config.supports_model(model):
+            return "model not in account allowlist"
+        if model in self.unsupported_models:
+            return "model rejected by upstream"
+        if self.inflight >= self.config.max_concurrency:
+            return f"at max concurrency ({self.config.max_concurrency})"
+        if self.config.spend_cap_usd is not None and self.spend_usd >= self.config.spend_cap_usd:
+            return "spend cap reached"
+        if not self.breaker.allow(now):
+            return "circuit open"
+        if not self.mirror.can_serve(estimate, now):
+            return "insufficient headroom"
+        return None
+
+    # ---- outcomes ------------------------------------------------------------
+
+    def apply(self, classification: Classification, now: float, model: str = "") -> None:
+        action = classification.account_action
+        if action is AccountAction.NONE:
+            return
+        if action is AccountAction.ERROR_TICK:
+            self.breaker.record_failure(now)
+        elif action is AccountAction.COOLDOWN:
+            seconds = classification.cooldown_seconds
+            if seconds is None:
+                seconds = self.mirror.next_reset(now) or 60.0
+            self.cooling_until = max(self.cooling_until, now + float(seconds))
+        elif action is AccountAction.SHORT_COOLDOWN:
+            self.cooling_until = max(self.cooling_until, now + 5.0)
+            self.breaker.record_failure(now)
+        elif action is AccountAction.DISABLE:
+            self.disabled_reason = classification.kind
+        elif action is AccountAction.MARK_MODEL_UNSUPPORTED and model:
+            self.unsupported_models.add(model)
+        self.outcomes.append(False)
+        self.failures_total += 1
+        self.error_kinds[classification.kind] = self.error_kinds.get(classification.kind, 0) + 1
+
+    def record_success(
+        self,
+        latency: float,
+        usage: Usage,
+        price: Optional[ModelPrice],
+        now: float,
+        cost_multiplier: float = 1.0,
+    ) -> Optional[float]:
+        self.breaker.record_success()
+        self.outcomes.append(True)
+        self.latencies.append(latency)
+        self.requests_total += 1
+        self.input_tokens_total += usage.input_tokens
+        self.output_tokens_total += usage.output_tokens
+        self.cache_read_total += usage.cache_read_tokens
+        self.cache_creation_total += usage.cache_creation_tokens
+        cost = usage.cost(price)
+        if cost is not None:
+            cost *= cost_multiplier
+        if cost is not None:
+            self.spend_usd += cost
+        return cost
+
+    # ---- derived stats -------------------------------------------------------
+
+    def error_rate(self) -> float:
+        if not self.outcomes:
+            return 0.0
+        return sum(1 for ok in self.outcomes if not ok) / float(len(self.outcomes))
+
+    def p95_latency(self) -> Optional[float]:
+        if not self.latencies:
+            return None
+        ordered = sorted(self.latencies)
+        index = min(len(ordered) - 1, int(round(0.95 * (len(ordered) - 1))))
+        return ordered[index]
+
+    def cache_hit_rate(self) -> Optional[float]:
+        billed = self.input_tokens_total + self.cache_read_total + self.cache_creation_total
+        if billed <= 0:
+            return None
+        return self.cache_read_total / float(billed)
+
+    def load(self) -> float:
+        if self.config.max_concurrency <= 0:
+            return 1.0
+        return min(1.0, self.inflight / float(self.config.max_concurrency))
+
+    def snapshot(self, now: float) -> Dict[str, Any]:
+        cooling = self.cooling_for(now)
+        p95 = self.p95_latency()
+        cache_rate = self.cache_hit_rate()
+        return {
+            "id": self.id,
+            "type": self.config.type,
+            "state": self.state(now).value,
+            "disabled_reason": self.disabled_reason,
+            "cooling_for": None if cooling is None else round(cooling, 1),
+            "inflight": self.inflight,
+            "priority": self.config.priority,
+            "cost_tier": self.config.cost_tier,
+            "limits": self.mirror.snapshot(now),
+            "error_rate": round(self.error_rate(), 4),
+            "p95_latency": None if p95 is None else round(p95, 3),
+            "cache_hit_rate": None if cache_rate is None else round(cache_rate, 4),
+            "requests_total": self.requests_total,
+            "failures_total": self.failures_total,
+            "error_kinds": dict(self.error_kinds),
+            "spend_usd": round(self.spend_usd, 4),
+            "tokens": {
+                "input": self.input_tokens_total,
+                "output": self.output_tokens_total,
+                "cache_read": self.cache_read_total,
+                "cache_write": self.cache_creation_total,
+            },
+        }

tokenbiryani/core/batch.py

@@ -0,0 +1,135 @@
+"""The spill lane: one Messages request run through the Message Batches API.
+
+Batches are cheaper but asynchronous. The gateway holds the client's connection
+while it polls, bounded by that request's own wait budget — never longer. A batch
+that outlives the budget is cancelled and the id is handed back, so nothing is
+silently abandoned upstream.
+
+Only `batch` priority spills, and never a streaming request: batches do not stream.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, Mapping, Optional
+
+import httpx
+
+from ..providers.base import Upstream
+
+CUSTOM_ID = "tokenbiryani-spill"
+
+#: Terminal processing_status values from the Batches API.
+ENDED = "ended"
+TERMINAL = {"ended", "canceled", "cancelled", "expired", "errored"}
+
+
+class BatchUnavailable(Exception):
+    """The spill lane could not serve this request; fall back to queueing."""
+
+
+class BatchTimeout(Exception):
+    """The batch outlived the request's wait budget. Carries the id for follow-up."""
+
+    def __init__(self, batch_id: Optional[str]) -> None:
+        super().__init__("batch did not finish within the request's wait budget")
+        self.batch_id = batch_id
+
+
+@dataclass
+class BatchOutcome:
+    message: Dict[str, Any]
+    batch_id: str
+    polls: int
+    waited: float
+
+
+def _first_result(payload: bytes) -> Optional[Dict[str, Any]]:
+    """Batch results are JSONL. We submit one request, so we read one line."""
+    for line in payload.decode("utf-8", "replace").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            parsed = json.loads(line)
+        except ValueError:
+            continue
+        if isinstance(parsed, dict):
+            return parsed
+    return None
+
+
+async def run_single(
+    client: httpx.AsyncClient,
+    upstream: Upstream,
+    params: Mapping[str, Any],
+    headers: Mapping[str, str],
+    poll_interval: float,
+    deadline: float,
+) -> BatchOutcome:
+    """Submit one request as a batch and wait for it, within `deadline`."""
+    started = time.time()
+    payload = {k: v for k, v in params.items() if k != "stream"}
+
+    submitted = await upstream.submit_batch(
+        client, [{"custom_id": CUSTOM_ID, "params": payload}], headers
+    )
+    if submitted.status >= 300 or not submitted.body:
+        raise BatchUnavailable(
+            f"batch submission returned {submitted.status}"
+        )
+    batch_id = str(submitted.body.get("id") or "")
+    if not batch_id:
+        raise BatchUnavailable("batch submission returned no id")
+
+    polls = 0
+    status = str(submitted.body.get("processing_status") or "in_progress")
+    while status not in TERMINAL:
+        if time.time() >= deadline:
+            await _cancel(client, upstream, batch_id, headers)
+            raise BatchTimeout(batch_id)
+        await asyncio.sleep(min(poll_interval, max(0.0, deadline - time.time())))
+        polls += 1
+        polled = await upstream.poll_batch(client, batch_id, headers)
+        if polled.status >= 300 or not polled.body:
+            raise BatchUnavailable(f"batch poll returned {polled.status}")
+        status = str(polled.body.get("processing_status") or "in_progress")
+
+    if status != ENDED:
+        raise BatchUnavailable(f"batch finished as {status}")
+
+    fetched = await upstream.fetch_batch_results(client, batch_id, headers)
+    if fetched.status >= 300:
+        raise BatchUnavailable(f"batch results returned {fetched.status}")
+
+    entry = _first_result(fetched.raw)
+    if entry is None:
+        raise BatchUnavailable("batch results were empty")
+
+    result = entry.get("result") or {}
+    if result.get("type") != "succeeded":
+        raise BatchUnavailable(
+            "batch request {}".format(result.get("type") or "did not succeed")
+        )
+    message = result.get("message")
+    if not isinstance(message, dict):
+        raise BatchUnavailable("batch result carried no message")
+
+    return BatchOutcome(
+        message=message, batch_id=batch_id, polls=polls, waited=time.time() - started
+    )
+
+
+async def _cancel(
+    client: httpx.AsyncClient,
+    upstream: Upstream,
+    batch_id: str,
+    headers: Mapping[str, str],
+) -> None:
+    try:
+        await upstream.cancel_batch(client, batch_id, headers)
+    except Exception:  # noqa: BLE001 - a failed cancel must not mask the timeout
+        pass

tokenbiryani/core/breaker.py

@@ -0,0 +1,53 @@
+"""Per-account circuit breaker: closed -> open -> half-open -> closed."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+class BreakerState(str, Enum):
+    CLOSED = "closed"
+    OPEN = "open"
+    HALF_OPEN = "half_open"
+
+
+@dataclass
+class CircuitBreaker:
+    failure_threshold: int = 5
+    cooldown_seconds: float = 30.0
+
+    consecutive_failures: int = 0
+    opened_at: Optional[float] = None
+    _probe_in_flight: bool = False
+
+    def state(self, now: float) -> BreakerState:
+        if self.opened_at is None:
+            return BreakerState.CLOSED
+        if now - self.opened_at >= self.cooldown_seconds:
+            return BreakerState.HALF_OPEN
+        return BreakerState.OPEN
+
+    def allow(self, now: float) -> bool:
+        """Half-open lets exactly one probe through at a time."""
+        state = self.state(now)
+        if state is BreakerState.CLOSED:
+            return True
+        if state is BreakerState.OPEN:
+            return False
+        if self._probe_in_flight:
+            return False
+        self._probe_in_flight = True
+        return True
+
+    def record_success(self) -> None:
+        self.consecutive_failures = 0
+        self.opened_at = None
+        self._probe_in_flight = False
+
+    def record_failure(self, now: float) -> None:
+        self.consecutive_failures += 1
+        self._probe_in_flight = False
+        if self.consecutive_failures >= self.failure_threshold:
+            self.opened_at = now

tokenbiryani/core/cacheadvice.py

@@ -0,0 +1,239 @@
+"""Whether the caller ever asked for caching, and what it costs when they did not.
+
+The gateway already measures the *outcome* — `cache_read_input_tokens` comes back on
+every response and the console draws a hit rate from it. What it could not do is tell
+the two reasons for a 0% hit rate apart:
+
+    the client never marked a breakpoint  -> caching never engages at all, and no
+                                             routing change can fix it
+    the breakpoint is there, affinity broke -> a routing problem, already diagnosed
+
+Both render as "cache hit 0%", and an operator seeing that reaches for the strategy
+knob, which cannot help in the first case. Anthropic's cache only engages where the
+request carries `cache_control`, so the presence of that marker is the fact that
+separates them, and it is knowable before the request is even sent.
+
+Nothing here keeps prompt content. It reads the body in memory, records booleans and
+token counts, and drops it — the promise that bodies are never logged is not
+weakened by knowing whether one had a breakpoint in it.
+"""
+
+from __future__ import annotations
+
+import copy
+from collections import defaultdict
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple
+
+#: Anthropic will not cache a prefix shorter than this, so a breakpoint on a small
+#: request buys nothing and advising one would be noise. The real minimum is
+#: model-dependent (larger for Haiku); this is the smaller of them, because
+#: over-reporting a missing breakpoint is worse than staying quiet.
+MIN_CACHEABLE_TOKENS = 1024
+
+#: Rough characters per token, matching `limits.CHARS_PER_TOKEN`.
+CHARS_PER_TOKEN = 3.5
+
+#: Below this many requests a group is not worth an opinion.
+MIN_REQUESTS_FOR_ADVICE = 20
+
+#: A group with fewer than this fraction of requests marked is treated as unmarked.
+BREAKPOINT_PRESENT = 0.5
+
+CACHE_CONTROL = "cache_control"
+EPHEMERAL = {"type": "ephemeral"}
+
+
+def _blocks(value: Any) -> Iterable[Mapping[str, Any]]:
+    """Yield the mapping blocks in a `system`, `tools` or message `content` field."""
+    if isinstance(value, Mapping):
+        yield value
+    elif isinstance(value, list):
+        for item in value:
+            if isinstance(item, Mapping):
+                yield item
+
+
+def has_cache_breakpoint(body: Mapping[str, Any]) -> bool:
+    """True when anything in the request is marked for caching.
+
+    Checks the three places a breakpoint may legally sit: a system block, a tool
+    definition, and a content block inside a message.
+    """
+    for field in ("system", "tools"):
+        for block in _blocks(body.get(field)):
+            if block.get(CACHE_CONTROL):
+                return True
+    messages = body.get("messages")
+    if isinstance(messages, list):
+        for message in messages:
+            if not isinstance(message, Mapping):
+                continue
+            for block in _blocks(message.get("content")):
+                if block.get(CACHE_CONTROL):
+                    return True
+    return False
+
+
+def cacheable_prefix_tokens(body: Mapping[str, Any]) -> int:
+    """Roughly how much of this request is a stable, cacheable head.
+
+    The system prompt and the tool definitions: the part an agent resends unchanged
+    on every turn, and the part worth a breakpoint.
+    """
+    characters = 0
+    for field in ("system", "tools"):
+        value = body.get(field)
+        if isinstance(value, str):
+            characters += len(value)
+            continue
+        for block in _blocks(value):
+            for key in ("text", "description", "name"):
+                piece = block.get(key)
+                if isinstance(piece, str):
+                    characters += len(piece)
+            schema = block.get("input_schema")
+            if isinstance(schema, Mapping):
+                characters += len(str(schema))
+    return int(characters / CHARS_PER_TOKEN)
+
+
+def insert_cache_breakpoint(body: Mapping[str, Any]) -> Tuple[Dict[str, Any], bool]:
+    """Return a copy of the body with one breakpoint at the end of the stable head.
+
+    Off unless `cache.auto_breakpoint` is set, because this is the gateway editing a
+    caller's request — the thing it otherwise refuses to do. It is the third
+    documented exception, after the two fields Bedrock and Vertex need.
+
+    The breakpoint goes on the last tool if there are tools, otherwise on the last
+    system block; those are the end of the prefix an agent resends unchanged. A
+    string `system` is promoted to a one-block list, which is the same prompt in the
+    other legal spelling and the only way to attach the marker at all.
+    """
+    if has_cache_breakpoint(body):
+        return dict(body), False
+    if cacheable_prefix_tokens(body) < MIN_CACHEABLE_TOKENS:
+        return dict(body), False
+
+    updated = copy.deepcopy(dict(body))
+
+    tools = updated.get("tools")
+    if isinstance(tools, list) and tools and isinstance(tools[-1], dict):
+        tools[-1][CACHE_CONTROL] = dict(EPHEMERAL)
+        return updated, True
+
+    system = updated.get("system")
+    if isinstance(system, str) and system:
+        updated["system"] = [
+            {"type": "text", "text": system, CACHE_CONTROL: dict(EPHEMERAL)}
+        ]
+        return updated, True
+    if isinstance(system, list) and system and isinstance(system[-1], dict):
+        system[-1][CACHE_CONTROL] = dict(EPHEMERAL)
+        return updated, True
+
+    return updated, False
+
+
+class _Group:
+    """Counters for one (virtual key, model) pair. No content, only arithmetic."""
+
+    __slots__ = (
+        "requests", "marked", "prefix_tokens", "input_tokens",
+        "cache_read_tokens", "cache_creation_tokens",
+    )
+
+    def __init__(self) -> None:
+        self.requests = 0
+        self.marked = 0
+        self.prefix_tokens = 0
+        self.input_tokens = 0
+        self.cache_read_tokens = 0
+        self.cache_creation_tokens = 0
+
+
+class CacheAdvisor:
+    """Aggregates breakpoint presence against realised cache hits, per key and model."""
+
+    def __init__(
+        self,
+        min_requests: int = MIN_REQUESTS_FOR_ADVICE,
+        min_cacheable_tokens: int = MIN_CACHEABLE_TOKENS,
+    ) -> None:
+        self.min_requests = max(1, int(min_requests))
+        self.min_cacheable_tokens = max(1, int(min_cacheable_tokens))
+        self._groups: Dict[Tuple[str, str], _Group] = defaultdict(_Group)
+
+    def reconfigure(self, min_requests: int) -> None:
+        """Apply new settings without discarding the counters already gathered."""
+        self.min_requests = max(1, int(min_requests))
+
+    def observe(
+        self,
+        key_name: str,
+        model: str,
+        marked: Optional[bool],
+        prefix_tokens: int,
+        input_tokens: int,
+        cache_read_tokens: int,
+        cache_creation_tokens: int,
+    ) -> None:
+        if marked is None:
+            return
+        group = self._groups[(key_name or "", model or "")]
+        group.requests += 1
+        group.marked += 1 if marked else 0
+        group.prefix_tokens += max(0, int(prefix_tokens))
+        group.input_tokens += max(0, int(input_tokens))
+        group.cache_read_tokens += max(0, int(cache_read_tokens))
+        group.cache_creation_tokens += max(0, int(cache_creation_tokens))
+
+    def advice(self) -> Dict[str, Any]:
+        findings: List[Dict[str, Any]] = []
+        for (key_name, model), group in sorted(self._groups.items()):
+            if group.requests < self.min_requests:
+                continue
+            billed = (
+                group.input_tokens + group.cache_read_tokens + group.cache_creation_tokens
+            )
+            marked_rate = group.marked / float(group.requests)
+            mean_prefix = group.prefix_tokens // group.requests
+            hit_rate = (group.cache_read_tokens / billed) if billed else 0.0
+
+            findings.append({
+                "key": key_name,
+                "model": model,
+                "requests": group.requests,
+                "breakpoint_rate": round(marked_rate, 4),
+                "mean_prefix_tokens": mean_prefix,
+                "cache_hit_rate": round(hit_rate, 4),
+                "uncached_input_tokens": group.input_tokens,
+                "verdict": self._verdict(marked_rate, mean_prefix, hit_rate),
+            })
+        return {
+            "min_requests": self.min_requests,
+            "min_cacheable_tokens": self.min_cacheable_tokens,
+            "findings": findings,
+        }
+
+    def _verdict(self, marked_rate: float, mean_prefix: int, hit_rate: float) -> str:
+        """One sentence an operator can act on, or one saying there is nothing to do."""
+        if marked_rate < BREAKPOINT_PRESENT:
+            if mean_prefix < self.min_cacheable_tokens:
+                return (
+                    "no cache_control breakpoint, and the stable prefix is under "
+                    f"{self.min_cacheable_tokens} tokens — too small to cache, so "
+                    "there is nothing to fix here"
+                )
+            return (
+                "no cache_control breakpoint on a stable prefix of about "
+                f"{mean_prefix} tokens: caching never engages for this traffic, and "
+                "no routing strategy can recover it. The client has to mark the "
+                "prefix, or set cache.auto_breakpoint"
+            )
+        if hit_rate < 0.2:
+            return (
+                "breakpoints are being sent but the hit rate is low — this is a "
+                "routing problem, not a client one. Check cache breaks and whether "
+                "the owner keeps going cooling"
+            )
+        return "caching is engaged and working"