dreadnode 2.0.22__tar.gz → 2.0.23__tar.gz

{dreadnode-2.0.22 → dreadnode-2.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 2.0.22
+Version: 2.0.23
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io
@@ -27,6 +27,7 @@ Requires-Dist: loguru>=0.7.3
 Requires-Dist: markdownify<2.0.0,>=1.1.0
 Requires-Dist: mcp<2.0.0,>=1.25.0
 Requires-Dist: moviepy<3.0.0,>=2.1.2
+Requires-Dist: networkx>=3.6.1
 Requires-Dist: numpy<=2.3.5,>=2.3.0
 Requires-Dist: optuna<5.0.0,>=4.5.0
 Requires-Dist: orjson>=3.11.5

{dreadnode-2.0.22 → dreadnode-2.0.23}/dreadnode/app/api/client.py

@@ -2604,6 +2604,27 @@ class ApiClient:
         )
         return t.cast("dict[str, t.Any]", response.json())
 
+    def rewind_transcript(
+        self,
+        org: str,
+        workspace: str,
+        session_id: str,
+        *,
+        from_seq: int,
+    ) -> dict[str, t.Any]:
+        """POST /org/{org}/ws/{workspace}/sessions/{session_id}/rewind.
+
+        Hard-truncates the transcript at ``from_seq`` (target user-message
+        seq). Returns ``RewindTranscriptResponse`` dict with
+        ``deleted_count``, ``target_seq``, and ``restored_content``.
+        """
+        response = self.request(
+            "POST",
+            f"/org/{org}/ws/{workspace}/sessions/{session_id}/rewind",
+            json_data={"from_seq": from_seq},
+        )
+        return t.cast("dict[str, t.Any]", response.json())
+
     # =========================================================================
     # Worlds
     # =========================================================================

{dreadnode-2.0.22 → dreadnode-2.0.23}/dreadnode/app/cli/airt.py

@@ -64,6 +64,30 @@ def _parse_json_object_option(value: str | None, *, field_name: str) -> dict[str
     return parsed
 
 
+def _resolve_project_id(api, profile, project):
+    """Resolve project name to UUID."""
+    from uuid import UUID
+
+    candidate = project or getattr(profile, "project_key", None)
+    if not candidate:
+        return None
+
+    # Check if already a UUID
+    try:
+        UUID(str(candidate))
+        return str(candidate)  # Already a UUID
+    except ValueError:
+        pass  # Not a UUID, need to resolve
+
+    # Try to resolve project name to UUID
+    try:
+        resolved = api.get_project(profile.org_key, profile.workspace_key, str(candidate))
+        return str(resolved.id)
+    except Exception as e:
+        print(f"[PROJECT DEBUG] Failed to resolve project '{candidate}': {e}")
+        return None
+
+
 _SEVERITY_COLORS = {
     "critical": "red",
     "high": "red",
@@ -1154,9 +1178,9 @@ def run(
         from dreadnode.airt import Assessment
 
         # Configure the SDK using the validated profile
-        from dreadnode.app.main import Dreadnode
+        from dreadnode.app.main import DEFAULT_INSTANCE
 
-        Dreadnode().configure(
+        DEFAULT_INSTANCE.configure(
             server=profile.url,
             api_key=profile.api_key,
             organization=profile.organization,
@@ -1164,6 +1188,16 @@ def run(
             project=profile.project,
         )
 
+        # Resolve project name to UUID
+        # Get project from environment if profile.project is None
+        import os
+
+        env_project = os.getenv("DREADNODE_PROJECT")
+        actual_project = profile.project or env_project
+
+        resolved_project_id = _resolve_project_id(_api, profile, actual_project)
+        final_project_id = resolved_project_id or profile.project_id or actual_project
+
         async with Assessment(
             name=name,
             description=f"CLI attack: {goal}",
@@ -1171,7 +1205,7 @@ def run(
             model=atk_model,
             goal=goal,
             goal_category=goal_category,
-            project_id=profile.project_id or profile.project,
+            project_id=final_project_id,
             attack_defaults={
                 "n_iterations": n_iterations,
                 "early_stopping_score": early_stopping,
@@ -1306,6 +1340,17 @@ def run_suite(
     async def _run_suite() -> list[dict[str, t.Any]]:
         from dreadnode.airt import Assessment
 
+        # Configure the SDK using the validated profile
+        from dreadnode.app.main import DEFAULT_INSTANCE
+
+        DEFAULT_INSTANCE.configure(
+            server=profile.url,
+            api_key=profile.api_key,
+            organization=profile.organization,
+            workspace=profile.workspace,
+            project=profile.project,
+        )
+
         suite_results = []
         for i, goal_cfg in enumerate(goals, 1):
             goal_text = goal_cfg["goal"]
@@ -1316,6 +1361,16 @@ def run_suite(
 
             console.print(f"\n--- Goal {i}/{len(goals)}: {goal_text[:60]}...")
 
+            # Resolve project name to UUID
+            # Get project from environment if profile.project is None
+            import os
+
+            env_project = os.getenv("DREADNODE_PROJECT")
+            actual_project = profile.project or env_project
+
+            resolved_project_id = _resolve_project_id(_api, profile, actual_project)
+            final_project_id = resolved_project_id or profile.project_id or actual_project
+
             async with Assessment(
                 name=f"Suite -- {sub_cat or goal_text[:40]}",
                 description=f"Suite run: {goal_text}",
@@ -1323,7 +1378,7 @@ def run_suite(
                 model=atk_model,
                 goal=goal_text,
                 goal_category=goal_cat,
-                project_id=profile.project_id or profile.project,
+                project_id=final_project_id,
                 attack_defaults={
                     "airt_category": cat,
                     "airt_sub_category": sub_cat,

{dreadnode-2.0.22 → dreadnode-2.0.23}/dreadnode/app/cli/main.py

@@ -36,6 +36,14 @@ from dreadnode.app.model_catalog import resolve_model
 DEBUG = bool(os.getenv("DREADNODE_DEBUG"))
 
 
+def _get_version_safe() -> str:
+    """Get package version safely, falling back to 'dev' if not installed."""
+    try:
+        return importlib.metadata.version("dreadnode")
+    except importlib.metadata.PackageNotFoundError:
+        return "dev"
+
+
 def _new_device_login_api_key_name() -> str:
     return f"dreadnode-{secrets.token_hex(3)}"
 
@@ -60,7 +68,7 @@ def _render_profile_context(profile: t.Any) -> str:
 cli = cyclopts.App(
     name="dreadnode",
     help="Dreadnode CLI — agent development and platform tooling.",
-    version=importlib.metadata.version("dreadnode"),
+    version=_get_version_safe(),
     help_on_error=True,
 )
 cli.register_install_completion_command()

{dreadnode-2.0.22 → dreadnode-2.0.23}/dreadnode/app/client/runtime_client.py

@@ -564,6 +564,42 @@ class RuntimeClient:
         response.raise_for_status()
         return response.json()
 
+    async def fetch_rewind_candidates(self, session_id: str) -> list[dict[str, t.Any]]:
+        """Return user-message rewind targets for the picker.
+
+        Returns an empty list when the runtime is not platform-synced —
+        rewind is platform-only, so there's nothing to surface.
+        """
+        logger.debug("Fetching rewind candidates | session_id={}", session_id[:8])
+        await self.start()
+        response = await self._http_client.get(f"/api/sessions/{session_id}/rewind/candidates")
+        response.raise_for_status()
+        body = response.json()
+        candidates = body.get("candidates") if isinstance(body, dict) else None
+        if not isinstance(candidates, list):
+            return []
+        return [entry for entry in candidates if isinstance(entry, dict)]
+
+    async def rewind_session(self, session_id: str, *, from_seq: int) -> dict[str, t.Any]:
+        """Hard-truncate a session at the target user-message ``seq``.
+
+        Returns ``{status, deleted_count, target_seq, restored_content}``
+        on success. Caller must already have aborted any in-flight turn
+        — the runtime refuses with ``status=skipped`` while busy.
+        """
+        logger.info(
+            "Rewinding session | session_id={} from_seq={}",
+            session_id[:8],
+            from_seq,
+        )
+        await self.start()
+        response = await self._http_client.post(
+            f"/api/sessions/{session_id}/rewind",
+            json={"from_seq": from_seq},
+        )
+        response.raise_for_status()
+        return dict(response.json())
+
     async def fetch_session_messages(self, session_id: str) -> list[dict[str, t.Any]]:
         """Fetch conversation messages for a session."""
         logger.debug("Fetching session messages | session_id={}", session_id[:8])

{dreadnode-2.0.22 → dreadnode-2.0.23}/dreadnode/app/main.py

@@ -451,9 +451,14 @@ class Dreadnode:
 
         if self._api is not None and self._profile is not None and isinstance(project, str):
             try:
+                # Use configured org/workspace if available, otherwise fall back to profile
+                org_key = str(self.organization) if self.organization else self._profile.org_key
+                workspace_key = (
+                    str(self.workspace) if self.workspace else self._profile.workspace_key
+                )
                 resolved_project = self._api.get_project(
-                    self._profile.org_key,
-                    self._profile.workspace_key,
+                    org_key,
+                    workspace_key,
                     project,
                 )
             except RuntimeError:

{dreadnode-2.0.22 → dreadnode-2.0.23}/dreadnode/app/server/app.py

@@ -1980,6 +1980,122 @@ class SessionRuntime:
             "messages_after": messages_after,
         }
 
+    async def rewind_to(self, *, from_seq: int) -> dict[str, t.Any]:
+        """Hard-truncate the session at a target user-message ``seq``.
+
+        Calls the platform rewind endpoint, then re-fetches the truncated
+        transcript and replaces the in-memory trajectory so the next chat
+        turn won't replay the deleted messages as model context.
+
+        Returns a dict with ``status`` (``completed`` | ``skipped`` |
+        ``failed``), and on success ``deleted_count`` / ``target_seq`` /
+        ``restored_content`` echoed straight from the platform response.
+
+        Refuses when the session is busy (an in-flight turn would race
+        with the truncate); the caller is expected to send ``/cancel``
+        first and wait for the abort to settle. Refuses when the session
+        isn't synced to a platform — there's no in-memory-only rewind
+        primitive to fall back to (no marker, no shadow tree).
+        """
+        if self.is_busy:
+            return {"status": "skipped", "reason": "turn_in_progress"}
+
+        ctx = self._get_api_context()
+        if ctx is None:
+            return {"status": "failed", "reason": "no_platform_sync"}
+        api, org, ws = ctx
+
+        try:
+            result = await asyncio.to_thread(
+                api.rewind_transcript,
+                org,
+                ws,
+                self.session_id,
+                from_seq=from_seq,
+            )
+        except Exception as exc:
+            logger.warning(
+                "Rewind failed at platform | session={} from_seq={} error={}",
+                self.session_id[:8],
+                from_seq,
+                exc,
+            )
+            return {"status": "failed", "reason": str(exc)}
+
+        # Re-source the in-memory trajectory from the platform's truncated
+        # transcript. ``restore_messages`` rebuilds via OpenAI-format
+        # conversion, which loses event-type granularity (GenerationStep
+        # vs ToolStep) — that's fine here: rewind is destructive, the
+        # next turn re-derives event detail from the model's response.
+        try:
+            transcript = await asyncio.to_thread(
+                api.get_transcript,
+                org,
+                ws,
+                self.session_id,
+            )
+        except Exception:
+            logger.opt(exception=True).warning(
+                "Rewind succeeded on platform but transcript refetch failed | session={}",
+                self.session_id[:8],
+            )
+            transcript = {"messages": []}
+
+        rebuilt: list[SessionMessage] = []
+        for raw in transcript.get("messages") or []:
+            role = raw.get("role")
+            content = raw.get("content") or ""
+            if role in {"user", "assistant"} and isinstance(content, str):
+                rebuilt.append(SessionMessage(role=role, content=content))
+
+        self.restore_messages(rebuilt, persist=False)
+        self.persistence.persisted_message_count = len(self._trajectory.messages)
+
+        return {
+            "status": "completed",
+            "deleted_count": int(result.get("deleted_count") or 0),
+            "target_seq": int(result.get("target_seq") or from_seq),
+            "restored_content": str(result.get("restored_content") or ""),
+        }
+
+    def list_rewind_candidates(self) -> dict[str, t.Any]:
+        """Return user-message rewind targets for the picker.
+
+        Pulls non-compacted ``role='user'`` rows straight from the
+        platform's transcript so the picker shows the same seqs the
+        rewind endpoint accepts. Sessions without platform sync (offline
+        runtime) return an empty list — there's no rewindable history
+        to surface.
+        """
+        ctx = self._get_api_context()
+        if ctx is None:
+            return {"status": "unavailable", "reason": "no_platform_sync", "candidates": []}
+        api, org, ws = ctx
+
+        try:
+            transcript = api.get_transcript(org, ws, self.session_id)
+        except Exception as exc:
+            logger.opt(exception=True).debug("Failed to load rewind candidates")
+            return {"status": "failed", "reason": str(exc), "candidates": []}
+
+        candidates: list[dict[str, t.Any]] = []
+        for raw in transcript.get("messages") or []:
+            if raw.get("role") != "user":
+                continue
+            if raw.get("compacted_at") is not None:
+                continue
+            content = raw.get("content")
+            if not isinstance(content, str):
+                continue
+            candidates.append(
+                {
+                    "seq": int(raw.get("seq") or 0),
+                    "content": content,
+                    "created_at": raw.get("created_at"),
+                }
+            )
+        return {"status": "ok", "candidates": candidates}
+
     def _compact_transcript_on_api(
         self,
         boundary: int,
@@ -2102,15 +2218,14 @@ class SessionRuntime:
         model: str | None = None,
         persist: bool = True,
     ) -> None:
-        """Seed the session agent trajectory from a simple message list."""
-        from dreadnode.agents.trajectory import trajectory_from_openai_format
+        """Seed the session agent trajectory from a simple message list.
 
-        if not messages:
-            if model is not None:
-                self.model = model
-                if persist:
-                    self._persist_state(update_messages=False)
-            return
+        An empty ``messages`` list resets the trajectory to a fresh empty
+        state — the rewind-to-seq-0 path relies on this to clear the
+        in-memory transcript after the platform truncates everything
+        (`ENG-6776`). Other callers guard against empty input upstream.
+        """
+        from dreadnode.agents.trajectory import trajectory_from_openai_format
 
         if model is not None:
             self.model = model
@@ -3139,6 +3254,36 @@ async def compact_session(session_id: str, body: dict[str, t.Any] | None = None)
     return JSONResponse(content=result)
 
 
+@app.get("/api/sessions/{session_id}/rewind/candidates")
+async def list_rewind_candidates(session_id: str) -> JSONResponse:
+    """Return user-message rewind targets pulled from platform-side transcript.
+
+    The picker uses this rather than the runtime's in-memory trajectory
+    because seqs only exist on the platform side; the in-memory copy
+    does not track them.
+    """
+    session = get_state().get_session(session_id)
+    if session is None:
+        raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
+    return JSONResponse(content=await asyncio.to_thread(session.list_rewind_candidates))
+
+
+@app.post("/api/sessions/{session_id}/rewind")
+async def rewind_session(session_id: str, body: dict[str, t.Any]) -> JSONResponse:
+    """Hard-truncate a session's transcript at a target user-message seq."""
+    session = get_state().get_session(session_id)
+    if session is None:
+        raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
+    raw_seq = body.get("from_seq")
+    if not isinstance(raw_seq, int) or raw_seq < 0:
+        raise HTTPException(
+            status_code=422,
+            detail="from_seq must be a non-negative integer",
+        )
+    result = await session.rewind_to(from_seq=raw_seq)
+    return JSONResponse(content=result)
+
+
 # =============================================================================
 # File & Shell Endpoints
 # =============================================================================
@@ -3771,7 +3916,32 @@ def _populate_registry(instance: t.Any) -> None:
     # 2. Determine host type: sandbox if runtime binding env is set, local otherwise
     host = "sandbox" if os.environ.get("DREADNODE_RUNTIME_ID", "").strip() else "local"
 
-    # 3. Discover with host-exclusive source (CAP-LOAD-014)
+    # 3. Install declared dependencies before discovery so preflight `checks:`
+    # see installed binaries. Failures log loudly but never block load —
+    # `checks:` is the user-visible signal for unmet prerequisites.
+    if host == "sandbox" and workspace_dir is not None:
+        try:
+            from dreadnode.capabilities.install import install_dependencies
+            from dreadnode.capabilities.loader import preload_dependency_specs
+
+            install_specs = preload_dependency_specs(workspace_dir)
+            install_report = install_dependencies(install_specs)
+            if install_report.installed:
+                logger.info(
+                    "Installed dependencies for {} capabilities: {}",
+                    len(install_report.installed),
+                    install_report.installed,
+                )
+            if install_report.cached:
+                logger.debug("Skipped install (already cached) for: {}", install_report.cached)
+            for cap_name, error in install_report.failed.items():
+                logger.error("Dependency install failed for capability '{}': {}", cap_name, error)
+        except Exception:
+            logger.opt(exception=True).warning(
+                "Capability dependency install pass failed; continuing with discovery"
+            )
+
+    # 4. Discover with host-exclusive source (CAP-LOAD-014)
     try:
         result = Capability.discover(
             cwd=Path.cwd(),