dreadnode 2.0.38__tar.gz → 2.0.41__tar.gz

{dreadnode-2.0.38 → dreadnode-2.0.41}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: dreadnode
-Version: 2.0.38
+Version: 2.0.41
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io
@@ -11,7 +11,7 @@ Requires-Dist: aiofiles<25.0.0,>=24.1.0
 Requires-Dist: art<7.0.0,>=6.5
 Requires-Dist: aws-sdk-bedrock-runtime>=0.7.0; python_version >= '3.12'
 Requires-Dist: awscrt>=0.27.0; python_version >= '3.12'
-Requires-Dist: boto3>=1.40.0
+Requires-Dist: boto3<=1.41.5,>=1.40.0
 Requires-Dist: coolname<3.0.0,>=2.2.0
 Requires-Dist: croniter<7.0.0,>=6.0.0
 Requires-Dist: cyclopts>=4.2.0
@@ -24,6 +24,7 @@ Requires-Dist: gepa>=0.1.1
 Requires-Dist: httpx<1.0.0,>=0.28.0
 Requires-Dist: jsonpath-ng>=1.7.0
 Requires-Dist: jsonref>=1.1.0
+Requires-Dist: jsonschema>=4.26.0
 Requires-Dist: litellm<=1.84.0,>=1.84.0
 Requires-Dist: logfire<=3.20.0,>=3.5.3
 Requires-Dist: loguru>=0.7.3
@@ -42,12 +43,14 @@ Requires-Dist: pyarrow>=4.0.0
 Requires-Dist: pydantic-xml>=2.14.0
 Requires-Dist: pydantic<3.0.0,>=2.9.2
 Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: s3fs<=2025.10.0,>=2025.10.0
 Requires-Dist: scipy<2.0.0,>=1.11.0
 Requires-Dist: smithy-aws-core>=0.7.0; python_version >= '3.12'
 Requires-Dist: soundfile<1.0.0,>=0.13.1
 Requires-Dist: starlette<1.4.0,>=1.3.1
 Requires-Dist: textual>=8.0.2
 Requires-Dist: transformers>=4.57.1
+Requires-Dist: truststore<1.0.0,>=0.10.4
 Requires-Dist: uvicorn>=0.34.0
 Requires-Dist: websockets>=14.0
 Requires-Dist: xmltodict>=1.0.2
@@ -131,24 +134,27 @@ import dreadnode as dn
 
 dn.configure()
 
+
 # Define a tool
 @dn.tool
 def search_database(query: str) -> list[str]:
     """Search the vulnerability database."""
     return ["CVE-2024-1234", "CVE-2024-5678"]
 
+
 # Create an agent with tools
 @dn.agent(model="openai/gpt-4o", tools=[search_database])
 def security_analyst():
     """You are a security analyst. Find and analyze vulnerabilities."""
 
+
 # Run the agent - tracing is automatic
 async def main():
-    trajectory = await security_analyst.run(
-        "Analyze recent vulnerabilities in the database"
-    )
+    trajectory = await security_analyst.run("Analyze recent vulnerabilities in the database")
 
     print(f"Completed in {len(trajectory.steps)} steps")
+
+
 print(f"Token usage: {trajectory.usage.total_tokens}")
 ```
 
@@ -190,12 +196,14 @@ import dreadnode as dn
 from dreadnode import tool
 from dreadnode.core.agents.reactions import Finish, Continue
 
+
 # Tools with type hints
 @tool
 def scan_ports(host: str) -> list[int]:
     """Scan for open ports on a host."""
     return [22, 80, 443]  # Simplified example
 
+
 # Agent with configuration
 @dn.agent(
     model="anthropic/claude-3-5-sonnet",
@@ -205,6 +213,7 @@ def scan_ports(host: str) -> list[int]:
 def pentester():
     """You are a penetration tester. Find security issues."""
 
+
 # Hooks for control flow
 @pentester.hook
 async def check_progress(event):
@@ -212,6 +221,7 @@ async def check_progress(event):
         return Finish("Vulnerability discovered")
     return Continue()
 
+
 # Run the agent
 trajectory = await pentester.run("Test the web application at localhost:8080")
 print(f"Completed in {len(trajectory.steps)} steps")
@@ -354,6 +364,7 @@ import dreadnode as dn
 trajectory = await security_analyst.run("Analyze the target")
 # All steps, tool calls, and generations are traced
 
+
 # For custom task workflows, use explicit runs
 @dn.task
 async def analyze(target: str) -> dict:
@@ -363,6 +374,7 @@ async def analyze(target: str) -> dict:
     dn.log_metric("quality", 0.95)
     return result
 
+
 with dn.run(name="custom-analysis"):
     await analyze("webapp")
 ```

{dreadnode-2.0.38 → dreadnode-2.0.41}/README.md

@@ -42,24 +42,27 @@ import dreadnode as dn
 
 dn.configure()
 
+
 # Define a tool
 @dn.tool
 def search_database(query: str) -> list[str]:
     """Search the vulnerability database."""
     return ["CVE-2024-1234", "CVE-2024-5678"]
 
+
 # Create an agent with tools
 @dn.agent(model="openai/gpt-4o", tools=[search_database])
 def security_analyst():
     """You are a security analyst. Find and analyze vulnerabilities."""
 
+
 # Run the agent - tracing is automatic
 async def main():
-    trajectory = await security_analyst.run(
-        "Analyze recent vulnerabilities in the database"
-    )
+    trajectory = await security_analyst.run("Analyze recent vulnerabilities in the database")
 
     print(f"Completed in {len(trajectory.steps)} steps")
+
+
 print(f"Token usage: {trajectory.usage.total_tokens}")
 ```
 
@@ -101,12 +104,14 @@ import dreadnode as dn
 from dreadnode import tool
 from dreadnode.core.agents.reactions import Finish, Continue
 
+
 # Tools with type hints
 @tool
 def scan_ports(host: str) -> list[int]:
     """Scan for open ports on a host."""
     return [22, 80, 443]  # Simplified example
 
+
 # Agent with configuration
 @dn.agent(
     model="anthropic/claude-3-5-sonnet",
@@ -116,6 +121,7 @@ def scan_ports(host: str) -> list[int]:
 def pentester():
     """You are a penetration tester. Find security issues."""
 
+
 # Hooks for control flow
 @pentester.hook
 async def check_progress(event):
@@ -123,6 +129,7 @@ async def check_progress(event):
         return Finish("Vulnerability discovered")
     return Continue()
 
+
 # Run the agent
 trajectory = await pentester.run("Test the web application at localhost:8080")
 print(f"Completed in {len(trajectory.steps)} steps")
@@ -265,6 +272,7 @@ import dreadnode as dn
 trajectory = await security_analyst.run("Analyze the target")
 # All steps, tool calls, and generations are traced
 
+
 # For custom task workflows, use explicit runs
 @dn.task
 async def analyze(target: str) -> dict:
@@ -274,6 +282,7 @@ async def analyze(target: str) -> dict:
     dn.log_metric("quality", 0.95)
     return result
 
+
 with dn.run(name="custom-analysis"):
     await analyze("webapp")
 ```

{dreadnode-2.0.38 → dreadnode-2.0.41}/dreadnode/agents/agent.py

@@ -85,54 +85,53 @@ def _raise_exception(error: BaseException) -> t.NoReturn:
     raise error
 
 
-_TRANSIENT_LITELLM_EXCEPTION_NAMES: tuple[str, ...] = (
-    "RateLimitError",
-    "Timeout",
-    "APIConnectionError",
-    "APIConnectionTimeoutError",
-    "ServiceUnavailableError",
-    "InternalServerError",
-    "BadGatewayError",
-    "APIError",
-)
-
-
-def _is_transient_api_error(error: BaseException) -> bool:
-    """Classify an error as a transient LLM API failure worth retrying.
+def _is_retry_safe_api_error(error: BaseException) -> bool:
+    """Return whether an LLM API failure is safe to send again.
 
-    Matches an explicit allow-list of ``litellm.exceptions`` classes that
-    represent recoverable conditions: rate limits, timeouts, connection
-    failures, and 5xx responses. Notably **does not** match
-    ``BadRequestError``, ``AuthenticationError``,
-    ``ContextWindowExceededError`` (handled by overflow recovery), or other
-    deterministic client errors.
-
-    The allow-list is walked dynamically because ``litellm.exceptions`` does
-    not expose a single common ancestor for its transient exceptions.
-    Returns ``False`` if ``litellm`` is not importable.
+    Only explicit 429 admission failures are retryable. Timeouts, connection
+    failures, interrupted streams, and 5xx responses are ambiguous because the
+    provider may still be working on the original request.
     """
     with contextlib.suppress(ImportError):
         import litellm.exceptions as _litellm_exc
 
-        classes = tuple(
-            cls
-            for name in _TRANSIENT_LITELLM_EXCEPTION_NAMES
-            if (cls := getattr(_litellm_exc, name, None)) is not None
-        )
-        if classes and isinstance(error, classes):
+        rate_limit_cls = getattr(_litellm_exc, "RateLimitError", None)
+        if (
+            rate_limit_cls is not None
+            and isinstance(error, rate_limit_cls)
+            and getattr(error, "status_code", None) == 429
+        ):
             # 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 "insufficient_quota" not in str(error)
     return False
 
 
+def _is_tool_array_overflow(error: BaseException | None) -> bool:
+    """Whether ``error`` is an OpenAI/Azure rejection of too many tools.
+
+    OpenAI-family endpoints cap the ``tools`` array at 128 and 400 with
+    ``code: array_above_max_length`` when it is longer. Anthropic has no
+    such cap and never raises this, so matching the provider's own error
+    string keeps the prompt-serialized fallback scoped to models that
+    actually need it — Claude keeps native tool calling untouched.
+    """
+    if error is None:
+        return False
+    text = str(error)
+    cause = getattr(error, "__cause__", None) or getattr(error, "__context__", None)
+    if cause is not None:
+        text += " " + str(cause)
+    lowered = text.lower()
+    return (
+        "array_above_max_length" in lowered
+        or ("tools" in lowered and "array too long" in lowered)
+        or "maximum length 128" in lowered
+    )
+
+
 def _replayable(messages: list[Message]) -> list[Message]:
     """Drop assistant messages that carry nothing worth sending back.
 
@@ -205,9 +204,9 @@ class Agent(Executor[AgentEvent, Trajectory]):
     generate_params_extra: dict[str, t.Any] = Config(default_factory=dict)
     """Extra parameters merged into GenerateParams for every generation (e.g. thinking config)."""
     backoff_max_tries: int = Config(default=8, ge=0)
-    """Maximum retries on transient LLM API errors per step. ``0`` disables retry."""
+    """Maximum retries on retry-safe LLM admission failures per step. ``0`` disables retry."""
     backoff_max_time: float = Config(default=300.0, ge=0)
-    """Maximum total seconds to spend retrying transient LLM API errors per step."""
+    """Maximum total seconds to spend on retry-safe LLM attempts per step."""
     backoff_base_factor: float = Config(default=1.0, ge=0)
     """Base factor for exponential backoff: wait = base_factor * 2 ** (attempt - 1)."""
     backoff_jitter: bool = Config(default=True)
@@ -219,6 +218,10 @@ class Agent(Executor[AgentEvent, Trajectory]):
 
     # Private state
     _generator: Generator | None = PrivateAttr(None, init=False)
+    _tool_cap_exceeded: bool = PrivateAttr(False, init=False)
+    """Set once the provider has rejected the tool count (>128 for OpenAI/Azure)
+    so later turns serialize tools up front instead of retrying a doomed api
+    attempt. Write-once True - safe under concurrent run() calls."""
     _current_input: str = PrivateAttr("", init=False)
     _capability: tuple[str, str] | None = PrivateAttr(None, init=False)
     """The (name, version) capability this agent runs under, if any. Bound to
@@ -313,11 +316,17 @@ class Agent(Executor[AgentEvent, Trajectory]):
         """Get conversation history."""
         return self.trajectory.messages
 
-    def _get_transforms(self) -> list[Transform]:
-        """Resolve message transforms for the current configuration."""
+    def _get_transforms(self, tool_mode: ToolMode | None = None) -> list[Transform]:
+        """Resolve message transforms for the current configuration.
+
+        ``tool_mode`` overrides ``self.tool_mode`` for a single generation
+        without mutating shared state - used by the tool-overflow fallback so
+        concurrent ``run()`` calls on one Agent don't clobber each other.
+        """
+        tool_mode = tool_mode if tool_mode is not None else self.tool_mode
         transforms = []
         if self.tools:
-            match self.tool_mode:
+            match tool_mode:
                 case "xml":
                     transforms.append(
                         make_tools_to_xml_transform(self.all_tools, add_tool_stop_token=True)
@@ -334,6 +343,49 @@ class Agent(Executor[AgentEvent, Trajectory]):
 
     async def _generate(self, messages: list[Message]) -> Chat:
         """Execute a single LLM generation step."""
+        if self.tool_mode == "auto" and self.tools:
+            self.tool_mode = (
+                "api" if await self.generator.supports_function_calling() else "json-in-xml"
+            )
+
+        # Effective mode is local to this call - never mutate self.tool_mode for
+        # the fallback, or concurrent run() calls on one shared Agent (e.g.
+        # Evaluation(concurrency > 1)) would clobber each other's mode.
+        effective_mode = self.tool_mode
+        # Once any turn has hit the provider tool cap, serialize up front on
+        # later turns to skip a doomed api attempt. The flag is only ever set
+        # True, so concurrent writers are harmless.
+        if effective_mode == "api" and self.tools and self._tool_cap_exceeded:
+            effective_mode = "json-in-xml"
+
+        chat = await self._generate_once(messages, effective_mode)
+
+        # Non-degrading fallback for the OpenAI/Azure 128-tool ceiling.
+        # GPT-family endpoints 400 with `array_above_max_length` when the
+        # tools array exceeds 128; Claude has no such cap and never hits this.
+        # Retry once with prompt-serialized tools so the full tool surface
+        # stays available instead of failing the turn. Native api mode is
+        # preserved for every model that accepts the tool count. The retry is
+        # gated on the call-local ``effective_mode`` so a sibling call that
+        # flipped the flag can't make this one skip its own recovery.
+        if (
+            chat.failed
+            and effective_mode == "api"
+            and self.tools
+            and _is_tool_array_overflow(chat.error)
+        ):
+            logger.warning(
+                "Model '{}' rejected {} tool definitions (over provider cap); "
+                "retrying with prompt-serialized tools (json-in-xml)",
+                self.generator.model,
+                len(self.all_tools),
+            )
+            self._tool_cap_exceeded = True
+            chat = await self._generate_once(messages, "json-in-xml")
+
+        return chat
+
+    async def _generate_once(self, messages: list[Message], tool_mode: ToolMode) -> Chat:
         messages = list(messages)
         extra = dict(self.generate_params_extra) if self.generate_params_extra else {}
         params_kwargs: dict[str, t.Any] = {
@@ -344,12 +396,7 @@ class Agent(Executor[AgentEvent, Trajectory]):
             params_kwargs["extra"] = extra
         params = GenerateParams(**params_kwargs)
 
-        if self.tool_mode == "auto" and self.tools:
-            self.tool_mode = (
-                "api" if await self.generator.supports_function_calling() else "json-in-xml"
-            )
-
-        transforms = self._get_transforms()
+        transforms = self._get_transforms(tool_mode)
         post_transforms: list[PostTransform | None] = []
         for transform_callback in transforms:
             messages, params, post_transform = await transform_callback(messages, params)
@@ -468,11 +515,32 @@ class Agent(Executor[AgentEvent, Trajectory]):
             (name for name, r in hook_reactions.items() if r is winning_reaction), "unknown"
         )
 
+        reaction_messages: list[Message] = []
+        if isinstance(winning_reaction, RetryWithFeedback):
+            if winning_reaction.tool_call_id:
+                reaction_messages.append(
+                    Message(
+                        "tool",
+                        f"[POLICY DENIED] {winning_reaction.feedback}",
+                        tool_call_id=winning_reaction.tool_call_id,
+                        metadata=winning_reaction.metadata,
+                    )
+                )
+            else:
+                reaction_messages.append(
+                    Message(
+                        "user",
+                        winning_reaction.feedback,
+                        metadata=winning_reaction.metadata,
+                    )
+                )
+
         async for _event in self._dispatch(
             ReactStep(
                 agent_id=self.agent_id,
                 hook_name=winning_hook_name,
                 reaction=winning_reaction,
+                messages=reaction_messages,
             )
         ):
             yield _event
@@ -483,8 +551,7 @@ class Agent(Executor[AgentEvent, Trajectory]):
                 messages.append(Message("user", winning_reaction.feedback))
             raise Continue(messages=messages)
         if isinstance(winning_reaction, RetryWithFeedback):
-            messages = [Message("user", winning_reaction.feedback)]
-            raise Retry(messages=messages)
+            raise Continue(messages=reaction_messages)
 
         raise winning_reaction
 
@@ -495,10 +562,10 @@ class Agent(Executor[AgentEvent, Trajectory]):
         tries: int,
         start_time: float,
     ) -> float | None:
-        """Compute a retry sleep for a transient LLM API error.
+        """Compute a retry sleep for a retry-safe LLM admission failure.
 
         Returns the sleep duration in seconds if the caller should retry, or
-        ``None`` if the error is not transient, tries are exhausted, or the
+        ``None`` if the error is not retry-safe, tries are exhausted, or the
         per-step time budget has been spent. Caller owns sleeping and emitting
         the ``GenerationRetry`` event. Backoff is agent-owned at the error
         site, mirroring ``_try_overflow_recovery`` — no step is consumed and
@@ -507,7 +574,7 @@ class Agent(Executor[AgentEvent, Trajectory]):
         if self.backoff_max_tries <= 0:
             return None
 
-        if not _is_transient_api_error(error):
+        if not _is_retry_safe_api_error(error):
             return None
 
         if tries >= self.backoff_max_tries:
@@ -670,6 +737,7 @@ class Agent(Executor[AgentEvent, Trajectory]):
                     agent_name=self.name,
                     tool_call=tool_call,
                     error=NameError(error_msg),
+                    policy_decision=start_event.policy_decision,
                 )
                 error_event.emit(t_span)
                 async for event in self._dispatch(error_event):
@@ -678,6 +746,8 @@ class Agent(Executor[AgentEvent, Trajectory]):
                 message = Message.from_model(
                     SystemErrorModel(content=f"Tool '{tool_call.name}' not found.")
                 )
+                if start_event.policy_decision is not None:
+                    message.metadata["policy_decision"] = start_event.policy_decision
 
                 step_event = ToolStep(
                     agent_id=self.agent_id,
@@ -698,6 +768,9 @@ class Agent(Executor[AgentEvent, Trajectory]):
             try:
                 message, stop = await tool.handle_tool_call(tool_call)
 
+                if start_event.policy_decision is not None:
+                    message.metadata["policy_decision"] = start_event.policy_decision
+
                 # Tools that catch their own exceptions (bash non-zero,
                 # @tool(catch=True), MCP isError) lift the failure into
                 # message.metadata. Surface it on ToolEnd so renderers can
@@ -717,6 +790,7 @@ class Agent(Executor[AgentEvent, Trajectory]):
                     error=tool_error,
                     error_type=tool_error_type,
                     cost_usd=tool_cost_usd,
+                    policy_decision=start_event.policy_decision,
                 )
                 async for event in self._dispatch(end_event):
                     yield event
@@ -754,6 +828,7 @@ class Agent(Executor[AgentEvent, Trajectory]):
                     status="errored",
                     tool_call=tool_call,
                     error=e,
+                    policy_decision=start_event.policy_decision,
                 )
                 error_event.emit(t_span)
                 async for event in self._dispatch(error_event):
@@ -862,15 +937,13 @@ class Agent(Executor[AgentEvent, Trajectory]):
                     async for event in self._dispatch(gen_start):
                         yield event
 
+                    backoff_started = time.monotonic()
                     step_chat = await self._generate(messages)
 
-                    # In-place transient-error backoff — rate limits and
-                    # other litellm.APIError failures get retried at the
-                    # error site with exponential backoff. No step budget
-                    # consumed; clients observe GenerationRetry events
-                    # rather than a spurious terminal GenerationError.
+                    # In-place retry-safe backoff — only explicit 429 admission
+                    # failures are sent again. Ambiguous transport and provider
+                    # failures may still have active work, so they terminate.
                     backoff_tries = 0
-                    backoff_started = time.monotonic()
                     while step_chat.failed and step_chat.error:
                         wait = self._try_backoff(
                             step_chat.error,
@@ -1090,11 +1163,17 @@ class Agent(Executor[AgentEvent, Trajectory]):
                         """Run all tools and signal completion."""
                         nonlocal tool_execution_error
                         try:
+                            tool_calls = _messages[-1].tool_calls or []
+                            item_calls = [tc for tc in tool_calls if tc.name == "report_item"]
+                            other_calls = [tc for tc in tool_calls if tc.name != "report_item"]
+
+                            async def run_item_tools() -> None:
+                                for tool_call in item_calls:
+                                    await run_tool_with_queue(tool_call)
+
                             await asyncio.gather(
-                                *[
-                                    run_tool_with_queue(tc)
-                                    for tc in (_messages[-1].tool_calls or [])
-                                ]
+                                *(run_tool_with_queue(tc) for tc in other_calls),
+                                run_item_tools(),
                             )
                         except Exception as exc:
                             tool_execution_error = exc
@@ -1116,9 +1195,21 @@ class Agent(Executor[AgentEvent, Trajectory]):
                                 stopped_by_tool_call = event.tool_call
 
                     await tools_task  # Ensure task completes
-                    if tool_execution_error is not None:
-                        _raise_exception(tool_execution_error)
+                    # Always preserve completed tool results — even when
+                    # one tool was denied, other tools may have finished
+                    # and their results must stay in the conversation.
                     messages.extend(tool_messages)
+                    # A hook retry or continuation (including a ScopeGuard
+                    # denial) still completes this generation boundary. Defer
+                    # that reaction until after GenerationStep so the assistant
+                    # tool call is persisted and can be paired with feedback.
+                    deferred_reaction = (
+                        tool_execution_error
+                        if isinstance(tool_execution_error, (Continue, Retry))
+                        else None
+                    )
+                    if tool_execution_error is not None and deferred_reaction is None:
+                        _raise_exception(tool_execution_error)
 
                     # Emit GenerationEnd AFTER tools (closes generation span)
                     gen_end = GenerationEnd(
@@ -1158,6 +1249,9 @@ class Agent(Executor[AgentEvent, Trajectory]):
                         yield event
                     gen_event.emit(gen_span)  # Emit after dispatch - metrics attached
 
+                    if deferred_reaction is not None:
+                        _raise_exception(deferred_reaction)
+
                     if stopped_by_tool_call:
                         _raise_exception(
                             Finish(

{dreadnode-2.0.38 → dreadnode-2.0.41}/dreadnode/agents/events.py

@@ -456,6 +456,7 @@ class ToolStart(AgentEvent):
     """
 
     tool_call: ToolCall
+    policy_decision: dict[str, t.Any] | None = None
 
     def _get_data(self) -> dict[str, t.Any]:
         try:
@@ -468,6 +469,7 @@ class ToolStart(AgentEvent):
                 "name": self.tool_call.name,
                 "arguments": args,
             },
+            "policy_decision": self.policy_decision,
         }
 
     def __repr__(self) -> str:
@@ -542,6 +544,7 @@ class ToolEnd(AgentEvent):
     error: str | None = None
     error_type: str | None = None
     cost_usd: float | None = None
+    policy_decision: dict[str, t.Any] | None = None
     """Estimated USD cost contributed by this tool call, when the tool
     ran an internal LLM (e.g. ``spawn_agent``). ``None`` for ordinary
     tools — the TUI only accumulates this into the sub-agent cost
@@ -559,6 +562,7 @@ class ToolEnd(AgentEvent):
             "error": self.error,
             "error_type": self.error_type,
             "cost_usd": self.cost_usd,
+            "policy_decision": self.policy_decision,
         }
 
     def __repr__(self) -> str:
@@ -605,6 +609,7 @@ class ToolError(AgentEvent):
 
     tool_call: ToolCall
     error: SerializableError
+    policy_decision: dict[str, t.Any] | None = None
 
     def _get_data(self) -> dict[str, t.Any]:
         return {
@@ -614,6 +619,7 @@ class ToolError(AgentEvent):
             },
             "error": str(self.error),
             "error_type": type(self.error).__name__,
+            "policy_decision": self.policy_decision,
         }
 
     def emit(self, span: "TaskSpan") -> None:
@@ -1005,10 +1011,17 @@ class ReactStep(AgentStep):
             reaction_data["type"] = type(self.reaction).__name__
             if hasattr(self.reaction, "feedback"):
                 reaction_data["feedback"] = self.reaction.feedback
+            if hasattr(self.reaction, "tool_call_id"):
+                reaction_data["tool_call_id"] = self.reaction.tool_call_id
+            if hasattr(self.reaction, "metadata"):
+                reaction_data["metadata"] = self.reaction.metadata
             if hasattr(self.reaction, "reason"):
                 reaction_data["reason"] = self.reaction.reason
             if hasattr(self.reaction, "error"):
-                reaction_data["error"] = str(self.reaction.error)
+                error = self.reaction.error
+                reaction_data["error"] = str(error)
+                if isinstance(error, BaseException):
+                    reaction_data["error_type"] = type(error).__name__
         return {
             "hook_name": self.hook_name,
             "reaction": reaction_data,