pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/ui/shell/update.py

@@ -0,0 +1,352 @@
+from __future__ import annotations
+
+import asyncio
+import re
+import subprocess
+import sys
+import time
+from enum import Enum, auto
+from pathlib import Path
+from shutil import which
+
+import aiohttp
+from rich.text import Text
+
+from pythinker_code.share import get_share_dir
+from pythinker_code.ui.shell.console import console
+from pythinker_code.utils.aiohttp import new_client_session
+from pythinker_code.utils.logging import logger
+
+PYPI_JSON_URL = "https://pypi.org/pypi/pythinker-code/json"
+CHANGELOG_URL_EN = "https://github.com/mohamed-elkholy95/Pythinker-Code/blob/main/CHANGELOG.md"
+
+# Default upgrade command. `_detect_upgrade_command()` overrides this when the
+# install method is recognizable from `sys.executable`.
+UPGRADE_COMMAND = ["uv", "tool", "upgrade", "pythinker-code"]
+
+LATEST_VERSION_FILE = get_share_dir() / "latest_version.txt"
+SKIPPED_VERSION_FILE = get_share_dir() / "skipped_version.txt"
+LAST_UPDATE_CHECK_FILE = get_share_dir() / "last_update_check.txt"
+AUTO_UPDATE_CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+
+_UPDATE_LOCK = asyncio.Lock()
+
+
+class UpdateResult(Enum):
+    UPDATE_AVAILABLE = auto()
+    UPDATED = auto()
+    UP_TO_DATE = auto()
+    FAILED = auto()
+    UNSUPPORTED = auto()
+
+
+def semver_tuple(version: str) -> tuple[int, int, int]:
+    v = version.strip()
+    if v.startswith("v"):
+        v = v[1:]
+    match = re.match(r"^(\d+)\.(\d+)(?:\.(\d+))?", v)
+    if not match:
+        return (0, 0, 0)
+    major = int(match.group(1))
+    minor = int(match.group(2))
+    patch = int(match.group(3) or 0)
+    return (major, minor, patch)
+
+
+def _detect_upgrade_command() -> list[str]:
+    """Pick the right upgrade argv based on how this interpreter was installed."""
+    exe = sys.executable.replace("\\", "/").lower()
+    if "/uv/tools/" in exe:
+        return ["uv", "tool", "upgrade", "pythinker-code"]
+    if "/pipx/venvs/" in exe:
+        return ["pipx", "upgrade", "pythinker-code"]
+    return [sys.executable, "-m", "pip", "install", "--upgrade", "pythinker-code"]
+
+
+def _format_upgrade_command(command: list[str]) -> str:
+    if _is_windows():
+        return subprocess.list2cmdline(command)
+    return " ".join(shlex_quote(part) for part in command)
+
+
+def shlex_quote(value: str) -> str:
+    if not value:
+        return "''"
+    if re.fullmatch(r"[A-Za-z0-9_@%+=:,./-]+", value):
+        return value
+    return "'" + value.replace("'", "'\\''") + "'"
+
+
+def _is_windows() -> bool:
+    return sys.platform == "win32"
+
+
+def _spawn_detached_windows_upgrade(upgrade_command: list[str]) -> bool:
+    """Launch the upgrade in a new console window that survives this process exit.
+
+    Returns True if the helper was spawned. The new console sleeps a few seconds
+    before invoking ``upgrade_command`` so the currently running ``pythinker.exe``
+    has time to exit and release the executable lock that ``uv``/``pip`` would
+    otherwise trip over with ``os error 32``.
+    """
+    if not _is_windows():
+        return False
+    if which("cmd") is None:
+        return False
+    DETACHED_PROCESS = 0x00000008
+    CREATE_NEW_PROCESS_GROUP = 0x00000200
+    # `start "" cmd /k <inner>` opens a new console; `timeout` gives the parent
+    # time to exit so the exe lock releases before the upgrade runs.
+    formatted_command = _format_upgrade_command(upgrade_command)
+    inner = (
+        "echo Waiting for Pythinker to exit... "
+        "& timeout /t 3 /nobreak >nul "
+        f"& {formatted_command} "
+        "& echo. "
+        "& echo Upgrade finished. Press any key to close this window. "
+        "& pause >nul"
+    )
+    try:
+        subprocess.Popen(
+            ["cmd", "/c", "start", "", "cmd", "/k", inner],
+            creationflags=DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP,
+            close_fds=True,
+        )
+    except OSError:
+        logger.exception("Failed to spawn detached Windows upgrade:")
+        return False
+    return True
+
+
+async def _get_latest_version(session: aiohttp.ClientSession) -> str | None:
+    try:
+        async with session.get(PYPI_JSON_URL) as resp:
+            resp.raise_for_status()
+            data = await resp.json(content_type=None)
+            version = data.get("info", {}).get("version")
+            return str(version).strip() if version else None
+    except (TimeoutError, aiohttp.ClientError):
+        logger.exception("Failed to fetch latest version from PyPI:")
+        return None
+    except Exception:
+        logger.exception("Failed to parse PyPI response:")
+        return None
+
+
+def _auto_update_disabled() -> bool:
+    from pythinker_code.utils.envvar import get_env_bool
+
+    return get_env_bool("PYTHINKER_CLI_NO_AUTO_UPDATE")
+
+
+def _is_running_from_source_checkout() -> bool:
+    """Return true when invoked from this repository via ``uv run``/editable source.
+
+    In that mode PyPI can legitimately have a newer released version than the
+    checkout's local ``pyproject.toml`` version. Showing the normal upgrade
+    banner is noisy and suggests replacing the developer checkout.
+    """
+    try:
+        import pythinker_code
+
+        package_path = Path(pythinker_code.__file__).resolve()
+    except Exception:
+        return False
+
+    for parent in package_path.parents:
+        pyproject = parent / "pyproject.toml"
+        git_dir = parent / ".git"
+        if pyproject.exists() and git_dir.exists():
+            try:
+                text = pyproject.read_text(encoding="utf-8")
+            except OSError:
+                return False
+            return 'name = "pythinker-code"' in text or "name = 'pythinker-code'" in text
+    return False
+
+
+def _should_auto_check_for_updates(now: float | None = None) -> bool:
+    if _auto_update_disabled() or _is_running_from_source_checkout():
+        return False
+    if not sys.stdout.isatty():
+        return False
+
+    now = time.time() if now is None else now
+    try:
+        last_check = LAST_UPDATE_CHECK_FILE.stat().st_mtime
+    except FileNotFoundError:
+        return True
+    except OSError:
+        logger.exception("Failed to read last update-check timestamp:")
+        return True
+    return now - last_check >= AUTO_UPDATE_CHECK_INTERVAL_SECONDS
+
+
+def _mark_auto_update_check_attempt() -> None:
+    try:
+        LAST_UPDATE_CHECK_FILE.write_text(str(int(time.time())), encoding="utf-8")
+    except OSError:
+        logger.exception("Failed to write last update-check timestamp:")
+
+
+def schedule_auto_update_check() -> asyncio.Task[UpdateResult] | None:
+    """Schedule a silent, throttled PyPI update check for interactive shell startup."""
+    if not _should_auto_check_for_updates():
+        return None
+
+    _mark_auto_update_check_attempt()
+    task = asyncio.create_task(
+        do_update(print=False, check_only=True),
+        name="pythinker-update-check",
+    )
+
+    def _log_result(done: asyncio.Task[UpdateResult]) -> None:
+        try:
+            result = done.result()
+        except asyncio.CancelledError:
+            return
+        except Exception:
+            logger.exception("Background update check failed:")
+            return
+        if result is UpdateResult.UPDATE_AVAILABLE:
+            logger.info("Update available; showing notification banner")
+            print_update_banner()
+
+    task.add_done_callback(_log_result)
+    return task
+
+
+def print_update_banner() -> None:
+    """Print a non-blocking 'Update Available' banner if a newer version is cached."""
+    from pythinker_code.constant import VERSION as current_version
+
+    if _auto_update_disabled() or _is_running_from_source_checkout():
+        return
+    if not sys.stdout.isatty():
+        return
+    if not LATEST_VERSION_FILE.exists():
+        return
+
+    try:
+        latest_version = LATEST_VERSION_FILE.read_text(encoding="utf-8").strip()
+    except OSError:
+        return
+    if not latest_version or semver_tuple(latest_version) <= semver_tuple(current_version):
+        return
+
+    if SKIPPED_VERSION_FILE.exists():
+        try:
+            skipped = SKIPPED_VERSION_FILE.read_text(encoding="utf-8").strip()
+        except OSError:
+            skipped = ""
+        if skipped == latest_version:
+            return
+
+    _render_update_banner(current_version, latest_version)
+
+
+def _update_banner_text(current_version: str, latest_version: str) -> Text:
+    upgrade_command = _detect_upgrade_command()
+    upgrade_command_text = _format_upgrade_command(upgrade_command)
+    return Text.assemble(
+        ("  ✨ ", "bold cyan"),
+        ("Update available!", "bold"),
+        (f" {current_version} -> {latest_version}", "grey50"),
+        ("\n\n  Release notes: ", "grey50"),
+        (CHANGELOG_URL_EN, "grey50 underline"),
+        ("\n\n  ", ""),
+        ("1", "bold cyan"),
+        (". Run ", ""),
+        ("pythinker update", "bold cyan"),
+        ("\n  ", ""),
+        ("2", "bold cyan"),
+        (". Or run ", ""),
+        (upgrade_command_text, "bold"),
+    )
+
+
+def _render_update_banner(current_version: str, latest_version: str) -> None:
+    console.print()
+    console.print(_update_banner_text(current_version, latest_version))
+
+
+async def do_update(*, print: bool = True, check_only: bool = False) -> UpdateResult:
+    async with _UPDATE_LOCK:
+        return await _do_update(print=print, check_only=check_only)
+
+
+async def _do_update(*, print: bool, check_only: bool) -> UpdateResult:
+    from pythinker_code.constant import VERSION as current_version
+
+    def _print(message: str) -> None:
+        if print:
+            console.print(message)
+
+    timeout = aiohttp.ClientTimeout(total=15, sock_connect=5, sock_read=10)
+    async with new_client_session(timeout=timeout) as session:
+        logger.info("Checking for updates...")
+        _print("Checking for updates...")
+        latest_version = await _get_latest_version(session)
+        if not latest_version:
+            _print("[red]Failed to check for updates.[/red]")
+            return UpdateResult.FAILED
+
+    logger.debug("Latest version: {latest_version}", latest_version=latest_version)
+    try:
+        LATEST_VERSION_FILE.write_text(latest_version, encoding="utf-8")
+    except OSError:
+        logger.exception("Failed to cache latest version:")
+
+    if semver_tuple(current_version) >= semver_tuple(latest_version):
+        logger.debug("Already up to date: {current_version}", current_version=current_version)
+        _print("[green]Already up to date.[/green]")
+        return UpdateResult.UP_TO_DATE
+
+    if check_only:
+        logger.info(
+            "Update available: current={current_version}, latest={latest_version}",
+            current_version=current_version,
+            latest_version=latest_version,
+        )
+        _print(f"[yellow]Update available: {latest_version}[/yellow]")
+        return UpdateResult.UPDATE_AVAILABLE
+
+    upgrade_command = _detect_upgrade_command()
+    upgrade_command_text = _format_upgrade_command(upgrade_command)
+    logger.info(
+        "Updating from {current_version} to {latest_version} via: {cmd}",
+        current_version=current_version,
+        latest_version=latest_version,
+        cmd=upgrade_command_text,
+    )
+    _print(f"Updating pythinker-code {current_version} → {latest_version}...")
+    _print(f"[grey50]Running: {upgrade_command_text}[/grey50]")
+
+    # On Windows, the running pythinker.exe holds an exclusive lock on its own
+    # binary. Any in-process `uv tool upgrade` / `pip install --upgrade` fails
+    # with `os error 32` (file in use). Spawn the upgrade in a detached console
+    # that waits a few seconds, then exit so the lock releases first.
+    if _is_windows() and _spawn_detached_windows_upgrade(upgrade_command):
+        _print(
+            "[yellow]Pythinker will exit so Windows can release the running executable.[/yellow]"
+        )
+        _print("[grey50]The upgrade will continue in a new console window.[/grey50]")
+        # Brief pause so the user can read the banner before the process dies.
+        await asyncio.sleep(1.0)
+        sys.exit(0)
+
+    try:
+        result = subprocess.run(upgrade_command)
+    except OSError as e:
+        logger.exception("Upgrade failed:")
+        _print(f"[red]Upgrade failed:[/red] {e}")
+        _print(f"Please run manually: {upgrade_command_text}")
+        return UpdateResult.FAILED
+
+    if result.returncode == 0:
+        _print("[green]Updated successfully![/green]")
+        _print("[yellow]Restart Pythinker CLI to use the new version.[/yellow]")
+        return UpdateResult.UPDATED
+    _print("[red]Upgrade failed. Please try running manually:[/red]")
+    _print(f"  {upgrade_command_text}")
+    return UpdateResult.FAILED

pythinker_code/ui/shell/usage.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import shlex
+from typing import TYPE_CHECKING
+
+from pythinker_code.auth.platforms import parse_managed_provider_key
+from pythinker_code.config import LLMProvider
+from pythinker_code.soul.pythinkersoul import PythinkerSoul
+from pythinker_code.ui.shell.console import console
+from pythinker_code.ui.shell.slash import registry
+from pythinker_code.ui.shell.usage_adapters import ADAPTERS
+from pythinker_code.ui.shell.usage_adapters.base import UsageAdapter, UsageReport, UsageRow
+from pythinker_code.ui.shell.usage_adapters.pythinker import to_int as _to_int
+from pythinker_code.ui.shell.usage_render import (
+    build_panel,
+)
+from pythinker_code.ui.shell.usage_render import (
+    format_row as _format_row,
+)
+from pythinker_code.ui.shell.usage_render import (
+    ratio_color as _ratio_color,
+)
+from pythinker_code.ui.shell.usage_render import (
+    remaining_quota as _remaining_quota,
+)
+from pythinker_code.usage_ratelimit_cache import get_cache
+from pythinker_code.utils.datetime import format_duration
+
+if TYPE_CHECKING:
+    from pythinker_code.auth.oauth import OAuthManager
+    from pythinker_code.ui.shell import Shell
+
+__all__ = [
+    "UsageRow",
+    "_format_row",
+    "_ratio_color",
+    "_remaining_quota",
+    "_gather_reports",
+    "_print_json",
+    "_print_no_usage_providers",
+    "_select_providers",
+    "_to_int",
+    "usage",
+]
+
+
+def _select_providers(
+    config_providers: dict[str, LLMProvider],
+    registered_platform_ids: set[str],
+    filter_provider_key: str | None,
+) -> list[tuple[str, LLMProvider]]:
+    providers = (
+        [(filter_provider_key, config_providers[filter_provider_key])]
+        if filter_provider_key in config_providers
+        else list(config_providers.items())
+        if filter_provider_key is None
+        else []
+    )
+
+    pairs: list[tuple[str, LLMProvider]] = []
+    for provider_key, provider in providers:
+        platform_id = parse_managed_provider_key(provider_key)
+        if platform_id in registered_platform_ids:
+            pairs.append((platform_id, provider))
+    return pairs
+
+
+async def _fetch_report(
+    adapter: UsageAdapter,
+    provider: LLMProvider,
+    oauth_mgr: OAuthManager,
+) -> UsageReport:
+    try:
+        return await adapter.fetch(provider, oauth_mgr)
+    except asyncio.CancelledError:
+        raise
+    except Exception as e:
+        return UsageReport(
+            provider_label=getattr(adapter, "provider_label", adapter.platform_id),
+            summary=None,
+            limits=[],
+            notes=[f"Adapter raised: {e!r}"],
+        )
+
+
+async def _gather_reports(
+    pairs: list[tuple[UsageAdapter, LLMProvider]],
+    oauth_mgr: OAuthManager,
+) -> list[UsageReport]:
+    return list(
+        await asyncio.gather(
+            *(_fetch_report(adapter, provider, oauth_mgr) for adapter, provider in pairs)
+        )
+    )
+
+
+def _print_json(value: object) -> None:
+    console.file.write(json.dumps(value, indent=2))
+    console.file.write("\n")
+    console.file.flush()
+
+
+def _print_no_usage_providers(json_mode: bool) -> None:
+    if json_mode:
+        _print_json([])
+        return
+    console.print("[yellow]No providers with usage support are configured.[/yellow]")
+
+
+def _ratelimit_fallback_report(provider_key: str, provider_label: str) -> UsageReport | None:
+    """Build a 'live rate limits' UsageReport from the most recent snapshot
+    captured for `provider_key`, or None when nothing has been recorded yet."""
+    snap = get_cache().snapshot(provider_key)
+    if snap is None:
+        return None
+
+    rows: list[UsageRow] = []
+    if snap.requests_limit is not None and snap.requests_remaining is not None:
+        rows.append(
+            UsageRow(
+                label="Requests",
+                used=snap.requests_remaining,
+                limit=snap.requests_limit,
+                unit="requests",
+                reset_hint=_seconds_to_reset_hint(snap.requests_reset_seconds),
+            )
+        )
+    if snap.tokens_limit is not None and snap.tokens_remaining is not None:
+        rows.append(
+            UsageRow(
+                label="Tokens",
+                used=snap.tokens_remaining,
+                limit=snap.tokens_limit,
+                unit="tokens",
+                reset_hint=_seconds_to_reset_hint(snap.tokens_reset_seconds),
+            )
+        )
+
+    if not rows:
+        return None
+
+    return UsageReport(
+        provider_label=f"{provider_label} (live rate limits)",
+        summary=rows[0],
+        limits=rows[1:],
+        notes=[
+            "Captured from the most recent chat-completion response headers — "
+            "no dedicated usage adapter is available for this provider yet."
+        ],
+        unit_hint="rate-limit",
+    )
+
+
+def _seconds_to_reset_hint(seconds: float | None) -> str | None:
+    if seconds is None:
+        return None
+    if seconds <= 0:
+        return "reset"
+    return f"resets in {format_duration(int(seconds))}"
+
+
+def _enrich_with_ratelimit_fallback(
+    reports: list[UsageReport],
+    selected: list[tuple[str, LLMProvider]],
+) -> list[UsageReport]:
+    """Merge live rate-limit cache rows into reports that lack real data.
+
+    A "real data" report has a `summary` or non-empty `limits`. Anything
+    without that — including notes-only reports from best-effort adapters
+    (MiniMax, OpenCode Go, Pythinker AI) — gets the cached rate-limit rows
+    appended, while the adapter's notes (which usually explain *why* there's
+    no real data) are preserved.
+    """
+    enriched: list[UsageReport] = []
+    for report, (platform_id, _) in zip(reports, selected, strict=True):
+        if report.summary is not None or report.limits:
+            enriched.append(report)
+            continue
+        fallback = _ratelimit_fallback_report(f"managed:{platform_id}", report.provider_label)
+        if fallback is None:
+            enriched.append(report)
+            continue
+        enriched.append(
+            UsageReport(
+                provider_label=fallback.provider_label,
+                summary=fallback.summary,
+                limits=fallback.limits,
+                # Adapter notes first so the user reads "why" before "what".
+                notes=[*report.notes, *fallback.notes],
+                unit_hint=fallback.unit_hint,
+            )
+        )
+    return enriched
+
+
+@registry.command(aliases=["/status"])
+async def usage(app: Shell, args: str):
+    """Display usage for the current model's provider.
+
+    Pass `all` for every provider, or a provider key to filter.
+    """
+    assert isinstance(app.soul, PythinkerSoul)
+
+    try:
+        tokens = shlex.split(args.strip())
+    except ValueError as e:
+        console.print(f"[red]Invalid usage arguments: {e}[/red]")
+        return
+
+    json_mode = "--json" in tokens
+    positional = [token for token in tokens if token != "--json"]
+    scoped_to_active = False
+    active_provider_key: str | None = None
+    if positional:
+        # `/usage all` → all providers; `/usage <key>` → just that one.
+        filter_provider_key = None if positional[0] == "all" else positional[0]
+    else:
+        # `/usage` with no args → scope to the active model's provider so
+        # users with multiple providers configured don't see a wall of
+        # unrelated reports. Falls back to all providers when no model is
+        # active (e.g. before /login).
+        llm = app.soul.runtime.llm
+        if llm is not None and llm.model_config is not None:
+            active_provider_key = llm.model_config.provider
+            scoped_to_active = True
+        filter_provider_key = active_provider_key
+
+    selected = _select_providers(
+        app.soul.runtime.config.providers,
+        registered_platform_ids=set(ADAPTERS),
+        filter_provider_key=filter_provider_key,
+    )
+    if not selected:
+        # No dedicated adapter for the active provider (e.g. MiniMax,
+        # OpenCode Go). Try the live-rate-limit cache as a universal
+        # fallback before giving up — chat-completion responses populate
+        # it for every openai-shape provider.
+        if scoped_to_active and active_provider_key in app.soul.runtime.config.providers:
+            platform_id = parse_managed_provider_key(active_provider_key)
+            fallback = _ratelimit_fallback_report(active_provider_key, platform_id or "Provider")
+            if fallback is not None:
+                if json_mode:
+                    _print_json([fallback.to_dict()])
+                else:
+                    console.print(build_panel(fallback))
+                return
+            if json_mode:
+                _print_json([])
+            else:
+                console.print(
+                    f"[yellow]Usage tracking is not yet available for the active "
+                    f"provider ({active_provider_key}). Send a message first so "
+                    f"live rate-limit headers can be captured, or run "
+                    f"[bold]/usage all[/bold] to see other configured providers."
+                    f"[/yellow]"
+                )
+            return
+        _print_no_usage_providers(json_mode)
+        return
+
+    pairs = [(ADAPTERS[platform_id], provider) for platform_id, provider in selected]
+
+    if json_mode:
+        reports = await _gather_reports(pairs, app.soul.runtime.oauth)
+        reports = _enrich_with_ratelimit_fallback(reports, selected)
+        _print_json([r.to_dict() for r in reports])
+        return
+
+    with console.status("[cyan]Fetching usage...[/cyan]"):
+        reports = await _gather_reports(pairs, app.soul.runtime.oauth)
+
+    # Swap any empty primary report for a live-rate-limit fallback when one
+    # has been captured for that provider's chat completions.
+    reports = _enrich_with_ratelimit_fallback(reports, selected)
+
+    non_empty_reports = [report for report in reports if not report.is_empty]
+    if not non_empty_reports:
+        # When scoped to a single active provider (no positional arg), always
+        # render the report even if empty — otherwise the user sees a flat
+        # "No usage data available." with no idea which provider was queried
+        # or what the adapter actually got back.
+        if scoped_to_active and len(reports) == 1:
+            console.print(build_panel(reports[0]))
+            return
+        console.print("[yellow]No usage data available.[/yellow]")
+        return
+
+    for report in non_empty_reports:
+        console.print(build_panel(report))

pythinker_code/ui/shell/usage_adapters/__init__.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pythinker_code.ui.shell.usage_adapters.anthropic_admin import AnthropicAdminAdapter
+from pythinker_code.ui.shell.usage_adapters.base import (
+    UsageAdapter,
+    UsageReport,
+    UsageRow,
+)
+from pythinker_code.ui.shell.usage_adapters.deepseek import DeepSeekAdapter
+from pythinker_code.ui.shell.usage_adapters.minimax import MiniMaxAdapter
+from pythinker_code.ui.shell.usage_adapters.openai_admin import OpenAIAdminAdapter
+from pythinker_code.ui.shell.usage_adapters.openai_chatgpt import OpenAIChatGPTAdapter
+from pythinker_code.ui.shell.usage_adapters.opencode_go import OpenCodeGoAdapter
+from pythinker_code.ui.shell.usage_adapters.openrouter import OpenRouterAdapter
+from pythinker_code.ui.shell.usage_adapters.pythinker import PythinkerAdapter
+from pythinker_code.ui.shell.usage_adapters.pythinker_ai import PythinkerAIAdapter
+
+_pythinker_ai_adapter = PythinkerAIAdapter()
+_minimax_adapter = MiniMaxAdapter()
+_opencode_go_adapter = OpenCodeGoAdapter()
+
+# A single provider can be registered under several `managed:<platform_id>`
+# keys when the chat path is exposed through both Anthropic-compat and
+# OpenAI-compat shapes (e.g. `managed:minimax-anthropic`,
+# `managed:opencode-go-openai`, `managed:opencode-go-anthropic`). The active
+# model's `provider` field carries one of these specific keys, so the adapter
+# registry has to cover every variant — otherwise `_select_providers` filters
+# the active provider out and `/usage` falls into the no-adapter branch.
+ADAPTERS: dict[str, UsageAdapter] = {
+    AnthropicAdminAdapter.platform_id: AnthropicAdminAdapter(),
+    DeepSeekAdapter.platform_id: DeepSeekAdapter(),
+    OpenAIAdminAdapter.platform_id: OpenAIAdminAdapter(),
+    OpenAIChatGPTAdapter.platform_id: OpenAIChatGPTAdapter(),
+    OpenRouterAdapter.platform_id: OpenRouterAdapter(),
+    PythinkerAdapter.platform_id: PythinkerAdapter(),
+    # MiniMax — only the anthropic-compat variant exists today; the bare
+    # `minimax` key is kept for a possible future openai-compat variant.
+    MiniMaxAdapter.platform_id: _minimax_adapter,
+    "minimax-anthropic": _minimax_adapter,
+    # OpenCode Go — both compat surfaces in use today.
+    OpenCodeGoAdapter.platform_id: _opencode_go_adapter,
+    "opencode-go-openai": _opencode_go_adapter,
+    "opencode-go-anthropic": _opencode_go_adapter,
+    # Pythinker AI — global and China regions share the adapter (same shape,
+    # different host).
+    PythinkerAIAdapter.platform_id: _pythinker_ai_adapter,
+    "pythinker_ai-cn": _pythinker_ai_adapter,
+}
+
+__all__ = ["ADAPTERS", "UsageAdapter", "UsageReport", "UsageRow"]