deepagents-code 0.1.10__tar.gz → 0.1.11__tar.gz

{deepagents_code-0.1.10 → deepagents_code-0.1.11}/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 # Deep Agents Code Changelog
 
+## [0.1.11](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.10...deepagents-code==0.1.11) (2026-06-07)
+
+### Bug Fixes
+
+* Pause loading timer during approvals ([#3782](https://github.com/langchain-ai/deepagents/issues/3782)) ([f98fb0c](https://github.com/langchain-ai/deepagents/commit/f98fb0c80d08e408a018ea33a8aa7144180f4e93))
+* Run auto-update before startup ([#3784](https://github.com/langchain-ai/deepagents/issues/3784)) ([c160ea3](https://github.com/langchain-ai/deepagents/commit/c160ea3eeda1d0ba707bb524cfd0ce087a854e08))
+* Skip update prompts for editable installs ([#3781](https://github.com/langchain-ai/deepagents/issues/3781)) ([ae2874e](https://github.com/langchain-ai/deepagents/commit/ae2874e8ece96c04233c1a88a9da1bd7b9ee2bb2))
+
 ## [0.1.10](https://github.com/langchain-ai/deepagents/compare/deepagents-code==0.1.9...deepagents-code==0.1.10) (2026-06-05)
 
 ### Features

{deepagents_code-0.1.10 → deepagents_code-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents-code
-Version: 0.1.10
+Version: 0.1.11
 Summary: Terminal interface for Deep Agents - interactive AI agent with file operations, shell access, and sub-agent capabilities.
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/

{deepagents_code-0.1.10 → deepagents_code-0.1.11}/deepagents_code/_env_vars.py

@@ -134,6 +134,16 @@ and `/api/show`. See `_ollama_discovery_enabled` for accepted truthy/falsy
 values.
 """
 
+RESTARTED_AFTER_UPDATE = "DEEPAGENTS_CODE_RESTARTED_AFTER_UPDATE"
+"""Internal sentinel recording the target version immediately before the
+startup auto-update re-execs the process.
+
+Not user-facing. The re-exec'd process consumes it and, if that same version
+still reports as available (a no-op upgrade that did not change the running
+version), skips auto-updating to break out of an otherwise endless
+upgrade/restart loop. Set and read internally across `os.execv`.
+"""
+
 SERVER_ENV_PREFIX = "DEEPAGENTS_CODE_SERVER_"
 """Environment variable prefix used to pass CLI config to the server subprocess."""
 

{deepagents_code-0.1.10 → deepagents_code-0.1.11}/deepagents_code/_version.py

@@ -2,7 +2,7 @@
 
 # Keep the `x-release-please-version` annotation — release-please uses it to
 # bump `__version__` in sync with `pyproject.toml` on every release PR.
-__version__ = "0.1.10"  # x-release-please-version
+__version__ = "0.1.11"  # x-release-please-version
 
 DOCS_URL = "https://docs.langchain.com/oss/python/deepagents/code"
 """URL for `deepagents-code` documentation."""

{deepagents_code-0.1.10 → deepagents_code-0.1.11}/deepagents_code/app.py

@@ -3201,23 +3201,31 @@ class DeepAgentsApp(App):
             self._update_check_done.set()
 
     async def _check_for_updates_impl(self, *, periodic: bool = False) -> None:
-        """Check PyPI for a newer version and either auto-update or queue a modal.
+        """Check PyPI for a newer version and surface it in-session.
 
         Phase 1 contacts PyPI and records the latest version on the app.
-        Phase 2 either performs the auto-upgrade (when enabled), or
-        registers the actionable notice and schedules the update modal.
+        Phase 2 surfaces a detected update without installing it in-session
+        (the actual install runs at startup via `_run_startup_auto_update`):
+        when auto-update is enabled it toasts a prompt to restart so the
+        startup path can upgrade; otherwise it raises an actionable notice
+        (periodic recheck) or registers the notice and schedules the update
+        modal (initial check).
         Phase 2 sets `_update_modal_pending` *only* when the modal is
         actually being scheduled; a detected-but-throttled update
         leaves the event clear so missing-dep toasts still fire.
         """
         # Phase 1: version check (benign failure)
         try:
+            from deepagents_code.config import _is_editable_install
             from deepagents_code.update_check import (
                 is_auto_update_enabled,
                 is_update_available,
                 upgrade_command,
             )
 
+            if await asyncio.to_thread(_is_editable_install):
+                return
+
             available, latest = await asyncio.to_thread(
                 is_update_available,
                 bypass_cache=periodic,
@@ -3233,68 +3241,16 @@ class DeepAgentsApp(App):
         # Phase 2: auto-update or register actionable notice
         try:
             from deepagents_code._version import __version__ as cli_version
+            from deepagents_code.update_check import (
+                format_installed_age_suffix,
+                format_release_age_parenthetical,
+                mark_update_notified,
+                should_notify_update,
+            )
 
             if is_auto_update_enabled():
-                from deepagents_code._env_vars import DEBUG_UPDATE
-                from deepagents_code.update_check import (
-                    create_update_log_path,
-                    perform_upgrade,
-                )
-
-                if os.environ.get(DEBUG_UPDATE):
-                    self.notify(
-                        "Skipped update install (debug mode).",
-                        severity="information",
-                        timeout=4,
-                        markup=False,
-                    )
-                    return
-
-                log_path = create_update_log_path()
-                self.notify(
-                    f"Updating to v{latest}... Logs: {log_path}",
-                    severity="information",
-                    timeout=5,
-                    markup=False,
-                )
-                success, output = await perform_upgrade(log_path=log_path)
-                if success:
-                    self.notify(
-                        f"Updated to v{latest}. Restart to use the new version.",
-                        severity="information",
-                        timeout=10,
-                    )
-                else:
-                    logger.warning(
-                        "Background auto-upgrade to v%s failed. Output:\n%s",
-                        latest,
-                        output,
-                    )
-                    cmd = upgrade_command()
-                    snippet = _truncate(output, limit=160) if output else ""
-                    message = (
-                        f"Auto-update failed. Run manually: {cmd}\nLog: {log_path}"
-                    )
-                    if snippet:
-                        message = f"{message}\n{snippet}"
-                    self.notify(
-                        message,
-                        severity="warning",
-                        timeout=15,
-                        markup=False,
-                    )
-            else:
-                from deepagents_code.update_check import (
-                    format_installed_age_suffix,
-                    format_release_age_parenthetical,
-                    mark_update_notified,
-                    should_notify_update,
-                )
-
                 if not await asyncio.to_thread(should_notify_update, latest):
                     return
-
-                cmd = upgrade_command()
                 release_age = await asyncio.to_thread(
                     format_release_age_parenthetical,
                     latest,
@@ -3303,33 +3259,56 @@ class DeepAgentsApp(App):
                     format_installed_age_suffix,
                     cli_version,
                 )
-                notification = self._build_update_notification(
-                    latest=latest,
-                    cli_version=cli_version,
-                    release_age=release_age,
-                    installed_age=installed_age,
-                    upgrade_cmd=cmd,
+                self.notify(
+                    f"Update available: v{latest}{release_age}. "
+                    f"Currently installed: {cli_version}{installed_age}. "
+                    "Restart dcode to auto-update before startup.",
+                    severity="information",
+                    timeout=12,
+                    markup=False,
                 )
-                if periodic:
-                    self._notify_actionable(
-                        notification,
-                        severity="information",
-                        timeout=12,
-                        action_hint="Press ctrl+n to install.",
-                    )
-                    await asyncio.to_thread(mark_update_notified, latest)
-                    return
-                # Register without a toast: the dedicated modal is
-                # the update's UI, so a parallel toast would be
-                # redundant. Registration still makes the entry
-                # reachable via ctrl+n if the modal is dismissed.
-                self._notice_registry.add(notification)
                 await asyncio.to_thread(mark_update_notified, latest)
-                # Set *before* scheduling the modal: the optional-tools
-                # worker may race with this path, and it gates toast
-                # suppression on this event.
-                self._update_modal_pending.set()
-                self.call_after_refresh(self._open_update_available_modal, notification)
+                return
+
+            if not await asyncio.to_thread(should_notify_update, latest):
+                return
+
+            cmd = upgrade_command()
+            release_age = await asyncio.to_thread(
+                format_release_age_parenthetical,
+                latest,
+            )
+            installed_age = await asyncio.to_thread(
+                format_installed_age_suffix,
+                cli_version,
+            )
+            notification = self._build_update_notification(
+                latest=latest,
+                cli_version=cli_version,
+                release_age=release_age,
+                installed_age=installed_age,
+                upgrade_cmd=cmd,
+            )
+            if periodic:
+                self._notify_actionable(
+                    notification,
+                    severity="information",
+                    timeout=12,
+                    action_hint="Press ctrl+n to install.",
+                )
+                await asyncio.to_thread(mark_update_notified, latest)
+                return
+            # Register without a toast: the dedicated modal is
+            # the update's UI, so a parallel toast would be
+            # redundant. Registration still makes the entry
+            # reachable via ctrl+n if the modal is dismissed.
+            self._notice_registry.add(notification)
+            await asyncio.to_thread(mark_update_notified, latest)
+            # Set *before* scheduling the modal: the optional-tools
+            # worker may race with this path, and it gates toast
+            # suppression on this event.
+            self._update_modal_pending.set()
+            self.call_after_refresh(self._open_update_available_modal, notification)
         except Exception:
             logger.warning("Update check/notify failed unexpectedly", exc_info=True)
             if is_auto_update_enabled():
@@ -4101,6 +4080,24 @@ class DeepAgentsApp(App):
             # Cosmetic only: must never break app startup or theme changes.
             logger.warning("set_terminal_background raised unexpectedly", exc_info=True)
 
+    def _pause_loading_spinner_for_approval(self) -> None:
+        """Pause the global spinner timer while an approval widget is visible."""
+        if self._loading_widget is not None:
+            self._loading_widget.pause()
+
+    def _resume_loading_spinner_after_approval(
+        self,
+        _future: asyncio.Future[Any] | None = None,
+    ) -> None:
+        """Resume the global spinner timer after an approval decision.
+
+        Accepts an unused `_future` argument so it can be registered directly as
+        a `Future.add_done_callback`, which always passes the completed future
+        positionally.
+        """
+        if self._loading_widget is not None:
+            self._loading_widget.resume()
+
     async def _set_spinner(self, status: SpinnerStatus) -> None:
         """Show, update, or hide the loading spinner.
 
@@ -4149,6 +4146,11 @@ class DeepAgentsApp(App):
             self._loading_widget = LoadingWidget(status)
             await self._mount_before_queued(messages, self._loading_widget)
         else:
+            # A fresh status update means the agent is active again, so
+            # un-pause as a backstop in case an approval future was ever
+            # abandoned without completing the resume callback. `resume()` is a
+            # no-op when the spinner is not paused.
+            self._loading_widget.resume()
             # Update existing
             self._loading_widget.set_status(status)
             # Reposition via move_child so elapsed-time and animation state
@@ -4261,6 +4263,13 @@ class DeepAgentsApp(App):
             while self._pending_approval_widget is not None:  # noqa: ASYNC110  # Simple polling is sufficient here
                 await asyncio.sleep(0.1)
 
+        # Pause the elapsed-time counter while the user decides, then resume it
+        # when the decision future completes. Resolve, reject, and cancel all
+        # fire the done-callback; the `_set_spinner` backstop covers the
+        # remaining case where a future is abandoned without completing.
+        self._pause_loading_spinner_for_approval()
+        result_future.add_done_callback(self._resume_loading_spinner_after_approval)
+
         # Create menu with unique ID to avoid conflicts
         from deepagents_code.widgets.approval import ApprovalMenu
 

deepagents_code-0.1.11/deepagents_code/auth_display.py

@@ -0,0 +1,137 @@
+"""Shared provider auth status formatting."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, assert_never
+
+from textual.content import Content
+
+from deepagents_code.model_config import (
+    ProviderAuthSource,
+    ProviderAuthState,
+    ProviderAuthStatus,
+    resolved_env_var_name,
+)
+
+if TYPE_CHECKING:
+    from deepagents_code.config import Glyphs
+
+
+def format_auth_badge(status: ProviderAuthStatus) -> Content:
+    """Format an auth manager badge for a provider.
+
+    Used by the `/auth` manager, where each provider renders a bracketed,
+    styled badge (e.g. `[stored]`, `[env: ANTHROPIC_API_KEY]`, `[missing]`).
+
+    Args:
+        status: Provider auth/readiness status.
+
+    Returns:
+        A styled badge `Content` for the auth manager surface.
+    """
+    state = status.state
+    match state:
+        case ProviderAuthState.CONFIGURED:
+            return _format_configured_badge(status)
+        case ProviderAuthState.MISSING:
+            return Content.styled("[missing]", "bold $warning")
+        case ProviderAuthState.NOT_REQUIRED:
+            return _auth_badge(status.detail or "no API key required")
+        case ProviderAuthState.IMPLICIT:
+            return _auth_badge(status.detail or "implicit auth")
+        case ProviderAuthState.MANAGED:
+            return _auth_badge(status.detail or "custom auth")
+        case ProviderAuthState.UNKNOWN:
+            return _auth_badge(status.detail or "credentials unknown", prefix="? ")
+        case _:
+            assert_never(state)
+
+
+def format_auth_indicator(status: ProviderAuthStatus, glyphs: Glyphs) -> str:
+    """Format a model selector provider-header indicator.
+
+    Used by `/model`, where the indicator is plain text shown next to the
+    provider name. Returns an empty string for `CONFIGURED` providers, which
+    need no indicator.
+
+    Args:
+        status: Provider auth/readiness status.
+        glyphs: Glyph table for the active terminal mode.
+
+    Returns:
+        Text shown next to the provider name, or an empty string when no
+            indicator should be rendered (e.g., `CONFIGURED`).
+    """
+    state = status.state
+    match state:
+        case ProviderAuthState.CONFIGURED:
+            return ""
+        case ProviderAuthState.MISSING:
+            if status.env_var:
+                return f"{glyphs.warning} missing {status.env_var}"
+            return f"{glyphs.warning} missing credentials"
+        case ProviderAuthState.NOT_REQUIRED:
+            return status.detail or "no API key required"
+        case ProviderAuthState.IMPLICIT:
+            return status.detail or "implicit auth"
+        case ProviderAuthState.MANAGED:
+            return status.detail or "custom auth"
+        case ProviderAuthState.UNKNOWN:
+            detail = status.detail or "credentials unknown"
+            return f"{glyphs.question} {detail}"
+        case _:
+            assert_never(state)
+
+
+def _auth_badge(detail: str, *, prefix: str = "") -> Content:
+    """Format a muted auth manager badge.
+
+    Args:
+        detail: Badge text inside the brackets.
+        prefix: Text prepended verbatim before `detail` inside the brackets.
+            Callers include any separator themselves (e.g. `"? "`); this
+            helper does not insert one.
+
+    Returns:
+        Formatted auth manager badge content.
+    """
+    return Content.assemble(
+        ("[", "$text-muted"),
+        (prefix, "$text-muted"),
+        Content.styled(detail, "$text-muted"),
+        ("]", "$text-muted"),
+    )
+
+
+def _format_configured_badge(status: ProviderAuthStatus) -> Content:
+    """Format the auth manager badge for a `CONFIGURED` provider.
+
+    Args:
+        status: A `CONFIGURED` provider auth status.
+
+    Returns:
+        A styled badge naming the credential source (`[stored]` or `[env: …]`).
+
+    Raises:
+        ValueError: If the status carries no source. `ProviderAuthStatus`
+            guarantees `CONFIGURED` implies a source, so this guards against
+            that invariant being violated rather than a normal input.
+    """
+    match status.source:
+        case ProviderAuthSource.STORED:
+            return Content.styled("[stored]", "bold $success")
+        case ProviderAuthSource.ENV:
+            if status.env_var:
+                return Content.assemble(
+                    ("[env: ", "$text-muted"),
+                    Content.styled(
+                        resolved_env_var_name(status.env_var), "$text-muted"
+                    ),
+                    ("]", "$text-muted"),
+                )
+            return Content.styled("[env]", "$text-muted")
+        case None:
+            msg = f"CONFIGURED auth status has no source: {status!r}"
+            raise ValueError(msg)
+        case _:
+            assert_never(status.source)

{deepagents_code-0.1.10 → deepagents_code-0.1.11}/deepagents_code/main.py

@@ -20,9 +20,11 @@ import sys
 import traceback
 from collections.abc import Callable, Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, NoReturn
 
 if TYPE_CHECKING:
+    from rich.console import Console
+
     from deepagents_code.app import AppResult
     from deepagents_code.mcp_tools import MCPServerInfo
     from deepagents_code.notifications import PendingNotification
@@ -35,6 +37,127 @@ from deepagents_code._version import __version__
 logger = logging.getLogger(__name__)
 
 
+def _restart_current_process() -> NoReturn:
+    """Replace the current process with a fresh `deepagents_code` invocation.
+
+    Raises:
+        RuntimeError: If process replacement unexpectedly returns.
+    """
+    argv = [sys.executable, "-m", "deepagents_code", *sys.argv[1:]]
+    # Re-exec the trusted interpreter with the user's own argv verbatim; the
+    # only "input" is the command the user already ran, so S606's concern
+    # (untrusted/unsanitized args to a spawned executable) does not apply.
+    os.execv(sys.executable, argv)  # noqa: S606
+    msg = "os.execv returned unexpectedly"
+    raise RuntimeError(msg)
+
+
+def _run_startup_auto_update(console: "Console") -> None:
+    """Apply enabled auto-updates before the TUI and server start.
+
+    On a successful upgrade the process is re-exec'd so the new version is
+    loaded. Any failure is fail-soft: the installed version is launched and
+    the error is surfaced, never blocking startup.
+
+    Raises:
+        SystemExit: Re-raised rather than suppressed by the fail-soft handler,
+            so a process-exit request is never swallowed (the `os.execv`
+            re-exec is simulated this way under test).
+    """
+    from rich.markup import escape
+
+    from deepagents_code._env_vars import DEBUG_UPDATE, RESTARTED_AFTER_UPDATE
+    from deepagents_code._version import __version__ as cli_version
+    from deepagents_code.config import _is_editable_install
+    from deepagents_code.update_check import (
+        create_update_log_path,
+        format_release_age_parenthetical,
+        get_cached_update_available,
+        is_auto_update_enabled,
+        perform_upgrade,
+        upgrade_command,
+    )
+
+    try:
+        if _is_editable_install() or not is_auto_update_enabled():
+            return
+        # Consume the re-exec sentinel recorded before the previous restart.
+        restarted_for = os.environ.pop(RESTARTED_AFTER_UPDATE, None)
+        available, latest = get_cached_update_available()
+        if not available or latest is None:
+            return
+        if restarted_for == latest:
+            # Already restarted after upgrading to this version, yet it still
+            # reports as available: the install did not change the running
+            # version. Bail out instead of upgrading and restarting forever
+            # (this runs before the TUI, so there is no in-app way to stop it).
+            cmd = upgrade_command()
+            console.print(
+                f"[bold yellow]Warning:[/bold yellow] v{latest} still reports as "
+                "available after an automatic update; skipping auto-update to "
+                f"avoid a restart loop. Update manually: [cyan]{cmd}[/cyan]\n"
+                f"Continuing with v{cli_version}.",
+                highlight=False,
+            )
+            return
+        release_age = format_release_age_parenthetical(latest)
+        console.print(
+            f"Auto-updating deepagents-code from v{cli_version} to "
+            f"v{latest}{release_age} before startup..."
+        )
+        if os.environ.get(DEBUG_UPDATE):
+            console.print("Skipped update install (debug mode).", style="dim")
+            return
+        log_path = create_update_log_path()
+        console.print(
+            f"Update log: {log_path}\nTail progress: tail -f {log_path}",
+            style="dim",
+            highlight=False,
+            markup=False,
+        )
+        success, output = asyncio.run(perform_upgrade(log_path=log_path))
+        if success:
+            console.print(f"[green]Updated to v{latest}. Restarting...[/green]")
+            # Record the target version so the re-exec'd process can detect a
+            # no-op upgrade and break the loop (see the `restarted_for` guard).
+            os.environ[RESTARTED_AFTER_UPDATE] = latest
+            try:
+                _restart_current_process()
+            except (OSError, RuntimeError):
+                # Upgrade succeeded but the re-exec did not happen (`os.execv`
+                # raised, or returned unexpectedly). Drop the sentinel and
+                # continue on the old in-memory code; the user must restart
+                # manually to load the new version.
+                os.environ.pop(RESTARTED_AFTER_UPDATE, None)
+                logger.warning("Restart after update failed", exc_info=True)
+                console.print(
+                    f"[bold yellow]Warning:[/bold yellow] Updated to v{latest} but "
+                    "the automatic restart failed. Restart dcode manually to use "
+                    "the new version.",
+                    highlight=False,
+                )
+            return
+        cmd = upgrade_command()
+        detail = f": {escape(output[:200])}" if output else ""
+        console.print(
+            f"[bold red]Auto-update failed{detail}[/bold red]\n"
+            f"Run manually: [cyan]{cmd}[/cyan]\n"
+            f"Continuing with v{cli_version}.",
+            markup=True,
+            highlight=False,
+        )
+    except SystemExit:
+        # Process replacement (and test doubles that simulate it) must not be
+        # swallowed by the fail-soft handler below.
+        raise
+    except Exception:
+        logger.warning("Startup auto-update failed", exc_info=True)
+        console.print(
+            "[bold yellow]Warning:[/bold yellow] Auto-update failed before startup; "
+            "continuing with the installed version."
+        )
+
+
 def _resolve_agent_arg(args: argparse.Namespace) -> str:
     """Resolve the final agent identifier from parsed CLI args.
 
@@ -2491,6 +2614,7 @@ def cli_main() -> None:
                 sys.exit(130)
             sys.exit(exit_code)
         else:
+            _run_startup_auto_update(console)
             # Resolve recent-agent fallback only for actual session launches.
             assistant_id = _resolve_agent_arg(args)
             # Interactive mode - handle thread resume

{deepagents_code-0.1.10 → deepagents_code-0.1.11}/deepagents_code/update_check.py

@@ -158,6 +158,49 @@ def _latest_from_releases(
     return best_str
 
 
+def get_cached_update_available() -> tuple[bool, str | None]:
+    """Check for updates using only a fresh local cache entry.
+
+    This is the startup fast path: it never contacts PyPI. Stale, missing,
+    corrupt, or unparsable cache data is treated as "no cached update answer" so
+    callers can launch immediately and let a background update check refresh the
+    cache later.
+
+    Returns:
+        A `(available, latest)` tuple. `latest` is `None` when the cache cannot
+            provide a fresh answer.
+    """
+    try:
+        installed = _parse_version(__version__)
+    except InvalidVersion:
+        logger.warning(
+            "Installed version %r is not PEP 440 compliant; "
+            "cache-only update checks disabled for this install",
+            __version__,
+        )
+        return False, None
+
+    cache_key = "version_prerelease" if installed.is_prerelease else "version"
+    try:
+        if not CACHE_FILE.exists():
+            return False, None
+        data = json.loads(CACHE_FILE.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            return False, None
+        checked_at = data.get("checked_at")
+        if not isinstance(checked_at, (int, float)):
+            return False, None
+        if time.time() - checked_at >= CACHE_TTL:
+            return False, None
+        value = data.get(cache_key)
+        if not isinstance(value, str):
+            return False, None
+        return _parse_version(value) > installed, value
+    except (OSError, json.JSONDecodeError, TypeError, InvalidVersion):
+        logger.debug("Failed to read cache-only update answer", exc_info=True)
+        return False, None
+
+
 def get_latest_version(
     *,
     bypass_cache: bool = False,

{deepagents_code-0.1.10 → deepagents_code-0.1.11}/deepagents_code/widgets/auth.py

@@ -35,19 +35,18 @@ if TYPE_CHECKING:
     from textual.events import Click
 
 from deepagents_code import auth_store, theme
+from deepagents_code.auth_display import format_auth_badge
 from deepagents_code.config import get_glyphs, is_ascii_mode
 from deepagents_code.model_config import (
     PROVIDER_API_KEY_ENV,
     PROVIDERS_DOCS_URL as _PROVIDERS_DOCS_URL,
     ModelConfig,
-    ProviderAuthSource,
     clear_caches,
     get_available_models,
     get_base_url_env_var,
     get_credential_env_var,
     get_default_base_url_env,
     get_provider_auth_status,
-    resolved_env_var_name,
 )
 from deepagents_code.widgets._links import open_style_link
 
@@ -671,20 +670,7 @@ class AuthManagerScreen(ModalScreen[None]):
             A composed `Content` with the provider name and a status badge.
         """
         status = get_provider_auth_status(provider)
-        env_var = status.env_var or get_credential_env_var(provider) or ""
-        if status.source is ProviderAuthSource.STORED:
-            badge = Content.styled("[stored]", "bold $success")
-        elif status.source is ProviderAuthSource.ENV:
-            if env_var:
-                badge = Content.assemble(
-                    ("[env: ", "$text-muted"),
-                    Content.styled(resolved_env_var_name(env_var), "$text-muted"),
-                    ("]", "$text-muted"),
-                )
-            else:
-                badge = Content.styled("[env]", "$text-muted")
-        else:
-            badge = Content.styled("[missing]", "bold $warning")
+        badge = format_auth_badge(status)
         return Content.assemble(
             Content.from_markup("$provider", provider=provider),
             "  ",