fix: Add empty thought since its required

fixing LiteLLM callback replacement bug

docs/concepts/flows.mdx

@@ -18,60 +18,63 @@ Flows allow you to create structured, event-driven workflows. They provide a sea
 
 4. **Flexible Control Flow**: Implement conditional logic, loops, and branching within your workflows.
 
+5. **Input Flexibility**: Flows can accept inputs to initialize or update their state, with different handling for structured and unstructured state management.
+
 ## Getting Started
 
 Let's create a simple Flow where you will use OpenAI to generate a random city in one task and then use that city to generate a fun fact in another task.
 
-```python Code
+### Passing Inputs to Flows
 
+Flows can accept inputs to initialize or update their state before execution. The way inputs are handled depends on whether the flow uses structured or unstructured state management.
+
+#### Structured State Management
+
+In structured state management, the flow's state is defined using a Pydantic `BaseModel`. Inputs must match the model's schema, and any updates will overwrite the default values.
+
+```python
 from crewai.flow.flow import Flow, listen, start
-from dotenv import load_dotenv
-from litellm import completion
+from pydantic import BaseModel
 
+class ExampleState(BaseModel):
+    counter: int = 0
+    message: str = ""
 
-class ExampleFlow(Flow):
-    model = "gpt-4o-mini"
-
+class StructuredExampleFlow(Flow[ExampleState]):
     @start()
-    def generate_city(self):
-        print("Starting flow")
+    def first_method(self):
+        # Implementation
 
-        response = completion(
-            model=self.model,
-            messages=[
-                {
-                    "role": "user",
-                    "content": "Return the name of a random city in the world.",
-                },
-            ],
-        )
+flow = StructuredExampleFlow()
+flow.kickoff(inputs={"counter": 10})
+```
 
-        random_city = response["choices"][0]["message"]["content"]
-        print(f"Random City: {random_city}")
+In this example, the `counter` is initialized to `10`, while `message` retains its default value.
 
-        return random_city
+#### Unstructured State Management
 
-    @listen(generate_city)
-    def generate_fun_fact(self, random_city):
-        response = completion(
-            model=self.model,
-            messages=[
-                {
-                    "role": "user",
-                    "content": f"Tell me a fun fact about {random_city}",
-                },
-            ],
-        )
+In unstructured state management, the flow's state is a dictionary. You can pass any dictionary to update the state.
 
-        fun_fact = response["choices"][0]["message"]["content"]
-        return fun_fact
+```python
+from crewai.flow.flow import Flow, listen, start
 
+class UnstructuredExampleFlow(Flow):
+    @start()
+    def first_method(self):
+        # Implementation
 
+flow = UnstructuredExampleFlow()
+flow.kickoff(inputs={"counter": 5, "message": "Initial message"})
+```
 
-flow = ExampleFlow()
-result = flow.kickoff()
+Here, both `counter` and `message` are updated based on the provided inputs.
 
-print(f"Generated fun fact: {result}")
+**Note:** Ensure that inputs for structured state management adhere to the defined schema to avoid validation errors.
+
+### Example Flow
+
+```python
+# Existing example code
 ```
 
 In the above example, we have created a simple Flow that generates a random city using OpenAI and then generates a fun fact about that city. The Flow consists of two tasks: `generate_city` and `generate_fun_fact`. The `generate_city` task is the starting point of the Flow, and the `generate_fun_fact` task listens for the output of the `generate_city` task.
@@ -94,14 +97,14 @@ The `@listen()` decorator can be used in several ways:
 
 1. **Listening to a Method by Name**: You can pass the name of the method you want to listen to as a string. When that method completes, the listener method will be triggered.
 
-   ```python Code
+   ```python
    @listen("generate_city")
    def generate_fun_fact(self, random_city):
        # Implementation
    ```
 
 2. **Listening to a Method Directly**: You can pass the method itself. When that method completes, the listener method will be triggered.
-   ```python Code
+   ```python
    @listen(generate_city)
    def generate_fun_fact(self, random_city):
        # Implementation
@@ -118,7 +121,7 @@ When you run a Flow, the final output is determined by the last method that comp
 Here's how you can access the final output:
 
 <CodeGroup>
-```python Code
+```python
 from crewai.flow.flow import Flow, listen, start
 
 class OutputExampleFlow(Flow):
@@ -130,18 +133,17 @@ class OutputExampleFlow(Flow):
     def second_method(self, first_output):
         return f"Second method received: {first_output}"
 
-
 flow = OutputExampleFlow()
 final_output = flow.kickoff()
 
 print("---- Final Output ----")
 print(final_output)
-````
+```
 
-``` text Output
+```text
 ---- Final Output ----
 Second method received: Output from first_method
-````
+```
 
 </CodeGroup>
 
@@ -156,7 +158,7 @@ Here's an example of how to update and access the state:
 
 <CodeGroup>
 
-```python Code
+```python
 from crewai.flow.flow import Flow, listen, start
 from pydantic import BaseModel
 
@@ -184,7 +186,7 @@ print("Final State:")
 print(flow.state)
 ```
 
-```text Output
+```text
 Final Output: Hello from first_method - updated by second_method
 Final State:
 counter=2 message='Hello from first_method - updated by second_method'
@@ -208,10 +210,10 @@ allowing developers to choose the approach that best fits their application's ne
 In unstructured state management, all state is stored in the `state` attribute of the `Flow` class.
 This approach offers flexibility, enabling developers to add or modify state attributes on the fly without defining a strict schema.
 
-```python Code
+```python
 from crewai.flow.flow import Flow, listen, start
 
-class UntructuredExampleFlow(Flow):
+class UnstructuredExampleFlow(Flow):
 
     @start()
     def first_method(self):
@@ -230,8 +232,7 @@ class UntructuredExampleFlow(Flow):
 
         print(f"State after third_method: {self.state}")
 
-
-flow = UntructuredExampleFlow()
+flow = UnstructuredExampleFlow()
 flow.kickoff()
 ```
 
@@ -245,16 +246,14 @@ flow.kickoff()
 Structured state management leverages predefined schemas to ensure consistency and type safety across the workflow.
 By using models like Pydantic's `BaseModel`, developers can define the exact shape of the state, enabling better validation and auto-completion in development environments.
 
-```python Code
+```python
 from crewai.flow.flow import Flow, listen, start
 from pydantic import BaseModel
 
-
 class ExampleState(BaseModel):
     counter: int = 0
     message: str = ""
 
-
 class StructuredExampleFlow(Flow[ExampleState]):
 
     @start()
@@ -273,7 +272,6 @@ class StructuredExampleFlow(Flow[ExampleState]):
 
         print(f"State after third_method: {self.state}")
 
-
 flow = StructuredExampleFlow()
 flow.kickoff()
 ```
@@ -307,7 +305,7 @@ The `or_` function in Flows allows you to listen to multiple methods and trigger
 
 <CodeGroup>
 
-```python Code
+```python
 from crewai.flow.flow import Flow, listen, or_, start
 
 class OrExampleFlow(Flow):
@@ -324,13 +322,11 @@ class OrExampleFlow(Flow):
     def logger(self, result):
         print(f"Logger: {result}")
 
-
-
 flow = OrExampleFlow()
 flow.kickoff()
 ```
 
-```text Output
+```text
 Logger: Hello from the start method
 Logger: Hello from the second method
 ```
@@ -346,7 +342,7 @@ The `and_` function in Flows allows you to listen to multiple methods and trigge
 
 <CodeGroup>
 
-```python Code
+```python
 from crewai.flow.flow import Flow, and_, listen, start
 
 class AndExampleFlow(Flow):
@@ -368,7 +364,7 @@ flow = AndExampleFlow()
 flow.kickoff()
 ```
 
-```text Output
+```text
 ---- Logger ----
 {'greeting': 'Hello from the start method', 'joke': 'What do computers eat? Microchips.'}
 ```
@@ -385,7 +381,7 @@ You can specify different routes based on the output of the method, allowing you
 
 <CodeGroup>
 
-```python Code
+```python
 import random
 from crewai.flow.flow import Flow, listen, router, start
 from pydantic import BaseModel
@@ -416,12 +412,11 @@ class RouterFlow(Flow[ExampleState]):
     def fourth_method(self):
         print("Fourth method running")
 
-
 flow = RouterFlow()
 flow.kickoff()
 ```
 
-```text Output
+```text
 Starting the structured flow
 Third method running
 Fourth method running
@@ -484,7 +479,7 @@ The `main.py` file is where you create your flow and connect the crews together.
 
 Here's an example of how you can connect the `poem_crew` in the `main.py` file:
 
-```python Code
+```python
 #!/usr/bin/env python
 from random import randint
 
@@ -612,7 +607,7 @@ CrewAI provides two convenient methods to generate plots of your flows:
 
 If you are working directly with a flow instance, you can generate a plot by calling the `plot()` method on your flow object. This method will create an HTML file containing the interactive plot of your flow.
 
-```python Code
+```python
 # Assuming you have a flow instance
 flow.plot("my_flow_plot")
 ```

docs/concepts/llms.mdx

@@ -25,7 +25,100 @@ By default, CrewAI uses the `gpt-4o-mini` model. It uses environment variables i
 - `OPENAI_API_BASE`
 - `OPENAI_API_KEY`
 
-### 2. Custom LLM Objects
+### 2. Updating YAML files
+
+You can update the `agents.yml` file to refer to the LLM you want to use:
+
+```yaml Code
+researcher:
+    role: Research Specialist
+    goal: Conduct comprehensive research and analysis to gather relevant information,
+        synthesize findings, and produce well-documented insights.
+    backstory: A dedicated research professional with years of experience in academic
+        investigation, literature review, and data analysis, known for thorough and
+        methodical approaches to complex research questions.
+    verbose: true
+    llm: openai/gpt-4o
+    # llm: azure/gpt-4o-mini
+    # llm: gemini/gemini-pro
+    # llm: anthropic/claude-3-5-sonnet-20240620
+    # llm: bedrock/anthropic.claude-3-sonnet-20240229-v1:0
+    # llm: mistral/mistral-large-latest
+    # llm: ollama/llama3:70b
+    # llm: groq/llama-3.2-90b-vision-preview
+    # llm: watsonx/meta-llama/llama-3-1-70b-instruct
+    # ...
+```
+
+Keep in mind that you will need to set certain ENV vars depending on the model you are
+using to account for the credentials or set a custom LLM object like described below.
+Here are some of the required ENV vars for some of the LLM integrations:
+
+<AccordionGroup>
+    <Accordion title="OpenAI">
+    ```python Code
+    OPENAI_API_KEY=<your-api-key>
+    OPENAI_API_BASE=<optional-custom-base-url>
+    OPENAI_MODEL_NAME=<openai-model-name>
+    OPENAI_ORGANIZATION=<your-org-id>       # OPTIONAL
+    OPENAI_API_BASE=<openaiai-api-base>     # OPTIONAL
+    ```
+    </Accordion>
+
+    <Accordion title="Anthropic">
+    ```python Code
+    ANTHROPIC_API_KEY=<your-api-key>
+    ```
+    </Accordion>
+
+    <Accordion title="Google">
+    ```python Code
+    GEMINI_API_KEY=<your-api-key>
+    ```
+    </Accordion>
+
+    <Accordion title="Azure">
+    ```python Code
+    AZURE_API_KEY=<your-api-key>                    # "my-azure-api-key"
+    AZURE_API_BASE=<your-resource-url>              # "https://example-endpoint.openai.azure.com"
+    AZURE_API_VERSION=<api-version>                 # "2023-05-15"
+    AZURE_AD_TOKEN=<your-azure-ad-token>            # Optional
+    AZURE_API_TYPE=<your-azure-api-type>            # Optional
+    ```
+    </Accordion>
+
+    <Accordion title="AWS Bedrock">
+    ```python Code
+    AWS_ACCESS_KEY_ID=<your-access-key>
+    AWS_SECRET_ACCESS_KEY=<your-secret-key>
+    AWS_DEFAULT_REGION=<your-region>
+    ```
+    </Accordion>
+
+    <Accordion title="Mistral">
+    ```python Code
+    MISTRAL_API_KEY=<your-api-key>
+    ```
+    </Accordion>
+
+    <Accordion title="Groq">
+    ```python Code
+    GROQ_API_KEY=<your-api-key>
+    ```
+    </Accordion>
+
+    <Accordion title="IBM watsonx.ai">
+    ```python Code
+    WATSONX_URL=<your-url>                          # (required) Base URL of your WatsonX instance
+    WATSONX_APIKEY=<your-apikey>                    # (required) IBM cloud API key
+    WATSONX_TOKEN=<your-token>                      # (required) IAM auth token (alternative to APIKEY)
+    WATSONX_PROJECT_ID=<your-project-id>            # (optional) Project ID of your WatsonX instance
+    WATSONX_DEPLOYMENT_SPACE_ID=<your-space-id>     # (optional) ID of deployment space for deployed models
+    ```
+    </Accordion>
+</AccordionGroup>
+
+### 3. Custom LLM Objects
 
 Pass a custom LLM implementation or object from another library.
 
@@ -102,7 +195,7 @@ When configuring an LLM for your agent, you have access to a wide range of param
 
 These are examples of how to configure LLMs for your agent.
 
-<AccordionGroup>    
+<AccordionGroup>
     <Accordion title="OpenAI">
 
     ```python Code
@@ -133,10 +226,10 @@ These are examples of how to configure LLMs for your agent.
         model="cerebras/llama-3.1-70b",
         api_key="your-api-key-here"
     )
-    agent = Agent(llm=llm, ...) 
+    agent = Agent(llm=llm, ...)
     ```
     </Accordion>
- 
+
     <Accordion title="Ollama (Local LLMs)">
 
     CrewAI supports using Ollama for running open-source models locally:
@@ -150,7 +243,7 @@ These are examples of how to configure LLMs for your agent.
 
     agent = Agent(
         llm=LLM(
-            model="ollama/llama3.1", 
+            model="ollama/llama3.1",
             base_url="http://localhost:11434"
         ),
         ...
@@ -164,7 +257,7 @@ These are examples of how to configure LLMs for your agent.
     from crewai import LLM
 
     llm = LLM(
-        model="groq/llama3-8b-8192", 
+        model="groq/llama3-8b-8192",
         api_key="your-api-key-here"
     )
     agent = Agent(llm=llm, ...)
@@ -189,7 +282,7 @@ These are examples of how to configure LLMs for your agent.
     from crewai import LLM
 
     llm = LLM(
-        model="fireworks_ai/accounts/fireworks/models/llama-v3-70b-instruct",  
+        model="fireworks_ai/accounts/fireworks/models/llama-v3-70b-instruct",
         api_key="your-api-key-here"
     )
     agent = Agent(llm=llm, ...)
@@ -224,6 +317,29 @@ These are examples of how to configure LLMs for your agent.
     </Accordion>
 
     <Accordion title="IBM watsonx.ai">
+    You can use IBM Watson by seeting the following ENV vars:
+
+    ```python Code
+    WATSONX_URL=<your-url>
+    WATSONX_APIKEY=<your-apikey>
+    WATSONX_PROJECT_ID=<your-project-id>
+    ```
+
+    You can then define your agents llms by updating the `agents.yml`
+
+    ```yaml Code
+    researcher:
+        role: Research Specialist
+        goal: Conduct comprehensive research and analysis to gather relevant information,
+            synthesize findings, and produce well-documented insights.
+        backstory: A dedicated research professional with years of experience in academic
+            investigation, literature review, and data analysis, known for thorough and
+            methodical approaches to complex research questions.
+        verbose: true
+        llm: watsonx/meta-llama/llama-3-1-70b-instruct
+    ```
+
+    You can also set up agents more dynamically as a base level LLM instance, like bellow:
 
     ```python Code
     from crewai import LLM
@@ -247,7 +363,7 @@ These are examples of how to configure LLMs for your agent.
         api_key="your-api-key-here",
         base_url="your_api_endpoint"
     )
-    agent = Agent(llm=llm, ...) 
+    agent = Agent(llm=llm, ...)
     ```
     </Accordion>
 </AccordionGroup>

docs/quickstart.mdx

@@ -330,4 +330,4 @@ This will clear the crew's memory, allowing for a fresh start.
 
 ## Deploying Your Project
 
-The easiest way to deploy your crew is through [CrewAI Enterprise](https://www.crewai.com/crewaiplus), where you can deploy your crew in a few clicks.
+The easiest way to deploy your crew is through [CrewAI Enterprise](http://app.crewai.com/), where you can deploy your crew in a few clicks.

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crewai"
-version = "0.76.9"
+version = "0.79.4"
 description = "Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks."
 readme = "README.md"
 requires-python = ">=3.10,<=3.13"
@@ -16,7 +16,7 @@ dependencies = [
     "opentelemetry-exporter-otlp-proto-http>=1.22.0",
     "instructor>=1.3.3",
     "regex>=2024.9.11",
-    "crewai-tools>=0.13.4",
+    "crewai-tools>=0.14.0",
     "click>=8.1.7",
     "python-dotenv>=1.0.0",
     "appdirs>=1.4.4",
@@ -37,7 +37,7 @@ Documentation = "https://docs.crewai.com"
 Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
-tools = ["crewai-tools>=0.13.4"]
+tools = ["crewai-tools>=0.14.0"]
 agentops = ["agentops>=0.3.0"]
 
 [tool.uv]
@@ -52,7 +52,7 @@ dev-dependencies = [
     "mkdocs-material-extensions>=1.3.1",
     "pillow>=10.2.0",
     "cairosvg>=2.7.1",
-    "crewai-tools>=0.13.4",
+    "crewai-tools>=0.14.0",
     "pytest>=8.0.0",
     "pytest-vcr>=1.0.2",
     "python-dotenv>=1.0.0",

src/crewai/__init__.py

@@ -14,5 +14,5 @@ warnings.filterwarnings(
     category=UserWarning,
     module="pydantic.main",
 )
-__version__ = "0.76.9"
+__version__ = "0.79.4"
 __all__ = ["Agent", "Crew", "Process", "Task", "Pipeline", "Router", "LLM", "Flow"]

src/crewai/agent.py

@@ -8,6 +8,7 @@ from pydantic import Field, InstanceOf, PrivateAttr, model_validator
 from crewai.agents import CacheHandler
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.agents.crew_agent_executor import CrewAgentExecutor
+from crewai.cli.constants import ENV_VARS
 from crewai.llm import LLM
 from crewai.memory.contextual.contextual_memory import ContextualMemory
 from crewai.tools.agent_tools.agent_tools import AgentTools
@@ -122,6 +123,11 @@ class Agent(BaseAgent):
     @model_validator(mode="after")
     def post_init_setup(self):
         self.agent_ops_agent_name = self.role
+        unnacepted_attributes = [
+            "AWS_ACCESS_KEY_ID",
+            "AWS_SECRET_ACCESS_KEY",
+            "AWS_REGION_NAME",
+        ]
 
         # Handle different cases for self.llm
         if isinstance(self.llm, str):
@@ -131,8 +137,12 @@ class Agent(BaseAgent):
             # If it's already an LLM instance, keep it as is
             pass
         elif self.llm is None:
-            # If it's None, use environment variables or default
-            model_name = os.environ.get("OPENAI_MODEL_NAME", "gpt-4o-mini")
+            # Determine the model name from environment variables or use default
+            model_name = (
+                os.environ.get("OPENAI_MODEL_NAME")
+                or os.environ.get("MODEL")
+                or "gpt-4o-mini"
+            )
             llm_params = {"model": model_name}
 
             api_base = os.environ.get("OPENAI_API_BASE") or os.environ.get(
@@ -141,9 +151,44 @@ class Agent(BaseAgent):
             if api_base:
                 llm_params["base_url"] = api_base
 
-            api_key = os.environ.get("OPENAI_API_KEY")
-            if api_key:
-                llm_params["api_key"] = api_key
+            set_provider = model_name.split("/")[0] if "/" in model_name else "openai"
+
+            # Iterate over all environment variables to find matching API keys or use defaults
+            for provider, env_vars in ENV_VARS.items():
+                if provider == set_provider:
+                    for env_var in env_vars:
+                        if env_var["key_name"] in unnacepted_attributes:
+                            continue
+                        # Check if the environment variable is set
+                        if "key_name" in env_var:
+                            env_value = os.environ.get(env_var["key_name"])
+                            if env_value:
+                                # Map key names containing "API_KEY" to "api_key"
+                                key_name = (
+                                    "api_key"
+                                    if "API_KEY" in env_var["key_name"]
+                                    else env_var["key_name"]
+                                )
+                                # Map key names containing "API_BASE" to "api_base"
+                                key_name = (
+                                    "api_base"
+                                    if "API_BASE" in env_var["key_name"]
+                                    else key_name
+                                )
+                                # Map key names containing "API_VERSION" to "api_version"
+                                key_name = (
+                                    "api_version"
+                                    if "API_VERSION" in env_var["key_name"]
+                                    else key_name
+                                )
+                                llm_params[key_name] = env_value
+                        # Check for default values if the environment variable is not set
+                        elif env_var.get("default", False):
+                            for key, value in env_var.items():
+                                if key not in ["prompt", "key_name", "default"]:
+                                    # Only add default if the key is already set in os.environ
+                                    if key in os.environ:
+                                        llm_params[key] = value
 
             self.llm = LLM(**llm_params)
         else:

src/crewai/agents/crew_agent_executor.py

@@ -117,6 +117,15 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         callbacks=self.callbacks,
                     )
 
+                    if answer is None or answer == "":
+                        self._printer.print(
+                            content="Received None or empty response from LLM call.",
+                            color="red",
+                        )
+                        raise ValueError(
+                            "Invalid response from LLM call - None or empty."
+                        )
+
                     if not self.use_stop_words:
                         try:
                             self._format_answer(answer)
@@ -136,25 +145,26 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         formatted_answer.result = action_result
                         self._show_logs(formatted_answer)
 
-                        if self.step_callback:
-                            self.step_callback(formatted_answer)
+                    if self.step_callback:
+                        self.step_callback(formatted_answer)
 
-                        if self._should_force_answer():
-                            if self.have_forced_answer:
-                                return AgentFinish(
-                                    output=self._i18n.errors(
-                                        "force_final_answer_error"
-                                    ).format(formatted_answer.text),
-                                    text=formatted_answer.text,
-                                )
-                            else:
-                                formatted_answer.text += (
-                                    f'\n{self._i18n.errors("force_final_answer")}'
-                                )
-                                self.have_forced_answer = True
-                        self.messages.append(
-                            self._format_msg(formatted_answer.text, role="assistant")
-                        )
+                    if self._should_force_answer():
+                        if self.have_forced_answer:
+                            return AgentFinish(
+                                thought="",
+                                output=self._i18n.errors(
+                                    "force_final_answer_error"
+                                ).format(formatted_answer.text),
+                                text=formatted_answer.text,
+                            )
+                        else:
+                            formatted_answer.text += (
+                                f'\n{self._i18n.errors("force_final_answer")}'
+                            )
+                            self.have_forced_answer = True
+                    self.messages.append(
+                        self._format_msg(formatted_answer.text, role="assistant")
+                    )
 
         except OutputParserException as e:
             self.messages.append({"role": "user", "content": e.error})
@@ -323,9 +333,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             if self.crew is not None and hasattr(self.crew, "_train_iteration"):
                 train_iteration = self.crew._train_iteration
                 if agent_id in training_data and isinstance(train_iteration, int):
-                    training_data[agent_id][train_iteration][
-                        "improved_output"
-                    ] = result.output
+                    training_data[agent_id][train_iteration]["improved_output"] = (
+                        result.output
+                    )
                     training_handler.save(training_data)
                 else:
                     self._logger.log(
@@ -376,4 +386,5 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         return CrewAgentParser(agent=self.agent).parse(answer)
 
     def _format_msg(self, prompt: str, role: str = "user") -> Dict[str, str]:
+        prompt = prompt.rstrip()
         return {"role": role, "content": prompt}

src/crewai/cli/add_crew_to_flow.py

@@ -54,7 +54,7 @@ def create_embedded_crew(crew_name: str, parent_folder: Path) -> None:
 
     templates_dir = Path(__file__).parent / "templates" / "crew"
     config_template_files = ["agents.yaml", "tasks.yaml"]
-    crew_template_file = f"{folder_name}_crew.py"  # Updated file name
+    crew_template_file = f"{folder_name}.py"  # Updated file name
 
     for file_name in config_template_files:
         src_file = templates_dir / "config" / file_name

src/crewai/cli/constants.py

@@ -1,19 +1,168 @@
 ENV_VARS = {
-    'openai': ['OPENAI_API_KEY'],
-    'anthropic': ['ANTHROPIC_API_KEY'],
-    'gemini': ['GEMINI_API_KEY'],
-    'groq': ['GROQ_API_KEY'],
-    'ollama': ['FAKE_KEY'],
+    "openai": [
+        {
+            "prompt": "Enter your OPENAI API key (press Enter to skip)",
+            "key_name": "OPENAI_API_KEY",
+        }
+    ],
+    "anthropic": [
+        {
+            "prompt": "Enter your ANTHROPIC API key (press Enter to skip)",
+            "key_name": "ANTHROPIC_API_KEY",
+        }
+    ],
+    "gemini": [
+        {
+            "prompt": "Enter your GEMINI API key (press Enter to skip)",
+            "key_name": "GEMINI_API_KEY",
+        }
+    ],
+    "groq": [
+        {
+            "prompt": "Enter your GROQ API key (press Enter to skip)",
+            "key_name": "GROQ_API_KEY",
+        }
+    ],
+    "watson": [
+        {
+            "prompt": "Enter your WATSONX URL (press Enter to skip)",
+            "key_name": "WATSONX_URL",
+        },
+        {
+            "prompt": "Enter your WATSONX API Key (press Enter to skip)",
+            "key_name": "WATSONX_APIKEY",
+        },
+        {
+            "prompt": "Enter your WATSONX Project Id (press Enter to skip)",
+            "key_name": "WATSONX_PROJECT_ID",
+        },
+    ],
+    "ollama": [
+        {
+            "default": True,
+            "API_BASE": "http://localhost:11434",
+        }
+    ],
+    "bedrock": [
+        {
+            "prompt": "Enter your AWS Access Key ID (press Enter to skip)",
+            "key_name": "AWS_ACCESS_KEY_ID",
+        },
+        {
+            "prompt": "Enter your AWS Secret Access Key (press Enter to skip)",
+            "key_name": "AWS_SECRET_ACCESS_KEY",
+        },
+        {
+            "prompt": "Enter your AWS Region Name (press Enter to skip)",
+            "key_name": "AWS_REGION_NAME",
+        },
+    ],
+    "azure": [
+        {
+            "prompt": "Enter your Azure deployment name (must start with 'azure/')",
+            "key_name": "model",
+        },
+        {
+            "prompt": "Enter your AZURE API key (press Enter to skip)",
+            "key_name": "AZURE_API_KEY",
+        },
+        {
+            "prompt": "Enter your AZURE API base URL (press Enter to skip)",
+            "key_name": "AZURE_API_BASE",
+        },
+        {
+            "prompt": "Enter your AZURE API version (press Enter to skip)",
+            "key_name": "AZURE_API_VERSION",
+        },
+    ],
+    "cerebras": [
+        {
+            "prompt": "Enter your Cerebras model name (must start with 'cerebras/')",
+            "key_name": "model",
+        },
+        {
+            "prompt": "Enter your Cerebras API version (press Enter to skip)",
+            "key_name": "CEREBRAS_API_KEY",
+        },
+    ],
 }
 
-PROVIDERS = ['openai', 'anthropic', 'gemini', 'groq', 'ollama']
+
+PROVIDERS = [
+    "openai",
+    "anthropic",
+    "gemini",
+    "groq",
+    "ollama",
+    "watson",
+    "bedrock",
+    "azure",
+    "cerebras",
+]
 
 MODELS = {
-    'openai': ['gpt-4', 'gpt-4o', 'gpt-4o-mini', 'o1-mini', 'o1-preview'],
-    'anthropic': ['claude-3-5-sonnet-20240620', 'claude-3-sonnet-20240229', 'claude-3-opus-20240229', 'claude-3-haiku-20240307'],
-    'gemini': ['gemini-1.5-flash', 'gemini-1.5-pro', 'gemini-gemma-2-9b-it', 'gemini-gemma-2-27b-it'],
-    'groq': ['llama-3.1-8b-instant', 'llama-3.1-70b-versatile', 'llama-3.1-405b-reasoning', 'gemma2-9b-it', 'gemma-7b-it'],
-    'ollama': ['llama3.1', 'mixtral'],
+    "openai": ["gpt-4", "gpt-4o", "gpt-4o-mini", "o1-mini", "o1-preview"],
+    "anthropic": [
+        "claude-3-5-sonnet-20240620",
+        "claude-3-sonnet-20240229",
+        "claude-3-opus-20240229",
+        "claude-3-haiku-20240307",
+    ],
+    "gemini": [
+        "gemini/gemini-1.5-flash",
+        "gemini/gemini-1.5-pro",
+        "gemini/gemini-gemma-2-9b-it",
+        "gemini/gemini-gemma-2-27b-it",
+    ],
+    "groq": [
+        "groq/llama-3.1-8b-instant",
+        "groq/llama-3.1-70b-versatile",
+        "groq/llama-3.1-405b-reasoning",
+        "groq/gemma2-9b-it",
+        "groq/gemma-7b-it",
+    ],
+    "ollama": ["ollama/llama3.1", "ollama/mixtral"],
+    "watson": [
+        "watsonx/google/flan-t5-xxl",
+        "watsonx/google/flan-ul2",
+        "watsonx/bigscience/mt0-xxl",
+        "watsonx/eleutherai/gpt-neox-20b",
+        "watsonx/ibm/mpt-7b-instruct2",
+        "watsonx/bigcode/starcoder",
+        "watsonx/meta-llama/llama-2-70b-chat",
+        "watsonx/meta-llama/llama-2-13b-chat",
+        "watsonx/ibm/granite-13b-instruct-v1",
+        "watsonx/ibm/granite-13b-chat-v1",
+        "watsonx/google/flan-t5-xl",
+        "watsonx/ibm/granite-13b-chat-v2",
+        "watsonx/ibm/granite-13b-instruct-v2",
+        "watsonx/elyza/elyza-japanese-llama-2-7b-instruct",
+        "watsonx/ibm-mistralai/mixtral-8x7b-instruct-v01-q",
+    ],
+    "bedrock": [
+        "bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0",
+        "bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
+        "bedrock/anthropic.claude-3-haiku-20240307-v1:0",
+        "bedrock/anthropic.claude-3-opus-20240229-v1:0",
+        "bedrock/anthropic.claude-v2:1",
+        "bedrock/anthropic.claude-v2",
+        "bedrock/anthropic.claude-instant-v1",
+        "bedrock/meta.llama3-1-405b-instruct-v1:0",
+        "bedrock/meta.llama3-1-70b-instruct-v1:0",
+        "bedrock/meta.llama3-1-8b-instruct-v1:0",
+        "bedrock/meta.llama3-70b-instruct-v1:0",
+        "bedrock/meta.llama3-8b-instruct-v1:0",
+        "bedrock/amazon.titan-text-lite-v1",
+        "bedrock/amazon.titan-text-express-v1",
+        "bedrock/cohere.command-text-v14",
+        "bedrock/ai21.j2-mid-v1",
+        "bedrock/ai21.j2-ultra-v1",
+        "bedrock/ai21.jamba-instruct-v1:0",
+        "bedrock/meta.llama2-13b-chat-v1",
+        "bedrock/meta.llama2-70b-chat-v1",
+        "bedrock/mistral.mistral-7b-instruct-v0:2",
+        "bedrock/mistral.mixtral-8x7b-instruct-v0:1",
+    ],
 }
 
-JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
+JSON_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"

src/crewai/cli/create_crew.py

@@ -1,11 +1,11 @@
+import shutil
 import sys
 from pathlib import Path
 
 import click
 
-from crewai.cli.constants import ENV_VARS
+from crewai.cli.constants import ENV_VARS, MODELS
 from crewai.cli.provider import (
-    PROVIDERS,
     get_provider_data,
     select_model,
     select_provider,
@@ -29,20 +29,20 @@ def create_folder_structure(name, parent_folder=None):
             click.secho("Operation cancelled.", fg="yellow")
             sys.exit(0)
         click.secho(f"Overriding folder {folder_name}...", fg="green", bold=True)
-    else:
-        click.secho(
-            f"Creating {'crew' if parent_folder else 'folder'} {folder_name}...",
-            fg="green",
-            bold=True,
-        )
+        shutil.rmtree(folder_path)  # Delete the existing folder and its contents
 
-    if not folder_path.exists():
-        folder_path.mkdir(parents=True)
-        (folder_path / "tests").mkdir(exist_ok=True)
-        if not parent_folder:
-            (folder_path / "src" / folder_name).mkdir(parents=True)
-            (folder_path / "src" / folder_name / "tools").mkdir(parents=True)
-            (folder_path / "src" / folder_name / "config").mkdir(parents=True)
+    click.secho(
+        f"Creating {'crew' if parent_folder else 'folder'} {folder_name}...",
+        fg="green",
+        bold=True,
+    )
+
+    folder_path.mkdir(parents=True)
+    (folder_path / "tests").mkdir(exist_ok=True)
+    if not parent_folder:
+        (folder_path / "src" / folder_name).mkdir(parents=True)
+        (folder_path / "src" / folder_name / "tools").mkdir(parents=True)
+        (folder_path / "src" / folder_name / "config").mkdir(parents=True)
 
     return folder_path, folder_name, class_name
 
@@ -92,7 +92,10 @@ def create_crew(name, provider=None, skip_provider=False, parent_folder=None):
 
         existing_provider = None
         for provider, env_keys in ENV_VARS.items():
-            if any(key in env_vars for key in env_keys):
+            if any(
+                "key_name" in details and details["key_name"] in env_vars
+                for details in env_keys
+            ):
                 existing_provider = provider
                 break
 
@@ -118,47 +121,48 @@ def create_crew(name, provider=None, skip_provider=False, parent_folder=None):
                 "No provider selected. Please try again or press 'q' to exit.", fg="red"
             )
 
-        while True:
-            selected_model = select_model(selected_provider, provider_models)
-            if selected_model is None:  # User typed 'q'
-                click.secho("Exiting...", fg="yellow")
-                sys.exit(0)
-            if selected_model:  # Valid selection
-                break
-            click.secho(
-                "No model selected. Please try again or press 'q' to exit.", fg="red"
-            )
+        # Check if the selected provider has predefined models
+        if selected_provider in MODELS and MODELS[selected_provider]:
+            while True:
+                selected_model = select_model(selected_provider, provider_models)
+                if selected_model is None:  # User typed 'q'
+                    click.secho("Exiting...", fg="yellow")
+                    sys.exit(0)
+                if selected_model:  # Valid selection
+                    break
+                click.secho(
+                    "No model selected. Please try again or press 'q' to exit.",
+                    fg="red",
+                )
+            env_vars["MODEL"] = selected_model
 
-        if selected_provider in PROVIDERS:
-            api_key_var = ENV_VARS[selected_provider][0]
-        else:
-            api_key_var = click.prompt(
-                f"Enter the environment variable name for your {selected_provider.capitalize()} API key",
-                type=str,
-                default="",
-            )
+        # Check if the selected provider requires API keys
+        if selected_provider in ENV_VARS:
+            provider_env_vars = ENV_VARS[selected_provider]
+            for details in provider_env_vars:
+                if details.get("default", False):
+                    # Automatically add default key-value pairs
+                    for key, value in details.items():
+                        if key not in ["prompt", "key_name", "default"]:
+                            env_vars[key] = value
+                elif "key_name" in details:
+                    # Prompt for non-default key-value pairs
+                    prompt = details["prompt"]
+                    key_name = details["key_name"]
+                    api_key_value = click.prompt(prompt, default="", show_default=False)
 
-        api_key_value = ""
-        click.echo(
-            f"Enter your {selected_provider.capitalize()} API key (press Enter to skip): ",
-            nl=False,
-        )
-        try:
-            api_key_value = input()
-        except (KeyboardInterrupt, EOFError):
-            api_key_value = ""
+                    if api_key_value.strip():
+                        env_vars[key_name] = api_key_value
 
-        if api_key_value.strip():
-            env_vars = {api_key_var: api_key_value}
+        if env_vars:
             write_env_file(folder_path, env_vars)
-            click.secho("API key saved to .env file", fg="green")
+            click.secho("API keys and model saved to .env file", fg="green")
         else:
             click.secho(
-                "No API key provided. Skipping .env file creation.", fg="yellow"
+                "No API keys provided. Skipping .env file creation.", fg="yellow"
             )
 
-        env_vars["MODEL"] = selected_model
-        click.secho(f"Selected model: {selected_model}", fg="green")
+        click.secho(f"Selected model: {env_vars.get('MODEL', 'N/A')}", fg="green")
 
     package_dir = Path(__file__).parent
     templates_dir = package_dir / "templates" / "crew"

src/crewai/cli/provider.py

@@ -164,7 +164,7 @@ def fetch_provider_data(cache_file):
     - dict or None: The fetched provider data or None if the operation fails.
     """
     try:
-        response = requests.get(JSON_URL, stream=True, timeout=10)
+        response = requests.get(JSON_URL, stream=True, timeout=60)
         response.raise_for_status()
         data = download_data(response)
         with open(cache_file, "w") as f:

src/crewai/cli/run_crew.py

@@ -24,7 +24,6 @@ def run_crew() -> None:
             f"Please run `crewai update` to update your pyproject.toml to use uv.",
             fg="red",
         )
-        print()
 
     try:
         subprocess.run(command, capture_output=False, text=True, check=True)

src/crewai/cli/templates/crew/crew.py

@@ -8,9 +8,12 @@ from crewai.project import CrewBase, agent, crew, task
 # from crewai_tools import SerperDevTool
 
 @CrewBase
-class {{crew_name}}Crew():
+class {{crew_name}}():
 	"""{{crew_name}} crew"""
 
+	agents_config = 'config/agents.yaml'
+	tasks_config = 'config/tasks.yaml'
+
 	@agent
 	def researcher(self) -> Agent:
 		return Agent(
@@ -48,4 +51,4 @@ class {{crew_name}}Crew():
 			process=Process.sequential,
 			verbose=True,
 			# process=Process.hierarchical, # In case you wanna use that instead https://docs.crewai.com/how-to/Hierarchical/
-		)
+		)

src/crewai/cli/templates/crew/main.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python
 import sys
-from {{folder_name}}.crew import {{crew_name}}Crew
+import warnings
+
+from {{folder_name}}.crew import {{crew_name}}
+
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
 
 # This main file is intended to be a way for you to run your
 # crew locally, so refrain from adding unnecessary logic into this file.
@@ -14,7 +18,7 @@ def run():
     inputs = {
         'topic': 'AI LLMs'
     }
-    {{crew_name}}Crew().crew().kickoff(inputs=inputs)
+    {{crew_name}}().crew().kickoff(inputs=inputs)
 
 
 def train():
@@ -25,7 +29,7 @@ def train():
         "topic": "AI LLMs"
     }
     try:
-        {{crew_name}}Crew().crew().train(n_iterations=int(sys.argv[1]), filename=sys.argv[2], inputs=inputs)
+        {{crew_name}}().crew().train(n_iterations=int(sys.argv[1]), filename=sys.argv[2], inputs=inputs)
 
     except Exception as e:
         raise Exception(f"An error occurred while training the crew: {e}")
@@ -35,7 +39,7 @@ def replay():
     Replay the crew execution from a specific task.
     """
     try:
-        {{crew_name}}Crew().crew().replay(task_id=sys.argv[1])
+        {{crew_name}}().crew().replay(task_id=sys.argv[1])
 
     except Exception as e:
         raise Exception(f"An error occurred while replaying the crew: {e}")
@@ -48,7 +52,7 @@ def test():
         "topic": "AI LLMs"
     }
     try:
-        {{crew_name}}Crew().crew().test(n_iterations=int(sys.argv[1]), openai_model_name=sys.argv[2], inputs=inputs)
+        {{crew_name}}().crew().test(n_iterations=int(sys.argv[1]), openai_model_name=sys.argv[2], inputs=inputs)
 
     except Exception as e:
         raise Exception(f"An error occurred while replaying the crew: {e}")

src/crewai/cli/templates/crew/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.76.9,<1.0.0"
+    "crewai[tools]>=0.79.4,<1.0.0"
 ]
 
 [project.scripts]

src/crewai/cli/templates/flow/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.76.9,<1.0.0",
+    "crewai[tools]>=0.79.4,<1.0.0",
 ]
 
 [project.scripts]

src/crewai/cli/templates/pipeline/pyproject.toml

@@ -6,7 +6,7 @@ authors = ["Your Name <you@example.com>"]
 
 [tool.poetry.dependencies]
 python = ">=3.10,<=3.13"
-crewai = { extras = ["tools"], version = ">=0.76.9,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.79.4,<1.0.0" }
 asyncio = "*"
 
 [tool.poetry.scripts]

src/crewai/cli/templates/pipeline_router/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = ["Your Name <you@example.com>"]
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.76.9,<1.0.0"
+    "crewai[tools]>=0.79.4,<1.0.0"
 ]
 
 [project.scripts]

src/crewai/cli/templates/tool/pyproject.toml

@@ -5,6 +5,6 @@ description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
 requires-python = ">=3.10,<=3.13"
 dependencies = [
-    "crewai[tools]>=0.76.9"
+    "crewai[tools]>=0.79.4"
 ]
 

src/crewai/crew.py

@@ -445,13 +445,14 @@ class Crew(BaseModel):
         training_data = CrewTrainingHandler(TRAINING_DATA_FILE).load()
 
         for agent in train_crew.agents:
-            result = TaskEvaluator(agent).evaluate_training_data(
-                training_data=training_data, agent_id=str(agent.id)
-            )
+            if training_data.get(str(agent.id)):
+                result = TaskEvaluator(agent).evaluate_training_data(
+                    training_data=training_data, agent_id=str(agent.id)
+                )
 
-            CrewTrainingHandler(filename).save_trained_data(
-                agent_id=str(agent.role), trained_data=result.model_dump()
-            )
+                CrewTrainingHandler(filename).save_trained_data(
+                    agent_id=str(agent.role), trained_data=result.model_dump()
+                )
 
     def kickoff(
         self,

src/crewai/flow/flow.py

@@ -1,8 +1,20 @@
 import asyncio
 import inspect
-from typing import Any, Callable, Dict, Generic, List, Set, Type, TypeVar, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Set,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 
 from crewai.flow.flow_visualizer import plot_flow
 from crewai.flow.utils import get_possible_return_constants
@@ -119,7 +131,6 @@ class FlowMeta(type):
                 condition_type = getattr(attr_value, "__condition_type__", "OR")
                 listeners[attr_name] = (condition_type, methods)
 
-            # TODO: should we add a check for __condition_type__ 'AND'?
             elif hasattr(attr_value, "__is_router__"):
                 routers[attr_value.__router_for__] = attr_name
                 possible_returns = get_possible_return_constants(attr_value)
@@ -159,8 +170,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
     def __init__(self) -> None:
         self._methods: Dict[str, Callable] = {}
         self._state: T = self._create_initial_state()
-        self._executed_methods: Set[str] = set()
-        self._scheduled_tasks: Set[str] = set()
+        self._method_execution_counts: Dict[str, int] = {}
         self._pending_and_listeners: Dict[str, Set[str]] = {}
         self._method_outputs: List[Any] = []  # List to store all method outputs
 
@@ -191,10 +201,74 @@ class Flow(Generic[T], metaclass=FlowMeta):
         """Returns the list of all outputs from executed methods."""
         return self._method_outputs
 
-    def kickoff(self) -> Any:
+    def _initialize_state(self, inputs: Dict[str, Any]) -> None:
+        """
+        Initializes or updates the state with the provided inputs.
+
+        Args:
+            inputs: Dictionary of inputs to initialize or update the state.
+
+        Raises:
+            ValueError: If inputs do not match the structured state model.
+            TypeError: If state is neither a BaseModel instance nor a dictionary.
+        """
+        if isinstance(self._state, BaseModel):
+            # Structured state management
+            try:
+                # Define a function to create the dynamic class
+                def create_model_with_extra_forbid(
+                    base_model: Type[BaseModel],
+                ) -> Type[BaseModel]:
+                    class ModelWithExtraForbid(base_model):  # type: ignore
+                        model_config = base_model.model_config.copy()
+                        model_config["extra"] = "forbid"
+
+                    return ModelWithExtraForbid
+
+                # Create the dynamic class
+                ModelWithExtraForbid = create_model_with_extra_forbid(
+                    self._state.__class__
+                )
+
+                # Create a new instance using the combined state and inputs
+                self._state = cast(
+                    T, ModelWithExtraForbid(**{**self._state.model_dump(), **inputs})
+                )
+
+            except ValidationError as e:
+                raise ValueError(f"Invalid inputs for structured state: {e}") from e
+        elif isinstance(self._state, dict):
+            # Unstructured state management
+            self._state.update(inputs)
+        else:
+            raise TypeError("State must be a BaseModel instance or a dictionary.")
+
+    def kickoff(self, inputs: Optional[Dict[str, Any]] = None) -> Any:
+        """
+        Starts the execution of the flow synchronously.
+
+        Args:
+            inputs: Optional dictionary of inputs to initialize or update the state.
+
+        Returns:
+            The final output from the flow execution.
+        """
+        if inputs is not None:
+            self._initialize_state(inputs)
         return asyncio.run(self.kickoff_async())
 
-    async def kickoff_async(self) -> Any:
+    async def kickoff_async(self, inputs: Optional[Dict[str, Any]] = None) -> Any:
+        """
+        Starts the execution of the flow asynchronously.
+
+        Args:
+            inputs: Optional dictionary of inputs to initialize or update the state.
+
+        Returns:
+            The final output from the flow execution.
+        """
+        if inputs is not None:
+            self._initialize_state(inputs)
         if not self._start_methods:
             raise ValueError("No start method defined")
 
@@ -233,7 +307,10 @@ class Flow(Generic[T], metaclass=FlowMeta):
         )
         self._method_outputs.append(result)  # Store the output
 
-        self._executed_methods.add(method_name)
+        # Track method execution counts
+        self._method_execution_counts[method_name] = (
+            self._method_execution_counts.get(method_name, 0) + 1
+        )
 
         return result
 
@@ -243,35 +320,34 @@ class Flow(Generic[T], metaclass=FlowMeta):
         if trigger_method in self._routers:
             router_method = self._methods[self._routers[trigger_method]]
             path = await self._execute_method(
-                trigger_method, router_method
-            )  # TODO: Change or not?
-            # Use the path as the new trigger method
+                self._routers[trigger_method], router_method
+            )
             trigger_method = path
 
         for listener_name, (condition_type, methods) in self._listeners.items():
             if condition_type == "OR":
                 if trigger_method in methods:
-                    if (
-                        listener_name not in self._executed_methods
-                        and listener_name not in self._scheduled_tasks
-                    ):
-                        self._scheduled_tasks.add(listener_name)
-                        listener_tasks.append(
-                            self._execute_single_listener(listener_name, result)
-                        )
+                    # Schedule the listener without preventing re-execution
+                    listener_tasks.append(
+                        self._execute_single_listener(listener_name, result)
+                    )
             elif condition_type == "AND":
-                if all(method in self._executed_methods for method in methods):
-                    if (
-                        listener_name not in self._executed_methods
-                        and listener_name not in self._scheduled_tasks
-                    ):
-                        self._scheduled_tasks.add(listener_name)
-                        listener_tasks.append(
-                            self._execute_single_listener(listener_name, result)
-                        )
+                # 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
+                self._pending_and_listeners[listener_name].discard(trigger_method)
+                if not self._pending_and_listeners[listener_name]:
+                    # All required methods have been executed
+                    listener_tasks.append(
+                        self._execute_single_listener(listener_name, result)
+                    )
+                    # Reset pending methods for this listener
+                    self._pending_and_listeners.pop(listener_name, None)
 
         # Run all listener tasks concurrently and wait for them to complete
-        await asyncio.gather(*listener_tasks)
+        if listener_tasks:
+            await asyncio.gather(*listener_tasks)
 
     async def _execute_single_listener(self, listener_name: str, result: Any) -> None:
         try:
@@ -291,9 +367,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 # If listener does not expect parameters, call without arguments
                 listener_result = await self._execute_method(listener_name, method)
 
-            # Remove from scheduled tasks after execution
-            self._scheduled_tasks.discard(listener_name)
-
             # Execute listeners of this listener
             await self._execute_listeners(listener_name, listener_result)
         except Exception as e:

src/crewai/llm.py

@@ -1,7 +1,10 @@
+import io
+import logging
+import sys
+import warnings
 from contextlib import contextmanager
 from typing import Any, Dict, List, Optional, Union
-import logging
-import warnings
+
 import litellm
 from litellm import get_supported_openai_params
 
@@ -9,9 +12,6 @@ from crewai.utilities.exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededException,
 )
 
-import sys
-import io
-
 
 class FilteredStream(io.StringIO):
     def write(self, s):
@@ -118,12 +118,12 @@ class LLM:
 
         litellm.drop_params = True
         litellm.set_verbose = False
-        litellm.callbacks = callbacks
+        self.set_callbacks(callbacks)
 
     def call(self, messages: List[Dict[str, str]], callbacks: List[Any] = []) -> str:
         with suppress_warnings():
             if callbacks and len(callbacks) > 0:
-                litellm.callbacks = callbacks
+                self.set_callbacks(callbacks)
 
             try:
                 params = {
@@ -181,3 +181,15 @@ class LLM:
     def get_context_window_size(self) -> int:
         # Only using 75% of the context window size to avoid cutting the message in the middle
         return int(LLM_CONTEXT_WINDOW_SIZES.get(self.model, 8192) * 0.75)
+
+    def set_callbacks(self, callbacks: List[Any]):
+        callback_types = [type(callback) for callback in callbacks]
+        for callback in litellm.success_callback[:]:
+            if type(callback) in callback_types:
+                litellm.success_callback.remove(callback)
+
+        for callback in litellm._async_success_callback[:]:
+            if type(callback) in callback_types:
+                litellm._async_success_callback.remove(callback)
+
+        litellm.callbacks = callbacks

src/crewai/memory/contextual/contextual_memory.py

@@ -34,7 +34,6 @@ class ContextualMemory:
         formatted_results = "\n".join(
             [f"- {result['context']}" for result in stm_results]
         )
-        print("formatted_results stm", formatted_results)
         return f"Recent Insights:\n{formatted_results}" if stm_results else ""
 
     def _fetch_ltm_context(self, task) -> Optional[str]:
@@ -54,8 +53,6 @@ class ContextualMemory:
         formatted_results = list(dict.fromkeys(formatted_results))
         formatted_results = "\n".join([f"- {result}" for result in formatted_results])  # type: ignore # Incompatible types in assignment (expression has type "str", variable has type "list[str]")
 
-        print("formatted_results ltm", formatted_results)
-
         return f"Historical Data:\n{formatted_results}" if ltm_results else ""
 
     def _fetch_entity_context(self, query) -> str:
@@ -67,5 +64,4 @@ class ContextualMemory:
         formatted_results = "\n".join(
             [f"- {result['context']}" for result in em_results]  # type: ignore #  Invalid index type "str" for "str"; expected type "SupportsIndex | slice"
         )
-        print("formatted_results em", formatted_results)
         return f"Entities:\n{formatted_results}" if em_results else ""

tests/cassettes/test_llm_callback_replacement.yaml

@@ -0,0 +1,205 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "user", "content": "Hello, world!"}], "model": "gpt-4o-mini",
+      "stream": false}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '101'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.52.1
+      x-stainless-arch:
+      - x64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - Linux
+      x-stainless-package-version:
+      - 1.52.1
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.11.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA4xSwWrcMBS8+ytedY6LvWvYZi8lpZSkBJLSQiChGK307FUi66nSc9Ml7L8H2e56
+        l7bQiw8zb8Yzg14yAGG0WINQW8mq8za/+Oqv5MUmXv+8+/Hl3uO3j59u1efreHO+/PAszpKCNo+o
+        +LfqraLOW2RDbqRVQMmYXMvVsqyWy1VVDERHGm2StZ7zivLOOJMvikWVF6u8fDept2QURrGGhwwA
+        4GX4ppxO4y+xhsFrQDqMUbYo1ocjABHIJkTIGE1k6ViczaQix+iG6JdoLb2BS3oGJR1cwSiAHfXA
+        pOXu/bEwYNNHmcK73toJ3x+SWGp9oE2c+APeGGfitg4oI7n018jkxcDuM4DvQ+P+pITwgTrPNdMT
+        umRYlqOdmHeeyfOJY2JpZ3gxjXRqVmtkaWw8GkwoqbaoZ+W8ruy1oSMiO6r8Z5a/eY+1jWv/x34m
+        lELPqGsfUBt12nc+C5ge4b/ODhMPgUXcRcauboxrMfhgxifQ+LrYyEKXi6opRbbPXgEAAP//AwAM
+        DMWoEAMAAA==
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 8e185b2c1b790303-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 12 Nov 2024 17:49:00 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=l.QrRLcNZkML_KSfxjir6YCV35B8GNTitBTNh7cPGc4-1731433740-1.0.1.1-j1ejlmykyoI8yk6i6pQjtPoovGzfxI2f5vG6u0EqodQMjCvhbHfNyN_wmYkeT._BMvFi.zDQ8m_PqEHr8tSdEQ;
+        path=/; expires=Tue, 12-Nov-24 18:19:00 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=jcCDyMK__Fd0V5DMeqt9yXdlKc7Hsw87a1K01pZu9l0-1731433740848-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-organization:
+      - user-tqfegqsiobpvvjmn0giaipdq
+      openai-processing-ms:
+      - '322'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '200000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '199978'
+      x-ratelimit-reset-requests:
+      - 8.64s
+      x-ratelimit-reset-tokens:
+      - 6ms
+      x-request-id:
+      - req_037288753767e763a51a04eae757ca84
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "user", "content": "Hello, world from another agent!"}],
+      "model": "gpt-4o-mini", "stream": false}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '120'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=l.QrRLcNZkML_KSfxjir6YCV35B8GNTitBTNh7cPGc4-1731433740-1.0.1.1-j1ejlmykyoI8yk6i6pQjtPoovGzfxI2f5vG6u0EqodQMjCvhbHfNyN_wmYkeT._BMvFi.zDQ8m_PqEHr8tSdEQ;
+        _cfuvid=jcCDyMK__Fd0V5DMeqt9yXdlKc7Hsw87a1K01pZu9l0-1731433740848-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.52.1
+      x-stainless-arch:
+      - x64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - Linux
+      x-stainless-package-version:
+      - 1.52.1
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.11.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA4xSy27bMBC86yu2PFuBZAt14UvRU5MA7aVAEKAIBJpcSUwoLkuu6jiB/z3QI5aM
+        tkAvPMzsDGZ2+ZoACKPFDoRqJKvW2/TLD3+z//oiD8dfL7d339zvW125x9zX90/3mVj1Cto/ouJ3
+        1ZWi1ltkQ26kVUDJ2Lvm201ebDbbIh+IljTaXlZ7TgtKW+NMus7WRZpt0/zTpG7IKIxiBz8TAIDX
+        4e1zOo3PYgfZ6h1pMUZZo9idhwBEINsjQsZoIkvHYjWTihyjG6Jfo7X0Ab4bhcAEipxDxXAw3IB0
+        xA0GkDU6voJrOoCSDm5gNIUjdcCk5fHz0jxg1UXZF3SdtRN+Oqe1VPtA+zjxZ7wyzsSmDCgjuT5Z
+        ZPJiYE8JwMOwle6iqPCBWs8l0xO63jAvRjsx32JBfpxIJpZ2xjfTJi/dSo0sjY2LrQolVYN6Vs4n
+        kJ02tCCSRec/w/zNe+xtXP0/9jOhFHpGXfqA2qjLwvNYwP6n/mvsvOMhsIjHyNiWlXE1Bh/M+E8q
+        X2Z7mel8XVS5SE7JGwAAAP//AwA/cK4yNQMAAA==
+    headers:
+      CF-Cache-Status:
+      - DYNAMIC
+      CF-RAY:
+      - 8e185b31398a0303-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 12 Nov 2024 17:49:02 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      openai-organization:
+      - user-tqfegqsiobpvvjmn0giaipdq
+      openai-processing-ms:
+      - '889'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '200000'
+      x-ratelimit-remaining-requests:
+      - '9998'
+      x-ratelimit-remaining-tokens:
+      - '199975'
+      x-ratelimit-reset-requests:
+      - 16.489s
+      x-ratelimit-reset-tokens:
+      - 7ms
+      x-request-id:
+      - req_bde3810b36a4859688e53d1df64bdd20
+    status:
+      code: 200
+      message: OK
+version: 1

tests/crew_test.py

@@ -1280,10 +1280,10 @@ def test_agent_usage_metrics_are_captured_for_hierarchical_process():
     assert result.raw == "Howdy!"
 
     assert result.token_usage == UsageMetrics(
-        total_tokens=2626,
-        prompt_tokens=2482,
-        completion_tokens=144,
-        successful_requests=5,
+        total_tokens=1673,
+        prompt_tokens=1562,
+        completion_tokens=111,
+        successful_requests=3,
     )
 
 

tests/flow_test.py

@@ -0,0 +1,264 @@
+"""Test Flow creation and execution basic functionality."""
+
+import asyncio
+
+import pytest
+from crewai.flow.flow import Flow, and_, listen, or_, router, start
+
+
+def test_simple_sequential_flow():
+    """Test a simple flow with two steps called sequentially."""
+    execution_order = []
+
+    class SimpleFlow(Flow):
+        @start()
+        def step_1(self):
+            execution_order.append("step_1")
+
+        @listen(step_1)
+        def step_2(self):
+            execution_order.append("step_2")
+
+    flow = SimpleFlow()
+    flow.kickoff()
+
+    assert execution_order == ["step_1", "step_2"]
+
+
+def test_flow_with_multiple_starts():
+    """Test a flow with multiple start methods."""
+    execution_order = []
+
+    class MultiStartFlow(Flow):
+        @start()
+        def step_a(self):
+            execution_order.append("step_a")
+
+        @start()
+        def step_b(self):
+            execution_order.append("step_b")
+
+        @listen(step_a)
+        def step_c(self):
+            execution_order.append("step_c")
+
+        @listen(step_b)
+        def step_d(self):
+            execution_order.append("step_d")
+
+    flow = MultiStartFlow()
+    flow.kickoff()
+
+    assert "step_a" in execution_order
+    assert "step_b" in execution_order
+    assert "step_c" in execution_order
+    assert "step_d" in execution_order
+    assert execution_order.index("step_c") > execution_order.index("step_a")
+    assert execution_order.index("step_d") > execution_order.index("step_b")
+
+
+def test_cyclic_flow():
+    """Test a cyclic flow that runs a finite number of iterations."""
+    execution_order = []
+
+    class CyclicFlow(Flow):
+        iteration = 0
+        max_iterations = 3
+
+        @start("loop")
+        def step_1(self):
+            if self.iteration >= self.max_iterations:
+                return  # Do not proceed further
+            execution_order.append(f"step_1_{self.iteration}")
+
+        @listen(step_1)
+        def step_2(self):
+            execution_order.append(f"step_2_{self.iteration}")
+
+        @router(step_2)
+        def step_3(self):
+            execution_order.append(f"step_3_{self.iteration}")
+            self.iteration += 1
+            if self.iteration < self.max_iterations:
+                return "loop"
+
+            return "exit"
+
+    flow = CyclicFlow()
+    flow.kickoff()
+
+    expected_order = []
+    for i in range(flow.max_iterations):
+        expected_order.extend([f"step_1_{i}", f"step_2_{i}", f"step_3_{i}"])
+
+    assert execution_order == expected_order
+
+
+def test_flow_with_and_condition():
+    """Test a flow where a step waits for multiple other steps to complete."""
+    execution_order = []
+
+    class AndConditionFlow(Flow):
+        @start()
+        def step_1(self):
+            execution_order.append("step_1")
+
+        @start()
+        def step_2(self):
+            execution_order.append("step_2")
+
+        @listen(and_(step_1, step_2))
+        def step_3(self):
+            execution_order.append("step_3")
+
+    flow = AndConditionFlow()
+    flow.kickoff()
+
+    assert "step_1" in execution_order
+    assert "step_2" in execution_order
+    assert execution_order[-1] == "step_3"
+    assert execution_order.index("step_3") > execution_order.index("step_1")
+    assert execution_order.index("step_3") > execution_order.index("step_2")
+
+
+def test_flow_with_or_condition():
+    """Test a flow where a step is triggered when any of multiple steps complete."""
+    execution_order = []
+
+    class OrConditionFlow(Flow):
+        @start()
+        def step_a(self):
+            execution_order.append("step_a")
+
+        @start()
+        def step_b(self):
+            execution_order.append("step_b")
+
+        @listen(or_(step_a, step_b))
+        def step_c(self):
+            execution_order.append("step_c")
+
+    flow = OrConditionFlow()
+    flow.kickoff()
+
+    assert "step_a" in execution_order or "step_b" in execution_order
+    assert "step_c" in execution_order
+    assert execution_order.index("step_c") > min(
+        execution_order.index("step_a"), execution_order.index("step_b")
+    )
+
+
+def test_flow_with_router():
+    """Test a flow that uses a router method to determine the next step."""
+    execution_order = []
+
+    class RouterFlow(Flow):
+        @start()
+        def start_method(self):
+            execution_order.append("start_method")
+
+        @router(start_method)
+        def router(self):
+            execution_order.append("router")
+            # Ensure the condition is set to True to follow the "step_if_true" path
+            condition = True
+            return "step_if_true" if condition else "step_if_false"
+
+        @listen("step_if_true")
+        def truthy(self):
+            execution_order.append("step_if_true")
+
+        @listen("step_if_false")
+        def falsy(self):
+            execution_order.append("step_if_false")
+
+    flow = RouterFlow()
+    flow.kickoff()
+
+    assert execution_order == ["start_method", "router", "step_if_true"]
+
+
+def test_async_flow():
+    """Test an asynchronous flow."""
+    execution_order = []
+
+    class AsyncFlow(Flow):
+        @start()
+        async def step_1(self):
+            execution_order.append("step_1")
+            await asyncio.sleep(0.1)
+
+        @listen(step_1)
+        async def step_2(self):
+            execution_order.append("step_2")
+            await asyncio.sleep(0.1)
+
+    flow = AsyncFlow()
+    asyncio.run(flow.kickoff_async())
+
+    assert execution_order == ["step_1", "step_2"]
+
+
+def test_flow_with_exceptions():
+    """Test flow behavior when exceptions occur in steps."""
+    execution_order = []
+
+    class ExceptionFlow(Flow):
+        @start()
+        def step_1(self):
+            execution_order.append("step_1")
+            raise ValueError("An error occurred in step_1")
+
+        @listen(step_1)
+        def step_2(self):
+            execution_order.append("step_2")
+
+    flow = ExceptionFlow()
+
+    with pytest.raises(ValueError):
+        flow.kickoff()
+
+    # Ensure step_2 did not execute
+    assert execution_order == ["step_1"]
+
+
+def test_flow_restart():
+    """Test restarting a flow after it has completed."""
+    execution_order = []
+
+    class RestartableFlow(Flow):
+        @start()
+        def step_1(self):
+            execution_order.append("step_1")
+
+        @listen(step_1)
+        def step_2(self):
+            execution_order.append("step_2")
+
+    flow = RestartableFlow()
+    flow.kickoff()
+    flow.kickoff()  # Restart the flow
+
+    assert execution_order == ["step_1", "step_2", "step_1", "step_2"]
+
+
+def test_flow_with_custom_state():
+    """Test a flow that maintains and modifies internal state."""
+
+    class StateFlow(Flow):
+        def __init__(self):
+            super().__init__()
+            self.counter = 0
+
+        @start()
+        def step_1(self):
+            self.counter += 1
+
+        @listen(step_1)
+        def step_2(self):
+            self.counter *= 2
+            assert self.counter == 2
+
+    flow = StateFlow()
+    flow.kickoff()
+    assert flow.counter == 2

tests/llm_test.py

@@ -0,0 +1,30 @@
+import pytest
+
+from crewai.agents.agent_builder.utilities.base_token_process import TokenProcess
+from crewai.llm import LLM
+from crewai.utilities.token_counter_callback import TokenCalcHandler
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_llm_callback_replacement():
+    llm = LLM(model="gpt-4o-mini")
+
+    calc_handler_1 = TokenCalcHandler(token_cost_process=TokenProcess())
+    calc_handler_2 = TokenCalcHandler(token_cost_process=TokenProcess())
+
+    llm.call(
+        messages=[{"role": "user", "content": "Hello, world!"}],
+        callbacks=[calc_handler_1],
+    )
+    usage_metrics_1 = calc_handler_1.token_cost_process.get_summary()
+
+    llm.call(
+        messages=[{"role": "user", "content": "Hello, world from another agent!"}],
+        callbacks=[calc_handler_2],
+    )
+    usage_metrics_2 = calc_handler_2.token_cost_process.get_summary()
+
+    # The first handler should not have been updated
+    assert usage_metrics_1.successful_requests == 1
+    assert usage_metrics_2.successful_requests == 1
+    assert usage_metrics_1 == calc_handler_1.token_cost_process.get_summary()

uv.lock

@@ -604,7 +604,7 @@ wheels = [
 
 [[package]]
 name = "crewai"
-version = "0.76.9"
+version = "0.79.4"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },
@@ -665,8 +665,8 @@ requires-dist = [
     { name = "auth0-python", specifier = ">=4.7.1" },
     { name = "chromadb", specifier = ">=0.4.24" },
     { name = "click", specifier = ">=8.1.7" },
-    { name = "crewai-tools", specifier = ">=0.13.4" },
-    { name = "crewai-tools", marker = "extra == 'tools'", specifier = ">=0.13.4" },
+    { name = "crewai-tools", specifier = ">=0.14.0" },
+    { name = "crewai-tools", marker = "extra == 'tools'", specifier = ">=0.14.0" },
     { name = "instructor", specifier = ">=1.3.3" },
     { name = "json-repair", specifier = ">=0.25.2" },
     { name = "jsonref", specifier = ">=1.1.0" },
@@ -688,7 +688,7 @@ requires-dist = [
 [package.metadata.requires-dev]
 dev = [
     { name = "cairosvg", specifier = ">=2.7.1" },
-    { name = "crewai-tools", specifier = ">=0.13.4" },
+    { name = "crewai-tools", specifier = ">=0.14.0" },
     { name = "mkdocs", specifier = ">=1.4.3" },
     { name = "mkdocs-material", specifier = ">=9.5.7" },
     { name = "mkdocs-material-extensions", specifier = ">=1.3.1" },
@@ -707,7 +707,7 @@ dev = [
 
 [[package]]
 name = "crewai-tools"
-version = "0.13.4"
+version = "0.14.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "beautifulsoup4" },
@@ -725,9 +725,9 @@ dependencies = [
     { name = "requests" },
     { name = "selenium" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/64/bd/eff7b633a0b28ff4ed115adde1499e3dcc683e4f0b5c378a4c6f5c0c1bf6/crewai_tools-0.13.4.tar.gz", hash = "sha256:b6ac527633b7018471d892c21ac96bc961a86b6626d996b1ed7d53cd481d4505", size = 816588 }
+sdist = { url = "https://files.pythonhosted.org/packages/9b/6d/4fa91b481b120f83bb58f365203d8aa8564e8ced1035d79f8aedb7d71e2f/crewai_tools-0.14.0.tar.gz", hash = "sha256:510f3a194bcda4fdae4314bd775521964b5f229ddbe451e5d9e0216cae57f4e3", size = 815892 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6c/40/93cd347d854059cf5e54a81b70f896deea7ad1f03e9c024549eb323c4da5/crewai_tools-0.13.4-py3-none-any.whl", hash = "sha256:eda78fe3c4df57676259d8dd6b2610fa31f89b90909512f15893adb57fb9e825", size = 463703 },
+    { url = "https://files.pythonhosted.org/packages/c8/ed/9f4e64e1507062957b0118085332d38b621c1000874baef2d1c4069bfd97/crewai_tools-0.14.0-py3-none-any.whl", hash = "sha256:0a804a828c29869c3af3253f4fc4c3967a3f80f06dab22e9bbe9526608a31564", size = 462980 },
 ]
 
 [[package]]