added validator for async_execution true in tasks whenever in hierarchical run

src/crewai/agents/agent_builder/utilities/base_output_converter_base.py

@@ -27,7 +27,7 @@ class OutputConverter(BaseModel, ABC):
     llm: Any = Field(description="The language model to be used to convert the text.")
     model: Any = Field(description="The model to be used to convert the text.")
     instructions: str = Field(description="Conversion instructions to the LLM.")
-    max_attempts: Optional[int] = Field(
+    max_attemps: Optional[int] = Field(
         description="Max number of attemps to try to get the output formated.",
         default=3,
     )

src/crewai/crew.py

@@ -1,7 +1,7 @@
 import asyncio
 import json
 import uuid
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Union, Tuple
 
 from langchain_core.callbacks import BaseCallbackHandler
 from pydantic import (
@@ -28,7 +28,6 @@ from crewai.task import Task
 from crewai.telemetry import Telemetry
 from crewai.tools.agent_tools import AgentTools
 from crewai.utilities import I18N, FileHandler, Logger, RPMController
-from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_FILE
 from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
 from crewai.utilities.training_handler import CrewTrainingHandler
 
@@ -290,9 +289,6 @@ class Crew(BaseModel):
         for agent in self.agents:
             agent.allow_delegation = False
 
-        CrewTrainingHandler(TRAINING_DATA_FILE).initialize_file()
-        CrewTrainingHandler(TRAINED_AGENTS_DATA_FILE).initialize_file()
-
     def train(self, n_iterations: int, inputs: Optional[Dict[str, Any]] = {}) -> None:
         """Trains the crew for a given number of iterations."""
         self._setup_for_training()
@@ -301,14 +297,14 @@ class Crew(BaseModel):
             self._train_iteration = n_iteration
             self.kickoff(inputs=inputs)
 
-        training_data = CrewTrainingHandler(TRAINING_DATA_FILE).load()
+        training_data = CrewTrainingHandler("training_data.pkl").load()
 
         for agent in self.agents:
             result = TaskEvaluator(agent).evaluate_training_data(
                 training_data=training_data, agent_id=str(agent.id)
             )
 
-            CrewTrainingHandler(TRAINED_AGENTS_DATA_FILE).save_trained_data(
+            CrewTrainingHandler("trained_agents_data.pkl").save_trained_data(
                 agent_id=str(agent.role), trained_data=result.model_dump()
             )
 
@@ -589,7 +585,9 @@ class Crew(BaseModel):
             self._rpm_controller.stop_rpm_counter()
         if agentops:
             agentops.end_session(
-                end_state="Success", end_state_reason="Finished Execution"
+                end_state="Success",
+                end_state_reason="Finished Execution",
+                is_auto_end=True,
             )
         self._telemetry.end_crew(self, output)
 

src/crewai/tools/tool_usage.py

@@ -97,7 +97,7 @@ class ToolUsage:
             self.task.increment_tools_errors()
             self._printer.print(content=f"\n\n{error}\n", color="red")
             return error
-        return f"{self._use(tool_string=tool_string, tool=tool, calling=calling)}"  # type: ignore # BUG?: "_use" of "ToolUsage" does not return a value (it only ever returns None)
+        return f"{self._use(tool_string=tool_string, tool=tool, calling=calling)}" # type: ignore # BUG?: "_use" of "ToolUsage" does not return a value (it only ever returns None)
 
     def _use(
         self,
@@ -105,8 +105,8 @@ class ToolUsage:
         tool: BaseTool,
         calling: Union[ToolCalling, InstructorToolCalling],
     ) -> str:  # TODO: Fix this return type
-        tool_event = agentops.ToolEvent(name=calling.tool_name) if agentops else None
-        if self._check_tool_repeated_usage(calling=calling):  # type: ignore # _check_tool_repeated_usage of "ToolUsage" does not return a value (it only ever returns None)
+        tool_event = agentops.ToolEvent(name=calling.tool_name) if agentops else None        
+        if self._check_tool_repeated_usage(calling=calling): # type: ignore # _check_tool_repeated_usage of "ToolUsage" does not return a value (it only ever returns None)
             try:
                 result = self._i18n.errors("task_repeated_usage").format(
                     tool_names=self.tools_names
@@ -117,20 +117,20 @@ class ToolUsage:
                     tool_name=tool.name,
                     attempts=self._run_attempts,
                 )
-                result = self._format_result(result=result)  # type: ignore #  "_format_result" of "ToolUsage" does not return a value (it only ever returns None)
+                result = self._format_result(result=result) # type: ignore #  "_format_result" of "ToolUsage" does not return a value (it only ever returns None)
                 return result  # type: ignore # Fix the reutrn type of this function
 
             except Exception:
                 self.task.increment_tools_errors()
 
-        result = None  # type: ignore # Incompatible types in assignment (expression has type "None", variable has type "str")
+        result = None # type: ignore # Incompatible types in assignment (expression has type "None", variable has type "str")
 
         if self.tools_handler.cache:
             result = self.tools_handler.cache.read(  # type: ignore # Incompatible types in assignment (expression has type "str | None", variable has type "str")
                 tool=calling.tool_name, input=calling.arguments
             )
 
-        if result is None:  #! finecwg: if not result --> if result is None
+        if result is None: #! finecwg: if not result --> if result is None
             try:
                 if calling.tool_name in [
                     "Delegate work to coworker",
@@ -140,7 +140,7 @@ class ToolUsage:
 
                 if calling.arguments:
                     try:
-                        acceptable_args = tool.args_schema.schema()["properties"].keys()  # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "schema"
+                        acceptable_args = tool.args_schema.schema()["properties"].keys() # type: ignore # Item "None" of "type[BaseModel] | None" has no attribute "schema"
                         arguments = {
                             k: v
                             for k, v in calling.arguments.items()
@@ -152,7 +152,7 @@ class ToolUsage:
                             arguments = calling.arguments
                             result = tool._run(**arguments)
                         else:
-                            arguments = calling.arguments.values()  # type: ignore # Incompatible types in assignment (expression has type "dict_values[str, Any]", variable has type "dict[str, Any]")
+                            arguments = calling.arguments.values() # type: ignore # Incompatible types in assignment (expression has type "dict_values[str, Any]", variable has type "dict[str, Any]")
                             result = tool._run(*arguments)
                 else:
                     result = tool._run()
@@ -201,14 +201,14 @@ class ToolUsage:
             llm=self.function_calling_llm,
             tool_name=tool.name,
             attempts=self._run_attempts,
-        )
-        result = self._format_result(result=result)  # type: ignore # "_format_result" of "ToolUsage" does not return a value (it only ever returns None)
+        )        
+        result = self._format_result(result=result) # type: ignore # "_format_result" of "ToolUsage" does not return a value (it only ever returns None)
         return result  # type: ignore # No return value expected
 
     def _format_result(self, result: Any) -> None:
         self.task.used_tools += 1
         if self._should_remember_format():  # type: ignore # "_should_remember_format" of "ToolUsage" does not return a value (it only ever returns None)
-            result = self._remember_format(result=result)  # type: ignore # "_remember_format" of "ToolUsage" does not return a value (it only ever returns None)
+            result = self._remember_format(result=result) # type: ignore # "_remember_format" of "ToolUsage" does not return a value (it only ever returns None)
         return result
 
     def _should_remember_format(self) -> None:
@@ -303,7 +303,7 @@ class ToolUsage:
               Example:
               {"tool_name": "tool name", "arguments": {"arg_name1": "value", "arg_name2": 2}}""",
                     ),
-                    max_attempts=1,
+                    max_attemps=1,
                 )
                 calling = converter.to_pydantic()
 

src/crewai/utilities/converter.py

@@ -32,7 +32,7 @@ class Converter(OutputConverter):
             else:
                 return self._create_chain().invoke({})
         except Exception as e:
-            if current_attempt < self.max_attempts:
+            if current_attempt < self.max_attemps:
                 return self.to_pydantic(current_attempt + 1)
             return ConverterError(
                 f"Failed to convert text into a pydantic model due to the following error: {e}"
@@ -46,7 +46,7 @@ class Converter(OutputConverter):
             else:
                 return json.dumps(self._create_chain().invoke({}).model_dump())
         except Exception:
-            if current_attempt < self.max_attempts:
+            if current_attempt < self.max_attemps:
                 return self.to_json(current_attempt + 1)
             return ConverterError("Failed to convert text into JSON.")
 
@@ -56,7 +56,7 @@ class Converter(OutputConverter):
 
         inst = Instructor(
             llm=self.llm,
-            max_attempts=self.max_attempts,
+            max_attemps=self.max_attemps,
             model=self.model,
             content=self.text,
             instructions=self.instructions,

src/crewai/utilities/file_handler.py

@@ -31,8 +31,9 @@ class PickleHandler:
         - file_name (str): The name of the file for saving and loading data.
         """
         self.file_path = os.path.join(os.getcwd(), file_name)
+        self._initialize_file()
 
-    def initialize_file(self) -> None:
+    def _initialize_file(self) -> None:
         """
         Initialize the file with an empty dictionary if it does not exist or is empty.
         """

tests/utilities/test_file_handler.py

@@ -17,10 +17,6 @@ class TestPickleHandler(unittest.TestCase):
             os.remove(self.file_path)
 
     def test_initialize_file(self):
-        assert os.path.exists(self.file_path) is False
-
-        self.handler.initialize_file()
-
         assert os.path.exists(self.file_path) is True
         assert os.path.getsize(self.file_path) >= 0