pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/ui/shell/update.py

@@ -0,0 +1,350 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import os
+import platform
+import re
+import shlex
+import shutil
+import stat
+import subprocess
+import tarfile
+import tempfile
+from enum import Enum, auto
+from pathlib import Path
+
+import aiohttp
+
+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
+
+BASE_URL = "https://cdn.pythinker.com/binaries/pythinker-code"
+LATEST_VERSION_URL = f"{BASE_URL}/latest"
+INSTALL_DIR = Path.home() / ".local" / "bin"
+
+# Upgrade command shown in toast notifications. Can be overridden by wrappers
+UPGRADE_COMMAND = "uv tool upgrade pythinker-code"
+
+
+class UpdateResult(Enum):
+    UPDATE_AVAILABLE = auto()
+    UPDATED = auto()
+    UP_TO_DATE = auto()
+    FAILED = auto()
+    UNSUPPORTED = auto()
+
+
+_UPDATE_LOCK = asyncio.Lock()
+
+
+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_target() -> str | None:
+    sys_name = platform.system()
+    mach = platform.machine()
+    if mach in ("x86_64", "amd64", "AMD64"):
+        arch = "x86_64"
+    elif mach in ("arm64", "aarch64"):
+        arch = "aarch64"
+    else:
+        logger.error("Unsupported architecture: {mach}", mach=mach)
+        return None
+    if sys_name == "Darwin":
+        os_name = "apple-darwin"
+    elif sys_name == "Linux":
+        os_name = "unknown-linux-gnu"
+    else:
+        logger.error("Unsupported OS: {sys_name}", sys_name=sys_name)
+        return None
+    return f"{arch}-{os_name}"
+
+
+async def _get_latest_version(session: aiohttp.ClientSession) -> str | None:
+    try:
+        async with session.get(LATEST_VERSION_URL) as resp:
+            resp.raise_for_status()
+            data = await resp.text()
+            return data.strip()
+    except (TimeoutError, aiohttp.ClientError):
+        logger.exception("Failed to get latest version:")
+        return None
+
+
+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)
+
+
+LATEST_VERSION_FILE = get_share_dir() / "latest_version.txt"
+SKIPPED_VERSION_FILE = get_share_dir() / "skipped_version.txt"
+CHANGELOG_URL_EN = (
+    "https://mohamed-elkholy95.github.io/Pythinker-Code/en/release-notes/changelog.html"
+)
+
+
+def _read_key() -> str:
+    """Read a single character from stdin in raw terminal mode."""
+    import sys
+
+    if sys.platform == "win32":
+        import msvcrt
+
+        return msvcrt.getwch()
+    else:
+        import termios
+        import tty
+
+        fd = sys.stdin.fileno()
+        old = termios.tcgetattr(fd)
+        try:
+            tty.setraw(fd)
+            return sys.stdin.read(1)
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+
+def check_update_gate() -> None:
+    """Block interactive shell startup if a newer version is cached locally."""
+    import sys
+
+    from pythinker_code.constant import VERSION as current_version
+    from pythinker_code.utils.envvar import get_env_bool
+
+    if get_env_bool("PYTHINKER_CLI_NO_AUTO_UPDATE"):
+        return
+    if not sys.stdin.isatty() or 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 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
+
+    _run_update_gate(current_version, latest_version)
+
+
+def _run_update_gate(current_version: str, latest_version: str) -> None:
+    """Display the blocking update UI and handle user key input."""
+    import sys
+
+    from rich.panel import Panel
+    from rich.rule import Rule
+    from rich.text import Text
+
+    body = Text.assemble(
+        ("  Current version   ", ""),
+        (current_version + "\n", ""),
+        ("  Latest version    ", ""),
+        (latest_version + "\n\n", "bold green"),
+        ("  What's new:\n", ""),
+        ("    · ", ""),
+        (CHANGELOG_URL_EN + "\n", "dodger_blue1"),
+    )
+    console.print()
+    console.print(
+        Panel(
+            body,
+            title="[bold]pythinker-code update available[/bold]",
+            border_style="yellow",
+            expand=False,
+            padding=(1, 2),
+        )
+    )
+    console.print(Rule(style="grey50"))
+    console.print(
+        Text.assemble(
+            "  ",
+            ("[Enter]", "bold"),
+            "  Upgrade now  ",
+            (f"({UPGRADE_COMMAND})", "grey50"),
+        )
+    )
+    console.print(Text.assemble("  ", ("[q]", "bold"), "      Not now, remind me next time"))
+    console.print(
+        Text.assemble("  ", ("[s]", "bold"), f"      Skip reminders for version {latest_version}")
+    )
+    console.print(Rule(style="grey50"))
+    console.print()
+
+    key = _read_key()
+    console.print()
+
+    if key in ("\r", "\n"):
+        console.print(f"[grey50]Running: {UPGRADE_COMMAND}[/grey50]\n")
+        try:
+            result = subprocess.run(shlex.split(UPGRADE_COMMAND))
+        except OSError:
+            console.print()
+            console.print("[red]Upgrade failed. Please try running manually:[/red]")
+            console.print(f"  {UPGRADE_COMMAND}")
+            sys.exit(1)
+        console.print()
+        if result.returncode == 0:
+            console.print(
+                "[green]Upgrade complete! Run pythinker-code to start the new version.[/green]"
+            )
+        else:
+            console.print("[red]Upgrade failed. Please try running manually:[/red]")
+            console.print(f"  {UPGRADE_COMMAND}")
+        sys.exit(result.returncode)
+    elif key in ("s", "S"):
+        with contextlib.suppress(OSError):
+            SKIPPED_VERSION_FILE.write_text(latest_version, encoding="utf-8")
+        console.print(f"[grey50]Reminders skipped for version {latest_version}.[/grey50]\n")
+    elif key in ("\x03", "\x1b"):
+        sys.exit(0)
+    # q/Q/other: fall through, continue startup
+
+
+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)
+
+    target = _detect_target()
+    if not target:
+        _print("[red]Failed to detect target platform.[/red]")
+        return UpdateResult.UNSUPPORTED
+
+    # Version check is fast, but the binary download can be large on slow links.
+    download_timeout = aiohttp.ClientTimeout(total=600, sock_read=60, sock_connect=15)
+    async with new_client_session(timeout=download_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)
+        LATEST_VERSION_FILE.write_text(latest_version, encoding="utf-8")
+
+        cur_t = semver_tuple(current_version)
+        lat_t = semver_tuple(latest_version)
+
+        if cur_t >= lat_t:
+            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
+
+        logger.info(
+            "Updating from {current_version} to {latest_version}...",
+            current_version=current_version,
+            latest_version=latest_version,
+        )
+        _print(f"Updating from {current_version} to {latest_version}...")
+
+        filename = f"pythinker-{latest_version}-{target}.tar.gz"
+        download_url = f"{BASE_URL}/{latest_version}/{filename}"
+
+        with tempfile.TemporaryDirectory(prefix="pythinker-code-") as tmpdir:
+            tar_path = os.path.join(tmpdir, filename)
+
+            logger.info("Downloading from {download_url}...", download_url=download_url)
+            _print("[grey50]Downloading...[/grey50]")
+            try:
+                async with session.get(download_url) as resp:
+                    resp.raise_for_status()
+                    with open(tar_path, "wb") as f:
+                        async for chunk in resp.content.iter_chunked(1024 * 64):
+                            if chunk:
+                                f.write(chunk)
+            except (TimeoutError, aiohttp.ClientError):
+                logger.exception(
+                    "Failed to download update from {download_url}",
+                    download_url=download_url,
+                )
+                _print("[red]Failed to download.[/red]")
+                return UpdateResult.FAILED
+            except Exception:
+                logger.exception("Failed to download:")
+                _print("[red]Failed to download.[/red]")
+                return UpdateResult.FAILED
+
+            logger.info("Extracting archive {tar_path}...", tar_path=tar_path)
+            _print("[grey50]Extracting...[/grey50]")
+            try:
+                with tarfile.open(tar_path, "r:gz") as tar:
+                    tar.extractall(tmpdir)
+                binary_path = None
+                for root, _, files in os.walk(tmpdir):
+                    if "pythinker" in files:
+                        binary_path = os.path.join(root, "pythinker")
+                        break
+                if not binary_path:
+                    logger.error("Binary 'pythinker' not found in archive.")
+                    _print("[red]Binary 'pythinker' not found in archive.[/red]")
+                    return UpdateResult.FAILED
+            except Exception:
+                logger.exception("Failed to extract archive:")
+                _print("[red]Failed to extract archive.[/red]")
+                return UpdateResult.FAILED
+
+            INSTALL_DIR.mkdir(parents=True, exist_ok=True)
+            dest_path = INSTALL_DIR / "pythinker"
+            logger.info("Installing to {dest_path}...", dest_path=dest_path)
+            _print("[grey50]Installing...[/grey50]")
+
+            try:
+                shutil.copy2(binary_path, dest_path)
+                os.chmod(
+                    dest_path,
+                    os.stat(dest_path).st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH,
+                )
+            except Exception:
+                logger.exception("Failed to install:")
+                _print("[red]Failed to install.[/red]")
+                return UpdateResult.FAILED
+
+    _print("[green]Updated successfully![/green]")
+    _print("[yellow]Restart Pythinker CLI to use the new version.[/yellow]")
+    return UpdateResult.UPDATED
+
+
+# @meta_command
+# async def update(app: "Shell", args: list[str]):
+#     """Check for updates"""
+#     await do_update(print=True)
+
+
+# @meta_command(name="check-update")
+# async def check_update(app: "Shell", args: list[str]):
+#     """Check for updates"""
+#     await do_update(print=True, check_only=True)

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"]