pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/ui/shell/usage_adapters/openai_admin.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import os
+import time
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Any, cast
+
+import aiohttp
+
+from pythinker_code.auth import OPENAI_API_PLATFORM_ID
+from pythinker_code.ui.shell.usage_adapters.base import UsageReport, UsageRow
+from pythinker_code.utils.aiohttp import new_client_session
+
+if TYPE_CHECKING:
+    from pythinker_code.auth.oauth import OAuthManager
+    from pythinker_code.config import LLMProvider
+
+
+OPENAI_BASE = "https://api.openai.com/v1"
+ADMIN_PREFIX = "sk-admin-"
+
+
+class OpenAIAdminAdapter:
+    platform_id = OPENAI_API_PLATFORM_ID
+    requires_admin_key = True
+    provider_label = "OpenAI API"
+
+    async def fetch(
+        self,
+        provider: LLMProvider,
+        oauth_mgr: OAuthManager,
+    ) -> UsageReport:
+        del oauth_mgr
+        admin_key = select_admin_key(provider.api_key.get_secret_value())
+        if admin_key is None:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=[
+                    "Set OPENAI_ADMIN_KEY (sk-admin-…) to see usage and cost data.",
+                    "The OpenAI Admin API does not accept regular sk-proj-… keys.",
+                ],
+                unit_hint="USD",
+            )
+
+        start_time = int(time.time()) - 24 * 60 * 60
+        costs = await _safe_get(
+            f"{OPENAI_BASE}/organization/costs",
+            {"start_time": start_time, "limit": 1},
+            admin_key,
+        )
+        completions = await _safe_get(
+            f"{OPENAI_BASE}/organization/usage/completions",
+            {
+                "start_time": start_time,
+                "bucket_width": "1d",
+                "limit": 7,
+                "group_by": "model",
+            },
+            admin_key,
+        )
+
+        cost_summary = parse_openai_costs(costs) if costs is not None else None
+        completion_rows = parse_openai_completions(completions) if completions is not None else []
+
+        notes: list[str] = []
+        if costs is None:
+            notes.append("OpenAI costs endpoint returned no usable data.")
+        elif not _has_bucket_results_shape(costs) or not _has_cost_results_shape(costs):
+            notes.append("OpenAI cost response had unexpected shape.")
+        if completions is None:
+            notes.append("OpenAI completions usage endpoint returned no usable data.")
+        elif not _has_bucket_results_shape(completions):
+            notes.append("OpenAI completions usage response had unexpected shape.")
+
+        return UsageReport(
+            self.provider_label,
+            cost_summary,
+            completion_rows,
+            notes=notes,
+            unit_hint="USD + tokens",
+        )
+
+
+def select_admin_key(provider_api_key: str) -> str | None:
+    env_key = os.getenv("OPENAI_ADMIN_KEY")
+    if env_key:
+        return env_key
+    if provider_api_key.startswith(ADMIN_PREFIX):
+        return provider_api_key
+    return None
+
+
+async def _safe_get(
+    url: str,
+    params: Mapping[str, str | int],
+    api_key: str,
+) -> Mapping[str, Any] | None:
+    try:
+        async with (
+            new_client_session() as session,
+            session.get(
+                url,
+                params=params,
+                headers={"Authorization": f"Bearer {api_key}"},
+                timeout=aiohttp.ClientTimeout(total=5),
+                raise_for_status=True,
+            ) as resp,
+        ):
+            payload = await resp.json()
+    except (TimeoutError, aiohttp.ClientError):
+        return None
+    if not isinstance(payload, Mapping):
+        return None
+    return cast(Mapping[str, Any], payload)
+
+
+def parse_openai_costs(payload: Mapping[str, Any]) -> UsageRow | None:
+    data = _as_sequence(payload.get("data"))
+    if data is None:
+        return None
+
+    total_cents = 0
+    for bucket_raw in data:
+        if not isinstance(bucket_raw, Mapping):
+            return None
+        bucket = cast(Mapping[str, Any], bucket_raw)
+        results = _as_sequence(bucket.get("results"))
+        if results is None:
+            return None
+        for result_raw in results:
+            if not isinstance(result_raw, Mapping):
+                return None
+            result = cast(Mapping[str, Any], result_raw)
+            amount = result.get("amount")
+            if not isinstance(amount, Mapping):
+                return None
+            cents = _to_cents(cast(Mapping[str, Any], amount).get("value"))
+            if cents is None:
+                return None
+            total_cents += cents
+
+    return UsageRow("Cost (last 24h)", total_cents, 0, unit="USD")
+
+
+def parse_openai_completions(payload: Mapping[str, Any]) -> list[UsageRow]:
+    data = _as_sequence(payload.get("data"))
+    if data is None:
+        return []
+
+    totals: dict[str, int] = {}
+    for bucket_raw in data:
+        if not isinstance(bucket_raw, Mapping):
+            continue
+        bucket = cast(Mapping[str, Any], bucket_raw)
+        results = _as_sequence(bucket.get("results"))
+        if results is None:
+            continue
+        for result_raw in results:
+            if not isinstance(result_raw, Mapping):
+                continue
+            result = cast(Mapping[str, Any], result_raw)
+            model = result.get("model")
+            if not isinstance(model, str) or not model:
+                continue
+            totals[model] = totals.get(model, 0) + _to_int(result.get("input_tokens"))
+            totals[model] += _to_int(result.get("output_tokens"))
+
+    return [
+        UsageRow(model, used, 0, unit="tokens")
+        for model, used in sorted(totals.items(), key=lambda item: item[1], reverse=True)
+    ]
+
+
+def _as_sequence(value: Any) -> Sequence[Any] | None:
+    if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
+        return cast(Sequence[Any], value)
+    return None
+
+
+def _has_bucket_results_shape(payload: Mapping[str, Any]) -> bool:
+    data = _as_sequence(payload.get("data"))
+    if data is None:
+        return False
+    for bucket_raw in data:
+        if not isinstance(bucket_raw, Mapping):
+            return False
+        bucket = cast(Mapping[str, Any], bucket_raw)
+        if _as_sequence(bucket.get("results")) is None:
+            return False
+    return True
+
+
+def _has_cost_results_shape(payload: Mapping[str, Any]) -> bool:
+    data = _as_sequence(payload.get("data"))
+    if data is None:
+        return False
+    for bucket_raw in data:
+        bucket = cast(Mapping[str, Any], bucket_raw)
+        results = cast(Sequence[Any], bucket.get("results"))
+        for result_raw in results:
+            if not isinstance(result_raw, Mapping):
+                return False
+            result = cast(Mapping[str, Any], result_raw)
+            amount = result.get("amount")
+            if not isinstance(amount, Mapping):
+                return False
+            if _to_cents(cast(Mapping[str, Any], amount).get("value")) is None:
+                return False
+    return True
+
+
+def _to_cents(value: Any) -> int | None:
+    try:
+        return int(round(float(value) * 100))
+    except (OverflowError, TypeError, ValueError):
+        return None
+
+
+def _to_int(value: Any) -> int:
+    try:
+        return int(value)
+    except (OverflowError, TypeError, ValueError):
+        return 0

pythinker_code/ui/shell/usage_adapters/openai_chatgpt.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any, cast
+
+import aiohttp
+
+from pythinker_code.auth import OPENAI_CHATGPT_PLATFORM_ID
+from pythinker_code.ui.shell.usage_adapters.base import UsageReport, UsageRow
+from pythinker_code.utils.aiohttp import new_client_session
+from pythinker_code.utils.datetime import format_duration
+
+if TYPE_CHECKING:
+    from pythinker_code.auth.oauth import OAuthManager
+    from pythinker_code.config import LLMProvider
+
+CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage"
+
+
+class OpenAIChatGPTAdapter:
+    platform_id = OPENAI_CHATGPT_PLATFORM_ID
+    requires_admin_key = False
+    provider_label = "ChatGPT Codex"
+
+    async def fetch(
+        self,
+        provider: LLMProvider,
+        oauth_mgr: OAuthManager,
+    ) -> UsageReport:
+        if provider.oauth is None:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=["Codex usage requires an OAuth login (`/login openai-chatgpt`)."],
+                unit_hint="quota",
+            )
+
+        access_token = oauth_mgr.resolve_api_key(provider.api_key, provider.oauth)
+        account_id = oauth_mgr.get_chatgpt_account_id(provider.oauth)
+        if not account_id:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=["Missing ChatGPT account_id in OAuth token."],
+                unit_hint="quota",
+            )
+
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "Accept": "application/json",
+            "ChatGPT-Account-Id": account_id,
+            "Origin": "https://chatgpt.com",
+            "Referer": "https://chatgpt.com/",
+            "User-Agent": "pythinker-code",
+        }
+        try:
+            async with (
+                new_client_session() as session,
+                session.get(
+                    CODEX_USAGE_URL,
+                    headers=headers,
+                    timeout=aiohttp.ClientTimeout(total=5),
+                    raise_for_status=True,
+                ) as resp,
+            ):
+                payload = await resp.json(content_type=None)
+        except aiohttp.ClientResponseError as e:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=[f"Codex usage fetch failed: HTTP {e.status}"],
+                unit_hint="quota",
+            )
+        except (aiohttp.ClientError, TimeoutError) as e:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=[f"Codex usage fetch failed: {e}"],
+                unit_hint="quota",
+            )
+
+        return parse_codex_usage_payload(payload)
+
+
+def parse_codex_usage_payload(payload: object) -> UsageReport:
+    if not isinstance(payload, Mapping):
+        return UsageReport(
+            OpenAIChatGPTAdapter.provider_label,
+            None,
+            [],
+            notes=["Unexpected Codex response shape."],
+            unit_hint="quota",
+        )
+
+    payload_map = cast(Mapping[str, Any], payload)
+    rate_limit = payload_map.get("rate_limit") or payload_map.get("rate_limits")
+    if not isinstance(rate_limit, Mapping):
+        return UsageReport(
+            OpenAIChatGPTAdapter.provider_label,
+            None,
+            [],
+            notes=["No rate_limit data in Codex response."],
+            unit_hint="quota",
+        )
+
+    rate_map = cast(Mapping[str, Any], rate_limit)
+    notes: list[str] = []
+
+    # `allowed` / `limit_reached` are top-level booleans on the current shape.
+    if rate_map.get("limit_reached") is True:
+        notes.append("Rate limit reached.")
+    elif rate_map.get("allowed") is False:
+        notes.append("Requests currently not allowed by the rate limiter.")
+
+    # Codex's wham/usage response carries up to two windows under
+    # `primary_window` / `secondary_window` (older releases used `five_hour` /
+    # `weekly`). Accounts on some plans only return one of them — and the slot
+    # name is NOT a reliable indicator of which window is shorter (e.g. free
+    # accounts can put a 7-day window in `primary_window`). Classify by
+    # `limit_window_seconds` instead, then sort smallest first.
+    rows: list[tuple[int, UsageRow]] = []
+    for slot in ("primary_window", "secondary_window", "five_hour", "weekly"):
+        window = rate_map.get(slot)
+        if not isinstance(window, Mapping):
+            continue
+        if pair := _row_for_codex_window(cast(Mapping[str, Any], window)):
+            rows.append(pair)
+
+    rows.sort(key=lambda item: item[0] or 10**12)
+    summary = rows[0][1] if rows else None
+    limits = [row for _, row in rows[1:]]
+
+    if summary is None and not limits:
+        # Surface what we did see so a future rename is obvious.
+        outer = ", ".join(sorted(rate_map.keys())) or "<empty>"
+        inner_hint = ""
+        for slot in ("primary_window", "secondary_window", "five_hour", "weekly"):
+            window = rate_map.get(slot)
+            if isinstance(window, Mapping):
+                inner_keys = ", ".join(sorted(cast(Mapping[str, Any], window).keys()))
+                inner_hint = f" Inner `{slot}` keys: {inner_keys}."
+                break
+        notes.append(
+            f"Codex returned rate_limit with no recognized quota fields "
+            f"(outer keys: {outer}).{inner_hint} "
+            f"Adapter expects a window object with `used_percent` (or "
+            f"`percent_left`) and `limit_window_seconds`."
+        )
+
+    return UsageReport(
+        OpenAIChatGPTAdapter.provider_label,
+        summary,
+        limits,
+        notes=notes,
+        unit_hint="quota",
+    )
+
+
+def _row_for_codex_window(window: Mapping[str, Any]) -> tuple[int, UsageRow] | None:
+    """Build a UsageRow from a single Codex rate-limit window object.
+
+    Returns (window_seconds, row) so the caller can sort windows shortest-
+    first. Handles both the current snake_case shape (`used_percent`,
+    `limit_window_seconds`, `resets_at`) and the older shape (`percent_left`,
+    `limit_window_seconds`, `reset_at`).
+    """
+    if "used_percent" in window:
+        used_percent = window.get("used_percent")
+        if not isinstance(used_percent, int | float):
+            return None
+        percent_left = max(0, 100 - int(used_percent))
+    elif "percent_left" in window:
+        raw_percent_left = window.get("percent_left")
+        if not isinstance(raw_percent_left, int | float):
+            return None
+        percent_left = int(raw_percent_left)
+    else:
+        return None
+
+    raw_window_seconds = window.get("limit_window_seconds")
+    window_seconds = int(raw_window_seconds) if isinstance(raw_window_seconds, int | float) else 0
+
+    return window_seconds, UsageRow(
+        label=_label_for_codex_window(window_seconds),
+        used=percent_left,
+        limit=100,
+        unit="%",
+        reset_hint=_codex_reset_hint(window),
+    )
+
+
+def _label_for_codex_window(seconds: int) -> str:
+    if seconds <= 0:
+        return "Rate limit"
+    if seconds <= 24 * 3600:
+        hours = seconds / 3600
+        return f"{hours:g}h window"
+    days = seconds // 86400
+    if 6 <= days <= 8:
+        return "Weekly window"
+    return f"{days}d window"
+
+
+def _codex_reset_hint(win_map: Mapping[str, Any]) -> str | None:
+    # Current shape: `resets_at` is a unix-seconds timestamp.
+    # Older shape: `reset_at` is an ISO-8601 string.
+    resets_at_unix = win_map.get("resets_at")
+    if isinstance(resets_at_unix, int | float):
+        try:
+            dt = datetime.fromtimestamp(float(resets_at_unix), tz=UTC)
+        except (OverflowError, OSError, ValueError):
+            return None
+        return _format_reset_delta(dt, win_map)
+
+    reset_at = win_map.get("reset_at")
+    if reset_at is None:
+        return None
+    reset_at_str = str(reset_at)
+    try:
+        dt = datetime.fromisoformat(reset_at_str.replace("Z", "+00:00"))
+    except (TypeError, ValueError):
+        return f"resets at {reset_at_str}"
+    return _format_reset_delta(dt, win_map)
+
+
+def _format_reset_delta(dt: datetime, win_map: Mapping[str, Any]) -> str:
+    delta = dt - datetime.now(UTC)
+    seconds = int(delta.total_seconds())
+    if seconds <= 0:
+        window_seconds = win_map.get("limit_window_seconds")
+        if isinstance(window_seconds, int | float) and window_seconds > 0:
+            while seconds <= 0:
+                seconds += int(window_seconds)
+    if seconds <= 0:
+        return "reset"
+    return f"resets in {format_duration(seconds)}"

pythinker_code/ui/shell/usage_adapters/opencode_go.py

@@ -0,0 +1,232 @@
+"""OpenCode Go usage adapter.
+
+OpenCode Go has no public Bearer-API-key usage endpoint as of 2026-05-06
+(verified via context7 `/anomalyco/opencode` and tavily — only chat
+endpoints are documented; the upstream FR `anomalyco/opencode#16017` is
+still open). Live consumption is only available by scraping the
+authenticated workspace dashboard, which the
+`slkiser/opencode-quota` plugin demonstrated:
+
+    GET https://opencode.ai/workspace/<workspace_id>/go
+    Cookie: auth=<auth_cookie>
+
+The page is server-rendered with SolidJS and inlines a
+`{rollingUsage,weeklyUsage,monthlyUsage}: $R[N]={ usagePercent, resetInSec }`
+hydration block we can regex out. We mirror the slkiser parser shape so
+the same workspace_id + auth_cookie config works in both tools.
+
+If `OPENCODE_GO_WORKSPACE_ID` and `OPENCODE_GO_AUTH_COOKIE` are set the
+adapter scrapes the live dashboard. Otherwise it falls back to the
+published static plan caps ($12 / 5h, $30 / week, $60 / month per
+opencode.ai/docs/go/) so the panel still has useful numbers.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from datetime import UTC, datetime, timedelta
+from typing import TYPE_CHECKING
+from urllib.parse import quote
+
+import aiohttp
+
+from pythinker_code.auth import OPENCODE_GO_PLATFORM_ID
+from pythinker_code.ui.shell.usage_adapters.base import UsageReport, UsageRow
+from pythinker_code.utils.aiohttp import new_client_session
+from pythinker_code.utils.datetime import format_duration
+
+if TYPE_CHECKING:
+    from pythinker_code.auth.oauth import OAuthManager
+    from pythinker_code.config import LLMProvider
+
+
+_DASHBOARD_URL_PREFIX = "https://opencode.ai/workspace/"
+_DASHBOARD_URL_SUFFIX = "/go"
+_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Gecko/20100101 Firefox/148.0"
+_SCRAPE_TIMEOUT_S = 10.0
+
+_NUM = r"(-?\d+(?:\.\d+)?)"
+_WINDOWS = (
+    ("rollingUsage", "5h"),
+    ("weeklyUsage", "Weekly"),
+    ("monthlyUsage", "Monthly"),
+)
+# For each window, a pair of regexes (pct-first then reset-first) since
+# SolidJS may emit fields in either order.
+_WINDOW_REGEXES: dict[str, tuple[re.Pattern[str], re.Pattern[str]]] = {
+    name: (
+        re.compile(
+            rf"{name}:\$R\[\d+\]=\{{[^}}]*usagePercent:{_NUM}[^}}]*resetInSec:{_NUM}[^}}]*\}}"
+        ),
+        re.compile(
+            rf"{name}:\$R\[\d+\]=\{{[^}}]*resetInSec:{_NUM}[^}}]*usagePercent:{_NUM}[^}}]*\}}"
+        ),
+    )
+    for name, _ in _WINDOWS
+}
+
+# Plan caps published at https://opencode.ai/docs/go/ (verified 2026-05-06).
+# Values in USD minor units (cents).
+_PLAN_CAPS: dict[str, int] = {
+    "5h": 1200,
+    "Weekly": 3000,
+    "Monthly": 6000,
+}
+
+
+class OpenCodeGoAdapter:
+    platform_id = OPENCODE_GO_PLATFORM_ID
+    requires_admin_key = False
+    provider_label = "OpenCode Go"
+
+    async def fetch(
+        self,
+        provider: LLMProvider,
+        oauth_mgr: OAuthManager,
+    ) -> UsageReport:
+        workspace_id = (os.getenv("OPENCODE_GO_WORKSPACE_ID") or "").strip()
+        auth_cookie = (os.getenv("OPENCODE_GO_AUTH_COOKIE") or "").strip()
+
+        if workspace_id and auth_cookie:
+            scraped, error = await _scrape_dashboard(workspace_id, auth_cookie)
+            if scraped:
+                return _report_from_windows(scraped, live=True)
+            return _report_from_caps(error_note=error)
+
+        if workspace_id or auth_cookie:
+            missing = "OPENCODE_GO_AUTH_COOKIE" if workspace_id else "OPENCODE_GO_WORKSPACE_ID"
+            return _report_from_caps(
+                error_note=(
+                    f"Live OpenCode Go usage needs both env vars; missing {missing}. "
+                    "Static plan caps shown above."
+                )
+            )
+
+        return _report_from_caps(
+            error_note=(
+                "Set OPENCODE_GO_WORKSPACE_ID and OPENCODE_GO_AUTH_COOKIE to scrape "
+                "live usage from your workspace dashboard. Both come from your "
+                "browser session at opencode.ai (workspace id from the URL, "
+                "auth cookie from devtools → Application → Cookies). Static plan "
+                "caps shown above in the meantime."
+            )
+        )
+
+
+async def _scrape_dashboard(
+    workspace_id: str, auth_cookie: str
+) -> tuple[dict[str, tuple[float, float]] | None, str | None]:
+    """Fetch the OpenCode Go dashboard and parse out window usage.
+
+    Returns (windows, None) on success, where windows maps the window label
+    (`5h`/`Weekly`/`Monthly`) to (`usage_percent`, `reset_in_sec`).
+    Returns (None, error_message) on any failure. Never raises.
+    """
+    url = f"{_DASHBOARD_URL_PREFIX}{quote(workspace_id, safe='')}{_DASHBOARD_URL_SUFFIX}"
+    headers = {
+        "User-Agent": _USER_AGENT,
+        "Accept": "text/html",
+        "Cookie": f"auth={auth_cookie}",
+    }
+    try:
+        async with (
+            new_client_session() as session,
+            session.get(
+                url,
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(total=_SCRAPE_TIMEOUT_S),
+                raise_for_status=True,
+            ) as resp,
+        ):
+            html = await resp.text()
+    except aiohttp.ClientResponseError as e:
+        if e.status in (401, 403):
+            return None, (
+                "OpenCode Go dashboard returned "
+                f"HTTP {e.status} — refresh your auth cookie from opencode.ai."
+            )
+        return None, f"OpenCode Go dashboard returned HTTP {e.status}"
+    except (TimeoutError, aiohttp.ClientError) as e:
+        return None, f"OpenCode Go dashboard fetch failed: {e}"
+
+    windows: dict[str, tuple[float, float]] = {}
+    for field, label in _WINDOWS:
+        pct_first, reset_first = _WINDOW_REGEXES[field]
+        if match := pct_first.search(html):
+            usage_percent, reset_in_sec = float(match.group(1)), float(match.group(2))
+        elif match := reset_first.search(html):
+            reset_in_sec, usage_percent = float(match.group(1)), float(match.group(2))
+        else:
+            continue
+        windows[label] = (usage_percent, reset_in_sec)
+
+    if not windows:
+        return None, (
+            "OpenCode Go dashboard scrape returned no recognizable windows — the "
+            "dashboard markup may have changed."
+        )
+    return windows, None
+
+
+def _report_from_windows(windows: dict[str, tuple[float, float]], *, live: bool) -> UsageReport:
+    rows: list[UsageRow] = []
+    for label in ("5h", "Weekly", "Monthly"):
+        if label not in windows:
+            continue
+        usage_percent, reset_in_sec = windows[label]
+        percent_left = max(0, min(100, int(round(100 - usage_percent))))
+        rows.append(
+            UsageRow(
+                label=f"{label} window",
+                used=percent_left,
+                limit=100,
+                unit="%",
+                reset_hint=_reset_hint(reset_in_sec),
+            )
+        )
+    notes: list[str] = []
+    if live:
+        notes.append(
+            "Live OpenCode Go usage scraped from the workspace dashboard. "
+            f"Plan caps: 5h ${_PLAN_CAPS['5h'] / 100:.0f}, "
+            f"weekly ${_PLAN_CAPS['Weekly'] / 100:.0f}, "
+            f"monthly ${_PLAN_CAPS['Monthly'] / 100:.0f}."
+        )
+    summary = rows[0] if rows else None
+    return UsageReport(
+        provider_label=OpenCodeGoAdapter.provider_label,
+        summary=summary,
+        limits=rows[1:],
+        notes=notes,
+        unit_hint="quota",
+    )
+
+
+def _report_from_caps(*, error_note: str | None) -> UsageReport:
+    rows = [
+        UsageRow(label=f"{label} cap", used=0, limit=cents, unit="USD")
+        for label, cents in _PLAN_CAPS.items()
+    ]
+    notes: list[str] = []
+    if error_note:
+        notes.append(error_note)
+    notes.append(
+        "Live consumption isn't exposed via API key (anomalyco/opencode#16017). "
+        "The web console at opencode.ai is the authoritative source."
+    )
+    return UsageReport(
+        provider_label=OpenCodeGoAdapter.provider_label,
+        summary=rows[0],
+        limits=rows[1:],
+        notes=notes,
+        unit_hint="quota",
+    )
+
+
+def _reset_hint(reset_in_sec: float) -> str | None:
+    seconds = int(reset_in_sec)
+    if seconds <= 0:
+        return None
+    reset_at = datetime.now(UTC) + timedelta(seconds=seconds)
+    return f"resets in {format_duration(seconds)} ({reset_at.strftime('%Y-%m-%d %H:%M UTC')})"