dreadnode 2.0.22__tar.gz → 2.0.24__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 2.0.22
+Version: 2.0.24
 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.24}/dreadnode/airt/assessment.py

@@ -23,6 +23,7 @@ import contextlib
 import contextvars
 import os
 import signal
+import threading
 import typing as t
 from pathlib import Path
 
@@ -57,6 +58,26 @@ def _get_platform_context() -> tuple[ApiClient, Profile] | None:
     return None
 
 
+# Thread-local storage for injected platform context
+_thread_local = threading.local()
+
+
+def _set_platform_context(api: ApiClient, profile: Profile) -> None:
+    """Set platform context for the current thread (used by AIRT CLI)."""
+    _thread_local.api = api
+    _thread_local.profile = profile
+
+
+def _get_platform_context_with_fallback() -> tuple[ApiClient, Profile] | None:
+    """Get platform context with CLI injection fallback."""
+    # First try thread-local injected context (from AIRT CLI)
+    if hasattr(_thread_local, "api") and hasattr(_thread_local, "profile"):
+        return _thread_local.api, _thread_local.profile
+
+    # Fallback to global DEFAULT_INSTANCE
+    return _get_platform_context()
+
+
 class Assessment:
     """Orchestrates multi-attack assessments.
 
@@ -91,6 +112,7 @@ class Assessment:
         workflow_run_id: str | None = None,
         workflow_script: str | None = None,
         project_id: str | None = None,
+        runtime_id: str | None = None,
     ) -> None:
         self.name = name
         self.description = description
@@ -116,6 +138,7 @@ class Assessment:
         self._workflow_run_id = workflow_run_id
         self._workflow_script = workflow_script
         self._project_id = project_id
+        self._runtime_id = runtime_id
 
         self._session_id = session_id or os.environ.get("DREADNODE_SESSION_ID")
         if self._session_id is None:
@@ -177,7 +200,7 @@ class Assessment:
         if self._assessment_id is not None:
             return self._assessment_id
 
-        ctx = _get_platform_context()
+        ctx = _get_platform_context_with_fallback()
         if ctx is None:
             logger.debug("SDK offline -- assessment not registered with platform")
             return None
@@ -192,11 +215,28 @@ class Assessment:
             return None
 
         try:
+            # Get runtime_id - try to use a default runtime for the project
+            runtime_id = getattr(self, "_runtime_id", None)
+            if runtime_id is None:
+                # Auto-discover a runtime for this project (CLI users shouldn't need to specify this)
+                try:
+                    runtimes_resp = api.list_runtimes(profile.org_key, profile.workspace_key)
+                    runtime_items = runtimes_resp.get("items", [])
+                    matching_runtimes = [r for r in runtime_items if r["project_id"] == project_id]
+                    if matching_runtimes:
+                        runtime_id = matching_runtimes[0]["id"]
+                        logger.debug(f"Auto-selected runtime {runtime_id} for project {project_id}")
+                    else:
+                        logger.warning(f"No runtimes found for project {project_id}")
+                except Exception as e:
+                    logger.debug(f"Failed to auto-discover runtime for project: {e}")
+
             result = api.create_airt_assessment(
                 profile.org_key,
                 profile.workspace_key,
                 name=self.name,
                 project_id=project_id,
+                runtime_id=runtime_id,
                 description=self.description,
                 session_id=self._session_id,
                 target_model=self.target_model,
@@ -402,7 +442,7 @@ class Assessment:
             await self.register()
             # Notify the platform that execution has started (sets started_at server-side)
             if self._assessment_id is not None:
-                ctx = _get_platform_context()
+                ctx = _get_platform_context_with_fallback()
                 if ctx is not None:
                     api, session = ctx
                     try:
@@ -459,7 +499,7 @@ class Assessment:
                 provider.force_flush(timeout_millis=10_000)
 
         # Use the sync API client directly — no async gymnastics
-        ctx = _get_platform_context()
+        ctx = _get_platform_context_with_fallback()
         if ctx is None or self._assessment_id is None:
             return
 
@@ -499,7 +539,7 @@ class Assessment:
         Returns:
             True if successfully marked, False otherwise.
         """
-        ctx = _get_platform_context()
+        ctx = _get_platform_context_with_fallback()
         if ctx is None or self._assessment_id is None:
             return False
 
@@ -527,7 +567,7 @@ class Assessment:
         Returns:
             True if successfully marked, False otherwise.
         """
-        ctx = _get_platform_context()
+        ctx = _get_platform_context_with_fallback()
         if ctx is None or self._assessment_id is None:
             return False
 

{dreadnode-2.0.22 → dreadnode-2.0.24}/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.24}/dreadnode/app/cli/airt.py

@@ -64,6 +64,46 @@ 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, creating the project if it doesn't exist."""
+    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 get_error:
+        # Project doesn't exist, try to create it
+        try:
+            print(f"[PROJECT DEBUG] Project '{candidate}' not found, creating it...")
+            created = api.create_project(
+                profile.org_key,
+                profile.workspace_key,
+                name=str(candidate),
+                key=str(candidate),
+                description="Auto-created project for AIRT CLI run",
+            )
+            print(
+                f"[PROJECT DEBUG] Successfully created project '{candidate}' with ID {created.id}"
+            )
+            return str(created.id)
+        except Exception as create_error:
+            print(f"[PROJECT DEBUG] Failed to resolve project '{candidate}': {get_error}")
+            print(f"[PROJECT DEBUG] Failed to create project '{candidate}': {create_error}")
+            return None
+
+
 _SEVERITY_COLORS = {
     "critical": "red",
     "high": "red",
@@ -1126,6 +1166,9 @@ def run(
             print_error(str(e))
             return
 
+    # Capture original project argument before connect() clears it
+    original_project = platform.project
+
     # Configure SDK and validate scope to populate project_id
     _api, profile = platform.connect()
 
@@ -1151,18 +1194,49 @@ def run(
     console.print()
 
     async def _run() -> None:
+        # Determine project for SDK configuration
+        # Use original CLI argument, fallback to profile, environment, then 'default'
+        import os
+
         from dreadnode.airt import Assessment
+        from dreadnode.airt.assessment import _set_platform_context
 
         # Configure the SDK using the validated profile
-        from dreadnode.app.main import Dreadnode
-
-        Dreadnode().configure(
-            server=profile.url,
-            api_key=profile.api_key,
-            organization=profile.organization,
-            workspace=profile.workspace,
-            project=profile.project,
-        )
+        from dreadnode.app.main import DEFAULT_INSTANCE
+
+        env_project = os.getenv("DREADNODE_PROJECT")
+        sdk_project = original_project or profile.project or env_project or "default"
+
+        # Try global SDK configuration first
+        try:
+            DEFAULT_INSTANCE.configure(
+                server=profile.url,
+                api_key=profile.api_key,
+                organization=profile.organization,
+                workspace=profile.workspace,
+                project=sdk_project,
+            )
+            from loguru import logger
+
+            logger.debug("SDK instance configured successfully for assessment registration")
+        except Exception as e:
+            from loguru import logger
+
+            logger.warning(f"Failed to configure SDK instance for assessment registration: {e}")
+            logger.info("Using fallback context injection for assessment registration")
+
+        # Always inject platform context as fallback for assessment registration
+        _set_platform_context(_api, profile)
+
+        # Resolve project name to UUID
+        # Use original CLI argument, fallback to profile, environment, then 'default'
+        import os
+
+        env_project = os.getenv("DREADNODE_PROJECT")
+        actual_project = original_project or profile.project or env_project or "default"
+
+        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,
@@ -1171,7 +1245,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,
@@ -1298,13 +1372,48 @@ def run_suite(
     console.print(f"  Config:  [dim]{file}[/dim]")
     console.print()
 
+    # Capture original project argument before connect() clears it
+    original_project = platform.project
+
     # Configure SDK
     _api, profile = platform.connect()
 
     target_fn = _build_target(model, max_tokens)
 
     async def _run_suite() -> list[dict[str, t.Any]]:
+        # Determine project for SDK configuration
+        # Use original CLI argument, fallback to profile, environment, then 'default'
+        import os
+
         from dreadnode.airt import Assessment
+        from dreadnode.airt.assessment import _set_platform_context
+
+        # Configure the SDK using the validated profile
+        from dreadnode.app.main import DEFAULT_INSTANCE
+
+        env_project = os.getenv("DREADNODE_PROJECT")
+        sdk_project = original_project or profile.project or env_project or "default"
+
+        # Try global SDK configuration first
+        try:
+            DEFAULT_INSTANCE.configure(
+                server=profile.url,
+                api_key=profile.api_key,
+                organization=profile.organization,
+                workspace=profile.workspace,
+                project=sdk_project,
+            )
+            from loguru import logger
+
+            logger.debug("SDK instance configured successfully for assessment registration")
+        except Exception as e:
+            from loguru import logger
+
+            logger.warning(f"Failed to configure SDK instance for assessment registration: {e}")
+            logger.info("Using fallback context injection for assessment registration")
+
+        # Always inject platform context as fallback for assessment registration
+        _set_platform_context(_api, profile)
 
         suite_results = []
         for i, goal_cfg in enumerate(goals, 1):
@@ -1316,6 +1425,16 @@ def run_suite(
 
             console.print(f"\n--- Goal {i}/{len(goals)}: {goal_text[:60]}...")
 
+            # Resolve project name to UUID
+            # Use original CLI argument, then environment variable as fallback
+            import os
+
+            env_project = os.getenv("DREADNODE_PROJECT")
+            actual_project = original_project or 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 +1442,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.24}/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.24}/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.24}/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.24}/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(),