Supporting no-code Guardrail creation (#2636)

* feat: support to define a guardrail task no-code

* feat: add auto-discovery for Guardrail code execution mode

* feat: handle malformed or invalid response from CodeInterpreterTool

* feat: allow to set unsafe_mode from Guardrail task

* feat: renaming GuardrailTask to TaskGuardrail

* feat: ensure guardrail is callable while initializing Task

* feat: remove Docker availability check from TaskGuardrail

The CodeInterpreterTool already ensures compliance with this requirement.

* refactor: replace if/raise with assert

For this use case `assert` is more appropriate choice

* test: remove useless or duplicated test

* fix: attempt to fix type-checker

* feat: support to define a task guardrail using YAML config

* refactor: simplify TaskGuardrail to use LLM for validation, no code generation

* docs: update TaskGuardrail doc strings

* refactor: drop task paramenter from TaskGuardrail

This parameter was used to get the model from the `task.agent` which is a quite bit redudant since we could propagate the llm directly

tests/test_task_guardrails.py

@@ -1,11 +1,16 @@
-"""Tests for task guardrails functionality."""
-
-from unittest.mock import Mock
+from unittest.mock import ANY, Mock, patch
 
 import pytest
 
-from crewai.task import Task
+from crewai import Agent, Task
+from crewai.llm import LLM
+from crewai.tasks.task_guardrail import TaskGuardrail
 from crewai.tasks.task_output import TaskOutput
+from crewai.utilities.events import (
+    TaskGuardrailCompletedEvent,
+    TaskGuardrailStartedEvent,
+)
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
 
 
 def test_task_without_guardrail():
@@ -22,7 +27,7 @@ def test_task_without_guardrail():
     assert result.raw == "test result"
 
 
-def test_task_with_successful_guardrail():
+def test_task_with_successful_guardrail_func():
     """Test that successful guardrail validation passes transformed result."""
 
     def guardrail(result: TaskOutput):
@@ -127,3 +132,138 @@ def test_guardrail_error_in_context():
 
     assert "Task failed guardrail validation" in str(exc_info.value)
     assert "Expected JSON, got string" in str(exc_info.value)
+
+
+@pytest.fixture
+def sample_agent():
+    return Agent(role="Test Agent", goal="Test Goal", backstory="Test Backstory")
+
+
+@pytest.fixture
+def task_output():
+    return TaskOutput(
+        raw="""
+        Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever
+        """,
+        description="Test task",
+        expected_output="Output",
+        agent="Test Agent",
+    )
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_task_guardrail_process_output(task_output):
+    guardrail = TaskGuardrail(
+        description="Ensure the result has less than 10 words", llm=LLM(model="gpt-4o")
+    )
+
+    result = guardrail(task_output)
+    assert result[0] is False
+
+    assert "exceeding the guardrail limit of fewer than" in result[1].lower()
+
+    guardrail = TaskGuardrail(
+        description="Ensure the result has less than 500 words", llm=LLM(model="gpt-4o")
+    )
+
+    result = guardrail(task_output)
+    assert result[0] is True
+    assert result[1] == task_output.raw
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_guardrail_emits_events(sample_agent):
+    started_guardrail = []
+    completed_guardrail = []
+
+    with crewai_event_bus.scoped_handlers():
+
+        @crewai_event_bus.on(TaskGuardrailStartedEvent)
+        def handle_guardrail_started(source, event):
+            started_guardrail.append(
+                {"guardrail": event.guardrail, "retry_count": event.retry_count}
+            )
+
+        @crewai_event_bus.on(TaskGuardrailCompletedEvent)
+        def handle_guardrail_completed(source, event):
+            completed_guardrail.append(
+                {
+                    "success": event.success,
+                    "result": event.result,
+                    "error": event.error,
+                    "retry_count": event.retry_count,
+                }
+            )
+
+        task = Task(
+            description="Gather information about available books on the First World War",
+            agent=sample_agent,
+            expected_output="A list of available books on the First World War",
+            guardrail="Ensure the authors are from Italy",
+        )
+
+        result = task.execute_sync(agent=sample_agent)
+
+        def custom_guardrail(result: TaskOutput):
+            return (True, "good result from callable function")
+
+        task = Task(
+            description="Test task",
+            expected_output="Output",
+            guardrail=custom_guardrail,
+        )
+
+        task.execute_sync(agent=sample_agent)
+
+        expected_started_events = [
+            {"guardrail": "Ensure the authors are from Italy", "retry_count": 0},
+            {"guardrail": "Ensure the authors are from Italy", "retry_count": 1},
+            {
+                "guardrail": """def custom_guardrail(result: TaskOutput):
+            return (True, "good result from callable function")""",
+                "retry_count": 0,
+            },
+        ]
+
+        expected_completed_events = [
+            {
+                "success": False,
+                "result": None,
+                "error": "The task result does not comply with the guardrail because none of "
+                "the listed authors are from Italy. All authors mentioned are from "
+                "different countries, including Germany, the UK, the USA, and others, "
+                "which violates the requirement that authors must be Italian.",
+                "retry_count": 0,
+            },
+            {"success": True, "result": result.raw, "error": None, "retry_count": 1},
+            {
+                "success": True,
+                "result": "good result from callable function",
+                "error": None,
+                "retry_count": 0,
+            },
+        ]
+        assert started_guardrail == expected_started_events
+        assert completed_guardrail == expected_completed_events
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_guardrail_when_an_error_occurs(sample_agent, task_output):
+    with (
+        patch(
+            "crewai.Agent.kickoff",
+            side_effect=Exception("Unexpected error"),
+        ),
+        pytest.raises(
+            Exception,
+            match="Error while validating the task output: Unexpected error",
+        ),
+    ):
+        task = Task(
+            description="Gather information about available books on the First World War",
+            agent=sample_agent,
+            expected_output="A list of available books on the First World War",
+            guardrail="Ensure the authors are from Italy",
+            max_retries=0,
+        )
+        task.execute_sync(agent=sample_agent)