dreadnode 2.0.40__tar.gz → 2.0.41__tar.gz

{dreadnode-2.0.40 → dreadnode-2.0.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dreadnode
-Version: 2.0.40
+Version: 2.0.41
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io

{dreadnode-2.0.40 → dreadnode-2.0.41}/dreadnode/agents/agent.py

@@ -85,51 +85,27 @@ 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.
+def _is_retry_safe_api_error(error: BaseException) -> bool:
+    """Return whether an LLM API failure is safe to send again.
 
-    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.
+    Only explicit 429 admission failures are retryable. Timeouts, connection
+    failures, interrupted streams, and 5xx responses are ambiguous because the
+    provider may still be working on the original request.
     """
     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):
+        rate_limit_cls = getattr(_litellm_exc, "RateLimitError", None)
+        if (
+            rate_limit_cls is not None
+            and isinstance(error, rate_limit_cls)
+            and getattr(error, "status_code", None) == 429
+        ):
             # OpenAI returns 429 with code "insufficient_quota" when the
             # account is out of credits — a permanent billing condition,
             # not a rate limit. litellm packs the provider body into the
             # message verbatim, so substring-match to exclude.
-            rate_limit_cls = getattr(_litellm_exc, "RateLimitError", None)
-            return not (
-                rate_limit_cls is not None
-                and isinstance(error, rate_limit_cls)
-                and "insufficient_quota" in str(error)
-            )
+            return "insufficient_quota" not in str(error)
     return False
 
 
@@ -228,9 +204,9 @@ class Agent(Executor[AgentEvent, Trajectory]):
     generate_params_extra: dict[str, t.Any] = Config(default_factory=dict)
     """Extra parameters merged into GenerateParams for every generation (e.g. thinking config)."""
     backoff_max_tries: int = Config(default=8, ge=0)
-    """Maximum retries on transient LLM API errors per step. ``0`` disables retry."""
+    """Maximum retries on retry-safe LLM admission failures 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."""
+    """Maximum total seconds to spend on retry-safe LLM attempts 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)
@@ -586,10 +562,10 @@ class Agent(Executor[AgentEvent, Trajectory]):
         tries: int,
         start_time: float,
     ) -> float | None:
-        """Compute a retry sleep for a transient LLM API error.
+        """Compute a retry sleep for a retry-safe LLM admission failure.
 
         Returns the sleep duration in seconds if the caller should retry, or
-        ``None`` if the error is not transient, tries are exhausted, or the
+        ``None`` if the error is not retry-safe, 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
@@ -598,7 +574,7 @@ class Agent(Executor[AgentEvent, Trajectory]):
         if self.backoff_max_tries <= 0:
             return None
 
-        if not _is_transient_api_error(error):
+        if not _is_retry_safe_api_error(error):
             return None
 
         if tries >= self.backoff_max_tries:
@@ -961,15 +937,13 @@ class Agent(Executor[AgentEvent, Trajectory]):
                     async for event in self._dispatch(gen_start):
                         yield event
 
+                    backoff_started = time.monotonic()
                     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.
+                    # In-place retry-safe backoff — only explicit 429 admission
+                    # failures are sent again. Ambiguous transport and provider
+                    # failures may still have active work, so they terminate.
                     backoff_tries = 0
-                    backoff_started = time.monotonic()
                     while step_chat.failed and step_chat.error:
                         wait = self._try_backoff(
                             step_chat.error,

{dreadnode-2.0.40 → dreadnode-2.0.41}/dreadnode/agents/trajectory.py

@@ -279,6 +279,31 @@ def trajectory_to_openai_format(trajectory: Trajectory) -> list[dict[str, t.Any]
     return messages
 
 
+_USAGE_INPUT_FIELDS = (
+    "input_tokens",
+    "cache_read_input_tokens",
+    "cache_creation_input_tokens",
+)
+
+
+def _usage_from_dict(data: dict[str, t.Any]) -> Usage | None:
+    """Build a :class:`Usage` from a persisted per-message usage block.
+
+    Returns ``None`` for an empty block so callers fall back to a plain
+    ``AgentStep``. ``total_tokens`` is derived the same way
+    ``_platform_usage_totals`` does (input + cache buckets + output), since
+    the persisted block stores the buckets rather than the total.
+    """
+    fields = {k: v for k, v in data.items() if v is not None}
+    if not fields:
+        return None
+    if "total_tokens" not in fields:
+        fields["total_tokens"] = sum(
+            int(fields.get(name, 0) or 0) for name in (*_USAGE_INPUT_FIELDS, "output_tokens")
+        )
+    return Usage(**fields)
+
+
 def trajectory_from_openai_format(
     messages: list[dict[str, t.Any]],
     message_class: type | None = None,
@@ -324,9 +349,22 @@ def trajectory_from_openai_format(
         message = message_class(**kwargs)
         current_messages.append(message)
 
-        # Create a step when we see an assistant message (the natural boundary)
+        # Create a step when we see an assistant message (the natural boundary).
+        # When the source message carries a ``usage`` block, emit a
+        # ``GenerationStep`` so downstream token / cost roll-ups (see
+        # ``SessionRuntime._trajectory_usage_rollup``, which filters on
+        # ``GenerationStep``) survive a rebuild from message dicts — this is
+        # what keeps the cost footer populated across ``dn --resume``
+        # (ENG-7589). Plain ``AgentStep`` remains the fallback so every other
+        # caller (rewind, compaction, rollouts, judge CLI) is unaffected.
         if msg.get("role") == "assistant":
-            step = AgentStep(step=step_num, messages=list(current_messages))
+            raw_usage = msg.get("usage")
+            usage = _usage_from_dict(raw_usage) if isinstance(raw_usage, dict) else None
+            step: AgentStep = (
+                GenerationStep(step=step_num, messages=list(current_messages), usage=usage)
+                if usage is not None
+                else AgentStep(step=step_num, messages=list(current_messages))
+            )
             trajectory.add_event(step)
             current_messages = []
             step_num += 1

{dreadnode-2.0.40 → dreadnode-2.0.41}/dreadnode/app/api/client.py

@@ -56,6 +56,13 @@ _TRANSPORT_ERRORS = (
     httpx.ConnectTimeout,
 )
 
+# Sandbox provisioning runs synchronously inside the start request, so it
+# must outlast a cold start (image pull + service readiness) rather than the
+# 30s default every other call uses. Sits below the ALB's 300s idle timeout
+# (platform/pulumi/alb.py) so a stuck provision surfaces as a client-side
+# timeout we can report, not a connection the edge drops out from under us.
+RUNTIME_PROVISION_TIMEOUT_SECONDS = 240.0
+
 
 class AuthenticationError(RuntimeError):
     """Raised when the platform returns HTTP 401."""
@@ -1863,15 +1870,23 @@ class ApiClient:
         *,
         state: str | list[str] | None = None,
         project_id: str | None = None,
+        owner: str | None = None,
         limit: int = 50,
         cursor: str | None = None,
     ) -> dict[str, t.Any]:
-        """GET /org/{org}/ws/{workspace}/runtimes - List interactive runtimes."""
+        """GET /org/{org}/ws/{workspace}/runtimes - List interactive runtimes.
+
+        Pass ``owner="me"`` to restrict the listing to runtimes the caller owns
+        (RT-OWN-021). Omitted, the listing covers the whole workspace
+        (RT-OWN-020).
+        """
         params: dict[str, t.Any] = {"limit": limit}
         if state is not None:
             params["state"] = ",".join(state) if isinstance(state, list) else state
         if project_id is not None:
             params["project_id"] = project_id
+        if owner is not None:
+            params["owner"] = owner
         if cursor is not None:
             params["cursor"] = cursor
         response = self.request(
@@ -1999,35 +2014,21 @@ class ApiClient:
         secret_ids: list[str] | None = None,
         requested_runtime_limit_seconds: int | None = None,
     ) -> dict[str, t.Any]:
-        """POST /org/{org}/ws/{workspace}/runtimes/{runtime_id}/start - Start or resume a runtime."""
-        json_data: dict[str, t.Any] | None = None
+        """Start a runtime and return its credential.
+
+        RT-AUTH-006: safe to retry. The credential is read, not minted, so a
+        retry returns the same value and disturbs no other client.
+        """
+        json_data: dict[str, t.Any] = {}
         if secret_ids is not None:
-            json_data = {"secret_ids": secret_ids}
+            json_data["secret_ids"] = secret_ids
         if requested_runtime_limit_seconds is not None:
-            if json_data is None:
-                json_data = {}
             json_data["requested_runtime_limit_seconds"] = requested_runtime_limit_seconds
         response = self.request(
             "POST",
             f"/org/{org}/ws/{workspace}/runtimes/{runtime_id}/start",
             json_data=json_data,
-        )
-        return t.cast("dict[str, t.Any]", response.json())
-
-    def reconnect_runtime(
-        self,
-        org: str,
-        workspace: str,
-        runtime_id: str,
-        *,
-        secret_ids: list[str] | None = None,
-    ) -> dict[str, t.Any]:
-        """POST /org/{org}/ws/{workspace}/runtimes/{runtime_id}/reconnect - Rotate credentials."""
-        json_data = {"secret_ids": secret_ids} if secret_ids is not None else None
-        response = self.request(
-            "POST",
-            f"/org/{org}/ws/{workspace}/runtimes/{runtime_id}/reconnect",
-            json_data=json_data,
+            timeout=RUNTIME_PROVISION_TIMEOUT_SECONDS,
         )
         return t.cast("dict[str, t.Any]", response.json())