Refactor event base classes (#2491)

- Renamed `CrewEvent` to `BaseEvent` across the codebase for consistency
- Created a `CrewBaseEvent` that automatically identifies fingerprints for DRY
- Added a new `to_json()` method for serializing events

src/crewai/utilities/events/agent_events.py

@@ -4,13 +4,13 @@ from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.tools.base_tool import BaseTool
 from crewai.tools.structured_tool import CrewStructuredTool
 
-from .base_events import CrewEvent
+from .base_events import BaseEvent
 
 if TYPE_CHECKING:
     from crewai.agents.agent_builder.base_agent import BaseAgent
 
 
-class AgentExecutionStartedEvent(CrewEvent):
+class AgentExecutionStartedEvent(BaseEvent):
     """Event emitted when an agent starts executing a task"""
 
     agent: BaseAgent
@@ -24,14 +24,17 @@ class AgentExecutionStartedEvent(CrewEvent):
     def __init__(self, **data):
         super().__init__(**data)
         # Set fingerprint data from the agent
-        if hasattr(self.agent, 'fingerprint') and self.agent.fingerprint:
+        if hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
             self.source_fingerprint = self.agent.fingerprint.uuid_str
             self.source_type = "agent"
-            if hasattr(self.agent.fingerprint, 'metadata') and self.agent.fingerprint.metadata:
+            if (
+                hasattr(self.agent.fingerprint, "metadata")
+                and self.agent.fingerprint.metadata
+            ):
                 self.fingerprint_metadata = self.agent.fingerprint.metadata
 
 
-class AgentExecutionCompletedEvent(CrewEvent):
+class AgentExecutionCompletedEvent(BaseEvent):
     """Event emitted when an agent completes executing a task"""
 
     agent: BaseAgent
@@ -42,14 +45,17 @@ class AgentExecutionCompletedEvent(CrewEvent):
     def __init__(self, **data):
         super().__init__(**data)
         # Set fingerprint data from the agent
-        if hasattr(self.agent, 'fingerprint') and self.agent.fingerprint:
+        if hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
             self.source_fingerprint = self.agent.fingerprint.uuid_str
             self.source_type = "agent"
-            if hasattr(self.agent.fingerprint, 'metadata') and self.agent.fingerprint.metadata:
+            if (
+                hasattr(self.agent.fingerprint, "metadata")
+                and self.agent.fingerprint.metadata
+            ):
                 self.fingerprint_metadata = self.agent.fingerprint.metadata
 
 
-class AgentExecutionErrorEvent(CrewEvent):
+class AgentExecutionErrorEvent(BaseEvent):
     """Event emitted when an agent encounters an error during execution"""
 
     agent: BaseAgent
@@ -60,8 +66,11 @@ class AgentExecutionErrorEvent(CrewEvent):
     def __init__(self, **data):
         super().__init__(**data)
         # Set fingerprint data from the agent
-        if hasattr(self.agent, 'fingerprint') and self.agent.fingerprint:
+        if hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
             self.source_fingerprint = self.agent.fingerprint.uuid_str
             self.source_type = "agent"
-            if hasattr(self.agent.fingerprint, 'metadata') and self.agent.fingerprint.metadata:
+            if (
+                hasattr(self.agent.fingerprint, "metadata")
+                and self.agent.fingerprint.metadata
+            ):
                 self.fingerprint_metadata = self.agent.fingerprint.metadata

src/crewai/utilities/events/base_events.py

@@ -3,12 +3,26 @@ from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, Field
 
+from crewai.utilities.serialization import to_serializable
 
-class CrewEvent(BaseModel):
-    """Base class for all crew events"""
+
+class BaseEvent(BaseModel):
+    """Base class for all events"""
 
     timestamp: datetime = Field(default_factory=datetime.now)
     type: str
     source_fingerprint: Optional[str] = None  # UUID string of the source entity
     source_type: Optional[str] = None  # "agent", "task", "crew"
     fingerprint_metadata: Optional[Dict[str, Any]] = None  # Any relevant metadata
+
+    def to_json(self, exclude: set[str] | None = None):
+        """
+        Converts the event to a JSON-serializable dictionary.
+
+        Args:
+            exclude (set[str], optional): Set of keys to exclude from the result. Defaults to None.
+
+        Returns:
+            dict: A JSON-serializable dictionary.
+        """
+        return to_serializable(self, exclude=exclude)

src/crewai/utilities/events/crew_events.py

@@ -1,171 +1,102 @@
-from typing import Any, Dict, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, Optional, Union
 
-from pydantic import InstanceOf
+from crewai.utilities.events.base_events import BaseEvent
 
-from crewai.utilities.events.base_events import CrewEvent
+if TYPE_CHECKING:
+    from crewai.crew import Crew
+else:
+    Crew = Any
 
 
-class CrewKickoffStartedEvent(CrewEvent):
+class CrewBaseEvent(BaseEvent):
+    """Base class for crew events with fingerprint handling"""
+
+    crew_name: Optional[str]
+    crew: Optional[Crew] = None
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.set_crew_fingerprint()
+
+    def set_crew_fingerprint(self) -> None:
+        if self.crew and hasattr(self.crew, "fingerprint") and self.crew.fingerprint:
+            self.source_fingerprint = self.crew.fingerprint.uuid_str
+            self.source_type = "crew"
+            if (
+                hasattr(self.crew.fingerprint, "metadata")
+                and self.crew.fingerprint.metadata
+            ):
+                self.fingerprint_metadata = self.crew.fingerprint.metadata
+
+    def to_json(self, exclude: set[str] | None = None):
+        if exclude is None:
+            exclude = set()
+        exclude.add("crew")
+        return super().to_json(exclude=exclude)
+
+
+class CrewKickoffStartedEvent(CrewBaseEvent):
     """Event emitted when a crew starts execution"""
 
-    crew_name: Optional[str]
     inputs: Optional[Dict[str, Any]]
     type: str = "crew_kickoff_started"
-    crew: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the crew
-        if self.crew and hasattr(self.crew, 'fingerprint') and self.crew.fingerprint:
-            self.source_fingerprint = self.crew.fingerprint.uuid_str
-            self.source_type = "crew"
-            if hasattr(self.crew.fingerprint, 'metadata') and self.crew.fingerprint.metadata:
-                self.fingerprint_metadata = self.crew.fingerprint.metadata
 
 
-class CrewKickoffCompletedEvent(CrewEvent):
+class CrewKickoffCompletedEvent(CrewBaseEvent):
     """Event emitted when a crew completes execution"""
 
-    crew_name: Optional[str]
     output: Any
     type: str = "crew_kickoff_completed"
-    crew: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the crew
-        if self.crew and hasattr(self.crew, 'fingerprint') and self.crew.fingerprint:
-            self.source_fingerprint = self.crew.fingerprint.uuid_str
-            self.source_type = "crew"
-            if hasattr(self.crew.fingerprint, 'metadata') and self.crew.fingerprint.metadata:
-                self.fingerprint_metadata = self.crew.fingerprint.metadata
 
 
-class CrewKickoffFailedEvent(CrewEvent):
+class CrewKickoffFailedEvent(CrewBaseEvent):
     """Event emitted when a crew fails to complete execution"""
 
     error: str
-    crew_name: Optional[str]
     type: str = "crew_kickoff_failed"
-    crew: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the crew
-        if self.crew and hasattr(self.crew, 'fingerprint') and self.crew.fingerprint:
-            self.source_fingerprint = self.crew.fingerprint.uuid_str
-            self.source_type = "crew"
-            if hasattr(self.crew.fingerprint, 'metadata') and self.crew.fingerprint.metadata:
-                self.fingerprint_metadata = self.crew.fingerprint.metadata
 
 
-class CrewTrainStartedEvent(CrewEvent):
+class CrewTrainStartedEvent(CrewBaseEvent):
     """Event emitted when a crew starts training"""
 
-    crew_name: Optional[str]
     n_iterations: int
     filename: str
     inputs: Optional[Dict[str, Any]]
     type: str = "crew_train_started"
-    crew: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the crew
-        if self.crew and hasattr(self.crew, 'fingerprint') and self.crew.fingerprint:
-            self.source_fingerprint = self.crew.fingerprint.uuid_str
-            self.source_type = "crew"
-            if hasattr(self.crew.fingerprint, 'metadata') and self.crew.fingerprint.metadata:
-                self.fingerprint_metadata = self.crew.fingerprint.metadata
 
 
-class CrewTrainCompletedEvent(CrewEvent):
+class CrewTrainCompletedEvent(CrewBaseEvent):
     """Event emitted when a crew completes training"""
 
-    crew_name: Optional[str]
     n_iterations: int
     filename: str
     type: str = "crew_train_completed"
-    crew: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the crew
-        if self.crew and hasattr(self.crew, 'fingerprint') and self.crew.fingerprint:
-            self.source_fingerprint = self.crew.fingerprint.uuid_str
-            self.source_type = "crew"
-            if hasattr(self.crew.fingerprint, 'metadata') and self.crew.fingerprint.metadata:
-                self.fingerprint_metadata = self.crew.fingerprint.metadata
 
 
-class CrewTrainFailedEvent(CrewEvent):
+class CrewTrainFailedEvent(CrewBaseEvent):
     """Event emitted when a crew fails to complete training"""
 
     error: str
-    crew_name: Optional[str]
     type: str = "crew_train_failed"
-    crew: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the crew
-        if self.crew and hasattr(self.crew, 'fingerprint') and self.crew.fingerprint:
-            self.source_fingerprint = self.crew.fingerprint.uuid_str
-            self.source_type = "crew"
-            if hasattr(self.crew.fingerprint, 'metadata') and self.crew.fingerprint.metadata:
-                self.fingerprint_metadata = self.crew.fingerprint.metadata
 
 
-class CrewTestStartedEvent(CrewEvent):
+class CrewTestStartedEvent(CrewBaseEvent):
     """Event emitted when a crew starts testing"""
 
-    crew_name: Optional[str]
     n_iterations: int
     eval_llm: Optional[Union[str, Any]]
     inputs: Optional[Dict[str, Any]]
     type: str = "crew_test_started"
-    crew: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the crew
-        if self.crew and hasattr(self.crew, 'fingerprint') and self.crew.fingerprint:
-            self.source_fingerprint = self.crew.fingerprint.uuid_str
-            self.source_type = "crew"
-            if hasattr(self.crew.fingerprint, 'metadata') and self.crew.fingerprint.metadata:
-                self.fingerprint_metadata = self.crew.fingerprint.metadata
 
 
-class CrewTestCompletedEvent(CrewEvent):
+class CrewTestCompletedEvent(CrewBaseEvent):
     """Event emitted when a crew completes testing"""
 
-    crew_name: Optional[str]
     type: str = "crew_test_completed"
-    crew: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the crew
-        if self.crew and hasattr(self.crew, 'fingerprint') and self.crew.fingerprint:
-            self.source_fingerprint = self.crew.fingerprint.uuid_str
-            self.source_type = "crew"
-            if hasattr(self.crew.fingerprint, 'metadata') and self.crew.fingerprint.metadata:
-                self.fingerprint_metadata = self.crew.fingerprint.metadata
 
 
-class CrewTestFailedEvent(CrewEvent):
+class CrewTestFailedEvent(CrewBaseEvent):
     """Event emitted when a crew fails to complete testing"""
 
     error: str
-    crew_name: Optional[str]
     type: str = "crew_test_failed"
-    crew: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the crew
-        if self.crew and hasattr(self.crew, 'fingerprint') and self.crew.fingerprint:
-            self.source_fingerprint = self.crew.fingerprint.uuid_str
-            self.source_type = "crew"
-            if hasattr(self.crew.fingerprint, 'metadata') and self.crew.fingerprint.metadata:
-                self.fingerprint_metadata = self.crew.fingerprint.metadata

src/crewai/utilities/events/crewai_event_bus.py

@@ -4,10 +4,10 @@ from typing import Any, Callable, Dict, List, Type, TypeVar, cast
 
 from blinker import Signal
 
-from crewai.utilities.events.base_events import CrewEvent
+from crewai.utilities.events.base_events import BaseEvent
 from crewai.utilities.events.event_types import EventTypes
 
-EventT = TypeVar("EventT", bound=CrewEvent)
+EventT = TypeVar("EventT", bound=BaseEvent)
 
 
 class CrewAIEventsBus:
@@ -30,7 +30,7 @@ class CrewAIEventsBus:
     def _initialize(self) -> None:
         """Initialize the event bus internal state"""
         self._signal = Signal("crewai_event_bus")
-        self._handlers: Dict[Type[CrewEvent], List[Callable]] = {}
+        self._handlers: Dict[Type[BaseEvent], List[Callable]] = {}
 
     def on(
         self, event_type: Type[EventT]
@@ -59,7 +59,7 @@ class CrewAIEventsBus:
 
         return decorator
 
-    def emit(self, source: Any, event: CrewEvent) -> None:
+    def emit(self, source: Any, event: BaseEvent) -> None:
         """
         Emit an event to all registered handlers
 

src/crewai/utilities/events/flow_events.py

@@ -2,10 +2,10 @@ from typing import Any, Dict, Optional, Union
 
 from pydantic import BaseModel, ConfigDict
 
-from .base_events import CrewEvent
+from .base_events import BaseEvent
 
 
-class FlowEvent(CrewEvent):
+class FlowEvent(BaseEvent):
     """Base class for all flow events"""
 
     type: str

src/crewai/utilities/events/llm_events.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 
-from crewai.utilities.events.base_events import CrewEvent
+from crewai.utilities.events.base_events import BaseEvent
 
 
 class LLMCallType(Enum):
@@ -11,9 +11,9 @@ class LLMCallType(Enum):
     LLM_CALL = "llm_call"
 
 
-class LLMCallStartedEvent(CrewEvent):
+class LLMCallStartedEvent(BaseEvent):
     """Event emitted when a LLM call starts
-    
+
     Attributes:
         messages: Content can be either a string or a list of dictionaries that support
             multimodal content (text, images, etc.)
@@ -26,7 +26,7 @@ class LLMCallStartedEvent(CrewEvent):
     available_functions: Optional[Dict[str, Any]] = None
 
 
-class LLMCallCompletedEvent(CrewEvent):
+class LLMCallCompletedEvent(BaseEvent):
     """Event emitted when a LLM call completes"""
 
     type: str = "llm_call_completed"
@@ -34,14 +34,14 @@ class LLMCallCompletedEvent(CrewEvent):
     call_type: LLMCallType
 
 
-class LLMCallFailedEvent(CrewEvent):
+class LLMCallFailedEvent(BaseEvent):
     """Event emitted when a LLM call fails"""
 
     error: str
     type: str = "llm_call_failed"
 
 
-class LLMStreamChunkEvent(CrewEvent):
+class LLMStreamChunkEvent(BaseEvent):
     """Event emitted when a streaming chunk is received"""
 
     type: str = "llm_stream_chunk"

src/crewai/utilities/events/task_events.py

@@ -1,10 +1,10 @@
 from typing import Any, Optional
 
 from crewai.tasks.task_output import TaskOutput
-from crewai.utilities.events.base_events import CrewEvent
+from crewai.utilities.events.base_events import BaseEvent
 
 
-class TaskStartedEvent(CrewEvent):
+class TaskStartedEvent(BaseEvent):
     """Event emitted when a task starts"""
 
     type: str = "task_started"
@@ -14,14 +14,17 @@ class TaskStartedEvent(CrewEvent):
     def __init__(self, **data):
         super().__init__(**data)
         # Set fingerprint data from the task
-        if hasattr(self.task, 'fingerprint') and self.task.fingerprint:
+        if hasattr(self.task, "fingerprint") and self.task.fingerprint:
             self.source_fingerprint = self.task.fingerprint.uuid_str
             self.source_type = "task"
-            if hasattr(self.task.fingerprint, 'metadata') and self.task.fingerprint.metadata:
+            if (
+                hasattr(self.task.fingerprint, "metadata")
+                and self.task.fingerprint.metadata
+            ):
                 self.fingerprint_metadata = self.task.fingerprint.metadata
 
 
-class TaskCompletedEvent(CrewEvent):
+class TaskCompletedEvent(BaseEvent):
     """Event emitted when a task completes"""
 
     output: TaskOutput
@@ -31,14 +34,17 @@ class TaskCompletedEvent(CrewEvent):
     def __init__(self, **data):
         super().__init__(**data)
         # Set fingerprint data from the task
-        if hasattr(self.task, 'fingerprint') and self.task.fingerprint:
+        if hasattr(self.task, "fingerprint") and self.task.fingerprint:
             self.source_fingerprint = self.task.fingerprint.uuid_str
             self.source_type = "task"
-            if hasattr(self.task.fingerprint, 'metadata') and self.task.fingerprint.metadata:
+            if (
+                hasattr(self.task.fingerprint, "metadata")
+                and self.task.fingerprint.metadata
+            ):
                 self.fingerprint_metadata = self.task.fingerprint.metadata
 
 
-class TaskFailedEvent(CrewEvent):
+class TaskFailedEvent(BaseEvent):
     """Event emitted when a task fails"""
 
     error: str
@@ -48,14 +54,17 @@ class TaskFailedEvent(CrewEvent):
     def __init__(self, **data):
         super().__init__(**data)
         # Set fingerprint data from the task
-        if hasattr(self.task, 'fingerprint') and self.task.fingerprint:
+        if hasattr(self.task, "fingerprint") and self.task.fingerprint:
             self.source_fingerprint = self.task.fingerprint.uuid_str
             self.source_type = "task"
-            if hasattr(self.task.fingerprint, 'metadata') and self.task.fingerprint.metadata:
+            if (
+                hasattr(self.task.fingerprint, "metadata")
+                and self.task.fingerprint.metadata
+            ):
                 self.fingerprint_metadata = self.task.fingerprint.metadata
 
 
-class TaskEvaluationEvent(CrewEvent):
+class TaskEvaluationEvent(BaseEvent):
     """Event emitted when a task evaluation is completed"""
 
     type: str = "task_evaluation"
@@ -65,8 +74,11 @@ class TaskEvaluationEvent(CrewEvent):
     def __init__(self, **data):
         super().__init__(**data)
         # Set fingerprint data from the task
-        if hasattr(self.task, 'fingerprint') and self.task.fingerprint:
+        if hasattr(self.task, "fingerprint") and self.task.fingerprint:
             self.source_fingerprint = self.task.fingerprint.uuid_str
             self.source_type = "task"
-            if hasattr(self.task.fingerprint, 'metadata') and self.task.fingerprint.metadata:
+            if (
+                hasattr(self.task.fingerprint, "metadata")
+                and self.task.fingerprint.metadata
+            ):
                 self.fingerprint_metadata = self.task.fingerprint.metadata

src/crewai/utilities/events/tool_usage_events.py

@@ -1,10 +1,10 @@
 from datetime import datetime
 from typing import Any, Callable, Dict, Optional
 
-from .base_events import CrewEvent
+from .base_events import BaseEvent
 
 
-class ToolUsageEvent(CrewEvent):
+class ToolUsageEvent(BaseEvent):
     """Base event for tool usage tracking"""
 
     agent_key: str
@@ -21,10 +21,13 @@ class ToolUsageEvent(CrewEvent):
     def __init__(self, **data):
         super().__init__(**data)
         # Set fingerprint data from the agent
-        if self.agent and hasattr(self.agent, 'fingerprint') and self.agent.fingerprint:
+        if self.agent and hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
             self.source_fingerprint = self.agent.fingerprint.uuid_str
             self.source_type = "agent"
-            if hasattr(self.agent.fingerprint, 'metadata') and self.agent.fingerprint.metadata:
+            if (
+                hasattr(self.agent.fingerprint, "metadata")
+                and self.agent.fingerprint.metadata
+            ):
                 self.fingerprint_metadata = self.agent.fingerprint.metadata
 
 
@@ -65,7 +68,7 @@ class ToolSelectionErrorEvent(ToolUsageEvent):
     type: str = "tool_selection_error"
 
 
-class ToolExecutionErrorEvent(CrewEvent):
+class ToolExecutionErrorEvent(BaseEvent):
     """Event emitted when a tool execution encounters an error"""
 
     error: Any
@@ -78,8 +81,11 @@ class ToolExecutionErrorEvent(CrewEvent):
     def __init__(self, **data):
         super().__init__(**data)
         # Set fingerprint data from the agent
-        if self.agent and hasattr(self.agent, 'fingerprint') and self.agent.fingerprint:
+        if self.agent and hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
             self.source_fingerprint = self.agent.fingerprint.uuid_str
             self.source_type = "agent"
-            if hasattr(self.agent.fingerprint, 'metadata') and self.agent.fingerprint.metadata:
+            if (
+                hasattr(self.agent.fingerprint, "metadata")
+                and self.agent.fingerprint.metadata
+            ):
                 self.fingerprint_metadata = self.agent.fingerprint.metadata

src/crewai/utilities/serialization.py

@@ -5,35 +5,17 @@ from typing import Any, Dict, List, Union
 
 from pydantic import BaseModel
 
-from crewai.flow import Flow
-
 SerializablePrimitive = Union[str, int, float, bool, None]
 Serializable = Union[
     SerializablePrimitive, List["Serializable"], Dict[str, "Serializable"]
 ]
 
 
-def export_state(flow: Flow) -> dict[str, Serializable]:
-    """Exports the Flow's internal state as JSON-compatible data structures.
-
-    Performs a one-way transformation of a Flow's state into basic Python types
-    that can be safely serialized to JSON. To prevent infinite recursion with
-    circular references, the conversion is limited to a depth of 5 levels.
-
-    Args:
-        flow: The Flow object whose state needs to be exported
-
-    Returns:
-        dict[str, Any]: The transformed state using JSON-compatible Python
-            types.
-    """
-    result = to_serializable(flow._state)
-    assert isinstance(result, dict)
-    return result
-
-
 def to_serializable(
-    obj: Any, exclude: set[str] | None = None, max_depth: int = 5, _current_depth: int = 0
+    obj: Any,
+    exclude: set[str] | None = None,
+    max_depth: int = 5,
+    _current_depth: int = 0,
 ) -> Serializable:
     """Converts a Python object into a JSON-compatible representation.