feat: fix test

docs/core-concepts/Crews.md

@@ -33,7 +33,6 @@ A crew in crewAI represents a collaborative group of agents working together to
 | **Manager Callbacks** _(optional)_    | `manager_callbacks`    | `manager_callbacks` takes a list of callback handlers to be executed by the manager agent when a hierarchical process is used.                                                                                                                            |
 | **Prompt File** _(optional)_          | `prompt_file`          | Path to the prompt JSON file to be used for the crew.                                                                                                                                                                                                     |
 | **Planning** *(optional)*             | `planning`             |  Adds planning ability to the Crew. When activated before each Crew iteration, all Crew data is sent to an AgentPlanner that will plan the tasks and this plan will be added to each task description.
-| **Planning LLM** *(optional)*         | `planning_llm`         | The language model used by the AgentPlanner in a planning process. |
 
 !!! note "Crew Max RPM"
 The `max_rpm` attribute sets the maximum number of requests per minute the crew can perform to avoid rate limits and will override individual agents' `max_rpm` settings if you set it.

docs/core-concepts/Planning.md

@@ -23,25 +23,6 @@ my_crew = Crew(
 
 From this point on, your crew will have planning enabled, and the tasks will be planned before each iteration.
 
-#### Planning LLM
-
-Now you can define the LLM that will be used to plan the tasks. You can use any ChatOpenAI LLM model available.
-
-```python
-from crewai import Crew, Agent, Task, Process
-from langchain_openai import ChatOpenAI
-
-# Assemble your crew with planning capabilities and custom LLM
-my_crew = Crew(
-    agents=self.agents,
-    tasks=self.tasks,
-    process=Process.sequential,
-    planning=True,
-    planning_llm=ChatOpenAI(model="gpt-4o")
-)
-```
-
-
 ### Example
 
 When running the base case example, you will see something like the following output, which represents the output of the AgentPlanner responsible for creating the step-by-step logic to add to the Agents tasks.

docs/how-to/Start-a-New-CrewAI-Project.md

@@ -16,7 +16,7 @@ We assume you have already installed CrewAI. If not, please refer to the [instal
 To create a new project, run the following CLI command:
 
 ```shell
-$ crewai create <project_name>
+$ crewai create my_project
 ```
 
 This command will create a new project folder with the following structure:
@@ -79,77 +79,8 @@ research_candidates_task:
     {job_requirements}
   expected_output: >
     A list of 10 potential candidates with their contact information and brief profiles highlighting their suitability.
-  agent: researcher # THIS NEEDS TO MATCH THE AGENT NAME IN THE AGENTS.YAML FILE AND THE AGENT DEFINED IN THE Crew.PY FILE
-  context: # THESE NEED TO MATCH THE TASK NAMES DEFINED ABOVE AND THE TASKS.YAML FILE AND THE TASK DEFINED IN THE Crew.PY FILE
-    - researcher
 ```
 
-### Referencing Variables:
-Your defined functions with the same name will be used. For example, you can reference the agent for specific tasks from task.yaml file. Ensure your annotated agent and function name is the same otherwise your task wont recognize the reference properly.
-
-#### Example References
-agent.yaml
-```yaml
-email_summarizer:
-    role: >
-      Email Summarizer
-    goal: >
-      Summarize emails into a concise and clear summary
-    backstory: >
-      You will create a 5 bullet point summary of the report
-    llm: mixtal_llm
-```
-
-task.yaml
-```yaml
-email_summarizer_task:
-    description: >
-      Summarize the email into a 5 bullet point summary
-    expected_output: >
-      A 5 bullet point summary of the email
-    agent: email_summarizer
-    context:
-      - reporting_task
-      - research_task
-```
-
-Use the annotations are used to properly reference the agent and task in the crew.py file.
-
-### Annotations include:
-* @agent
-* @task
-* @crew
-* @llm
-* @tool
-* @callback
-* @output_json
-* @output_pydantic
-* @cache_handler
-
-
-crew.py
-```py
-...
-    @llm
-    def mixtal_llm(self):
-        return ChatGroq(temperature=0, model_name="mixtral-8x7b-32768")
-
-    @agent
-    def email_summarizer(self) -> Agent:
-        return Agent(
-            config=self.agents_config["email_summarizer"],
-        )
-    ## ...other tasks defined
-    @task
-    def email_summarizer_task(self) -> Task:
-        return Task(
-            config=self.tasks_config["email_summarizer_task"],
-        )
-...
-```
-
-
-
 ## Installing Dependencies
 
 To install the dependencies for your project, you can use Poetry. First, navigate to your project directory:

src/crewai/cli/templates/config/tasks.yaml

@@ -5,7 +5,6 @@ research_task:
     the current year is 2024.
   expected_output: >
     A list with 10 bullet points of the most relevant information about {topic}
-  agent: researcher
 
 reporting_task:
   description: >
@@ -14,4 +13,3 @@ reporting_task:
   expected_output: >
     A fully fledge reports with the mains topics, each with a full section of information.
     Formatted as markdown without '```'
-  agent: reporting_analyst

src/crewai/cli/templates/crew.py

@@ -32,12 +32,14 @@ class {{crew_name}}Crew():
 	def research_task(self) -> Task:
 		return Task(
 			config=self.tasks_config['research_task'],
+			agent=self.researcher()
 		)
 
 	@task
 	def reporting_task(self) -> Task:
 		return Task(
 			config=self.tasks_config['reporting_task'],
+			agent=self.reporting_analyst(),
 			output_file='report.md'
 		)
 

src/crewai/crew.py

@@ -155,10 +155,6 @@ class Crew(BaseModel):
         default=False,
         description="Plan the crew execution and add the plan to the crew.",
     )
-    planning_llm: Optional[Any] = Field(
-        default=None,
-        description="Language model that will run the AgentPlanner if planning is True.",
-    )
     task_execution_output_json_files: Optional[List[str]] = Field(
         default=None,
         description="List of file paths for task execution JSON files.",
@@ -271,6 +267,20 @@ class Crew(BaseModel):
 
         return self
 
+    @model_validator(mode="after")
+    def check_tasks_in_hierarchical_process_not_async(self):
+        """Validates that the tasks in hierarchical process are not flagged with async_execution."""
+        if self.process == Process.hierarchical:
+            for task in self.tasks:
+                if task.async_execution:
+                    raise PydanticCustomError(
+                        "async_execution_in_hierarchical_process",
+                        "Hierarchical process error: Tasks cannot be flagged with async_execution.",
+                        {},
+                    )
+
+        return self
+
     @model_validator(mode="after")
     def validate_end_with_at_most_one_async_task(self):
         """Validates that the crew ends with at most one asynchronous task."""
@@ -550,12 +560,15 @@ class Crew(BaseModel):
     def _handle_crew_planning(self):
         """Handles the Crew planning."""
         self._logger.log("info", "Planning the crew execution")
-        result = CrewPlanner(
-            tasks=self.tasks, planning_agent_llm=self.planning_llm
-        )._handle_crew_planning()
+        result = CrewPlanner(self.tasks)._handle_crew_planning()
 
-        for task, step_plan in zip(self.tasks, result.list_of_plans_per_task):
-            task.description += step_plan
+        if result is not None and hasattr(result, "list_of_plans_per_task"):
+            for task, step_plan in zip(self.tasks, result.list_of_plans_per_task):
+                task.description += step_plan
+        else:
+            self._logger.log(
+                "info", "Something went wrong with the planning process of the Crew"
+            )
 
     def _store_execution_log(
         self,
@@ -593,7 +606,7 @@ class Crew(BaseModel):
     def _run_hierarchical_process(self) -> CrewOutput:
         """Creates and assigns a manager agent to make sure the crew completes the tasks."""
         self._create_manager_agent()
-        return self._execute_tasks(self.tasks)
+        return self._execute_tasks(self.tasks, self.manager_agent)
 
     def _create_manager_agent(self):
         i18n = I18N(prompt_file=self.prompt_file)
@@ -617,6 +630,7 @@ class Crew(BaseModel):
     def _execute_tasks(
         self,
         tasks: List[Task],
+        manager: Optional[BaseAgent] = None,
         start_index: Optional[int] = 0,
         was_replayed: bool = False,
     ) -> CrewOutput:
@@ -644,13 +658,13 @@ class Crew(BaseModel):
                         last_sync_output = task.output
                 continue
 
-            agent_to_use = self._get_agent_to_use(task)
+            agent_to_use = self._get_agent_to_use(task, manager)
             if agent_to_use is None:
                 raise ValueError(
                     f"No agent available for task: {task.description}. Ensure that either the task has an assigned agent or a manager agent is provided."
                 )
 
-            self._prepare_agent_tools(task)
+            self._prepare_agent_tools(task, manager)
             self._log_task_start(task, agent_to_use.role)
 
             if isinstance(task, ConditionalTask):
@@ -716,18 +730,20 @@ class Crew(BaseModel):
             return skipped_task_output
         return None
 
-    def _prepare_agent_tools(self, task: Task):
+    def _prepare_agent_tools(self, task: Task, manager: Optional[BaseAgent]):
         if self.process == Process.hierarchical:
-            if self.manager_agent:
-                self._update_manager_tools(task)
+            if manager:
+                self._update_manager_tools(task, manager)
             else:
                 raise ValueError("Manager agent is required for hierarchical process.")
         elif task.agent and task.agent.allow_delegation:
             self._add_delegation_tools(task)
 
-    def _get_agent_to_use(self, task: Task) -> Optional[BaseAgent]:
+    def _get_agent_to_use(
+        self, task: Task, manager: Optional[BaseAgent]
+    ) -> Optional[BaseAgent]:
         if self.process == Process.hierarchical:
-            return self.manager_agent
+            return manager
         return task.agent
 
     def _add_delegation_tools(self, task: Task):
@@ -763,14 +779,11 @@ class Crew(BaseModel):
         if self.output_log_file:
             self._file_handler.log(agent=role, task=task.description, status="started")
 
-    def _update_manager_tools(self, task: Task):
-        if self.manager_agent:
-            if task.agent:
-                self.manager_agent.tools = task.agent.get_delegation_tools([task.agent])
-            else:
-                self.manager_agent.tools = self.manager_agent.get_delegation_tools(
-                    self.agents
-                )
+    def _update_manager_tools(self, task: Task, manager: BaseAgent):
+        if task.agent:
+            manager.tools = task.agent.get_delegation_tools([task.agent])
+        else:
+            manager.tools = manager.get_delegation_tools(self.agents)
 
     def _get_context(self, task: Task, task_outputs: List[TaskOutput]):
         context = (
@@ -869,7 +882,7 @@ class Crew(BaseModel):
             self.tasks[i].output = task_output
 
         self._logging_color = "bold_blue"
-        result = self._execute_tasks(self.tasks, start_index, True)
+        result = self._execute_tasks(self.tasks, self.manager_agent, start_index, True)
         return result
 
     def copy(self):

src/crewai/project/__init__.py

@@ -1,25 +1,2 @@
-from .annotations import (
-    agent,
-    crew,
-    task,
-    output_json,
-    output_pydantic,
-    tool,
-    callback,
-    llm,
-    cache_handler,
-)
+from .annotations import agent, crew, task
 from .crew_base import CrewBase
-
-__all__ = [
-    "agent",
-    "crew",
-    "task",
-    "output_json",
-    "output_pydantic",
-    "tool",
-    "callback",
-    "CrewBase",
-    "llm",
-    "cache_handler",
-]

src/crewai/project/annotations.py

@@ -30,37 +30,6 @@ def agent(func):
     return func
 
 
-def llm(func):
-    func.is_llm = True
-    func = memoize(func)
-    return func
-
-
-def output_json(cls):
-    cls.is_output_json = True
-    return cls
-
-
-def output_pydantic(cls):
-    cls.is_output_pydantic = True
-    return cls
-
-
-def tool(func):
-    func.is_tool = True
-    return memoize(func)
-
-
-def callback(func):
-    func.is_callback = True
-    return memoize(func)
-
-
-def cache_handler(func):
-    func.is_cache_handler = True
-    return memoize(func)
-
-
 def crew(func):
     def wrapper(self, *args, **kwargs):
         instantiated_tasks = []

src/crewai/project/crew_base.py

@@ -1,7 +1,6 @@
 import inspect
 import os
 from pathlib import Path
-from typing import Any, Callable, Dict
 
 import yaml
 from dotenv import load_dotenv
@@ -21,6 +20,11 @@ def CrewBase(cls):
                 base_directory = Path(frame_info.filename).parent.resolve()
                 break
 
+        if base_directory is None:
+            raise Exception(
+                "Unable to dynamically determine the project's base directory, you must run it from the project's root directory."
+            )
+
         original_agents_config_path = getattr(
             cls, "agents_config", "config/agents.yaml"
         )
@@ -28,20 +32,12 @@ def CrewBase(cls):
 
         def __init__(self, *args, **kwargs):
             super().__init__(*args, **kwargs)
-
-            if self.base_directory is None:
-                raise Exception(
-                    "Unable to dynamically determine the project's base directory, you must run it from the project's root directory."
-                )
-
             self.agents_config = self.load_yaml(
                 os.path.join(self.base_directory, self.original_agents_config_path)
             )
             self.tasks_config = self.load_yaml(
                 os.path.join(self.base_directory, self.original_tasks_config_path)
             )
-            self.map_all_agent_variables()
-            self.map_all_task_variables()
 
         @staticmethod
         def load_yaml(config_path: str):
@@ -49,138 +45,4 @@ def CrewBase(cls):
                 # parsedContent = YamlParser.parse(file)  # type: ignore # Argument 1 to "parse" has incompatible type "TextIOWrapper"; expected "YamlParser"
                 return yaml.safe_load(file)
 
-        def _get_all_functions(self):
-            return {
-                name: getattr(self, name)
-                for name in dir(self)
-                if callable(getattr(self, name))
-            }
-
-        def _filter_functions(
-            self, functions: Dict[str, Callable], attribute: str
-        ) -> Dict[str, Callable]:
-            return {
-                name: func
-                for name, func in functions.items()
-                if hasattr(func, attribute)
-            }
-
-        def map_all_agent_variables(self) -> None:
-            all_functions = self._get_all_functions()
-            llms = self._filter_functions(all_functions, "is_llm")
-            tool_functions = self._filter_functions(all_functions, "is_tool")
-            cache_handler_functions = self._filter_functions(
-                all_functions, "is_cache_handler"
-            )
-            callbacks = self._filter_functions(all_functions, "is_callback")
-            agents = self._filter_functions(all_functions, "is_agent")
-
-            for agent_name, agent_info in self.agents_config.items():
-                self._map_agent_variables(
-                    agent_name,
-                    agent_info,
-                    agents,
-                    llms,
-                    tool_functions,
-                    cache_handler_functions,
-                    callbacks,
-                )
-
-        def _map_agent_variables(
-            self,
-            agent_name: str,
-            agent_info: Dict[str, Any],
-            agents: Dict[str, Callable],
-            llms: Dict[str, Callable],
-            tool_functions: Dict[str, Callable],
-            cache_handler_functions: Dict[str, Callable],
-            callbacks: Dict[str, Callable],
-        ) -> None:
-            if llm := agent_info.get("llm"):
-                self.agents_config[agent_name]["llm"] = llms[llm]()
-
-            if tools := agent_info.get("tools"):
-                self.agents_config[agent_name]["tools"] = [
-                    tool_functions[tool]() for tool in tools
-                ]
-
-            if function_calling_llm := agent_info.get("function_calling_llm"):
-                self.agents_config[agent_name]["function_calling_llm"] = agents[
-                    function_calling_llm
-                ]()
-
-            if step_callback := agent_info.get("step_callback"):
-                self.agents_config[agent_name]["step_callback"] = callbacks[
-                    step_callback
-                ]()
-
-            if cache_handler := agent_info.get("cache_handler"):
-                self.agents_config[agent_name]["cache_handler"] = (
-                    cache_handler_functions[cache_handler]()
-                )
-
-        def map_all_task_variables(self) -> None:
-            all_functions = self._get_all_functions()
-            agents = self._filter_functions(all_functions, "is_agent")
-            tasks = self._filter_functions(all_functions, "is_task")
-            output_json_functions = self._filter_functions(
-                all_functions, "is_output_json"
-            )
-            tool_functions = self._filter_functions(all_functions, "is_tool")
-            callback_functions = self._filter_functions(all_functions, "is_callback")
-            output_pydantic_functions = self._filter_functions(
-                all_functions, "is_output_pydantic"
-            )
-
-            for task_name, task_info in self.tasks_config.items():
-                self._map_task_variables(
-                    task_name,
-                    task_info,
-                    agents,
-                    tasks,
-                    output_json_functions,
-                    tool_functions,
-                    callback_functions,
-                    output_pydantic_functions,
-                )
-
-        def _map_task_variables(
-            self,
-            task_name: str,
-            task_info: Dict[str, Any],
-            agents: Dict[str, Callable],
-            tasks: Dict[str, Callable],
-            output_json_functions: Dict[str, Callable],
-            tool_functions: Dict[str, Callable],
-            callback_functions: Dict[str, Callable],
-            output_pydantic_functions: Dict[str, Callable],
-        ) -> None:
-            if context_list := task_info.get("context"):
-                self.tasks_config[task_name]["context"] = [
-                    tasks[context_task_name]() for context_task_name in context_list
-                ]
-
-            if tools := task_info.get("tools"):
-                self.tasks_config[task_name]["tools"] = [
-                    tool_functions[tool]() for tool in tools
-                ]
-
-            if agent_name := task_info.get("agent"):
-                self.tasks_config[task_name]["agent"] = agents[agent_name]()
-
-            if output_json := task_info.get("output_json"):
-                self.tasks_config[task_name]["output_json"] = output_json_functions[
-                    output_json
-                ]
-
-            if output_pydantic := task_info.get("output_pydantic"):
-                self.tasks_config[task_name]["output_pydantic"] = (
-                    output_pydantic_functions[output_pydantic]
-                )
-
-            if callbacks := task_info.get("callbacks"):
-                self.tasks_config[task_name]["callbacks"] = [
-                    callback_functions[callback]() for callback in callbacks
-                ]
-
     return WrappedClass

src/crewai/utilities/crew_pydantic_output_parser.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, List, Type
+from typing import Any, List, Type, Union
 
 import regex
 from langchain.output_parsers import PydanticOutputParser
@@ -7,24 +7,29 @@ from langchain_core.exceptions import OutputParserException
 from langchain_core.outputs import Generation
 from langchain_core.pydantic_v1 import ValidationError
 from pydantic import BaseModel
+from pydantic.v1 import BaseModel as V1BaseModel
 
 
 class CrewPydanticOutputParser(PydanticOutputParser):
     """Parses the text into pydantic models"""
 
-    pydantic_object: Type[BaseModel]
+    pydantic_object: Union[Type[BaseModel], Type[V1BaseModel]]
 
-    def parse_result(self, result: List[Generation]) -> Any:
+    def parse_result(self, result: List[Generation], *, partial: bool = False) -> Any:
         result[0].text = self._transform_in_valid_json(result[0].text)
 
         # Treating edge case of function calling llm returning the name instead of tool_name
         json_object = json.loads(result[0].text)
-        if "tool_name" not in json_object:
-            json_object["tool_name"] = json_object.get("name", "")
+        json_object["tool_name"] = (
+            json_object["name"]
+            if "tool_name" not in json_object
+            else json_object["tool_name"]
+        )
         result[0].text = json.dumps(json_object)
 
+        json_object = super().parse_result(result)
         try:
-            return self.pydantic_object.model_validate(json_object)
+            return self.pydantic_object.parse_obj(json_object)
         except ValidationError as e:
             name = self.pydantic_object.__name__
             msg = f"Failed to parse {name} from completion {json_object}. Got: {e}"

src/crewai/utilities/evaluators/task_evaluator.py

@@ -66,11 +66,11 @@ class TaskEvaluator:
             "- Entities extracted from the task output, if any, their type, description, and relationships"
         )
 
-        instructions = "Convert all responses into valid JSON output."
+        instructions = "I'm gonna convert this raw text into valid JSON."
 
         if not self._is_gpt(self.llm):
             model_schema = PydanticSchemaParser(model=TaskEvaluation).get_schema()
-            instructions = f"{instructions}\n\nReturn only valid JSON with the following schema:\n```json\n{model_schema}\n```"
+            instructions = f"{instructions}\n\nThe json should have the following structure, with the following keys:\n{model_schema}"
 
         converter = Converter(
             llm=self.llm,

src/crewai/utilities/planning_handler.py

@@ -1,6 +1,5 @@
-from typing import Any, List, Optional
+from typing import List, Optional
 
-from langchain_openai import ChatOpenAI
 from pydantic import BaseModel
 
 from crewai.agent import Agent
@@ -12,27 +11,17 @@ class PlannerTaskPydanticOutput(BaseModel):
 
 
 class CrewPlanner:
-    def __init__(self, tasks: List[Task], planning_agent_llm: Optional[Any] = None):
+    def __init__(self, tasks: List[Task]):
         self.tasks = tasks
 
-        if planning_agent_llm is None:
-            self.planning_agent_llm = ChatOpenAI(model="gpt-4o-mini")
-        else:
-            self.planning_agent_llm = planning_agent_llm
-
-    def _handle_crew_planning(self) -> PlannerTaskPydanticOutput:
+    def _handle_crew_planning(self) -> Optional[BaseModel]:
         """Handles the Crew planning by creating detailed step-by-step plans for each task."""
         planning_agent = self._create_planning_agent()
         tasks_summary = self._create_tasks_summary()
 
         planner_task = self._create_planner_task(planning_agent, tasks_summary)
 
-        result = planner_task.execute_sync()
-
-        if isinstance(result.pydantic, PlannerTaskPydanticOutput):
-            return result.pydantic
-
-        raise ValueError("Failed to get the Planning output")
+        return planner_task.execute_sync().pydantic
 
     def _create_planning_agent(self) -> Agent:
         """Creates the planning agent for the crew planning."""
@@ -43,7 +32,6 @@ class CrewPlanner:
                 "available to each agent so that they can perform the tasks in an exemplary manner"
             ),
             backstory="Planner agent for crew planning",
-            llm=self.planning_agent_llm,
         )
 
     def _create_planner_task(self, planning_agent: Agent, tasks_summary: str) -> Task:

src/crewai/utilities/pydantic_schema_parser.py

@@ -16,13 +16,11 @@ class PydanticSchemaParser(BaseModel):
         return self._get_model_schema(self.model)
 
     def _get_model_schema(self, model, depth=0) -> str:
-        indent = "    " * depth
-        lines = [f"{indent}{{"]
+        lines = []
         for field_name, field in model.model_fields.items():
             field_type_str = self._get_field_type(field, depth + 1)
-            lines.append(f"{indent}    {field_name}: {field_type_str},")
-        lines[-1] = lines[-1].rstrip(",")  # Remove trailing comma from last item
-        lines.append(f"{indent}}}")
+            lines.append(f"{' ' * 4 * depth}- {field_name}: {field_type_str}")
+
         return "\n".join(lines)
 
     def _get_field_type(self, field, depth) -> str:
@@ -37,6 +35,6 @@ class PydanticSchemaParser(BaseModel):
             else:
                 return f"List[{list_item_type.__name__}]"
         elif issubclass(field_type, BaseModel):
-            return self._get_model_schema(field_type, depth)
+            return f"\n{self._get_model_schema(field_type, depth)}"
         else:
             return field_type.__name__

tests/crew_test.py

@@ -1356,66 +1356,28 @@ def test_hierarchical_crew_creation_tasks_with_agents():
 
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_hierarchical_crew_creation_tasks_with_async_execution():
-    """
-    Agents are not required for tasks in a hierarchical process but sometimes they are still added
-    This test makes sure that the manager still delegates the task to the agent even if the agent is passed in the task
-    """
     from langchain_openai import ChatOpenAI
 
     task = Task(
-        description="Write one amazing paragraph about AI.",
-        expected_output="A single paragraph with 4 sentences.",
-        agent=writer,
-        async_execution=True,
+        description="Come up with a list of 5 interesting ideas to explore for an article, then write one amazing paragraph highlight for each idea that showcases how good an article about this topic could be. Return the list of ideas with their paragraph and your notes.",
+        expected_output="5 bullet points with a paragraph for each idea.",
+        async_execution=True,  # should throw an error
     )
 
-    crew = Crew(
-        tasks=[task],
-        agents=[writer, researcher, ceo],
-        process=Process.hierarchical,
-        manager_llm=ChatOpenAI(model="gpt-4o"),
+    with pytest.raises(pydantic_core._pydantic_core.ValidationError) as exec_info:
+        Crew(
+            tasks=[task],
+            agents=[researcher],
+            process=Process.hierarchical,
+            manager_llm=ChatOpenAI(model="gpt-4o"),
+        )
+
+    assert (
+        exec_info.value.errors()[0]["type"] == "async_execution_in_hierarchical_process"
     )
-
-    crew.kickoff()
-    assert crew.manager_agent is not None
-    assert crew.manager_agent.tools is not None
-    assert crew.manager_agent.tools[0].description.startswith(
-        "Delegate a specific task to one of the following coworkers: Senior Writer\n"
-    )
-
-
-@pytest.mark.vcr(filter_headers=["authorization"])
-def test_hierarchical_crew_creation_tasks_with_sync_last():
-    """
-    Agents are not required for tasks in a hierarchical process but sometimes they are still added
-    This test makes sure that the manager still delegates the task to the agent even if the agent is passed in the task
-    """
-    from langchain_openai import ChatOpenAI
-
-    task = Task(
-        description="Write one amazing paragraph about AI.",
-        expected_output="A single paragraph with 4 sentences.",
-        agent=writer,
-        async_execution=True,
-    )
-    task2 = Task(
-        description="Write one amazing paragraph about AI.",
-        expected_output="A single paragraph with 4 sentences.",
-        async_execution=False,
-    )
-
-    crew = Crew(
-        tasks=[task, task2],
-        agents=[writer, researcher, ceo],
-        process=Process.hierarchical,
-        manager_llm=ChatOpenAI(model="gpt-4o"),
-    )
-
-    crew.kickoff()
-    assert crew.manager_agent is not None
-    assert crew.manager_agent.tools is not None
-    assert crew.manager_agent.tools[0].description.startswith(
-        "Delegate a specific task to one of the following coworkers: Senior Writer, Researcher, CEO\n"
+    assert (
+        "Hierarchical process error: Tasks cannot be flagged with async_execution."
+        in exec_info.value.errors()[0]["msg"]
     )
 
 

tests/utilities/evaluators/test_task_evaluator.py

@@ -56,7 +56,8 @@ def test_evaluate_training_data(converter_mock):
                 "based on the human feedback\n",
                 model=TrainingTaskEvaluation,
                 instructions="I'm gonna convert this raw text into valid JSON.\n\nThe json should have the "
-                "following structure, with the following keys:\n{\n    suggestions: List[str],\n    quality: float,\n    final_summary: str\n}",
+                "following structure, with the following keys:\n- suggestions: List[str]\n- "
+                "quality: float\n- final_summary: str",
             ),
             mock.call().to_pydantic(),
         ]

tests/utilities/test_planning_handler.py

@@ -1,11 +1,10 @@
 from unittest.mock import patch
+from crewai.tasks.task_output import TaskOutput
 
 import pytest
-from langchain_openai import ChatOpenAI
 
 from crewai.agent import Agent
 from crewai.task import Task
-from crewai.tasks.task_output import TaskOutput
 from crewai.utilities.planning_handler import CrewPlanner, PlannerTaskPydanticOutput
 
 
@@ -29,19 +28,7 @@ class TestCrewPlanner:
                 agent=Agent(role="Agent 3", goal="Goal 3", backstory="Backstory 3"),
             ),
         ]
-        return CrewPlanner(tasks, None)
-
-    @pytest.fixture
-    def crew_planner_different_llm(self):
-        tasks = [
-            Task(
-                description="Task 1",
-                expected_output="Output 1",
-                agent=Agent(role="Agent 1", goal="Goal 1", backstory="Backstory 1"),
-            )
-        ]
-        planning_agent_llm = ChatOpenAI(model="gpt-3.5-turbo")
-        return CrewPlanner(tasks, planning_agent_llm)
+        return CrewPlanner(tasks)
 
     def test_handle_crew_planning(self, crew_planner):
         with patch.object(Task, "execute_sync") as execute:
@@ -53,7 +40,7 @@ class TestCrewPlanner:
                 ),
             )
             result = crew_planner._handle_crew_planning()
-            assert crew_planner.planning_agent_llm.model_name == "gpt-4o-mini"
+
             assert isinstance(result, PlannerTaskPydanticOutput)
             assert len(result.list_of_plans_per_task) == len(crew_planner.tasks)
             execute.assert_called_once()
@@ -85,22 +72,3 @@ class TestCrewPlanner:
         assert isinstance(tasks_summary, str)
         assert tasks_summary.startswith("\n                Task Number 1 - Task 1")
         assert tasks_summary.endswith('"agent_tools": []\n                ')
-
-    def test_handle_crew_planning_different_llm(self, crew_planner_different_llm):
-        with patch.object(Task, "execute_sync") as execute:
-            execute.return_value = TaskOutput(
-                description="Description",
-                agent="agent",
-                pydantic=PlannerTaskPydanticOutput(list_of_plans_per_task=["Plan 1"]),
-            )
-            result = crew_planner_different_llm._handle_crew_planning()
-
-            assert (
-                crew_planner_different_llm.planning_agent_llm.model_name
-                == "gpt-3.5-turbo"
-            )
-            assert isinstance(result, PlannerTaskPydanticOutput)
-            assert len(result.list_of_plans_per_task) == len(
-                crew_planner_different_llm.tasks
-            )
-            execute.assert_called_once()