cli-consumption 0.3.2__tar.gz → 0.4.0__tar.gz

{cli_consumption-0.3.2 → cli_consumption-0.4.0}/.gitignore

@@ -12,6 +12,12 @@ reports/
 *.sqlite
 *.sqlite3
 .env
+node_modules/
+apps/*/.next/
+playwright-report/
+test-results/
+*.tsbuildinfo
+packages/*/dist/
 
 # Machine-specific orchestration context. These files must never be committed.
 .agents/orchestrator.md

{cli_consumption-0.3.2 → cli_consumption-0.4.0}/CHANGELOG.md

@@ -6,6 +6,55 @@ use [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.4.0] - 2026-09-01
+
+### Added
+
+- Added a blocking browser CI gate that opens detailed and share-safe dashboards
+  directly from `file://`, exercises their controls, and rejects network activity.
+- Defined the versioned, scoped, and bounded contracts for database upload, persistent
+  dashboard reporting, conversation pagination, and standalone web export.
+- Added read-only, migration-free extraction of bounded snapshot-schema-v1 payloads
+  from current local SQLite collection databases, including WAL-consistent reads,
+  exact schema verification, provider grouping, and privacy-safe failures.
+- Added `upload-db` with stable per-snapshot replay keys, required capability
+  negotiation, bounded retries, deterministic partial results, resumable uploads, and
+  strict fail-fast automation.
+- Added scoped `read` and `export` bearer credentials plus strict, bounded reporting
+  endpoints for dashboard datasets, filter options, opaque stable pagination,
+  conversation detail, and self-contained HTML downloads.
+- Added a locked TypeScript workspace with versioned dashboard contracts, pure shared
+  analytics, presentation helpers, Vitest parity coverage, ESM output, and a
+  reproducible network-free browser bundle included in Python wheels.
+- Added an authenticated responsive Next.js dashboard with a server-only collector
+  credential, bounded reporting BFF, URL-safe filters, conversation pagination and
+  detail, shared analytics, accessibility checks, and desktop/mobile browser coverage.
+- Replaced the classic offline renderer with the self-contained React/Tailwind runtime,
+  shared web primitives, streamed bounded dataset injection, reproducible packaged
+  assets, and detailed/share-safe `file://` browser coverage. The temporary
+  `--renderer` migration option was removed.
+- Added persistent-dashboard offline downloads for the exact visible selection, with
+  detailed/share-safe profiles, a credential-isolating bounded BFF, private temporary
+  cleanup, fixed failures, and self-contained browser coverage.
+
+## [0.3.3] - 2026-08-31
+
+### Added
+
+- Added deterministic, compressed offline snapshot files authenticated with Ed25519,
+  with bounded verification-before-parsing and idempotent SQLite/PostgreSQL ingestion.
+
+### Fixed
+
+- Continue now applies provider-specific cache semantics, preventing Anthropic cache
+  reads and writes from being omitted from input totals, and reports persisted
+  conversation-compaction markers.
+- Codex now preserves valid token accounting when provider counters are inconsistent,
+  keeps partial work and compaction records from referencing nonexistent turns, and
+  safely handles malformed metadata and timestamps.
+- OpenCode now rejects timezone-naive text timestamps consistently while retaining its
+  OpenCode 1.18.23 message/part extraction for models, tokens, and tools.
+
 ## [0.3.2] - 2026-08-31
 
 ### Changed
@@ -115,7 +164,9 @@ use [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - Refreshed the provider guide for the first minor release ([#26]).
 
-[Unreleased]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.3.2...HEAD
+[Unreleased]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.4.0...HEAD
+[0.4.0]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.3.3...v0.4.0
+[0.3.3]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.3.2...v0.3.3
 [0.3.2]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.3.1...v0.3.2
 [0.3.1]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.2.1...v0.3.0

{cli_consumption-0.3.2 → cli_consumption-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-consumption
-Version: 0.3.2
+Version: 0.4.0
 Summary: Analyze and consolidate AI coding CLI consumption across machines.
 Project-URL: Homepage, https://github.com/Guillaume-Lombardo/cli-consumption
 Project-URL: Documentation, https://github.com/Guillaume-Lombardo/cli-consumption#readme
@@ -31,6 +31,8 @@ Requires-Dist: psycopg[binary]>=3.2; extra == 'postgres'
 Provides-Extra: server
 Requires-Dist: fastapi>=0.115; extra == 'server'
 Requires-Dist: uvicorn>=0.34; extra == 'server'
+Provides-Extra: snapshots
+Requires-Dist: cryptography>=45; extra == 'snapshots'
 Provides-Extra: sync
 Requires-Dist: httpx>=0.27; extra == 'sync'
 Description-Content-Type: text/markdown
@@ -75,7 +77,8 @@ the optional runtime capabilities you use:
 
 - `cli-consumption[sync]` for the sync client;
 - `cli-consumption[server]` for the collector service;
-- `cli-consumption[postgres]` for PostgreSQL.
+- `cli-consumption[postgres]` for PostgreSQL;
+- `cli-consumption[snapshots]` for signed, compressed offline snapshot files.
 
 Extras can be combined, for example `cli-consumption[server,postgres]` on a central
 collector.
@@ -94,6 +97,20 @@ uv run cli-consumption export --output reports
 Open `reports/dashboard.html` locally. It makes no network requests. Detailed CSV
 tables are generated only when `--csv` is passed.
 
+Dashboard development lives in the locked npm workspace under `packages/`. It builds
+provider-neutral ESM analytics, shared React presentation primitives, and deterministic
+React/Tailwind browser assets that Python embeds in the wheel. The React runtime is the
+only offline renderer; installing or using the Python CLI does not require Node.js.
+
+The authenticated persistent dashboard lives in `apps/web/`. It reads the same
+minimized reporting contract through a server-side Next.js BFF: the browser never
+receives a collector credential or a database connection string. Its **Export
+offline** action downloads the exact visible selection as a self-contained detailed or
+share-safe HTML file. For a production
+setup, required environment variables, reverse-proxy constraints, and startup commands
+are documented in the
+[deployment guide](https://github.com/Guillaume-Lombardo/cli-consumption/blob/main/docs/deployment.md#run-the-persistent-dashboard).
+
 To collect one provider or select another database:
 
 ```bash
@@ -103,7 +120,7 @@ uv run cli-consumption collect --provider codex --database usage.sqlite
 Use `--source [LABEL=]PATH` for trusted offline copies and repeated
 `--project NAME=PATH_PREFIX` mappings for stable project labels. See the
 [usage and operations guide](https://github.com/Guillaume-Lombardo/cli-consumption/blob/main/docs/usage.md)
-for multi-machine collection, reporting,
+for signed offline transfers, multi-machine collection, reporting,
 PostgreSQL, retention, synchronization, readiness, and automation.
 
 ## Supported CLIs
@@ -152,8 +169,10 @@ for ingestion, idempotency, migrations, report limits, and collector behavior.
 | Command | Purpose |
 | --- | --- |
 | `collect` | Collect local or copied provider data into SQL. |
+| `snapshot` | Create or ingest signed, compressed offline snapshot files. |
 | `sync` | Collect and send metadata-only snapshots to a central API. |
-| `serve` | Run the central collection API. |
+| `upload-db` | Upload validated snapshots reconstructed from a local collect database. |
+| `serve` | Run the scoped central ingestion, reporting, and export API. |
 | `export` | Write the HTML dashboard and optional CSV tables. |
 | `providers` | List provider names and compatibility status. |
 | `retention` | Preview or apply deletion outside a retention window. |
@@ -184,6 +203,11 @@ uv run ruff check .
 uv run ty check
 uv run pytest --cov --cov-report=term-missing
 uv build
+npm ci
+npm run verify
+npm audit --audit-level=high
+npm run build:web
+npm run test:e2e
 ```
 
 Development uses short-lived branches and squash-merged pull requests into protected

{cli_consumption-0.3.2 → cli_consumption-0.4.0}/README.md

@@ -38,7 +38,8 @@ the optional runtime capabilities you use:
 
 - `cli-consumption[sync]` for the sync client;
 - `cli-consumption[server]` for the collector service;
-- `cli-consumption[postgres]` for PostgreSQL.
+- `cli-consumption[postgres]` for PostgreSQL;
+- `cli-consumption[snapshots]` for signed, compressed offline snapshot files.
 
 Extras can be combined, for example `cli-consumption[server,postgres]` on a central
 collector.
@@ -57,6 +58,20 @@ uv run cli-consumption export --output reports
 Open `reports/dashboard.html` locally. It makes no network requests. Detailed CSV
 tables are generated only when `--csv` is passed.
 
+Dashboard development lives in the locked npm workspace under `packages/`. It builds
+provider-neutral ESM analytics, shared React presentation primitives, and deterministic
+React/Tailwind browser assets that Python embeds in the wheel. The React runtime is the
+only offline renderer; installing or using the Python CLI does not require Node.js.
+
+The authenticated persistent dashboard lives in `apps/web/`. It reads the same
+minimized reporting contract through a server-side Next.js BFF: the browser never
+receives a collector credential or a database connection string. Its **Export
+offline** action downloads the exact visible selection as a self-contained detailed or
+share-safe HTML file. For a production
+setup, required environment variables, reverse-proxy constraints, and startup commands
+are documented in the
+[deployment guide](https://github.com/Guillaume-Lombardo/cli-consumption/blob/main/docs/deployment.md#run-the-persistent-dashboard).
+
 To collect one provider or select another database:
 
 ```bash
@@ -66,7 +81,7 @@ uv run cli-consumption collect --provider codex --database usage.sqlite
 Use `--source [LABEL=]PATH` for trusted offline copies and repeated
 `--project NAME=PATH_PREFIX` mappings for stable project labels. See the
 [usage and operations guide](https://github.com/Guillaume-Lombardo/cli-consumption/blob/main/docs/usage.md)
-for multi-machine collection, reporting,
+for signed offline transfers, multi-machine collection, reporting,
 PostgreSQL, retention, synchronization, readiness, and automation.
 
 ## Supported CLIs
@@ -115,8 +130,10 @@ for ingestion, idempotency, migrations, report limits, and collector behavior.
 | Command | Purpose |
 | --- | --- |
 | `collect` | Collect local or copied provider data into SQL. |
+| `snapshot` | Create or ingest signed, compressed offline snapshot files. |
 | `sync` | Collect and send metadata-only snapshots to a central API. |
-| `serve` | Run the central collection API. |
+| `upload-db` | Upload validated snapshots reconstructed from a local collect database. |
+| `serve` | Run the scoped central ingestion, reporting, and export API. |
 | `export` | Write the HTML dashboard and optional CSV tables. |
 | `providers` | List provider names and compatibility status. |
 | `retention` | Preview or apply deletion outside a retention window. |
@@ -147,6 +164,11 @@ uv run ruff check .
 uv run ty check
 uv run pytest --cov --cov-report=term-missing
 uv build
+npm ci
+npm run verify
+npm audit --audit-level=high
+npm run build:web
+npm run test:e2e
 ```
 
 Development uses short-lived branches and squash-merged pull requests into protected

{cli_consumption-0.3.2 → cli_consumption-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cli-consumption"
-version = "0.3.2"
+version = "0.4.0"
 description = "Analyze and consolidate AI coding CLI consumption across machines."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -34,6 +34,9 @@ dependencies = [
 postgres = ["psycopg[binary]>=3.2"]
 server = ["fastapi>=0.115", "uvicorn>=0.34"]
 sync = ["httpx>=0.27"]
+snapshots = [
+    "cryptography>=45",
+]
 
 [project.urls]
 Homepage = "https://github.com/Guillaume-Lombardo/cli-consumption"
@@ -51,6 +54,7 @@ dev = [
   "httpx>=0.27",
   "hypothesis>=6.165.10",
   "pip-audit>=2.10.1",
+  "playwright>=1.55",
   "pre-commit>=4.6.2",
   "psycopg[binary]>=3.2",
   "pytest>=8.3",
@@ -107,6 +111,5 @@ select = ["E", "F", "I", "UP", "B", "SIM", "RUF", "S"]
 "tests/**" = ["S101"]
 "tests/smoke_minimal_install.py" = ["S603", "S607"]
 "tests/test_codex_adapter.py" = ["S608"]
-"tests/test_dashboard_calculations.py" = ["S607"]
 "tests/test_demo.py" = ["S603"]
 "tests/test_packaging.py" = ["S603", "S607"]

{cli_consumption-0.3.2 → cli_consumption-0.4.0}/src/cli_consumption/adapters/_shared.py

@@ -166,15 +166,22 @@ def tokens(
     reasoning: object = 0,
     total: object = 0,
 ) -> dict[str, int]:
-    uncached_n = counter(uncached)
-    cached_n = counter(cached)
-    write_n = counter(cache_write)
-    visible_n = counter(visible)
-    reasoning_n = counter(reasoning)
-    input_n = bounded_sum(uncached_n, cached_n, write_n)
-    output_n = bounded_sum(visible_n, reasoning_n)
-    attributed = bounded_sum(input_n, output_n)
-    total_n = max(attributed, counter(total))
+    remaining = MAX_BIGINT
+    uncached_n = min(counter(uncached), remaining)
+    remaining -= uncached_n
+    cached_n = min(counter(cached), remaining)
+    remaining -= cached_n
+    write_n = min(counter(cache_write), remaining)
+    remaining -= write_n
+    visible_n = min(counter(visible), remaining)
+    remaining -= visible_n
+    reasoning_n = min(counter(reasoning), remaining)
+    remaining -= reasoning_n
+    input_n = uncached_n + cached_n + write_n
+    output_n = visible_n + reasoning_n
+    attributed = input_n + output_n
+    unattributed_n = min(max(0, counter(total) - attributed), remaining)
+    total_n = attributed + unattributed_n
     return {
         "input_tokens": input_n,
         "cached_input_tokens": cached_n,
@@ -184,13 +191,34 @@ def tokens(
         "total_tokens": total_n,
         "uncached_input_tokens": uncached_n,
         "visible_output_tokens": visible_n,
-        "unattributed_tokens": max(0, total_n - attributed),
+        "unattributed_tokens": unattributed_n,
     }
 
 
 def add_tokens(target: dict[str, Any], value: dict[str, int]) -> None:
-    for field, amount in value.items():
-        target[field] = bounded_sum(int(target[field]), amount)
+    remaining = MAX_BIGINT
+    for field in (
+        "uncached_input_tokens",
+        "cached_input_tokens",
+        "cache_write_input_tokens",
+        "visible_output_tokens",
+        "reasoning_output_tokens",
+        "unattributed_tokens",
+    ):
+        amount = min(remaining, int(target[field]) + value[field])
+        target[field] = amount
+        remaining -= amount
+    target["input_tokens"] = (
+        target["uncached_input_tokens"]
+        + target["cached_input_tokens"]
+        + target["cache_write_input_tokens"]
+    )
+    target["output_tokens"] = (
+        target["visible_output_tokens"] + target["reasoning_output_tokens"]
+    )
+    target["total_tokens"] = (
+        target["input_tokens"] + target["output_tokens"] + target["unattributed_tokens"]
+    )
 
 
 def new_turn(

{cli_consumption-0.3.2 → cli_consumption-0.4.0}/src/cli_consumption/adapters/codex.py

@@ -87,11 +87,14 @@ AGENT_ROLE_ALIASES = {
 SAFE_DIMENSION = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.:/+-]*")
 
 
-def parse_timestamp(value: str | None) -> datetime | None:
-    if not value:
+def parse_timestamp(value: object) -> datetime | None:
+    if not isinstance(value, str) or not value:
         return None
     try:
-        return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(UTC)
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        if parsed.tzinfo is None or parsed.utcoffset() is None:
+            return None
+        return parsed.astimezone(UTC)
     except ValueError:
         return None
 
@@ -99,7 +102,8 @@ def parse_timestamp(value: str | None) -> datetime | None:
 def infer_project(
     metadata: dict[str, Any], mappings: list[tuple[str, str]]
 ) -> tuple[str, str]:
-    cwd = str(metadata.get("cwd") or "").rstrip("/\\")
+    raw_cwd = metadata.get("cwd")
+    cwd = raw_cwd.rstrip("/\\") if isinstance(raw_cwd, str) else ""
     normalized_cwd = cwd.replace("\\", "/")
     for name, prefix in sorted(mappings, key=lambda item: len(item[1]), reverse=True):
         normalized_prefix = prefix.replace("\\", "/").rstrip("/")
@@ -109,17 +113,18 @@ def infer_project(
             return name, "mapping"
     git = metadata.get("git")
     if isinstance(git, dict):
-        repository = str(git.get("repository_url") or git.get("repository") or "")
+        raw_repository = git.get("repository_url") or git.get("repository")
+        repository = raw_repository if isinstance(raw_repository, str) else ""
         slug = re.split(r"[/\\:]", repository.rstrip("/\\"))[-1]
         if slug.endswith(".git"):
             slug = slug[:-4]
-        if slug:
+        if _safe_dimension(slug, 255):
             return slug, "git"
     return OUTSIDE_PROJECT, "none"
 
 
 def extract_tools(payload: dict[str, Any]) -> list[tuple[str, str]]:
-    outer_name = str(payload.get("name", "unknown"))
+    outer_name = _safe_dimension(payload.get("name"), 512) or "unknown"
     if outer_name != "exec":
         return [(outer_name, outer_name)]
     raw_input = payload.get("input", "")
@@ -233,9 +238,16 @@ class CodexAdapter:
                         continue
                     event_count += 1
                     if event.get("type") == "session_meta":
-                        conversation_id = str(event.get("payload", {}).get("id", ""))
-                conversation_id = conversation_id or path.stem
-                candidate = (machine, path, event_count, digest.hexdigest())
+                        payload = event.get("payload")
+                        if not isinstance(payload, dict):
+                            malformed += 1
+                            continue
+                        candidate_id = _safe_dimension(payload.get("id"), 512)
+                        if candidate_id and not conversation_id:
+                            conversation_id = candidate_id
+                content_hash = digest.hexdigest()
+                conversation_id = conversation_id or f"content-{content_hash}"
+                candidate = (machine, path, event_count, content_hash)
                 previous = selected.get(conversation_id)
                 if previous is None:
                     selected[conversation_id] = candidate
@@ -273,7 +285,16 @@ class CodexAdapter:
             ),
             {},
         )
-        conversation_id = str(metadata.get("id") or path.stem)
+        conversation_id = next(
+            (
+                candidate_id
+                for event in events
+                if event.get("type") == "session_meta"
+                and isinstance((payload := event.get("payload")), dict)
+                and (candidate_id := _safe_dimension(payload.get("id"), 512))
+            ),
+            f"content-{digest}",
+        )
         record_id = f"codex:{conversation_id}"
         project, project_source = infer_project(metadata, mappings)
         timestamps = [
@@ -316,9 +337,7 @@ class CodexAdapter:
                     {
                         "id": f"{record_id}:compaction:{compaction_sequence}",
                         "conversation_id": record_id,
-                        "turn_id": (
-                            f"{record_id}:{active_turn_id}" if active_turn_id else None
-                        ),
+                        "turn_id": turns.get(active_turn_id or "", {}).get("id"),
                         "sequence": compaction_sequence,
                         "timestamp": _iso(timestamp),
                     }
@@ -343,7 +362,7 @@ class CodexAdapter:
                         _merge_present(settings_by_turn[active_turn_id], updates)
             if event_type == "turn_context":
                 active_turn_id = (
-                    str(payload.get("turn_id") or active_turn_id or "") or None
+                    _safe_dimension(payload.get("turn_id"), 512) or active_turn_id
                 )
                 active_model = (
                     _safe_dimension(payload.get("model"), 255) or active_model
@@ -362,7 +381,7 @@ class CodexAdapter:
                         or setting_defaults["collaboration_mode"],
                     }
             if event_type == "event_msg" and payload_type == "task_started":
-                active_turn_id = str(payload.get("turn_id") or "") or None
+                active_turn_id = _safe_dimension(payload.get("turn_id"), 512)
                 if active_turn_id:
                     settings = settings_by_turn.setdefault(
                         active_turn_id, dict(setting_defaults)
@@ -391,7 +410,9 @@ class CodexAdapter:
                 "task_complete",
                 "turn_aborted",
             }:
-                turn_id = str(payload.get("turn_id") or active_turn_id or "")
+                turn_id = (
+                    _safe_dimension(payload.get("turn_id"), 512) or active_turn_id or ""
+                )
                 if turn_id in turns:
                     turns[turn_id].update(
                         ended_at=_iso(timestamp),
@@ -412,12 +433,13 @@ class CodexAdapter:
                 work_sequence += 1
                 started_at_ms = _integer_or_none(payload.get("started_at_ms"))
                 completed_at_ms = _integer_or_none(payload.get("completed_at_ms"))
-                turn_id = str(payload.get("turn_id") or active_turn_id or "") or None
+                turn_id = _safe_dimension(payload.get("turn_id") or active_turn_id, 512)
+                turn = turns.get(turn_id or "")
                 snapshot.work_items.append(
                     {
                         "id": f"{record_id}:work:{work_sequence}",
                         "conversation_id": record_id,
-                        "turn_id": f"{record_id}:{turn_id}" if turn_id else None,
+                        "turn_id": turn["id"] if turn else None,
                         "sequence": work_sequence,
                         "kind": WORK_ITEM_KINDS.get(
                             str(item.get("type") or ""), "other"
@@ -438,18 +460,12 @@ class CodexAdapter:
                 if not isinstance(usage, dict):
                     continue
                 call_sequence += 1
-                tokens = {
-                    field: _nonnegative_integer(usage.get(field))
-                    for field in TOKEN_FIELDS
-                }
-                tokens.update(_derived_tokens(tokens))
-                for field, value in tokens.items():
-                    totals[field] += value
+                tokens = _usage_tokens(usage)
+                _accumulate_tokens(totals, tokens)
                 turn = turns.get(active_turn_id or "")
                 if turn:
                     turn["model_calls"] += 1
-                    for field, value in tokens.items():
-                        turn[field] += value
+                    _accumulate_tokens(turn, tokens)
                 snapshot.model_calls.append(
                     {
                         "id": f"{record_id}:model:{call_sequence}",
@@ -548,24 +564,62 @@ class CodexAdapter:
         )
 
 
-def _derived_tokens(tokens: dict[str, int]) -> dict[str, int]:
+def _usage_tokens(usage: dict[str, Any]) -> dict[str, int]:
+    raw = {field: _nonnegative_integer(usage.get(field)) for field in TOKEN_FIELDS}
+    cached = raw["cached_input_tokens"]
+    cache_write = min(raw["cache_write_input_tokens"], MAX_BIGINT - cached)
+    input_tokens = max(raw["input_tokens"], cached + cache_write)
+    uncached = input_tokens - cached - cache_write
+    remaining = MAX_BIGINT - input_tokens
+    reasoning = min(raw["reasoning_output_tokens"], remaining)
+    visible = min(
+        max(0, raw["output_tokens"] - raw["reasoning_output_tokens"]),
+        remaining - reasoning,
+    )
+    output_tokens = reasoning + visible
+    unattributed = min(
+        max(0, raw["total_tokens"] - input_tokens - output_tokens),
+        MAX_BIGINT - input_tokens - output_tokens,
+    )
     return {
-        "uncached_input_tokens": max(
-            0,
-            tokens["input_tokens"]
-            - tokens["cached_input_tokens"]
-            - tokens["cache_write_input_tokens"],
-        ),
-        "visible_output_tokens": max(
-            0, tokens["output_tokens"] - tokens["reasoning_output_tokens"]
-        ),
-        "unattributed_tokens": max(
-            0,
-            tokens["total_tokens"] - tokens["input_tokens"] - tokens["output_tokens"],
-        ),
+        "input_tokens": input_tokens,
+        "cached_input_tokens": cached,
+        "cache_write_input_tokens": cache_write,
+        "output_tokens": output_tokens,
+        "reasoning_output_tokens": reasoning,
+        "total_tokens": input_tokens + output_tokens + unattributed,
+        "uncached_input_tokens": uncached,
+        "visible_output_tokens": visible,
+        "unattributed_tokens": unattributed,
     }
 
 
+def _accumulate_tokens(target: dict[str, Any], value: dict[str, int]) -> None:
+    remaining = MAX_BIGINT
+    for field in (
+        "uncached_input_tokens",
+        "cached_input_tokens",
+        "cache_write_input_tokens",
+        "visible_output_tokens",
+        "reasoning_output_tokens",
+        "unattributed_tokens",
+    ):
+        amount = min(remaining, int(target[field]) + value[field])
+        target[field] = amount
+        remaining -= amount
+    target["input_tokens"] = (
+        target["uncached_input_tokens"]
+        + target["cached_input_tokens"]
+        + target["cache_write_input_tokens"]
+    )
+    target["output_tokens"] = (
+        target["visible_output_tokens"] + target["reasoning_output_tokens"]
+    )
+    target["total_tokens"] = (
+        target["input_tokens"] + target["output_tokens"] + target["unattributed_tokens"]
+    )
+
+
 def _safe_dimension(value: object, maximum: int) -> str | None:
     if not isinstance(value, str):
         return None
@@ -650,5 +704,9 @@ def _integer_or_none(value: object) -> int | None:
 
 
 def _nonnegative_integer(value: object) -> int:
-    parsed = _integer_or_none(value)
+    parsed = (
+        _integer_or_none(value)
+        if not isinstance(value, float) or value.is_integer()
+        else None
+    )
     return max(0, parsed or 0)