Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
fix: preserve enum type in router result; improve types
Greyson LaLonde28a6b855a28b
diff --git a/lib/crewai/src/crewai/flow/flow.py b/lib/crewai/src/crewai/flow/flow.pyindex 58a59debe..b32321daa 100644--- a/lib/crewai/src/crewai/flow/flow.py+++ b/lib/crewai/src/crewai/flow/flow.py@@ -10,6 +10,7 @@ import asynciofrom collections.abc import (Callable,ItemsView,+ Iterable,Iterator,KeysView,Sequence,@@ -17,6 +18,7 @@ from collections.abc import ()from concurrent.futures import Futureimport copy+import enumimport inspectimport loggingimport threading@@ -27,8 +29,10 @@ from typing import (Generic,Literal,ParamSpec,+ SupportsIndex,TypeVar,cast,+ overload,)from uuid import uuid4@@ -77,7 +81,12 @@ from crewai.flow.flow_wrappers import (StartMethod,)from crewai.flow.persistence.base import FlowPersistence-from crewai.flow.types import FlowExecutionData, FlowMethodName, InputHistoryEntry, PendingListenerKey+from crewai.flow.types import (+ FlowExecutionData,+ FlowMethodName,+ InputHistoryEntry,+ PendingListenerKey,+)from crewai.flow.utils import (_extract_all_methods,_extract_all_methods_recursive,@@ -426,8 +435,7 @@ class LockedListProxy(list, Generic[T]): # type: ignore[type-arg]"""def __init__(self, lst: list[T], lock: threading.Lock) -> None:- # Do NOT call super().__init__() -- we don't want to copy data into- # the builtin list storage. All access goes through self._list.+ super().__init__() # empty builtin list; all access goes through self._listself._list = lstself._lock = lock@@ -435,11 +443,11 @@ class LockedListProxy(list, Generic[T]): # type: ignore[type-arg]with self._lock:self._list.append(item)- def extend(self, items: list[T]) -> None:+ def extend(self, items: Iterable[T]) -> None:with self._lock:self._list.extend(items)- def insert(self, index: int, item: T) -> None:+ def insert(self, index: SupportsIndex, item: T) -> None:with self._lock:self._list.insert(index, item)@@ -447,7 +455,7 @@ class LockedListProxy(list, Generic[T]): # type: ignore[type-arg]with self._lock:self._list.remove(item)- def pop(self, index: int = -1) -> T:+ def pop(self, index: SupportsIndex = -1) -> T:with self._lock:return self._list.pop(index)@@ -455,15 +463,23 @@ class LockedListProxy(list, Generic[T]): # type: ignore[type-arg]with self._lock:self._list.clear()- def __setitem__(self, index: int, value: T) -> None:+ @overload+ def __setitem__(self, index: SupportsIndex, value: T) -> None: ...+ @overload+ def __setitem__(self, index: slice, value: Iterable[T]) -> None: ...+ def __setitem__(self, index: Any, value: Any) -> None:with self._lock:self._list[index] = value- def __delitem__(self, index: int) -> None:+ def __delitem__(self, index: SupportsIndex | slice) -> None:with self._lock:del self._list[index]- def __getitem__(self, index: int) -> T:+ @overload+ def __getitem__(self, index: SupportsIndex) -> T: ...+ @overload+ def __getitem__(self, index: slice) -> list[T]: ...+ def __getitem__(self, index: Any) -> Any:return self._list[index]def __len__(self) -> int:@@ -481,7 +497,7 @@ class LockedListProxy(list, Generic[T]): # type: ignore[type-arg]def __bool__(self) -> bool:return bool(self._list)- def __eq__(self, other: object) -> bool: # type: ignore[override]+ def __eq__(self, other: object) -> bool:"""Compare based on the underlying list contents."""if isinstance(other, LockedListProxy):# Avoid deadlocks by acquiring locks in a consistent order.@@ -492,7 +508,7 @@ class LockedListProxy(list, Generic[T]): # type: ignore[type-arg]with self._lock:return self._list == other- def __ne__(self, other: object) -> bool: # type: ignore[override]+ def __ne__(self, other: object) -> bool:return not self.__eq__(other)@@ -505,8 +521,7 @@ class LockedDictProxy(dict, Generic[T]): # type: ignore[type-arg]"""def __init__(self, d: dict[str, T], lock: threading.Lock) -> None:- # Do NOT call super().__init__() -- we don't want to copy data into- # the builtin dict storage. All access goes through self._dict.+ super().__init__() # empty builtin dict; all access goes through self._dictself._dict = dself._lock = lock@@ -518,11 +533,11 @@ class LockedDictProxy(dict, Generic[T]): # type: ignore[type-arg]with self._lock:del self._dict[key]- def pop(self, key: str, *default: T) -> T:+ def pop(self, key: str, *default: T) -> T: # type: ignore[override]with self._lock:return self._dict.pop(key, *default)- def update(self, other: dict[str, T]) -> None:+ def update(self, other: dict[str, T]) -> None: # type: ignore[override]with self._lock:self._dict.update(other)@@ -530,7 +545,7 @@ class LockedDictProxy(dict, Generic[T]): # type: ignore[type-arg]with self._lock:self._dict.clear()- def setdefault(self, key: str, default: T) -> T:+ def setdefault(self, key: str, default: T) -> T: # type: ignore[override]with self._lock:return self._dict.setdefault(key, default)@@ -546,16 +561,16 @@ class LockedDictProxy(dict, Generic[T]): # type: ignore[type-arg]def __contains__(self, key: object) -> bool:return key in self._dict- def keys(self) -> KeysView[str]:+ def keys(self) -> KeysView[str]: # type: ignore[override]return self._dict.keys()- def values(self) -> ValuesView[T]:+ def values(self) -> ValuesView[T]: # type: ignore[override]return self._dict.values()- def items(self) -> ItemsView[str, T]:+ def items(self) -> ItemsView[str, T]: # type: ignore[override]return self._dict.items()- def get(self, key: str, default: T | None = None) -> T | None:+ def get(self, key: str, default: T | None = None) -> T | None: # type: ignore[override]return self._dict.get(key, default)def __repr__(self) -> str:@@ -564,7 +579,7 @@ class LockedDictProxy(dict, Generic[T]): # type: ignore[type-arg]def __bool__(self) -> bool:return bool(self._dict)- def __eq__(self, other: object) -> bool: # type: ignore[override]+ def __eq__(self, other: object) -> bool:"""Compare based on the underlying dict contents."""if isinstance(other, LockedDictProxy):# Avoid deadlocks by acquiring locks in a consistent order.@@ -575,7 +590,7 @@ class LockedDictProxy(dict, Generic[T]): # type: ignore[type-arg]with self._lock:return self._dict == other- def __ne__(self, other: object) -> bool: # type: ignore[override]+ def __ne__(self, other: object) -> bool:return not self.__eq__(other)@@ -737,7 +752,9 @@ class Flow(Generic[T], metaclass=FlowMeta):name: str | None = Nonetracing: bool | None = Nonestream: bool = False- memory: Any = None # Memory | MemoryScope | MemorySlice | None; auto-created if not set+ memory: Any = (+ None # Memory | MemoryScope | MemorySlice | None; auto-created if not set+ )input_provider: Any = None # InputProvider | None; per-flow override for self.ask()def __class_getitem__(cls: type[Flow[T]], item: type[T]) -> type[Flow[T]]:@@ -881,7 +898,8 @@ class Flow(Generic[T], metaclass=FlowMeta):"""if self.memory is None:raise ValueError("No memory configured for this flow")- return self.memory.extract_memories(content)+ result: list[str] = self.memory.extract_memories(content)+ return resultdef _mark_or_listener_fired(self, listener_name: FlowMethodName) -> bool:"""Mark an OR listener as fired atomically.@@ -1352,8 +1370,10 @@ class Flow(Generic[T], metaclass=FlowMeta):ValueError: If structured state model lacks 'id' fieldTypeError: If state is neither BaseModel nor dictionary"""+ init_state = self.initial_state+# Handle case where initial_state is None but we have a type parameter- if self.initial_state is None and hasattr(self, "_initial_state_t"):+ if init_state is None and hasattr(self, "_initial_state_t"):state_type = self._initial_state_tif isinstance(state_type, type):if issubclass(state_type, FlowState):@@ -1377,12 +1397,12 @@ class Flow(Generic[T], metaclass=FlowMeta):return cast(T, {"id": str(uuid4())})# Handle case where no initial state is provided- if self.initial_state is None:+ if init_state is None:return cast(T, {"id": str(uuid4())})# Handle case where initial_state is a type (class)- if isinstance(self.initial_state, type):- state_class: type[T] = self.initial_state+ if isinstance(init_state, type):+ state_class = init_stateif issubclass(state_class, FlowState):return state_class()if issubclass(state_class, BaseModel):@@ -1393,19 +1413,19 @@ class Flow(Generic[T], metaclass=FlowMeta):if not getattr(model_instance, "id", None):object.__setattr__(model_instance, "id", str(uuid4()))return model_instance- if self.initial_state is dict:+ if init_state is dict:return cast(T, {"id": str(uuid4())})# Handle dictionary instance case- if isinstance(self.initial_state, dict):- new_state = dict(self.initial_state) # Copy to avoid mutations+ if isinstance(init_state, dict):+ new_state = dict(init_state) # Copy to avoid mutationsif "id" not in new_state:new_state["id"] = str(uuid4())return cast(T, new_state)# Handle BaseModel instance case- if isinstance(self.initial_state, BaseModel):- model = cast(BaseModel, self.initial_state)+ if isinstance(init_state, BaseModel):+ model = cast(BaseModel, init_state)if not hasattr(model, "id"):raise ValueError("Flow state model must have an 'id' field")@@ -2277,14 +2297,23 @@ class Flow(Generic[T], metaclass=FlowMeta):router_name, router_input, current_triggering_event_id)if router_result: # Only add non-None results- router_results.append(FlowMethodName(str(router_result)))+ router_result_str = (+ router_result.value+ if isinstance(router_result, enum.Enum)+ else str(router_result)+ )+ router_results.append(FlowMethodName(router_result_str))# If this was a human_feedback router, map the outcome to the feedbackif self.last_human_feedback is not None:- router_result_to_feedback[str(router_result)] = (+ router_result_to_feedback[router_result_str] = (self.last_human_feedback)current_trigger = (- FlowMethodName(str(router_result))+ FlowMethodName(+ router_result.value+ if isinstance(router_result, enum.Enum)+ else str(router_result)+ )if router_result is not Noneelse FlowMethodName("") # Update for next iteration of router chain)@@ -2701,7 +2730,10 @@ class Flow(Generic[T], metaclass=FlowMeta):return topic```"""- from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError+ from concurrent.futures import (+ ThreadPoolExecutor,+ TimeoutError as FuturesTimeoutError,+ )from datetime import datetimefrom crewai.events.types.flow_events import (@@ -2770,14 +2802,16 @@ class Flow(Generic[T], metaclass=FlowMeta):response = None# Record in history- self._input_history.append({- "message": message,- "response": response,- "method_name": method_name,- "timestamp": datetime.now(),- "metadata": metadata,- "response_metadata": response_metadata,- })+ self._input_history.append(+ {+ "message": message,+ "response": response,+ "method_name": method_name,+ "timestamp": datetime.now(),+ "metadata": metadata,+ "response_metadata": response_metadata,+ }+ )# Emit input received eventcrewai_event_bus.emit(