most of your input tokens sit in the 200k-1M band

"""Report Claude workloads whose input has grown into the 200k-1M band.

Read only. GET requests and nothing else: ANTHROPIC_ADMIN_KEY must be an Admin
API key (sk-ant-admin...), which can be provisioned read-only. A workspace key
is rejected by every /v1/organizations/* path.

This is a SIZE alarm and not a price alarm. On current models the 1M context
window is the default, no beta header is involved, and long-context requests
bill at standard rates. The old belief that crossing 200k triggers premium
pricing came from a retired beta and is not true now.

What the band measures is a prefix that grows every turn: expensive because it
is enormous at an ordinary rate, and inaccurate because the window fills. The
repair is compaction first and caching second, and it is printed, because both
are application changes.
"""
import argparse
import datetime as dt
import logging
import os
import sys

import requests

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger("anthropic_long_context_audit")

API = "https://api.anthropic.com/v1"
VERSION = "2023-06-01"

SHORT_BAND = "0-200k"
LONG_BAND = "200k-1M"
UNBANDED = "unbanded"

FINDINGS = ("long-context-uncached",)


def band(result):
    """Normalise the context_window value. Pure.

    A null becomes "unbanded", never "0-200k". Folding unbanded traffic into the
    short band deflates the long share and turns a real finding into a
    comfortable number, which is the one outcome this whole check exists to
    prevent.
    """
    raw = str((result or {}).get("context_window") or "").strip().lower()
    if raw == LONG_BAND.lower():
        return LONG_BAND
    if raw == SHORT_BAND.lower():
        return SHORT_BAND
    return UNBANDED


def fold(pages):
    """Sum input tokens into {model: {band: {uncached, cache_read}}}. Pure."""
    out = {}
    for page in pages:
        for bucket in page.get("data") or []:
            for result in bucket.get("results") or []:
                model = str(result.get("model") or "all models")
                where = band(result)
                row = out.setdefault(model, {}).setdefault(
                    where, {"uncached": 0, "cache_read": 0})
                for field, key in (("uncached_input_tokens", "uncached"),
                                   ("cache_read_input_tokens", "cache_read")):
                    try:
                        row[key] += int(result.get(field) or 0)
                    except (TypeError, ValueError):
                        pass
    return out


def long_share(model_rows):
    """Share of BANDED uncached input sitting in the 200k-1M band. Pure.

    Banded only. Unbanded traffic cannot be placed on either side, and putting
    it in the denominator would make a workload look shorter than it is purely
    because the report declined to classify some of it.
    """
    rows = model_rows or {}
    short = int((rows.get(SHORT_BAND) or {}).get("uncached") or 0)
    long_ = int((rows.get(LONG_BAND) or {}).get("uncached") or 0)
    banded = short + long_
    if banded <= 0:
        return 0.0
    return long_ / float(banded)


def cached_share(row):
    """Share of a band's input that was read back from cache. Pure.

    Grades severity, not diagnosis: a cached long prefix costs a tenth as much
    and is exactly as long, so it fixes the money and none of the accuracy.
    """
    data = row or {}
    reads = int(data.get("cache_read") or 0)
    uncached = int(data.get("uncached") or 0)
    total = reads + uncached
    if total <= 0:
        return 0.0
    return reads / float(total)


def uncached_cost(tokens, rate_per_mtok):
    """Dollars for a number of uncached input tokens. Pure.

    The rate is passed in rather than baked into a table. A price table in an
    audit script is a fact with an expiry date on it, and nothing warns you the
    day it passes.
    """
    if rate_per_mtok < 0:
        raise ValueError("rate_per_mtok must not be negative")
    return max(0, int(tokens or 0)) / 1e6 * float(rate_per_mtok)


def verdict(model_rows, min_tokens=10_000_000, long_threshold=0.25,
            cache_floor=0.30):
    """Classify one model's context profile. Pure. Returns (state, detail)."""
    rows = model_rows or {}
    banded = sum(int((rows.get(b) or {}).get("uncached") or 0)
                 for b in (SHORT_BAND, LONG_BAND))
    unbanded = int((rows.get(UNBANDED) or {}).get("uncached") or 0)
    total = banded + unbanded

    if total < min_tokens:
        return ("low-volume",
                "%d uncached input token(s) in the window, too few to conclude "
                "anything" % total)
    if banded <= 0:
        return ("unbanded-only",
                "%.1fM uncached input token(s) with no context_window on any "
                "result, so this traffic cannot be placed in a band at all"
                % (unbanded / 1e6))

    share = long_share(rows)
    long_row = rows.get(LONG_BAND) or {}
    cached = cached_share(long_row)
    shape = ("%.0f%% of banded uncached input is %s, with %.0f%% of that band "
             "read from cache" % (share * 100, LONG_BAND, cached * 100))

    if share < long_threshold:
        return ("short-context",
                "%s. The prefix is not where the money is going here." % shape)
    if cached >= cache_floor:
        return ("long-context-cached",
                "%s. The big prefix is being read back rather than reprocessed, "
                "so it costs a tenth of full rate. It is still just as long, "
                "and length is what degrades the answer." % shape)
    return ("long-context-uncached",
            "%s. A very large prefix reprocessed from scratch on every call. "
            "Standard rates, extraordinary volume." % shape)


def get(session, path, params):
    r = session.get(API + path, params=params, timeout=60)
    if r.status_code in (401, 403):
        raise SystemExit("%d from Anthropic: /v1/organizations/* needs an Admin "
                         "API key (sk-ant-admin...), not a workspace key"
                         % r.status_code)
    r.raise_for_status()
    return r.json()


def pages(session, path, params):
    """Walk the paginated usage report."""
    params = dict(params)
    while True:
        page = get(session, path, params)
        yield page
        if not page.get("has_more") or not page.get("next_page"):
            return
        params["page"] = page["next_page"]


def window_start(days):
    """Floor to midnight UTC: starting_at must sit on a bucket boundary."""
    now = dt.datetime.now(dt.timezone.utc)
    midnight = now.replace(hour=0, minute=0, second=0, microsecond=0)
    return (midnight - dt.timedelta(days=days)).strftime("%Y-%m-%dT%H:%M:%SZ")


def main():
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--days", type=int, default=30,
                    help="days of daily buckets to read (default 30)")
    ap.add_argument("--input-rate", type=float, default=5.0,
                    help="dollars per million uncached input tokens, for the "
                         "printed estimate only (default 5.0)")
    ap.add_argument("--min-tokens", type=int, default=10_000_000,
                    help="uncached input tokens below which no claim is made")
    args = ap.parse_args()

    admin = os.environ.get("ANTHROPIC_ADMIN_KEY")
    if not admin:
        log.error("set ANTHROPIC_ADMIN_KEY to an Admin API key (sk-ant-admin...); "
                  "a workspace key cannot read /v1/organizations/*")
        return 2

    s = requests.Session()
    s.headers.update({"x-api-key": admin, "anthropic-version": VERSION})

    rows = fold(pages(s, "/organizations/usage_report/messages",
                      {"starting_at": window_start(args.days),
                       "bucket_width": "1d", "limit": min(args.days + 1, 31),
                       "group_by[]": ["context_window", "model"]}))

    checked = 0
    bad = 0
    for model in sorted(rows, key=lambda m: -((rows[m].get(LONG_BAND) or {})
                                              .get("uncached") or 0)):
        state, detail = verdict(rows[model], args.min_tokens)
        checked += 1
        line = "%-22s %-22s %s" % (state, model, detail)

        if state == "long-context-cached":
            log.warning(line)
            log.warning("  note: caching fixed the price and not the length. "
                        "Compaction is still the lever for answer quality.")
            continue
        if state not in FINDINGS:
            log.info(line)
            continue

        bad += 1
        log.warning(line)
        tokens = (rows[model].get(LONG_BAND) or {}).get("uncached") or 0
        log.warning("  %.1fM uncached token(s) in the band, about $%.2f at "
                    "$%.2f per million", tokens / 1e6,
                    uncached_cost(tokens, args.input_rate), args.input_rate)
        log.warning("  repair: compact or edit the context on the routes "
                    "generating 200k+ prefixes, then put a cache_control "
                    "breakpoint on whatever stays stable. In that order.")
        log.warning("  note: this band is not a premium price tier. It is "
                    "standard rates on a very large number of tokens.")

    unbanded = sum((rows[m].get(UNBANDED) or {}).get("uncached") or 0 for m in rows)
    if unbanded:
        log.info("%.1fM uncached token(s) carried no context_window and were "
                 "excluded from every share above", unbanded / 1e6)

    log.info("%d model(s) checked, %d finding(s)", checked, bad)
    return 1 if bad else 0


if __name__ == "__main__":
    sys.exit(main())

/**
 * Report Claude workloads whose input has grown into the 200k-1M band.
 *
 * Read only. GET requests and nothing else against the Admin API, which needs
 * an Admin API key (sk-ant-admin...); a workspace key is rejected by every
 * /v1/organizations/* path.
 *
 * A SIZE alarm and not a price alarm. On current models the 1M window is the
 * default, no beta header is involved, and long-context requests bill at
 * standard rates. What the band measures is a prefix that grows every turn.
 * The repair is compaction first, caching second, and it is printed.
 */
const API = 'https://api.anthropic.com/v1';
const VERSION = '2023-06-01';

const SHORT_BAND = '0-200k';
const LONG_BAND = '200k-1M';
const UNBANDED = 'unbanded';

const FINDINGS = ['long-context-uncached'];

/**
 * Normalise the context_window value. Pure.
 * A null becomes "unbanded", never "0-200k": folding unbanded traffic into the
 * short band deflates the long share and turns a real finding into a
 * comfortable number.
 */
export function band(result) {
  const raw = String(result?.context_window ?? '').trim().toLowerCase();
  if (raw === LONG_BAND.toLowerCase()) return LONG_BAND;
  if (raw === SHORT_BAND.toLowerCase()) return SHORT_BAND;
  return UNBANDED;
}

/** Sum input tokens into {model: {band: {uncached, cache_read}}}. Pure. */
export function fold(pages) {
  const out = {};
  for (const page of pages ?? []) {
    for (const bucket of page.data ?? []) {
      for (const result of bucket.results ?? []) {
        const model = String(result.model ?? 'all models');
        const where = band(result);
        if (!out[model]) out[model] = {};
        if (!out[model][where]) out[model][where] = { uncached: 0, cache_read: 0 };
        const row = out[model][where];
        for (const [field, key] of [['uncached_input_tokens', 'uncached'],
                                    ['cache_read_input_tokens', 'cache_read']]) {
          const n = Number(result[field] ?? 0);
          if (Number.isFinite(n)) row[key] += Math.trunc(n);
        }
      }
    }
  }
  return out;
}

/**
 * Share of BANDED uncached input sitting in the 200k-1M band. Pure.
 * Banded only: unbanded traffic cannot be placed on either side, and putting it
 * in the denominator makes a workload look shorter than it is.
 */
export function longShare(modelRows) {
  const rows = modelRows ?? {};
  const short = Number(rows[SHORT_BAND]?.uncached ?? 0) || 0;
  const long = Number(rows[LONG_BAND]?.uncached ?? 0) || 0;
  const banded = short + long;
  if (banded <= 0) return 0;
  return long / banded;
}

/**
 * Share of a band's input read back from cache. Pure. Grades severity, not
 * diagnosis: a cached long prefix costs a tenth and is exactly as long.
 */
export function cachedShare(row) {
  const reads = Number(row?.cache_read ?? 0) || 0;
  const uncached = Number(row?.uncached ?? 0) || 0;
  const total = reads + uncached;
  if (total <= 0) return 0;
  return reads / total;
}

/**
 * Dollars for a number of uncached input tokens. Pure. The rate is passed in
 * rather than baked into a table: a price table in an audit script is a fact
 * with an expiry date and nothing warns you the day it passes.
 */
export function uncachedCost(tokens, ratePerMtok) {
  if (ratePerMtok < 0) throw new Error('ratePerMtok must not be negative');
  return Math.max(0, Math.trunc(Number(tokens ?? 0))) / 1e6 * Number(ratePerMtok);
}

/** Classify one model's context profile. Pure. Returns [state, detail]. */
export function verdict(modelRows, minTokens = 10000000, longThreshold = 0.25,
                        cacheFloor = 0.30) {
  const rows = modelRows ?? {};
  const banded = [SHORT_BAND, LONG_BAND]
    .reduce((a, b) => a + (Number(rows[b]?.uncached ?? 0) || 0), 0);
  const unbanded = Number(rows[UNBANDED]?.uncached ?? 0) || 0;
  const total = banded + unbanded;

  if (total < minTokens) {
    return ['low-volume',
      `${total} uncached input token(s) in the window, too few to conclude anything`];
  }
  if (banded <= 0) {
    return ['unbanded-only',
      `${(unbanded / 1e6).toFixed(1)}M uncached input token(s) with no ` +
      'context_window on any result, so this traffic cannot be placed in a band at all'];
  }

  const share = longShare(rows);
  const cached = cachedShare(rows[LONG_BAND]);
  const shape = `${(share * 100).toFixed(0)}% of banded uncached input is ` +
                `${LONG_BAND}, with ${(cached * 100).toFixed(0)}% of that band ` +
                'read from cache';

  if (share < longThreshold) {
    return ['short-context',
      `${shape}. The prefix is not where the money is going here.`];
  }
  if (cached >= cacheFloor) {
    return ['long-context-cached',
      `${shape}. The big prefix is being read back rather than reprocessed, so ` +
      'it costs a tenth of full rate. It is still just as long, and length is ' +
      'what degrades the answer.'];
  }
  return ['long-context-uncached',
    `${shape}. A very large prefix reprocessed from scratch on every call. ` +
    'Standard rates, extraordinary volume.'];
}

async function get(key, path, params) {
  const url = new URL(API + path);
  for (const [k, v] of Object.entries(params)) {
    if (Array.isArray(v)) for (const item of v) url.searchParams.append(k, String(item));
    else if (v !== undefined && v !== null) url.searchParams.set(k, String(v));
  }
  const res = await fetch(url, {
    headers: { 'x-api-key': key, 'anthropic-version': VERSION },
  });
  if (res.status === 401 || res.status === 403) {
    throw new Error(`${res.status} from Anthropic: /v1/organizations/* needs an ` +
                    'Admin API key (sk-ant-admin...), not a workspace key');
  }
  if (!res.ok) throw new Error(`${res.status} from ${path}`);
  return res.json();
}

async function readPages(key, path, params) {
  const out = [];
  let next = { ...params };
  for (;;) {
    const page = await get(key, path, next);
    out.push(page);
    if (!page.has_more || !page.next_page) return out;
    next = { ...next, page: page.next_page };
  }
}

/** Floor to midnight UTC: starting_at must sit on a bucket boundary. */
function windowStart(days) {
  const midnight = new Date();
  midnight.setUTCHours(0, 0, 0, 0);
  midnight.setUTCDate(midnight.getUTCDate() - days);
  return midnight.toISOString().replace(/\.\d{3}Z$/, 'Z');
}

async function main() {
  const key = process.env.ANTHROPIC_ADMIN_KEY;
  if (!key) {
    console.error('set ANTHROPIC_ADMIN_KEY to an Admin API key (sk-ant-admin...); ' +
                  'a workspace key cannot read /v1/organizations/*');
    process.exitCode = 2;
    return;
  }

  const days = Number(process.env.DAYS ?? 30);
  const inputRate = Number(process.env.INPUT_RATE ?? 5.0);
  const minTokens = Number(process.env.MIN_TOKENS ?? 10000000);

  const rows = fold(await readPages(key, '/organizations/usage_report/messages', {
    starting_at: windowStart(days), bucket_width: '1d',
    limit: Math.min(days + 1, 31),
    'group_by[]': ['context_window', 'model'],
  }));

  let checked = 0;
  let bad = 0;
  const models = Object.keys(rows).sort(
    (a, b) => (rows[b][LONG_BAND]?.uncached ?? 0) - (rows[a][LONG_BAND]?.uncached ?? 0));
  for (const model of models) {
    const [state, detail] = verdict(rows[model], minTokens);
    checked += 1;
    const line = `${state.padEnd(22)} ${model.padEnd(22)} ${detail}`;

    if (state === 'long-context-cached') {
      console.warn(line);
      console.warn('  note: caching fixed the price and not the length. ' +
                   'Compaction is still the lever for answer quality.');
      continue;
    }
    if (!FINDINGS.includes(state)) {
      console.log(line);
      continue;
    }

    bad += 1;
    console.warn(line);
    const tokens = rows[model][LONG_BAND]?.uncached ?? 0;
    console.warn(`  ${(tokens / 1e6).toFixed(1)}M uncached token(s) in the band, ` +
                 `about $${uncachedCost(tokens, inputRate).toFixed(2)} at ` +
                 `$${inputRate.toFixed(2)} per million`);
    console.warn('  repair: compact or edit the context on the routes generating ' +
                 '200k+ prefixes, then put a cache_control breakpoint on whatever ' +
                 'stays stable. In that order.');
    console.warn('  note: this band is not a premium price tier. It is standard ' +
                 'rates on a very large number of tokens.');
  }

  const unbanded = Object.values(rows)
    .reduce((a, r) => a + (r[UNBANDED]?.uncached ?? 0), 0);
  if (unbanded) {
    console.log(`${(unbanded / 1e6).toFixed(1)}M uncached token(s) carried no ` +
                'context_window and were excluded from every share above');
  }

  console.log(`${checked} model(s) checked, ${bad} finding(s)`);
  process.exitCode = bad ? 1 : 0;
}

// Only run when invoked directly, so importing this module from the test file
// does not fire main() and fail on the missing key.
if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch((err) => { console.error(err.message); process.exitCode = 2; });
}

from anthropic_long_context_audit import (band, cached_share, fold,
                                           long_share, uncached_cost, verdict)


def result(window="200k-1M", model="claude-opus-5", uncached=400_000_000,
           cache_read=0):
    """One result from the messages usage report."""
    return {"context_window": window, "model": model,
            "uncached_input_tokens": uncached,
            "cache_read_input_tokens": cache_read}


def page(*results):
    return {"data": [{"starting_at": "2026-08-01T00:00:00Z",
                      "results": list(results)}], "has_more": False}


def rows(long_uncached=400_000_000, long_read=0, short_uncached=160_000_000,
         unbanded=0):
    """A folded model row shaped like fold() returns them."""
    out = {"200k-1M": {"uncached": long_uncached, "cache_read": long_read},
           "0-200k": {"uncached": short_uncached, "cache_read": 0}}
    if unbanded:
        out["unbanded"] = {"uncached": unbanded, "cache_read": 0}
    return out


def test_a_null_context_window_is_unbanded_and_not_the_short_band():
    # The load-bearing one. 400M long against 160M short is 71%. Counting a
    # further 400M of unbanded traffic as short would report 41% and nothing
    # would ever be looked at.
    assert band({"context_window": None}) == "unbanded"
    assert band({}) == "unbanded"
    assert band({"context_window": "200k-1M"}) == "200k-1M"
    assert band({"context_window": "0-200k"}) == "0-200k"
    with_nulls = rows(unbanded=400_000_000)
    assert abs(long_share(with_nulls) - 400 / 560) < 1e-9
    state, detail = verdict(with_nulls)
    assert state == "long-context-uncached"
    assert "71% of banded uncached input" in detail


def test_a_cached_long_prefix_is_a_different_state_with_a_different_sentence():
    state, detail = verdict(rows(long_uncached=40_000_000,
                                 long_read=360_000_000,
                                 short_uncached=10_000_000))
    assert state == "long-context-cached"
    assert "It is still just as long" in detail


def test_a_short_context_workload_is_not_a_finding():
    assert verdict(rows(long_uncached=10_000_000,
                        short_uncached=400_000_000))[0] == "short-context"
    assert verdict(rows(long_uncached=100, short_uncached=100))[0] == "low-volume"


def test_traffic_the_report_never_banded_is_reported_as_such():
    state, detail = verdict({"unbanded": {"uncached": 400_000_000, "cache_read": 0}})
    assert state == "unbanded-only"
    assert "cannot be placed in a band" in detail


def test_the_cached_share_is_read_inside_the_band():
    assert cached_share({"uncached": 0, "cache_read": 100}) == 1.0
    assert cached_share({"uncached": 100, "cache_read": 0}) == 0.0
    assert cached_share({"uncached": 50, "cache_read": 50}) == 0.5
    assert cached_share({}) == 0.0


def test_the_rate_is_supplied_rather_than_baked_in():
    # 408M uncached input tokens at $5 per million.
    assert uncached_cost(408_000_000, 5.0) == 2040.0
    assert uncached_cost(0, 5.0) == 0.0
    assert uncached_cost(1_000_000, 0.0) == 0.0


def test_folding_keeps_models_and_bands_apart():
    folded = fold([page(result(window="200k-1M", uncached=200_000_000),
                        result(window="200k-1M", uncached=200_000_000,
                               cache_read=5_000_000),
                        result(window="0-200k", uncached=160_000_000),
                        result(window=None, model="claude-haiku-4-5-20251001",
                               uncached=9_000_000))])
    assert folded["claude-opus-5"]["200k-1M"]["uncached"] == 400_000_000
    assert folded["claude-opus-5"]["200k-1M"]["cache_read"] == 5_000_000
    assert folded["claude-opus-5"]["0-200k"]["uncached"] == 160_000_000
    assert folded["claude-haiku-4-5-20251001"]["unbanded"]["uncached"] == 9_000_000

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { band, cachedShare, fold, longShare, uncachedCost, verdict }
  from './anthropic-long-context-audit.mjs';

/** One result from the messages usage report. */
function result({ window = '200k-1M', model = 'claude-opus-5',
                  uncached = 400000000, cacheRead = 0 } = {}) {
  return {
    context_window: window, model,
    uncached_input_tokens: uncached, cache_read_input_tokens: cacheRead,
  };
}

function page(...results) {
  return { data: [{ starting_at: '2026-08-01T00:00:00Z', results }], has_more: false };
}

/** A folded model row shaped like fold() returns them. */
function rows({ longUncached = 400000000, longRead = 0,
                shortUncached = 160000000, unbanded = 0 } = {}) {
  const out = {
    '200k-1M': { uncached: longUncached, cache_read: longRead },
    '0-200k': { uncached: shortUncached, cache_read: 0 },
  };
  if (unbanded) out.unbanded = { uncached: unbanded, cache_read: 0 };
  return out;
}

test('a null context_window is unbanded and not the short band', () => {
  assert.equal(band({ context_window: null }), 'unbanded');
  assert.equal(band({}), 'unbanded');
  assert.equal(band({ context_window: '200k-1M' }), '200k-1M');
  assert.equal(band({ context_window: '0-200k' }), '0-200k');
  const withNulls = rows({ unbanded: 400000000 });
  assert.ok(Math.abs(longShare(withNulls) - 400 / 560) < 1e-9);
  const [state, detail] = verdict(withNulls);
  assert.equal(state, 'long-context-uncached');
  assert.match(detail, /71% of banded uncached input/);
});

test('a cached long prefix is a different state with a different sentence', () => {
  const [state, detail] = verdict(rows({ longUncached: 40000000,
                                         longRead: 360000000,
                                         shortUncached: 10000000 }));
  assert.equal(state, 'long-context-cached');
  assert.match(detail, /It is still just as long/);
});

test('a short context workload is not a finding', () => {
  assert.equal(verdict(rows({ longUncached: 10000000, shortUncached: 400000000 }))[0],
               'short-context');
  assert.equal(verdict(rows({ longUncached: 100, shortUncached: 100 }))[0], 'low-volume');
});

test('traffic the report never banded is reported as such', () => {
  const [state, detail] = verdict({ unbanded: { uncached: 400000000, cache_read: 0 } });
  assert.equal(state, 'unbanded-only');
  assert.match(detail, /cannot be placed in a band/);
});

test('the cached share is read inside the band', () => {
  assert.equal(cachedShare({ uncached: 0, cache_read: 100 }), 1);
  assert.equal(cachedShare({ uncached: 100, cache_read: 0 }), 0);
  assert.equal(cachedShare({ uncached: 50, cache_read: 50 }), 0.5);
  assert.equal(cachedShare({}), 0);
});

test('the rate is supplied rather than baked in', () => {
  assert.equal(uncachedCost(408000000, 5.0), 2040);
  assert.equal(uncachedCost(0, 5.0), 0);
  assert.equal(uncachedCost(1000000, 0), 0);
});

test('folding keeps models and bands apart', () => {
  const folded = fold([page(
    result({ window: '200k-1M', uncached: 200000000 }),
    result({ window: '200k-1M', uncached: 200000000, cacheRead: 5000000 }),
    result({ window: '0-200k', uncached: 160000000 }),
    result({ window: null, model: 'claude-haiku-4-5-20251001', uncached: 9000000 }),
  )]);
  assert.equal(folded['claude-opus-5']['200k-1M'].uncached, 400000000);
  assert.equal(folded['claude-opus-5']['200k-1M'].cache_read, 5000000);
  assert.equal(folded['claude-opus-5']['0-200k'].uncached, 160000000);
  assert.equal(folded['claude-haiku-4-5-20251001'].unbanded.uncached, 9000000);
});