File size: 22,087 Bytes
b48ae75
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
"""Native CLI counters and provider usage at trusted evaluation completion boundaries."""
import threading
import json
import os
import time
import uuid
import urllib.request
import urllib.error
from urllib.parse import urlsplit


FIELDS = ("input_tokens", "uncached_input_tokens", "cache_read_tokens", "cache_write_tokens",
          "output_tokens", "reasoning_tokens", "total_tokens")


def number(value):
    return value if type(value) is int and value >= 0 else None


def normalized(raw, kind):
    if kind == "claude":
        uncached = number(raw.get("input_tokens", raw.get("inputTokens")))
        read = number(raw.get("cache_read_input_tokens", raw.get("cacheReadInputTokens")))
        write = number(raw.get("cache_creation_input_tokens", raw.get("cacheCreationInputTokens")))
        inp = uncached + read + write if None not in (uncached, read, write) else None
        out = number(raw.get("output_tokens", raw.get("outputTokens")))
        reason = number(raw.get("reasoning_tokens"))
    elif kind == "codex":
        inp, out = number(raw.get("input_tokens")), number(raw.get("output_tokens"))
        read, write = number(raw.get("cached_input_tokens")), number(raw.get("cache_write_input_tokens"))
        uncached = inp - read if None not in (inp, read) and inp >= read else None
        reason = number(raw.get("reasoning_output_tokens"))
    elif kind == "opencode":
        uncached = number(raw.get("input"))
        read, write = number(raw.get("cache", {}).get("read")), number(raw.get("cache", {}).get("write"))
        inp = uncached + read + write if None not in (uncached, read, write) else None
        # OpenCode v1.2.27 getUsage stores outputTokens INCLUDING reasoningTokens.
        # Preserve reasoning as a breakdown, never add it a second time.
        out, reason = number(raw.get("output")), number(raw.get("reasoning"))
    else:
        return {k: number(raw.get(k)) for k in FIELDS}
    total = inp + out if inp is not None and out is not None else None
    return dict(zip(FIELDS, (inp, uncached, read, write, out, reason, total)))


def total(rows):
    rows = list(rows)
    return {k: sum(r[k] for r in rows) if rows and all(r[k] is not None for r in rows) else None
            for k in FIELDS}


class UsageLedger:
    """Versioned native formats with conservative checkpoint coverage.

    Claude: finalized stream message usage, reconciled against native result.
    Codex: turn.completed contains turn aggregate, NOT per model response usage.
    OpenCode: step_finish tokens, reconciled with `export SESSION_ID` at exit.
    """
    def __init__(self, kind):
        self.kind = kind
        self.lock = threading.RLock()
        self.rows, self.raw_rows = {}, {}
        self.open_messages, self.current = {}, {}
        self.session_id = None
        self.models = set()
        self.terminal = None
        self.terminal_source = None
        self.terminal_error = False
        self.child_seen = False
        self.stream_errors = []
        self.native_warnings = []
        self.codex_turn = 0
        self.version = None
        self.meter_url = os.environ.get("NATIVE_BENCH_USAGE_URL", "")
        self.meter_token = os.environ.get("NATIVE_BENCH_USAGE_TOKEN", "")
        self.meter_epoch = None
        self.completion_checkpoints = []
        self.last_transport_receipt = None

    def reset_meter(self):
        if not self.meter_url:
            return
        parts = urlsplit(self.meter_url)
        if parts.scheme != "http" or parts.hostname not in ("127.0.0.1", "localhost", "::1") or parts.username or parts.query or parts.fragment:
            raise ValueError("completion usage meter must share the local monotonic clock")
        request = urllib.request.Request(self.meter_url, data=b"{}", method="POST",
            headers={"Authorization": "Bearer " + self.meter_token, "Content-Type": "application/json"})
        with urllib.request.urlopen(request, timeout=5) as response:
            self.meter_epoch = json.load(response)["epoch"]

    def completion_checkpoint(self, at_ns=None, kind=None):
        at_ns = time.monotonic_ns() if at_ns is None else at_ns
        result = {"available": False, "cumulative_tokens": None, "as_of_ns": at_ns,
                  "reason": "run-scoped model transport meter is not configured", "epoch": self.meter_epoch}
        if self.meter_url:
            try:
                request = urllib.request.Request(self.meter_url + "?at_ns=" + str(at_ns),
                    headers={"Authorization": "Bearer " + self.meter_token})
                with urllib.request.urlopen(request, timeout=5) as response:
                    result = json.load(response)
                if result.get("epoch") != self.meter_epoch:
                    raise ValueError("transport meter epoch changed")
                result = transport_snapshot(result["records"], at_ns, result["epoch"])
                with self.lock:
                    if self.last_transport_receipt is None or at_ns >= self.last_transport_receipt["as_of_ns"]:
                        self.last_transport_receipt = result
            except (OSError, ValueError, KeyError, TypeError) as exc:
                result = {"available": False, "cumulative_tokens": None, "as_of_ns": at_ns,
                          "reason": "transport usage unavailable: " + type(exc).__name__, "epoch": self.meter_epoch}
        if kind in ("baseline", "candidate"):
            with self.lock:
                self.completion_checkpoints.append({"kind": kind, **{k: v for k, v in result.items() if k != "records"}})
        return result

    def consume(self, record):
        with self.lock:
            try:
                self._consume(record)
            except (KeyError, TypeError, ValueError) as exc:
                self.stream_errors.append(type(exc).__name__ + ": " + str(exc))

    def _consume(self, r):
        typ = r.get("type")
        if self.kind == "claude":
            if typ == "system" and r.get("subtype") == "init":
                self.session_id = r.get("session_id")
                self.version = r.get("claude_code_version")
                if r.get("model"):
                    self.models.add(r["model"])
            if r.get("parent_tool_use_id"):
                self.child_seen = True
            if typ == "stream_event":
                e = r["event"]
                lane = (r.get("session_id"), r.get("parent_tool_use_id"))
                if e["type"] == "message_start":
                    msg = e["message"]
                    key = str((lane, msg["id"]))
                    self.current[lane] = key
                    self.open_messages[key] = dict(msg.get("usage", {}))
                    if msg.get("model"):
                        self.models.add(msg["model"])
                elif e["type"] == "message_delta" and lane in self.current:
                    self.open_messages[self.current[lane]].update(e.get("usage", {}))
                elif e["type"] == "message_stop" and lane in self.current:
                    key = self.current.pop(lane)
                    raw = self.open_messages.pop(key)
                    self.raw_rows[key] = raw
                    self.rows[key] = normalized(raw, self.kind)
            if typ == "result":
                models = r.get("modelUsage") or {}
                self.models.update(models)
                if models:
                    self.terminal = total(normalized(v, self.kind) for v in models.values())
                    self.terminal_source = "claude.result.modelUsage"
                elif not self.child_seen:
                    self.terminal = normalized(r.get("usage") or {}, self.kind)
                    self.terminal_source = "claude.result.usage (main loop)"
                self.terminal_error = bool(r.get("is_error"))
        elif self.kind == "codex":
            if typ == "thread.started":
                self.session_id = r.get("thread_id")
            if typ == "turn.started":
                self.codex_turn += 1
            if typ == "turn.completed":
                key = r.get("turn_id") or f"turn-{self.codex_turn}"
                self.raw_rows[key] = r.get("usage") or {}
                self.rows[key] = normalized(self.raw_rows[key], self.kind)
                self.terminal = total(self.rows.values())
                self.terminal_source = "codex.exec.turn.completed.usage"
            if typ == "turn.failed":
                self.terminal_error = True
            elif typ == "error":
                # Codex also emits type=error for retry/reconnect notifications.
                # Only a failed turn / missing final usage / process failure is
                # terminal. Preserve warnings rather than discard a later native
                # turn.completed report. This is NOT a provider billing audit.
                self.native_warnings.append(r)
        elif self.kind == "opencode":
            if r.get("sessionID"):
                self.session_id = r["sessionID"]
            if typ == "step_finish":
                part = r["part"]
                key = part["id"]
                self.raw_rows[key] = part["tokens"]
                self.rows[key] = normalized(part["tokens"], self.kind)
            if typ == "tool_use" and r.get("part", {}).get("tool") == "task":
                self.child_seen = True
            if typ == "error":
                self.terminal_error = True
        elif self.kind == "custom" and typ == "benchmark.usage":
            # An external CLI adapter may emit native counts with a stable ID.
            key = r["usage_id"]
            self.raw_rows[key] = r["usage"]
            self.rows[key] = normalized(r["usage"], "custom")
            if r.get("final"):
                self.terminal = total(self.rows.values())
                self.terminal_source = "custom.command.native_usage"

    def consume_export(self, data):
        """OpenCode's own per-session export; never account-wide stats subtraction."""
        with self.lock:
            info = data.get("info", {})
            if info.get("id") != self.session_id:
                raise ValueError("OpenCode export session identity mismatch")
            found = {}
            for message in data.get("messages", []):
                m = message.get("info", {})
                if m.get("role") == "assistant":
                    if m.get("modelID"):
                        self.models.add(m["modelID"])
                    found[m["id"]] = normalized(m.get("tokens") or {}, "opencode")
            self.terminal = total(found.values())
            self.terminal_source = "opencode.export.session.assistant.tokens"

    def checkpoint(self):
        with self.lock:
            observed = total(self.rows.values())
            provisional = (self.kind in ("claude", "opencode", "custom") and bool(self.rows)
                           and not self.open_messages and not self.child_seen and not self.stream_errors
                           and observed["total_tokens"] is not None)
            return {"observed": observed, "provisional": provisional,
                    "cumulative_tokens": observed["total_tokens"] if provisional else None,
                    "usage_record_ids": sorted(self.rows),
                    "reason": "native stream counters; require final reconciliation" if provisional else
                              "per-submission native usage is not observable or complete"}

    def report(self, completed):
        transport = self.completion_checkpoint() if self.meter_url else None
        with self.lock:
            observed = total(self.rows.values())
            end = self.terminal
            if self.kind == "opencode" and end is None and completed and not self.child_seen:
                end = observed
                source = "opencode.run.step_finish.tokens"
            else:
                source = self.terminal_source
            available = bool(completed and not self.terminal_error and end and
                             end["total_tokens"] is not None and not self.stream_errors and
                             not (self.kind == "opencode" and self.child_seen))
            reconciled = bool(available and end["total_tokens"] == observed["total_tokens"] and
                              not self.open_messages and not self.child_seen and self.kind != "codex")
            report = {"available": available, "total": end if end else {k: None for k in FIELDS},
                    "source": source, "observed_stream_subtotal": observed,
                    "submission_checkpoints_reconciled": reconciled,
                    "submission_checkpoints_usable": False,
                    "checkpoint_limitation": "No causal native usage-to-evaluation binding; receive-time subtotals are not exact submission token counts.",
                    "session_id": self.session_id, "models_observed": sorted(self.models),
                    "native_usage_records": len(self.rows), "child_activity_seen": self.child_seen,
                    "observed_model_request_count": len(self.rows) if self.kind in ("claude", "opencode") and not self.child_seen and not self.open_messages and not self.stream_errors and completed else None,
                    "native_turn_count": self.codex_turn if self.kind == "codex" else None,
                    "errors": list(self.stream_errors),
                    "native_warnings": list(self.native_warnings),
                    "note": "Counts reported by native CLI, not independently measured provider billing. Unknown stays null."}
            if transport is not None:
                proof = self.last_transport_receipt
                checkpoints = [reconcile_completion(c, proof) for c in self.completion_checkpoints]
                candidates = [c for c in checkpoints if c["kind"] == "candidate"]
                usable = bool(candidates and all(c["available"] for c in candidates))
                report.update(native_cli_total=report["total"], available=transport["available"],
                    total=transport.get("total", {k: None for k in FIELDS}),
                    source="provider.transport.usage", transport_receipt=transport,
                    completion_checkpoints=checkpoints,
                    submission_checkpoints_reconciled=usable,
                    submission_checkpoints_usable=usable,
                    checkpoint_limitation=None if usable else
                        "a candidate completion has missing usage, active requests, or no covering transport receipt",
                    note="Candidate completion counts and whole-session totals have separate availability; no token estimates.")
                if proof is not None and proof is not transport:
                    report["completion_receipt"] = proof
            return report



def transport_snapshot(records, at_ns, epoch):
    if type(at_ns) is not int or at_ns < 0 or not isinstance(records, list):
        raise ValueError("invalid transport snapshot")
    selected, errors, seen = [], [], set()
    for record in records:
        rid, started, finished = record["request_id"], record["started_ns"], record["finished_ns"]
        if type(rid) is not int or rid < 1 or rid in seen or type(started) is not int or started < 0:
            raise ValueError("invalid transport request identity or start")
        seen.add(rid)
        if finished is not None and (type(finished) is not int or finished < started):
            raise ValueError("invalid transport completion")
        if started > at_ns:
            continue
        if finished is None or finished > at_ns:
            errors.append("model request active at completion boundary")
            continue
        usage = record.get("usage")
        if not isinstance(usage, dict) or number(usage.get("total_tokens")) is None:
            errors.append("provider usage missing for a completed request")
            continue
        inp, out, count = usage.get("input_tokens"), usage.get("output_tokens"), usage["total_tokens"]
        if inp is not None and out is not None and count != inp + out:
            raise ValueError("inconsistent provider token totals")
        if any(v is not None and (number(v) is None or v > count) for v in (inp, out)):
            raise ValueError("inconsistent provider token breakdown")
        if any(v is not None and number(v) is None for v in usage.values()):
            raise ValueError("invalid provider usage")
        selected.append(usage)
    sums = total(selected) if selected else {k: 0 for k in FIELDS}
    available = not errors
    return {"available": available, "cumulative_tokens": sums["total_tokens"] if available else None,
            "total": sums if available else {k: None for k in FIELDS},
            "observed_subtotal": sums, "as_of_ns": at_ns, "epoch": epoch,
            "records": records, "reason": "; ".join(sorted(set(errors))) if errors else None}


class TransportMeter:
    def __init__(self):
        self.lock = threading.RLock()
        self.records = []
        self.epoch = uuid.uuid4().hex

    def reset(self):
        with self.lock:
            if any(r["finished_ns"] is None for r in self.records):
                raise ValueError("cannot reset active model requests")
            self.records = []
            self.epoch = uuid.uuid4().hex
            return {"epoch": self.epoch}

    def begin(self):
        with self.lock:
            record = {"request_id": len(self.records) + 1, "started_ns": time.monotonic_ns(),
                      "finished_ns": None, "usage": None}
            self.records.append(record)
            return record

    def finish(self, record, usage):
        with self.lock:
            if record["finished_ns"] is not None:
                return
            record["usage"] = usage
            record["finished_ns"] = time.monotonic_ns()

    def snapshot(self, at_ns=None):
        with self.lock:
            records = [{**r, "usage": dict(r["usage"]) if r["usage"] is not None else None} for r in self.records]
            now = time.monotonic_ns()
            if at_ns is not None and at_ns > now:
                raise ValueError("usage cutoff is in the future")
            return transport_snapshot(records, now if at_ns is None else at_ns, self.epoch)


def provider_usage(raw, kind):
    if kind == "anthropic":
        inp = number(raw.get("input_tokens"))
        read, write = number(raw.get("cache_read_input_tokens", 0)), number(raw.get("cache_creation_input_tokens", 0))
        uncached = inp
        inp = inp + read + write if None not in (inp, read, write) else None
        out = number(raw.get("output_tokens"))
    else:
        inp = number(raw.get("prompt_tokens", raw.get("input_tokens")))
        out = number(raw.get("completion_tokens", raw.get("output_tokens")))
        details = raw.get("prompt_tokens_details") or raw.get("input_tokens_details") or {}
        read = number(details.get("cached_tokens", 0))
        write = number(raw.get("cache_write_input_tokens", 0))
        uncached = inp - read if None not in (inp, read) and inp >= read else None
    declared = raw.get("total_tokens")
    if declared is not None:
        count = number(declared)
        if count is None or any(v is not None and v > count for v in (inp, out)):
            return None
        if inp is not None and out is not None and inp + out != count:
            return None
    elif inp is not None and out is not None:
        count = inp + out
    else:
        return None
    reason = number((raw.get("completion_tokens_details") or raw.get("output_tokens_details") or {}).get("reasoning_tokens"))
    return dict(zip(FIELDS, (inp, uncached, read, write, out, reason, count)))


def reconcile_completion(previous, proof):
    if not proof or "records" not in proof or previous.get("epoch") != proof["epoch"] or previous["as_of_ns"] > proof["as_of_ns"]:
        return dict(previous)
    checkpoint = transport_snapshot(proof["records"], previous["as_of_ns"], proof["epoch"])
    return {"kind": previous["kind"], **{k: v for k, v in checkpoint.items() if k != "records"},
            "recovered_from_transport_receipt": bool(previous.get("recovered_from_transport_receipt")
                or (not previous["available"] and checkpoint["available"]))}


def replay_transport_usage(native, saved, rows):
    receipt = saved["transport_receipt"]
    proof = saved.get("completion_receipt", receipt)
    if "records" in receipt:
        current = transport_snapshot(receipt["records"], receipt["as_of_ns"], receipt["epoch"])
    else:
        current = {"available": False, "total": {k: None for k in FIELDS}}
    checkpoints = []
    for row in rows:
        if row["evaluation_kind"] not in ("baseline", "candidate"):
            continue
        previous = row["completion_usage_checkpoint"]
        covered = bool(proof and "records" in proof and previous.get("epoch") == proof.get("epoch")
                       and previous["as_of_ns"] <= proof["as_of_ns"])
        if previous["available"] and not covered:
            raise ValueError("completion usage lacks a covering receipt")
        checkpoint = reconcile_completion({"kind": row["evaluation_kind"], **previous}, proof)
        if checkpoint["cumulative_tokens"] != previous.get("cumulative_tokens") or checkpoint["cumulative_tokens"] != row.get("cumulative_tokens"):
            raise ValueError("completion token receipt mismatch")
        checkpoints.append(checkpoint)
    candidates = [c for c in checkpoints if c["kind"] == "candidate"]
    usable = bool(candidates and all(c["available"] for c in candidates))
    native.update(native_cli_total=native["total"], available=current["available"], total=current["total"],
        source="provider.transport.usage", transport_receipt=receipt, completion_checkpoints=checkpoints,
        submission_checkpoints_reconciled=usable, submission_checkpoints_usable=usable,
        checkpoint_limitation=None if usable else "a candidate completion lacks complete transport evidence")
    if "completion_receipt" in saved:
        native["completion_receipt"] = proof
    return native