dreadnode 2.0.23__tar.gz → 2.0.25__tar.gz

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

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

{dreadnode-2.0.23 → dreadnode-2.0.25}/dreadnode/agents/agent.py

@@ -118,7 +118,16 @@ def _is_transient_api_error(error: BaseException) -> bool:
             if (cls := getattr(_litellm_exc, name, None)) is not None
         )
         if classes and isinstance(error, classes):
-            return True
+            # OpenAI returns 429 with code "insufficient_quota" when the
+            # account is out of credits — a permanent billing condition,
+            # not a rate limit. litellm packs the provider body into the
+            # message verbatim, so substring-match to exclude.
+            rate_limit_cls = getattr(_litellm_exc, "RateLimitError", None)
+            return not (
+                rate_limit_cls is not None
+                and isinstance(error, rate_limit_cls)
+                and "insufficient_quota" in str(error)
+            )
     return False
 
 

{dreadnode-2.0.23 → dreadnode-2.0.25}/dreadnode/agents/skills.py

@@ -348,9 +348,9 @@ def discover_skills(directory: Path | None = None) -> list[Skill]:
                 try:
                     skill = load_skill(skill_file)
                     skills.append(skill)
-                    logger.debug(f"Discovered skill: {skill.name} at {skill_file}")
+                    logger.debug("Discovered skill: {} at {}", skill.name, skill_file)
                 except Exception as e:
-                    logger.warning(f"Failed to load skill from {skill_file}: {e}")
+                    logger.error("Failed to load skill from {}: {}", skill_file, e)
 
     return skills
 
@@ -515,7 +515,7 @@ def create_skill_tool(skills: list[Skill]) -> t.Any:
     examples = ", ".join(f"'{s.qualified_id}'" for s in skills[:3])
     hint = f" (e.g., {examples}, ...)" if examples else ""
 
-    @tool(catch=True, description=description)
+    @tool(description=description)
     async def skill(
         name: t.Annotated[str, f"The name of the skill from available_skills{hint}"],
     ) -> str:

{dreadnode-2.0.23 → dreadnode-2.0.25}/dreadnode/agents/subagent.py

@@ -95,7 +95,7 @@ class SubAgentToolset(Toolset):
     run_in_background: bool = Config(default=False)
     """Whether to run sub-agents in background (not yet implemented)."""
 
-    @tool_method(catch=True)
+    @tool_method
     async def spawn_agent(
         self,
         task: t.Annotated[str, "The task for the sub-agent to complete"],

{dreadnode-2.0.23 → dreadnode-2.0.25}/dreadnode/agents/tools.py

@@ -288,15 +288,13 @@ class Tool(BaseModel, t.Generic[P, R]):
         exclude=True,
     )
     """The function to call."""
-    catch: bool | t.Iterable[type[Exception]] = set(DEFAULT_CATCH_EXCEPTIONS)
+    catch: bool | t.Iterable[type[Exception]] = True
     """
     Whether to catch exceptions and return them as messages.
 
     - `False`: Do not catch exceptions.
-    - `True`: Catch all exceptions.
+    - `True`: Catch all exceptions (default).
     - `set[type[Exception]]`: Catch only the specified exceptions.
-
-    By default, catches `json.JSONDecodeError` and `ValidationError`.
     """
     truncate: int | None = None
     """If set, the maximum number of characters to truncate any tool output to."""
@@ -386,7 +384,7 @@ class Tool(BaseModel, t.Generic[P, R]):
             description=description,
             parameters_schema=schema,
             fn=fn,
-            catch=catch or DEFAULT_CATCH_EXCEPTIONS,
+            catch=True if catch is None else catch,
             truncate=truncate,
             offload=offload if offload is not None else True,
         )
@@ -471,8 +469,15 @@ class Tool(BaseModel, t.Generic[P, R]):
                 kwargs = self._type_adapter.validate_python(kwargs)
             kwargs = kwargs or {}
 
-            # Call the function
-            result = self.fn(**kwargs)  # ty: ignore[missing-argument]  # ParamSpec limitation
+            # Call the function. Sync tools are offloaded to a worker thread
+            # so blocking work (subprocess.run, network, large file I/O) does
+            # not stall the event loop — the TUI shares that loop with input
+            # parsing, and a multi-second block desyncs Textual's escape-
+            # sequence parser, leaking raw mouse/key bytes into the composer.
+            if inspect.iscoroutinefunction(self.fn):
+                result = self.fn(**kwargs)  # ty: ignore[missing-argument]  # ParamSpec limitation
+            else:
+                result = await asyncio.to_thread(self.fn, **kwargs)  # ParamSpec limitation
             if inspect.isawaitable(result):
                 result = await result
 
@@ -596,9 +601,9 @@ class Tool(BaseModel, t.Generic[P, R]):
             description: The description of the tool.
             catch: Whether to catch exceptions and return them as messages.
                 - `False`: Do not catch exceptions.
-                - `True`: Catch all exceptions.
+                - `True`: Catch all exceptions (default).
                 - `list[type[Exception]]`: Catch only the specified exceptions.
-                - `None`: By default, catches `json.JSONDecodeError` and `ValidationError
+                - `None`: Use the default (`True`)
             truncate: If set, the maximum number of characters to truncate any tool output to.
             offload: Whether large tool outputs should be offloaded to disk.
 
@@ -667,7 +672,7 @@ class ToolMethod(property, t.Generic[P, R]):
                 name=self.tool_name,
                 description=self.tool_description,
                 parameters_schema=self.tool_parameters_schema,
-                catch=self.tool_catch or DEFAULT_CATCH_EXCEPTIONS,
+                catch=True if self.tool_catch is None else self.tool_catch,
                 truncate=self.tool_truncate,
             )
             tool._signature = self._tool_signature
@@ -681,7 +686,7 @@ class ToolMethod(property, t.Generic[P, R]):
             name=self.tool_name,
             description=self.tool_description,
             parameters_schema=self.tool_parameters_schema,
-            catch=self.tool_catch or DEFAULT_CATCH_EXCEPTIONS,
+            catch=True if self.tool_catch is None else self.tool_catch,
             truncate=self.tool_truncate,
         )
         bound_tool._signature = self._tool_signature
@@ -835,9 +840,9 @@ def tool(
         description: The description of the tool.
         catch: Whether to catch exceptions and return them as messages.
             - `False`: Do not catch exceptions.
-            - `True`: Catch all exceptions.
+            - `True`: Catch all exceptions (default).
             - `list[type[Exception]]`: Catch only the specified exceptions.
-            - `None`: By default, catches `json.JSONDecodeError` and `ValidationError`.
+            - `None`: Use the default (`True`).
         truncate: If set, the maximum number of characters to truncate any tool output to.
 
     Returns:
@@ -908,9 +913,9 @@ def tool_method(
         description: Override the tool's description. Defaults to the docstring.
         catch: Whether to catch exceptions and return them as messages.
             - `False`: Do not catch exceptions.
-            - `True`: Catch all exceptions.
+            - `True`: Catch all exceptions (default).
             - `list[type[Exception]]`: Catch only the specified exceptions.
-            - `None`: By default, catches `json.JSONDecodeError` and `ValidationError`.
+            - `None`: Use the default (`True`).
         truncate: The maximum number of characters for the tool's output.
     """
 

{dreadnode-2.0.23 → dreadnode-2.0.25}/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
@@ -106,9 +128,12 @@ class Assessment:
         self.judge_model = judge_model or model
 
         if target_config is None and model is not None:
-            target_config = {"model": model}
+            target_config = {"model": self.target_model or model}
         if attacker_config is None and model is not None:
-            attacker_config = {"model": model, "evaluator_model": model}
+            attacker_config = {
+                "model": self.attacker_model or model,
+                "evaluator_model": self.judge_model or model,
+            }
 
         self.target_config = target_config
         self.attacker_config = attacker_config
@@ -116,6 +141,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 +203,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 +218,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 +445,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 +502,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 +542,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 +570,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.23 → dreadnode-2.0.25}/dreadnode/app/cli/airt.py

@@ -65,7 +65,7 @@ def _parse_json_object_option(value: str | None, *, field_name: str) -> dict[str
 
 
 def _resolve_project_id(api, profile, project):
-    """Resolve project name to UUID."""
+    """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)
@@ -83,9 +83,25 @@ def _resolve_project_id(api, profile, project):
     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
+    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 = {
@@ -1150,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()
 
@@ -1175,25 +1194,46 @@ 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 DEFAULT_INSTANCE
 
-        DEFAULT_INSTANCE.configure(
-            server=profile.url,
-            api_key=profile.api_key,
-            organization=profile.organization,
-            workspace=profile.workspace,
-            project=profile.project,
-        )
+        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
-        # Get project from environment if profile.project is None
+        # Use original CLI argument, fallback to profile, environment, then 'default'
         import os
 
         env_project = os.getenv("DREADNODE_PROJECT")
-        actual_project = profile.project or env_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
@@ -1203,6 +1243,9 @@ def run(
             description=f"CLI attack: {goal}",
             target=target_fn,
             model=atk_model,
+            target_model=target_model,
+            attacker_model=atk_model,
+            judge_model=eval_model,
             goal=goal,
             goal_category=goal_category,
             project_id=final_project_id,
@@ -1332,24 +1375,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
 
-        DEFAULT_INSTANCE.configure(
-            server=profile.url,
-            api_key=profile.api_key,
-            organization=profile.organization,
-            workspace=profile.workspace,
-            project=profile.project,
-        )
+        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):
@@ -1362,11 +1429,11 @@ 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
+            # Use original CLI argument, then environment variable as fallback
             import os
 
             env_project = os.getenv("DREADNODE_PROJECT")
-            actual_project = profile.project or env_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
@@ -1376,6 +1443,9 @@ def run_suite(
                 description=f"Suite run: {goal_text}",
                 target=target_fn,
                 model=atk_model,
+                target_model=model,
+                attacker_model=atk_model,
+                judge_model=atk_model,
                 goal=goal_text,
                 goal_category=goal_cat,
                 project_id=final_project_id,

{dreadnode-2.0.23 → dreadnode-2.0.25}/dreadnode/app/cli/capability.py

@@ -1398,15 +1398,22 @@ def validate(
             cap = Capability(cap_dir)
             agents = cap.agents
             tools = cap.tools
-            skills = cap.skills_paths or []
             mcp = cap.mcp_server_defs
             workers = cap.worker_defs
 
             health_errors = [h for h in cap.component_health if h.get("status") == "error"]
+            # Count loadable skills (one SKILL.md per skill), not manifest path
+            # entries — `skills_paths` is a list of search roots and overstates
+            # the count, especially when entries fail to parse.
+            skill_count = sum(
+                1
+                for h in cap.component_health
+                if h.get("kind") == "skill" and h.get("status") == "ok"
+            )
 
             summary = (
                 f"agents={len(agents)}, tools={len(tools)}, "
-                f"skills={len(skills)}, mcp={len(mcp)}, workers={len(workers)}"
+                f"skills={skill_count}, mcp={len(mcp)}, workers={len(workers)}"
             )
 
             if health_errors:

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

@@ -513,13 +513,6 @@ class RuntimeClient:
         response.raise_for_status()
         return models.SessionInfo.from_dict(response.json())
 
-    async def reset_session(self, session_id: str) -> None:
-        """Reset a server session."""
-        logger.info("Resetting session | session_id={}", session_id[:8])
-        await self.start()
-        response = await self._http_client.post(f"/api/sessions/{session_id}/reset")
-        response.raise_for_status()
-
     async def set_session_title(self, session_id: str, title: str) -> None:
         """Persist a session title on the server."""
         logger.info("Setting session title | session_id={}", session_id[:8])

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

@@ -2201,16 +2201,6 @@ class SessionRuntime:
         """Async wrapper around ``_persist_state`` with per-session locking."""
         await self.persistence.persist_state_locked(update_messages=update_messages)
 
-    def reset(self, *, persist: bool = True) -> None:
-        """Reset the conversation history."""
-        from dreadnode.agents.trajectory import Trajectory as TrajectoryModel
-
-        self._trajectory = TrajectoryModel()
-        self._message_count = 0
-        self._agent = None
-        if persist:
-            self._persist_state()
-
     def restore_messages(
         self,
         messages: list[SessionMessage],
@@ -3216,16 +3206,6 @@ async def set_session_policy(session_id: str, body: dict[str, t.Any]) -> JSONRes
     )
 
 
-@app.post("/api/sessions/{session_id}/reset")
-async def reset_session(session_id: str) -> JSONResponse:
-    """Reset the agent conversation."""
-    session = get_state().get_session(session_id)
-    if session is None:
-        raise HTTPException(status_code=404, detail=f"Session not found: {session_id}")
-    session.reset()
-    return JSONResponse(content={"status": "reset", "session_id": session_id})
-
-
 @app.post("/api/sessions/{session_id}/cancel")
 async def cancel_session(session_id: str) -> JSONResponse:
     """Cancel the active turn and drain queued requests for a session."""
@@ -3897,7 +3877,10 @@ def _populate_registry(instance: t.Any) -> None:
     """Discover capabilities and install them into app state."""
     from dreadnode.builtin_capabilities import load_builtin_capabilities
     from dreadnode.capabilities import Capability
-    from dreadnode.capabilities.capability import read_local_capability_records
+    from dreadnode.capabilities.capability import (
+        read_local_capability_records,
+        read_local_capability_state,
+    )
 
     state = get_state()
     registry = capability_manager.CapabilityRegistry()
@@ -3975,6 +3958,18 @@ def _populate_registry(instance: t.Any) -> None:
     except Exception:
         logger.exception("Failed to discover capabilities")
 
+    # Bundled caps don't flow through Capability.discover(), so the
+    # disabled-state filter that runs inside discover() never touches
+    # them — they'd always load as active regardless of
+    # local-capability-state.json. Apply the same filter here so the
+    # toggle is honored. The default capability is pinned active.
+    bundled_state = read_local_capability_state(instance.storage.local_capability_state_path)
+    for name in list(registry.capabilities):
+        if name == _BUNDLED_DEFAULT_CAPABILITY:
+            continue
+        if bundled_state.get(name, True) is False:
+            registry.disabled_local[name] = registry.capabilities.pop(name)
+
     if instance.can_sync:
         try:
             registry.update_info = _check_capability_updates(