teamspend-cli 0.2.1__py3-none-any.whl

teamspend/__init__.py

@@ -0,0 +1,82 @@
+"""
+Programmatic / agent-native entry point.
+
+    from teamspend import fetch_cursor_spend, fetch_claude_code_spend, build_comparison
+
+    before = fetch_cursor_spend(DateWindow("2026-04-01", "2026-04-30"), api_key)
+    after = fetch_claude_code_spend(DateWindow("2026-06-01", "2026-06-30"), api_key)
+
+Each adapter returns the same normalized AdapterResult shape regardless of
+source vendor, so a caller (CLI, CI script, or an agent framework) can
+compare spend across tools without vendor-specific branching.
+
+This is the Python port of the teamspend npm package
+(https://www.npmjs.com/package/teamspend). Both distributions talk to the
+same two admin APIs (Cursor, Anthropic Claude Enterprise Analytics) and
+compute the same before/after delta; see
+https://github.com/RudrenduPaul/teamspend for the canonical documentation
+and the original TypeScript source.
+"""
+from .adapters.claude_code import fetch_claude_code_spend
+from .adapters.copilot import fetch_copilot_spend
+from .adapters.csv_import import import_from_csv
+from .adapters.cursor import fetch_cursor_spend
+from .compare import ComparisonReport, PeriodOutcome, TopSpenderEntry, build_comparison
+from .errors import (
+    AuthenticationError,
+    CSVRowError,
+    CSVSchemaError,
+    DataUnavailableError,
+    EmptyCSVError,
+    InvalidCliArgError,
+    RetryExhaustedError,
+    SchemaDriftError,
+)
+from .http_client import fetch_with_retry, require_field
+from .output import (
+    render_terminal_summary,
+    report_to_json_dict,
+    scaffold_gitignore,
+    write_json_report,
+)
+from .types import AdapterResult, DateWindow, ToolId, UserUsage, sum_cost, top_spenders
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    # types
+    "AdapterResult",
+    "DateWindow",
+    "ToolId",
+    "UserUsage",
+    "sum_cost",
+    "top_spenders",
+    # errors
+    "AuthenticationError",
+    "RetryExhaustedError",
+    "SchemaDriftError",
+    "DataUnavailableError",
+    "CSVSchemaError",
+    "EmptyCSVError",
+    "CSVRowError",
+    "InvalidCliArgError",
+    # http
+    "fetch_with_retry",
+    "require_field",
+    # adapters
+    "fetch_cursor_spend",
+    "fetch_claude_code_spend",
+    "fetch_copilot_spend",
+    "import_from_csv",
+    # compare
+    "PeriodOutcome",
+    "ComparisonReport",
+    "TopSpenderEntry",
+    "build_comparison",
+    # output
+    "render_terminal_summary",
+    "write_json_report",
+    "report_to_json_dict",
+    "scaffold_gitignore",
+]

teamspend/adapters/__init__.py

@@ -0,0 +1,9 @@
+from .claude_code import fetch_claude_code_spend
+from .csv_import import import_from_csv
+from .cursor import fetch_cursor_spend
+
+__all__ = [
+    "fetch_cursor_spend",
+    "fetch_claude_code_spend",
+    "import_from_csv",
+]

teamspend/adapters/claude_code.py

@@ -0,0 +1,77 @@
+"""
+Claude Code (Anthropic Claude Enterprise Analytics API) adapter.
+
+Ported from src/adapters/claude-code.ts.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from ..errors import DataUnavailableError
+from ..http_client import fetch_with_retry, require_field
+from ..types import AdapterResult, DateWindow, UserUsage, sum_cost
+
+TOOL = "claude-code"
+ANALYTICS_API_START_DATE = "2026-01-01"
+"""Anthropic's Claude Enterprise Analytics API has no data before this date."""
+
+
+def _normalize_user(raw: Dict[str, Any]) -> UserUsage:
+    input_tokens = require_field(raw, "input_tokens", TOOL)
+    output_tokens = require_field(raw, "output_tokens", TOOL)
+    cost_usd = require_field(raw, "spend_usd", TOOL)
+
+    # Claude.ai Team/Enterprise seats don't expose true per-user cost via the
+    # Admin API -- it reports a technically-valid but structurally
+    # uninformative spend_usd: 0 for a user who clearly has real token
+    # activity. Flag that specific combination as estimated rather than
+    # presenting a misleading exact-looking $0 (no requests field exists on
+    # this vendor's payload, so the check is token-only).
+    is_suspicious_zero = cost_usd == 0 and (input_tokens > 0 or output_tokens > 0)
+
+    return UserUsage(
+        user_id=require_field(raw, "user_id", TOOL),
+        user_email=require_field(raw, "email", TOOL),
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        cache_read_tokens=require_field(raw, "cache_read_tokens", TOOL),
+        cache_write_tokens=require_field(raw, "cache_write_tokens", TOOL),
+        requests=None,
+        cost_usd=cost_usd,
+        is_estimated=is_suspicious_zero,
+    )
+
+
+def fetch_claude_code_spend(
+    window: DateWindow, api_key: str, **fetch_kwargs: Any
+) -> AdapterResult:
+    """
+    Fetches Claude Code spend via Anthropic's Analytics/Admin API. If the
+    window's start predates 2026-01-01 (the Analytics API's hard start date,
+    not a rolling window), raises DataUnavailableError rather than silently
+    returning an incomplete or zeroed result. The caller falls back to the
+    CSV-import path for that portion of the window.
+    """
+    if window.start < ANALYTICS_API_START_DATE:
+        raise DataUnavailableError(
+            TOOL,
+            f"requested window starts {window.start}, before the Analytics "
+            f"API's {ANALYTICS_API_START_DATE} start date",
+        )
+
+    auth_header = {"x-api-key": api_key}
+    url = (
+        "https://api.anthropic.com/v1/organizations/usage_report/claude_code"
+        f"?start={window.start}&end={window.end}"
+    )
+    raw = fetch_with_retry(TOOL, url, auth_header, **fetch_kwargs)
+    raw_users = require_field(raw, "users", TOOL)
+
+    users = [_normalize_user(u) for u in raw_users]
+    return AdapterResult(
+        source=TOOL,
+        window=window,
+        total_cost_usd=sum_cost(users),
+        is_estimated=any(u.is_estimated for u in users),
+        users=users,
+    )

teamspend/adapters/claude_code_personal.py

@@ -0,0 +1,258 @@
+"""
+Claude Code personal-usage adapter -- reads Claude Code's own local JSONL
+session logs directly, no admin API, no network call, no credential.
+
+Ported from src/adapters/claude-code-personal.ts. For someone who just
+wants their own personal Claude Code spend/usage without org-admin access
+to the Cursor Admin API or Anthropic's Claude Enterprise Analytics API that
+every other adapter in this package requires.
+"""
+from __future__ import annotations
+
+import getpass
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..errors import DataUnavailableError
+from ..types import AdapterResult, DateWindow, SessionUsage, UserUsage, sum_cost
+
+TOOL = "claude-code-personal"
+
+
+def _path_exists(candidate: Path) -> bool:
+    try:
+        return candidate.exists()
+    except OSError:
+        return False
+
+
+def resolve_projects_dirs() -> List[Path]:
+    """
+    Resolves the directory (or directories) to scan for Claude Code session
+    logs, in the same order Claude Code itself resolves its config dir:
+
+    1. `CLAUDE_CONFIG_DIR` (comma-separated list -- every entry is scanned,
+       not just the first). Each entry may either already point at a
+       `projects/` directory or be the parent config dir that contains one.
+    2. Else, the XDG-style location (`$XDG_CONFIG_HOME/claude/projects`,
+       defaulting `XDG_CONFIG_HOME` itself to `~/.config` per the XDG spec)
+       IF that directory exists.
+    3. Else, the legacy default: `~/.claude/projects`.
+
+    Only one of (2)/(3) is ever returned -- they're alternatives, not both
+    scanned -- while (1) can return several directories at once.
+    """
+    override = os.environ.get("CLAUDE_CONFIG_DIR")
+    if override and override.strip():
+        dirs = []
+        for entry in override.split(","):
+            entry = entry.strip()
+            if not entry:
+                continue
+            entry_path = Path(entry)
+            dirs.append(
+                entry_path
+                if entry_path.name == "projects"
+                else entry_path / "projects"
+            )
+        return dirs
+
+    xdg_base_raw = os.environ.get("XDG_CONFIG_HOME", "").strip()
+    xdg_base = Path(xdg_base_raw) if xdg_base_raw else Path.home() / ".config"
+    xdg_projects_dir = xdg_base / "claude" / "projects"
+    if _path_exists(xdg_projects_dir):
+        return [xdg_projects_dir]
+
+    return [Path.home() / ".claude" / "projects"]
+
+
+def _collect_jsonl_files(directory: Path) -> List[Path]:
+    """
+    Recursively collects every `*.jsonl` file under `directory`, including
+    nested `subagents/` subdirectories. A missing/unreadable directory
+    yields an empty list rather than raising -- the caller decides what "no
+    files anywhere" means (DataUnavailableError), not this low-level walker.
+    """
+    if not _path_exists(directory):
+        return []
+    try:
+        return sorted(directory.rglob("*.jsonl"))
+    except OSError:
+        return []
+
+
+def _within_window(timestamp: str, window: DateWindow) -> bool:
+    date = timestamp[:10]
+    return window.start <= date <= window.end
+
+
+def _resolve_local_user_id() -> str:
+    """
+    Best-effort local identity for the single user this mode reports on.
+    There is no admin API here, so there is no vendor-supplied user_id/email
+    to fall back on (unlike cursor.py/claude_code.py) -- the OS login name
+    is the closest reliable local signal, matching csv_import.py's
+    precedent of using whatever identity is directly at hand rather than
+    guessing. Falls back to a fixed placeholder if the OS refuses to answer
+    (some minimal containers have no passwd entry for the running uid).
+    """
+    try:
+        username = getpass.getuser()
+        if username and username.strip():
+            return username
+    except (OSError, KeyError):
+        pass
+    return "local-user"
+
+
+def fetch_claude_code_personal_usage(window: DateWindow) -> AdapterResult:
+    """
+    Reads Claude Code's own local JSONL session logs and reports the single
+    local user's usage for `window` -- no admin API, no network call, no
+    credential.
+
+    Entries are deduped by the (message.id, requestId) pair before summing,
+    since retried requests can appear more than once in the logs. `costUSD`
+    is trusted when present on a line; when it's absent, that line still
+    contributes its token counts but NOT a dollar amount, and the whole
+    result is flagged `is_estimated` -- matching this codebase's existing
+    "never present a guess as an exact number" rule (see
+    claude_code.py/cursor.py's suspicious-zero handling for the same
+    philosophy).
+    """
+    projects_dirs = resolve_projects_dirs()
+
+    jsonl_files: List[Path] = []
+    for directory in projects_dirs:
+        jsonl_files.extend(_collect_jsonl_files(directory))
+
+    if not jsonl_files:
+        checked = ", ".join(str(d) for d in projects_dirs)
+        raise DataUnavailableError(
+            TOOL,
+            f"no Claude Code session logs (*.jsonl) found under {checked} "
+            "(checked recursively, including subagents/ subdirectories)",
+        )
+
+    seen_keys = set()
+    input_tokens = 0
+    output_tokens = 0
+    cache_read_tokens = 0
+    cache_write_tokens = 0
+    requests = 0
+    cost_usd = 0.0
+    is_estimated = False
+    # Per-session totals, keyed by each JSONL line's own sessionId. A line
+    # with no sessionId still contributes to the flat totals above but
+    # can't be attributed to any session, so it's simply left out of this
+    # dict.
+    session_totals: Dict[str, Dict[str, Any]] = {}
+
+    for file_path in jsonl_files:
+        text = file_path.read_text(encoding="utf-8")
+        for line in text.split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                entry: Dict[str, Any] = json.loads(line)
+            except (json.JSONDecodeError, ValueError):
+                # Skip a corrupted/partial line rather than failing the
+                # whole read -- Claude Code's own logs can end mid-write if
+                # a session crashes.
+                continue
+
+            timestamp = entry.get("timestamp")
+            if not timestamp or not _within_window(timestamp, window):
+                continue
+
+            message = entry.get("message") or {}
+            message_id: Optional[str] = message.get("id")
+            request_id: Optional[str] = entry.get("requestId")
+            if message_id or request_id:
+                dedupe_key = f"{message_id or ''}::{request_id or ''}"
+                if dedupe_key in seen_keys:
+                    continue
+                seen_keys.add(dedupe_key)
+
+            usage = message.get("usage") or {}
+            line_input_tokens = usage.get("input_tokens") or 0
+            line_output_tokens = usage.get("output_tokens") or 0
+            input_tokens += line_input_tokens
+            output_tokens += line_output_tokens
+            cache_read_tokens += usage.get("cache_read_input_tokens") or 0
+            cache_write_tokens += usage.get("cache_creation_input_tokens") or 0
+            requests += 1
+
+            cost = entry.get("costUSD")
+            line_cost_usd = 0.0
+            line_is_estimated = False
+            if isinstance(cost, (int, float)) and not isinstance(cost, bool):
+                cost_usd += cost
+                line_cost_usd = float(cost)
+            else:
+                is_estimated = True
+                line_is_estimated = True
+
+            session_id = entry.get("sessionId")
+            if session_id:
+                totals = session_totals.setdefault(
+                    session_id,
+                    {
+                        "cost_usd": 0.0,
+                        "input_tokens": 0,
+                        "output_tokens": 0,
+                        "requests": 0,
+                        "is_estimated": False,
+                    },
+                )
+                totals["cost_usd"] += line_cost_usd
+                totals["input_tokens"] += line_input_tokens
+                totals["output_tokens"] += line_output_tokens
+                totals["requests"] += 1
+                totals["is_estimated"] = totals["is_estimated"] or line_is_estimated
+
+    # Only attach `sessions` when at least one line actually carried a
+    # sessionId -- an empty list would misleadingly claim "zero sessions"
+    # for a log format that simply predates the sessionId field, when the
+    # truth is teamspend couldn't group anything at all.
+    sessions: Optional[List[SessionUsage]] = (
+        [
+            SessionUsage(
+                session_id=session_id,
+                cost_usd=totals["cost_usd"],
+                input_tokens=totals["input_tokens"],
+                output_tokens=totals["output_tokens"],
+                requests=totals["requests"],
+                is_estimated=totals["is_estimated"],
+            )
+            for session_id, totals in session_totals.items()
+        ]
+        if session_totals
+        else None
+    )
+
+    user = UserUsage(
+        user_id=_resolve_local_user_id(),
+        user_email=None,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        cache_read_tokens=cache_read_tokens,
+        cache_write_tokens=cache_write_tokens,
+        requests=requests,
+        cost_usd=cost_usd,
+        is_estimated=is_estimated,
+        sessions=sessions,
+    )
+
+    users = [user]
+    return AdapterResult(
+        source=TOOL,
+        window=window,
+        total_cost_usd=sum_cost(users),
+        is_estimated=any(u.is_estimated for u in users),
+        users=users,
+    )

teamspend/adapters/codex.py

@@ -0,0 +1,265 @@
+"""
+Codex CLI local-file adapter.
+
+Ported from src/adapters/codex.ts.
+
+Codex CLI (github.com/openai/codex, OpenAI's coding agent CLI) has no
+admin/team/billing API -- it is a local CLI with its own local session
+logs, the same shape as claude_code_personal.py and opencode.py. Verified
+directly against openai/codex's own Rust source (not a third-party guess):
+
+- `codex-rs/utils/home-dir/src/lib.rs::find_codex_home` -- resolves via the
+  `CODEX_HOME` env var, defaulting to `~/.codex` if unset. Unlike Claude
+  Code's `CLAUDE_CONFIG_DIR`, this is a single path, never a
+  comma-separated list.
+- `codex-rs/rollout/src/lib.rs` -- `SESSIONS_SUBDIR = "sessions"` and
+  `ARCHIVED_SESSIONS_SUBDIR = "archived_sessions"`, both scanned below.
+- `codex-rs/rollout/src/list.rs` (doc comment) -- on-disk layout is
+  `<codex_home>/sessions/YYYY/MM/DD/rollout-<timestamp>-<uuid>.jsonl`.
+- `codex-rs/protocol/src/protocol.rs::TokenUsage` / `TokenUsageInfo` -- the
+  exact per-turn usage record shape read below (`input_tokens`,
+  `cached_input_tokens`, `cache_write_input_tokens`, `output_tokens`,
+  `reasoning_output_tokens`, `total_tokens`, wrapped in
+  `{ total_token_usage, last_token_usage }`).
+- `codex-rs/codex-api/src/sse/responses.rs` -- confirms `input_tokens` in
+  that struct is copied straight from OpenAI's Responses API
+  `usage.input_tokens`, which already *includes* `cached_tokens` as a
+  subset (its own test fixture: `input_tokens: 100`, `cached_tokens: 40`),
+  not an additional amount.
+
+Cross-checked against ccusage's own Codex guide
+(ccusage.com/guide/codex/) and mrexodia/agent-cost-dashboard's
+`cost_dashboard.py` (`analyze_codex_jsonl_file`), which parse the
+identical record shapes independently -- both agree with the Rust source
+on every field name.
+
+**Cold-storage limitation**: `codex-rs/rollout/src/compression.rs`
+background-compresses any rollout file older than 7 days
+(`MIN_ROLLOUT_AGE`) from `rollout-*.jsonl` to `rollout-*.jsonl.zst`
+(zstd). This adapter only reads plain `.jsonl` files -- the same tradeoff
+opencode.py already made for OpenCode's newer SQLite store: this package
+adds no dependency for a secondary on-disk format. A requested window
+reaching back more than ~7 days will under-report or come back empty for
+Codex; use the CSV-import fallback to cover that period.
+"""
+from __future__ import annotations
+
+import getpass
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from ..errors import DataUnavailableError
+from ..types import AdapterResult, DateWindow, UserUsage, sum_cost
+
+TOOL = "codex"
+CODEX_HOME_ENV = "CODEX_HOME"
+SESSIONS_SUBDIR = "sessions"
+ARCHIVED_SESSIONS_SUBDIR = "archived_sessions"
+
+
+def resolve_codex_sessions_dirs(
+    env: Optional[Dict[str, str]] = None,
+) -> List[str]:
+    """
+    Resolves the directories to scan for local Codex CLI session logs:
+    `<CODEX_HOME>/sessions` and `<CODEX_HOME>/archived_sessions`, where
+    `CODEX_HOME` defaults to `~/.codex` (see module docstring for the
+    source citation). Falls back to `HOME`/`USERPROFILE` off the same
+    `env` dict (rather than `Path.home()` directly) so tests can inject a
+    fake home directory the same way `resolve_opencode_data_dirs` does.
+    """
+    if env is None:
+        env = dict(os.environ)
+
+    override = env.get(CODEX_HOME_ENV, "").strip()
+    if override:
+        return [
+            str(Path(override, SESSIONS_SUBDIR)),
+            str(Path(override, ARCHIVED_SESSIONS_SUBDIR)),
+        ]
+
+    home = env.get("HOME") or env.get("USERPROFILE")
+    codex_home = Path(home, ".codex") if home else Path.home() / ".codex"
+    return [
+        str(codex_home / SESSIONS_SUBDIR),
+        str(codex_home / ARCHIVED_SESSIONS_SUBDIR),
+    ]
+
+
+def _collect_jsonl_files(directory: str) -> List[Path]:
+    """
+    Recursively collects every plain `*.jsonl` rollout file under
+    `directory` (the real layout nests them `YYYY/MM/DD/rollout-*.jsonl`,
+    but this walks arbitrarily deep rather than hardcoding that depth).
+    `*.jsonl.zst` (compressed, cold) siblings are deliberately skipped --
+    see the module docstring. A missing/unreadable directory yields an
+    empty list rather than raising.
+    """
+    root = Path(directory)
+    if not root.is_dir():
+        return []
+    try:
+        return sorted(root.rglob("*.jsonl"))
+    except OSError:
+        return []
+
+
+def _within_window(timestamp: str, window: DateWindow) -> bool:
+    date = timestamp[:10]
+    return window.start <= date <= window.end
+
+
+def _resolve_local_user_id() -> str:
+    """
+    Best-effort local identity for the single user this mode reports on --
+    same rationale and fallback as claude_code_personal.py/opencode.py: no
+    admin API here means no vendor-supplied user_id/email to fall back on.
+    """
+    try:
+        username = getpass.getuser()
+        if username and username.strip():
+            return username
+    except (OSError, KeyError):
+        pass
+    return "local-user"
+
+
+def fetch_codex_usage(
+    window: DateWindow, sessions_dirs: Optional[List[str]] = None
+) -> AdapterResult:
+    """
+    Reads Codex CLI's own local JSONL rollout logs and reports the single
+    local user's token usage for `window` -- no admin API, no network
+    call, no credential.
+
+    Codex's `event_msg` records with `payload.type == "token_count"` carry
+    per-turn token counts but, unlike Cursor/Claude Code's admin APIs,
+    **no cost field at all** -- not even a `cost: 0` placeholder the way
+    OpenCode's message files have. teamspend bundles no per-token pricing
+    table of its own (the same call opencode.py already made, for the
+    same reason: a bundled table drifts from real vendor prices and is
+    exactly the kind of guessed data this package avoids). `cost_usd` is
+    therefore always `0` and the result is always `is_estimated: True`
+    when any usage is found -- token counts are exact, dollars are simply
+    not reported by Codex at all.
+
+    `last_token_usage` on each `token_count` event is already the per-turn
+    delta (Codex's own `TokenUsageInfo::append_last_usage` sets it
+    verbatim per turn, distinct from the cumulative `total_token_usage`),
+    so this reads it directly rather than diffing consecutive cumulative
+    totals. Sessions old enough for `last_token_usage` to be entirely
+    absent predate the current schema and, per the cold-storage limitation
+    above, will already have been compressed to `.jsonl.zst` and skipped
+    -- such lines are simply skipped here too rather than deriving a delta
+    from `total_token_usage`.
+
+    Codex emits each `token_count` event twice in a row with
+    byte-identical `info` -- confirmed independently by
+    mrexodia/agent-cost-dashboard's own parser, which carries the same
+    dedup -- so a repeated `info` blob (matched by structural equality) is
+    skipped rather than double-counted.
+
+    `input_tokens` in Codex's schema already includes `cached_input_tokens`
+    as a subset (see module docstring), so this stores the net, uncached
+    portion as `input_tokens` to avoid double-counting input and
+    cache-read tokens the way `cache_read_tokens` already accounts for the
+    cached portion.
+    """
+    if sessions_dirs is None:
+        sessions_dirs = resolve_codex_sessions_dirs()
+
+    jsonl_files: List[Path] = []
+    for directory in sessions_dirs:
+        jsonl_files.extend(_collect_jsonl_files(directory))
+
+    if not jsonl_files:
+        checked = ", ".join(sessions_dirs)
+        raise DataUnavailableError(
+            TOOL,
+            f"no Codex CLI session logs (*.jsonl) found under {checked} -- "
+            "codex has no admin/team API, only local per-machine rollout "
+            "logs (set CODEX_HOME to override)",
+        )
+
+    input_tokens = 0
+    output_tokens = 0
+    cache_read_tokens = 0
+    cache_write_tokens = 0
+    requests = 0
+
+    for file_path in jsonl_files:
+        text = file_path.read_text(encoding="utf-8")
+        previous_signature: Optional[str] = None
+
+        for line in text.split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                record: Dict[str, Any] = json.loads(line)
+            except (json.JSONDecodeError, ValueError):
+                # Skip a corrupted/partial line rather than failing the
+                # whole read -- a rollout file can end mid-write if Codex
+                # crashes or is killed mid-turn.
+                continue
+
+            payload = record.get("payload") or {}
+            if record.get("type") != "event_msg" or payload.get("type") != "token_count":
+                continue
+
+            info = payload.get("info")
+            if not info:
+                continue
+
+            signature = json.dumps(info, sort_keys=True)
+            if signature == previous_signature:
+                # Codex fires each token_count event twice in a row with
+                # identical usage -- see module docstring.
+                continue
+            previous_signature = signature
+
+            usage = info.get("last_token_usage")
+            if not usage:
+                continue
+
+            timestamp = record.get("timestamp")
+            if not timestamp or not _within_window(timestamp, window):
+                continue
+
+            raw_input = usage.get("input_tokens") or 0
+            cached_input = usage.get("cached_input_tokens") or 0
+            input_tokens += max(0, raw_input - cached_input)
+            cache_read_tokens += cached_input
+            cache_write_tokens += usage.get("cache_write_input_tokens") or 0
+            output_tokens += usage.get("output_tokens") or 0
+            requests += 1
+
+    if requests == 0:
+        return AdapterResult(
+            source=TOOL, window=window, total_cost_usd=0, is_estimated=False, users=[]
+        )
+
+    users = [
+        UserUsage(
+            user_id=_resolve_local_user_id(),
+            user_email=None,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            cache_read_tokens=cache_read_tokens,
+            cache_write_tokens=cache_write_tokens,
+            requests=requests,
+            cost_usd=0,
+            is_estimated=True,
+        )
+    ]
+
+    return AdapterResult(
+        source=TOOL,
+        window=window,
+        total_cost_usd=sum_cost(users),
+        is_estimated=True,
+        users=users,
+    )