pythinker-code 0.60.0__py3-none-any.whl → 0.62.0__py3-none-any.whl

pythinker_code/CHANGELOG.md

@@ -15,6 +15,38 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+## 0.62.0 (2026-07-22)
+
+- Treat the repository-root `.agents/` directory as local agent configuration and keep it out of version control.
+- Show an update notice when a newer Pythinker version becomes available mid-session.
+
+## 0.61.0 (2026-07-22)
+
+- Fixed reasoning summaries exposing Markdown delimiters and duplicate terminal rows after refocus, and redesigned agent progress (single `Agent` calls and parallel `RunAgents` fan-outs) as a compact, payload-free agent activity tree.
+- Retain a non-streaming OpenAI Responses reasoning item's encrypted content when it carries no summary, matching the streaming path so the reasoning boundary stays replayable.
+- Reduce the shell prompt session to a compatibility façade over deep `prompting/` modules (config, keybindings, completion menus, narrow shell-facing methods), with Unicode cell-width coverage and documented module ownership in the architecture guide.
+- Render image/audio/video and unknown content parts as payload-free labels in the live view, roll nested subagent activity (up to 16 levels) under the correct root tool card, and stop provider-remapped tool results from starting replay user turns.
+- **Behavior change:** `!` shell commands now run through the detected configured shell (`<shell> -c`, PowerShell `-command` on Windows) instead of the implicit `/bin/sh`/`cmd.exe`, with separate 1 MiB stdout/stderr caps and cancellation cleanup; existing `cmd.exe`-syntax commands on Windows may need updating.
+- Distinguish background auto-trigger grace expiry from user input activity with typed prompt events, and bound streamed tool-argument label scans to 1 KiB growth boundaries.
+- Scope prompt Git status, toasts, history, and clipboard to each shell session with a new `/prompt-history status|clear` command, bounded locked history storage, and cross-session isolation.
+- Unify the shell footer behind one per-frame view model shared by the legacy and card renderers, and key theme style-resolver caching by terminal capabilities.
+- Fix a rare queued-follow-up "ghost card": echoing a drained queued command now commits through the scrollback handoff (which hides the input card before the terminal teardown erases the prompt), so the input-card border can no longer fossilize into scrollback above the echoed command under heavy load.
+- Freeze the public shell prompt compatibility contract with constructor and rendering coverage.
+- Unify slash and file-mention completion behind one canonical completion context, adding quoted `@"path with spaces"` file mentions.
+- Index workspace file mentions asynchronously with a cwd-aware, generation-owned snapshot index so completion never blocks on disk or Git scans.
+- Harden prompt completion: Escape now dismisses the slash-argument menu (not just draft commands), file-mention highlighting no longer swallows trailing prose punctuation, scoped `@dir/name` completions rank basename-prefix matches first, workspace Git scans drain stdout/stderr concurrently to avoid a pipe deadlock, and a mid-session working-directory removal no longer crashes the prompt turn.
+- Keep the interactive prompt scene within the terminal height with a priority-ordered row allocator, and shut prompt background tasks/processes down with an awaited lifecycle.
+- Add xAI Grok OAuth login (browser loopback and device-code).
+- Add GitHub Copilot device-code OAuth login for individual github.com accounts.
+- Add DigitalOcean Gradient AI browser OAuth login with dynamically discovered Inference Routers; router-discovery failures (unauthorized, outage, malformed, empty) are now reported distinctly instead of silently yielding no models.
+- Add Snowflake Cortex account-scoped browser OAuth login (`pythinker login --snowflake`); the account identifier is validated before any request, and models register without becoming the default until Cortex chat support ships.
+- Discover each provider's models from a cached, typed, provider-neutral models.dev catalog with curated fallbacks, so xAI, GitHub Copilot, and Snowflake pick up new models automatically; the catalog is now portable across platforms (no longer Unix-only) and distinguishes fresh, cached, stale, disabled, and unavailable results.
+- Persist provider login and logout atomically so a failed save never leaves orphaned credentials or a half-applied configuration; a re-login whose save fails now restores the previous credential instead of deleting it, and provider persistence failures are logged.
+- Fix queued follow-up input showing a bordered ghost; pressing Enter during an active turn now shows one intentional queued row.
+- Harden provider OAuth credential handling: scope token refresh to the active/selected provider, serialize persistence under a lock with atomic config replacement, roll back replaced credentials when a save fails, fail closed on credential migration, and validate OAuth token and implicit-state responses.
+- Fix an intermittent doubled/"ghost" copy of the running-prompt block (agent tree, spinner, and tip) on long streaming turns: after a scrollback handoff the suppressed live body now waits for the terminal's re-requested absolute cursor position to settle before it re-expands, so it repaints against a correct cursor model instead of the mis-anchored frame left behind by `run_in_terminal`.
+- Fix the "update available" footer notice being suppressed on shell-mode frames (and a stale agent-mode notice replaying after a mode switch): the shell prompt render now refreshes the per-frame update-notice snapshot like the agent path, and the snapshot is cleared with the frame.
+
 ## 0.60.0 (2026-07-18)
 
 - **Leaf subagent prompt profile.** All 12 built-in subagent roles (implementer,

pythinker_code/auth/__init__.py

@@ -9,10 +9,14 @@ MINIMAX_PLATFORM_ID = "minimax"
 MOONSHOT_PLATFORM_ID = "moonshot"
 KIMI_PLATFORM_ID = "kimi"
 DEEPSEEK_PLATFORM_ID = "deepseek"
+DIGITALOCEAN_PLATFORM_ID = "digitalocean"
+GITHUB_COPILOT_PLATFORM_ID = "copilot"
 ANTHROPIC_PLATFORM_ID = "anthropic"
 OPENROUTER_PLATFORM_ID = "openrouter"
+SNOWFLAKE_CORTEX_PLATFORM_ID = "snowflake-cortex"
 LM_STUDIO_PLATFORM_ID = "lm-studio"
 OLLAMA_PLATFORM_ID = "ollama"
+XAI_PLATFORM_ID = "xai"
 ZAI_CODING_PLATFORM_ID = "z-ai-coding"
 ZAI_API_PLATFORM_ID = "z-ai-api"
 
@@ -20,6 +24,8 @@ __all__ = [
     "ALIBABA_PLATFORM_ID",
     "ANTHROPIC_PLATFORM_ID",
     "DEEPSEEK_PLATFORM_ID",
+    "DIGITALOCEAN_PLATFORM_ID",
+    "GITHUB_COPILOT_PLATFORM_ID",
     "KIMI_PLATFORM_ID",
     "LM_STUDIO_PLATFORM_ID",
     "MINIMAX_PLATFORM_ID",
@@ -30,6 +36,8 @@ __all__ = [
     "OPENCODE_GO_PLATFORM_ID",
     "OPENROUTER_PLATFORM_ID",
     "PYTHINKER_CODE_PLATFORM_ID",
+    "SNOWFLAKE_CORTEX_PLATFORM_ID",
+    "XAI_PLATFORM_ID",
     "ZAI_API_PLATFORM_ID",
     "ZAI_CODING_PLATFORM_ID",
 ]

pythinker_code/auth/copilot.py

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from typing import Any, cast
+
+import aiohttp
+from pydantic import SecretStr
+
+from pythinker_code.auth import GITHUB_COPILOT_PLATFORM_ID
+from pythinker_code.auth.models_dev import (
+    CatalogModel,
+    build_catalog_models,
+    get_models_dev_catalog,
+)
+from pythinker_code.auth.oauth import (
+    OAuthError,
+    OAuthEvent,
+    OAuthToken,
+    OAuthUnauthorized,
+    persist_login,
+    persist_logout,
+)
+from pythinker_code.auth.oauth_flows import poll_device_token, request_device_code
+from pythinker_code.auth.platforms import managed_model_key, managed_provider_key
+from pythinker_code.config import Config, LLMModel, LLMProvider, OAuthRef
+from pythinker_code.thinking import apply_login_thinking_defaults
+from pythinker_code.utils.aiohttp import new_client_session
+from pythinker_code.utils.logging import logger
+
+GITHUB_COPILOT_CLIENT_ID = "Iv1.b507a08c87ecfe98"
+GITHUB_COPILOT_SCOPE = "read:user"
+GITHUB_DEVICE_CODE_ENDPOINT = "https://github.com/login/device/code"
+GITHUB_TOKEN_ENDPOINT = "https://github.com/login/oauth/access_token"
+GITHUB_COPILOT_TOKEN_ENDPOINT = "https://api.github.com/copilot_internal/v2/token"
+GITHUB_COPILOT_OAUTH_KEY = "oauth/github-copilot"
+GITHUB_COPILOT_PROVIDER_KEY = managed_provider_key(GITHUB_COPILOT_PLATFORM_ID)
+COPILOT_BASE_URL = "https://api.githubcopilot.com"
+GITHUB_COPILOT_MODELS_DEV_PROVIDER_ID = "github-copilot"
+GITHUB_COPILOT_DEFAULT_CONTEXT = 128_000
+
+GITHUB_JSON_HEADERS = {"Accept": "application/json"}
+_EDITOR_VERSION = "vscode/1.99.0"
+_EDITOR_PLUGIN_VERSION = "copilot-chat/0.26.7"
+_USER_AGENT = "GitHubCopilotChat/0.26.7"
+_GITHUB_API_VERSION = "2025-04-01"
+
+
+def build_copilot_headers() -> dict[str, str]:
+    return {
+        "Copilot-Integration-Id": "vscode-chat",
+        "Editor-Version": _EDITOR_VERSION,
+        "Editor-Plugin-Version": _EDITOR_PLUGIN_VERSION,
+        "User-Agent": _USER_AGENT,
+        "X-GitHub-Api-Version": _GITHUB_API_VERSION,
+        "Openai-Intent": "conversation-panel",
+    }
+
+
+def _build_exchange_headers(github_token: str) -> dict[str, str]:
+    return {
+        "Authorization": f"token {github_token}",
+        "Editor-Version": _EDITOR_VERSION,
+        "Editor-Plugin-Version": _EDITOR_PLUGIN_VERSION,
+        "User-Agent": _USER_AGENT,
+        "X-GitHub-Api-Version": _GITHUB_API_VERSION,
+    }
+
+
+@dataclass(frozen=True, slots=True)
+class GitHubCopilotModel:
+    model_id: str
+    display_name: str
+    max_context_size: int
+
+    @property
+    def alias(self) -> str:
+        return managed_model_key(GITHUB_COPILOT_PLATFORM_ID, self.model_id)
+
+
+GITHUB_COPILOT_MODELS: tuple[GitHubCopilotModel, ...] = (
+    GitHubCopilotModel("gpt-4.1", "GPT-4.1", 1_000_000),
+    GitHubCopilotModel("gpt-4o", "GPT-4o", 128_000),
+    GitHubCopilotModel("o4-mini", "o4-mini", 200_000),
+)
+
+
+def _copilot_oauth_ref() -> OAuthRef:
+    return OAuthRef(storage="file", key=GITHUB_COPILOT_OAUTH_KEY)
+
+
+def _apply_copilot_config(
+    config: Config, models: tuple[GitHubCopilotModel, ...] = GITHUB_COPILOT_MODELS
+) -> None:
+    oauth_ref = _copilot_oauth_ref()
+    config.providers[GITHUB_COPILOT_PROVIDER_KEY] = LLMProvider(
+        type="openai_legacy",
+        base_url=COPILOT_BASE_URL,
+        api_key=SecretStr(""),
+        oauth=oauth_ref,
+        custom_headers=build_copilot_headers(),
+    )
+
+    for alias, model in list(config.models.items()):
+        if model.provider == GITHUB_COPILOT_PROVIDER_KEY:
+            del config.models[alias]
+
+    for model in models:
+        config.models[model.alias] = LLMModel(
+            provider=GITHUB_COPILOT_PROVIDER_KEY,
+            model=model.model_id,
+            max_context_size=model.max_context_size,
+            display_name=model.display_name,
+        )
+
+    if models:
+        config.default_model = models[0].alias
+    apply_login_thinking_defaults(config, thinking=False, effort="off")
+
+
+def _catalog_models_to_copilot(built: tuple[CatalogModel, ...]) -> tuple[GitHubCopilotModel, ...]:
+    return tuple(
+        GitHubCopilotModel(model.model_id, model.display_name, model.max_context_size)
+        for model in built
+    )
+
+
+async def _discover_copilot_models() -> tuple[GitHubCopilotModel, ...]:
+    """Resolve the live Copilot model list from the shared models.dev catalog.
+
+    Falls back to the curated list when the catalog is unavailable or degraded.
+    """
+    result = await get_models_dev_catalog()
+    if not result.is_authoritative:
+        logger.debug(
+            "models.dev catalog not authoritative (status={status}, source={source}); "
+            "using curated GitHub Copilot models.",
+            status=result.status,
+            source=result.source,
+        )
+        return GITHUB_COPILOT_MODELS
+    built = build_catalog_models(
+        result.catalog,
+        GITHUB_COPILOT_MODELS_DEV_PROVIDER_ID,
+        default_context=GITHUB_COPILOT_DEFAULT_CONTEXT,
+    )
+    converted = _catalog_models_to_copilot(built)
+    if converted:
+        return converted
+    logger.debug(
+        "models.dev catalog contained no usable GitHub Copilot models "
+        "(status={status}, source={source}); using curated models.",
+        status=result.status,
+        source=result.source,
+    )
+    return GITHUB_COPILOT_MODELS
+
+
+async def refresh_copilot_token(github_token: str) -> OAuthToken:
+    try:
+        async with (
+            new_client_session() as session,
+            session.get(
+                GITHUB_COPILOT_TOKEN_ENDPOINT,
+                headers=_build_exchange_headers(github_token),
+            ) as response,
+        ):
+            status = response.status
+            try:
+                payload_any: Any = await response.json(content_type=None)
+            except ValueError:
+                payload_any = None
+    except (aiohttp.ClientError, TimeoutError, OSError) as exc:
+        raise OAuthError("GitHub Copilot token exchange request failed.") from exc
+
+    if status in {401, 403}:
+        raise OAuthUnauthorized("GitHub Copilot token exchange was unauthorized.")
+    if status != 200:
+        raise OAuthError(f"GitHub Copilot token exchange failed (HTTP {status}).")
+    if not isinstance(payload_any, dict):
+        raise OAuthError("GitHub Copilot token exchange returned an invalid response.")
+
+    payload = cast(dict[str, Any], payload_any)
+    bearer = payload.get("token")
+    expires_at = payload.get("expires_at")
+    refresh_in = payload.get("refresh_in")
+    if (
+        not isinstance(bearer, str)
+        or not bearer
+        or isinstance(expires_at, bool)
+        or not isinstance(expires_at, int)
+        or expires_at <= 0
+        or isinstance(refresh_in, bool)
+        or not isinstance(refresh_in, int)
+        or refresh_in <= 0
+    ):
+        raise OAuthError("GitHub Copilot token exchange returned an incomplete response.")
+
+    return OAuthToken(
+        access_token=bearer,
+        refresh_token=github_token,
+        expires_at=float(expires_at),
+        scope=GITHUB_COPILOT_SCOPE,
+        token_type="Bearer",
+        expires_in=float(refresh_in),
+    )
+
+
+async def login_copilot(config: Config, *, open_browser: bool = True) -> AsyncIterator[OAuthEvent]:
+    if not config.is_from_default_location:
+        yield OAuthEvent(
+            "error",
+            "Login requires the default config file; restart without --config/--config-file.",
+        )
+        return
+
+    try:
+        device_code = await request_device_code(
+            device_authorization_endpoint=GITHUB_DEVICE_CODE_ENDPOINT,
+            client_id=GITHUB_COPILOT_CLIENT_ID,
+            scope=GITHUB_COPILOT_SCOPE,
+            headers=GITHUB_JSON_HEADERS,
+        )
+    except OAuthError as exc:
+        yield OAuthEvent("error", f"Failed to start GitHub Copilot login: {exc}")
+        return
+
+    yield OAuthEvent(
+        "verification_url",
+        f"Open {device_code.verification_uri} and enter code {device_code.user_code}.",
+        data={
+            "verification_url": device_code.verification_uri,
+            "user_code": device_code.user_code,
+        },
+    )
+    if open_browser:
+        try:
+            from pythinker_code.utils.term import open_url_in_browser
+
+            open_url_in_browser(device_code.verification_uri)
+        except Exception as exc:
+            logger.warning("Failed to open browser: {error}", error=exc)
+    yield OAuthEvent("waiting", "Waiting for GitHub Copilot authorization...")
+
+    try:
+        payload = await poll_device_token(
+            token_endpoint=GITHUB_TOKEN_ENDPOINT,
+            client_id=GITHUB_COPILOT_CLIENT_ID,
+            device_code=device_code,
+            headers=GITHUB_JSON_HEADERS,
+        )
+        github_token = payload.get("access_token")
+        if not isinstance(github_token, str) or not github_token:
+            raise OAuthError("GitHub device token response was incomplete.")
+        copilot_token = await refresh_copilot_token(github_token)
+    except OAuthError as exc:
+        yield OAuthEvent("error", f"GitHub Copilot login failed: {exc}")
+        return
+
+    token = OAuthToken(
+        access_token=copilot_token.access_token,
+        refresh_token=github_token,
+        expires_at=copilot_token.expires_at,
+        scope=copilot_token.scope,
+        token_type=copilot_token.token_type,
+        expires_in=copilot_token.expires_in,
+    )
+    models = await _discover_copilot_models()
+    try:
+        await persist_login(
+            config, _copilot_oauth_ref(), token, lambda cfg: _apply_copilot_config(cfg, models)
+        )
+    except Exception as exc:
+        logger.warning("Failed to persist GitHub Copilot login: {exc}", exc=exc)
+        yield OAuthEvent("error", "Failed to save GitHub Copilot login.")
+        return
+    yield OAuthEvent(
+        "success",
+        f"GitHub Copilot configured with model {config.default_model}.",
+    )
+
+
+async def logout_copilot(config: Config) -> AsyncIterator[OAuthEvent]:
+    if not config.is_from_default_location:
+        yield OAuthEvent(
+            "error",
+            "Logout requires the default config file; restart without --config/--config-file.",
+        )
+        return
+
+    def _remove(cfg: Config) -> None:
+        cfg.providers.pop(GITHUB_COPILOT_PROVIDER_KEY, None)
+        for alias, model in list(cfg.models.items()):
+            if model.provider == GITHUB_COPILOT_PROVIDER_KEY:
+                del cfg.models[alias]
+        if cfg.default_model not in cfg.models:
+            cfg.default_model = next(iter(cfg.models), "")
+
+    try:
+        await persist_logout(config, _copilot_oauth_ref(), _remove)
+    except Exception as exc:
+        logger.warning("Failed to persist GitHub Copilot logout: {exc}", exc=exc)
+        yield OAuthEvent("error", "Failed to log out of GitHub Copilot.")
+        return
+    yield OAuthEvent("success", "Logged out of GitHub Copilot successfully.")

pythinker_code/auth/digitalocean.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, cast
+
+import aiohttp
+from pydantic import SecretStr
+
+from pythinker_code.auth import DIGITALOCEAN_PLATFORM_ID
+from pythinker_code.auth.oauth import OAuthError, OAuthEvent, persist_config_change
+from pythinker_code.auth.oauth_flows import run_loopback_implicit_flow
+from pythinker_code.auth.platforms import managed_model_key, managed_provider_key
+from pythinker_code.config import Config, LLMModel, LLMProvider
+from pythinker_code.thinking import apply_login_thinking_defaults
+from pythinker_code.utils.aiohttp import new_client_session
+from pythinker_code.utils.logging import logger
+
+DIGITALOCEAN_CLIENT_ID = "b1a6c5158156caac821fd1b30253ca8acb52454a48fa744420e41889cb589f82"
+DIGITALOCEAN_AUTHORIZE_URL = "https://cloud.digitalocean.com/v1/oauth/authorize"
+DIGITALOCEAN_SCOPE = "genai:read inference:query"
+DIGITALOCEAN_BASE_URL = "https://inference.do-ai.run/v1"
+DIGITALOCEAN_ROUTERS_URL = "https://api.digitalocean.com/v2/gen-ai/models/routers"
+DIGITALOCEAN_REDIRECT_PORT = 1456
+DIGITALOCEAN_CALLBACK_PATH = "/auth/callback"
+DIGITALOCEAN_TOKEN_PATH = "/auth/token"
+DIGITALOCEAN_PROVIDER_KEY = managed_provider_key(DIGITALOCEAN_PLATFORM_ID)
+DIGITALOCEAN_DEFAULT_CONTEXT = 128_000
+
+
+class RouterDiscovery(str, Enum):
+    """Outcome of a DigitalOcean inference-router discovery call."""
+
+    OK = "ok"  # routers were discovered
+    PARTIAL = "partial"  # valid routers were discovered alongside malformed entries
+    EMPTY = "empty"  # the account has no routers (valid, but empty)
+    UNAUTHORIZED = "unauthorized"  # the token could not list routers
+    UNAVAILABLE = "unavailable"  # timeout / outage / non-2xx response
+    MALFORMED = "malformed"  # the response body was not the expected shape
+
+
+@dataclass(frozen=True, slots=True)
+class RouterCatalog:
+    """Discovered routers paired with the outcome that produced them."""
+
+    status: RouterDiscovery
+    names: tuple[str, ...]
+
+
+def _skip_browser_open(_url: str) -> None:
+    return None
+
+
+def _apply_digitalocean_config(
+    config: Config,
+    api_key: SecretStr,
+    router_names: tuple[str, ...],
+) -> None:
+    config.providers[DIGITALOCEAN_PROVIDER_KEY] = LLMProvider(
+        type="openai_legacy",
+        base_url=DIGITALOCEAN_BASE_URL,
+        api_key=api_key,
+    )
+
+    for alias, model in list(config.models.items()):
+        if model.provider == DIGITALOCEAN_PROVIDER_KEY:
+            del config.models[alias]
+
+    for name in router_names:
+        model_id = f"router:{name}"
+        alias = managed_model_key(DIGITALOCEAN_PLATFORM_ID, model_id)
+        config.models[alias] = LLMModel(
+            provider=DIGITALOCEAN_PROVIDER_KEY,
+            model=model_id,
+            max_context_size=DIGITALOCEAN_DEFAULT_CONTEXT,
+            display_name=name,
+        )
+
+    if router_names:
+        config.default_model = managed_model_key(
+            DIGITALOCEAN_PLATFORM_ID,
+            f"router:{router_names[0]}",
+        )
+    elif config.default_model not in config.models:
+        config.default_model = next(iter(config.models), "")
+    apply_login_thinking_defaults(config, thinking=False, effort="off")
+
+
+def _parse_router_names(payload: object) -> RouterCatalog:
+    if not isinstance(payload, dict):
+        return RouterCatalog(RouterDiscovery.MALFORMED, ())
+    raw = cast(dict[str, Any], payload).get("model_routers")
+    if not isinstance(raw, list):
+        return RouterCatalog(RouterDiscovery.MALFORMED, ())
+    if not raw:
+        return RouterCatalog(RouterDiscovery.EMPTY, ())
+
+    names: list[str] = []
+    has_malformed_entry = False
+    for item in cast(list[Any], raw):
+        if isinstance(item, dict):
+            name = cast(dict[str, Any], item).get("name")
+            if isinstance(name, str) and name.strip():
+                names.append(name)
+                continue
+        has_malformed_entry = True
+    if not names:
+        return RouterCatalog(RouterDiscovery.MALFORMED, ())
+    if has_malformed_entry:
+        return RouterCatalog(RouterDiscovery.PARTIAL, tuple(names))
+    return RouterCatalog(RouterDiscovery.OK, tuple(names))
+
+
+async def _fetch_router_catalog(access_token: str) -> RouterCatalog:
+    """Discover the account's inference routers, preserving distinct outcomes.
+
+    Authentication failures, dependency outages, malformed responses, and a
+    valid-but-empty catalog are each reported separately so the login flow can
+    surface an accurate message instead of collapsing everything into "no
+    routers".
+    """
+    try:
+        async with (
+            new_client_session() as session,
+            session.get(
+                DIGITALOCEAN_ROUTERS_URL,
+                headers={
+                    "Authorization": f"Bearer {access_token}",
+                    "Accept": "application/json",
+                },
+            ) as response,
+        ):
+            status = response.status
+            if status in (401, 403):
+                return RouterCatalog(RouterDiscovery.UNAUTHORIZED, ())
+            if not 200 <= status < 300:
+                return RouterCatalog(RouterDiscovery.UNAVAILABLE, ())
+            try:
+                payload: Any = await response.json(content_type=None)
+            except (ValueError, aiohttp.ClientError):
+                return RouterCatalog(RouterDiscovery.MALFORMED, ())
+    except (TimeoutError, aiohttp.ClientError, OSError):
+        return RouterCatalog(RouterDiscovery.UNAVAILABLE, ())
+
+    return _parse_router_names(payload)
+
+
+def _router_status_message(status: RouterDiscovery) -> str | None:
+    if status is RouterDiscovery.OK:
+        return None
+    if status is RouterDiscovery.PARTIAL:
+        return (
+            "DigitalOcean returned some malformed inference-router entries; sign-in saved "
+            "with valid routers configured and malformed entries ignored."
+        )
+    if status is RouterDiscovery.EMPTY:
+        return "DigitalOcean returned no inference routers; sign-in saved with no models."
+    if status is RouterDiscovery.MALFORMED:
+        return (
+            "DigitalOcean returned entirely malformed inference-router data; sign-in saved "
+            "with no models configured."
+        )
+    if status is RouterDiscovery.UNAUTHORIZED:
+        return (
+            "DigitalOcean did not authorize inference-router discovery; sign-in saved. "
+            "Re-run login once the account has inference access."
+        )
+    return (
+        "DigitalOcean Inference Routers were unavailable; sign-in saved. "
+        "Re-run login to load routers."
+    )
+
+
+async def login_digitalocean(
+    config: Config, *, open_browser: bool = True
+) -> AsyncIterator[OAuthEvent]:
+    if not config.is_from_default_location:
+        yield OAuthEvent(
+            "error",
+            "Login requires the default config file; restart without --config/--config-file.",
+        )
+        return
+
+    yield OAuthEvent("waiting", "Waiting for DigitalOcean browser authorization...")
+    try:
+        auth = await run_loopback_implicit_flow(
+            authorize_endpoint=DIGITALOCEAN_AUTHORIZE_URL,
+            client_id=DIGITALOCEAN_CLIENT_ID,
+            scope=DIGITALOCEAN_SCOPE,
+            callback_path=DIGITALOCEAN_CALLBACK_PATH,
+            token_path=DIGITALOCEAN_TOKEN_PATH,
+            port=DIGITALOCEAN_REDIRECT_PORT,
+            browser_open=None if open_browser else _skip_browser_open,
+        )
+    except OAuthError as exc:
+        yield OAuthEvent("error", f"DigitalOcean browser login failed: {exc}")
+        return
+
+    catalog = await _fetch_router_catalog(auth.access_token)
+    try:
+        await persist_config_change(
+            config,
+            lambda cfg: _apply_digitalocean_config(
+                cfg, SecretStr(auth.access_token), catalog.names
+            ),
+        )
+    except Exception as exc:
+        logger.warning("Failed to persist DigitalOcean login: {exc}", exc=exc)
+        yield OAuthEvent("error", "Failed to save DigitalOcean login.")
+        return
+
+    message = _router_status_message(catalog.status)
+    if message:
+        yield OAuthEvent("info", message)
+    if catalog.names:
+        success_message = f"DigitalOcean configured with model {config.default_model}."
+    else:
+        success_message = "DigitalOcean credentials saved; no inference routers are configured."
+    yield OAuthEvent("success", success_message)
+
+
+async def logout_digitalocean(config: Config) -> AsyncIterator[OAuthEvent]:
+    if not config.is_from_default_location:
+        yield OAuthEvent(
+            "error",
+            "Logout requires the default config file; restart without --config/--config-file.",
+        )
+        return
+
+    def _remove(cfg: Config) -> None:
+        cfg.providers.pop(DIGITALOCEAN_PROVIDER_KEY, None)
+        for alias, model in list(cfg.models.items()):
+            if model.provider == DIGITALOCEAN_PROVIDER_KEY:
+                del cfg.models[alias]
+        if cfg.default_model not in cfg.models:
+            cfg.default_model = next(iter(cfg.models), "")
+
+    try:
+        await persist_config_change(config, _remove)
+    except Exception as exc:
+        logger.warning("Failed to persist DigitalOcean logout: {exc}", exc=exc)
+        yield OAuthEvent("error", "Failed to log out of DigitalOcean.")
+        return
+    yield OAuthEvent("success", "Logged out of DigitalOcean successfully.")