dreadnode 2.0.12__tar.gz → 2.0.13__tar.gz

{dreadnode-2.0.12 → dreadnode-2.0.13}/PKG-INFO

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

{dreadnode-2.0.12 → dreadnode-2.0.13}/dreadnode/app/client/interactive.py

@@ -363,10 +363,6 @@ class _RuntimeInteractiveTransport:
         http_transport = self._client._http_client._transport
         if isinstance(http_transport, StreamingASGITransport):
             return await http_transport.websocket_connect(url=interactive_url, headers=headers)
-        if self._client._http_client._transport is not None:
-            raise RuntimeError(
-                "Interactive websocket transport is unavailable with injected HTTP transport"
-            )
 
         from websockets.asyncio.client import connect
 

{dreadnode-2.0.12 → dreadnode-2.0.13}/dreadnode/app/client/managed_client.py

@@ -74,6 +74,13 @@ class ManagedRuntimeClient(RuntimeClient):
         self._capability_flag_overrides = capability_flag_overrides
         self._system_prompt_append = system_prompt_append
         self._lifecycle_ctx: t.Any = None
+        # Serialize concurrent start() callers so the slow in-process boot
+        # (capability scan + MCP start + litellm warmup) runs once. The
+        # event lets passive consumers (e.g. the TUI notify subscriber)
+        # wait for the runtime to come up instead of racing start() and
+        # kicking off a second boot with empty credentials.
+        self._start_lock = asyncio.Lock()
+        self._started_event = asyncio.Event()
 
     # ── Platform profile ──────────────────────────────────────────
 
@@ -125,30 +132,46 @@ class ManagedRuntimeClient(RuntimeClient):
         if self._started:
             return
 
-        if self._in_process:
-            logger.info("Server start | mode=in-process | url={}", self.server_url)
-            await self._start_in_process()
-            self._started = True
-            return
+        async with self._start_lock:
+            if self._started:
+                return
 
-        if await self._is_healthy():
-            logger.info("Server start | mode=external | url={}", self.server_url)
-            self._started = True
-            return
+            if self._in_process:
+                logger.info("Server start | mode=in-process | url={}", self.server_url)
+                await self._start_in_process()
+                self._mark_started()
+                return
+
+            if await self._is_healthy():
+                logger.info("Server start | mode=external | url={}", self.server_url)
+                self._mark_started()
+                return
 
-        if not self.auto_start:
-            logger.error("Server unreachable | url={} | auto_start=false", self.server_url)
-            raise RuntimeError(
-                "Could not connect to Dreadnode runtime server at "
-                f"{self.server_url}. The --server flag overrides the local runtime "
-                "endpoint, not the platform API. Omit --server to auto-start the local "
-                "runtime, and use /login --server <url> to set the platform API."
-            )
-
-        logger.info("Server start | mode=spawned | url={}", self.server_url)
-        self._spawn_local_server()
-        await self._wait_until_healthy()
+            if not self.auto_start:
+                logger.error("Server unreachable | url={} | auto_start=false", self.server_url)
+                raise RuntimeError(
+                    "Could not connect to Dreadnode runtime server at "
+                    f"{self.server_url}. The --server flag overrides the local runtime "
+                    "endpoint, not the platform API. Omit --server to auto-start the local "
+                    "runtime, and use /login --server <url> to set the platform API."
+                )
+
+            logger.info("Server start | mode=spawned | url={}", self.server_url)
+            self._spawn_local_server()
+            await self._wait_until_healthy()
+            self._mark_started()
+
+    async def wait_until_started(self) -> None:
+        """Block until ``start()`` has successfully brought the server up."""
+        await self._started_event.wait()
+
+    def _mark_started(self) -> None:
         self._started = True
+        self._started_event.set()
+
+    def _mark_stopped(self) -> None:
+        self._started = False
+        self._started_event.clear()
 
     async def close(self) -> None:
         """Close resources and shut down any managed server."""
@@ -215,15 +238,15 @@ class ManagedRuntimeClient(RuntimeClient):
 
             reset_app_state()
 
-            self._started = False
+            self._mark_stopped()
             await self._start_in_process()
-            self._started = True
+            self._mark_started()
             return
 
         await self.close()
         self._owned_process = None
         self._owned_log_file = None
-        self._started = False
+        self._mark_stopped()
         self._http_client = httpx.AsyncClient(
             base_url=self.server_url,
             timeout=None,  # noqa: S113 - long-lived local runtime client intentionally disables global timeout

{dreadnode-2.0.12 → dreadnode-2.0.13}/dreadnode/app/client/runtime_client.py

@@ -285,11 +285,17 @@ class RuntimeClient:
 
     # ── Session management ────────────────────────────────────────
 
-    async def list_sessions(self) -> list[models.SessionInfo]:
-        """List active sessions from the connected server."""
-        logger.debug("Listing sessions")
+    async def list_sessions(self, *, include_platform: bool = False) -> list[models.SessionInfo]:
+        """List active sessions from the connected server.
+
+        By default only in-process sessions are returned. Pass
+        ``include_platform=True`` when the caller needs the full history
+        (session picker); it adds a platform API round-trip.
+        """
+        logger.debug("Listing sessions | include_platform={}", include_platform)
         await self.start()
-        response = await self._http_client.get("/api/sessions")
+        params = {"include_platform": "true"} if include_platform else None
+        response = await self._http_client.get("/api/sessions", params=params)
         response.raise_for_status()
         sessions = [models.SessionInfo.from_dict(item) for item in response.json()]
         logger.debug("Listed sessions | count={}", len(sessions))

{dreadnode-2.0.12 → dreadnode-2.0.13}/dreadnode/app/server/app.py

@@ -728,21 +728,37 @@ class ServerState:
         """List all sessions."""
         return list(self._sessions.values())
 
-    def list_session_infos(self) -> list[SessionInfo]:
-        """List active sessions plus persisted sessions from the API and local store."""
+    def list_session_infos(self, *, include_platform: bool = False) -> list[SessionInfo]:
+        """List active sessions, optionally merged with platform-persisted sessions.
+
+        The platform fetch is a ~500ms round-trip that callers only need
+        when rendering the full history (session picker, ``/sessions``
+        slash command). Boot, runtime swap, and other fast paths skip it
+        and get only the in-process set (plus legacy local store).
+        """
         sessions = {session.session_id: session.to_info() for session in self._sessions.values()}
 
-        # Try API list first. Scoped to the current user via ``user_id`` so
-        # the TUI session view doesn't surface other workspace members'
-        # sessions — the platform endpoint defaults to workspace-wide as
-        # of the workspace-permission-boundary change.
+        # Platform-scoped list — scoped to the current user via ``user_id``
+        # and to this SDK runtime via ``DREADNODE_RUNTIME_ID`` (None on
+        # local, the sandbox id on remote). ``save_session`` tags new rows
+        # with the same env so the filter stays consistent. Without the
+        # runtime scope a local SDK server surfaces sessions from every
+        # runtime the user has connected to, and the TUI swap-back lands
+        # on a stray remote session. Stop-gap until the platform endpoint
+        # gains a first-class runtime_id filter.
+        own_runtime_id = os.environ.get("DREADNODE_RUNTIME_ID", "").strip() or None
         ctx = self._get_api_context()
-        if ctx is not None:
+        if include_platform and ctx is not None:
             api, org, ws, user_id = ctx
             try:
                 data = api.list_sessions(org, ws, page_size=100, user_id=user_id)
                 for s in data.get("sessions", []):
                     sid = s.get("id", "")
+                    session_runtime_id = s.get("runtime_id")
+                    if session_runtime_id is not None:
+                        session_runtime_id = str(session_runtime_id)
+                    if session_runtime_id != own_runtime_id:
+                        continue
                     if sid and sid not in sessions:
                         sessions[sid] = SessionInfo(
                             session_id=sid,
@@ -2216,9 +2232,13 @@ class SessionRuntime:
 
 
 @app.get("/api/sessions", response_model=list[SessionInfo])
-async def list_sessions() -> list[SessionInfo]:
-    """List all active agent sessions."""
-    return get_state().list_session_infos()
+async def list_sessions(include_platform: bool = False) -> list[SessionInfo]:
+    """List active agent sessions.
+
+    Defaults to the in-process set; pass ``include_platform=true`` to
+    merge platform-persisted sessions for this runtime (slower).
+    """
+    return get_state().list_session_infos(include_platform=include_platform)
 
 
 @app.post("/api/sessions", response_model=SessionInfo)

{dreadnode-2.0.12 → dreadnode-2.0.13}/dreadnode/app/tui/app.py

@@ -555,8 +555,8 @@ class _AppProfileRuntime:
     async def refresh_runtime(self) -> None:
         await self._app._capabilities_manager.refresh()
 
-    async def refresh_server_sessions(self) -> None:
-        await self._app._refresh_server_sessions()
+    async def refresh_server_sessions(self, *, include_platform: bool = False) -> None:
+        await self._app._refresh_server_sessions(include_platform=include_platform)
 
     async def refresh_skill_names(self) -> None:
         await self._app._command_dispatcher.refresh_skill_names()
@@ -809,8 +809,8 @@ class _AppSessionsTransport:
     async def fetch_session_messages(self, session_id: str) -> list[dict[str, t.Any]]:
         return await self._app.managed_client.fetch_session_messages(session_id)
 
-    async def list_sessions(self) -> list[SessionInfo]:
-        return await self._app.managed_client.list_sessions()
+    async def list_sessions(self, *, include_platform: bool = False) -> list[SessionInfo]:
+        return await self._app.managed_client.list_sessions(include_platform=include_platform)
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -962,8 +962,8 @@ class _AppCommandActions:
     ) -> None:
         self._app._run_command(coro_fn, *args)
 
-    async def refresh_server_sessions(self) -> None:
-        await self._app._refresh_server_sessions()
+    async def refresh_server_sessions(self, *, include_platform: bool = False) -> None:
+        await self._app._refresh_server_sessions(include_platform=include_platform)
 
     async def apply_runtime_info(
         self,
@@ -2456,8 +2456,8 @@ class DreadnodeTextualApp(App[None]):
         finally:
             self._update_check_done = True
 
-    async def _refresh_server_sessions(self) -> None:
-        await self._sessions_manager.refresh_from_server()
+    async def _refresh_server_sessions(self, *, include_platform: bool = False) -> None:
+        await self._sessions_manager.refresh_from_server(include_platform=include_platform)
 
     @work(exclusive=True, group="session-picker-refresh")
     async def _refresh_sessions_then_open_picker(self) -> None:
@@ -2466,7 +2466,7 @@ class DreadnodeTextualApp(App[None]):
 
         if self._is_screen_open(SessionPickerScreen):
             return
-        await self._sessions_manager.refresh_from_server()
+        await self._sessions_manager.refresh_from_server(include_platform=True)
         self._dismiss_pushed_screens()
         self.push_screen(
             SessionPickerScreen(
@@ -3680,6 +3680,8 @@ class DreadnodeTextualApp(App[None]):
 
         self._update_remote_status()
         self._sync_conversation()
+        if self.active_session_id is not None:
+            self._dismiss_welcome()
 
     async def _on_remote_disconnected(self) -> None:
         """Called after RuntimeConnectionManager.disconnect() succeeds.
@@ -3691,6 +3693,7 @@ class DreadnodeTextualApp(App[None]):
         await self._capabilities_manager.refresh()
         await self._refresh_server_sessions()
         self._update_remote_status()
+        self._sync_conversation()
 
     def _update_remote_status(self) -> None:
         """Update status bar to reflect remote/local connection state."""
@@ -3724,7 +3727,13 @@ class DreadnodeTextualApp(App[None]):
         internally (CAP-WCLI-021); this outer loop only exists to survive
         server-startup races where the first connect attempt fails before
         the local runtime is up.
+
+        Wait for the runtime to be started before calling ``subscribe`` —
+        ``subscribe`` would otherwise call ``start()`` itself and race
+        ``ProfileManager.boot``, booting the in-process server twice
+        (and the first boot with empty platform credentials).
         """
+        await client.wait_until_started()
         backoff = 0.5
         while True:
             try:

{dreadnode-2.0.12 → dreadnode-2.0.13}/dreadnode/app/tui/command_dispatcher.py

@@ -151,7 +151,7 @@ class CommandActions(t.Protocol):
         """Spawn ``coro_fn(*args)`` as a tracked worker with auth-error recovery."""
         ...
 
-    async def refresh_server_sessions(self) -> None: ...
+    async def refresh_server_sessions(self, *, include_platform: bool = False) -> None: ...
 
     async def apply_runtime_info(
         self,
@@ -532,7 +532,7 @@ class CommandDispatcher:
     # ------------------------------------------------------------------
 
     async def list_sessions_command(self) -> None:
-        await self._actions.refresh_server_sessions()
+        await self._actions.refresh_server_sessions(include_platform=True)
         self._actions.write_session_listing()
 
     async def reload_capabilities_command(self) -> None:

{dreadnode-2.0.12 → dreadnode-2.0.13}/dreadnode/app/tui/profile_manager.py

@@ -38,6 +38,7 @@ inside a sub-controller.
 """
 
 import asyncio
+import contextlib
 import time
 import typing as t
 from dataclasses import dataclass
@@ -58,6 +59,22 @@ if t.TYPE_CHECKING:
     from dreadnode.app.tui.update_check import UpdateInfo
 
 
+def _log_background_boot_failure(task: "asyncio.Task[t.Any]") -> None:
+    """Surface exceptions from a detached runtime-boot task.
+
+    When early auth failures cause ``boot()`` to return before awaiting
+    the runtime-boot task, the task keeps running in the background so
+    a subsequent successful auth can reuse it. Without a done-callback,
+    any exception raised by the detached task would be lost at GC time
+    as ``Task exception was never retrieved``.
+    """
+    if task.cancelled():
+        return
+    exc = task.exception()
+    if exc is not None:
+        logger.opt(exception=exc).debug("Background runtime boot failed")
+
+
 # =============================================================================
 # Shared flow state + ports
 # =============================================================================
@@ -157,7 +174,7 @@ class ProfileRuntimePort(t.Protocol):
 
     async def refresh_runtime(self) -> None: ...
 
-    async def refresh_server_sessions(self) -> None: ...
+    async def refresh_server_sessions(self, *, include_platform: bool = False) -> None: ...
 
     async def refresh_skill_names(self) -> None: ...
 
@@ -629,6 +646,18 @@ class BootAndAuthRecoveryController:
 
         org = profile.organization
         workspace = profile.workspace
+
+        # Kick off the local runtime boot now — it only needs the profile's
+        # scalar fields (url/api_key/org/workspace/project), which are already
+        # in memory. Running it concurrently with the remaining platform API
+        # calls (org/workspace validation, identity hydration, user prefs +
+        # LiteLLM key provisioning) collapses the critical path substantially.
+        self._runtime.set_api_context(api, org, workspace)
+        self._runtime.set_platform_profile(profile)
+        runtime_start_t0 = time.monotonic()
+        runtime_boot_task = asyncio.create_task(self._runtime.start_local_runtime())
+        runtime_boot_task.add_done_callback(_log_background_boot_failure)
+
         try:
             t0 = time.monotonic()
             await asyncio.to_thread(api.get_organization, org)
@@ -643,6 +672,8 @@ class BootAndAuthRecoveryController:
             self._invoke_show_auth_modal(
                 reason="Could not verify your account — please sign in again"
             )
+            # Let the runtime boot finish in the background — a subsequent
+            # successful auth will restart it with fresh creds anyway.
             return
 
         if not any(getattr(ws, "key", None) == workspace for ws in workspaces):
@@ -664,12 +695,24 @@ class BootAndAuthRecoveryController:
             logger.opt(exception=True).debug("Boot: identity hydration failed (non-fatal)")
 
         resume_session_id = self._state.resume_session_id()
+        # Platform models + LiteLLM provisioning can overlap with the tail of
+        # the runtime boot and the subsequent runtime refreshes.
+        platform_models_t0 = time.monotonic()
+        platform_models_task = asyncio.create_task(
+            self._models.refresh_platform_models_and_key(api)
+        )
         try:
-            self._runtime.set_api_context(api, org, workspace)
-            self._runtime.set_platform_profile(profile)
-            t0 = time.monotonic()
-            await self._runtime.start_local_runtime()
-            logger.debug("Boot timing | runtime_start={:.0f}ms", (time.monotonic() - t0) * 1000)
+            try:
+                await runtime_boot_task
+            except BaseException:
+                platform_models_task.cancel()
+                with contextlib.suppress(BaseException):
+                    await platform_models_task
+                raise
+            logger.debug(
+                "Boot timing | runtime_start={:.0f}ms",
+                (time.monotonic() - runtime_start_t0) * 1000,
+            )
             t0 = time.monotonic()
             await self._runtime.refresh_runtime()
             logger.debug("Boot timing | refresh_runtime={:.0f}ms", (time.monotonic() - t0) * 1000)
@@ -677,11 +720,10 @@ class BootAndAuthRecoveryController:
             await self._runtime.refresh_server_sessions()
             logger.debug("Boot timing | refresh_sessions={:.0f}ms", (time.monotonic() - t0) * 1000)
             try:
-                t0 = time.monotonic()
-                await self._models.refresh_platform_models_and_key(api)
+                await platform_models_task
                 logger.debug(
                     "Boot timing | platform_models_and_key={:.0f}ms",
-                    (time.monotonic() - t0) * 1000,
+                    (time.monotonic() - platform_models_t0) * 1000,
                 )
             except AuthenticationError:
                 self.handle_authentication_error("Session expired — please sign in again")

{dreadnode-2.0.12 → dreadnode-2.0.13}/dreadnode/app/tui/sessions_manager.py

@@ -453,7 +453,7 @@ class SessionsTransportPort(t.Protocol):
 
     async def fetch_session_messages(self, session_id: str) -> list[dict[str, t.Any]]: ...
 
-    async def list_sessions(self) -> list[SessionInfo]: ...
+    async def list_sessions(self, *, include_platform: bool = False) -> list[SessionInfo]: ...
 
 
 # =============================================================================
@@ -540,7 +540,7 @@ class SessionsManager:
     # Refresh from server (session list hydration)
     # ------------------------------------------------------------------
 
-    async def refresh_from_server(self) -> None:
+    async def refresh_from_server(self, *, include_platform: bool = False) -> None:
         """Pull the session list from the runtime server and reconcile.
 
         Preserves any locally-cached transcript and TUI-only per-session
@@ -550,8 +550,14 @@ class SessionsManager:
         Promotes the resulting first session to active if the previous
         ``active_session_id`` no longer exists. Lazy-loads the active
         session's transcript if the cache is empty.
+
+        ``include_platform`` is forwarded to the runtime server; set it
+        to True only when the caller needs the full persisted history
+        (session picker, ``/sessions`` slash command). Fast paths — boot,
+        runtime swap, auth refresh — leave it False to avoid a ~500ms
+        platform round-trip.
         """
-        session_infos = await self._transport.list_sessions()
+        session_infos = await self._transport.list_sessions(include_platform=include_platform)
         logger.debug("Sessions refresh | count={}", len(session_infos))
         current_model = self._context.current_model()
         refreshed: dict[str, SessionRecord] = {}

{dreadnode-2.0.12 → dreadnode-2.0.13}/pyproject.toml

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