teamspend-cli 0.2.1__py3-none-any.whl

teamspend/adapters/copilot.py

@@ -0,0 +1,189 @@
+"""
+GitHub Copilot usage metrics adapter.
+
+Ported from src/adapters/copilot.ts. See that file's module docstring for
+the full research writeup; summarized here:
+
+- The endpoint this adapter calls, GET /orgs/{org}/copilot/metrics/reports/
+  users-1-day, is the CURRENT (non-deprecated) Copilot usage metrics API.
+  The older /orgs/{org}/copilot/metrics endpoint, which returned inline
+  org-aggregate JSON, was sunset by GitHub on 2026-04-02 and no longer
+  exists.
+- That real API has no arbitrary start/end range parameter -- only
+  single-day (`users-1-day?day=YYYY-MM-DD`) or latest-rolling-28-day
+  (`users-28-day/latest`) granularity. This adapter requests one report per
+  calendar day in the window and sums per-user totals across days, the
+  Python mirror of fetch_cursor_spend's 30-day-chunk-and-sum pattern.
+- Each report call returns `{download_links, report_day}`, not data inline.
+  download_links are short-lived, pre-signed GitHub-owned URLs pointing to
+  NDJSON (newline-delimited JSON) files -- this adapter fetches and parses
+  each one.
+- GitHub's Copilot metrics API has NO cost/spend field at all (unlike
+  Cursor/Claude Code, which do report a native cost figure). The only real,
+  vendor-reported, per-user number is `ai_credits_used`, which this adapter
+  converts to USD at GitHub's own published, fixed $0.01/credit rate --
+  never fabricated. An optional `seat_price_usd` adds a flat per-seat
+  monthly price once per user (never per day), since GitHub does not expose
+  an org's actual negotiated seat price via any API -- the same structural
+  gap Cursor's and Claude Code's flat-seat plans have.
+- `is_estimated` is unconditionally True for every Copilot result: every
+  dollar figure produced here is derived, never vendor-reported.
+"""
+from __future__ import annotations
+
+import json as json_module
+from datetime import date, timedelta
+from typing import Any, Dict, List, Optional
+from urllib.parse import quote
+
+from ..errors import AuthenticationError, DataUnavailableError, InvalidCliArgError
+from ..http_client import fetch_with_retry, require_field
+from ..types import AdapterResult, DateWindow, UserUsage, sum_cost
+
+TOOL = "copilot"
+COPILOT_API_VERSION = "2026-03-10"
+
+COPILOT_METRICS_START_DATE = "2025-10-10"
+"""GitHub's Copilot usage metrics reports have no data before this date."""
+
+COPILOT_CREDIT_USD_RATE = 0.01
+"""
+GitHub's own published, fixed conversion rate from an AI credit to USD --
+not a negotiated or per-org price. Source: GitHub Blog, "GitHub Copilot is
+moving to usage-based billing" (2026) -- "1 AI credit = $0.01 USD".
+"""
+
+
+def _split_into_days(window: DateWindow) -> List[str]:
+    start = date.fromisoformat(window.start)
+    end = date.fromisoformat(window.end)
+    days: List[str] = []
+    cursor = start
+    while cursor <= end:
+        days.append(cursor.isoformat())
+        cursor += timedelta(days=1)
+    return days
+
+
+def _normalize_user(raw: Dict[str, Any]) -> UserUsage:
+    user_login = require_field(raw, "user_login", TOOL)
+    ai_credits_used = require_field(raw, "ai_credits_used", TOOL)
+    interaction_count = require_field(raw, "user_initiated_interaction_count", TOOL)
+
+    return UserUsage(
+        user_id=user_login,
+        # GitHub identifies Copilot users by user_id/user_login (a GitHub
+        # username), never an email address -- unlike Cursor and Claude Code.
+        user_email=None,
+        # Copilot's metrics reports carry no token counts at all.
+        input_tokens=None,
+        output_tokens=None,
+        cache_read_tokens=None,
+        cache_write_tokens=None,
+        requests=interaction_count,
+        cost_usd=ai_credits_used * COPILOT_CREDIT_USD_RATE,
+        is_estimated=True,
+    )
+
+
+def _parse_ndjson(text: str) -> List[Dict[str, Any]]:
+    return [
+        json_module.loads(line)
+        for line in text.split("\n")
+        if line.strip()
+    ]
+
+
+def fetch_copilot_spend(
+    window: DateWindow,
+    api_key: str,
+    org: str,
+    seat_price_usd: Optional[float] = None,
+    **fetch_kwargs: Any,
+) -> AdapterResult:
+    """
+    Fetches GitHub Copilot org usage for the given window and converts it to
+    a dollar figure. See this module's docstring for the full API research
+    writeup.
+
+    `fetch_kwargs` forwards to http_client.fetch_with_retry (e.g.
+    `transport` and `sleep` for tests) -- never used by real callers.
+    """
+    if seat_price_usd is not None and not (seat_price_usd >= 0):
+        raise InvalidCliArgError(
+            f"copilot seat price must be a non-negative number, got {seat_price_usd}"
+        )
+
+    if window.start < COPILOT_METRICS_START_DATE:
+        raise DataUnavailableError(
+            TOOL,
+            f"requested window starts {window.start}, before Copilot usage "
+            f"metrics reports' {COPILOT_METRICS_START_DATE} start date",
+        )
+
+    auth_header = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": COPILOT_API_VERSION,
+    }
+
+    user_totals: Dict[str, UserUsage] = {}
+
+    for day in _split_into_days(window):
+        url = (
+            f"https://api.github.com/orgs/{quote(org, safe='')}"
+            f"/copilot/metrics/reports/users-1-day?day={day}"
+        )
+        report = fetch_with_retry(
+            TOOL, url, auth_header, empty_on=(404,), **fetch_kwargs
+        )
+
+        # 404 means "no report for this day" -- treated as zero users for
+        # that day, not a failure, the same way Cursor's adapter treats a
+        # 200 {"users": []} response.
+        if report is None:
+            continue
+
+        download_links = require_field(report, "download_links", TOOL)
+
+        for link in download_links:
+            try:
+                # Download links are short-lived, pre-signed GitHub-owned
+                # URLs -- they don't need (and can reject) the org's
+                # TEAMSPEND_COPILOT_TOKEN.
+                ndjson_text = fetch_with_retry(
+                    TOOL,
+                    link,
+                    {},
+                    response_type="text",
+                    **fetch_kwargs,
+                )
+            except AuthenticationError as error:
+                raise RuntimeError(
+                    f"{TOOL}: report download link for {day} was rejected "
+                    f"(expired signed URL?) -- retry the command (org={org})"
+                ) from error
+
+            for raw_user in _parse_ndjson(ndjson_text):
+                normalized = _normalize_user(raw_user)
+                existing = user_totals.get(normalized.user_id)
+                if existing:
+                    existing.requests = (existing.requests or 0) + (
+                        normalized.requests or 0
+                    )
+                    existing.cost_usd += normalized.cost_usd
+                else:
+                    user_totals[normalized.user_id] = normalized
+
+    if seat_price_usd:
+        for user in user_totals.values():
+            user.cost_usd += seat_price_usd
+
+    users_list = list(user_totals.values())
+    return AdapterResult(
+        source=TOOL,
+        window=window,
+        total_cost_usd=sum_cost(users_list),
+        is_estimated=True,
+        users=users_list,
+    )

teamspend/adapters/csv_import.py

@@ -0,0 +1,127 @@
+"""
+CSV-import fallback adapter, for the history a live admin API can't reach.
+
+Ported from src/adapters/csv-import.ts. Schema: date, user_email, cost_usd,
+is_estimated. One row per user per day; rows are aggregated per user_email.
+
+Uses a simple split(",") parser rather than the stdlib `csv` module, on
+purpose: the TypeScript original does the same (no quoted-field or embedded-
+comma support), and keeping the two implementations' exact parsing
+semantics identical matters more here than gaining stdlib `csv`'s richer
+quoting support that the npm CLI doesn't have either.
+"""
+from __future__ import annotations
+
+import math
+import re
+from pathlib import Path
+from typing import Dict, List
+
+from ..errors import CSVRowError, CSVSchemaError, EmptyCSVError
+from ..types import AdapterResult, DateWindow, ToolId, UserUsage, sum_cost
+
+EXPECTED_COLUMNS = ["date", "user_email", "cost_usd", "is_estimated"]
+
+_CONTROL_CHAR_RE = re.compile(r"[\x00-\x1f]")
+
+
+def strip_control_chars(value: str) -> str:
+    """
+    Strips C0 control characters (0x00-0x1f), including ANSI/OSC terminal
+    escape sequences, from a string. Without this, a crafted user_email --
+    whether from an imported CSV or a live admin API response -- could
+    inject escape codes into the non-JSON terminal summary output.
+    """
+    return _CONTROL_CHAR_RE.sub("", value)
+
+
+def _parse_csv(text: str) -> List[Dict[str, str]]:
+    lines = [line.strip() for line in text.split("\n") if line.strip()]
+    if not lines:
+        raise EmptyCSVError("<csv content>")
+
+    header = [h.strip() for h in lines[0].split(",")]
+    missing_columns = [col for col in EXPECTED_COLUMNS if col not in header]
+    if missing_columns:
+        raise CSVSchemaError(EXPECTED_COLUMNS)
+
+    date_idx = header.index("date")
+    email_idx = header.index("user_email")
+    cost_idx = header.index("cost_usd")
+    estimated_idx = header.index("is_estimated")
+
+    rows: List[Dict[str, str]] = []
+    for line in lines[1:]:
+        cells = [strip_control_chars(c.strip()) for c in line.split(",")]
+
+        def cell(idx: int) -> str:
+            return cells[idx] if idx < len(cells) else ""
+
+        rows.append(
+            {
+                "date": cell(date_idx),
+                "user_email": cell(email_idx),
+                "cost_usd": cell(cost_idx),
+                "is_estimated": cell(estimated_idx),
+            }
+        )
+    return rows
+
+
+def import_from_csv(csv_path: str, source: ToolId, window: DateWindow) -> AdapterResult:
+    """
+    Imports before-window spend from a CSV file for a tool whose admin API
+    doesn't cover the requested window (e.g. Claude Code before 2026-01-01).
+    """
+    text = Path(csv_path).read_text(encoding="utf-8")
+    if not text.strip():
+        raise EmptyCSVError(csv_path)
+
+    rows = _parse_csv(text)
+    user_totals: Dict[str, UserUsage] = {}
+
+    for index, row in enumerate(rows):
+        row_number = index + 2  # +1 for header row, +1 for 1-based numbering
+        if len(row["user_email"]) == 0:
+            raise CSVRowError(row_number, "user_email is empty")
+
+        try:
+            cost = float(row["cost_usd"])
+        except ValueError:
+            cost = math.nan
+        # float() accepts "inf"/"nan" (case-insensitive) as valid input where
+        # the TypeScript port's Number.isFinite(Number.parseFloat(...)) check
+        # already rejects both -- close the same gap here rather than let a
+        # crafted CSV silently propagate inf/nan into totals and CI-gate math.
+        if not math.isfinite(cost):
+            raise CSVRowError(
+                row_number, f'cost_usd "{row["cost_usd"]}" is not a valid number'
+            )
+
+        existing = user_totals.get(row["user_email"])
+        is_estimated = row["is_estimated"].lower() == "true"
+
+        if existing:
+            existing.cost_usd += cost
+            existing.is_estimated = existing.is_estimated or is_estimated
+        else:
+            user_totals[row["user_email"]] = UserUsage(
+                user_id=row["user_email"],
+                user_email=row["user_email"],
+                input_tokens=None,
+                output_tokens=None,
+                cache_read_tokens=None,
+                cache_write_tokens=None,
+                requests=None,
+                cost_usd=cost,
+                is_estimated=is_estimated,
+            )
+
+    users_list = list(user_totals.values())
+    return AdapterResult(
+        source=source,
+        window=window,
+        total_cost_usd=sum_cost(users_list),
+        is_estimated=any(u.is_estimated for u in users_list),
+        users=users_list,
+    )

teamspend/adapters/cursor.py

@@ -0,0 +1,114 @@
+"""
+Cursor Admin API adapter.
+
+Ported from src/adapters/cursor.ts. Paginates across the API's 30-day
+per-call cap and sums the result. If any chunk fails after retries are
+exhausted, the ENTIRE call fails -- never silently sums only the chunks
+that succeeded, which would under-report spend without any indication the
+number is incomplete.
+"""
+from __future__ import annotations
+
+from datetime import date, timedelta
+from typing import Any, Dict, List
+
+from ..http_client import fetch_with_retry, require_field
+from ..types import AdapterResult, DateWindow, UserUsage, sum_cost
+
+CURSOR_MAX_WINDOW_DAYS = 30
+TOOL = "cursor"
+
+
+def _split_into_chunks(window: DateWindow) -> List[DateWindow]:
+    start = date.fromisoformat(window.start)
+    end = date.fromisoformat(window.end)
+    chunks: List[DateWindow] = []
+    chunk_start = start
+
+    while chunk_start <= end:
+        chunk_end = chunk_start + timedelta(days=CURSOR_MAX_WINDOW_DAYS - 1)
+        clamped_end = min(chunk_end, end)
+        chunks.append(
+            DateWindow(start=chunk_start.isoformat(), end=clamped_end.isoformat())
+        )
+        chunk_start = clamped_end + timedelta(days=1)
+
+    return chunks
+
+
+def _normalize_user(raw: Dict[str, Any]) -> UserUsage:
+    input_tokens = require_field(raw, "input_tokens", TOOL)
+    output_tokens = require_field(raw, "output_tokens", TOOL)
+    requests = require_field(raw, "requests", TOOL)
+    cost_usd = require_field(raw, "cost_usd", TOOL)
+
+    # Cursor plans without usage overage don't expose true per-user cost via
+    # the Admin API -- it reports a technically-valid but structurally
+    # uninformative cost_usd: 0 for a user who clearly has real activity.
+    # Flag that specific combination as estimated rather than presenting a
+    # misleading exact-looking $0.
+    is_suspicious_zero = cost_usd == 0 and (
+        input_tokens > 0 or output_tokens > 0 or requests > 0
+    )
+
+    return UserUsage(
+        user_id=require_field(raw, "user_id", TOOL),
+        user_email=raw.get("email"),
+        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=requests,
+        cost_usd=cost_usd,
+        is_estimated=is_suspicious_zero,
+    )
+
+
+def fetch_cursor_spend(window: DateWindow, api_key: str, **fetch_kwargs: Any) -> AdapterResult:
+    """
+    Fetches Cursor Admin API spend for the given window, paginating across
+    30-day chunks (the API's per-call cap) and summing the result.
+
+    `fetch_kwargs` forwards to http_client.fetch_with_retry (e.g. `transport`
+    and `sleep` for tests) -- never used by real callers.
+    """
+    chunks = _split_into_chunks(window)
+    auth_header = {"Authorization": f"Bearer {api_key}"}
+
+    user_totals: Dict[str, UserUsage] = {}
+
+    for chunk in chunks:
+        url = f"https://api.cursor.com/admin/usage?start={chunk.start}&end={chunk.end}"
+        raw = fetch_with_retry(TOOL, url, auth_header, **fetch_kwargs)
+        users = require_field(raw, "users", TOOL)
+
+        for raw_user in users:
+            normalized = _normalize_user(raw_user)
+            existing = user_totals.get(normalized.user_id)
+            if existing:
+                existing.input_tokens = (existing.input_tokens or 0) + (
+                    normalized.input_tokens or 0
+                )
+                existing.output_tokens = (existing.output_tokens or 0) + (
+                    normalized.output_tokens or 0
+                )
+                existing.cache_read_tokens = (existing.cache_read_tokens or 0) + (
+                    normalized.cache_read_tokens or 0
+                )
+                existing.cache_write_tokens = (existing.cache_write_tokens or 0) + (
+                    normalized.cache_write_tokens or 0
+                )
+                existing.requests = (existing.requests or 0) + (normalized.requests or 0)
+                existing.cost_usd += normalized.cost_usd
+                existing.is_estimated = existing.is_estimated or normalized.is_estimated
+            else:
+                user_totals[normalized.user_id] = normalized
+
+    users_list = list(user_totals.values())
+    return AdapterResult(
+        source=TOOL,
+        window=window,
+        total_cost_usd=sum_cost(users_list),
+        is_estimated=any(u.is_estimated for u in users_list),
+        users=users_list,
+    )

teamspend/adapters/opencode.py

@@ -0,0 +1,250 @@
+"""
+OpenCode local-file adapter.
+
+Ported from src/adapters/opencode.ts.
+
+OpenCode (github.com/anomalyco/opencode, formerly sst/opencode -- the GitHub
+org renamed and the old slug now redirects) has no admin/team/billing API at
+all -- confirmed against its own README, which describes only a local CLI
+with no organization-level usage endpoint. Every session/message is written
+to local JSON files under
+`$OPENCODE_DATA_DIR/storage/message/{sessionID}/msg_{messageID}.json`
+(default data dir: `~/.local/share/opencode`, including on Windows --
+OpenCode follows the XDG layout on every platform). Verified two ways:
+ccusage's own OpenCode data-source guide (ccusage.com/guide/opencode/,
+already this codebase's cited prior art for adapter quirks) documents this
+exact path and the `OPENCODE_DATA_DIR` override; tokscale's README
+(github.com/junhoyeo/tokscale) independently lists the same
+`~/.local/share/opencode/storage/message/` path as its "legacy/unmigrated"
+fallback alongside a newer SQLite `opencode.db` (v1.2+) that tokscale also
+reads but this adapter does not -- this package has zero runtime
+dependencies by design, and a SQLite reader isn't worth adding against that
+constraint, so only the plain-JSON message-file format is supported for now.
+
+The per-message field shapes handled here (tokens.input/output/reasoning,
+tokens.cache.read/write, cost, modelID, providerID) are taken verbatim from
+OpenCode's own generated SDK types
+(packages/sdk/js/src/gen/types.gen.ts, dev branch, AssistantMessage).
+"""
+from __future__ import annotations
+
+import getpass
+import json
+import os
+from datetime import datetime, timezone
+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 = "opencode"
+OPENCODE_DATA_DIR_ENV = "OPENCODE_DATA_DIR"
+
+
+def resolve_opencode_data_dirs(env: Optional[Dict[str, str]] = None) -> List[str]:
+    """
+    Resolves the directories to scan for local OpenCode message logs.
+    `OPENCODE_DATA_DIR` may name a single directory or a comma-separated
+    list (ccusage's own adapter supports the same override, for the same
+    reason: OpenCode can be pointed at more than one data root). Falls back
+    to the documented default, `~/.local/share/opencode` -- including on
+    Windows, where OpenCode still uses the XDG-style relative path under
+    `%USERPROFILE%`.
+    """
+    if env is None:
+        env = dict(os.environ)
+
+    env_value = env.get(OPENCODE_DATA_DIR_ENV)
+    if env_value and env_value.strip():
+        return [d.strip() for d in env_value.split(",") if d.strip()]
+
+    home = env.get("HOME") or env.get("USERPROFILE")
+    if not home:
+        return []
+    return [str(Path(home, ".local", "share", "opencode"))]
+
+
+def _window_bounds_ms(window: DateWindow) -> "tuple[int, int]":
+    start = datetime.fromisoformat(f"{window.start}T00:00:00.000+00:00")
+    end = datetime.fromisoformat(f"{window.end}T23:59:59.999+00:00")
+    return int(start.timestamp() * 1000), int(end.timestamp() * 1000)
+
+
+def _list_message_files(data_dir: str) -> List[Path]:
+    """
+    Lists every message JSON file under each session subdirectory of
+    `<data_dir>/storage/message/`. Missing directories (data dir doesn't
+    exist, or a session subdirectory disappeared mid-scan) resolve to an
+    empty list rather than raising -- this is local disk state being read
+    opportunistically, not a versioned API contract, and a half-written or
+    already-cleaned-up session shouldn't fail the whole scan.
+    """
+    message_dir = Path(data_dir, "storage", "message")
+    if not message_dir.is_dir():
+        return []
+
+    files: List[Path] = []
+    for session_dir in sorted(message_dir.iterdir()):
+        if not session_dir.is_dir():
+            continue
+        for entry in sorted(session_dir.iterdir()):
+            if entry.is_file() and entry.suffix == ".json":
+                files.append(entry)
+    return files
+
+
+def fetch_opencode_spend(
+    window: DateWindow, data_dirs: Optional[List[str]] = None
+) -> AdapterResult:
+    """
+    Fetches local OpenCode spend for the given window by scanning message
+    JSON files directly on disk -- there is no admin API to call. Unlike the
+    Cursor/Claude Code adapters, this can only ever see the current
+    machine's own local usage: OpenCode's message files carry no user/email
+    field at all (confirmed against its own SDK types -- it's a
+    single-developer local tool with no team concept), so every message
+    found is attributed to one synthetic user: the OS account running
+    `teamspend`. Rolling up spend across a real team means running
+    `teamspend` on each person's machine (or collecting their numbers out of
+    band and using the CSV-import fallback).
+
+    Raises DataUnavailableError when no local message store is found at all
+    (missing data dir, or a data dir with no `storage/message` files), so
+    the CSV-import fallback engages the same way it does for a tool whose
+    live API can't cover part of the window. A data dir that exists but has
+    no messages *inside the requested window* is a different, legitimate
+    case (an inactive period) and returns a normal empty-users result
+    instead.
+    """
+    if data_dirs is None:
+        data_dirs = resolve_opencode_data_dirs()
+
+    all_files: List[Path] = []
+    for data_dir in data_dirs:
+        all_files.extend(_list_message_files(data_dir))
+
+    if not all_files:
+        resolved = ", ".join(data_dirs) if data_dirs else (
+            "(no data directory resolved -- set OPENCODE_DATA_DIR or $HOME)"
+        )
+        raise DataUnavailableError(
+            TOOL,
+            f"no local OpenCode message logs found under {resolved} -- "
+            "opencode has no admin/team API, only local per-machine session logs",
+        )
+
+    start_ms, end_ms = _window_bounds_ms(window)
+
+    input_tokens = 0
+    output_tokens = 0
+    cache_read_tokens = 0
+    cache_write_tokens = 0
+    requests = 0
+    cost_usd = 0.0
+    # Per-session totals, keyed by each message's own sessionID (the same
+    # sessionID that names its parent storage/message/{sessionID}/
+    # directory). A message with no sessionID still contributes to the flat
+    # totals above, just not to this dict.
+    session_totals: Dict[str, Dict[str, Any]] = {}
+
+    for file_path in all_files:
+        try:
+            raw: Dict[str, Any] = json.loads(file_path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            # Corrupt or partially-written file (e.g. opencode was mid-write
+            # when this ran) -- skip it rather than failing the entire
+            # snapshot over one bad file among what can be thousands on an
+            # active machine.
+            continue
+
+        if raw.get("role") != "assistant":
+            continue
+
+        created_ms = raw.get("time", {}).get("created") if isinstance(raw.get("time"), dict) else None
+        if created_ms is None or created_ms < start_ms or created_ms > end_ms:
+            continue
+
+        requests += 1
+        tokens = raw.get("tokens") or {}
+        cache = tokens.get("cache") or {}
+        message_input_tokens = tokens.get("input") or 0
+        message_output_tokens = tokens.get("output") or 0
+        message_cost = raw.get("cost") or 0
+        input_tokens += message_input_tokens
+        output_tokens += message_output_tokens
+        cache_read_tokens += cache.get("read") or 0
+        cache_write_tokens += cache.get("write") or 0
+        cost_usd += message_cost
+
+        session_id = raw.get("sessionID")
+        if session_id:
+            totals = session_totals.setdefault(
+                session_id,
+                {"cost_usd": 0.0, "input_tokens": 0, "output_tokens": 0, "requests": 0},
+            )
+            totals["cost_usd"] += message_cost
+            totals["input_tokens"] += message_input_tokens
+            totals["output_tokens"] += message_output_tokens
+            totals["requests"] += 1
+
+    if requests == 0:
+        return AdapterResult(
+            source=TOOL, window=window, total_cost_usd=0, is_estimated=False, users=[]
+        )
+
+    # Only attach `sessions` when at least one message actually carried a
+    # sessionID -- an empty list would misleadingly claim "zero sessions"
+    # rather than "couldn't group anything."
+    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"],
+                # Same reasoning as the overall result below: OpenCode has
+                # no real cost source of truth, so every session's dollar
+                # figure is just as estimated as the aggregate one.
+                is_estimated=True,
+            )
+            for session_id, totals in session_totals.items()
+        ]
+        if session_totals
+        else None
+    )
+
+    users = [
+        UserUsage(
+            user_id=getpass.getuser(),
+            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,
+            # OpenCode has no admin-billed source of truth for cost the way
+            # Cursor/Claude Code do. Per ccusage's own OpenCode guide:
+            # "OpenCode stores cost: 0 in message files. Costs are
+            # calculated from token counts using LiteLLM pricing."
+            # teamspend bundles no per-token pricing table of its own -- one
+            # would drift from real vendor prices and would be exactly the
+            # kind of guessed data format this adapter is supposed to avoid
+            # -- so it only ever sums whatever cost OpenCode itself recorded
+            # (frequently $0) and always flags the result as estimated,
+            # even on the rare message where that field is genuinely
+            # populated.
+            is_estimated=True,
+            sessions=sessions,
+        )
+    ]
+
+    return AdapterResult(
+        source=TOOL,
+        window=window,
+        total_cost_usd=sum_cost(users),
+        is_estimated=True,
+        users=users,
+    )