tokenbill 0.1.0__py3-none-any.whl

tokenbill/__init__.py

@@ -0,0 +1,12 @@
+"""Token Bill: token economics and prompt-cache profiling for LLM agents.
+
+Answers "why is our agent bill so high" with receipts: parses agent traces,
+computes per-call token waterfalls from real billed usage, measures what share
+of billed input tokens re-sent bytes the model had already seen, simulates what
+prompt caching would actually save under the provider's documented rules, and
+pinpoints the exact orchestration choices (a timestamp in the system prompt, a
+reordered tool list) that break cache hits — each with a concrete fix and the
+dollars it recovers.
+"""
+
+__version__ = "0.1.0"

tokenbill/__main__.py

@@ -0,0 +1,6 @@
+"""``python -m tokenbill`` entry point."""
+
+from tokenbill.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tokenbill/analyzer.py

@@ -0,0 +1,187 @@
+"""Waterfalls, redundancy, and segment attribution over recorded runs.
+
+Honesty rules (see docs/SPEC.md):
+
+- Dollar figures come from real billed ``usage`` via :mod:`tokenbill.pricing`.
+  Exact.
+- Char-based numbers (segment attribution, repeated-prefix fractions, the
+  redundancy fraction) are **approximate**, used only to apportion a call's
+  billed totals, and every approximate token figure is scaled so segments sum
+  to the call's billed ``total_input``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from tokenbill.pricing import cost_breakdown
+from tokenbill.trace import Call, Run, common_prefix_chars, render_segments, rendered_text
+
+_DOLLAR_KEYS = ("uncached", "write", "read", "output")
+_TOKEN_KEYS = ("uncached", "cache_write", "cache_read", "output", "total_input")
+
+
+@dataclass(frozen=True)
+class SegmentShare:
+    """One rendered segment's approximate share of a call's billed input.
+
+    ``approx_tokens`` is the call's billed ``total_input`` scaled by this
+    segment's char fraction — approximate by construction, but the shares of
+    one call always sum to the billed total.
+    """
+
+    kind: str
+    label: str
+    chars: int
+    char_fraction: float
+    approx_tokens: float
+
+
+@dataclass(frozen=True)
+class CallProfile:
+    """Per-call profile: exact billed dollars plus approximate attribution."""
+
+    call: Call
+    dollars: dict[str, float] | None  # pricing.cost_breakdown, None if model unknown
+    segments: list[SegmentShare]  # per-segment approx attribution
+    repeated_prefix_chars: int  # LCP with previous call (0 for first)
+    repeated_fraction_of_input: float  # approx: repeated chars / rendered chars
+
+
+@dataclass(frozen=True)
+class RunTotals:
+    """Run-level aggregates.
+
+    ``tokens`` (exact, from billed usage): ``uncached``, ``cache_write``,
+    ``cache_read``, ``output``, ``total_input``.
+
+    ``dollars`` (exact, billed): ``uncached``, ``write``, ``read``,
+    ``output``, ``total`` — or ``None`` when any call's model has no pricing
+    entry (a partial dollar total would be misleading; tokens stay exact).
+
+    ``redundancy_fraction`` is the headline number: the share of cumulative
+    billed input tokens attributable to re-sent byte-identical prefix that
+    was NOT served from cache. ``redundancy_is_approx`` is always ``True``:
+    the fraction rests on char-based prefix attribution.
+    """
+
+    tokens: dict[str, int]
+    dollars: dict[str, float] | None
+    redundancy_fraction: float
+    redundancy_is_approx: bool = True
+
+
+@dataclass(frozen=True)
+class RunProfile:
+    """Everything the report needs about one run."""
+
+    run: Run
+    calls: list[CallProfile]
+    totals: RunTotals
+
+
+def _segment_parts(segment: Any) -> tuple[str, str, str]:
+    """Normalize a trace Segment to ``(kind, label, text)``.
+
+    The SPEC writes Segment as a 3-tuple; tolerate an attribute-bearing
+    equivalent so a NamedTuple or dataclass from trace.py also works.
+    """
+    try:
+        kind, label, text = segment
+    except (TypeError, ValueError):
+        kind, label, text = segment.kind, segment.label, segment.text
+    return str(kind), str(label), str(text)
+
+
+def _profile_call(call: Call, prev: Call | None) -> tuple[CallProfile, float]:
+    """Build one CallProfile; also return this call's wasted-input tokens."""
+    rendered_chars = len(rendered_text(call))
+    total_input = call.usage.total_input
+
+    # Millions of shares are built for a large run; keep the loop body lean
+    # (positional construction, hoisted append, one division).
+    segments: list[SegmentShare] = []
+    append = segments.append
+    inv_chars = (1.0 / rendered_chars) if rendered_chars else 0.0
+    for segment in render_segments(call):
+        kind, label, text = _segment_parts(segment)
+        chars = len(text)
+        fraction = chars * inv_chars
+        append(SegmentShare(kind, label, chars, fraction, total_input * fraction))
+
+    if prev is None:
+        repeated_chars = 0
+    else:
+        repeated_chars = common_prefix_chars(prev, call)
+    repeated_fraction = (repeated_chars / rendered_chars) if rendered_chars else 0.0
+
+    # Redundancy contribution (see profile_run docstring): repeated prefix
+    # char fraction x billed total_input, minus tokens already served from
+    # cache; clamped at 0 per call.
+    wasted = max(0.0, total_input * repeated_fraction - call.usage.cache_read_input_tokens)
+
+    profile = CallProfile(
+        call=call,
+        dollars=cost_breakdown(call.model, call.usage),
+        segments=segments,
+        repeated_prefix_chars=repeated_chars,
+        repeated_fraction_of_input=repeated_fraction,
+    )
+    return profile, wasted
+
+
+def profile_run(run: Run) -> RunProfile:
+    """Profile one run: per-call waterfalls plus the run redundancy fraction.
+
+    Redundancy definition (the headline number; also in DESIGN.md): for call
+    ``i > 0`` the re-sent prefix is ``common_prefix_chars(call[i-1],
+    call[i])`` of the canonical rendered text. Its token value is the call's
+    billed ``total_input`` scaled by the repeated char fraction; the portion
+    already served as ``cache_read_input_tokens`` is subtracted (cache reads
+    are cheap — they are not waste), and each call's contribution is clamped
+    at 0. The fraction is the sum of those contributions divided by the sum
+    of billed ``total_input`` over all calls. Approximate by construction
+    (char-based attribution); labeled via ``redundancy_is_approx``.
+    """
+    call_profiles: list[CallProfile] = []
+    wasted_total = 0.0
+    prev: Call | None = None
+    for call in run.calls:
+        profile, wasted = _profile_call(call, prev)
+        call_profiles.append(profile)
+        wasted_total += wasted
+        prev = call
+
+    tokens = dict.fromkeys(_TOKEN_KEYS, 0)
+    for call in run.calls:
+        tokens["uncached"] += call.usage.input_tokens
+        tokens["cache_write"] += call.usage.cache_creation_input_tokens
+        tokens["cache_read"] += call.usage.cache_read_input_tokens
+        tokens["output"] += call.usage.output_tokens
+        tokens["total_input"] += call.usage.total_input
+
+    dollars: dict[str, float] | None
+    if any(p.dollars is None for p in call_profiles):
+        dollars = None
+    else:
+        dollars = dict.fromkeys(_DOLLAR_KEYS, 0.0)
+        for profile in call_profiles:
+            assert profile.dollars is not None  # narrowed by the branch above
+            for key in _DOLLAR_KEYS:
+                dollars[key] += profile.dollars[key]
+        dollars["total"] = sum(dollars[key] for key in _DOLLAR_KEYS)
+
+    billed_input = tokens["total_input"]
+    redundancy = (wasted_total / billed_input) if billed_input else 0.0
+
+    return RunProfile(
+        run=run,
+        calls=call_profiles,
+        totals=RunTotals(tokens=tokens, dollars=dollars, redundancy_fraction=redundancy),
+    )
+
+
+def profile_trace(runs: list[Run]) -> list[RunProfile]:
+    """Profile every run in a trace, preserving order."""
+    return [profile_run(run) for run in runs]

tokenbill/breakers.py

@@ -0,0 +1,369 @@
+"""Cache-breaker detection: divergence classification, fixes, and repair.
+
+For each pair of consecutive calls the first matching rule wins (SPEC priority
+order):
+
+1. ``model`` differs from the previous call → ``model-switch``.
+2. diverging segment is tools → ``tool-churn``.
+3. diverging segment is system → ``volatile-system`` when the changed span
+   strictly overlaps a :data:`VOLATILE_PATTERNS` match (ISO dates/times, unix
+   timestamps, UUIDs, monotonic counters) AND substituting every volatile
+   match makes the two system prompts byte-identical — i.e. the volatile
+   values fully explain the divergence. Otherwise ``system-edit`` — the
+   non-volatile variant with its own fix sentence (whose repair, pinning the
+   system text, also covers mixed volatile-plus-edit changes).
+4. diverging segment is a message that already existed in the previous call →
+   ``history-rewrite``.
+5. no divergence, shared prefix at least the model's minimum cacheable length
+   (approx tokens), but ``cache_breakpoints == 0`` and billed cache activity
+   is zero → ``missing-breakpoint``.
+
+:func:`detect` reports one :class:`Breaker` per distinct cause with the first
+call index where it bites (the demo's ``timestamp`` scenario diverges on every
+call but yields exactly one ``volatile-system`` breaker at call 1).
+``est_recovered_usd`` isolates each cause: the run is re-simulated with only
+that one breaker repaired, and the value is as-billed minus fixed-cache
+dollars, floored at 0 (positive = money recovered by the fix; approx, since
+the fixed-cache scenario is simulated; 0 when billed caching already beats
+the simulated single-breakpoint policy — the report words that case
+explicitly rather than showing a negative "recovery"). Causes with no
+mechanical repair (``model-switch``, ``history-rewrite``) get ``None`` — a
+billed-minus-fixed number there would price the optimal replay of the
+still-broken run, which is not attributable to the displayed fix.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, replace
+
+from tokenbill.common import canonical_json
+from tokenbill.pricing import PRICING, ModelPricing
+
+# _as_billed/_replay are simulator internals shared within the package: the
+# per-breaker estimate needs exactly one as-billed total per run and one
+# fixed-cache replay per breaker — calling the full simulate() here would
+# redundantly re-replay optimal-cache for every detected breaker.
+from tokenbill.simulator import _as_billed, _replay
+from tokenbill.trace import Call, Run, approx_tokens, diverging_segment, rendered_text
+
+# Heuristic patterns for content that legitimately changes every call and
+# therefore must not live in the cached prefix. Tested as a module constant
+# (SPEC). Order matters for :func:`repaired_calls`: the combined ISO datetime
+# comes first so one substitution covers the whole stamp.
+VOLATILE_PATTERNS: tuple[re.Pattern[str], ...] = (
+    # ISO datetime, e.g. "2026-07-26T14:03:05Z" or "2026-07-26 14:03:05".
+    re.compile(r"\b\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b"),
+    # ISO date, e.g. "2026-07-26".
+    re.compile(r"\b\d{4}-\d{2}-\d{2}\b"),
+    # Clock time, e.g. "14:03" or "14:03:05".
+    re.compile(r"\b\d{1,2}:\d{2}(?::\d{2})?\b"),
+    # Unix timestamp in seconds (~2017..2051 range guard against arbitrary
+    # 10-digit numbers).
+    re.compile(r"\b(?:1[5-9]|2[0-5])\d{8}\b"),
+    # UUID.
+    re.compile(r"\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b"),
+    # Monotonic counters, e.g. "attempt 3", "seq=42", "turn #7".
+    re.compile(
+        r"\b(?:seq|counter|attempt|turn|step|iteration|request|call|run)[ _#:=-]{1,3}\d+\b",
+        re.IGNORECASE,
+    ),
+)
+
+#: What repaired volatile spans are replaced with (stable across all calls).
+STABLE_PLACEHOLDER = "<volatile>"
+
+_DEFAULT_LIMITS = ModelPricing(input_per_mtok=0.0, output_per_mtok=0.0)
+
+_FIXES: dict[str, str] = {
+    "model-switch": (
+        "prompt caches are per-model: keep one model for the whole run, or expect a "
+        "cold cache after every switch"
+    ),
+    "tool-churn": (
+        "send tool definitions in one fixed order on every call (sort them once at "
+        "startup); reordering rewrites the cached prefix"
+    ),
+    "volatile-system": (
+        "move the volatile value (timestamp/UUID/counter) out of the system prompt — "
+        "inject it in the latest user message instead"
+    ),
+    "system-edit": (
+        "keep the system prompt byte-stable for the whole run; put per-turn context in "
+        "the latest user message instead of editing the system text"
+    ),
+    "history-rewrite": (
+        "append new messages instead of rewriting earlier ones; any edit above the "
+        "cache breakpoint invalidates the cached prefix"
+    ),
+    "missing-breakpoint": (
+        "add a cache_control breakpoint (for example on the last message); the stable "
+        "prefix already meets the minimum cacheable length"
+    ),
+}
+
+# SPEC rule order, used only to order breakers that first bite at the same call.
+_KIND_PRIORITY = {
+    "model-switch": 0,
+    "tool-churn": 1,
+    "volatile-system": 2,
+    "system-edit": 2,
+    "history-rewrite": 3,
+    "missing-breakpoint": 4,
+}
+
+
+@dataclass(frozen=True)
+class Breaker:
+    """One detected cache-breaking cause with a concrete, priced fix.
+
+    ``kind`` is one of ``model-switch``, ``tool-churn``, ``volatile-system``,
+    ``system-edit`` (the non-volatile system-divergence variant),
+    ``history-rewrite``, ``missing-breakpoint``. ``evidence`` shows the exact
+    changed span, truncated, with char offsets. ``est_recovered_usd`` is
+    as-billed minus fixed-cache dollars with only this breaker repaired,
+    floored at 0 (positive = recovered; 0 = billed caching already beats the
+    simulated repair; ``None`` when pricing is unknown or when the kind has
+    no mechanical repair — ``model-switch`` and ``history-rewrite`` — so no
+    honest per-fix dollar figure exists).
+    """
+
+    kind: str
+    first_call_index: int
+    evidence: str
+    fix: str
+    est_recovered_usd: float | None
+
+
+def _truncate(text: str, limit: int = 80) -> str:
+    if len(text) <= limit:
+        return text
+    keep = (limit - 3) // 2
+    return f"{text[:keep]}...{text[-keep:]}"
+
+
+def _changed_window(prev: str, cur: str) -> tuple[int, int, int]:
+    """``(lo, hi_prev, hi_cur)``: minimal spans ``prev[lo:hi_prev]`` vs ``cur[lo:hi_cur]``."""
+    lo = 0
+    limit = min(len(prev), len(cur))
+    while lo < limit and prev[lo] == cur[lo]:
+        lo += 1
+    hi_prev, hi_cur = len(prev), len(cur)
+    while hi_prev > lo and hi_cur > lo and prev[hi_prev - 1] == cur[hi_cur - 1]:
+        hi_prev -= 1
+        hi_cur -= 1
+    return lo, hi_prev, hi_cur
+
+
+def _volatile_overlap(text: str, lo: int, hi: int) -> re.Match[str] | None:
+    """First volatile-pattern match strictly overlapping ``text[lo:hi]``.
+
+    Strict means at least one shared character: a match that merely touches
+    the changed span (e.g. a stable date immediately before an edited
+    punctuation mark) must not classify the change as volatile.
+    """
+    for pattern in VOLATILE_PATTERNS:
+        for match in pattern.finditer(text):
+            if match.start() < hi and match.end() > lo:
+                return match
+    return None
+
+
+def _excerpt(text: str, lo: int, hi: int, context: int = 24) -> str:
+    start = max(0, lo - context)
+    end = min(len(text), hi + context)
+    prefix = "..." if start > 0 else ""
+    suffix = "..." if end < len(text) else ""
+    return prefix + _truncate(text[start:end]) + suffix
+
+
+def _tool_names(call: Call) -> list[str]:
+    return [str(tool.get("name", "?")) for tool in call.tools]
+
+
+def _classify_system(prev: Call, cur: Call) -> tuple[str, str]:
+    lo, hi_prev, hi_cur = _changed_window(prev.system, cur.system)
+    match_cur = _volatile_overlap(cur.system, lo, hi_cur)
+    match_prev = _volatile_overlap(prev.system, lo, hi_prev)
+    # Volatile only when the volatile values fully explain the divergence:
+    # after substituting every volatile match the systems must be identical.
+    # Otherwise the volatile repair would leave the run still diverging and
+    # the honest classification (and fix) is system-edit.
+    volatile = (match_cur is not None or match_prev is not None) and _stabilized(
+        prev.system
+    ) == _stabilized(cur.system)
+    if volatile:
+        # Widen each excerpt to cover the volatile token so the evidence shows
+        # the full stamp, not just the digits that changed.
+        prev_lo = min(lo, match_prev.start()) if match_prev else lo
+        prev_hi = max(hi_prev, match_prev.end()) if match_prev else hi_prev
+        cur_lo = min(lo, match_cur.start()) if match_cur else lo
+        cur_hi = max(hi_cur, match_cur.end()) if match_cur else hi_cur
+        evidence = (
+            f"system chars [{cur_lo}:{cur_hi}] at call {cur.index}: "
+            f"{_excerpt(prev.system, prev_lo, prev_hi)!r} -> "
+            f"{_excerpt(cur.system, cur_lo, cur_hi)!r}"
+        )
+        return "volatile-system", evidence
+    evidence = (
+        f"system chars [{lo}:{hi_cur}] at call {cur.index}: "
+        f"{_excerpt(prev.system, lo, hi_prev)!r} -> {_excerpt(cur.system, lo, hi_cur)!r}"
+    )
+    return "system-edit", evidence
+
+
+def _classify_pair(prev: Call, cur: Call, first_seen_tools: list[str]) -> tuple[str, str] | None:
+    """Classify one consecutive pair per the SPEC priority order."""
+    if cur.model != prev.model:
+        return "model-switch", (
+            f"model changed at call {cur.index}: {prev.model!r} -> {cur.model!r}"
+        )
+    divergence = diverging_segment(prev, cur)
+    if divergence is not None:
+        seg_index, seg_kind = divergence
+        if seg_kind == "tools":
+            return "tool-churn", (
+                f"tool order changed at call {cur.index}: first seen "
+                f"{first_seen_tools} -> {_tool_names(cur)}"
+            )
+        if seg_kind == "system":
+            return _classify_system(prev, cur)
+        # Message segments start after the tools and system segments.
+        msg_index = seg_index - 2
+        if 0 <= msg_index < len(prev.messages):
+            prev_text = canonical_json(prev.messages[msg_index])
+            cur_text = (
+                canonical_json(cur.messages[msg_index]) if msg_index < len(cur.messages) else ""
+            )
+            lo, hi_prev, hi_cur = _changed_window(prev_text, cur_text)
+            return "history-rewrite", (
+                f"messages[{msg_index}] rewritten at call {cur.index}, chars "
+                f"[{lo}:{hi_cur}]: {_excerpt(prev_text, lo, hi_prev)!r} -> "
+                f"{_excerpt(cur_text, lo, hi_cur)!r}"
+            )
+        return None
+    # Rule 5: byte-stable prefix that was never cached.
+    usage = cur.usage
+    if (
+        cur.cache_breakpoints == 0
+        and usage.cache_read_input_tokens == 0
+        and usage.cache_creation_input_tokens == 0
+    ):
+        limits = PRICING.get(cur.model) or _DEFAULT_LIMITS
+        prev_text = rendered_text(prev)
+        shared_chars = min(len(prev_text), len(rendered_text(cur)))
+        prefix_tokens = approx_tokens(prev_text[:shared_chars])
+        if prefix_tokens >= limits.min_cacheable_prefix_tokens:
+            return "missing-breakpoint", (
+                f"calls {prev.index}->{cur.index} share a byte-stable prefix of "
+                f"~{prefix_tokens:.0f} approx tokens (min cacheable "
+                f"{limits.min_cacheable_prefix_tokens}) but cache_breakpoints=0 "
+                "and billed cache activity is 0"
+            )
+    return None
+
+
+def detect(run: Run) -> list[Breaker]:
+    """Detect cache breakers in *run*: one :class:`Breaker` per distinct cause.
+
+    Consecutive call pairs are classified per the SPEC priority order; events
+    of the same kind are collapsed to the first call index where the cause
+    bites. Each breaker's ``est_recovered_usd`` is computed by re-simulating
+    the run with only that breaker repaired (see :func:`repaired_calls`), so
+    the dollar estimate isolates each cause; kinds with no mechanical repair
+    report ``None`` instead of a number the fix cannot claim.
+    """
+    calls = run.calls
+    if len(calls) < 2:
+        return []
+    first_seen_tools = _tool_names(calls[0])
+    events: dict[str, tuple[int, str]] = {}
+    for i in range(1, len(calls)):
+        classified = _classify_pair(calls[i - 1], calls[i], first_seen_tools)
+        if classified is None:
+            continue
+        kind, evidence = classified
+        events.setdefault(kind, (i, evidence))
+
+    ordered = sorted(events.items(), key=lambda item: (item[1][0], _KIND_PRIORITY[item[0]]))
+    # As-billed dollars are a property of the run, not of any repair: price
+    # them once instead of once per breaker (replays dominate detect() time).
+    billed = _as_billed(calls).dollars if ordered else None
+    breakers: list[Breaker] = []
+    for kind, (index, evidence) in ordered:
+        breaker = Breaker(
+            kind=kind,
+            first_call_index=index,
+            evidence=evidence,
+            fix=_FIXES[kind],
+            est_recovered_usd=None,
+        )
+        breakers.append(replace(breaker, est_recovered_usd=_estimate(run, breaker, billed)))
+    return breakers
+
+
+def _estimate(run: Run, breaker: Breaker, billed: float | None) -> float | None:
+    """As-billed minus fixed-cache dollars with only *breaker* repaired.
+
+    Floored at 0: billed usage can legitimately beat the simulated
+    single-breakpoint replay (e.g. real multi-breakpoint caching), and a
+    negative "recovery" would claim the fix costs money — the report words
+    that case explicitly instead. ``None`` when the repair left the calls
+    untouched (no mechanical repair exists — model-switch, history-rewrite):
+    billed minus fixed would then be the optimal replay of the still-broken
+    run, a number the displayed fix cannot claim. ``None`` also when any
+    call's model is unpriced (*billed* arrives as ``None``).
+    """
+    repaired = repaired_calls(run, [breaker])
+    if repaired == list(run.calls):
+        return None
+    if billed is None:
+        return None
+    fixed = _replay(repaired, "fixed-cache", "").dollars
+    if fixed is None:
+        return None
+    return max(0.0, billed - fixed)
+
+
+def _stabilized(system: str) -> str:
+    for pattern in VOLATILE_PATTERNS:
+        system = pattern.sub(STABLE_PLACEHOLDER, system)
+    return system
+
+
+def repaired_calls(run: Run, breakers: list[Breaker]) -> list[Call]:
+    """Return *run*'s calls with the given breakers neutralized for simulation.
+
+    Repairs (SPEC): volatile spans in the system prompt are replaced by the
+    stable :data:`STABLE_PLACEHOLDER`; a mid-run system edit is pinned to the
+    first call's system text; tool order is restored to first-seen order;
+    ``cache_breakpoints=1`` where it was 0. ``model-switch`` and
+    ``history-rewrite`` have no mechanical repair (rewriting content or
+    models would change semantics) and leave the calls untouched. Content
+    semantics are never mutated otherwise; billed ``usage`` is preserved so
+    the fixed-cache simulation still scales to real billed totals.
+    """
+    kinds = {breaker.kind for breaker in breakers}
+    calls = list(run.calls)
+    if "tool-churn" in kinds:
+        first_seen: dict[str, int] = {}
+        for call in calls:
+            for tool in call.tools:
+                first_seen.setdefault(canonical_json(tool), len(first_seen))
+        calls = [
+            replace(
+                call,
+                tools=tuple(sorted(call.tools, key=lambda t: first_seen[canonical_json(t)])),
+            )
+            for call in calls
+        ]
+    if "volatile-system" in kinds:
+        calls = [replace(call, system=_stabilized(call.system)) for call in calls]
+    if "system-edit" in kinds and calls:
+        calls = [replace(call, system=calls[0].system) for call in calls]
+    if "missing-breakpoint" in kinds:
+        calls = [
+            replace(call, cache_breakpoints=1) if call.cache_breakpoints == 0 else call
+            for call in calls
+        ]
+    return calls