Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks.
reasoning logs
João Moura50b8f83428cb
diff --git a/src/crewai/utilities/events/event_listener.py b/src/crewai/utilities/events/event_listener.pyindex a76b87964..caf83bfdc 100644--- a/src/crewai/utilities/events/event_listener.py+++ b/src/crewai/utilities/events/event_listener.py@@ -56,6 +56,11 @@ from .tool_usage_events import (ToolUsageFinishedEvent,ToolUsageStartedEvent,)+from .reasoning_events import (+ AgentReasoningStartedEvent,+ AgentReasoningCompletedEvent,+ AgentReasoningFailedEvent,+)class EventListener(BaseEventListener):@@ -406,5 +411,30 @@ class EventListener(BaseEventListener):self.formatter.current_crew_tree,)+ # ----------- REASONING EVENTS -----------++ @crewai_event_bus.on(AgentReasoningStartedEvent)+ def on_agent_reasoning_started(source, event: AgentReasoningStartedEvent):+ self.formatter.handle_reasoning_started(+ self.formatter.current_agent_branch,+ event.attempt,+ self.formatter.current_crew_tree,+ )++ @crewai_event_bus.on(AgentReasoningCompletedEvent)+ def on_agent_reasoning_completed(source, event: AgentReasoningCompletedEvent):+ self.formatter.handle_reasoning_completed(+ event.plan,+ event.ready,+ self.formatter.current_crew_tree,+ )++ @crewai_event_bus.on(AgentReasoningFailedEvent)+ def on_agent_reasoning_failed(source, event: AgentReasoningFailedEvent):+ self.formatter.handle_reasoning_failed(+ event.error,+ self.formatter.current_crew_tree,+ )+event_listener = EventListener()diff --git a/src/crewai/utilities/events/event_types.py b/src/crewai/utilities/events/event_types.pyindex 4e0673758..5d4a41dcc 100644--- a/src/crewai/utilities/events/event_types.py+++ b/src/crewai/utilities/events/event_types.py@@ -43,6 +43,11 @@ from .tool_usage_events import (ToolUsageFinishedEvent,ToolUsageStartedEvent,)+from .reasoning_events import (+ AgentReasoningStartedEvent,+ AgentReasoningCompletedEvent,+ AgentReasoningFailedEvent,+)EventTypes = Union[CrewKickoffStartedEvent,@@ -74,4 +79,7 @@ EventTypes = Union[LLMStreamChunkEvent,LLMGuardrailStartedEvent,LLMGuardrailCompletedEvent,+ AgentReasoningStartedEvent,+ AgentReasoningCompletedEvent,+ AgentReasoningFailedEvent,]diff --git a/src/crewai/utilities/events/reasoning_events.py b/src/crewai/utilities/events/reasoning_events.pynew file mode 100644index 000000000..03d484de3--- /dev/null+++ b/src/crewai/utilities/events/reasoning_events.py@@ -0,0 +1,31 @@+from crewai.utilities.events.base_events import BaseEvent+++class AgentReasoningStartedEvent(BaseEvent):+ """Event emitted when an agent starts reasoning about a task."""++ type: str = "agent_reasoning_started"+ agent_role: str+ task_id: str+ attempt: int = 1 # The current reasoning/refinement attempt+++class AgentReasoningCompletedEvent(BaseEvent):+ """Event emitted when an agent finishes its reasoning process."""++ type: str = "agent_reasoning_completed"+ agent_role: str+ task_id: str+ plan: str+ ready: bool+ attempt: int = 1+++class AgentReasoningFailedEvent(BaseEvent):+ """Event emitted when the reasoning process fails."""++ type: str = "agent_reasoning_failed"+ agent_role: str+ task_id: str+ error: str+ attempt: int = 1\ No newline at end of filediff --git a/src/crewai/utilities/events/utils/console_formatter.py b/src/crewai/utilities/events/utils/console_formatter.pyindex b9adc9fda..e3ae471d2 100644--- a/src/crewai/utilities/events/utils/console_formatter.py+++ b/src/crewai/utilities/events/utils/console_formatter.py@@ -15,6 +15,7 @@ class ConsoleFormatter:current_method_branch: Optional[Tree] = Nonecurrent_lite_agent_branch: Optional[Tree] = Nonetool_usage_counts: Dict[str, int] = {}+ current_reasoning_branch: Optional[Tree] = None # Track reasoning statusdef __init__(self, verbose: bool = False):self.console = Console(width=None)@@ -399,7 +400,11 @@ class ConsoleFormatter:tree_to_use = branch_to_use or crew_treeif branch_to_use is None or tree_to_use is None:- return None+ # If we don't have a valid branch, default to crew_tree if provided+ if crew_tree is not None:+ branch_to_use = tree_to_use = crew_tree+ else:+ return None# Update tool usage countself.tool_usage_counts[tool_name] = self.tool_usage_counts.get(tool_name, 0) + 1@@ -501,7 +506,11 @@ class ConsoleFormatter:tree_to_use = branch_to_use or crew_treeif branch_to_use is None or tree_to_use is None:- return None+ # If we don't have a valid branch, default to crew_tree if provided+ if crew_tree is not None:+ branch_to_use = tree_to_use = crew_tree+ else:+ return None# Only add thinking status if we don't have a current tool branchif self.current_tool_branch is None:@@ -797,7 +806,7 @@ class ConsoleFormatter:tree_to_use = branch_to_use or crew_treeif branch_to_use is None or tree_to_use is None:- # If we don't have a valid branch, use crew_tree as the branch if available+ # If we don't have a valid branch, default to crew_tree if providedif crew_tree is not None:branch_to_use = tree_to_use = crew_treeelse:@@ -982,3 +991,118 @@ class ConsoleFormatter:"Knowledge Search Failed", "Search Error", "red", Error=error)self.print_panel(error_content, "Search Error", "red")++ # ----------- AGENT REASONING EVENTS -----------++ def handle_reasoning_started(+ self,+ agent_branch: Optional[Tree],+ attempt: int,+ crew_tree: Optional[Tree],+ ) -> Optional[Tree]:+ """Handle agent reasoning started (or refinement) event."""+ if not self.verbose:+ return None++ # Prefer LiteAgent branch if we are within a LiteAgent context+ branch_to_use = self.current_lite_agent_branch or agent_branch+ tree_to_use = branch_to_use or crew_tree++ if branch_to_use is None or tree_to_use is None:+ # If we don't have a valid branch, default to crew_tree if provided+ if crew_tree is not None:+ branch_to_use = tree_to_use = crew_tree+ else:+ return None++ # Reuse existing reasoning branch if present+ reasoning_branch = self.current_reasoning_branch+ if reasoning_branch is None:+ reasoning_branch = branch_to_use.add("")+ self.current_reasoning_branch = reasoning_branch++ # Build label text depending on attempt+ status_text = (+ f"Reasoning (Attempt {attempt})" if attempt > 1 else "Reasoning..."+ )+ self.update_tree_label(reasoning_branch, "🧠", status_text, "blue")++ self.print(tree_to_use)+ self.print()++ return reasoning_branch++ def handle_reasoning_completed(+ self,+ plan: str,+ ready: bool,+ crew_tree: Optional[Tree],+ ) -> None:+ """Handle agent reasoning completed event."""+ if not self.verbose:+ return++ reasoning_branch = self.current_reasoning_branch+ tree_to_use = (+ self.current_lite_agent_branch+ or self.current_agent_branch+ or crew_tree+ )++ style = "green" if ready else "yellow"+ status_text = "Reasoning Completed" if ready else "Reasoning Completed (Not Ready)"++ if reasoning_branch is not None:+ self.update_tree_label(reasoning_branch, "✅", status_text, style)++ if tree_to_use is not None:+ self.print(tree_to_use)++ # Show plan in a panel (trim very long plans)+ if plan:+ plan_panel = Panel(+ Text(plan, style="white"),+ title="🧠 Reasoning Plan",+ border_style=style,+ padding=(1, 2),+ )+ self.print(plan_panel)++ self.print()++ # Clear stored branch after completion+ self.current_reasoning_branch = None++ def handle_reasoning_failed(+ self,+ error: str,+ crew_tree: Optional[Tree],+ ) -> None:+ """Handle agent reasoning failure event."""+ if not self.verbose:+ return++ reasoning_branch = self.current_reasoning_branch+ tree_to_use = (+ self.current_lite_agent_branch+ or self.current_agent_branch+ or crew_tree+ )++ if reasoning_branch is not None:+ self.update_tree_label(reasoning_branch, "❌", "Reasoning Failed", "red")++ if tree_to_use is not None:+ self.print(tree_to_use)++ # Error panel+ error_content = self.create_status_content(+ "Reasoning Failed",+ "Error",+ "red",+ Error=error,+ )+ self.print_panel(error_content, "Reasoning Error", "red")++ # Clear stored branch after failure+ self.current_reasoning_branch = Nonediff --git a/src/crewai/utilities/reasoning_handler.py b/src/crewai/utilities/reasoning_handler.pyindex 2fa5dba3c..cb94eb38a 100644--- a/src/crewai/utilities/reasoning_handler.py+++ b/src/crewai/utilities/reasoning_handler.py@@ -8,6 +8,12 @@ from crewai.agent import Agentfrom crewai.task import Taskfrom crewai.utilities import I18Nfrom crewai.llm import LLM+from crewai.utilities.events.crewai_event_bus import crewai_event_bus+from crewai.utilities.events.reasoning_events import (+ AgentReasoningStartedEvent,+ AgentReasoningCompletedEvent,+ AgentReasoningFailedEvent,+)class ReasoningPlan(BaseModel):@@ -49,7 +55,55 @@ class AgentReasoning:Returns:AgentReasoningOutput: The output of the agent reasoning process."""- return self.__handle_agent_reasoning()+ # Emit a reasoning started event (attempt 1)+ try:+ crewai_event_bus.emit(+ self.agent,+ AgentReasoningStartedEvent(+ agent_role=self.agent.role,+ task_id=str(self.task.id),+ attempt=1,+ ),+ )+ except Exception:+ # Ignore event bus errors to avoid breaking execution+ pass++ try:+ output = self.__handle_agent_reasoning()++ # Emit reasoning completed event+ try:+ crewai_event_bus.emit(+ self.agent,+ AgentReasoningCompletedEvent(+ agent_role=self.agent.role,+ task_id=str(self.task.id),+ plan=output.plan.plan,+ ready=output.plan.ready,+ attempt=1,+ ),+ )+ except Exception:+ pass++ return output+ except Exception as e:+ # Emit reasoning failed event+ try:+ crewai_event_bus.emit(+ self.agent,+ AgentReasoningFailedEvent(+ agent_role=self.agent.role,+ task_id=str(self.task.id),+ error=str(e),+ attempt=1,+ ),+ )+ except Exception:+ pass++ raisedef __handle_agent_reasoning(self) -> AgentReasoningOutput:"""@@ -108,6 +162,19 @@ class AgentReasoning:max_attempts = self.agent.max_reasoning_attemptswhile not ready and (max_attempts is None or attempt < max_attempts):+ # Emit event for each refinement attempt+ try:+ crewai_event_bus.emit(+ self.agent,+ AgentReasoningStartedEvent(+ agent_role=self.agent.role,+ task_id=str(self.task.id),+ attempt=attempt + 1,+ ),+ )+ except Exception:+ pass+refine_prompt = self.__create_refine_prompt(plan)if self.llm.supports_function_calling():@@ -179,12 +246,18 @@ class AgentReasoning:backstory=self.__get_agent_backstory())+ # Prepare a simple callable that just returns the tool arguments as JSON+ def _create_reasoning_plan(plan: str, ready: bool): # noqa: N802+ """Return the reasoning plan result in JSON string form."""+ return json.dumps({"plan": plan, "ready": ready})+response = self.llm.call([{"role": "system", "content": system_prompt},{"role": "user", "content": prompt}],- tools=[function_schema]+ tools=[function_schema],+ available_functions={"create_reasoning_plan": _create_reasoning_plan},)self.logger.debug(f"Function calling response: {response[:100]}...")