dreadnode 2.0.10__tar.gz → 2.0.11__tar.gz

{dreadnode-2.0.10 → dreadnode-2.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 2.0.10
+Version: 2.0.11
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io

{dreadnode-2.0.10 → dreadnode-2.0.11}/dreadnode/agents/agent.py

@@ -1,5 +1,8 @@
 import asyncio
+import contextlib
 import inspect
+import random
+import time
 import typing as t
 from contextlib import AsyncExitStack, asynccontextmanager, suppress
 from copy import deepcopy
@@ -30,6 +33,7 @@ from dreadnode.agents.events import (
     GenerationContent,
     GenerationEnd,
     GenerationError,
+    GenerationRetry,
     GenerationStart,
     GenerationStep,
     ReactStep,
@@ -80,6 +84,45 @@ def _raise_exception(error: BaseException) -> t.NoReturn:
     raise error
 
 
+_TRANSIENT_LITELLM_EXCEPTION_NAMES: tuple[str, ...] = (
+    "RateLimitError",
+    "Timeout",
+    "APIConnectionError",
+    "APIConnectionTimeoutError",
+    "ServiceUnavailableError",
+    "InternalServerError",
+    "BadGatewayError",
+    "APIError",
+)
+
+
+def _is_transient_api_error(error: BaseException) -> bool:
+    """Classify an error as a transient LLM API failure worth retrying.
+
+    Matches an explicit allow-list of ``litellm.exceptions`` classes that
+    represent recoverable conditions: rate limits, timeouts, connection
+    failures, and 5xx responses. Notably **does not** match
+    ``BadRequestError``, ``AuthenticationError``,
+    ``ContextWindowExceededError`` (handled by overflow recovery), or other
+    deterministic client errors.
+
+    The allow-list is walked dynamically because ``litellm.exceptions`` does
+    not expose a single common ancestor for its transient exceptions.
+    Returns ``False`` if ``litellm`` is not importable.
+    """
+    with contextlib.suppress(ImportError):
+        import litellm.exceptions as _litellm_exc
+
+        classes = tuple(
+            cls
+            for name in _TRANSIENT_LITELLM_EXCEPTION_NAMES
+            if (cls := getattr(_litellm_exc, name, None)) is not None
+        )
+        if classes and isinstance(error, classes):
+            return True
+    return False
+
+
 class Agent(Executor[AgentEvent, Trajectory]):
     """
     Agent abstraction for applying tools, event logic, and message state to LLM generation.
@@ -128,6 +171,14 @@ class Agent(Executor[AgentEvent, Trajectory]):
     """Extra parameters merged into GenerateParams for every generation (e.g. thinking config)."""
     working_dir: Path | None = Config(default=None)
     """Working directory used for tool output offloading and other IO."""
+    backoff_max_tries: int = Config(default=8, ge=0)
+    """Maximum retries on transient LLM API errors per step. ``0`` disables retry."""
+    backoff_max_time: float = Config(default=300.0, ge=0)
+    """Maximum total seconds to spend retrying transient LLM API errors per step."""
+    backoff_base_factor: float = Config(default=1.0, ge=0)
+    """Base factor for exponential backoff: wait = base_factor * 2 ** (attempt - 1)."""
+    backoff_jitter: bool = Config(default=True)
+    """Whether to add up to ``backoff_base_factor`` seconds of random jitter to each wait."""
 
     # Private state
     _generator: Generator | None = PrivateAttr(None, init=False)
@@ -381,6 +432,49 @@ class Agent(Executor[AgentEvent, Trajectory]):
 
         raise winning_reaction
 
+    def _try_backoff(
+        self,
+        error: BaseException,
+        *,
+        tries: int,
+        start_time: float,
+    ) -> float | None:
+        """Compute a retry sleep for a transient LLM API error.
+
+        Returns the sleep duration in seconds if the caller should retry, or
+        ``None`` if the error is not transient, tries are exhausted, or the
+        per-step time budget has been spent. Caller owns sleeping and emitting
+        the ``GenerationRetry`` event. Backoff is agent-owned at the error
+        site, mirroring ``_try_overflow_recovery`` — no step is consumed and
+        no hook indirection is involved.
+        """
+        if self.backoff_max_tries <= 0:
+            return None
+
+        if not _is_transient_api_error(error):
+            return None
+
+        if tries >= self.backoff_max_tries:
+            logger.warning("Backoff aborted: max tries ({}) exceeded.", self.backoff_max_tries)
+            return None
+
+        remaining = self.backoff_max_time - (time.monotonic() - start_time)
+        if remaining <= 0:
+            logger.warning("Backoff aborted: max time ({:.2f}s) exceeded.", self.backoff_max_time)
+            return None
+
+        seconds = self.backoff_base_factor * (2**tries)
+        if self.backoff_jitter:
+            seconds += random.uniform(0, self.backoff_base_factor)
+        if seconds > remaining:
+            logger.warning(
+                "Backoff aborted: next sleep ({:.2f}s) would exceed remaining budget ({:.2f}s).",
+                seconds,
+                remaining,
+            )
+            return None
+        return seconds
+
     async def _try_overflow_recovery(
         self,
         error: BaseException,
@@ -628,6 +722,43 @@ class Agent(Executor[AgentEvent, Trajectory]):
 
                     step_chat = await self._generate(messages)
 
+                    # In-place transient-error backoff — rate limits and
+                    # other litellm.APIError failures get retried at the
+                    # error site with exponential backoff. No step budget
+                    # consumed; clients observe GenerationRetry events
+                    # rather than a spurious terminal GenerationError.
+                    backoff_tries = 0
+                    backoff_started = time.monotonic()
+                    while step_chat.failed and step_chat.error:
+                        wait = self._try_backoff(
+                            step_chat.error,
+                            tries=backoff_tries,
+                            start_time=backoff_started,
+                        )
+                        if wait is None:
+                            break
+                        backoff_tries += 1
+                        logger.warning(
+                            "Backing off {:.2f}s (try {}/{})",
+                            wait,
+                            backoff_tries,
+                            self.backoff_max_tries,
+                        )
+                        retry_event = GenerationRetry(
+                            agent_id=self.agent_id,
+                            agent_name=self.name,
+                            step=step_count,
+                            attempt=backoff_tries,
+                            max_attempts=self.backoff_max_tries,
+                            wait_seconds=wait,
+                            error_type=type(step_chat.error).__name__,
+                            error_message=str(step_chat.error),
+                        )
+                        async for event in self._dispatch(retry_event):
+                            yield event
+                        await asyncio.sleep(wait)
+                        step_chat = await self._generate(messages)
+
                     # In-place overflow recovery — at most once per step,
                     # no step budget consumed, preserves step_count for
                     # user_message inclusion in trajectory.

{dreadnode-2.0.10 → dreadnode-2.0.11}/dreadnode/agents/events.py

@@ -311,6 +311,32 @@ class CompactionEvent(AgentEvent):
         }
 
 
+class GenerationRetry(AgentEvent):
+    """Lifecycle event: the agent is about to sleep and retry a failed generation.
+
+    Emitted by the agent loop when a transient LLM API error (rate limit, etc.)
+    is recovered in place via ``Agent._try_backoff``. This is a lifecycle signal
+    only — it does not consume a step or land in the trajectory.
+    """
+
+    step: int
+    attempt: int
+    max_attempts: int
+    wait_seconds: float
+    error_type: str
+    error_message: str
+
+    def _get_data(self) -> dict[str, t.Any]:
+        return {
+            "step": self.step,
+            "attempt": self.attempt,
+            "max_attempts": self.max_attempts,
+            "wait_seconds": self.wait_seconds,
+            "error_type": self.error_type,
+            "error_message": self.error_message,
+        }
+
+
 class AgentStalled(AgentEvent):
     """Event: The agent is stalled and there are no tool calls, or stop condition).
 
@@ -1017,6 +1043,7 @@ EVENT_TYPES: dict[str, type[AgentEvent]] = {
     "GenerationStep": GenerationStep,
     "GenerationContent": GenerationContent,
     "GenerationError": GenerationError,
+    "GenerationRetry": GenerationRetry,
     "ReactStep": ReactStep,
     "UserInputRequired": UserInputRequired,
     "Heartbeat": Heartbeat,

{dreadnode-2.0.10 → dreadnode-2.0.11}/dreadnode/agents/hooks.py

@@ -1,19 +1,15 @@
-"""Core agent hooks: backoff, metrics, and summarization.
+"""Optional agent hooks: tool metrics and conversation summarization.
 
-These hooks are included by default in every agent created by the server.
+These hooks are opt-in — users register them explicitly on an ``Agent`` via
+the ``hooks=`` constructor argument. Transient-error backoff is handled inline
+by the agent loop (see ``Agent._try_backoff``) and is not a hook.
 """
 
-import asyncio
 import contextlib
-import random
-import time
 import typing as t
 from dataclasses import dataclass
 
-from loguru import logger
-
 from dreadnode.agents.events import (
-    AgentError,
     AgentEvent,
     AgentStep,
     ToolEnd,
@@ -28,73 +24,6 @@ if t.TYPE_CHECKING:
     from datetime import datetime
 
 
-# =============================================================================
-# Backoff
-# =============================================================================
-
-
-def _make_backoff_hook(
-    exception_types: tuple[type[Exception], ...],
-    *,
-    max_tries: int = 8,
-    max_time: float = 300.0,
-    base_factor: float = 1.0,
-    jitter: bool = True,
-):
-    """Create a backoff hook for specific exception types."""
-    tries = 0
-    start_time: float | None = None
-    last_step_seen = -1
-
-    @hook(AgentEvent)
-    async def backoff_hook(event: AgentEvent) -> Reaction | None:
-        nonlocal tries, start_time, last_step_seen
-
-        if isinstance(event, AgentStep):
-            if event.step > last_step_seen:
-                tries = 0
-                start_time = None
-                last_step_seen = event.step
-            return None
-
-        if not isinstance(event, AgentError) or not isinstance(event.error, exception_types):
-            return None
-
-        if start_time is None:
-            start_time = time.monotonic()
-
-        if tries >= max_tries:
-            logger.warning(f"Backoff aborted: max tries ({max_tries}) exceeded.")
-            return None
-
-        if (time.monotonic() - start_time) >= max_time:
-            logger.warning(f"Backoff aborted: max time ({max_time:.2f}s) exceeded.")
-            return None
-
-        tries += 1
-        seconds = base_factor * (2 ** (tries - 1))
-        if jitter:
-            seconds += random.uniform(0, base_factor)
-
-        logger.warning(f"Backing off {seconds:.2f}s (try {tries}/{max_tries})")
-        await asyncio.sleep(seconds)
-        return Retry()
-
-    return backoff_hook
-
-
-# Pre-instantiated for common LLM rate limit errors
-backoff_on_ratelimit: Hook | None = None
-try:
-    import litellm.exceptions
-
-    backoff_on_ratelimit = _make_backoff_hook(
-        (litellm.exceptions.RateLimitError, litellm.exceptions.APIError),
-    )
-except ImportError:
-    pass
-
-
 # =============================================================================
 # Tool Metrics
 # =============================================================================

{dreadnode-2.0.10 → dreadnode-2.0.11}/dreadnode/app/cli/evaluation.py

@@ -1181,6 +1181,30 @@ def get_sample(
         console.print()
         console.print(f"{_label('Error')}[red]{error}[/red]")
 
+    # Phase-aware provisioning failure — written by the eval worker when the
+    # env-sandbox / runtime-sandbox phases fail outside of a task-authored
+    # provision script. Surfaces which phase stalled + elapsed, so operators
+    # don't have to open Logfire for every timeout (ENG-6249).
+    provision_failure = dreadnode_meta.get("provision_failure") or {}
+    if provision_failure:
+        console.print()
+        phase_raw = str(provision_failure.get("phase") or "unknown")
+        phase_label = {
+            "env_sandbox": "env sandbox",
+            "provision_script": "provision script",
+            "runtime_sandbox": "runtime sandbox",
+        }.get(phase_raw, phase_raw)
+        elapsed_ms = provision_failure.get("elapsed_ms") or 0
+        elapsed_s = int(elapsed_ms) // 1000
+        timed_out = bool(provision_failure.get("timed_out"))
+        verb = "timed out provisioning" if timed_out else "failed to provision"
+        console.print(f"{_label('Provisioning')}[red]{verb} {phase_label} after {elapsed_s}s[/red]")
+        if not timed_out:
+            cause_type = provision_failure.get("cause_type") or ""
+            cause_message = provision_failure.get("cause_message") or ""
+            if cause_type or cause_message:
+                console.print(f"{_label('Cause')}[dim]{cause_type}: {cause_message}[/dim]")
+
     # Verification result
     result = payload.get("result_json")
     if result:

{dreadnode-2.0.10 → dreadnode-2.0.11}/dreadnode/app/cli/shared.py

@@ -54,7 +54,7 @@ def print_link(profile_url: str, path: str, **query: str) -> None:
     qs = f"?{urlencode(query)}" if query else ""
     url = f"{root}/{path.lstrip('/')}{qs}"
     console.print()
-    console.print(f"  [dim]→[/dim] [u][link={url}]View on web[/link][/u]")
+    console.print(f"  [dim]→[/dim] View on web: [u][link={url}]{url}[/link][/u]")
 
 
 # ---------------------------------------------------------------------------

{dreadnode-2.0.10 → dreadnode-2.0.11}/dreadnode/app/tui/app.py

@@ -279,7 +279,6 @@ class DreadnodeTextualApp(App[None]):
         Binding("ctrl+e", "open_evaluations", "Evals", show=False),
         Binding("f5", "open_console", "Console", show=False),
         Binding("ctrl+a", "select_agent", "Agent", show=False),
-        Binding("f9", "run_update", "Update", show=False),
         Binding("ctrl+k", "select_model", "Model", show=False),
         Binding("ctrl+shift+k", "cycle_effort", "Effort", show=False),
         Binding("ctrl+n", "new_session", "New", show=False),
@@ -1647,7 +1646,9 @@ class DreadnodeTextualApp(App[None]):
 
         resolved_url = server_url or self._server_url
         update_banner = (
-            f"Update available: v{VERSION} \u2192 v{self.update_available} \u2014 press F9 to update now, or /update after login"
+            "Update available: "
+            f"v{VERSION} \u2192 v{self.update_available} \u2014 "
+            "press U to update now, or /update after login"
             if self.update_available
             else None
         )
@@ -1755,7 +1756,11 @@ class DreadnodeTextualApp(App[None]):
 
             screen = self.screen
             if isinstance(screen, AuthModal):
-                banner = f"Update available: v{VERSION} \u2192 v{info.latest} \u2014 press F9 to update now, or /update after login"
+                banner = (
+                    "Update available: "
+                    f"v{VERSION} \u2192 v{info.latest} \u2014 "
+                    "press U to update now, or /update after login"
+                )
                 screen.query_one("#auth-update-banner", Static).update(f"[bold yellow]{banner}[/]")
         except Exception:
             logger.opt(exception=True).debug("Failed to update auth modal banner")
@@ -2880,6 +2885,24 @@ class DreadnodeTextualApp(App[None]):
                 )
             return
 
+        if event_type == "generation_retry":
+            data = (normalized.raw or {}).get("data", {})
+            attempt = data.get("attempt", 0)
+            max_attempts = data.get("max_attempts", 0)
+            wait_seconds = float(data.get("wait_seconds", 0.0) or 0.0)
+            err_type = normalized.error_type or "error"
+            err_msg = normalized.error_text or ""
+            detail = f": {err_msg}" if err_msg else ""
+            label = (
+                f"{err_type} — retrying in {wait_seconds:.1f}s "
+                f"(attempt {attempt}/{max_attempts}){detail}"
+            )
+            self._append_transcript(
+                TranscriptEntry(kind="system", title="retry", body=label),
+                session_id,
+            )
+            return
+
         if event_type == "agent_stalled":
             logger.warning("Agent stalled: {}", normalized.error_text)
             self._append_transcript(

{dreadnode-2.0.10 → dreadnode-2.0.11}/dreadnode/app/tui/event_contract.py

@@ -241,6 +241,15 @@ def normalize_event(raw: dict[str, t.Any], session_id: str) -> NormalizedEvent:
             prompt_text=_as_str(payload.get("compaction_status")),
             **base,
         )
+    elif event_type == "generationretry":
+        error_type = _as_str(payload.get("error_type"))
+        error_message = _as_str(payload.get("error_message"))
+        normalized = NormalizedEvent(
+            type="generation_retry",
+            error_type=error_type,
+            error_text=error_message,
+            **base,
+        )
     elif event_type == "agentstalled":
         normalized = NormalizedEvent(
             type="agent_stalled",

{dreadnode-2.0.10 → dreadnode-2.0.11}/dreadnode/app/tui/screens/auth.py

@@ -68,6 +68,7 @@ class AuthModal(ModalScreen[Profile | None]):
     BINDINGS: t.ClassVar[list[Binding]] = [
         Binding("escape", "escape", "Back / Cancel", show=False, priority=True),
         Binding("ctrl+c", "cancel", "Cancel", show=False),
+        Binding("u", "run_update", "Update", show=False),
         Binding("up", "move_selection(-1)", "Up", show=False),
         Binding("down", "move_selection(1)", "Down", show=False),
         Binding("enter", "confirm", "Confirm", show=False),
@@ -165,6 +166,11 @@ class AuthModal(ModalScreen[Profile | None]):
         self._cancel_auth_workers()
         self.dismiss(None)
 
+    def action_run_update(self) -> None:
+        handler = getattr(self.app, "action_run_update", None)
+        if callable(handler):
+            handler()
+
     def action_escape(self) -> None:
         if self._active_view == "method":
             self.action_cancel()

{dreadnode-2.0.10 → dreadnode-2.0.11}/dreadnode/app/tui/screens/runtimes.py

@@ -292,6 +292,12 @@ class RuntimeScreen(DreadnodeScreen):
         self._current_actions: list[tuple[str, str]] = []
         self._logs_content: str | None = None
 
+        # In-flight action tracking — blocks double-clicks and drives the
+        # "Starting..." active state in the detail view. Mirrors the
+        # pending-action pattern in capabilities.py.
+        self._pending_action_runtime_id: str | None = None
+        self._pending_action_label: str | None = None
+
     # ── Connected runtime helpers ────────────────────────────────────────
 
     @property
@@ -484,7 +490,7 @@ class RuntimeScreen(DreadnodeScreen):
 
     def _quick_start(self) -> None:
         """Start directly from list — skip detail view for idle runtimes."""
-        if self._is_app_busy():
+        if self._is_app_busy() or self._is_action_pending():
             return
         selected = self._selected_list_runtime()
         if not selected:
@@ -694,6 +700,10 @@ class RuntimeScreen(DreadnodeScreen):
             is_connected=is_connected,
             is_any_remote=self._is_any_remote,
         )
+        # While an action is in flight for this runtime, replace the action
+        # list with a single disabled noop showing progress ("Starting...").
+        if runtime_id == self._pending_action_runtime_id and self._pending_action_label:
+            actions = [("noop", self._pending_action_label)]
         self._current_actions = actions
 
         for i, (action_id, label) in enumerate(actions):
@@ -701,7 +711,9 @@ class RuntimeScreen(DreadnodeScreen):
                 text.append(" ❯ ", style=f"bold {ACCENT}")
             else:
                 text.append("   ")
-            if action_id in ("reset",):
+            if action_id == "noop":
+                text.append(f"{label}\n", style=FG_FAINTEST)
+            elif action_id in ("reset",):
                 text.append(f"{label}\n", style=ERROR)
             elif action_id in ("connect", "start", "resume"):
                 text.append(f"{label}\n", style=INFO)
@@ -889,7 +901,9 @@ class RuntimeScreen(DreadnodeScreen):
     # ── Action execution ─────────────────────────────────────────────────
 
     def _execute_action(self, action_id: str) -> None:
-        if self._is_app_busy():
+        if action_id == "noop":
+            return
+        if self._is_app_busy() or self._is_action_pending():
             return
         runtime = self._selected_runtime
         if not runtime:
@@ -922,20 +936,55 @@ class RuntimeScreen(DreadnodeScreen):
             return True
         return False
 
+    def _is_action_pending(self) -> bool:
+        """True if a runtime action is in flight — blocks new actions."""
+        if self._pending_action_runtime_id is not None:
+            self.notify("Action already in progress", title="Runtimes", severity="warning")
+            return True
+        return False
+
+    def _show_action_notice(self, runtime_id: str, verb: str) -> None:
+        """Mark a runtime action as in flight. Re-renders the detail view
+        so the action list shows a disabled `{verb}...` entry."""
+        self._pending_action_runtime_id = runtime_id
+        self._pending_action_label = f"{verb}..."
+        if self.is_mounted:
+            self._render_current_view()
+
+    def _clear_pending_action(self, runtime_id: str | None = None) -> None:
+        """Clear the pending action marker. When ``runtime_id`` is provided
+        and doesn't match the tracked id, this is a no-op — avoids one
+        worker clearing another's pending state."""
+        if (
+            runtime_id is not None
+            and self._pending_action_runtime_id is not None
+            and self._pending_action_runtime_id != runtime_id
+        ):
+            return
+        had_pending = self._pending_action_runtime_id is not None
+        self._pending_action_runtime_id = None
+        self._pending_action_label = None
+        if had_pending and self.is_mounted:
+            self._render_current_view()
+
     # ── Runtime actions ──────────────────────────────────────────────────
 
-    @work(exclusive=True, group="runtime-action")
+    @work(group="runtime-action")
     async def _do_pause(self, runtime_id: str) -> None:
+        self._show_action_notice(runtime_id, "Pausing")
         self.notify(f"Pausing {runtime_id[:8]}…", title="Runtimes", severity="warning")
         try:
             await asyncio.to_thread(self._api.pause_runtime, self._org, self._workspace, runtime_id)
             self.notify(f"Paused {runtime_id[:8]}", title="Runtimes", severity="information")
         except Exception as exc:
             self.notify(f"Pause failed: {exc}", title="Runtimes", severity="error")
+        finally:
+            self._clear_pending_action(runtime_id)
         self._load_data()
 
-    @work(exclusive=True, group="runtime-action")
+    @work(group="runtime-action")
     async def _do_resume(self, runtime_id: str) -> None:
+        self._show_action_notice(runtime_id, "Resuming")
         self.notify(f"Resuming {runtime_id[:8]}…", title="Runtimes", severity="information")
         try:
             await asyncio.to_thread(
@@ -944,10 +993,13 @@ class RuntimeScreen(DreadnodeScreen):
             self.notify(f"Resumed {runtime_id[:8]}", title="Runtimes", severity="information")
         except Exception as exc:
             self.notify(f"Resume failed: {exc}", title="Runtimes", severity="error")
+        finally:
+            self._clear_pending_action(runtime_id)
         self._load_data()
 
-    @work(exclusive=True, group="runtime-action")
+    @work(group="runtime-action")
     async def _do_reset(self, runtime_id: str) -> None:
+        self._show_action_notice(runtime_id, "Resetting")
         self.notify(f"Resetting {runtime_id[:8]}…", title="Runtimes", severity="warning")
         try:
             if (
@@ -964,10 +1016,13 @@ class RuntimeScreen(DreadnodeScreen):
             self.notify(f"Reset {runtime_id[:8]}", title="Runtimes", severity="information")
         except Exception as exc:
             self.notify(f"Reset failed: {exc}", title="Runtimes", severity="error")
+        finally:
+            self._clear_pending_action(runtime_id)
         self._load_data()
 
-    @work(exclusive=True, group="runtime-action")
+    @work(group="runtime-action")
     async def _do_keepalive(self, runtime_id: str) -> None:
+        self._show_action_notice(runtime_id, "Extending")
         self.notify(f"Extending {runtime_id[:8]}…", title="Runtimes", severity="information")
         try:
             await asyncio.to_thread(
@@ -984,10 +1039,22 @@ class RuntimeScreen(DreadnodeScreen):
             )
         except Exception as exc:
             self.notify(f"Keepalive failed: {exc}", title="Runtimes", severity="error")
+        finally:
+            self._clear_pending_action(runtime_id)
         self._load_data()
 
     def _cache_start_result(self, runtime_id: str, result: dict[str, t.Any]) -> bool:
-        """Cache connection info from a start_runtime response. Returns True if cached."""
+        """Cache connection info from a start_runtime response. Returns True if cached.
+
+        The server only returns ``sandbox_token`` on the request that actually
+        provisions the sandbox. Subsequent /start calls for a still-live
+        sandbox return ``sandbox_token=None`` (the plaintext token is never
+        persisted). We must NOT overwrite the cache in that case — doing so
+        blows away a valid token from our original successful start and
+        leaves us unable to reconnect. If no token is returned, leave the
+        cache alone; ``_do_connect`` handles staleness separately by
+        comparing ``provider_sandbox_id``.
+        """
         from dreadnode.app.tui.runtime_cache import RuntimeTokenCache
 
         sandbox_token = result.get("sandbox_token")
@@ -1003,18 +1070,20 @@ class RuntimeScreen(DreadnodeScreen):
             provider_sandbox_id or "null",
         )
 
-        if sandbox_url and provider_sandbox_id:
-            RuntimeTokenCache().put(
-                runtime_id,
-                sandbox_url=sandbox_url,
-                token=sandbox_token or "",
-                provider_sandbox_id=provider_sandbox_id,
-            )
-            return True
-        return False
+        if not sandbox_token or not sandbox_url or not provider_sandbox_id:
+            return False
 
-    @work(exclusive=True, group="runtime-action")
+        RuntimeTokenCache().put(
+            runtime_id,
+            sandbox_url=sandbox_url,
+            token=sandbox_token,
+            provider_sandbox_id=provider_sandbox_id,
+        )
+        return True
+
+    @work(group="runtime-action")
     async def _do_start(self, runtime_id: str) -> None:
+        self._show_action_notice(runtime_id, "Starting")
         self.notify(f"Starting {runtime_id[:8]}…", title="Runtimes", severity="information")
         try:
             result = await asyncio.to_thread(
@@ -1040,6 +1109,8 @@ class RuntimeScreen(DreadnodeScreen):
         except Exception as exc:
             logger.warning("start_runtime failed for {}: {}", runtime_id[:8], exc)
             self.notify(f"Start failed: {exc}", title="Runtimes", severity="error")
+        finally:
+            self._clear_pending_action(runtime_id)
         self._load_data()
 
     @work(exclusive=True, group="runtime-action")

{dreadnode-2.0.10 → dreadnode-2.0.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dreadnode"
-version = "2.0.10"
+version = "2.0.11"
 description = "Dreadnode SDK"
 authors = [{ name = "Dreadnode Team", email = "support@dreadnode.io" }]
 readme = "README.md"