dreadnode 2.0.5__tar.gz → 2.0.6__tar.gz

{dreadnode-2.0.5 → dreadnode-2.0.6}/PKG-INFO

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

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/agents/agent.py

@@ -27,6 +27,7 @@ from dreadnode.agents.events import (
     AgentStep,
     AgentStopReason,
     CompactionEvent,
+    GenerationContent,
     GenerationEnd,
     GenerationError,
     GenerationStart,
@@ -793,6 +794,19 @@ class Agent(Executor[AgentEvent, Trajectory]):
                         finally:
                             await _event_queue.put(None)  # Signal done
 
+                    # Emit generation content BEFORE tools so TUI can
+                    # render text immediately (ENG-5879)
+                    last_msg = step_chat.generated[-1] if step_chat.generated else None
+                    if last_msg and last_msg.content:
+                        content_event = GenerationContent(
+                            agent_id=self.agent_id,
+                            agent_name=self.name,
+                            step=step_count,
+                            content=str(last_msg.content)[:4000],
+                            extra=step_chat.extra,
+                        )
+                        yield content_event
+
                     # Start tools in background
                     tools_task = asyncio.create_task(run_all_tools())
 

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/agents/events.py

@@ -1,6 +1,6 @@
 import json
 import typing as t
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from uuid import UUID, uuid4
 
 import typing_extensions as te
@@ -80,7 +80,7 @@ class AgentEvent(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc), kw_only=True)
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(UTC), kw_only=True)
     agent_id: UUID = Field(default_factory=uuid4)
     agent_name: str | None = None
     status: AgentStatus | None = Field(default=None)
@@ -775,9 +775,37 @@ class GenerationEnd(AgentStep):
     stop_reason: str | None = None
 
     def _get_data(self) -> dict[str, t.Any]:
+        content = None
+        tool_calls = []
+
+        if self.messages:
+            last_msg = self.messages[-1]
+            content = str(last_msg.content)[:4000] if last_msg.content else None
+
+            for tc in last_msg.tool_calls or []:
+                try:
+                    args = json.loads(tc.function.arguments)
+                except (json.JSONDecodeError, TypeError):
+                    args = tc.function.arguments
+                tool_calls.append(
+                    {
+                        "id": tc.id,
+                        "name": tc.name,
+                        "arguments": args,
+                    }
+                )
+
         return {
-            "model": self.generator.model if self.generator else None,
             "step": self.step,
+            "content": content,
+            "tool_calls": tool_calls,
+            "usage": {
+                "input_tokens": self.usage.input_tokens,
+                "output_tokens": self.usage.output_tokens,
+                "total_tokens": self.usage.total_tokens,
+            },
+            "stop_reason": self.stop_reason,
+            "model": self.generator.model if self.generator else None,
         }
 
     def emit(self, span: "TaskSpan") -> None:
@@ -814,6 +842,38 @@ class GenerationEnd(AgentStep):
         super().emit(span)
 
 
+class GenerationContent(AgentEvent):
+    """Event: The LLM produced content, emitted before tool execution.
+
+    This is a TUI rendering signal — it carries the generation text so it can
+    be displayed immediately, before tools run. GenerationEnd/GenerationStep
+    still fire after tools for trajectory, hooks, and telemetry.
+
+    Attributes:
+        step: The step number.
+        content: The generated text content.
+        tool_calls: Tool calls requested by the generation.
+        extra: Additional metadata (reasoning_content, etc.).
+    """
+
+    step: int = 0
+    content: str | None = None
+    tool_calls: list[dict[str, t.Any]] = Field(default_factory=list)
+    extra: dict[str, t.Any] = Field(default_factory=dict)
+
+    def _get_data(self) -> dict[str, t.Any]:
+        return {
+            "step": self.step,
+            "content": self.content,
+            "tool_calls": self.tool_calls,
+            "extra": self.extra,
+        }
+
+    def emit(self, span: "TaskSpan") -> None:
+        # No telemetry — GenerationEnd handles that
+        pass
+
+
 class GenerationError(AgentEvent):
     """Event: An error occurred during a generation step
 
@@ -938,6 +998,7 @@ EVENT_TYPES: dict[str, type[AgentEvent]] = {
     "GenerationStart": GenerationStart,
     "GenerationEnd": GenerationEnd,
     "GenerationStep": GenerationStep,
+    "GenerationContent": GenerationContent,
     "GenerationError": GenerationError,
     "ReactStep": ReactStep,
     "UserInputRequired": UserInputRequired,

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/agents/mcp/client.py

@@ -6,6 +6,7 @@ fallback for streamable-http connections.
 """
 
 import asyncio
+import contextlib
 import typing as t
 import warnings
 from contextlib import AsyncExitStack
@@ -36,6 +37,56 @@ if t.TYPE_CHECKING:
     from dreadnode.generators.message import Content
 
 
+class _StderrCapture:
+    """Async reader that buffers the last N lines from a pipe fd.
+
+    Used to capture MCP subprocess stderr without blocking and without
+    letting it spill into the parent terminal. On connection failure the
+    buffered lines are included in the error message so users can see
+    why the server process crashed.
+    """
+
+    _MAX_LINES = 50
+
+    def __init__(self, read_fd: int, exit_stack: AsyncExitStack) -> None:
+        import os
+        import threading
+
+        self._lines: list[str] = []
+        self._read_file = os.fdopen(read_fd, "r")
+
+        def _reader() -> None:
+            try:
+                for raw in self._read_file:
+                    line = raw.rstrip("\n")
+                    if line:
+                        logger.debug("MCP stderr: {}", line)
+                        self._lines.append(line)
+                        if len(self._lines) > self._MAX_LINES:
+                            self._lines.pop(0)
+            except (OSError, ValueError):
+                pass  # fd closed
+
+        self._thread = threading.Thread(target=_reader, daemon=True)
+        self._thread.start()
+        exit_stack.callback(self._close)
+
+    def _close(self) -> None:
+        with contextlib.suppress(OSError):
+            self._read_file.close()
+        self._thread.join(timeout=1)
+
+    @property
+    def output(self) -> str:
+        """Return captured stderr as a single string."""
+        return "\n".join(self._lines)
+
+    @property
+    def last_lines(self) -> list[str]:
+        """Return the buffered lines."""
+        return list(self._lines)
+
+
 def _convert_mcp_result_to_message_parts(result: "CallToolResult") -> list[t.Any]:
     from mcp.types import TextResourceContents
 
@@ -121,6 +172,7 @@ class MCPClient:
         self._session = None
         self._oauth_config = oauth
         self._init_timeout = init_timeout
+        self._stderr_capture: _StderrCapture | None = None
 
     @classmethod
     def from_config(cls, config: ServerConfig) -> "MCPClient":
@@ -185,11 +237,35 @@ class MCPClient:
         ]
 
     async def _connect_via_stdio(self, connection: StdioConnection) -> "ClientSession":
+        import os
+
         from mcp import ClientSession, StdioServerParameters
         from mcp.client.stdio import stdio_client
 
+        # Capture subprocess stderr via an OS pipe instead of letting it spill
+        # into the parent terminal. An async reader task buffers the last N
+        # lines so we can surface them in error messages on connection failure.
+        read_fd, write_fd = os.pipe()
+        write_file = os.fdopen(write_fd, "w")
+
+        stderr_capture = _StderrCapture(read_fd, self._exit_stack)
+        self._stderr_capture = stderr_capture
+
         server_params = StdioServerParameters(**connection)
-        read, write = await self._exit_stack.enter_async_context(stdio_client(server_params))
+        try:
+            read, write = await self._exit_stack.enter_async_context(
+                stdio_client(server_params, errlog=write_file)
+            )
+        except BaseException:
+            # If the subprocess fails to start (e.g. command not found),
+            # close the write end so the reader thread sees EOF and exits.
+            write_file.close()
+            raise
+        # Close parent's write end now that the subprocess has inherited
+        # the fd. This ensures the pipe reader sees EOF when the subprocess
+        # exits, preventing hangs.
+        write_file.close()
+
         return await self._exit_stack.enter_async_context(ClientSession(read, write))
 
     async def _probe_supports_streamable_http(
@@ -323,9 +399,27 @@ class MCPClient:
             self._status = MCPStatus.CONNECTED
             self._error = None
 
-        except Exception as e:
+        except BaseException as e:
             await self._shutdown()
-            error_msg = str(e)
+
+            # anyio TaskGroups wrap failures in BaseExceptionGroup — unwrap
+            # to surface the actual root cause (e.g. ConnectionRefusedError)
+            # instead of the opaque "unhandled errors in a TaskGroup" message.
+            cause = e
+            if isinstance(e, BaseExceptionGroup):
+                leaf = e.exceptions[0] if e.exceptions else e
+                while isinstance(leaf, BaseExceptionGroup) and leaf.exceptions:
+                    leaf = leaf.exceptions[0]
+                cause = leaf
+
+            error_msg = str(cause)
+
+            # Append captured subprocess stderr for stdio failures —
+            # this surfaces the actual crash output (tracebacks, missing
+            # modules, config errors) instead of just "Connection closed".
+            if self._stderr_capture and self._stderr_capture.last_lines:
+                stderr_tail = "\n".join(self._stderr_capture.last_lines[-10:])
+                error_msg = f"{error_msg}\n\nServer stderr:\n{stderr_tail}"
 
             # Check for auth-related failures
             error_lower = error_msg.lower()
@@ -335,6 +429,10 @@ class MCPClient:
                 self._status = MCPStatus.FAILED
 
             self._error = error_msg
+
+            # Re-raise the unwrapped cause so callers can catch with `except Exception`
+            if cause is not e and isinstance(cause, Exception):
+                raise cause from e
             raise
 
     async def disconnect(self) -> None:

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/agents/mcp/config.py

@@ -8,7 +8,7 @@ StdioServerConfig → stdio, HttpServerConfig → streamable-http.
 
 import typing as t
 from dataclasses import dataclass, field
-from enum import Enum
+from enum import StrEnum
 from pathlib import Path
 
 import typing_extensions as te
@@ -25,7 +25,7 @@ DEFAULT_SSE_READ_TIMEOUT = 60 * 5
 Transport = t.Literal["stdio", "streamable-http"]
 
 
-class MCPStatus(str, Enum):
+class MCPStatus(StrEnum):
     """Status of an MCP server connection."""
 
     CONNECTED = "connected"

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/airt/analytics/types.py

@@ -8,14 +8,14 @@ from __future__ import annotations
 
 import typing as t
 from dataclasses import asdict, dataclass, field
-from enum import Enum
+from enum import StrEnum
 
 # ---------------------------------------------------------------------------
 # Enums
 # ---------------------------------------------------------------------------
 
 
-class Severity(str, Enum):
+class Severity(StrEnum):
     """Risk severity levels for attack findings."""
 
     CRITICAL = "critical"
@@ -42,7 +42,7 @@ _SEVERITY_RANK: dict[Severity, int] = {
 }
 
 
-class GoalCategory(str, Enum):
+class GoalCategory(StrEnum):
     """Impact categories for severity classification.
 
     Each category represents a class of attack objective.  The category

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/airt/compliance/atlas.py

@@ -6,10 +6,10 @@ AI/ML-specific attack techniques organized by tactics similar to MITRE ATT&CK.
 Reference: https://atlas.mitre.org/
 """
 
-from enum import Enum
+from enum import StrEnum
 
 
-class ATLASTechnique(str, Enum):
+class ATLASTechnique(StrEnum):
     """
     MITRE ATLAS AI/ML Attack Technique IDs.
 

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/airt/compliance/nist.py

@@ -6,10 +6,10 @@ Risk management functions and categories for AI systems.
 Reference: https://www.nist.gov/itl/ai-risk-management-framework
 """
 
-from enum import Enum
+from enum import StrEnum
 
 
-class NISTAIRMFFunction(str, Enum):
+class NISTAIRMFFunction(StrEnum):
     """
     NIST AI Risk Management Framework Core Functions.
 

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/airt/compliance/owasp.py

@@ -4,10 +4,10 @@ OWASP Top 10 for LLM Applications 2025.
 Reference: https://genai.owasp.org/llm-top-10/
 """
 
-from enum import Enum
+from enum import StrEnum
 
 
-class OWASPCategory(str, Enum):
+class OWASPCategory(StrEnum):
     """
     OWASP Top 10 for LLM Applications 2025.
 

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/airt/compliance/owasp_agentic.py

@@ -19,10 +19,10 @@ Example:
     ```
 """
 
-from enum import Enum
+from enum import StrEnum
 
 
-class OWASPAgenticCategory(str, Enum):
+class OWASPAgenticCategory(StrEnum):
     """
     OWASP Top 10 for Agentic Applications (2026).
 

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/airt/compliance/saif.py

@@ -6,10 +6,10 @@ Security categories for AI/ML systems aligned with Google's security principles.
 Reference: https://blog.google/technology/safety-security/google-secure-ai-framework/
 """
 
-from enum import Enum
+from enum import StrEnum
 
 
-class SAIFCategory(str, Enum):
+class SAIFCategory(StrEnum):
     """
     Google SAIF (Secure AI Framework) Security Categories.
 

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/airt/events.py

@@ -23,7 +23,7 @@ Hierarchy::
 from __future__ import annotations
 
 import typing as t
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -77,7 +77,7 @@ class AssessmentEvent(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc), kw_only=True)
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(UTC), kw_only=True)
     assessment_id: str = ""
     assessment_name: str = ""
 
@@ -498,7 +498,7 @@ class TransformApplied(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc), kw_only=True)
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(UTC), kw_only=True)
     transform_name: str = ""
     transform_index: int = 0
     chain_length: int = 0

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/airt/reporting/json_report.py

@@ -7,7 +7,7 @@ Suitable for CI/CD integration (e.g. ``jq '.summary.severity_breakdown.critical'
 from __future__ import annotations
 
 import typing as t
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 
 from dreadnode.airt.analytics.types import (
     ASRBreakdown,
@@ -87,7 +87,7 @@ def generate_json_report(analytics: CampaignAnalytics) -> dict[str, t.Any]:
 
     return {
         "meta": {
-            "generated_at": datetime.now(tz=timezone.utc).isoformat(),
+            "generated_at": datetime.now(tz=UTC).isoformat(),
             "report_version": "1.0",
         },
         "summary": {

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/airt/reporting/markdown.py

@@ -6,7 +6,7 @@ document suitable for human review or conversion to HTML/PDF.
 
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 
 from dreadnode.airt.analytics.types import (
     ASRBreakdown,
@@ -41,7 +41,7 @@ def _truncate(text: str, max_len: int = 500) -> str:
 
 
 def _render_header(analytics: CampaignAnalytics) -> str:
-    now = datetime.now(tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
+    now = datetime.now(tz=UTC).strftime("%Y-%m-%d %H:%M:%S UTC")
     stats = analytics.execution_stats
     return (
         "# AIRT Campaign Report\n\n"

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/app/api/client.py

@@ -355,6 +355,18 @@ class ApiClient:
         """DELETE /api/org/{org}/datasets/{name}/{version} - Delete dataset artifact."""
         self.request("DELETE", f"/org/{org}/datasets/{name}/{version}")
 
+    def download_dataset(
+        self, org: str, name: str, version: str, *, format: str = "raw", split: str | None = None
+    ) -> dict:
+        """POST /api/org/{org}/datasets/{name}/{version}/download - Get presigned download URL."""
+        body: dict[str, t.Any] = {"format": format}
+        if split:
+            body["split"] = split
+        response = self.request(
+            "POST", f"/org/{org}/datasets/{name}/{version}/download", json_data=body
+        )
+        return response.json()
+
     def list_models(self, org: str) -> list[Package]:
         """GET /api/org/{org}/models - List models."""
         response = self.request("GET", f"/org/{org}/models")
@@ -1217,6 +1229,11 @@ class ApiClient:
         response = self.request("GET", f"/org/{org}/capabilities/{name}/versions")
         return t.cast("dict[str, t.Any]", response.json())
 
+    def list_public_capability_versions(self, owner: str, name: str) -> dict[str, t.Any]:
+        """GET /capabilities/{owner}/{name}/versions - List public capability versions."""
+        response = self.request("GET", f"/capabilities/{owner}/{name}/versions")
+        return t.cast("dict[str, t.Any]", response.json())
+
     def get_capability(self, org: str, name: str, version: str) -> dict[str, t.Any]:
         """GET /org/{org}/capabilities/{name}/{version} - Get artifact detail."""
         response = self.request("GET", f"/org/{org}/capabilities/{name}/{version}")

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/app/api/models.py

@@ -857,6 +857,11 @@ class ComponentStatusInfo(BaseModel):
     status: t.Literal["ok", "error", "degraded"]
     error: str | None = None
     detail: str | None = None
+    # MCP-specific optional fields
+    qualified_name: str | None = None
+    capability: str | None = None
+    transport: str | None = None
+    tool_count: int | None = None
 
 
 class CapabilityInfo(BaseModel):
@@ -874,6 +879,7 @@ class CapabilityInfo(BaseModel):
     origin: dict[str, t.Any] | None = None
     enabled: bool = True
     binding_id: str | None = None
+    update_available: str | None = None
     components: list[ComponentStatusInfo] = []
     # Existing fields retained for backward compat
     entry_agent: str | None = None

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/app/cli/airt.py

@@ -13,6 +13,7 @@ from dreadnode.app.cli.shared import (
     _render_airt_assessment_list,
     _render_airt_reports,
     configured_dreadnode,
+    console,
     require_workspace_context,
 )
 
@@ -161,7 +162,7 @@ def delete(
     dn = configured_dreadnode(platform)
     org, workspace, client = require_workspace_context(dn, label="AIRT")
     client.delete_airt_assessment(org, workspace, assessment_id)
-    print(f"Deleted AIRT assessment {assessment_id}")
+    console.print(f"Deleted AIRT assessment [dim]{assessment_id}[/dim]")
 
 
 # ---------------------------------------------------------------------------

{dreadnode-2.0.5 → dreadnode-2.0.6}/dreadnode/app/cli/capability.py

@@ -11,6 +11,7 @@ from dreadnode.app.cli.shared import (
     _render_capability_list,
     _sync_progress,
     configured_dreadnode,
+    console,
     require_registry_context,
 )
 
@@ -45,13 +46,15 @@ def push(
     except (ValueError, RuntimeError) as exc:
         raise SystemExit(str(exc)) from exc
 
+    name = result.name
+    version = result.version
     if result.status == "built":
-        print(f"Built {result.name}@{result.version}")
+        console.print(f"Built [cyan]{name}[/cyan]@[dim]{version}[/dim]")
     elif result.status == "up_to_date":
-        print(f"{result.name}@{result.version} already up to date")
+        console.print(f"[cyan]{name}[/cyan]@[dim]{version}[/dim] already up to date")
     else:
         digest = result.digest or "unknown"
-        print(f"Pushed {result.name}@{result.version} ({digest})")
+        console.print(f"Pushed [cyan]{name}[/cyan]@[dim]{version}[/dim] [dim]({digest})[/dim]")
 
 
 # ---------------------------------------------------------------------------
@@ -110,7 +113,7 @@ def delete(
     org, client = require_registry_context(dn)
     name, version = _parse_versioned_ref(ref, field_name="ref")
     client.delete_capability(org, name, version)
-    print(f"Deleted {org}/{name}@{version}")
+    console.print(f"Deleted [dim]{org}/[/dim][cyan]{name}[/cyan]@[dim]{version}[/dim]")
 
 
 # ---------------------------------------------------------------------------
@@ -168,10 +171,11 @@ def sync(
     )
 
     total = len(result.uploaded) + len(result.skipped) + len(result.failed)
-    print(
+    console.print(
         f"\nSynced {total} capability(ies): "
-        f"uploaded={len(result.uploaded)} skipped={len(result.skipped)} "
-        f"failed={len(result.failed)}"
+        f"[green]uploaded={len(result.uploaded)}[/green] "
+        f"[dim]skipped={len(result.skipped)}[/dim] "
+        f"[red]failed={len(result.failed)}[/red]"
     )
     if not result.ok:
         raise SystemExit(1)
@@ -195,7 +199,7 @@ def validate(
 
     resolved = Path(path).resolve()
     if not resolved.exists():
-        print(f"Path not found: {resolved}")
+        console.print(f"[red]Path not found:[/red] {resolved}")
         raise SystemExit(1)
 
     # If path contains capability.yaml directly, validate just that one
@@ -207,7 +211,9 @@ def validate(
             d for d in resolved.iterdir() if d.is_dir() and (d / "capability.yaml").exists()
         )
         if not dirs:
-            print(f"No capability.yaml found in {resolved} or its subdirectories")
+            console.print(
+                f"[red]No capability.yaml found in {resolved} or its subdirectories[/red]"
+            )
             raise SystemExit(1)
 
     errors: list[tuple[str, str]] = []
@@ -233,20 +239,22 @@ def validate(
 
             if health_errors:
                 warnings.append(cap.name)
-                print(f"  WARN {cap.name}@{cap.version} ({summary})")
+                console.print(f"  [yellow]WARN[/yellow] {cap.name}@{cap.version} ({summary})")
                 for h in health_errors:
-                    print(f"       {h.get('component', '?')}: {h.get('error', 'unknown')}")
+                    console.print(f"       {h.get('component', '?')}: {h.get('error', 'unknown')}")
             else:
-                print(f"  OK   {cap.name}@{cap.version} ({summary})")
+                console.print(f"  [green]OK[/green]   {cap.name}@{cap.version} ({summary})")
         except (ValueError, FileNotFoundError) as exc:
             errors.append((dir_name, str(exc)))
-            print(f"  FAIL {dir_name}: {exc}")
+            console.print(f"  [red]FAIL[/red] {dir_name}: {exc}")
 
     total = len(dirs)
     failed = len(errors)
     warned = len(warnings)
-    print(
-        f"\nValidated {total} capability(ies): {total - failed - warned} ok, {warned} warn, {failed} failed"
+    ok_count = total - failed - warned
+    console.print(
+        f"\nValidated {total} capability(ies): "
+        f"[green]{ok_count} ok[/green], [yellow]{warned} warn[/yellow], [red]{failed} failed[/red]"
     )
     if errors or (strict and warnings):
         raise SystemExit(1)