dreadnode 1.15.0__tar.gz → 1.15.2__tar.gz

{dreadnode-1.15.0 → dreadnode-1.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 1.15.0
+Version: 1.15.2
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://github.com/dreadnode/sdk
 Project-URL: Repository, https://github.com/dreadnode/sdk

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/agent/agent.py

@@ -2,10 +2,11 @@ import inspect
 import typing as t
 from contextlib import aclosing, asynccontextmanager
 from copy import deepcopy
+from textwrap import dedent
 
 import rigging as rg
 from loguru import logger
-from pydantic import ConfigDict, Field, PrivateAttr, SkipValidation, field_validator
+from pydantic import AfterValidator, ConfigDict, Field, PrivateAttr, SkipValidation, field_validator
 from rigging.message import inject_system_content
 from ulid import ULID  # can't access via rg
 
@@ -71,14 +72,18 @@ class Agent(Model):
 
     name: str
     """The name of the agent."""
-    description: str = ""
+    description: t.Annotated[str, AfterValidator(dedent)] = ""
     """A brief description of the agent's purpose."""
     tags: list[str] = Config(default_factory=lambda: ["agent"])
     """A list of tags associated with the agent."""
+    label: str | None = Config(default=None)
+    """Specific label for tracing, otherwise derived from the name."""
 
     model: str | None = Config(default=None)
     """Inference model (rigging generator identifier)."""
-    instructions: str | None = Config(default=None)
+    instructions: t.Annotated[str | None, AfterValidator(lambda x: dedent(x) if x else x)] = Config(
+        default=None
+    )
     """The agent's core instructions."""
     max_steps: int = Config(default=10)
     """The maximum number of steps (generation + tool calls)."""
@@ -90,15 +95,15 @@ class Agent(Model):
     tool_mode: ToolMode = Config(default="auto", repr=False)
     """The tool calling mode to use."""
 
-    hooks: list[Hook] = Config(default_factory=list, exclude=True, repr=False)
+    hooks: list[Hook] = Field(default_factory=list, exclude=True, repr=False)
     """Hooks to run at various points in the agent's lifecycle."""
-    stop_conditions: list[StopCondition] = Config(default_factory=list)
+    stop_conditions: list[StopCondition] = Field(default_factory=list)
     """The logical condition for successfully stopping a run."""
     thread: Thread = Field(default_factory=Thread, exclude=True, repr=False)
     """Stateful thread for this agent, for when otherwise not specified during execution."""
-    scorers: ScorersLike[AgentResult] = Config(default_factory=list)
+    scorers: ScorersLike[AgentResult] = Field(default_factory=list)
     """Scorers to evaluate the agent output."""
-    assert_scores: list[str] | t.Literal[True] = Config(default_factory=list)
+    assert_scores: list[str] | t.Literal[True] = Field(default_factory=list)
     """Scores to ensure are truthy, otherwise the agent task is marked as failed."""
 
     _generator: rg.Generator | None = PrivateAttr(None, init=False)
@@ -716,14 +721,25 @@ class Agent(Model):
         )
         trace_params.update(
             {
+                "name": self.name,
                 "model": self.model,
                 "max_steps": self.max_steps,
                 "tool_mode": self.tool_mode,
+                "tool_count": len(self.all_tools),
+                "instructions_length": len(self.instructions or ""),
+                "stop_condition_count": len(self.stop_conditions),
+                "message_count": len(messages),
             }
         )
 
         last_event: AgentEvent | None = None
-        with task_and_run(name=self.name, tags=self.tags, inputs=trace_inputs, params=trace_params):
+        with task_and_run(
+            name=self.name,
+            tags=self.tags,
+            label=self.label,
+            inputs=trace_inputs,
+            params=trace_params,
+        ):
             try:
                 async with aclosing(self._stream(thread, messages, hooks, commit=commit)) as stream:
                     async for event in stream:

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/agent/hooks/__init__.py

@@ -3,6 +3,7 @@ from dreadnode.agent.hooks.base import (
     Hook,
     retry_with_feedback,
 )
+from dreadnode.agent.hooks.metrics import tool_metrics
 from dreadnode.agent.hooks.summarize import summarize_when_long
 
 __all__ = [
@@ -11,4 +12,5 @@ __all__ = [
     "backoff_on_ratelimit",
     "retry_with_feedback",
     "summarize_when_long",
+    "tool_metrics",
 ]

dreadnode-1.15.2/dreadnode/agent/hooks/metrics.py

@@ -0,0 +1,84 @@
+import typing as t
+
+from dreadnode.agent.events import AgentEvent, ToolEnd, ToolStart
+from dreadnode.agent.hooks import Hook
+from dreadnode.meta import Config, component
+
+if t.TYPE_CHECKING:
+    from datetime import datetime
+
+
+def tool_metrics(*, detailed: bool = False) -> Hook:
+    """
+    Creates an agent hook to log metrics about tool usage, execution time, and success rates.
+
+    Args:
+        detailed: If True, logs metrics for each specific tool in addition to general stats.
+                  If False, only logs aggregate statistics across all tools.
+
+    Returns:
+        An async hook function that can be registered with an agent.
+    """
+    _start_times: dict[str, datetime] = {}
+
+    @component
+    async def tool_metrics(
+        event: AgentEvent,
+        *,
+        detailed: bool = Config(
+            default=detailed,
+            help="If True, logs metrics for each specific tool in addition to general stats.",
+        ),
+    ) -> None:
+        """The actual hook implementation that processes agent events."""
+        from dreadnode import log_metric
+
+        if isinstance(event, ToolStart):
+            log_metric("tool/total_count", 1, step=event.step, mode="count")
+            _start_times[event.tool_call.id] = event.timestamp
+
+            if detailed:
+                tool_name = event.tool_call.name
+                log_metric(f"tool/count.{tool_name}", 1, step=event.step, mode="count")
+
+        elif isinstance(event, ToolEnd):
+            tool_name = event.tool_call.name
+            start_time = _start_times.pop(event.tool_call.id, event.timestamp)
+            duration_seconds = (event.timestamp - start_time).total_seconds()
+            errored = "error" in event.message.metadata
+
+            log_metric("tool/total_time", duration_seconds, step=event.step, mode="sum")
+            log_metric("tool/success_rate", 0 if errored else 1, step=event.step, mode="avg")
+
+            if errored:
+                log_metric("tool/failed_count", 1, step=event.step, mode="count")
+
+            if detailed:
+                log_metric(
+                    f"tool/time.{tool_name}",
+                    duration_seconds,
+                    step=event.step,
+                    mode="sum",
+                )
+                log_metric(
+                    f"tool/avg_time.{tool_name}",
+                    duration_seconds,
+                    step=event.step,
+                    mode="avg",
+                )
+                log_metric(
+                    f"tool/success_rate.{tool_name}",
+                    0 if errored else 1,
+                    step=event.step,
+                    mode="avg",
+                )
+
+                if errored:
+                    log_metric(
+                        f"tool/failed_count.{tool_name}",
+                        1,
+                        step=event.step,
+                        mode="count",
+                    )
+
+    return tool_metrics

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/agent/tools/__init__.py

@@ -16,7 +16,7 @@ from dreadnode.agent.tools.base import (
 )
 
 if t.TYPE_CHECKING:
-    from dreadnode.agent.tools import fs, planning, reporting, tasking
+    from dreadnode.agent.tools import execute, fs, memory, planning, reporting, tasking
 
 __all__ = [
     "AnyTool",
@@ -28,7 +28,9 @@ __all__ = [
     "ToolMode",
     "Toolset",
     "discover_tools_on_obj",
+    "execute",
     "fs",
+    "memory",
     "planning",
     "reporting",
     "tasking",
@@ -36,7 +38,7 @@ __all__ = [
     "tool_method",
 ]
 
-__lazy_submodules__: list[str] = ["fs", "planning", "reporting", "tasking"]
+__lazy_submodules__: list[str] = ["fs", "planning", "reporting", "tasking", "execute", "memory"]
 __lazy_components__: dict[str, str] = {}
 
 

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/agent/tools/base.py

@@ -4,7 +4,7 @@ from pydantic import ConfigDict
 from rigging import tools
 from rigging.tools.base import ToolMethod as RiggingToolMethod
 
-from dreadnode.meta import Component, Config, Model
+from dreadnode.meta import Component, Model
 
 Tool = tools.Tool
 ToolMode = tools.ToolMode
@@ -103,18 +103,18 @@ def tool_method(
     description: str | None = None,
     catch: bool | t.Iterable[type[Exception]] | None = None,
     truncate: int | None = None,
-) -> t.Callable[[t.Callable[P, R]], RiggingToolMethod[P, R]]: ...
+) -> t.Callable[[t.Callable[t.Concatenate[t.Any, P], R]], RiggingToolMethod[P, R]]: ...
 
 
 @t.overload
 def tool_method(
-    func: t.Callable[P, R],
+    func: t.Callable[t.Concatenate[t.Any, P], R],
     /,
 ) -> RiggingToolMethod[P, R]: ...
 
 
 def tool_method(
-    func: t.Callable[P, R] | None = None,
+    func: t.Callable[t.Concatenate[t.Any, P], R] | None = None,
     /,
     *,
     variants: list[str] | None = None,
@@ -122,7 +122,10 @@ def tool_method(
     description: str | None = None,
     catch: bool | t.Iterable[type[Exception]] | None = None,
     truncate: int | None = None,
-) -> t.Callable[[t.Callable[P, R]], RiggingToolMethod[P, R]] | RiggingToolMethod[P, R]:
+) -> (
+    t.Callable[[t.Callable[t.Concatenate[t.Any, P], R]], RiggingToolMethod[P, R]]
+    | RiggingToolMethod[P, R]
+):
     """
     Marks a method on a Toolset as a tool, adding it to specified variants.
 
@@ -143,7 +146,9 @@ def tool_method(
         truncate: The maximum number of characters for the tool's output.
     """
 
-    def make_tool_method(func: t.Callable[P, R]) -> RiggingToolMethod[P, R]:
+    def make_tool_method(
+        func: t.Callable[t.Concatenate[t.Any, P], R],
+    ) -> RiggingToolMethod[P, R]:
         tool_method_descriptor: RiggingToolMethod[P, R] = tools.tool_method(
             name=name,
             description=description,
@@ -168,7 +173,7 @@ class Toolset(Model):
     - A `get_tools` method for discovering methods decorated with `@dreadnode.tool_method`.
     """
 
-    variant: str = Config("all")
+    variant: str | None = None
     """The variant for filtering tools available in this toolset."""
 
     model_config = ConfigDict(arbitrary_types_allowed=True, use_attribute_docstrings=True)
@@ -190,7 +195,7 @@ class Toolset(Model):
                     continue
 
                 variants = getattr(class_member, TOOL_VARIANTS_ATTR, [])
-                if variant in variants:
+                if not variant or not variants or variant in variants:
                     bound_tool = t.cast("AnyTool", getattr(self, name))
                     tools.append(bound_tool)
                     seen_names.add(name)

dreadnode-1.15.2/dreadnode/agent/tools/execute.py

@@ -0,0 +1,111 @@
+import asyncio
+import contextlib
+import sys
+
+from loguru import logger
+
+from dreadnode.agent.tools.base import tool
+
+
+@tool(catch=True)
+async def command(
+    cmd: list[str],
+    *,
+    timeout: int = 120,
+    cwd: str | None = None,
+    env: dict[str, str] | None = None,
+) -> str:
+    """
+    Execute a shell command.
+
+    Use this tool to run system utilities and command-line programs (e.g., `ls`, `cat`, `grep`). \
+    It is designed for straightforward, single-shot operations and returns the combined output and error streams.
+
+    ## Best Practices
+    - Argument Format: The command and its arguments *must* be provided as a \
+    list of strings (e.g., `["ls", "-la", "/tmp"]`), not as a single string.
+    - No Shell Syntax: Does not use a shell. Features like pipes (`|`), \
+    redirection (`>`), and variable expansion (`$VAR`) are not supported.
+    - Error on Failure: The tool will raise a `RuntimeError` if the command returns a non-zero exit code.
+
+    Args:
+        cmd: The command to execute, provided as a list of strings.
+        timeout: Maximum time in seconds to allow for command execution.
+        cwd: The working directory in which to execute the command.
+        env: Optional environment variables to set for the command.
+    """
+    try:
+        command_str = " ".join(cmd)
+        logger.debug(f"Executing '{command_str}'")
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+            cwd=cwd,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+        output = stdout.decode() + stderr.decode()
+    except asyncio.TimeoutError as e:
+        logger.warning(f"Command '{command_str}' timed out after {timeout} seconds.")
+        with contextlib.suppress(OSError):
+            proc.kill()
+        raise TimeoutError(f"Command timed out after {timeout} seconds") from e
+    except Exception as e:
+        logger.error(f"Error executing '{command_str}': {e}")
+        raise
+
+    if proc.returncode != 0:
+        logger.error(f"Command '{command_str}' failed with return code {proc.returncode}: {output}")
+        raise RuntimeError(f"Command failed ({proc.returncode}): {output}")
+
+    logger.debug(f"Command '{command_str}':\n{output}")
+    return output
+
+
+@tool(catch=True)
+async def python(code: str, *, timeout: int = 120) -> str:
+    """
+    Execute Python code.
+
+    This tool is ideal for tasks that require custom logic like loops and conditionals, \
+    or for parsing and transforming the output from other tools. Use it to implement a \
+    sequence of actions, perform file I/O, or create functionality not covered by other \
+    available tools.
+
+    ## Best Practices
+    - Capture Output: Your script *must* print results to standard output (`print(...)`) to be captured.
+    - Self-Contained: Import all required standard libraries (e.g., `os`, `json`) within the script.
+    - Handle Errors: Write robust code. Unhandled exceptions in your script will cause the tool to fail.
+    - String-Based I/O: Ensure all printed output can be represented as a string. Use formats like JSON (`json.dumps`) for complex data.
+
+    Args:
+        code: The Python code to execute as a string.
+        timeout: Maximum time in seconds to allow for code execution.
+    """
+    try:
+        logger.debug(f"Executing python:\n{code}")
+        proc = await asyncio.create_subprocess_exec(
+            *[sys.executable, "-"],
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await asyncio.wait_for(
+            proc.communicate(input=code.encode("utf-8")), timeout=timeout
+        )
+        output = stdout.decode(errors="ignore") + stderr.decode(errors="ignore")
+    except asyncio.TimeoutError as e:
+        with contextlib.suppress(ProcessLookupError):
+            proc.kill()
+        raise TimeoutError(f"Execution timed out after {timeout} seconds") from e
+    except Exception as e:
+        logger.error(f"Error executing code in Python: {e}")
+        raise
+
+    if proc.returncode != 0:
+        logger.error(f"Execution failed with return code {proc.returncode}:\n{output}")
+        raise RuntimeError(f"Execution failed ({proc.returncode}):\n{output}")
+
+    logger.debug(f"Execution successful. Output:\n{output}")
+    return output

dreadnode-1.15.2/dreadnode/agent/tools/memory.py

@@ -0,0 +1,56 @@
+import typing as t
+
+from pydantic import PrivateAttr
+
+from dreadnode.agent.tools import Toolset, tool_method
+
+
+class Memory(Toolset):
+    """
+    Provides a stateful, in-memory key-value store for the toolset's lifetime.
+
+    This toolset allows the agent to save, retrieve, and manage data, enabling it to
+    remember information across multiple steps and tool calls.
+    """
+
+    _memory: dict[str, str] = PrivateAttr(default_factory=dict)
+
+    @tool_method
+    def save_memory(
+        self,
+        key: t.Annotated[str, "The unique key to store the value under."],
+        value: t.Annotated[str, "The string value to store in memory."],
+    ) -> str:
+        """Saves a value to memory with the specified key, overwriting any existing value."""
+        self._memory[key] = value
+        return f"Value saved to memory key: '{key}'"
+
+    @tool_method(catch=True)
+    def retrieve_memory(self, key: t.Annotated[str, "The key of the value to retrieve."]) -> str:
+        """Retrieves a value from memory using the specified key."""
+        return self._memory[key]
+
+    @tool_method
+    def list_memory_keys(self) -> list[str]:
+        """Lists all keys currently stored in memory."""
+        return list(self._memory.keys())
+
+    @tool_method(catch=True)
+    def clear_memory(
+        self,
+        key: t.Annotated[
+            str | None, "The specific key to clear. If not provided, all memory is cleared."
+        ] = None,
+    ) -> str:
+        """
+        Clears a specific key from memory, or clears all memory if no key is provided.
+        """
+        if key is None:
+            self._memory.clear()
+            return "All memory has been cleared."
+
+        if key not in self._memory:
+            return f"Key '{key}' not found in memory. Nothing to clear."
+
+        del self._memory[key]
+        return f"Cleared memory for key: '{key}'"

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/agent/tools/planning.py

@@ -22,7 +22,7 @@ class TodoItem(BaseModel):
     )
 
 
-@tool
+@tool(catch=True)
 def update_todo(todos: t.Annotated[list[TodoItem], "The full, updated list of todo items."]) -> str:
     """
     Use this tool to create and manage a structured task list for your current session.
@@ -30,7 +30,6 @@ def update_todo(todos: t.Annotated[list[TodoItem], "The full, updated list of to
     It also helps the user understand the progress of the task and overall progress of their requests.
 
     ## When to Use This Tool
-    Use this tool proactively in these scenarios:
 
     1. Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
     2. Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
@@ -42,7 +41,6 @@ def update_todo(todos: t.Annotated[list[TodoItem], "The full, updated list of to
 
     ## When NOT to Use This Tool
 
-    Skip using this tool when:
     1. There is only a single, straightforward task
     2. The task is trivial and tracking it provides no organizational benefit
     3. The task can be completed in less than 3 trivial steps
@@ -111,3 +109,28 @@ def update_todo(todos: t.Annotated[list[TodoItem], "The full, updated list of to
         f"{status_counts['in_progress']} in progress, "
         f"{status_counts['pending']} pending."
     )
+
+
+@tool
+def think(thought: str) -> None:
+    """
+    Records a thought, reflection, or plan to document your reasoning process.
+
+    This tool acts as your internal monologue, allowing you to articulate your strategy. Use it to:
+    - Break down a complex problem into smaller steps.
+    - Formulate a multi-step plan before you act.
+    - Interpret the results of another tool's output.
+    - Document a change in strategy (self-correction).
+
+    A clear chain of thought is essential for explaining your actions.
+
+    ## Best Practices
+    - Do Not Substitute for Action**: After thinking, you must call the appropriate \
+    tool to execute your plan. This tool performs no action on its own.
+    - Do Not Repeat Information**: Never use this to repeat the output of other tools. \
+    Use it to state your *conclusion* or *next step* based on that output.
+
+    Args:
+        thought: A clear, concise statement of your thought process or plan.
+    """
+    logger.info(f"Agent thought: {thought}")

dreadnode-1.15.2/dreadnode/agent/tools/reporting.py

@@ -0,0 +1,35 @@
+from loguru import logger
+
+from dreadnode.agent.tools.base import tool
+from dreadnode.data_types import Markdown
+
+
+@tool(catch=True)
+async def highlight_for_review(title: str, interest_level: str, justification: str) -> str:
+    """
+    Flag a finding for human review. Use this to surface leads that warrant further investigation.
+
+    This tool is essential for escalating findings that appear anomalous, valuable, or potentially
+    vulnerable. It creates a "lead" for a human operator to pick up.
+
+    Args:
+        title: A brief, descriptive summary of the finding.
+        interest_level: The priority of the finding. Must be one of:
+            - "high": Urgent. Potential for immediate impact or exploitation. (exposed credentials, pre-authentication vulnerability).
+            - "medium": Noteworthy. Suggests a potential weakness or area for deeper investigation. (debug endpoint, verbose error messages, PII exposure).
+            - "low": Informational. Provides useful context but is not an immediate risk. (software version disclosure, interesting file path).
+        justification: A technical, markdown-formatted explanation. Detail *why* the finding is interesting, what its potential impact is, and suggest next steps for a human analyst.
+    """
+    from dreadnode import log_metric, log_output, tag
+
+    interest_level = interest_level.lower().strip()
+    if interest_level not in ["high", "medium", "low"]:
+        interest_level = "medium"  # Default to medium if invalid
+
+    logger.success(f"Area of Interest - '{title}' [{interest_level}]:\n{justification}\n---")
+
+    tag(f"interest/{interest_level}")
+    log_output("markdown", Markdown(f"# {title} ({interest_level})\n\n{justification}"))
+    log_metric("count", 1, mode="count")
+
+    return "Highlighted."

dreadnode-1.15.2/dreadnode/agent/tools/tasking.py

@@ -0,0 +1,58 @@
+from loguru import logger
+
+from dreadnode.agent.reactions import Fail, Finish
+from dreadnode.agent.tools.base import tool
+
+
+@tool
+async def finish_task(success: bool, summary: str) -> None:  # noqa: ARG001, FBT001
+    """
+    Concludes the task by reporting a final status and a comprehensive summary.
+
+    This is the **final tool** to call when your planned sequence of actions is complete, \
+    regardless of whether the outcome was successful. Use it when you have no more \
+    steps to take and are ready to present a final report.
+
+    ## Best Practices
+    - Honest Status: The `success` flag must accurately reflect the final outcome. \
+    If any part of the task failed or objectives were not met, it must be `False`.
+    - Comprehensive Summary: The `summary` is your final report. It must be a complete, \
+    markdown-formatted document detailing all actions taken, tools used, and the results.
+
+    Args:
+        success: True if the task's objectives were fully met, False otherwise.
+        summary: A complete markdown-formatted report of all actions and outcomes.
+    """
+    from dreadnode import log_metric
+
+    log_func = logger.success if success else logger.warning
+    log_func(f"Agent finished the task (success={success})")
+    log_metric("task_success", success)
+
+    raise Finish if success else Fail("Agent marked the task as failed.")
+
+
+@tool
+async def give_up_on_task(reason: str) -> None:
+    """
+    Aborts the task when you are irrecoverably stuck and cannot make progress.
+
+    This tool is a last resort and should only be used when you have exhausted all \
+    possible strategies and alternative approaches. It signals that you were unable \
+    to complete your assigned process.
+
+    ## Best Practices
+    - Do Not Use for a Failed Outcome**: If the `finish_task` tool is available, use it to report failures. \
+    This tool is strictly for when you cannot *finish* your work.
+    - Provide a Clear Justification**: The `reason` must clearly explain why you are stuck. \
+    Detail the final obstacle you could not overcome and the approaches you already tried.
+
+    Args:
+        reason: A concise explanation of why you are unable to continue the task.
+    """
+    from dreadnode import log_metric
+
+    logger.warning(f"Agent gave up on the task: {reason}")
+    log_metric("task_give_up", 1)
+
+    raise Fail("Agent gave up on the task.")

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/cli/agent/cli.py

@@ -139,8 +139,6 @@ async def run(  # noqa: PLR0912, PLR0915
     agent_cli.__annotations__["config"] = config_annotation
 
     help_text = f"Run the '{agent_name}' agent."
-    if agent_blueprint.__doc__:
-        help_text += "\n\n" + agent_blueprint.__doc__
     if agent_blueprint.description:
         help_text += "\n\n" + agent_blueprint.description
 

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/cli/attack/cli.py

@@ -128,8 +128,6 @@ async def run(  # noqa: PLR0912, PLR0915
     attack_cli.__annotations__["config"] = config_annotation
 
     help_text = f"Run the '{attack_name}' attack."
-    if attack_blueprint.__doc__:
-        help_text += "\n\n" + attack_blueprint.__doc__
     if attack_blueprint.description:
         help_text += "\n\n" + attack_blueprint.description
 

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/cli/eval/cli.py

@@ -129,8 +129,6 @@ async def run(  # noqa: PLR0912, PLR0915
     eval_cli.__annotations__["config"] = config_annotation
 
     help_text = f"Run the '{eval_name}' eval."
-    if eval_blueprint.__doc__:
-        help_text += "\n\n" + eval_blueprint.__doc__
     if eval_blueprint.description:
         help_text += "\n\n" + eval_blueprint.description
 

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/cli/study/cli.py

@@ -130,8 +130,6 @@ async def run(  # noqa: PLR0912, PLR0915
     study_cli.__annotations__["config"] = config_annotation
 
     help_text = f"Run the '{study_name}' study."
-    if study_blueprint.__doc__:
-        help_text += "\n\n" + study_blueprint.__doc__
     if study_blueprint.description:
         help_text += "\n\n" + study_blueprint.description
 

{dreadnode-1.15.0 → dreadnode-1.15.2}/dreadnode/cli/task/cli.py

@@ -4,6 +4,7 @@ import itertools
 import typing as t
 from inspect import isawaitable
 from pathlib import Path
+from textwrap import dedent
 
 import cyclopts
 import rich
@@ -131,7 +132,7 @@ async def run(  # noqa: PLR0912, PLR0915
 
     help_text = f"Run the '{task_name}' task."
     if task_blueprint.__doc__:
-        help_text += "\n\n" + task_blueprint.__doc__
+        help_text += "\n\n" + dedent(task_blueprint.__doc__)
 
     task_app = cyclopts.App(
         name=task_name,