Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
fix: preserve nested condition structure in Flow decorators
Greyson LaLonde42f2b4d551dc
diff --git a/src/crewai/flow/flow.py b/src/crewai/flow/flow.pyindex 85bb077ee..84783b081 100644--- a/src/crewai/flow/flow.py+++ b/src/crewai/flow/flow.py@@ -31,7 +31,7 @@ from crewai.flow.flow_visualizer import plot_flowfrom crewai.flow.persistence.base import FlowPersistencefrom crewai.flow.types import FlowExecutionDatafrom crewai.flow.utils import get_possible_return_constants-from crewai.utilities.printer import Printer+from crewai.utilities.printer import Printer, PrinterColorlogger = logging.getLogger(__name__)@@ -105,7 +105,7 @@ def start(condition: str | dict | Callable | None = None) -> Callable:condition : Optional[Union[str, dict, Callable]], optionalDefines when the start method should execute. Can be:- str: Name of a method that triggers this start- - dict: Contains "type" ("AND"/"OR") and "methods" (list of triggers)+ - dict: Result from or_() or and_(), including nested conditions- Callable: A method reference that triggers this startDefault is None, meaning unconditional start.@@ -140,13 +140,18 @@ def start(condition: str | dict | Callable | None = None) -> Callable:if isinstance(condition, str):func.__trigger_methods__ = [condition]func.__condition_type__ = "OR"- elif (- isinstance(condition, dict)- and "type" in condition- and "methods" in condition- ):- func.__trigger_methods__ = condition["methods"]- func.__condition_type__ = condition["type"]+ elif isinstance(condition, dict) and "type" in condition:+ if "conditions" in condition:+ func.__trigger_condition__ = condition+ func.__trigger_methods__ = _extract_all_methods(condition)+ func.__condition_type__ = condition["type"]+ elif "methods" in condition:+ func.__trigger_methods__ = condition["methods"]+ func.__condition_type__ = condition["type"]+ else:+ raise ValueError(+ "Condition dict must contain 'conditions' or 'methods'"+ )elif callable(condition) and hasattr(condition, "__name__"):func.__trigger_methods__ = [condition.__name__]func.__condition_type__ = "OR"@@ -172,7 +177,7 @@ def listen(condition: str | dict | Callable) -> Callable:condition : Union[str, dict, Callable]Specifies when the listener should execute. Can be:- str: Name of a method that triggers this listener- - dict: Contains "type" ("AND"/"OR") and "methods" (list of triggers)+ - dict: Result from or_() or and_(), including nested conditions- Callable: A method reference that triggers this listenerReturns@@ -200,13 +205,18 @@ def listen(condition: str | dict | Callable) -> Callable:if isinstance(condition, str):func.__trigger_methods__ = [condition]func.__condition_type__ = "OR"- elif (- isinstance(condition, dict)- and "type" in condition- and "methods" in condition- ):- func.__trigger_methods__ = condition["methods"]- func.__condition_type__ = condition["type"]+ elif isinstance(condition, dict) and "type" in condition:+ if "conditions" in condition:+ func.__trigger_condition__ = condition+ func.__trigger_methods__ = _extract_all_methods(condition)+ func.__condition_type__ = condition["type"]+ elif "methods" in condition:+ func.__trigger_methods__ = condition["methods"]+ func.__condition_type__ = condition["type"]+ else:+ raise ValueError(+ "Condition dict must contain 'conditions' or 'methods'"+ )elif callable(condition) and hasattr(condition, "__name__"):func.__trigger_methods__ = [condition.__name__]func.__condition_type__ = "OR"@@ -233,7 +243,7 @@ def router(condition: str | dict | Callable) -> Callable:condition : Union[str, dict, Callable]Specifies when the router should execute. Can be:- str: Name of a method that triggers this router- - dict: Contains "type" ("AND"/"OR") and "methods" (list of triggers)+ - dict: Result from or_() or and_(), including nested conditions- Callable: A method reference that triggers this routerReturns@@ -266,13 +276,18 @@ def router(condition: str | dict | Callable) -> Callable:if isinstance(condition, str):func.__trigger_methods__ = [condition]func.__condition_type__ = "OR"- elif (- isinstance(condition, dict)- and "type" in condition- and "methods" in condition- ):- func.__trigger_methods__ = condition["methods"]- func.__condition_type__ = condition["type"]+ elif isinstance(condition, dict) and "type" in condition:+ if "conditions" in condition:+ func.__trigger_condition__ = condition+ func.__trigger_methods__ = _extract_all_methods(condition)+ func.__condition_type__ = condition["type"]+ elif "methods" in condition:+ func.__trigger_methods__ = condition["methods"]+ func.__condition_type__ = condition["type"]+ else:+ raise ValueError(+ "Condition dict must contain 'conditions' or 'methods'"+ )elif callable(condition) and hasattr(condition, "__name__"):func.__trigger_methods__ = [condition.__name__]func.__condition_type__ = "OR"@@ -298,14 +313,15 @@ def or_(*conditions: str | dict | Callable) -> dict:*conditions : Union[str, dict, Callable]Variable number of conditions that can be:- str: Method names- - dict: Existing condition dictionaries+ - dict: Existing condition dictionaries (nested conditions)- Callable: Method referencesReturns-------dictA condition dictionary with format:- {"type": "OR", "methods": list_of_method_names}+ {"type": "OR", "conditions": list_of_conditions}+ where each condition can be a string (method name) or a nested dictRaises------@@ -317,18 +333,22 @@ def or_(*conditions: str | dict | Callable) -> dict:>>> @listen(or_("success", "timeout"))>>> def handle_completion(self):... pass++ >>> @listen(or_(and_("step1", "step2"), "step3"))+ >>> def handle_nested(self):+ ... pass"""- methods = []+ processed_conditions: list[str | dict[str, Any]] = []for condition in conditions:- if isinstance(condition, dict) and "methods" in condition:- methods.extend(condition["methods"])+ if isinstance(condition, dict):+ processed_conditions.append(condition)elif isinstance(condition, str):- methods.append(condition)+ processed_conditions.append(condition)elif callable(condition):- methods.append(getattr(condition, "__name__", repr(condition)))+ processed_conditions.append(getattr(condition, "__name__", repr(condition)))else:raise ValueError("Invalid condition in or_()")- return {"type": "OR", "methods": methods}+ return {"type": "OR", "conditions": processed_conditions}def and_(*conditions: str | dict | Callable) -> dict:@@ -344,14 +364,15 @@ def and_(*conditions: str | dict | Callable) -> dict:*conditions : Union[str, dict, Callable]Variable number of conditions that can be:- str: Method names- - dict: Existing condition dictionaries+ - dict: Existing condition dictionaries (nested conditions)- Callable: Method referencesReturns-------dictA condition dictionary with format:- {"type": "AND", "methods": list_of_method_names}+ {"type": "AND", "conditions": list_of_conditions}+ where each condition can be a string (method name) or a nested dictRaises------@@ -363,18 +384,69 @@ def and_(*conditions: str | dict | Callable) -> dict:>>> @listen(and_("validated", "processed"))>>> def handle_complete_data(self):... pass++ >>> @listen(and_(or_("step1", "step2"), "step3"))+ >>> def handle_nested(self):+ ... pass"""- methods = []+ processed_conditions: list[str | dict[str, Any]] = []for condition in conditions:- if isinstance(condition, dict) and "methods" in condition:- methods.extend(condition["methods"])+ if isinstance(condition, dict):+ processed_conditions.append(condition)elif isinstance(condition, str):- methods.append(condition)+ processed_conditions.append(condition)elif callable(condition):- methods.append(getattr(condition, "__name__", repr(condition)))+ processed_conditions.append(getattr(condition, "__name__", repr(condition)))else:raise ValueError("Invalid condition in and_()")- return {"type": "AND", "methods": methods}+ return {"type": "AND", "conditions": processed_conditions}+++def _normalize_condition(condition: str | dict | list) -> dict:+ """Normalize a condition to standard format with 'conditions' key.++ Args:+ condition: Can be a string (method name), dict (condition), or list++ Returns:+ Normalized dict with 'type' and 'conditions' keys+ """+ if isinstance(condition, str):+ return {"type": "OR", "conditions": [condition]}+ if isinstance(condition, dict):+ if "conditions" in condition:+ return condition+ if "methods" in condition:+ return {"type": condition["type"], "conditions": condition["methods"]}+ return condition+ if isinstance(condition, list):+ return {"type": "OR", "conditions": condition}+ return {"type": "OR", "conditions": [condition]}+++def _extract_all_methods(condition: str | dict | list) -> list[str]:+ """Extract all method names from a condition (including nested).++ Args:+ condition: Can be a string, dict, or list++ Returns:+ List of all method names in the condition tree+ """+ if isinstance(condition, str):+ return [condition]+ if isinstance(condition, dict):+ normalized = _normalize_condition(condition)+ methods = []+ for sub_cond in normalized.get("conditions", []):+ methods.extend(_extract_all_methods(sub_cond))+ return methods+ if isinstance(condition, list):+ methods = []+ for item in condition:+ methods.extend(_extract_all_methods(item))+ return methods+ return []class FlowMeta(type):@@ -402,7 +474,10 @@ class FlowMeta(type):if hasattr(attr_value, "__trigger_methods__"):methods = attr_value.__trigger_methods__condition_type = getattr(attr_value, "__condition_type__", "OR")- listeners[attr_name] = (condition_type, methods)+ if hasattr(attr_value, "__trigger_condition__"):+ listeners[attr_name] = attr_value.__trigger_condition__+ else:+ listeners[attr_name] = (condition_type, methods)if (hasattr(attr_value, "__is_router__")@@ -822,6 +897,7 @@ class Flow(Generic[T], metaclass=FlowMeta):# Clear completed methods and outputs for a fresh startself._completed_methods.clear()self._method_outputs.clear()+ self._pending_and_listeners.clear()else:# We're restoring from persistence, set the flagself._is_execution_resuming = True@@ -1086,10 +1162,16 @@ class Flow(Generic[T], metaclass=FlowMeta):for method_name in self._start_methods:# Check if this start method is triggered by the current triggerif method_name in self._listeners:- condition_type, trigger_methods = self._listeners[- method_name- ]- if current_trigger in trigger_methods:+ condition_data = self._listeners[method_name]+ should_trigger = False+ if isinstance(condition_data, tuple):+ _, trigger_methods = condition_data+ should_trigger = current_trigger in trigger_methods+ elif isinstance(condition_data, dict):+ all_methods = _extract_all_methods(condition_data)+ should_trigger = current_trigger in all_methods++ if should_trigger:# Only execute if this is a cycle (method was already completed)if method_name in self._completed_methods:# For router-triggered start methods in cycles, temporarily clear resumption flag@@ -1099,6 +1181,51 @@ class Flow(Generic[T], metaclass=FlowMeta):await self._execute_start_method(method_name)self._is_execution_resuming = was_resuming+ def _evaluate_condition(+ self, condition: str | dict, trigger_method: str, listener_name: str+ ) -> bool:+ """Recursively evaluate a condition (simple or nested).++ Args:+ condition: Can be a string (method name) or dict (nested condition)+ trigger_method: The method that just completed+ listener_name: Name of the listener being evaluated++ Returns:+ True if the condition is satisfied, False otherwise+ """+ if isinstance(condition, str):+ return condition == trigger_method++ if isinstance(condition, dict):+ normalized = _normalize_condition(condition)+ cond_type = normalized.get("type", "OR")+ sub_conditions = normalized.get("conditions", [])++ if cond_type == "OR":+ return any(+ self._evaluate_condition(sub_cond, trigger_method, listener_name)+ for sub_cond in sub_conditions+ )++ if cond_type == "AND":+ pending_key = f"{listener_name}:{id(condition)}"++ if pending_key not in self._pending_and_listeners:+ all_methods = set(_extract_all_methods(condition))+ self._pending_and_listeners[pending_key] = all_methods++ if trigger_method in self._pending_and_listeners[pending_key]:+ self._pending_and_listeners[pending_key].discard(trigger_method)++ if not self._pending_and_listeners[pending_key]:+ self._pending_and_listeners.pop(pending_key, None)+ return True++ return False++ return False+def _find_triggered_methods(self, trigger_method: str, router_only: bool) -> list[str]:@@ -1106,7 +1233,7 @@ class Flow(Generic[T], metaclass=FlowMeta):Finds all methods that should be triggered based on conditions.This internal method evaluates both OR and AND conditions to determine- which methods should be executed next in the flow.+ which methods should be executed next in the flow. Supports nested conditions.Parameters----------@@ -1123,14 +1250,13 @@ class Flow(Generic[T], metaclass=FlowMeta):Notes------ - Handles both OR and AND conditions:- * OR: Triggers if any condition is met- * AND: Triggers only when all conditions are met+ - Handles both OR and AND conditions, including nested combinations- Maintains state for AND conditions using _pending_and_listeners- Separates router and normal listener evaluation"""triggered = []- for listener_name, (condition_type, methods) in self._listeners.items():++ for listener_name, condition_data in self._listeners.items():is_router = listener_name in self._routersif router_only != is_router:@@ -1139,23 +1265,29 @@ class Flow(Generic[T], metaclass=FlowMeta):if not router_only and listener_name in self._start_methods:continue- if condition_type == "OR":- # If the trigger_method matches any in methods, run this- if trigger_method in methods:- triggered.append(listener_name)- elif condition_type == "AND":- # Initialize pending methods for this listener if not already done- if listener_name not in self._pending_and_listeners:- self._pending_and_listeners[listener_name] = set(methods)- # Remove the trigger method from pending methods- if trigger_method in self._pending_and_listeners[listener_name]:- self._pending_and_listeners[listener_name].discard(trigger_method)-- if not self._pending_and_listeners[listener_name]:- # All required methods have been executed+ if isinstance(condition_data, tuple):+ condition_type, methods = condition_data++ if condition_type == "OR":+ if trigger_method in methods:+ triggered.append(listener_name)+ elif condition_type == "AND":+ if listener_name not in self._pending_and_listeners:+ self._pending_and_listeners[listener_name] = set(methods)+ if trigger_method in self._pending_and_listeners[listener_name]:+ self._pending_and_listeners[listener_name].discard(+ trigger_method+ )++ if not self._pending_and_listeners[listener_name]:+ triggered.append(listener_name)+ self._pending_and_listeners.pop(listener_name, None)++ elif isinstance(condition_data, dict):+ if self._evaluate_condition(+ condition_data, trigger_method, listener_name+ ):triggered.append(listener_name)- # Reset pending methods for this listener- self._pending_and_listeners.pop(listener_name, None)return triggered@@ -1218,7 +1350,7 @@ class Flow(Generic[T], metaclass=FlowMeta):raisedef _log_flow_event(- self, message: str, color: str = "yellow", level: str = "info"+ self, message: str, color: PrinterColor | None = "yellow", level: str = "info") -> None:"""Centralized logging method for flow events.diff --git a/tests/test_flow.py b/tests/test_flow.pyindex 504cf8e6e..f060a7a19 100644--- a/tests/test_flow.py+++ b/tests/test_flow.py@@ -6,15 +6,15 @@ from datetime import datetimeimport pytestfrom pydantic import BaseModel-from crewai.flow.flow import Flow, and_, listen, or_, router, startfrom crewai.events.event_bus import crewai_event_busfrom crewai.events.types.flow_events import (FlowFinishedEvent,- FlowStartedEvent,FlowPlotEvent,+ FlowStartedEvent,MethodExecutionFinishedEvent,MethodExecutionStartedEvent,)+from crewai.flow.flow import Flow, and_, listen, or_, router, startdef test_simple_sequential_flow():@@ -679,11 +679,11 @@ def test_structured_flow_event_emission():assert isinstance(received_events[3], MethodExecutionStartedEvent)assert received_events[3].method_name == "send_welcome_message"assert received_events[3].params == {}- assert getattr(received_events[3].state, "sent") is False+ assert received_events[3].state.sent is Falseassert isinstance(received_events[4], MethodExecutionFinishedEvent)assert received_events[4].method_name == "send_welcome_message"- assert getattr(received_events[4].state, "sent") is True+ assert received_events[4].state.sent is Trueassert received_events[4].result == "Welcome, Anakin!"assert isinstance(received_events[5], FlowFinishedEvent)@@ -894,3 +894,75 @@ def test_flow_name():flow = MyFlow()assert flow.name == "MyFlow"+++def test_nested_and_or_conditions():+ """Test nested conditions like or_(and_(A, B), and_(C, D)).++ Reproduces bug from issue #3719 where nested conditions are flattened,+ causing premature execution.+ """+ execution_order = []++ class NestedConditionFlow(Flow):+ @start()+ def method_1(self):+ execution_order.append("method_1")++ @listen(method_1)+ def method_2(self):+ execution_order.append("method_2")++ @router(method_2)+ def method_3(self):+ execution_order.append("method_3")+ # Choose b_condition path+ return "b_condition"++ @listen("b_condition")+ def method_5(self):+ execution_order.append("method_5")++ @listen(method_5)+ async def method_4(self):+ execution_order.append("method_4")++ @listen(or_("a_condition", "b_condition"))+ async def method_6(self):+ execution_order.append("method_6")++ @listen(+ or_(+ and_("a_condition", method_6),+ and_(method_6, method_4),+ )+ )+ def method_7(self):+ execution_order.append("method_7")++ @listen(method_7)+ async def method_8(self):+ execution_order.append("method_8")++ flow = NestedConditionFlow()+ flow.kickoff()++ # Verify execution happened+ assert "method_1" in execution_order+ assert "method_2" in execution_order+ assert "method_3" in execution_order+ assert "method_5" in execution_order+ assert "method_4" in execution_order+ assert "method_6" in execution_order+ assert "method_7" in execution_order+ assert "method_8" in execution_order++ # Critical assertion: method_7 should only execute AFTER both method_6 AND method_4+ # Since b_condition was returned, method_6 triggers on b_condition+ # method_7 requires: (a_condition AND method_6) OR (method_6 AND method_4)+ # The second condition (method_6 AND method_4) should be the one that triggers+ assert execution_order.index("method_7") > execution_order.index("method_6")+ assert execution_order.index("method_7") > execution_order.index("method_4")++ # method_8 should execute after method_7+ assert execution_order.index("method_8") > execution_order.index("method_7")