dreadnode 2.0.33__tar.gz → 2.0.34__tar.gz

{dreadnode-2.0.33 → dreadnode-2.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 2.0.33
+Version: 2.0.34
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io
@@ -62,6 +62,11 @@ Requires-Dist: textstat<1.0.0,>=0.7.10; extra == 'all'
 Requires-Dist: torch>=2.9.0; extra == 'all'
 Provides-Extra: claude-code
 Requires-Dist: claude-agent-sdk>=0.1.0; extra == 'claude-code'
+Provides-Extra: nova-sonic
+Requires-Dist: aws-sdk-bedrock-runtime>=0.7.0; (python_version >= '3.12') and extra == 'nova-sonic'
+Requires-Dist: awscrt>=0.27.0; extra == 'nova-sonic'
+Requires-Dist: boto3>=1.40.0; extra == 'nova-sonic'
+Requires-Dist: smithy-aws-core>=0.7.0; (python_version >= '3.12') and extra == 'nova-sonic'
 Provides-Extra: scoring
 Requires-Dist: confusables<2.0.0,>=1.2.0; extra == 'scoring'
 Requires-Dist: nltk<4.0.0,>=3.9.1; extra == 'scoring'
@@ -379,6 +384,9 @@ pip install -U "dreadnode[scoring]"
 # Optional training and serving stack
 pip install -U "dreadnode[training]"
 
+# Amazon Nova Sonic speech-to-speech target (requires Python >=3.12)
+pip install -U "dreadnode[nova-sonic]"
+
 # All optional features
 pip install -U "dreadnode[all]"
 ```

{dreadnode-2.0.33 → dreadnode-2.0.34}/README.md

@@ -298,6 +298,9 @@ pip install -U "dreadnode[scoring]"
 # Optional training and serving stack
 pip install -U "dreadnode[training]"
 
+# Amazon Nova Sonic speech-to-speech target (requires Python >=3.12)
+pip install -U "dreadnode[nova-sonic]"
+
 # All optional features
 pip install -U "dreadnode[all]"
 ```

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/agents/agent.py

@@ -50,6 +50,7 @@ from dreadnode.agents.reactions import (
     Retry,
     RetryWithFeedback,
 )
+from dreadnode.agents.sanitize import sanitize_orphan_tool_messages
 from dreadnode.agents.tools import Tool, ToolCall, ToolMode, Toolset, discover_tools_on_obj
 from dreadnode.agents.trajectory import Trajectory
 from dreadnode.core.exceptions import warn_at_user_stacklevel
@@ -329,6 +330,12 @@ class Agent(Executor[AgentEvent, Trajectory]):
             messages, params, post_transform = await transform_callback(messages, params)
             post_transforms.append(post_transform)
 
+        # ENG-7343 / ENG-6214: general tool-call repair at the provider boundary.
+        # Strip orphan tool_results and synthesize placeholders for tool_use
+        # blocks whose results were lost (cancel mid-tool, compaction split).
+        # Anthropic + OpenAI both 400 on the orphan shape.
+        messages = sanitize_orphan_tool_messages(messages)
+
         try:
             if self.cache is not None and self.generator.supports_prompt_caching():
                 messages = caching.apply_cache_mode_to_messages(self.cache, [messages])[0]

dreadnode-2.0.34/dreadnode/agents/sanitize.py

@@ -0,0 +1,150 @@
+"""Trajectory sanitization for tool-call/tool-result integrity (ENG-7343, ENG-6214).
+
+Strict providers (Anthropic, OpenAI, and OpenAI-compatible gateways) reject
+requests whose tool-call structure is malformed. Mid-tool cancellation,
+compaction, session resume, and weak-model output can all produce shapes that
+400 the entire request and leave a session unrecoverable. This module is the
+single pre-provider chokepoint that repairs them.
+
+Two failure families, both surfacing as request-fatal 400s, are handled here:
+
+1. **Orphan pairs.** An assistant ``tool_call`` with no matching ``tool_result``
+   (or the inverse). Anthropic 400s with "unexpected tool_use_id ... must have a
+   corresponding tool_use block". Cause: cancel mid-tool, or compaction splitting
+   a pair across the summarization boundary.
+
+2. **Malformed tool_calls that the adapter silently drops.** A ``tool_call`` with
+   a blank ``function.name`` is dropped by Responses-API adapters while its
+   ``function_call_output`` survives, producing OpenAI's
+   "No tool call found for function call output with call_id ..." 400 — the same
+   symptom as (1) but a different root cause the orphan pass cannot see (the id
+   is present on both sides, so the pair *looks* complete). An empty
+   ``tool_calls`` array is likewise rejected by some gateways (DeepSeek). These
+   are normalized *before* the orphan analysis. Reference: hermes-agent
+   ``agent/agent_runtime_helpers.py`` pre-call sanitizer.
+
+None of these passes mutate the input messages or the persisted trajectory —
+repaired messages are shallow copies, so stored history and prompt caching stay
+byte-stable.
+"""
+
+from collections import Counter
+
+from loguru import logger
+
+from dreadnode.generators.message import Message
+
+_INTERRUPTED_TOOL_RESULT = "[Tool execution was interrupted]"
+# A blank tool-call name is invalid anyway; a non-empty sentinel keeps the call
+# paired with its result through Responses-API adapters that would otherwise drop
+# the nameless call and orphan its output.
+_EMPTY_NAME_SENTINEL = "invalid_tool_call"
+
+
+def _repair_tool_calls(messages: list[Message]) -> tuple[list[Message], int, int]:
+    """Normalize assistant ``tool_calls`` that strict providers reject.
+
+    - Empty ``tool_calls`` list → ``None`` (some gateways 400 on empty arrays).
+    - Blank ``function.name`` → ``_EMPTY_NAME_SENTINEL`` so the call is not
+      silently dropped by the adapter and orphaned from its output (ENG-7343).
+
+    Returns ``(messages, emptied, renamed)``. Never mutates the input.
+    """
+    result: list[Message] = []
+    emptied = 0
+    renamed = 0
+
+    for m in messages:
+        if m.role != "assistant" or not m.tool_calls:
+            # Collapse an empty (but non-None) tool_calls array to None.
+            if m.role == "assistant" and m.tool_calls is not None and not m.tool_calls:
+                result.append(m.model_copy(update={"tool_calls": None}))
+                emptied += 1
+            else:
+                result.append(m)
+            continue
+
+        new_calls = []
+        changed = False
+        for tc in m.tool_calls:
+            if (tc.function.name or "").strip():
+                new_calls.append(tc)
+                continue
+            new_calls.append(
+                tc.model_copy(
+                    update={
+                        "function": tc.function.model_copy(update={"name": _EMPTY_NAME_SENTINEL})
+                    }
+                )
+            )
+            renamed += 1
+            changed = True
+
+        result.append(m.model_copy(update={"tool_calls": new_calls}) if changed else m)
+
+    return result, emptied, renamed
+
+
+def sanitize_orphan_tool_messages(messages: list[Message]) -> list[Message]:
+    """Return ``messages`` with tool-call/result integrity restored.
+
+    Runs the malformed-tool_call repair, then resolves orphan pairs. Does not
+    mutate the input list. Idempotent: ``f(f(x)) == f(x)``.
+    """
+    messages, emptied, renamed = _repair_tool_calls(messages)
+
+    tool_use_ids: set[str] = {
+        tc.id for m in messages if m.role == "assistant" and m.tool_calls for tc in m.tool_calls
+    }
+    # A *count* of available results per id, not a set: duplicate or blank ids
+    # (weak models behind OpenAI-compatible gateways emit both) would collapse
+    # in a set, so a second same-id call whose result is missing would never be
+    # synthesized and reach the provider unmatched. Each call consumes one
+    # available result; a call with none left gets a synthesized result.
+    available_results: Counter[str] = Counter(
+        m.tool_call_id for m in messages if m.role == "tool" and m.tool_call_id is not None
+    )
+
+    result: list[Message] = []
+    synthesized = 0
+    stripped = 0
+
+    for m in messages:
+        if m.role == "tool" and m.tool_call_id is not None and m.tool_call_id not in tool_use_ids:
+            stripped += 1
+            continue
+
+        result.append(m)
+
+        if m.role == "assistant" and m.tool_calls:
+            for tc in m.tool_calls:
+                if available_results[tc.id] > 0:
+                    # Reserve one real result for this call; the rest of the loop
+                    # keeps it in place when it is reached.
+                    available_results[tc.id] -= 1
+                    continue
+                result.append(
+                    Message(
+                        role="tool",
+                        tool_call_id=tc.id,
+                        content=_INTERRUPTED_TOOL_RESULT,
+                    )
+                )
+                synthesized += 1
+
+    if synthesized or stripped or emptied or renamed:
+        # INFO, not DEBUG: any repair here means a malformed/orphan tool shape
+        # reached the provider boundary — a signal the compaction boundary
+        # detector, a cancel path, or a weak model let something through. We
+        # want to see this firing in the wild, not silently paper over it.
+        # See ENG-7343 / ENG-6551 Phase 2.
+        logger.info(
+            "sanitize_orphan_tool_messages: synthesized={}, stripped={}, "
+            "emptied_tool_calls={}, renamed_blank_tool_calls={}",
+            synthesized,
+            stripped,
+            emptied,
+            renamed,
+        )
+
+    return result

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/agents/subagent.py

@@ -11,6 +11,7 @@ from textwrap import dedent
 
 from loguru import logger
 
+from dreadnode.agents.events import AgentEnd
 from dreadnode.agents.tools import Toolset, tool_method
 from dreadnode.core.meta import Config
 from dreadnode.generators.message import Message
@@ -207,6 +208,21 @@ class SubAgentToolset(Toolset):
             logger.error(f"Sub-agent failed: {e}")
             return f"Sub-agent failed: {e}"
         else:
+            terminal_event = next(
+                (event for event in reversed(trajectory.events) if isinstance(event, AgentEnd)),
+                None,
+            )
+            if terminal_event is not None and terminal_event.error:
+                error_text = str(terminal_event.error)
+                logger.error(
+                    "Sub-agent ended with error | type={} | message={}",
+                    type(terminal_event.error).__name__
+                    if isinstance(terminal_event.error, BaseException)
+                    else "error",
+                    error_text,
+                )
+                return f"Sub-agent failed: {error_text}"
+
             # Get the last assistant message content as the response
             last_message = trajectory.messages[-1] if trajectory.messages else None
             response = str(last_message.content) if last_message else ""

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/agents/tools.py

@@ -121,8 +121,15 @@ class FunctionDefinition(BaseModel):
         if not isinstance(value, dict):
             return value
 
-        if value.get("type") == "object" and value.get("properties") == {}:
-            return None
+        # A function definition must always carry a parameters object with a
+        # `properties` key so it survives model_dump(exclude_none=True) and satisfies
+        # strict providers (e.g. Together, DeepInfra) that reject tool definitions
+        # missing the `parameters` field. Fill in an empty `properties` when absent
+        # while preserving any sibling schema keys (additionalProperties,
+        # patternProperties, required, $defs, ...) so free-form-map and strict
+        # no-arg schemas are not silently flattened.
+        if value.get("type") == "object" and not value.get("properties"):
+            return {**value, "properties": value.get("properties") or {}}
 
         return value
 

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/airt/assessment.py

@@ -138,6 +138,22 @@ class Assessment:
 
         self.target_config = target_config
         self.attacker_config = attacker_config
+
+        # Infer first-class model ids from the configs when not passed explicitly,
+        # so a user who only provides target_config / attacker_config still gets
+        # model metadata on the assessment header AND findings (mirrors the
+        # platform-side backfill). Keys match the capability/TUI convention.
+        if self.target_model is None and self.target_config:
+            self.target_model = self.target_config.get("model")
+        if self.attacker_model is None and self.attacker_config:
+            self.attacker_model = self.attacker_config.get("model") or self.attacker_config.get(
+                "attacker_model"
+            )
+        if self.judge_model is None and self.attacker_config:
+            self.judge_model = self.attacker_config.get(
+                "evaluator_model"
+            ) or self.attacker_config.get("judge")
+
         self._attack_manifest = attack_manifest
         self._workflow_run_id = workflow_run_id
         self._workflow_script = workflow_script
@@ -350,6 +366,15 @@ class Assessment:
             study.airt_category = self.goal_category
         if self.goal_category and not study.airt_sub_category:
             study.airt_sub_category = self.goal_category
+        # Propagate the assessment's model identifiers so findings carry the
+        # target/judge metadata without the caller passing airt_* kwargs to the
+        # attack factory (e.g. multimodal_attack, which the user builds directly).
+        if self.target_model and not study.airt_target_model:
+            study.airt_target_model = self.target_model
+        if self.judge_model and not study.airt_evaluator_model:
+            study.airt_evaluator_model = self.judge_model
+        if self.attacker_model and not study.airt_attacker_model:
+            study.airt_attacker_model = self.attacker_model
 
         from dreadnode.airt.analytics.types import GoalCategory
 

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/airt/targets/streaming/nova_sonic.py

@@ -12,12 +12,30 @@ dynamically. Auth is AWS IAM/SigV4 via the credential chain — no API key.
 import base64
 import contextlib
 import importlib
+import importlib.util
 import os
 import typing as t
 
 from dreadnode.core.task import Task, task
 from dreadnode.generators.message import ContentAudioInput, ContentText, Message
 
+_NOVA_DEPS = ("aws_sdk_bedrock_runtime", "awscrt", "smithy_aws_core")
+
+
+def _require_nova_deps() -> None:
+    """Fail fast if the Nova Sonic streaming deps are missing.
+
+    Called at target-construction time so a missing ``dreadnode[nova-sonic]``
+    stops the run up front instead of surfacing as a mid-stream error finding.
+    """
+    for mod in _NOVA_DEPS:
+        if importlib.util.find_spec(mod) is None:
+            raise RuntimeError(
+                "Nova Sonic speech-to-speech needs the optional streaming "
+                'dependencies. Install them with:  pip install "dreadnode[nova-sonic]"'
+                f"  (requires Python >=3.12). Missing module: {mod}."
+            )
+
 
 def _ensure_aws_credentials(region: str) -> None:
     """Resolve AWS credentials up front and seed the environment for Nova Sonic.
@@ -69,9 +87,12 @@ def nova_sonic_target(
     decodes to it). Streams it to Nova Sonic and returns a :class:`Message` with the
     model's spoken reply (audio) and its transcript (text).
 
-    Prerequisites (see docs): ``pip install aws-sdk-bedrock-runtime awscrt``, AWS
-    credentials (env vars / profile / role), and Nova Sonic model access in the region.
+    Prerequisites (see docs): ``pip install "dreadnode[nova-sonic]"`` (Python >=3.12),
+    AWS credentials (env vars / profile / role), and Nova Sonic model access in the region.
     """
+    # Fail fast at construction so a missing dependency doesn't register a doomed
+    # assessment that only errors mid-stream.
+    _require_nova_deps()
 
     async def target(message: Message) -> Message:
         pcm = _first_audio_pcm(message)
@@ -128,10 +149,17 @@ async def _roundtrip(
     # fast with a clear error instead of hanging on the Bedrock handshake.
     _ensure_aws_credentials(region)
 
-    bedrock = importlib.import_module("aws_sdk_bedrock_runtime.client")
-    models = importlib.import_module("aws_sdk_bedrock_runtime.models")
-    config_mod = importlib.import_module("aws_sdk_bedrock_runtime.config")
-    smithy_env = importlib.import_module("smithy_aws_core.identity.environment")
+    try:
+        bedrock = importlib.import_module("aws_sdk_bedrock_runtime.client")
+        models = importlib.import_module("aws_sdk_bedrock_runtime.models")
+        config_mod = importlib.import_module("aws_sdk_bedrock_runtime.config")
+        smithy_env = importlib.import_module("smithy_aws_core.identity.environment")
+    except ModuleNotFoundError as e:
+        raise RuntimeError(
+            "Nova Sonic speech-to-speech needs the optional streaming dependencies. "
+            'Install them with:  pip install "dreadnode[nova-sonic]"  (requires Python '
+            f">=3.12). Missing module: {e.name}."
+        ) from e
 
     prompt_id, sys_id, audio_id = (str(uuid.uuid4()) for _ in range(3))
     text_out: list[str] = []
@@ -161,9 +189,14 @@ async def _roundtrip(
         while not done.is_set():
             output = await stream.await_output()
             result = await output[1].receive()
-            if not (result.value and result.value.bytes_):
+            # `result` is a union of chunk + error types; only the chunk variant
+            # carries `.value.bytes_`. Access defensively so the type checker
+            # doesn't flag the error variants (which have no such attribute).
+            value = getattr(result, "value", None)
+            payload = getattr(value, "bytes_", None)
+            if not payload:
                 continue
-            ev = json.loads(result.value.bytes_.decode("utf-8")).get("event", {})
+            ev = json.loads(payload.decode("utf-8")).get("event", {})
             if "contentStart" in ev:
                 role["v"] = ev["contentStart"].get("role")
             elif "textOutput" in ev and role["v"] == "ASSISTANT":

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/app/api/client.py

@@ -172,8 +172,20 @@ class ApiClient:
         json_data: dict[str, t.Any] | None = None,
         data: dict[str, t.Any] | None = None,
         headers: dict[str, str] | None = None,
+        *,
+        timeout: float | None = None,
     ) -> httpx.Response:
         """Make a raw HTTP request without raising on errors."""
+        if timeout is not None:
+            return self._client.request(
+                method,
+                path,
+                params=params,
+                json=json_data,
+                data=data,
+                headers=headers,
+                timeout=timeout,
+            )
         return self._client.request(
             method,
             path,
@@ -191,9 +203,22 @@ class ApiClient:
         json_data: dict[str, t.Any] | None = None,
         data: dict[str, t.Any] | None = None,
         headers: dict[str, str] | None = None,
+        *,
+        timeout: float | None = None,
     ) -> httpx.Response:
         """Make an HTTP request and raise on errors."""
-        response = self._request(method, path, params, json_data, data, headers)
+        if timeout is None:
+            response = self._request(method, path, params, json_data, data, headers)
+        else:
+            response = self._request(
+                method,
+                path,
+                params,
+                json_data,
+                data,
+                headers,
+                timeout=timeout,
+            )
         if response.status_code == 401:
             raise AuthenticationError(self._get_error_message(response))
         if response.status_code == 404:
@@ -2249,10 +2274,20 @@ class ApiClient:
         response = self.request("GET", f"/org/{org}/capabilities/facets", params=params)
         return t.cast("dict[str, t.Any]", response.json())
 
-    def list_capability_versions(self, org: str, name: str) -> dict[str, t.Any]:
+    def list_capability_versions(
+        self,
+        org: str,
+        name: str,
+        *,
+        timeout: float | None = None,
+    ) -> dict[str, t.Any]:
         """GET /org/{org}/capabilities/{name}/versions - List all versions."""
         safe_name = _url_quote(name, safe="")
-        response = self.request("GET", f"/org/{org}/capabilities/{safe_name}/versions")
+        response = self.request(
+            "GET",
+            f"/org/{org}/capabilities/{safe_name}/versions",
+            timeout=timeout,
+        )
         return t.cast("dict[str, t.Any]", response.json())
 
     def get_capability(self, org: str, name: str, version: str | None = None) -> dict[str, t.Any]:

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/app/cli/evaluation.py

@@ -670,6 +670,16 @@ def create(
     ] = None,
     concurrency: int | None = None,
     task_timeout_sec: int | None = None,
+    max_steps: t.Annotated[
+        int | None,
+        cyclopts.Parameter(
+            help=(
+                "Maximum agent tool/generation steps per sample. "
+                "Enforced via a headless session policy; the task timeout "
+                "still applies as a wall-clock bound."
+            ),
+        ),
+    ] = None,
     cleanup_policy: CleanupPolicy | None = None,
     judge_model: str | None = None,
     env_model: t.Annotated[
@@ -726,6 +736,9 @@ def create(
             `dn secret list` to discover configured names.
         concurrency: Maximum concurrent evaluation samples.
         task_timeout_sec: Timeout per task in seconds.
+        max_steps: Maximum agent tool/generation steps per sample.
+            Enforced via a headless session policy; the task timeout still
+            applies as a wall-clock bound.
         cleanup_policy: Sandbox cleanup policy.
         judge_model: Override the judge model for all tasks in this evaluation.
         wait: Block until the evaluation reaches a terminal state.
@@ -758,6 +771,8 @@ def create(
         request["concurrency"] = concurrency
     if task_timeout_sec is not None:
         request["task_timeout_sec"] = task_timeout_sec
+    if max_steps is not None:
+        request["max_steps"] = max_steps
     if cleanup_policy:
         request["cleanup_policy"] = cleanup_policy
     if judge_model:

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/app/client/transports.py

@@ -122,6 +122,7 @@ class StreamingASGITransport(httpx.AsyncBaseTransport):
         if tasks:
             await asyncio.gather(*tasks, return_exceptions=True)
         await loop.shutdown_asyncgens()
+        await loop.shutdown_default_executor()
 
     async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
         server_loop = self.require_server_loop()

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/app/server/app.py

@@ -657,6 +657,9 @@ async def server_lifecycle() -> t.AsyncIterator[None]:
     try:
         yield
     finally:
+        if not synchronous:
+            with suppress(Exception):
+                await asyncio.wait_for(asyncio.shield(warm_future), timeout=2)
         # Workers stop BEFORE MCP teardown
         if registry and registry.worker_manager:
             await registry.worker_manager.stop()
@@ -4327,7 +4330,7 @@ def _check_capability_updates(
     ) -> tuple[str, str | None, str]:
         identity, owner, name, installed_ver, _source = item
         try:
-            resp = api.list_capability_versions(owner, name)
+            resp = api.list_capability_versions(owner, name, timeout=timeout)
             latest = resp.get("latest")
             if isinstance(latest, dict):
                 return identity, latest.get("version"), installed_ver
@@ -4356,7 +4359,7 @@ def _check_capability_updates(
     except Exception:
         logger.debug("Capability update check failed", exc_info=True)
     finally:
-        executor.shutdown(wait=False, cancel_futures=True)
+        executor.shutdown(wait=True, cancel_futures=True)
 
     return updates
 

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/app/tui/app.py

@@ -3643,12 +3643,13 @@ class DreadnodeTextualApp(App[None]):
             "expanded" if self.output_mode == "compact" else "compact"
         )
         self.output_mode = new_mode
-        from dreadnode.app.tui.widgets.conversation import CompactionSummary
+        from dreadnode.app.tui.widgets.conversation import CompactionSummary, ThinkingBlock
         from dreadnode.app.tui.widgets.tool import ToolCall as ToolCallWidget
 
-        # ^O controls tool-output verbosity only. Reasoning (ThinkingBlock) is a
-        # separate concern shown inline regardless of this toggle (ENG-6108), so
-        # it is intentionally not touched here.
+        # ^O drives every expandable surface: tool output, compaction summaries,
+        # and reasoning. Reasoning was previously excluded (ENG-6108) but that
+        # left long traces filling the viewport with no way to shorten them, so
+        # ^O now shortens/expands ThinkingBlocks too (ENG-7463).
         try:
             conv = self.query_one("#conversation", ConversationView)
             for tc in conv.query(ToolCallWidget):
@@ -3656,6 +3657,8 @@ class DreadnodeTextualApp(App[None]):
             expanded = new_mode == "expanded"
             for cs in conv.query(CompactionSummary):
                 cs.display = expanded
+            for tb in conv.query(ThinkingBlock):
+                tb.set_output_mode(new_mode)
         except Exception:
             logger.debug("Could not refresh output mode widgets")
         self._flash(f"Output: {new_mode}", severity="info")

{dreadnode-2.0.33 → dreadnode-2.0.34}/dreadnode/app/tui/capabilities_manager.py

@@ -224,6 +224,7 @@ class CapabilitiesManager:
                             "description": agent.description or "",
                             "model": agent.model or "inherit",
                             "capability": cap.name,
+                            "capability_version": getattr(cap, "version", None) or "",
                         }
                     )
                     seen.add(agent.name)