pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/ui/shell/usage_adapters/openrouter.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, cast
+
+import aiohttp
+
+from pythinker_code.auth import OPENROUTER_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
+
+
+OPENROUTER_KEY_URL = "https://openrouter.ai/api/v1/key"
+
+
+class OpenRouterAdapter:
+    platform_id = OPENROUTER_PLATFORM_ID
+    requires_admin_key = False
+    provider_label = "OpenRouter"
+
+    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(
+                    OPENROUTER_KEY_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 = "OpenRouter returned 401 — check your API key."
+            else:
+                message = f"OpenRouter usage fetch failed: HTTP {e.status}"
+            return UsageReport(self.provider_label, None, [], notes=[message])
+        except (TimeoutError, aiohttp.ClientError) as e:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=[f"OpenRouter usage fetch failed: {e}"],
+            )
+
+        if not isinstance(payload, Mapping):
+            return UsageReport(self.provider_label, None, [], notes=["Unexpected response shape."])
+        return parse_openrouter_payload(cast(Mapping[str, Any], payload))
+
+
+def parse_openrouter_payload(payload: Mapping[str, Any]) -> UsageReport:
+    data_raw = payload.get("data")
+    if not isinstance(data_raw, Mapping):
+        return UsageReport(
+            provider_label=OpenRouterAdapter.provider_label,
+            summary=None,
+            limits=[],
+            notes=["Unexpected response shape."],
+            unit_hint="USD",
+        )
+
+    data = cast(Mapping[str, Any], data_raw)
+    limit_reset = data.get("limit_reset")
+    summary = UsageRow(
+        label="Credit balance",
+        used=_to_cents(data.get("usage")),
+        limit=_to_cents(data.get("limit")),
+        unit="USD",
+        reset_hint=f"resets {limit_reset}" if limit_reset else None,
+    )
+    limits = [
+        UsageRow("Today", _to_cents(data.get("usage_daily")), 0, unit="USD"),
+        UsageRow("This week", _to_cents(data.get("usage_weekly")), 0, unit="USD"),
+        UsageRow("This month", _to_cents(data.get("usage_monthly")), 0, unit="USD"),
+    ]
+    notes = (
+        ["Free tier key; OpenRouter may apply free-model limits."]
+        if data.get("is_free_tier")
+        else []
+    )
+
+    return UsageReport(
+        provider_label=OpenRouterAdapter.provider_label,
+        summary=summary,
+        limits=limits,
+        notes=notes,
+        unit_hint="USD",
+    )
+
+
+def _to_cents(value: Any) -> int:
+    try:
+        return int(round(float(value) * 100))
+    except (OverflowError, TypeError, ValueError):
+        return 0

pythinker_code/ui/shell/usage_adapters/pythinker.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Any, cast
+
+import aiohttp
+
+from pythinker_code.auth import PYTHINKER_CODE_PLATFORM_ID
+from pythinker_code.auth.platforms import get_platform_by_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
+
+
+class PythinkerAdapter:
+    platform_id = PYTHINKER_CODE_PLATFORM_ID
+    requires_admin_key = False
+    provider_label = "Pythinker"
+
+    async def fetch(
+        self,
+        provider: LLMProvider,
+        oauth_mgr: OAuthManager,
+    ) -> UsageReport:
+        platform = get_platform_by_id(self.platform_id)
+        if platform is None:
+            return UsageReport(
+                provider_label=self.provider_label,
+                summary=None,
+                limits=[],
+                notes=["Usage is available on Pythinker platform only."],
+            )
+
+        url = f"{platform.base_url.rstrip('/')}/usages"
+        api_key = oauth_mgr.resolve_api_key(provider.api_key, provider.oauth)
+        try:
+            async with (
+                new_client_session() as session,
+                session.get(
+                    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:
+            message = "Failed to fetch usage."
+            if e.status == 401:
+                message = "Authorization failed. Please check your API key."
+            elif e.status == 404:
+                message = "Usage endpoint not available. Try Pythinker for Coding."
+            return UsageReport(self.provider_label, None, [], notes=[message])
+        except TimeoutError:
+            return UsageReport(
+                self.provider_label,
+                None,
+                [],
+                notes=["Failed to fetch usage: request timed out."],
+            )
+        except aiohttp.ClientError as e:
+            return UsageReport(self.provider_label, None, [], notes=[f"Failed to fetch usage: {e}"])
+
+        return parse_pythinker_payload(payload)
+
+
+def parse_pythinker_payload(payload: Mapping[str, Any]) -> UsageReport:
+    summary: UsageRow | None = None
+    limits: list[UsageRow] = []
+
+    usage = payload.get("usage")
+    if isinstance(usage, Mapping):
+        usage_map: Mapping[str, Any] = cast(Mapping[str, Any], usage)
+        summary = _to_usage_row(usage_map, default_label="Weekly limit")
+
+    raw_limits_obj = payload.get("limits")
+    if isinstance(raw_limits_obj, Sequence):
+        limits_seq: Sequence[Any] = cast(Sequence[Any], raw_limits_obj)
+        for idx, item in enumerate(limits_seq):
+            if not isinstance(item, Mapping):
+                continue
+            item_map: Mapping[str, Any] = cast(Mapping[str, Any], item)
+            detail_raw = item_map.get("detail")
+            detail: Mapping[str, Any] = (
+                cast(Mapping[str, Any], detail_raw) if isinstance(detail_raw, Mapping) else item_map
+            )
+            window_raw = item_map.get("window")
+            window: Mapping[str, Any] = (
+                cast(Mapping[str, Any], window_raw) if isinstance(window_raw, Mapping) else {}
+            )
+            label = _limit_label(item_map, detail, window, idx)
+            row = _to_usage_row(detail, default_label=label)
+            if row:
+                limits.append(row)
+
+    return UsageReport(
+        provider_label=PythinkerAdapter.provider_label,
+        summary=summary,
+        limits=limits,
+    )
+
+
+def _to_usage_row(data: Mapping[str, Any], *, default_label: str) -> UsageRow | None:
+    limit = _to_int(data.get("limit"))
+    used = _to_int(data.get("used"))
+    if used is None:
+        remaining = _to_int(data.get("remaining"))
+        if remaining is not None and limit is not None:
+            used = limit - remaining
+    if used is None and limit is None:
+        return None
+    return UsageRow(
+        label=str(data.get("name") or data.get("title") or default_label),
+        used=used or 0,
+        limit=limit or 0,
+        reset_hint=_reset_hint(data),
+    )
+
+
+def _limit_label(
+    item: Mapping[str, Any],
+    detail: Mapping[str, Any],
+    window: Mapping[str, Any],
+    idx: int,
+) -> str:
+    for key in ("name", "title", "scope"):
+        if val := (item.get(key) or detail.get(key)):
+            return str(val)
+
+    duration = _to_int(window.get("duration") or item.get("duration") or detail.get("duration"))
+    time_unit = window.get("timeUnit") or item.get("timeUnit") or detail.get("timeUnit") or ""
+    if duration:
+        if "MINUTE" in time_unit:
+            if duration >= 60 and duration % 60 == 0:
+                return f"{duration // 60}h limit"
+            return f"{duration}m limit"
+        if "HOUR" in time_unit:
+            return f"{duration}h limit"
+        if "DAY" in time_unit:
+            return f"{duration}d limit"
+        return f"{duration}s limit"
+
+    return f"Limit #{idx + 1}"
+
+
+def _reset_hint(data: Mapping[str, Any]) -> str | None:
+    for key in ("reset_at", "resetAt", "reset_time", "resetTime"):
+        if val := data.get(key):
+            return _format_reset_time(str(val))
+
+    for key in ("reset_in", "resetIn", "ttl", "window"):
+        seconds = _to_int(data.get(key))
+        if seconds:
+            return f"resets in {format_duration(seconds)}"
+
+    return None
+
+
+def _format_reset_time(val: str) -> str:
+    from datetime import UTC, datetime
+
+    try:
+        if "." in val and val.endswith("Z"):
+            base, frac = val[:-1].split(".")
+            frac = frac[:6]
+            val = f"{base}.{frac}Z"
+        dt = datetime.fromisoformat(val.replace("Z", "+00:00"))
+        now = datetime.now(UTC)
+        delta = dt - now
+
+        if delta.total_seconds() <= 0:
+            return "reset"
+        return f"resets in {format_duration(int(delta.total_seconds()))}"
+    except (ValueError, TypeError):
+        return f"resets at {val}"
+
+
+def _to_int(value: Any) -> int | None:
+    try:
+        return int(value)
+    except (OverflowError, TypeError, ValueError):
+        return None
+
+
+to_int = _to_int

pythinker_code/ui/shell/usage_adapters/pythinker_ai.py

@@ -0,0 +1,50 @@
+"""Pythinker AI Open Platform usage adapter (notes-only).
+
+Verified 2026-05-06 via context7 (`/websites/platform_minimax_io`,
+`/websites/z_ai`) and tavily web search: there are no public docs and
+no discoverable usage/billing endpoint for `api.pythinker-ai.ai` /
+`api.pythinker-ai.cn`. Earlier drafts of this adapter speculatively
+probed `/user/balance` (the DeepSeek convention) — that was a guess,
+not a verified shape, so it's been removed to avoid surfacing
+misleading errors against an endpoint that doesn't exist.
+
+The adapter exists so `/usage` produces a clean panel for Pythinker AI
+sessions and the Phase-5 rate-limit cache can fill in live limits from
+chat-completion response headers.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pythinker_code.ui.shell.usage_adapters.base import UsageReport
+
+if TYPE_CHECKING:
+    from pythinker_code.auth.oauth import OAuthManager
+    from pythinker_code.config import LLMProvider
+
+
+PYTHINKER_AI_PLATFORM_ID = "pythinker-ai"
+
+
+class PythinkerAIAdapter:
+    platform_id = PYTHINKER_AI_PLATFORM_ID
+    requires_admin_key = False
+    provider_label = "Pythinker AI"
+
+    async def fetch(
+        self,
+        provider: LLMProvider,
+        oauth_mgr: OAuthManager,
+    ) -> UsageReport:
+        return UsageReport(
+            provider_label=self.provider_label,
+            summary=None,
+            limits=[],
+            notes=[
+                "Pythinker AI doesn't publish a usage endpoint. "
+                "Live rate-limit headers will appear here after sending a "
+                "chat message."
+            ],
+            unit_hint="quota",
+        )

pythinker_code/ui/shell/usage_render.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from rich.console import Group, RenderableType
+from rich.panel import Panel
+from rich.progress_bar import ProgressBar
+from rich.table import Table
+from rich.text import Text
+
+from pythinker_code.ui.shell.usage_adapters.base import UsageReport, UsageRow
+
+
+def build_panel(report: UsageReport) -> Panel:
+    return _build_usage_panel(report.summary, report.limits, notes=report.notes)
+
+
+def _build_usage_panel(
+    summary: UsageRow | None,
+    limits: list[UsageRow],
+    *,
+    notes: list[str] | None = None,
+) -> Panel:
+    rows = ([summary] if summary else []) + limits
+    if not rows and not notes:
+        return Panel(
+            Text("No usage data", style="grey50"), title="API Usage", border_style="wheat4"
+        )
+
+    label_width = max((len(r.label) for r in rows), default=6)
+    label_width = max(label_width, 6)
+
+    lines: list[RenderableType] = []
+    for row in rows:
+        lines.append(_format_row(row, label_width))
+    for note in notes or []:
+        lines.append(Text(note, style="yellow"))
+
+    return Panel(
+        Group(*lines),
+        title="API Usage",
+        border_style="wheat4",
+        padding=(0, 2),
+        expand=False,
+    )
+
+
+def _format_row(row: UsageRow, label_width: int) -> RenderableType:
+    if row.limit <= 0 and row.unit is not None:
+        return _format_unbounded_row(row, label_width)
+    if row.unit == "%":
+        return _format_percent_row(row, label_width)
+
+    remaining, remaining_ratio, bar_total = _remaining_quota(row)
+    color = _ratio_color(remaining_ratio)
+
+    label = Text(f"{row.label:<{label_width}}  ", style="cyan")
+    bar = ProgressBar(
+        total=bar_total,
+        completed=remaining,
+        width=20,
+        complete_style=color,
+        finished_style=color,
+    )
+
+    detail = Text()
+    percent = remaining_ratio * 100
+    detail.append(f"  {percent:.0f}% left", style="bold")
+    if row.reset_hint:
+        detail.append(f"  ({row.reset_hint})", style="grey50")
+
+    return _row_table(label_width, label, bar, detail)
+
+
+def _format_percent_row(row: UsageRow, label_width: int) -> RenderableType:
+    percent_left = min(max(row.used, 0), 100)
+    color = _ratio_color(percent_left / 100)
+    label = Text(f"{row.label:<{label_width}}  ", style="cyan")
+    bar = ProgressBar(
+        total=100,
+        completed=percent_left,
+        width=20,
+        complete_style=color,
+        finished_style=color,
+    )
+    detail = Text(f"  {_format_value(percent_left, row.unit)} left", style="bold")
+    if row.reset_hint:
+        detail.append(f"  ({row.reset_hint})", style="grey50")
+    return _row_table(label_width, label, bar, detail)
+
+
+def _format_unbounded_row(row: UsageRow, label_width: int) -> RenderableType:
+    label = Text(f"{row.label:<{label_width}}  ", style="cyan")
+    detail = Text(f"  {_format_value(row.used, row.unit)} used", style="bold")
+    if row.reset_hint:
+        detail.append(f"  ({row.reset_hint})", style="grey50")
+    t = Table.grid(padding=0)
+    t.add_column(width=label_width + 2)
+    t.add_column()
+    t.add_row(label, detail)
+    return t
+
+
+def _row_table(
+    label_width: int,
+    label: Text,
+    bar: ProgressBar,
+    detail: Text,
+) -> Table:
+    t = Table.grid(padding=0)
+    t.add_column(width=label_width + 2)
+    t.add_column(width=20)
+    t.add_column()
+    t.add_row(label, bar, detail)
+    return t
+
+
+def _remaining_quota(row: UsageRow) -> tuple[int, float, int]:
+    if row.limit <= 0:
+        return 0, 0, 1
+
+    remaining = min(max(row.limit - row.used, 0), row.limit)
+    return remaining, remaining / row.limit, row.limit
+
+
+def _ratio_color(remaining_ratio: float) -> str:
+    if remaining_ratio <= 0.1:
+        return "red"
+    if remaining_ratio <= 0.3:
+        return "yellow"
+    return "green"
+
+
+def _format_value(value: int, unit: str | None) -> str:
+    if unit is None:
+        return _format_count(value)
+    if unit == "%":
+        return f"{value}%"
+    if unit == "USD":
+        return f"${value / 100:.2f}"
+    if unit == "CNY":
+        return f"¥{value / 100:.2f}"
+    return f"{_format_count(value)} {unit}"
+
+
+def _format_count(value: int) -> str:
+    return f"{value:,}"
+
+
+format_row = _format_row
+remaining_quota = _remaining_quota
+ratio_color = _ratio_color

pythinker_code/ui/shell/visualize/__init__.py

@@ -0,0 +1,165 @@
+"""Bottom dynamic area rendering package.
+
+This package contains all components for the terminal's bottom dynamic area:
+event-driven streaming view, interactive overlays (approval, question, btw),
+input routing, and renderable blocks.
+
+All public names are re-exported here so external imports remain stable:
+    from pythinker_code.ui.shell.visualize import visualize, _PromptLiveView, ...
+"""
+
+# pyright: reportPrivateUsage=false
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from typing import Any
+
+# Re-export Rich Live for test monkeypatching
+from rich.live import Live as Live  # noqa: F401
+
+# --- Re-exports (keep all existing import paths working) -------------------
+# Console (re-exported for test monkeypatching compatibility)
+from pythinker_code.ui.shell.console import console as console  # noqa: F401
+from pythinker_code.ui.shell.keyboard import KeyEvent as KeyEvent  # noqa: F401
+from pythinker_code.ui.shell.prompt import CustomPromptSession, UserInput
+
+# Approval panel (moved from ui/shell/approval_panel.py)
+from pythinker_code.ui.shell.visualize._approval_panel import (
+    ApprovalPromptDelegate as ApprovalPromptDelegate,
+)
+from pythinker_code.ui.shell.visualize._approval_panel import (
+    ApprovalRequestPanel as ApprovalRequestPanel,
+)
+from pythinker_code.ui.shell.visualize._approval_panel import (
+    show_approval_in_pager as show_approval_in_pager,
+)
+
+# Renderable blocks (+ helper functions used by tests)
+from pythinker_code.ui.shell.visualize._blocks import (
+    _ContentBlock as _ContentBlock,
+)
+from pythinker_code.ui.shell.visualize._blocks import (
+    _estimate_tokens as _estimate_tokens,
+)
+from pythinker_code.ui.shell.visualize._blocks import (
+    _find_committed_boundary as _find_committed_boundary,
+)
+from pythinker_code.ui.shell.visualize._blocks import (
+    _NotificationBlock as _NotificationBlock,
+)
+from pythinker_code.ui.shell.visualize._blocks import (
+    _StatusBlock as _StatusBlock,
+)
+from pythinker_code.ui.shell.visualize._blocks import (
+    _tail_lines as _tail_lines,
+)
+from pythinker_code.ui.shell.visualize._blocks import (
+    _ToolCallBlock as _ToolCallBlock,
+)
+from pythinker_code.ui.shell.visualize._blocks import (
+    _truncate_to_display_width as _truncate_to_display_width,
+)
+
+# BTW panel
+from pythinker_code.ui.shell.visualize._btw_panel import (
+    _BtwModalDelegate as _BtwModalDelegate,
+)
+
+# Input routing
+from pythinker_code.ui.shell.visualize._input_router import (
+    InputAction as InputAction,
+)
+from pythinker_code.ui.shell.visualize._input_router import (
+    classify_input as classify_input,
+)
+
+# Interactive view
+from pythinker_code.ui.shell.visualize._interactive import (
+    BtwRunner,
+    _PromptLiveView,
+)
+
+# Base view
+from pythinker_code.ui.shell.visualize._live_view import (
+    _keyboard_listener as _keyboard_listener,
+)
+from pythinker_code.ui.shell.visualize._live_view import (
+    _LiveView,
+)
+
+# Question panel (moved from ui/shell/question_panel.py)
+from pythinker_code.ui.shell.visualize._question_panel import (
+    QuestionPromptDelegate as QuestionPromptDelegate,
+)
+from pythinker_code.ui.shell.visualize._question_panel import (
+    QuestionRequestPanel as QuestionRequestPanel,
+)
+from pythinker_code.ui.shell.visualize._question_panel import (
+    prompt_other_input as prompt_other_input,
+)
+from pythinker_code.ui.shell.visualize._question_panel import (
+    show_question_body_in_pager as show_question_body_in_pager,
+)
+
+# Wire types and utils (re-exported for test compatibility)
+from pythinker_code.utils.aioqueue import QueueShutDown as QueueShutDown  # noqa: F401
+from pythinker_code.wire import WireUISide
+from pythinker_code.wire.types import ContentPart, StatusUpdate
+from pythinker_code.wire.types import TurnEnd as TurnEnd  # noqa: F401
+
+# --- Factory function ------------------------------------------------------
+
+
+async def visualize(
+    wire: WireUISide,
+    *,
+    initial_status: StatusUpdate,
+    cancel_event: asyncio.Event | None = None,
+    prompt_session: CustomPromptSession | None = None,
+    steer: Callable[[str | list[ContentPart]], None] | None = None,
+    btw_runner: BtwRunner | None = None,
+    bind_running_input: Callable[[Callable[[UserInput], None], Callable[[], None]], None]
+    | None = None,
+    unbind_running_input: Callable[[], None] | None = None,
+    on_view_ready: Callable[[Any], None] | None = None,
+    on_view_closed: Callable[[], None] | None = None,
+    show_thinking_stream: bool = False,
+):
+    """A loop to consume agent events and visualize the agent behavior.
+
+    Creates either a ``_LiveView`` (Rich Live, non-interactive) or a
+    ``_PromptLiveView`` (prompt_toolkit, interactive) depending on whether
+    a prompt session is provided.
+    """
+    if prompt_session is not None and steer is not None:
+        view = _PromptLiveView(
+            initial_status,
+            prompt_session=prompt_session,
+            steer=steer,
+            btw_runner=btw_runner,
+            cancel_event=cancel_event,
+            show_thinking_stream=show_thinking_stream,
+        )
+        prompt_session.attach_running_prompt(view)
+
+        def _cancel_running_input() -> None:
+            if cancel_event is not None:
+                cancel_event.set()
+
+        if bind_running_input is not None:
+            bind_running_input(view.handle_local_input, _cancel_running_input)
+    else:
+        view = _LiveView(initial_status, cancel_event, show_thinking_stream=show_thinking_stream)
+    if on_view_ready is not None:
+        on_view_ready(view)
+    try:
+        await view.visualize_loop(wire)
+    finally:
+        if prompt_session is not None and steer is not None:
+            if unbind_running_input is not None:
+                unbind_running_input()
+            if isinstance(view, _PromptLiveView):
+                prompt_session.detach_running_prompt(view)
+        if on_view_closed is not None:
+            on_view_closed()