pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/ui/shell/usage_adapters/anthropic_admin.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping, Sequence
+from datetime import UTC, datetime, timedelta
+from decimal import Decimal, InvalidOperation
+from typing import TYPE_CHECKING, Any, cast
+
+import aiohttp
+
+from pythinker_code.auth import ANTHROPIC_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
+
+
+ANTHROPIC_BASE = "https://api.anthropic.com/v1/organizations"
+ADMIN_PREFIX = "sk-ant-admin-"
+ANTHROPIC_VERSION = "2023-06-01"
+
+
+class AnthropicAdminAdapter:
+    platform_id = ANTHROPIC_PLATFORM_ID
+    requires_admin_key = True
+    provider_label = "Anthropic"
+
+    async def fetch(
+        self,
+        provider: LLMProvider,
+        oauth_mgr: OAuthManager,
+    ) -> UsageReport:
+        del oauth_mgr
+        admin_key = select_anthropic_admin_key(provider.api_key.get_secret_value())
+        if admin_key is None:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=[
+                    "Set ANTHROPIC_ADMIN_KEY (sk-ant-admin-…) to see usage and cost data.",
+                    "Regular sk-ant-api03-… keys cannot call the Admin API.",
+                ],
+                unit_hint="USD",
+            )
+
+        starting_at = (datetime.now(UTC) - timedelta(hours=24)).strftime("%Y-%m-%dT%H:%M:%SZ")
+        cost = await _safe_get(
+            f"{ANTHROPIC_BASE}/cost_report",
+            {"starting_at": starting_at},
+            admin_key,
+        )
+        usage = await _safe_get(
+            f"{ANTHROPIC_BASE}/usage_report/messages",
+            {
+                "starting_at": starting_at,
+                "bucket_width": "1h",
+                "limit": 24,
+                "group_by[]": "model",
+            },
+            admin_key,
+        )
+
+        cost_summary = parse_anthropic_cost(cost) if cost is not None else None
+        usage_rows = parse_anthropic_usage(usage) if usage is not None else []
+
+        notes: list[str] = []
+        if cost is None:
+            notes.append("Anthropic cost endpoint returned no usable data.")
+        elif not _has_bucket_results_shape(cost) or not _has_cost_results_shape(cost):
+            notes.append("Anthropic cost response had unexpected shape.")
+        if usage is None:
+            notes.append("Anthropic messages usage endpoint returned no usable data.")
+        elif not _has_bucket_results_shape(usage):
+            notes.append("Anthropic messages usage response had unexpected shape.")
+
+        return UsageReport(
+            self.provider_label,
+            cost_summary,
+            usage_rows,
+            notes=notes,
+            unit_hint="USD + tokens",
+        )
+
+
+def select_anthropic_admin_key(provider_api_key: str) -> str | None:
+    env_key = os.getenv("ANTHROPIC_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={"x-api-key": api_key, "anthropic-version": ANTHROPIC_VERSION},
+                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_anthropic_cost(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_anthropic_usage(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("uncached_input_tokens"))
+            totals[model] += _to_int(result.get("output_tokens"))
+            totals[model] += _to_int(result.get("cache_read_input_tokens"))
+            cache_creation = result.get("cache_creation")
+            if isinstance(cache_creation, Mapping):
+                cache = cast(Mapping[str, Any], cache_creation)
+                totals[model] += _to_int(cache.get("ephemeral_5m_input_tokens"))
+                totals[model] += _to_int(cache.get("ephemeral_1h_input_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(Decimal(str(value)) * 100)
+    except (InvalidOperation, 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/base.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from pythinker_code.auth.oauth import OAuthManager
+    from pythinker_code.config import LLMProvider
+
+UsageUnit = str  # one of: "tokens", "USD", "CNY", "%", "requests", "credits"
+
+
+@dataclass(slots=True, frozen=True)
+class UsageRow:
+    label: str
+    used: int
+    limit: int
+    unit: UsageUnit | None = None
+    reset_hint: str | None = None
+
+
+@dataclass(slots=True, frozen=True)
+class UsageReport:
+    provider_label: str
+    summary: UsageRow | None
+    limits: list[UsageRow]
+    notes: list[str] = field(default_factory=lambda: list[str]())
+    unit_hint: str | None = None
+
+    @property
+    def is_empty(self) -> bool:
+        return self.summary is None and not self.limits and not self.notes
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "provider_label": self.provider_label,
+            "unit_hint": self.unit_hint,
+            "summary": (
+                {
+                    "label": self.summary.label,
+                    "used": self.summary.used,
+                    "limit": self.summary.limit,
+                    "unit": self.summary.unit,
+                    "reset_hint": self.summary.reset_hint,
+                }
+                if self.summary
+                else None
+            ),
+            "limits": [
+                {
+                    "label": r.label,
+                    "used": r.used,
+                    "limit": r.limit,
+                    "unit": r.unit,
+                    "reset_hint": r.reset_hint,
+                }
+                for r in self.limits
+            ],
+            "notes": list(self.notes),
+        }
+
+
+class UsageAdapter(Protocol):
+    platform_id: str
+    provider_label: str
+    requires_admin_key: bool
+
+    async def fetch(
+        self,
+        provider: LLMProvider,
+        oauth_mgr: OAuthManager,
+    ) -> UsageReport: ...

pythinker_code/ui/shell/usage_adapters/deepseek.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from decimal import Decimal, InvalidOperation
+from typing import TYPE_CHECKING, Any, cast
+
+import aiohttp
+
+from pythinker_code.auth import DEEPSEEK_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
+
+
+DEEPSEEK_BALANCE_URL = "https://api.deepseek.com/user/balance"
+SUPPORTED_CURRENCIES = {"USD", "CNY"}
+
+
+class DeepSeekAdapter:
+    platform_id = DEEPSEEK_PLATFORM_ID
+    requires_admin_key = False
+    provider_label = "DeepSeek"
+
+    async def fetch(
+        self,
+        provider: LLMProvider,
+        oauth_mgr: OAuthManager,
+    ) -> UsageReport:
+        api_key = oauth_mgr.resolve_api_key(provider.api_key, provider.oauth)
+        try:
+            async with (
+                new_client_session() as session,
+                session.get(
+                    DEEPSEEK_BALANCE_URL,
+                    headers={"Authorization": f"Bearer {api_key}"},
+                    timeout=aiohttp.ClientTimeout(total=5),
+                    raise_for_status=True,
+                ) as resp,
+            ):
+                payload = await resp.json()
+        except aiohttp.ClientResponseError as e:
+            if e.status == 401:
+                message = "DeepSeek returned 401 — check your API key."
+            else:
+                message = f"DeepSeek balance fetch failed: HTTP {e.status}"
+            return UsageReport(self.provider_label, None, [], notes=[message], unit_hint="balance")
+        except (TimeoutError, aiohttp.ClientError) as e:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=[f"DeepSeek balance fetch failed: {e}"],
+                unit_hint="balance",
+            )
+
+        if not isinstance(payload, Mapping):
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=["Unexpected response shape."],
+                unit_hint="balance",
+            )
+        return parse_deepseek_payload(cast(Mapping[str, Any], payload))
+
+
+def parse_deepseek_payload(payload: Mapping[str, Any]) -> UsageReport:
+    summary: UsageRow | None = None
+    limits: list[UsageRow] = []
+    notes: list[str] = []
+
+    if payload.get("is_available") is False:
+        notes.append("DeepSeek balance is currently unavailable for API calls.")
+
+    balance_infos_raw = payload.get("balance_infos")
+    if not isinstance(balance_infos_raw, Sequence) or isinstance(balance_infos_raw, str | bytes):
+        return UsageReport(
+            provider_label=DeepSeekAdapter.provider_label,
+            summary=None,
+            limits=[],
+            notes=[*notes, "Unexpected response shape: balance_infos missing."],
+            unit_hint="balance",
+        )
+
+    balance_infos: Sequence[Any] = cast(Sequence[Any], balance_infos_raw)
+    for info_raw in balance_infos:
+        if not isinstance(info_raw, Mapping):
+            continue
+        info: Mapping[str, Any] = cast(Mapping[str, Any], info_raw)
+        currency = str(info.get("currency") or "")
+        if currency not in SUPPORTED_CURRENCIES:
+            continue
+
+        total = UsageRow(
+            f"Total balance ({currency})",
+            _to_minor_units(info.get("total_balance")),
+            0,
+            unit=currency,
+        )
+        if summary is None:
+            summary = total
+        else:
+            limits.append(total)
+        limits.append(
+            UsageRow(
+                f"Granted ({currency})",
+                _to_minor_units(info.get("granted_balance")),
+                0,
+                unit=currency,
+            )
+        )
+        limits.append(
+            UsageRow(
+                f"Topped up ({currency})",
+                _to_minor_units(info.get("topped_up_balance")),
+                0,
+                unit=currency,
+            )
+        )
+
+    return UsageReport(
+        provider_label=DeepSeekAdapter.provider_label,
+        summary=summary,
+        limits=limits,
+        notes=notes,
+        unit_hint="balance",
+    )
+
+
+def _to_minor_units(value: Any) -> int:
+    try:
+        return int(Decimal(str(value)) * 100)
+    except (InvalidOperation, ValueError):
+        return 0

pythinker_code/ui/shell/usage_adapters/minimax.py

@@ -0,0 +1,236 @@
+"""MiniMax Token-Plan usage adapter.
+
+Endpoint sourced from the official docs (verified 2026-05-06 via
+context7 + tavily against `platform.minimax.io/docs/token-plan/faq`):
+
+    GET https://www.minimax.io/v1/token_plan/remains
+    Authorization: Bearer <API Key>
+    Content-Type: application/json
+
+The published response shape isn't fully documented; community integrations
+(openclaw.ai, openclaw docs / providers / minimax) cite the inner fields
+`usage_percent` / `usagePercent`, `model_remains`, `start_time`, `end_time`,
+which we parse defensively. The unrelated portal endpoint
+`https://www.minimaxi.com/v1/api/openplatform/coding_plan/remains` requires
+browser cookies (issue #88) — we don't use it.
+
+For pay-as-you-go MiniMax keys (non-`sk-cp-*`) there's no Token-Plan to
+query, so we short-circuit and let the Phase-5 rate-limit cache fill in
+live limits from chat-completion headers.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, cast
+
+import aiohttp
+
+from pythinker_code.auth import MINIMAX_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
+
+
+# Documented at https://platform.minimax.io/docs/token-plan/faq (verified
+# 2026-05-06): the API-key-authenticated Token-Plan usage endpoint.
+MINIMAX_TOKEN_PLAN_URL = "https://www.minimax.io/v1/token_plan/remains"
+_TOKEN_PLAN_KEY_PREFIX = "sk-cp-"
+
+
+class MiniMaxAdapter:
+    platform_id = MINIMAX_PLATFORM_ID
+    requires_admin_key = False
+    provider_label = "MiniMax"
+
+    async def fetch(
+        self,
+        provider: LLMProvider,
+        oauth_mgr: OAuthManager,
+    ) -> UsageReport:
+        api_key = oauth_mgr.resolve_api_key(provider.api_key, provider.oauth)
+
+        # Pay-as-you-go MiniMax API keys (non-`sk-cp-…`) don't have a
+        # token-plan to query at all; short-circuit instead of probing.
+        if not api_key.startswith(_TOKEN_PLAN_KEY_PREFIX):
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=[
+                    "Pay-as-you-go MiniMax keys don't expose a usage endpoint. "
+                    "Live rate-limit headers will appear here after sending a "
+                    "chat message."
+                ],
+                unit_hint="quota",
+            )
+
+        try:
+            async with (
+                new_client_session() as session,
+                session.get(
+                    MINIMAX_TOKEN_PLAN_URL,
+                    headers={"Authorization": f"Bearer {api_key}"},
+                    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"MiniMax token-plan probe failed: HTTP {e.status}"],
+                unit_hint="quota",
+            )
+        except (TimeoutError, aiohttp.ClientError) as e:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=[f"MiniMax token-plan probe failed: {e}"],
+                unit_hint="quota",
+            )
+
+        if not isinstance(payload, Mapping):
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=["Unexpected MiniMax response shape."],
+                unit_hint="quota",
+            )
+
+        return parse_minimax_payload(cast(Mapping[str, Any], payload))
+
+
+def parse_minimax_payload(payload: Mapping[str, Any]) -> UsageReport:
+    """Parse the `/v1/token_plan/remains` response.
+
+    Field names verified 2026-05-06 against the live API via the
+    `slkiser/opencode-quota` repo (`src/providers/minimax-coding-plan.ts`).
+    `model_remains` is an array of per-model entries with this shape:
+
+        {
+          "model_name": "MiniMax-M2.7",
+          "current_interval_total_count": 1500,
+          "current_interval_usage_count": 1473,   # CAUTION: actually REMAINING
+          "remains_time": 12345,                  # seconds to 5h reset
+          "current_weekly_total_count": 15000,
+          "current_weekly_usage_count": 14500,    # CAUTION: actually REMAINING
+          "weekly_remains_time": 432000           # seconds to weekly reset
+        }
+
+    The `*_usage_count` field names are misleading — MiniMax's API returns
+    *remaining* counts there, not used. (Documented footgun in the slkiser
+    integration.) `usage = total - usage_count` gives the actual usage.
+    """
+    notes: list[str] = []
+
+    # MiniMax's universal envelope: 0 = success, anything else is an error.
+    base_resp = payload.get("base_resp")
+    if isinstance(base_resp, Mapping):
+        base = cast(Mapping[str, Any], base_resp)
+        status_code = base.get("status_code")
+        if status_code not in (None, 0):
+            msg = base.get("status_msg") or "unknown error"
+            return UsageReport(
+                MiniMaxAdapter.provider_label,
+                None,
+                [],
+                notes=[f"MiniMax responded {status_code}: {msg}"],
+                unit_hint="quota",
+            )
+
+    summary: UsageRow | None = None
+    limits: list[UsageRow] = []
+
+    model_remains = payload.get("model_remains")
+    if isinstance(model_remains, list):
+        for entry in cast(list[Any], model_remains):
+            if not isinstance(entry, Mapping):
+                continue
+            entry_map = cast(Mapping[str, Any], entry)
+            for row in _rows_from_minimax_model_entry(entry_map):
+                # First row produced (the highest-priority model's 5h window)
+                # becomes the panel summary; the rest go into limits.
+                if summary is None:
+                    summary = row
+                else:
+                    limits.append(row)
+
+    if summary is None and not limits:
+        outer = ", ".join(sorted(payload.keys())) or "<empty>"
+        notes.append(
+            f"MiniMax returned no recognizable token-plan fields "
+            f"(keys: {outer}). Live rate-limit headers will fill this "
+            f"panel after sending a chat message."
+        )
+
+    return UsageReport(
+        provider_label=MiniMaxAdapter.provider_label,
+        summary=summary,
+        limits=limits,
+        notes=notes,
+        unit_hint="quota",
+    )
+
+
+def _rows_from_minimax_model_entry(entry: Mapping[str, Any]) -> list[UsageRow]:
+    """Yield the 5h-window and weekly-window UsageRows for one model entry.
+
+    Returns an empty list if no recognized window fields are present.
+    """
+    model_name = str(entry.get("model_name") or entry.get("model") or "model")
+    rows: list[UsageRow] = []
+
+    interval_total = _to_int(entry.get("current_interval_total_count"))
+    interval_remaining = _to_int(entry.get("current_interval_usage_count"))
+    interval_remains_seconds = _to_int(entry.get("remains_time"))
+    if interval_total is not None and interval_remaining is not None:
+        rows.append(
+            UsageRow(
+                label=f"{model_name} 5h",
+                used=min(interval_total, max(0, interval_remaining)),
+                limit=interval_total,
+                unit="requests",
+                reset_hint=_seconds_to_reset_hint(interval_remains_seconds),
+            )
+        )
+
+    weekly_total = _to_int(entry.get("current_weekly_total_count"))
+    weekly_remaining = _to_int(entry.get("current_weekly_usage_count"))
+    weekly_remains_seconds = _to_int(entry.get("weekly_remains_time"))
+    if weekly_total is not None and weekly_remaining is not None:
+        rows.append(
+            UsageRow(
+                label=f"{model_name} weekly",
+                used=min(weekly_total, max(0, weekly_remaining)),
+                limit=weekly_total,
+                unit="requests",
+                reset_hint=_seconds_to_reset_hint(weekly_remains_seconds),
+            )
+        )
+
+    return rows
+
+
+def _to_int(value: Any) -> int | None:
+    if value is None:
+        return None
+    try:
+        return int(float(value))
+    except (TypeError, ValueError):
+        return None
+
+
+def _seconds_to_reset_hint(seconds: int | None) -> str | None:
+    from pythinker_code.utils.datetime import format_duration
+
+    if seconds is None or seconds <= 0:
+        return None
+    return f"resets in {format_duration(seconds)}"