flow template copy fix

.gitignore

@@ -2,7 +2,6 @@
 .pytest_cache
 __pycache__
 dist/
-lib/
 .env
 assets/*
 .idea
@@ -16,4 +15,4 @@ rc-tests/*
 *.pkl
 temp/*
 .vscode/*
-crew_tasks_output.json
+crew_tasks_output.json

docs/core-concepts/Flows.md

@@ -0,0 +1,556 @@
+# CrewAI Flows
+
+## Introduction
+
+CrewAI Flows is a powerful feature designed to streamline the creation and management of AI workflows. Flows allow developers to combine and coordinate coding tasks and Crews efficiently, providing a robust framework for building sophisticated AI automations.
+
+Flows allow you to create structured, event-driven workflows. They provide a seamless way to connect multiple tasks, manage state, and control the flow of execution in your AI applications. With Flows, you can easily design and implement multi-step processes that leverage the full potential of CrewAI's capabilities.
+
+1. **Simplified Workflow Creation**: Easily chain together multiple Crews and tasks to create complex AI workflows.
+
+2. **State Management**: Flows make it super easy to manage and share state between different tasks in your workflow.
+
+3. **Event-Driven Architecture**: Built on an event-driven model, allowing for dynamic and responsive workflows.
+
+4. **Flexible Control Flow**: Implement conditional logic, loops, and branching within your workflows.
+
+## 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
+import asyncio
+
+from crewai.flow.flow import Flow, listen, start
+from litellm import completion
+
+
+class ExampleFlow(Flow):
+    model = "gpt-4o-mini"
+
+    @start()
+    def generate_city(self):
+        print("Starting flow")
+
+        response = completion(
+            model=self.model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": "Return the name of a random city in the world.",
+                },
+            ],
+        )
+
+        random_city = response["choices"][0]["message"]["content"]
+        print(f"Random City: {random_city}")
+
+        return random_city
+
+    @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}",
+                },
+            ],
+        )
+
+        fun_fact = response["choices"][0]["message"]["content"]
+        return fun_fact
+
+
+async def main():
+    flow = ExampleFlow()
+    result = await flow.kickoff()
+
+    print(f"Generated fun fact: {result}")
+
+asyncio.run(main())
+```
+
+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.
+
+When you run the Flow, it will generate a random city and then generate a fun fact about that city. The output will be printed to the console.
+
+### @start()
+
+The `@start()` decorator is used to mark a method as the starting point of a Flow. When a Flow is started, all the methods decorated with `@start()` are executed in parallel. You can have multiple start methods in a Flow, and they will all be executed when the Flow is started.
+
+### @listen()
+
+The `@listen()` decorator is used to mark a method as a listener for the output of another task in the Flow. The method decorated with `@listen()` will be executed when the specified task emits an output. The method can access the output of the task it is listening to as an argument.
+
+#### Usage
+
+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
+   @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
+   @listen(generate_city)
+   def generate_fun_fact(self, random_city):
+       # Implementation
+   ```
+
+### Flow Output
+
+Accessing and handling the output of a Flow is essential for integrating your AI workflows into larger applications or systems. CrewAI Flows provide straightforward mechanisms to retrieve the final output, access intermediate results, and manage the overall state of your Flow.
+
+#### Retrieving the Final Output
+
+When you run a Flow, the final output is determined by the last method that completes. The `kickoff()` method returns the output of this final method.
+
+Here's how you can access the final output:
+
+```python
+import asyncio
+from crewai.flow.flow import Flow, listen, start
+
+class OutputExampleFlow(Flow):
+    @start()
+    def first_method(self):
+        return "Output from first_method"
+
+    @listen(first_method)
+    def second_method(self, first_output):
+        return f"Second method received: {first_output}"
+
+async def main():
+    flow = OutputExampleFlow()
+    final_output = await flow.kickoff()
+    print("---- Final Output ----")
+    print(final_output)
+
+asyncio.run(main())
+```
+
+In this example, the `second_method` is the last method to complete, so its output will be the final output of the Flow. The `kickoff()` method will return this final output, which is then printed to the console.
+
+The output of the Flow will be:
+
+```
+---- Final Output ----
+Second method received: Output from first_method
+```
+
+#### Accessing and Updating State
+
+In addition to retrieving the final output, you can also access and update the state within your Flow. The state can be used to store and share data between different methods in the Flow. After the Flow has run, you can access the state to retrieve any information that was added or updated during the execution.
+
+Here's an example of how to update and access the state:
+
+```python
+import asyncio
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class ExampleState(BaseModel):
+    counter: int = 0
+    message: str = ""
+
+class StateExampleFlow(Flow[ExampleState]):
+
+    @start()
+    def first_method(self):
+        self.state.message = "Hello from first_method"
+        self.state.counter += 1
+
+    @listen(first_method)
+    def second_method(self):
+        self.state.message += " - updated by second_method"
+        self.state.counter += 1
+        return self.state.message
+
+async def main():
+    flow = StateExampleFlow()
+    final_output = await flow.kickoff()
+    print(f"Final Output: {final_output}")
+    print("Final State:")
+    print(flow.state)
+
+asyncio.run(main())
+```
+
+In this example, the state is updated by both `first_method` and `second_method`. After the Flow has run, you can access the final state to see the updates made by these methods.
+
+The output of the Flow will be:
+
+```
+Final Output: Hello from first_method - updated by second_method
+Final State:
+counter=2 message='Hello from first_method - updated by second_method'
+```
+
+By ensuring that the final method's output is returned and providing access to the state, CrewAI Flows make it easy to integrate the results of your AI workflows into larger applications or systems, while also maintaining and accessing the state throughout the Flow's execution.
+
+## Flow State Management
+
+Managing state effectively is crucial for building reliable and maintainable AI workflows. CrewAI Flows provides robust mechanisms for both unstructured and structured state management, allowing developers to choose the approach that best fits their application's needs.
+
+### Unstructured State Management
+
+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
+import asyncio
+
+from crewai.flow.flow import Flow, listen, start
+
+class UntructuredExampleFlow(Flow):
+
+    @start()
+    def first_method(self):
+        self.state.message = "Hello from structured flow"
+        self.state.counter = 0
+
+    @listen(first_method)
+    def second_method(self):
+        self.state.counter += 1
+        self.state.message += " - updated"
+
+    @listen(second_method)
+    def third_method(self):
+        self.state.counter += 1
+        self.state.message += " - updated again"
+
+        print(f"State after third_method: {self.state}")
+
+
+async def main():
+    flow = UntructuredExampleFlow()
+    await flow.kickoff()
+
+
+asyncio.run(main())
+```
+
+**Key Points:**
+
+- **Flexibility:** You can dynamically add attributes to `self.state` without predefined constraints.
+- **Simplicity:** Ideal for straightforward workflows where state structure is minimal or varies significantly.
+
+### Structured State Management
+
+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
+import asyncio
+
+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()
+    def first_method(self):
+        self.state.message = "Hello from structured flow"
+
+    @listen(first_method)
+    def second_method(self):
+        self.state.counter += 1
+        self.state.message += " - updated"
+
+    @listen(second_method)
+    def third_method(self):
+        self.state.counter += 1
+        self.state.message += " - updated again"
+
+        print(f"State after third_method: {self.state}")
+
+
+async def main():
+    flow = StructuredExampleFlow()
+    await flow.kickoff()
+
+
+asyncio.run(main())
+```
+
+**Key Points:**
+
+- **Defined Schema:** `ExampleState` clearly outlines the state structure, enhancing code readability and maintainability.
+- **Type Safety:** Leveraging Pydantic ensures that state attributes adhere to the specified types, reducing runtime errors.
+- **Auto-Completion:** IDEs can provide better auto-completion and error checking based on the defined state model.
+
+### Choosing Between Unstructured and Structured State Management
+
+- **Use Unstructured State Management when:**
+
+  - The workflow's state is simple or highly dynamic.
+  - Flexibility is prioritized over strict state definitions.
+  - Rapid prototyping is required without the overhead of defining schemas.
+
+- **Use Structured State Management when:**
+  - The workflow requires a well-defined and consistent state structure.
+  - Type safety and validation are important for your application's reliability.
+  - You want to leverage IDE features like auto-completion and type checking for better developer experience.
+
+By providing both unstructured and structured state management options, CrewAI Flows empowers developers to build AI workflows that are both flexible and robust, catering to a wide range of application requirements.
+
+## Flow Control
+
+### Conditional Logic
+
+#### or
+
+The `or_` function in Flows allows you to listen to multiple methods and trigger the listener method when any of the specified methods emit an output.
+
+```python
+import asyncio
+from crewai.flow.flow import Flow, listen, or_, start
+
+class OrExampleFlow(Flow):
+
+    @start()
+    def start_method(self):
+        return "Hello from the start method"
+
+    @listen(start_method)
+    def second_method(self):
+        return "Hello from the second method"
+
+    @listen(or_(start_method, second_method))
+    def logger(self, result):
+        print(f"Logger: {result}")
+
+
+async def main():
+    flow = OrExampleFlow()
+    await flow.kickoff()
+
+
+asyncio.run(main())
+```
+
+When you run this Flow, the `logger` method will be triggered by the output of either the `start_method` or the `second_method`. The `or_` function is to listen to multiple methods and trigger the listener method when any of the specified methods emit an output.
+
+The output of the Flow will be:
+
+```
+Logger: Hello from the start method
+Logger: Hello from the second method
+```
+
+#### and
+
+The `and_` function in Flows allows you to listen to multiple methods and trigger the listener method only when all the specified methods emit an output.
+
+```python
+import asyncio
+from crewai.flow.flow import Flow, and_, listen, start
+
+class AndExampleFlow(Flow):
+
+    @start()
+    def start_method(self):
+        self.state["greeting"] = "Hello from the start method"
+
+    @listen(start_method)
+    def second_method(self):
+        self.state["joke"] = "What do computers eat? Microchips."
+
+    @listen(and_(start_method, second_method))
+    def logger(self):
+        print("---- Logger ----")
+        print(self.state)
+
+
+async def main():
+    flow = AndExampleFlow()
+    await flow.kickoff()
+
+
+asyncio.run(main())
+```
+
+When you run this Flow, the `logger` method will be triggered only when both the `start_method` and the `second_method` emit an output. The `and_` function is used to listen to multiple methods and trigger the listener method only when all the specified methods emit an output.
+
+The output of the Flow will be:
+
+```
+---- Logger ----
+{'greeting': 'Hello from the start method', 'joke': 'What do computers eat? Microchips.'}
+```
+
+### Router
+
+The `@router()` decorator in Flows allows you to define conditional routing logic based on the output of a method. You can specify different routes based on the output of the method, allowing you to control the flow of execution dynamically.
+
+```python
+import asyncio
+import random
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+
+class ExampleState(BaseModel):
+    success_flag: bool = False
+
+class RouterFlow(Flow[ExampleState]):
+
+    @start()
+    def start_method(self):
+        print("Starting the structured flow")
+        random_boolean = random.choice([True, False])
+        self.state.success_flag = random_boolean
+
+    @router(start_method)
+    def second_method(self):
+        if self.state.success_flag:
+            return "success"
+        else:
+            return "failed"
+
+    @listen("success")
+    def third_method(self):
+        print("Third method running")
+
+    @listen("failed")
+    def fourth_method(self):
+        print("Fourth method running")
+
+
+async def main():
+    flow = RouterFlow()
+    await flow.kickoff()
+
+
+asyncio.run(main())
+```
+
+In the above example, the `start_method` generates a random boolean value and sets it in the state. The `second_method` uses the `@router()` decorator to define conditional routing logic based on the value of the boolean. If the boolean is `True`, the method returns `"success"`, and if it is `False`, the method returns `"failed"`. The `third_method` and `fourth_method` listen to the output of the `second_method` and execute based on the returned value.
+
+When you run this Flow, the output will change based on the random boolean value generated by the `start_method`, but you should see an output similar to the following:
+
+```
+Starting the structured flow
+Third method running
+```
+
+## Adding Crews to Flows
+
+Creating a flow with multiple crews in CrewAI is straightforward. You can generate a new CrewAI project that includes all the scaffolding needed to create a flow with multiple crews by running the following command:
+
+```bash
+crewai create flow name_of_flow
+```
+
+This command will generate a new CrewAI project with the necessary folder structure. The generated project includes a prebuilt crew called `poem_crew` that is already working. You can use this crew as a template by copying, pasting, and editing it to create other crews.
+
+### Folder Structure
+
+After running the `crewai create flow name_of_flow` command, you will see a folder structure similar to the following:
+
+```
+name_of_flow/
+├── crews/
+│   └── poem_crew/
+│       ├── config/
+│       │   ├── agents.yaml
+│       │   └── tasks.yaml
+│       ├── poem_crew.py
+├── tools/
+│   └── custom_tool.py
+├── main.py
+├── README.md
+├── pyproject.toml
+└── .gitignore
+```
+
+### Building Your Crews
+
+In the `crews` folder, you can define multiple crews. Each crew will have its own folder containing configuration files and the crew definition file. For example, the `poem_crew` folder contains:
+
+- `config/agents.yaml`: Defines the agents for the crew.
+- `config/tasks.yaml`: Defines the tasks for the crew.
+- `poem_crew.py`: Contains the crew definition, including agents, tasks, and the crew itself.
+
+You can copy, paste, and edit the `poem_crew` to create other crews.
+
+### Connecting Crews in `main.py`
+
+The `main.py` file is where you create your flow and connect the crews together. You can define your flow by using the `Flow` class and the decorators `@start` and `@listen` to specify the flow of execution.
+
+Here's an example of how you can connect the `poem_crew` in the `main.py` file:
+
+```python
+#!/usr/bin/env python
+import asyncio
+from random import randint
+
+from pydantic import BaseModel
+from crewai.flow.flow import Flow, listen, start
+from .crews.poem_crew.poem_crew import PoemCrew
+
+class PoemState(BaseModel):
+    sentence_count: int = 1
+    poem: str = ""
+
+class PoemFlow(Flow[PoemState]):
+
+    @start()
+    def generate_sentence_count(self):
+        print("Generating sentence count")
+        # Generate a number between 1 and 5
+        self.state.sentence_count = randint(1, 5)
+
+    @listen(generate_sentence_count)
+    def generate_poem(self):
+        print("Generating poem")
+        poem_crew = PoemCrew().crew()
+        result = poem_crew.kickoff(inputs={"sentence_count": self.state.sentence_count})
+
+        print("Poem generated", result.raw)
+        self.state.poem = result.raw
+
+    @listen(generate_poem)
+    def save_poem(self):
+        print("Saving poem")
+        with open("poem.txt", "w") as f:
+            f.write(self.state.poem)
+
+async def run():
+    """
+    Run the flow.
+    """
+    poem_flow = PoemFlow()
+    await poem_flow.kickoff()
+
+def main():
+    asyncio.run(run())
+
+if __name__ == "__main__":
+    main()
+```
+
+In this example, the `PoemFlow` class defines a flow that generates a sentence count, uses the `PoemCrew` to generate a poem, and then saves the poem to a file. The flow is kicked off by calling the `kickoff()` method.
+
+## Next Steps
+
+If you're interested in exploring additional examples of flows, we have a variety of recommendations in our examples repository. Here are four specific flow examples, each showcasing unique use cases to help you match your current problem type to a specific example:
+
+1. **Email Auto Responder Flow**: This example demonstrates an infinite loop where a background job continually runs to automate email responses. It's a great use case for tasks that need to be performed repeatedly without manual intervention. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/email_auto_responder_flow)
+
+2. **Lead Score Flow**: This flow showcases adding human-in-the-loop feedback and handling different conditional branches using the router. It's an excellent example of how to incorporate dynamic decision-making and human oversight into your workflows. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/lead-score-flow)
+
+3. **Write a Book Flow**: This example excels at chaining multiple crews together, where the output of one crew is used by another. Specifically, one crew outlines an entire book, and another crew generates chapters based on the outline. Eventually, everything is connected to produce a complete book. This flow is perfect for complex, multi-step processes that require coordination between different tasks. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/write_a_book_with_flows)
+
+4. **Meeting Assistant Flow**: This flow demonstrates how to broadcast one event to trigger multiple follow-up actions. For instance, after a meeting is completed, the flow can update a Trello board, send a Slack message, and save the results. It's a great example of handling multiple outcomes from a single event, making it ideal for comprehensive task management and notification systems. [View Example](https://github.com/crewAIInc/crewAI-examples/tree/main/meeting_assistant_flow)
+
+By exploring these examples, you can gain insights into how to leverage CrewAI Flows for various use cases, from automating repetitive tasks to managing complex, multi-step processes with dynamic decision-making and human feedback.

docs/core-concepts/Pipeline.md

@@ -248,7 +248,7 @@ main_pipeline = Pipeline(stages=[classification_crew, email_router])
 
 inputs = [{"email": "..."}, {"email": "..."}]  # List of email data
 
-main_pipeline.kickoff(inputs=inputs)
+main_pipeline.kickoff(inputs=inputs=inputs)
 ```
 
 In this example, the router decides between an urgent pipeline and a normal pipeline based on the urgency score of the email. If the urgency score is greater than 7, it routes to the urgent pipeline; otherwise, it uses the normal pipeline. If the input doesn't include an urgency score, it defaults to just the classification crew.
@@ -265,4 +265,4 @@ In this example, the router decides between an urgent pipeline and a normal pipe
 The `Pipeline` class includes validation mechanisms to ensure the robustness of the pipeline structure:
 
 - Validates that stages contain only Crew instances or lists of Crew instances.
-- Prevents double nesting of stages to maintain a clear structure.
+- Prevents double nesting of stages to maintain a clear structure.

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "crewai"
-version = "0.66.0"
+version = "0.65.2"
 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."
 authors = ["Joao Moura <joao@crewai.com>"]
 readme = "README.md"
@@ -32,7 +32,6 @@ json-repair = "^0.25.2"
 auth0-python = "^4.7.1"
 poetry = "^1.8.3"
 litellm = "^1.44.22"
-pyvis = "^0.3.2"
 
 [tool.poetry.extras]
 tools = ["crewai-tools"]

src/crewai/__init__.py

@@ -1,13 +1,12 @@
 import warnings
-
 from crewai.agent import Agent
 from crewai.crew import Crew
-from crewai.flow.flow import Flow
-from crewai.llm import LLM
 from crewai.pipeline import Pipeline
 from crewai.process import Process
 from crewai.routers import Router
 from crewai.task import Task
+from crewai.llm import LLM
+
 
 warnings.filterwarnings(
     "ignore",
@@ -16,4 +15,4 @@ warnings.filterwarnings(
     module="pydantic.main",
 )
 
-__all__ = ["Agent", "Crew", "Process", "Task", "Pipeline", "Router", "LLM", "Flow"]
+__all__ = ["Agent", "Crew", "Process", "Task", "Pipeline", "Router", "LLM"]

src/crewai/cli/cli.py

@@ -12,14 +12,12 @@ from crewai.memory.storage.kickoff_task_outputs_storage import (
 
 from .authentication.main import AuthenticationCommand
 from .deploy.main import DeployCommand
+from .tools.main import ToolCommand
 from .evaluate_crew import evaluate_crew
 from .install_crew import install_crew
-from .plot_flow import plot_flow
 from .replay_from_task import replay_task_command
 from .reset_memories_command import reset_memories_command
 from .run_crew import run_crew
-from .run_flow import run_flow
-from .tools.main import ToolCommand
 from .train_crew import train_crew
 
 
@@ -275,25 +273,5 @@ def tool_publish(is_public: bool):
     tool_cmd.publish(is_public)
 
 
-@crewai.group()
-def flow():
-    """Flow related commands."""
-    pass
-
-
-@flow.command(name="run")
-def flow_run():
-    """Run the Flow."""
-    click.echo("Running the Flow")
-    run_flow()
-
-
-@flow.command(name="plot")
-def flow_plot():
-    """Plot the Flow."""
-    click.echo("Plotting the Flow")
-    plot_flow()
-
-
 if __name__ == "__main__":
     crewai()

src/crewai/cli/create_flow.py

@@ -38,7 +38,7 @@ def create_flow(name):
     ]
 
     def process_file(src_file, dst_file):
-        if src_file.suffix in [".pyc", ".pyo", ".pyd"]:
+        if src_file.suffix in ['.pyc', '.pyo', '.pyd']:
             return
 
         try:
@@ -47,6 +47,7 @@ def create_flow(name):
         except Exception as e:
             click.secho(f"Error processing file {src_file}: {e}", fg="red")
             return
+            content = file.read()
 
         content = content.replace("{{name}}", name)
         content = content.replace("{{flow_name}}", class_name)

src/crewai/cli/plot_flow.py

@@ -1,23 +0,0 @@
-import subprocess
-
-import click
-
-
-def plot_flow() -> None:
-    """
-    Plot the flow by running a command in the Poetry environment.
-    """
-    command = ["poetry", "run", "plot_flow"]
-
-    try:
-        result = subprocess.run(command, capture_output=False, text=True, check=True)
-
-        if result.stderr:
-            click.echo(result.stderr, err=True)
-
-    except subprocess.CalledProcessError as e:
-        click.echo(f"An error occurred while plotting the flow: {e}", err=True)
-        click.echo(e.output, err=True)
-
-    except Exception as e:
-        click.echo(f"An unexpected error occurred: {e}", err=True)

src/crewai/cli/run_flow.py

@@ -1,23 +0,0 @@
-import subprocess
-
-import click
-
-
-def run_flow() -> None:
-    """
-    Run the flow by running a command in the Poetry environment.
-    """
-    command = ["poetry", "run", "run_flow"]
-
-    try:
-        result = subprocess.run(command, capture_output=False, text=True, check=True)
-
-        if result.stderr:
-            click.echo(result.stderr, err=True)
-
-    except subprocess.CalledProcessError as e:
-        click.echo(f"An error occurred while running the flow: {e}", err=True)
-        click.echo(e.output, err=True)
-
-    except Exception as e:
-        click.echo(f"An unexpected error occurred: {e}", err=True)

src/crewai/cli/templates/crew/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.66.0,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.65.2,<1.0.0" }
 
 
 [tool.poetry.scripts]

src/crewai/cli/templates/flow/.gitignore

@@ -1,3 +1,2 @@
 .env
 __pycache__/
-lib/

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

@@ -22,7 +22,8 @@ class PoemFlow(Flow[PoemState]):
     def generate_poem(self):
         print("Generating poem")
         print(f"State before poem: {self.state}")
-        result = PoemCrew().crew().kickoff(inputs={"sentence_count": self.state.sentence_count})
+        poem_crew = PoemCrew().crew()
+        result = poem_crew.kickoff(inputs={"sentence_count": self.state.sentence_count})
         
         print("Poem generated", result.raw)
         self.state.poem = result.raw
@@ -37,28 +38,16 @@ class PoemFlow(Flow[PoemState]):
             f.write(self.state.poem)
         print(f"State after save_poem: {self.state}")
 
-async def run_flow():
+async def run():
     """
     Run the flow.
     """
     poem_flow = PoemFlow()
     await poem_flow.kickoff()
 
-async def plot_flow():
-    """
-    Plot the flow.
-    """
-    poem_flow = PoemFlow()
-    poem_flow.plot()
-
 
 def main():
-    asyncio.run(run_flow())
-
-
-def plot():
-    asyncio.run(plot_flow())
-
+    asyncio.run(run())
 
 
 if __name__ == "__main__":

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

@@ -6,13 +6,12 @@ authors = ["Your Name <you@example.com>"]
 
 [tool.poetry.dependencies]
 python = ">=3.10,<=3.13"
-crewai = { extras = ["tools"], version = ">=0.66.0,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.55.2,<1.0.0" }
 asyncio = "*"
 
 [tool.poetry.scripts]
 {{folder_name}} = "{{folder_name}}.main:main"
-run_flow = "{{folder_name}}.main:main"
-plot_flow = "{{folder_name}}.main:plot"
+run_crew = "{{folder_name}}.main:main"
 
 [build-system]
 requires = ["poetry-core"]

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.66.0,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.65.2,<1.0.0" }
 asyncio = "*"
 
 [tool.poetry.scripts]

src/crewai/cli/templates/pipeline_router/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.66.0,<1.0.0" }
+crewai = { extras = ["tools"], version = ">=0.65.2,<1.0.0" }
 
 
 [tool.poetry.scripts]

src/crewai/flow/__init__.py

@@ -1,3 +0,0 @@
-from crewai.flow.flow import Flow
-
-__all__ = ["Flow"]

src/crewai/flow/assets/crewai_flow_visual_template.html

@@ -1,93 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <title>{{ title }}</title>
-    <script
-      src="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/vis-network.min.js"
-      integrity="sha512-LnvoEWDFrqGHlHmDD2101OrLcbsfkrzoSpvtSQtxK3RMnRV0eOkhhBN2dXHKRrUU8p2DGRTk35n4O8nWSVe1mQ=="
-      crossorigin="anonymous"
-      referrerpolicy="no-referrer"
-    ></script>
-    <link
-      rel="stylesheet"
-      href="https://cdnjs.cloudflare.com/ajax/libs/vis-network/9.1.2/dist/dist/vis-network.min.css"
-      integrity="sha512-WgxfT5LWjfszlPHXRmBWHkV2eceiWTOBvrKCNbdgDYTHrT2AeLCGbF4sZlZw3UMN3WtL0tGUoIAKsu8mllg/XA=="
-      crossorigin="anonymous"
-      referrerpolicy="no-referrer"
-    />
-    <style type="text/css">
-      body {
-        font-family: verdana;
-        margin: 0;
-        padding: 0;
-      }
-      .container {
-        display: flex;
-        flex-direction: column;
-        height: 100vh;
-      }
-      #mynetwork {
-        flex-grow: 1;
-        width: 100%;
-        height: 750px;
-        background-color: #ffffff;
-      }
-      .card {
-        border: none;
-      }
-      .legend-container {
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        padding: 10px;
-        background-color: #f8f9fa;
-        position: fixed; /* Make the legend fixed */
-        bottom: 0; /* Position it at the bottom */
-        width: 100%; /* Make it span the full width */
-      }
-      .legend-item {
-        display: flex;
-        align-items: center;
-        margin-right: 20px;
-      }
-      .legend-color-box {
-        width: 20px;
-        height: 20px;
-        margin-right: 5px;
-      }
-      .logo {
-        height: 50px;
-        margin-right: 20px;
-      }
-      .legend-dashed {
-        border-bottom: 2px dashed #666666;
-        width: 20px;
-        height: 0;
-        margin-right: 5px;
-      }
-      .legend-solid {
-        border-bottom: 2px solid #666666;
-        width: 20px;
-        height: 0;
-        margin-right: 5px;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="container">
-      <div class="card" style="width: 100%">
-        <div id="mynetwork" class="card-body"></div>
-      </div>
-      <div class="legend-container">
-        <img
-          src="data:image/svg+xml;base64,{{ logo_svg_base64 }}"
-          alt="CrewAI logo"
-          class="logo"
-        />
-        <!-- LEGEND_ITEMS_PLACEHOLDER -->
-      </div>
-    </div>
-    {{ network_content }}
-  </body>
-</html>

src/crewai/flow/config.py

@@ -1,46 +0,0 @@
-DARK_GRAY = "#333333"
-CREWAI_ORANGE = "#FF5A50"
-GRAY = "#666666"
-WHITE = "#FFFFFF"
-
-COLORS = {
-    "bg": WHITE,
-    "start": CREWAI_ORANGE,
-    "method": DARK_GRAY,
-    "router": DARK_GRAY,
-    "router_border": CREWAI_ORANGE,
-    "edge": GRAY,
-    "router_edge": CREWAI_ORANGE,
-    "text": WHITE,
-}
-
-NODE_STYLES = {
-    "start": {
-        "color": COLORS["start"],
-        "shape": "box",
-        "font": {"color": COLORS["text"]},
-        "margin": {"top": 10, "bottom": 8, "left": 10, "right": 10},
-    },
-    "method": {
-        "color": COLORS["method"],
-        "shape": "box",
-        "font": {"color": COLORS["text"]},
-        "margin": {"top": 10, "bottom": 8, "left": 10, "right": 10},
-    },
-    "router": {
-        "color": {
-            "background": COLORS["router"],
-            "border": COLORS["router_border"],
-            "highlight": {
-                "border": COLORS["router_border"],
-                "background": COLORS["router"],
-            },
-        },
-        "shape": "box",
-        "font": {"color": COLORS["text"]},
-        "borderWidth": 3,
-        "borderWidthSelected": 4,
-        "shapeProperties": {"borderDashes": [5, 5]},
-        "margin": {"top": 10, "bottom": 8, "left": 10, "right": 10},
-    },
-}

src/crewai/flow/flow.py

@@ -1,15 +1,9 @@
-# flow.py
-
-# flow.py
-
 import asyncio
 import inspect
 from typing import Any, Callable, Dict, Generic, List, Set, Type, TypeVar, Union
 
 from pydantic import BaseModel
 
-from crewai.flow.flow_visualizer import plot_flow
-
 T = TypeVar("T", bound=Union[BaseModel, Dict[str, Any]])
 
 
@@ -63,12 +57,10 @@ def listen(condition):
     return decorator
 
 
-def router(method, paths=None):
+def router(method):
     def decorator(func):
         func.__is_router__ = True
         func.__router_for__ = method.__name__
-        if paths:
-            func.__router_paths__ = paths
         return func
 
     return decorator
@@ -109,7 +101,6 @@ class FlowMeta(type):
         start_methods = []
         listeners = {}
         routers = {}
-        router_paths = {}
 
         for attr_name, attr_value in dct.items():
             if hasattr(attr_value, "__is_start_method__"):
@@ -124,19 +115,10 @@ class FlowMeta(type):
                 listeners[attr_name] = (condition_type, methods)
             elif hasattr(attr_value, "__is_router__"):
                 routers[attr_value.__router_for__] = attr_name
-                if hasattr(attr_value, "__router_paths__"):
-                    router_paths[attr_name] = attr_value.__router_paths__
-
-                # **Register router as a listener to its triggering method**
-                trigger_method_name = attr_value.__router_for__
-                methods = [trigger_method_name]
-                condition_type = "OR"
-                listeners[attr_name] = (condition_type, methods)
 
         setattr(cls, "_start_methods", start_methods)
         setattr(cls, "_listeners", listeners)
         setattr(cls, "_routers", routers)
-        setattr(cls, "_router_paths", router_paths)
 
         return cls
 
@@ -145,7 +127,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
     _start_methods: List[str] = []
     _listeners: Dict[str, tuple[str, List[str]]] = {}
     _routers: Dict[str, str] = {}
-    _router_paths: Dict[str, List[str]] = {}
     initial_state: Union[Type[T], T, None] = None
 
     def __class_getitem__(cls, item):
@@ -269,6 +250,3 @@ class Flow(Generic[T], metaclass=FlowMeta):
             import traceback
 
             traceback.print_exc()
-
-    def plot(self, filename: str = "crewai_flow_graph"):
-        plot_flow(self, filename)

src/crewai/flow/flow_visualizer.py

@@ -1,99 +0,0 @@
-# flow_visualizer.py
-
-import os
-
-from pyvis.network import Network
-
-from crewai.flow.config import COLORS, NODE_STYLES
-from crewai.flow.html_template_handler import HTMLTemplateHandler
-from crewai.flow.legend_generator import generate_legend_items_html, get_legend_items
-from crewai.flow.utils import calculate_node_levels
-from crewai.flow.visualization_utils import (
-    add_edges,
-    add_nodes_to_network,
-    compute_positions,
-)
-
-
-class FlowPlot:
-    def __init__(self, flow):
-        self.flow = flow
-        self.colors = COLORS
-        self.node_styles = NODE_STYLES
-
-    def plot(self, filename):
-        net = Network(
-            directed=True,
-            height="750px",
-            width="100%",
-            bgcolor=self.colors["bg"],
-            layout=None,
-        )
-
-        # Calculate levels for nodes
-        node_levels = calculate_node_levels(self.flow)
-
-        # Compute positions
-        node_positions = compute_positions(self.flow, node_levels)
-
-        # Add nodes to the network
-        add_nodes_to_network(net, self.flow, node_positions, self.node_styles)
-
-        # Add edges to the network
-        add_edges(net, self.flow, node_positions, self.colors)
-
-        # Set options to disable physics
-        net.set_options(
-            """
-            var options = {
-                "physics": {
-                    "enabled": false
-                }
-            }
-            """
-        )
-
-        network_html = net.generate_html()
-        final_html_content = self._generate_final_html(network_html)
-
-        # Save the final HTML content to the file
-        with open(f"{filename}.html", "w", encoding="utf-8") as f:
-            f.write(final_html_content)
-        print(f"Graph saved as {filename}.html")
-
-        self._cleanup_pyvis_lib()
-
-    def _generate_final_html(self, network_html):
-        # Extract just the body content from the generated HTML
-        current_dir = os.path.dirname(__file__)
-        template_path = os.path.join(
-            current_dir, "assets", "crewai_flow_visual_template.html"
-        )
-        logo_path = os.path.join(current_dir, "assets", "crewai_logo.svg")
-
-        html_handler = HTMLTemplateHandler(template_path, logo_path)
-        network_body = html_handler.extract_body_content(network_html)
-
-        # Generate the legend items HTML
-        legend_items = get_legend_items(self.colors)
-        legend_items_html = generate_legend_items_html(legend_items)
-        final_html_content = html_handler.generate_final_html(
-            network_body, legend_items_html
-        )
-        return final_html_content
-
-    def _cleanup_pyvis_lib(self):
-        # Clean up the generated lib folder
-        lib_folder = os.path.join(os.getcwd(), "lib")
-        try:
-            if os.path.exists(lib_folder) and os.path.isdir(lib_folder):
-                import shutil
-
-                shutil.rmtree(lib_folder)
-        except Exception as e:
-            print(f"Error cleaning up {lib_folder}: {e}")
-
-
-def plot_flow(flow, filename="flow_graph"):
-    visualizer = FlowPlot(flow)
-    visualizer.plot(filename)

src/crewai/flow/html_template_handler.py

@@ -1,66 +0,0 @@
-import base64
-import os
-import re
-
-
-class HTMLTemplateHandler:
-    def __init__(self, template_path, logo_path):
-        self.template_path = template_path
-        self.logo_path = logo_path
-
-    def read_template(self):
-        with open(self.template_path, "r", encoding="utf-8") as f:
-            return f.read()
-
-    def encode_logo(self):
-        with open(self.logo_path, "rb") as logo_file:
-            logo_svg_data = logo_file.read()
-            return base64.b64encode(logo_svg_data).decode("utf-8")
-
-    def extract_body_content(self, html):
-        match = re.search("<body.*?>(.*?)</body>", html, re.DOTALL)
-        return match.group(1) if match else ""
-
-    def generate_legend_items_html(self, legend_items):
-        legend_items_html = ""
-        for item in legend_items:
-            if "border" in item:
-                legend_items_html += f"""
-                <div class="legend-item">
-                <div class="legend-color-box" style="background-color: {item['color']}; border: 2px dashed {item['border']};"></div>
-                <div>{item['label']}</div>
-                </div>
-                """
-            elif item.get("dashed") is not None:
-                style = "dashed" if item["dashed"] else "solid"
-                legend_items_html += f"""
-                <div class="legend-item">
-                <div class="legend-{style}" style="border-bottom: 2px {style} {item['color']};"></div>
-                <div>{item['label']}</div>
-                </div>
-                """
-            else:
-                legend_items_html += f"""
-                <div class="legend-item">
-                <div class="legend-color-box" style="background-color: {item['color']};"></div>
-                <div>{item['label']}</div>
-                </div>
-                """
-        return legend_items_html
-
-    def generate_final_html(self, network_body, legend_items_html, title="Flow Graph"):
-        html_template = self.read_template()
-        logo_svg_base64 = self.encode_logo()
-
-        final_html_content = html_template.replace("{{ title }}", title)
-        final_html_content = final_html_content.replace(
-            "{{ network_content }}", network_body
-        )
-        final_html_content = final_html_content.replace(
-            "{{ logo_svg_base64 }}", logo_svg_base64
-        )
-        final_html_content = final_html_content.replace(
-            "<!-- LEGEND_ITEMS_PLACEHOLDER -->", legend_items_html
-        )
-
-        return final_html_content

src/crewai/flow/legend_generator.py

@@ -1,46 +0,0 @@
-def get_legend_items(colors):
-    return [
-        {"label": "Start Method", "color": colors["start"]},
-        {"label": "Method", "color": colors["method"]},
-        {
-            "label": "Router",
-            "color": colors["router"],
-            "border": colors["router_border"],
-            "dashed": True,
-        },
-        {"label": "Trigger", "color": colors["edge"], "dashed": False},
-        {"label": "AND Trigger", "color": colors["edge"], "dashed": True},
-        {
-            "label": "Router Trigger",
-            "color": colors["router_edge"],
-            "dashed": True,
-        },
-    ]
-
-
-def generate_legend_items_html(legend_items):
-    legend_items_html = ""
-    for item in legend_items:
-        if "border" in item:
-            legend_items_html += f"""
-            <div class="legend-item">
-            <div class="legend-color-box" style="background-color: {item['color']}; border: 2px dashed {item['border']};"></div>
-            <div>{item['label']}</div>
-            </div>
-            """
-        elif item.get("dashed") is not None:
-            style = "dashed" if item["dashed"] else "solid"
-            legend_items_html += f"""
-            <div class="legend-item">
-            <div class="legend-{style}" style="border-bottom: 2px {style} {item['color']};"></div>
-            <div>{item['label']}</div>
-            </div>
-            """
-        else:
-            legend_items_html += f"""
-            <div class="legend-item">
-            <div class="legend-color-box" style="background-color: {item['color']};"></div>
-            <div>{item['label']}</div>
-            </div>
-            """
-    return legend_items_html

src/crewai/flow/utils.py

@@ -1,143 +0,0 @@
-def calculate_node_levels(flow):
-    levels = {}
-    queue = []
-    visited = set()
-    pending_and_listeners = {}
-
-    # Make all start methods at level 0
-    for method_name, method in flow._methods.items():
-        if hasattr(method, "__is_start_method__"):
-            levels[method_name] = 0
-            queue.append(method_name)
-
-    # Breadth-first traversal to assign levels
-    while queue:
-        current = queue.pop(0)
-        current_level = levels[current]
-        visited.add(current)
-
-        for listener_name, (
-            condition_type,
-            trigger_methods,
-        ) in flow._listeners.items():
-            if condition_type == "OR":
-                if current in trigger_methods:
-                    if (
-                        listener_name not in levels
-                        or levels[listener_name] > current_level + 1
-                    ):
-                        levels[listener_name] = current_level + 1
-                        if listener_name not in visited:
-                            queue.append(listener_name)
-            elif condition_type == "AND":
-                if listener_name not in pending_and_listeners:
-                    pending_and_listeners[listener_name] = set()
-                if current in trigger_methods:
-                    pending_and_listeners[listener_name].add(current)
-                if set(trigger_methods) == pending_and_listeners[listener_name]:
-                    if (
-                        listener_name not in levels
-                        or levels[listener_name] > current_level + 1
-                    ):
-                        levels[listener_name] = current_level + 1
-                        if listener_name not in visited:
-                            queue.append(listener_name)
-
-        # Handle router connections
-        if current in flow._routers.values():
-            router_method_name = current
-            paths = flow._router_paths.get(router_method_name, [])
-            for path in paths:
-                for listener_name, (
-                    condition_type,
-                    trigger_methods,
-                ) in flow._listeners.items():
-                    if path in trigger_methods:
-                        if (
-                            listener_name not in levels
-                            or levels[listener_name] > current_level + 1
-                        ):
-                            levels[listener_name] = current_level + 1
-                            if listener_name not in visited:
-                                queue.append(listener_name)
-    return levels
-
-
-def count_outgoing_edges(flow):
-    counts = {}
-    for method_name in flow._methods:
-        counts[method_name] = 0
-    for method_name in flow._listeners:
-        _, trigger_methods = flow._listeners[method_name]
-        for trigger in trigger_methods:
-            if trigger in flow._methods:
-                counts[trigger] += 1
-    return counts
-
-
-def build_ancestor_dict(flow):
-    ancestors = {node: set() for node in flow._methods}
-    visited = set()
-    for node in flow._methods:
-        if node not in visited:
-            dfs_ancestors(node, ancestors, visited, flow)
-    return ancestors
-
-
-def dfs_ancestors(node, ancestors, visited, flow):
-    if node in visited:
-        return
-    visited.add(node)
-
-    # Handle regular listeners
-    for listener_name, (_, trigger_methods) in flow._listeners.items():
-        if node in trigger_methods:
-            ancestors[listener_name].add(node)
-            ancestors[listener_name].update(ancestors[node])
-            dfs_ancestors(listener_name, ancestors, visited, flow)
-
-    # Handle router methods separately
-    if node in flow._routers.values():
-        router_method_name = node
-        paths = flow._router_paths.get(router_method_name, [])
-        for path in paths:
-            for listener_name, (_, trigger_methods) in flow._listeners.items():
-                if path in trigger_methods:
-                    # Only propagate the ancestors of the router method, not the router method itself
-                    ancestors[listener_name].update(ancestors[node])
-                    dfs_ancestors(listener_name, ancestors, visited, flow)
-
-
-def is_ancestor(node, ancestor_candidate, ancestors):
-    return ancestor_candidate in ancestors.get(node, set())
-
-
-def build_parent_children_dict(flow):
-    parent_children = {}
-
-    # Map listeners to their trigger methods
-    for listener_name, (_, trigger_methods) in flow._listeners.items():
-        for trigger in trigger_methods:
-            if trigger not in parent_children:
-                parent_children[trigger] = []
-            if listener_name not in parent_children[trigger]:
-                parent_children[trigger].append(listener_name)
-
-    # Map router methods to their paths and to listeners
-    for router_method_name, paths in flow._router_paths.items():
-        for path in paths:
-            # Map router method to listeners of each path
-            for listener_name, (_, trigger_methods) in flow._listeners.items():
-                if path in trigger_methods:
-                    if router_method_name not in parent_children:
-                        parent_children[router_method_name] = []
-                    if listener_name not in parent_children[router_method_name]:
-                        parent_children[router_method_name].append(listener_name)
-
-    return parent_children
-
-
-def get_child_index(parent, child, parent_children):
-    children = parent_children.get(parent, [])
-    children.sort()
-    return children.index(child)

src/crewai/flow/visualization_utils.py

@@ -1,132 +0,0 @@
-from .utils import (
-    build_ancestor_dict,
-    build_parent_children_dict,
-    get_child_index,
-    is_ancestor,
-)
-
-
-def compute_positions(flow, node_levels, y_spacing=150, x_spacing=150):
-    level_nodes = {}
-    node_positions = {}
-
-    for method_name, level in node_levels.items():
-        level_nodes.setdefault(level, []).append(method_name)
-
-    for level, nodes in level_nodes.items():
-        x_offset = -(len(nodes) - 1) * x_spacing / 2  # Center nodes horizontally
-        for i, method_name in enumerate(nodes):
-            x = x_offset + i * x_spacing
-            y = level * y_spacing
-            node_positions[method_name] = (x, y)
-
-    return node_positions
-
-
-def add_edges(net, flow, node_positions, colors):
-    ancestors = build_ancestor_dict(flow)
-    parent_children = build_parent_children_dict(flow)
-
-    for method_name in flow._listeners:
-        condition_type, trigger_methods = flow._listeners[method_name]
-        is_and_condition = condition_type == "AND"
-
-        for trigger in trigger_methods:
-            if trigger in flow._methods or trigger in flow._routers.values():
-                is_router_edge = any(
-                    trigger in paths for paths in flow._router_paths.values()
-                )
-                edge_color = colors["router_edge"] if is_router_edge else colors["edge"]
-
-                is_cycle_edge = is_ancestor(trigger, method_name, ancestors)
-                parent_has_multiple_children = len(parent_children.get(trigger, [])) > 1
-                needs_curvature = is_cycle_edge or parent_has_multiple_children
-
-                if needs_curvature:
-                    source_pos = node_positions.get(trigger)
-                    target_pos = node_positions.get(method_name)
-
-                    if source_pos and target_pos:
-                        dx = target_pos[0] - source_pos[0]
-                        smooth_type = "curvedCCW" if dx <= 0 else "curvedCW"
-                        index = get_child_index(trigger, method_name, parent_children)
-                        edge_smooth = {
-                            "type": smooth_type,
-                            "roundness": 0.2 + (0.1 * index),
-                        }
-                    else:
-                        edge_smooth = {"type": "cubicBezier"}
-                else:
-                    edge_smooth = False
-
-                edge_style = {
-                    "color": edge_color,
-                    "width": 2,
-                    "arrows": "to",
-                    "dashes": True if is_router_edge or is_and_condition else False,
-                    "smooth": edge_smooth,
-                }
-
-                net.add_edge(trigger, method_name, **edge_style)
-
-    for router_method_name, paths in flow._router_paths.items():
-        for path in paths:
-            for listener_name, (
-                condition_type,
-                trigger_methods,
-            ) in flow._listeners.items():
-                if path in trigger_methods:
-                    is_cycle_edge = is_ancestor(trigger, method_name, ancestors)
-                    parent_has_multiple_children = (
-                        len(parent_children.get(router_method_name, [])) > 1
-                    )
-                    needs_curvature = is_cycle_edge or parent_has_multiple_children
-
-                    if needs_curvature:
-                        source_pos = node_positions.get(router_method_name)
-                        target_pos = node_positions.get(listener_name)
-
-                        if source_pos and target_pos:
-                            dx = target_pos[0] - source_pos[0]
-                            smooth_type = "curvedCCW" if dx <= 0 else "curvedCW"
-                            index = get_child_index(
-                                router_method_name, listener_name, parent_children
-                            )
-                            edge_smooth = {
-                                "type": smooth_type,
-                                "roundness": 0.2 + (0.1 * index),
-                            }
-                        else:
-                            edge_smooth = {"type": "cubicBezier"}
-                    else:
-                        edge_smooth = False
-
-                    edge_style = {
-                        "color": colors["router_edge"],
-                        "width": 2,
-                        "arrows": "to",
-                        "dashes": True,
-                        "smooth": edge_smooth,
-                    }
-                    net.add_edge(router_method_name, listener_name, **edge_style)
-
-
-def add_nodes_to_network(net, flow, node_positions, node_styles):
-    for method_name, (x, y) in node_positions.items():
-        method = flow._methods.get(method_name)
-        if hasattr(method, "__is_start_method__"):
-            node_style = node_styles["start"]
-        elif hasattr(method, "__is_router__"):
-            node_style = node_styles["router"]
-        else:
-            node_style = node_styles["method"]
-
-        net.add_node(
-            method_name,
-            label=method_name,
-            x=x,
-            y=y,
-            fixed=True,
-            physics=False,
-            **node_style,
-        )

tests/agent_test.py

@@ -1205,9 +1205,7 @@ def test_agent_with_custom_stop_words():
     )
 
     assert isinstance(agent.llm, LLM)
-    assert set(agent.llm.stop) == set(stop_words + ["\nObservation:"])
-    assert all(word in agent.llm.stop for word in stop_words)
-    assert "\nObservation:" in agent.llm.stop
+    assert agent.llm.stop == stop_words + ["\nObservation:"]
 
 
 def test_agent_with_callbacks():
@@ -1370,8 +1368,7 @@ def test_agent_with_all_llm_attributes():
     assert agent.llm.temperature == 0.7
     assert agent.llm.top_p == 0.9
     assert agent.llm.n == 1
-    assert set(agent.llm.stop) == set(["STOP", "END", "\nObservation:"])
-    assert all(word in agent.llm.stop for word in ["STOP", "END", "\nObservation:"])
+    assert agent.llm.stop == ["STOP", "END", "\nObservation:"]
     assert agent.llm.max_tokens == 100
     assert agent.llm.presence_penalty == 0.1
     assert agent.llm.frequency_penalty == 0.1