fix(beta): adapt ToolPolicyMiddleware to new ToolResult signature

ToolResult no longer accepts 'content' keyword; the constructor is now:
  ToolResult(*inputs, parts=(), final=False, metadata=None)

_make_tool_error simplified to one line via ToolErrorEvent.from_call:
  return ToolErrorEvent.from_call(event, PermissionError(reason))

Tests updated: .content assertions replaced with
  isinstance(error_event.error, PermissionError) + str(error_event.error)
checks, since ToolErrorEvent no longer carries a .content property.

Removed unused ToolResult import from tool_policy.py.

Addresses marklysze's CI-staleness review on #2533.

Author: amabito

autogen/beta/middleware/builtin/tool_policy.py

@@ -11,7 +11,6 @@
 from autogen.beta.annotations import Context
 from autogen.beta.events import BaseEvent, ToolCallEvent, ToolErrorEvent
 from autogen.beta.middleware.base import BaseMiddleware, MiddlewareFactory, ToolExecution, ToolResultType
-from autogen.beta.tools import ToolResult
 
 OnBlockedCallback = Callable[[ToolCallEvent, str], None]
 
@@ -38,16 +37,8 @@ def __post_init__(self) -> None:
 
 
 def _make_tool_error(event: ToolCallEvent, reason: str) -> ToolErrorEvent:
-    """Build a ToolErrorEvent with an explicit content string."""
-    err = ToolErrorEvent(
-        parent_id=event.id,
-        name=event.name,
-        result=ToolResult(content=None),
-        error=PermissionError(reason),
-    )
-    # Override content so it shows the reason, not a traceback.
-    err.content = reason
-    return err
+    """Build a ToolErrorEvent that carries the denial reason as a PermissionError."""
+    return ToolErrorEvent.from_call(event, PermissionError(reason))
 
 
 class _ToolPolicy:

test/beta/middleware/builtins/test_tool_policy_middleware.py

@@ -150,17 +150,17 @@ def test_blocklist_overrides_allowlist(self) -> None:
         assert not allowed
         assert "blocked" in reason
 
-    def test_tool_error_content_matches_reason(self) -> None:
+    def test_tool_error_reason_carried_as_permission_error(self) -> None:
         # Given a tool call that will be blocked
         event = _make_tool_call(name="delete_all")
         reason = "tool 'delete_all' is blocked"
 
         # When building the error event
         error_event = _make_tool_error(event, reason)
 
-        # Then the content equals the reason string, not "NoneType: None"
-        assert error_event.content == reason
-        assert "NoneType" not in error_event.content
+        # Then the error is a PermissionError whose message equals the denial reason
+        assert isinstance(error_event.error, PermissionError)
+        assert str(error_event.error) == reason
 
 
 # ---------------------------------------------------------------------------
@@ -236,7 +236,8 @@ async def call_next(event: ToolCallEvent, context: mock.MagicMock) -> ToolResult
 
         # Then enforcement still returns the policy denial
         assert isinstance(result, ToolErrorEvent)
-        assert result.content == "tool 'bad_tool' is blocked"
+        assert isinstance(result.error, PermissionError)
+        assert str(result.error) == "tool 'bad_tool' is blocked"
 
     @pytest.mark.asyncio()
     async def test_on_blocked_not_called_when_allowed(self) -> None: