fix: Resolve merge conflict and maintain organized imports

Co-Authored-By: Joe Moura <joao@crewai.com>

src/crewai/task.py

@@ -1,4 +1,5 @@
 import datetime
+import inspect
 import json
 import logging
 import threading
@@ -7,18 +8,7 @@ from concurrent.futures import Future
 from copy import copy
 from hashlib import md5
 from pathlib import Path
-from typing import (
-    Any,
-    Callable,
-    ClassVar,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    Union,
-)
+from typing import Any, Callable, ClassVar, Dict, List, Optional, Set, Tuple, Type, Union
 
 from opentelemetry.trace import Span
 from pydantic import (
@@ -124,6 +114,55 @@ class Task(BaseModel):
         default=None,
     )
     processed_by_agents: Set[str] = Field(default_factory=set)
+    guardrail: Optional[Callable[[TaskOutput], Tuple[bool, Any]]] = Field(
+        default=None,
+        description="Function to validate task output before proceeding to next task"
+    )
+    max_retries: int = Field(
+        default=3,
+        description="Maximum number of retries when guardrail fails"
+    )
+    retry_count: int = Field(
+        default=0,
+        description="Current number of retries"
+    )
+
+    @field_validator("guardrail")
+    @classmethod
+    def validate_guardrail_function(cls, v: Optional[Callable]) -> Optional[Callable]:
+        """Validate that the guardrail function has the correct signature and behavior.
+        
+        While type hints provide static checking, this validator ensures runtime safety by:
+        1. Verifying the function accepts exactly one parameter (the TaskOutput)
+        2. Checking return type annotations match Tuple[bool, Any] if present
+        3. Providing clear, immediate error messages for debugging
+        
+        This runtime validation is crucial because:
+        - Type hints are optional and can be ignored at runtime
+        - Function signatures need immediate validation before task execution
+        - Clear error messages help users debug guardrail implementation issues
+        
+        Args:
+            v: The guardrail function to validate
+            
+        Returns:
+            The validated guardrail function
+            
+        Raises:
+            ValueError: If the function signature is invalid or return annotation
+                       doesn't match Tuple[bool, Any]
+        """
+        if v is not None:
+            sig = inspect.signature(v)
+            if len(sig.parameters) != 1:
+                raise ValueError("Guardrail function must accept exactly one parameter")
+
+            # Check return annotation if present, but don't require it
+            return_annotation = sig.return_annotation
+            if return_annotation != inspect.Signature.empty:
+                if not (return_annotation == Tuple[bool, Any] or str(return_annotation) == 'Tuple[bool, Any]'):
+                    raise ValueError("If return type is annotated, it must be Tuple[bool, Any]")
+        return v
 
     _telemetry: Telemetry = PrivateAttr(default_factory=Telemetry)
     _execution_span: Optional[Span] = PrivateAttr(default=None)
@@ -268,7 +307,6 @@ class Task(BaseModel):
         )
 
         pydantic_output, json_output = self._export_output(result)
-
         task_output = TaskOutput(
             name=self.name,
             description=self.description,
@@ -279,6 +317,37 @@ class Task(BaseModel):
             agent=agent.role,
             output_format=self._get_output_format(),
         )
+
+        if self.guardrail:
+            guardrail_result = GuardrailResult.from_tuple(self.guardrail(task_output))
+            if not guardrail_result.success:
+                if self.retry_count >= self.max_retries:
+                    raise Exception(
+                        f"Task failed guardrail validation after {self.max_retries} retries. "
+                        f"Last error: {guardrail_result.error}"
+                    )
+
+                self.retry_count += 1
+                context = (
+                    f"### Previous attempt failed validation: {guardrail_result.error}\n\n\n"
+                    f"### Previous result:\n{task_output.raw}\n\n\n"
+                    "Try again, making sure to address the validation error."
+                )
+                return self._execute_core(agent, context, tools)
+
+            if guardrail_result.result is None:
+                raise Exception(
+                    "Task guardrail returned None as result. This is not allowed."
+                )
+
+            if isinstance(guardrail_result.result, str):
+                task_output.raw = guardrail_result.result
+                pydantic_output, json_output = self._export_output(guardrail_result.result)
+                task_output.pydantic = pydantic_output
+                task_output.json_dict = json_output
+            elif isinstance(guardrail_result.result, TaskOutput):
+                task_output = guardrail_result.result
+
         self.output = task_output
 
         self._set_end_execution_time(start_time)

src/crewai/tasks/guardrail_result.py

@@ -0,0 +1,56 @@
+"""
+Module for handling task guardrail validation results.
+
+This module provides the GuardrailResult class which standardizes
+the way task guardrails return their validation results.
+"""
+
+from typing import Any, Optional, Tuple, Union
+
+from pydantic import BaseModel, field_validator
+
+
+class GuardrailResult(BaseModel):
+    """Result from a task guardrail execution.
+
+    This class standardizes the return format of task guardrails,
+    converting tuple responses into a structured format that can
+    be easily handled by the task execution system.
+
+    Attributes:
+        success (bool): Whether the guardrail validation passed
+        result (Any, optional): The validated/transformed result if successful
+        error (str, optional): Error message if validation failed
+    """
+    success: bool
+    result: Optional[Any] = None
+    error: Optional[str] = None
+
+    @field_validator("result", "error")
+    @classmethod
+    def validate_result_error_exclusivity(cls, v: Any, info) -> Any:
+        values = info.data
+        if "success" in values:
+            if values["success"] and v and "error" in values and values["error"]:
+                raise ValueError("Cannot have both result and error when success is True")
+            if not values["success"] and v and "result" in values and values["result"]:
+                raise ValueError("Cannot have both result and error when success is False")
+        return v
+
+    @classmethod
+    def from_tuple(cls, result: Tuple[bool, Union[Any, str]]) -> "GuardrailResult":
+        """Create a GuardrailResult from a validation tuple.
+
+        Args:
+            result: A tuple of (success, data) where data is either
+                   the validated result or error message.
+
+        Returns:
+            GuardrailResult: A new instance with the tuple data.
+        """
+        success, data = result
+        return cls(
+            success=success,
+            result=data if success else None,
+            error=data if not success else None
+        )