docs(mintlify): remove OpenAPI Endpoints groups; add localized MDX endpoint pages for pt-BR and ko

.github/workflows/linter.yml

@@ -15,19 +15,8 @@ jobs:
       - name: Fetch Target Branch
         run: git fetch origin $TARGET_BRANCH --depth=1
 
-      - name: Install uv
-        uses: astral-sh/setup-uv@v6
-        with:
-          enable-cache: true
-          cache-dependency-glob: |
-            **/pyproject.toml
-            **/uv.lock
-
-      - name: Set up Python
-        run: uv python install 3.11
-
-      - name: Install dependencies
-        run: uv sync --dev --no-install-project
+      - name: Install Ruff
+        run: pip install ruff
 
       - name: Get Changed Python Files
         id: changed-files
@@ -44,4 +33,4 @@ jobs:
           echo "${{ steps.changed-files.outputs.files }}" \
             | tr ' ' '\n' \
             | grep -v 'src/crewai/cli/templates/' \
-            | xargs -I{} uv run ruff check "{}"
+            | xargs -I{} ruff check "{}"

.github/workflows/security-checker.yml

@@ -10,20 +10,14 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Install uv
-        uses: astral-sh/setup-uv@v6
-        with:
-          enable-cache: true
-          cache-dependency-glob: |
-            **/pyproject.toml
-            **/uv.lock
-
       - name: Set up Python
-        run: uv python install 3.11
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11.9"
 
       - name: Install dependencies
-        run: uv sync --dev --no-install-project
+        run: pip install bandit
 
       - name: Run Bandit
-        run: uv run bandit -c pyproject.toml -r src/ -ll
+        run: bandit -c pyproject.toml -r src/ -ll
 

.github/workflows/tests.yml

@@ -24,7 +24,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
           cache-dependency-glob: |

.github/workflows/type-checker.yml

@@ -6,78 +6,21 @@ permissions:
   contents: write
 
 jobs:
-  type-checker-matrix:
-    name: type-checker (${{ matrix.python-version }})
+  type-checker:
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
 
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
         with:
-          fetch-depth: 0 # Fetch all history for proper diff
+          python-version: "3.11.9"
 
-      - name: Install uv
-        uses: astral-sh/setup-uv@v6
-        with:
-          enable-cache: true
-          cache-dependency-glob: |
-            **/pyproject.toml
-            **/uv.lock
-
-      - name: Set up Python ${{ matrix.python-version }}
-        run: uv python install ${{ matrix.python-version }}
-
-      - name: Install dependencies
-        run: uv sync --dev --no-install-project
-
-      - name: Get changed Python files
-        id: changed-files
+      - name: Install Requirements
         run: |
-          # Get the list of changed Python files compared to the base branch
-          echo "Fetching changed files..."
-          git diff --name-only --diff-filter=ACMRT origin/${{ github.base_ref }}...HEAD -- '*.py' > changed_files.txt
+          pip install mypy
 
-          # Filter for files in src/ and tests/ directories
-          grep -E "^(src/|tests/)" changed_files.txt > filtered_changed_files.txt || true
-
-          # Check if there are any changed files
-          if [ -s filtered_changed_files.txt ]; then
-            echo "Changed Python files in src/ and tests/:"
-            cat filtered_changed_files.txt
-            echo "has_changes=true" >> $GITHUB_OUTPUT
-            # Convert newlines to spaces for mypy command
-            echo "files=$(cat filtered_changed_files.txt | tr '\n' ' ')" >> $GITHUB_OUTPUT
-          else
-            echo "No Python files changed in src/ or tests/"
-            echo "has_changes=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Run type checks on changed files
-        if: steps.changed-files.outputs.has_changes == 'true'
-        run: |
-          echo "Running mypy on changed files with Python ${{ matrix.python-version }}..."
-          uv run mypy ${{ steps.changed-files.outputs.files }}
-
-      - name: No files to check
-        if: steps.changed-files.outputs.has_changes == 'false'
-        run: echo "No Python files in src/ or tests/ were modified - skipping type checks"
-
-  # Summary job to provide single status for branch protection
-  type-checker:
-    name: type-checker
-    runs-on: ubuntu-latest
-    needs: type-checker-matrix
-    if: always()
-    steps:
-      - name: Check matrix results
-        run: |
-          if [ "${{ needs.type-checker-matrix.result }}" == "success" ] || [ "${{ needs.type-checker-matrix.result }}" == "skipped" ]; then
-            echo "✅ All type checks passed"
-          else
-            echo "❌ Type checks failed"
-            exit 1
-          fi
+      - name: Run type checks
+        run: mypy src

.pre-commit-config.yaml

@@ -1,14 +1,7 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.11
+    rev: v0.8.2
     hooks:
       - id: ruff
-        args: ["--config", "pyproject.toml"]
+        args: ["--fix"]
       - id: ruff-format
-        args: ["--config", "pyproject.toml"]
-  
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.17.1
-    hooks:
-      - id: mypy
-        args: ["--config-file", "pyproject.toml"]

.ruff.toml

@@ -0,0 +1,4 @@
+exclude = [
+    "templates",
+    "__init__.py",
+]

README.md

@@ -418,10 +418,10 @@ Choose CrewAI to easily build powerful, adaptable, and production-ready AI autom
 
 You can test different real life examples of AI crews in the [CrewAI-examples repo](https://github.com/crewAIInc/crewAI-examples?tab=readme-ov-file):
 
-- [Landing Page Generator](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/landing_page_generator)
+- [Landing Page Generator](https://github.com/crewAIInc/crewAI-examples/tree/main/landing_page_generator)
 - [Having Human input on the execution](https://docs.crewai.com/how-to/Human-Input-on-Execution)
-- [Trip Planner](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/trip_planner)
-- [Stock Analysis](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/stock_analysis)
+- [Trip Planner](https://github.com/crewAIInc/crewAI-examples/tree/main/trip_planner)
+- [Stock Analysis](https://github.com/crewAIInc/crewAI-examples/tree/main/stock_analysis)
 
 ### Quick Tutorial
 
@@ -429,19 +429,19 @@ You can test different real life examples of AI crews in the [CrewAI-examples re
 
 ### Write Job Descriptions
 
-[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/job-posting) or watch a video below:
+[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/job-posting) or watch a video below:
 
 [![Jobs postings](https://img.youtube.com/vi/u98wEMz-9to/maxresdefault.jpg)](https://www.youtube.com/watch?v=u98wEMz-9to "Jobs postings")
 
 ### Trip Planner
 
-[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/trip_planner) or watch a video below:
+[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/trip_planner) or watch a video below:
 
 [![Trip Planner](https://img.youtube.com/vi/xis7rWp-hjs/maxresdefault.jpg)](https://www.youtube.com/watch?v=xis7rWp-hjs "Trip Planner")
 
 ### Stock Analysis
 
-[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/stock_analysis) or watch a video below:
+[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/stock_analysis) or watch a video below:
 
 [![Stock Analysis](https://img.youtube.com/vi/e0Uj4yWdaAg/maxresdefault.jpg)](https://www.youtube.com/watch?v=e0Uj4yWdaAg "Stock Analysis")
 

docs/docs.json

@@ -320,7 +320,6 @@
                   "en/enterprise/guides/update-crew",
                   "en/enterprise/guides/enable-crew-studio",
                   "en/enterprise/guides/azure-openai-setup",
-                  "en/enterprise/guides/automation-triggers",
                   "en/enterprise/guides/hubspot-trigger",
                   "en/enterprise/guides/react-component-export",
                   "en/enterprise/guides/salesforce-trigger",
@@ -659,7 +658,6 @@
                   "pt-BR/enterprise/guides/update-crew",
                   "pt-BR/enterprise/guides/enable-crew-studio",
                   "pt-BR/enterprise/guides/azure-openai-setup",
-                  "pt-BR/enterprise/guides/automation-triggers",
                   "pt-BR/enterprise/guides/hubspot-trigger",
                   "pt-BR/enterprise/guides/react-component-export",
                   "pt-BR/enterprise/guides/salesforce-trigger",
@@ -1009,7 +1007,6 @@
                   "ko/enterprise/guides/update-crew",
                   "ko/enterprise/guides/enable-crew-studio",
                   "ko/enterprise/guides/azure-openai-setup",
-                  "ko/enterprise/guides/automation-triggers",
                   "ko/enterprise/guides/hubspot-trigger",
                   "ko/enterprise/guides/react-component-export",
                   "ko/enterprise/guides/salesforce-trigger",

docs/en/concepts/cli.mdx

@@ -282,25 +282,7 @@ Watch this video tutorial for a step-by-step demonstration of deploying your cre
   allowfullscreen
 ></iframe>
 
-### 12. Login
-
-Authenticate with CrewAI Enterprise using a secure device code flow (no email entry required).
-
-```shell Terminal
-crewai login
-```
-
-What happens:
-- A verification URL and short code are displayed in your terminal
-- Your browser opens to the verification URL
-- Enter/confirm the code to complete authentication
-
-Notes:
-- The OAuth2 provider and domain are configured via `crewai config` (defaults use `login.crewai.com`)
-- After successful login, the CLI also attempts to authenticate to the Tool Repository automatically
-- If you reset your configuration, run `crewai login` again to re-authenticate
-
-### 13. API Keys
+### 11. API Keys
 
 When running ```crewai create crew``` command, the CLI will show you a list of available LLM providers to choose from, followed by model selection for your chosen provider.
 
@@ -328,7 +310,7 @@ See the following link for each provider's key name:
 
 * [LiteLLM Providers](https://docs.litellm.ai/docs/providers)
 
-### 14. Configuration Management
+### 12. Configuration Management
 
 Manage CLI configuration settings for CrewAI.
 
@@ -403,10 +385,6 @@ Reset all configuration to defaults:
 crewai config reset
 ```
 
-<Tip>
-After resetting configuration, re-run `crewai login` to authenticate again.
-</Tip>
-
 <Note>
 Configuration settings are stored in `~/.config/crewai/settings.json`. Some settings like organization name and UUID are read-only and managed through authentication and organization commands. Tool repository related settings are hidden and cannot be set directly by users.
 </Note>

docs/en/concepts/event-listener.mdx

@@ -44,12 +44,12 @@ To create a custom event listener, you need to:
 Here's a simple example of a custom event listener class:
 
 ```python
-from crewai.events import (
+from crewai.utilities.events import (
     CrewKickoffStartedEvent,
     CrewKickoffCompletedEvent,
     AgentExecutionCompletedEvent,
 )
-from crewai.events import BaseEventListener
+from crewai.utilities.events.base_event_listener import BaseEventListener
 
 class MyCustomListener(BaseEventListener):
     def __init__(self):
@@ -146,7 +146,7 @@ my_project/
 
 ```python
 # my_custom_listener.py
-from crewai.events import BaseEventListener
+from crewai.utilities.events.base_event_listener import BaseEventListener
 # ... import events ...
 
 class MyCustomListener(BaseEventListener):
@@ -279,7 +279,7 @@ Additional fields vary by event type. For example, `CrewKickoffCompletedEvent` i
 For temporary event handling (useful for testing or specific operations), you can use the `scoped_handlers` context manager:
 
 ```python
-from crewai.events import crewai_event_bus, CrewKickoffStartedEvent
+from crewai.utilities.events import crewai_event_bus, CrewKickoffStartedEvent
 
 with crewai_event_bus.scoped_handlers():
     @crewai_event_bus.on(CrewKickoffStartedEvent)

docs/en/concepts/flows.mdx

@@ -97,13 +97,7 @@ The state's unique ID and stored data can be useful for tracking flow executions
 
 ### @start()
 
-The `@start()` decorator marks entry points for a Flow. You can:
-
-- Declare multiple unconditional starts: `@start()`
-- Gate a start on a prior method or router label: `@start("method_or_label")`
-- Provide a callable condition to control when a start should fire
-
-All satisfied `@start()` methods will execute (often in parallel) when the Flow begins or resumes.
+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()
 

docs/en/concepts/knowledge.mdx

@@ -24,41 +24,6 @@ For file-based Knowledge Sources, make sure to place your files in a `knowledge`
 Also, use relative paths from the `knowledge` directory when creating the source.
 </Tip>
 
-### Vector store (RAG) client configuration
-
-CrewAI exposes a provider-neutral RAG client abstraction for vector stores. The default provider is ChromaDB, and Qdrant is supported as well. You can switch providers using configuration utilities.
-
-Supported today:
-- ChromaDB (default)
-- Qdrant
-
-```python Code
-from crewai.rag.config.utils import set_rag_config, get_rag_client, clear_rag_config
-
-# ChromaDB (default)
-from crewai.rag.chromadb.config import ChromaDBConfig
-set_rag_config(ChromaDBConfig())
-chromadb_client = get_rag_client()
-
-# Qdrant
-from crewai.rag.qdrant.config import QdrantConfig
-set_rag_config(QdrantConfig())
-qdrant_client = get_rag_client()
-
-# Example operations (same API for any provider)
-client = qdrant_client  # or chromadb_client
-client.create_collection(collection_name="docs")
-client.add_documents(
-    collection_name="docs",
-    documents=[{"id": "1", "content": "CrewAI enables collaborative AI agents."}],
-)
-results = client.search(collection_name="docs", query="collaborative agents", limit=3)
-
-clear_rag_config()  # optional reset
-```
-
-This RAG client is separate from Knowledge’s built-in storage. Use it when you need direct vector-store control or custom retrieval pipelines.
-
 ### Basic String Knowledge Example
 
 ```python Code
@@ -716,11 +681,11 @@ CrewAI emits events during the knowledge retrieval process that you can listen f
 #### Example: Monitoring Knowledge Retrieval
 
 ```python
-from crewai.events import (
+from crewai.utilities.events import (
     KnowledgeRetrievalStartedEvent,
     KnowledgeRetrievalCompletedEvent,
-    BaseEventListener,
 )
+from crewai.utilities.events.base_event_listener import BaseEventListener
 
 class KnowledgeMonitorListener(BaseEventListener):
     def setup_listeners(self, crewai_event_bus):

docs/en/concepts/llms.mdx

@@ -733,10 +733,10 @@ CrewAI supports streaming responses from LLMs, allowing your application to rece
     CrewAI emits events for each chunk received during streaming:
 
     ```python
-    from crewai.events import (
+    from crewai.utilities.events import (
       LLMStreamChunkEvent
     )
-    from crewai.events import BaseEventListener
+    from crewai.utilities.events.base_event_listener import BaseEventListener
 
     class MyCustomListener(BaseEventListener):
         def setup_listeners(self, crewai_event_bus):
@@ -758,8 +758,8 @@ CrewAI supports streaming responses from LLMs, allowing your application to rece
 
     ```python
     from crewai import LLM, Agent, Task, Crew
-    from crewai.events import LLMStreamChunkEvent
-    from crewai.events import BaseEventListener
+    from crewai.utilities.events import LLMStreamChunkEvent
+    from crewai.utilities.events.base_event_listener import BaseEventListener
 
     class MyCustomListener(BaseEventListener):
         def setup_listeners(self, crewai_event_bus):

docs/en/concepts/memory.mdx

@@ -738,17 +738,6 @@ print(f"OpenAI: {openai_time:.2f}s")
 print(f"Ollama: {ollama_time:.2f}s")
 ```
 
-### Entity Memory batching behavior
-
-Entity Memory supports batching when saving multiple entities at once. When you pass a list of `EntityMemoryItem`, the system:
-
-- Emits a single MemorySaveStartedEvent with `entity_count`
-- Saves each entity internally, collecting any partial errors
-- Emits MemorySaveCompletedEvent with aggregate metadata (saved count, errors)
-- Raises a partial-save exception if some entities failed (includes counts)
-
-This improves performance and observability when writing many entities in one operation.
-
 ## 2. External Memory 
 External Memory provides a standalone memory system that operates independently from the crew's built-in memory. This is ideal for specialized memory providers or cross-application memory sharing.
 
@@ -1052,8 +1041,8 @@ CrewAI emits the following memory-related events:
 Track memory operation timing to optimize your application:
 
 ```python
-from crewai.events import (
-    BaseEventListener,
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
     MemoryQueryCompletedEvent,
     MemorySaveCompletedEvent
 )
@@ -1087,8 +1076,8 @@ memory_monitor = MemoryPerformanceMonitor()
 Log memory operations for debugging and insights:
 
 ```python
-from crewai.events import (
-    BaseEventListener,
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
     MemorySaveStartedEvent,
     MemoryQueryStartedEvent,
     MemoryRetrievalCompletedEvent
@@ -1128,8 +1117,8 @@ memory_logger = MemoryLogger()
 Capture and respond to memory errors:
 
 ```python
-from crewai.events import (
-    BaseEventListener,
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
     MemorySaveFailedEvent,
     MemoryQueryFailedEvent
 )
@@ -1178,8 +1167,8 @@ error_tracker = MemoryErrorTracker(notify_email="admin@example.com")
 Memory events can be forwarded to analytics and monitoring platforms to track performance metrics, detect anomalies, and visualize memory usage patterns:
 
 ```python
-from crewai.events import (
-    BaseEventListener,
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
     MemoryQueryCompletedEvent,
     MemorySaveCompletedEvent
 )

docs/en/concepts/tasks.mdx

@@ -59,12 +59,6 @@ crew = Crew(
 | **Output Pydantic** _(optional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`   | A Pydantic model for task output.                                                                                    |
 | **Callback** _(optional)_        | `callback`        | `Optional[Any]`               | Function/object to be executed after task completion.                                                                |
 | **Guardrail** _(optional)_       | `guardrail`       | `Optional[Callable]`             | Function to validate task output before proceeding to next task.                                                  |
-| **Guardrail Max Retries** _(optional)_ | `guardrail_max_retries` | `Optional[int]`     | Maximum number of retries when guardrail validation fails. Defaults to 3.                                         |
-
-<Note type="warning" title="Deprecated: max_retries">
-  The task attribute `max_retries` is deprecated and will be removed in v1.0.0.
-  Use `guardrail_max_retries` instead to control retry attempts when a guardrail fails.
-</Note>
 
 ## Creating Tasks
 
@@ -437,7 +431,7 @@ When a guardrail returns `(False, error)`:
 2. The agent attempts to fix the issue
 3. The process repeats until:
    - The guardrail returns `(True, result)`
-   - Maximum retries are reached (`guardrail_max_retries`)
+   - Maximum retries are reached
 
 Example with retry handling:
 ```python Code
@@ -458,7 +452,7 @@ task = Task(
     expected_output="A valid JSON object",
     agent=analyst,
     guardrail=validate_json_output,
-    guardrail_max_retries=3  # Limit retry attempts
+    max_retries=3  # Limit retry attempts
 )
 ```
 

docs/en/enterprise/features/integrations.mdx

@@ -59,7 +59,7 @@ Before using Authentication Integrations, ensure you have:
 3. Click **Connect** on your desired service from the Authentication Integrations section
 4. Complete the OAuth authentication flow
 5. Grant necessary permissions for your use case
-6. All set! Get your Enterprise Token from your [CrewAI Enterprise](https://app.crewai.com) in **Integration** tab
+6. Get your Enterprise Token from your [CrewAI Enterprise](https://app.crewai.com) account page - https://app.crewai.com/crewai_plus/settings/account
 
 <Frame>
   ![Integrations](/images/enterprise/enterprise_action_auth_token.png)

docs/en/enterprise/features/traces.mdx

@@ -141,16 +141,6 @@ Traces are invaluable for troubleshooting issues with your crews:
   </Step>
 </Steps>
 
-## Performance and batching
-
-CrewAI batches trace uploads to reduce overhead on high-volume runs:
-
-- A TraceBatchManager buffers events and sends them in batches via the Plus API client
-- Reduces network chatter and improves reliability on flaky connections
-- Automatically enabled in the default trace listener; no configuration needed
-
-This yields more stable tracing under load while preserving detailed task/agent telemetry.
-
 <Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
   Contact our support team for assistance with trace analysis or any other CrewAI Enterprise features.
 </Card>

docs/en/enterprise/guides/automation-triggers.mdx

@@ -1,178 +0,0 @@
----
-title: "Automation Triggers"
-description: "Automatically execute your CrewAI workflows when specific events occur in connected integrations"
-icon: "bolt"
----
-
-Automation triggers enable you to automatically run your CrewAI deployments when specific events occur in your connected integrations, creating powerful event-driven workflows that respond to real-time changes in your business systems.
-
-## Overview
-
-With automation triggers, you can:
-
-- **Respond to real-time events** - Automatically execute workflows when specific conditions are met
-- **Integrate with external systems** - Connect with platforms like Gmail, Outlook, OneDrive, JIRA, Slack, Stripe and more
-- **Scale your automation** - Handle high-volume events without manual intervention
-- **Maintain context** - Access trigger data within your crews and flows
-
-## Managing Automation Triggers
-
-### Viewing Available Triggers
-
-To access and manage your automation triggers:
-
-1. Navigate to your deployment in the CrewAI dashboard
-2. Click on the **Triggers** tab to view all available trigger integrations
-
-<Frame>
-  <img src="/images/enterprise/list-available-triggers.png" alt="List of available automation triggers" />
-</Frame>
-
-This view shows all the trigger integrations available for your deployment, along with their current connection status.
-
-### Enabling and Disabling Triggers
-
-Each trigger can be easily enabled or disabled using the toggle switch:
-
-<Frame>
-  <img src="/images/enterprise/trigger-selected.png" alt="Enable or disable triggers with toggle" />
-</Frame>
-
-- **Enabled (blue toggle)**: The trigger is active and will automatically execute your deployment when the specified events occur
-- **Disabled (gray toggle)**: The trigger is inactive and will not respond to events
-
-Simply click the toggle to change the trigger state. Changes take effect immediately.
-
-### Monitoring Trigger Executions
-
-Track the performance and history of your triggered executions:
-
-<Frame>
-  <img src="/images/enterprise/list-executions.png" alt="List of executions triggered by automation" />
-</Frame>
-
-## Building Automation
-
-Before building your automation, it's helpful to understand the structure of trigger payloads that your crews and flows will receive.
-
-### Payload Samples Repository
-
-We maintain a comprehensive repository with sample payloads from various trigger sources to help you build and test your automations:
-
-**🔗 [CrewAI Enterprise Trigger Payload Samples](https://github.com/crewAIInc/crewai-enterprise-trigger-payload-samples)**
-
-This repository contains:
-
-- **Real payload examples** from different trigger sources (Gmail, Google Drive, etc.)
-- **Payload structure documentation** showing the format and available fields
-
-### Triggers with Crew
-
-Your existing crew definitions work seamlessly with triggers, you just need to have a task to parse the received payload:
-
-```python
-@CrewBase
-class MyAutomatedCrew:
-    @agent
-    def researcher(self) -> Agent:
-        return Agent(
-            config=self.agents_config['researcher'],
-        )
-
-    @task
-    def parse_trigger_payload(self) -> Task:
-        return Task(
-            config=self.tasks_config['parse_trigger_payload'],
-            agent=self.researcher(),
-        )
-
-    @task
-    def analyze_trigger_content(self) -> Task:
-        return Task(
-            config=self.tasks_config['analyze_trigger_data'],
-            agent=self.researcher(),
-        )
-```
-
-The crew will automatically receive and can access the trigger payload through the standard CrewAI context mechanisms.
-
-<Note>
-  Crew and Flow inputs can include `crewai_trigger_payload`. CrewAI automatically injects this payload:
-  - Tasks: appended to the first task's description by default ("Trigger Payload: {crewai_trigger_payload}")
-  - Control via `allow_crewai_trigger_context`: set `True` to always inject, `False` to never inject
-  - Flows: any `@start()` method that accepts a `crewai_trigger_payload` parameter will receive it
-</Note>
-
-### Integration with Flows
-
-For flows, you have more control over how trigger data is handled:
-
-#### Accessing Trigger Payload
-
-All `@start()` methods in your flows will accept an additional parameter called `crewai_trigger_payload`:
-
-```python
-from crewai.flow import Flow, start, listen
-
-class MyAutomatedFlow(Flow):
-    @start()
-    def handle_trigger(self, crewai_trigger_payload: dict = None):
-        """
-        This start method can receive trigger data
-        """
-        if crewai_trigger_payload:
-            # Process the trigger data
-            trigger_id = crewai_trigger_payload.get('id')
-            event_data = crewai_trigger_payload.get('payload', {})
-
-            # Store in flow state for use by other methods
-            self.state.trigger_id = trigger_id
-            self.state.trigger_type = event_data
-
-            return event_data
-
-        # Handle manual execution
-        return None
-
-    @listen(handle_trigger)
-    def process_data(self, trigger_data):
-        """
-        Process the data from the trigger
-        """
-        # ... process the trigger
-```
-
-#### Triggering Crews from Flows
-
-When kicking off a crew within a flow that was triggered, pass the trigger payload as it:
-
-```python
-@start()
-def delegate_to_crew(self, crewai_trigger_payload: dict = None):
-    """
-    Delegate processing to a specialized crew
-    """
-    crew = MySpecializedCrew()
-
-    # Pass the trigger payload to the crew
-    result = crew.crew().kickoff(
-        inputs={
-            'a_custom_parameter': "custom_value",
-            'crewai_trigger_payload': crewai_trigger_payload
-        },
-    )
-
-    return result
-```
-
-## Troubleshooting
-
-**Trigger not firing:**
-- Verify the trigger is enabled
-- Check integration connection status
-
-**Execution failures:**
-- Check the execution logs for error details
-- If you are developing, make sure the inputs include the `crewai_trigger_payload` parameter with the correct payload
-
-Automation triggers transform your CrewAI deployments into responsive, event-driven systems that can seamlessly integrate with your existing business processes and tools.

docs/en/guides/flows/mastering-flow-state.mdx

@@ -348,31 +348,6 @@ class SelectivePersistFlow(Flow):
 
 ## Advanced State Patterns
 
-### Conditional starts and resumable execution
-
-Flows support conditional `@start()` and resumable execution for HITL/cyclic scenarios:
-
-```python
-from crewai.flow.flow import Flow, start, listen, and_, or_
-
-class ResumableFlow(Flow):
-    @start()  # unconditional start
-    def init(self):
-        ...
-
-    # Conditional start: run after "init" or external trigger name
-    @start("init")
-    def maybe_begin(self):
-        ...
-
-    @listen(and_(init, maybe_begin))
-    def proceed(self):
-        ...
-```
-
-- Conditional `@start()` accepts a method name, a router label, or a callable condition.
-- During resume, listeners continue from prior checkpoints; cycle/router branches honor resumption flags.
-
 ### State-Based Conditional Logic
 
 You can use state to implement complex conditional logic in your flows:

docs/en/installation.mdx

@@ -30,12 +30,6 @@ Watch this video tutorial for a step-by-step demonstration of the installation p
   If you need to update Python, visit [python.org/downloads](https://python.org/downloads)
 </Note>
 
-<Note>
-  **OpenAI SDK Requirement**
-
-  CrewAI 0.175.0 requires `openai >= 1.13.3`. If you manage dependencies yourself, ensure your environment satisfies this constraint to avoid import/runtime issues.
-</Note>
-
 CrewAI uses the `uv` as its dependency management and package handling tool. It simplifies project setup and execution, offering a seamless experience.
 
 If you haven't installed `uv` yet, follow **step 1** to quickly get it set up on your system, else you can skip to **step 2**.

docs/en/tools/database-data/weaviatevectorsearchtool.mdx

@@ -1,13 +1,13 @@
 ---
 title: Weaviate Vector Search
-description: The `WeaviateVectorSearchTool` is designed to search a Weaviate vector database for semantically similar documents using hybrid search.
+description: The `WeaviateVectorSearchTool` is designed to search a Weaviate vector database for semantically similar documents.
 icon: network-wired
 ---
 
 ## Overview
 
 
-The `WeaviateVectorSearchTool` is specifically crafted for conducting semantic searches within documents stored in a Weaviate vector database. This tool allows you to find semantically similar documents to a given query, leveraging the power of vector and keyword search for more accurate and contextually relevant search results.
+The `WeaviateVectorSearchTool` is specifically crafted for conducting semantic searches within documents stored in a Weaviate vector database. This tool allows you to find semantically similar documents to a given query, leveraging the power of vector embeddings for more accurate and contextually relevant search results.
 
 [Weaviate](https://weaviate.io/) is a vector database that stores and queries vector embeddings, enabling semantic search capabilities.
 
@@ -39,7 +39,6 @@ from crewai_tools import WeaviateVectorSearchTool
 tool = WeaviateVectorSearchTool(
     collection_name='example_collections',
     limit=3,
-    alpha=0.75,
     weaviate_cluster_url="https://your-weaviate-cluster-url.com",
     weaviate_api_key="your-weaviate-api-key",
 )
@@ -64,7 +63,6 @@ The `WeaviateVectorSearchTool` accepts the following parameters:
 - **weaviate_cluster_url**: Required. The URL of the Weaviate cluster.
 - **weaviate_api_key**: Required. The API key for the Weaviate cluster.
 - **limit**: Optional. The number of results to return. Default is `3`.
-- **alpha**: Optional. Controls the weighting between vector and keyword (BM25) search. alpha = 0 -> BM25 only, alpha = 1 -> vector search only. Default is `0.75`.
 - **vectorizer**: Optional. The vectorizer to use. If not provided, it will use `text2vec_openai` with the `nomic-embed-text` model.
 - **generative_model**: Optional. The generative model to use. If not provided, it will use OpenAI's `gpt-4o`.
 
@@ -80,7 +78,6 @@ from weaviate.classes.config import Configure
 tool = WeaviateVectorSearchTool(
     collection_name='example_collections',
     limit=3,
-    alpha=0.75,
     vectorizer=Configure.Vectorizer.text2vec_openai(model="nomic-embed-text"),
     generative_model=Configure.Generative.openai(model="gpt-4o-mini"),
     weaviate_cluster_url="https://your-weaviate-cluster-url.com",
@@ -131,7 +128,6 @@ with test_docs.batch.dynamic() as batch:
 tool = WeaviateVectorSearchTool(
     collection_name='example_collections', 
     limit=3,
-    alpha=0.75,
     weaviate_cluster_url="https://your-weaviate-cluster-url.com",
     weaviate_api_key="your-weaviate-api-key",
 )
@@ -149,7 +145,6 @@ from crewai_tools import WeaviateVectorSearchTool
 weaviate_tool = WeaviateVectorSearchTool(
     collection_name='example_collections',
     limit=3,
-    alpha=0.75,
     weaviate_cluster_url="https://your-weaviate-cluster-url.com",
     weaviate_api_key="your-weaviate-api-key",
 )

docs/ko/concepts/event-listener.mdx

@@ -44,12 +44,12 @@ Prompt Tracing을 통해 다음과 같은 작업이 가능합니다:
 아래는 커스텀 이벤트 리스너 클래스의 간단한 예시입니다:
 
 ```python
-from crewai.events import (
+from crewai.utilities.events import (
     CrewKickoffStartedEvent,
     CrewKickoffCompletedEvent,
     AgentExecutionCompletedEvent,
 )
-from crewai.events import BaseEventListener
+from crewai.utilities.events.base_event_listener import BaseEventListener
 
 class MyCustomListener(BaseEventListener):
     def __init__(self):
@@ -146,7 +146,7 @@ my_project/
 
 ```python
 # my_custom_listener.py
-from crewai.events import BaseEventListener
+from crewai.utilities.events.base_event_listener import BaseEventListener
 # ... import events ...
 
 class MyCustomListener(BaseEventListener):
@@ -279,7 +279,7 @@ CrewAI는 여러분이 청취할 수 있는 다양한 이벤트를 제공합니
 임시 이벤트 처리가 필요한 경우(테스트 또는 특정 작업에 유용함), `scoped_handlers` 컨텍스트 관리자를 사용할 수 있습니다:
 
 ```python
-from crewai.events import crewai_event_bus, CrewKickoffStartedEvent
+from crewai.utilities.events import crewai_event_bus, CrewKickoffStartedEvent
 
 with crewai_event_bus.scoped_handlers():
     @crewai_event_bus.on(CrewKickoffStartedEvent)

docs/ko/concepts/knowledge.mdx

@@ -683,11 +683,11 @@ CrewAI는 knowledge 검색 과정에서 이벤트를 발생시키며, 이벤트
 #### 예시: Knowledge Retrieval 모니터링
 
 ```python
-from crewai.events import (
+from crewai.utilities.events import (
     KnowledgeRetrievalStartedEvent,
     KnowledgeRetrievalCompletedEvent,
-    BaseEventListener,
 )
+from crewai.utilities.events.base_event_listener import BaseEventListener
 
 class KnowledgeMonitorListener(BaseEventListener):
     def setup_listeners(self, crewai_event_bus):

docs/ko/concepts/llms.mdx

@@ -731,10 +731,10 @@ CrewAI는 LLM의 스트리밍 응답을 지원하여, 애플리케이션이 출
     CrewAI는 스트리밍 중 수신되는 각 청크에 대해 이벤트를 발생시킵니다:
 
     ```python
-    from crewai.events import (
+    from crewai.utilities.events import (
       LLMStreamChunkEvent
     )
-    from crewai.events import BaseEventListener
+    from crewai.utilities.events.base_event_listener import BaseEventListener
 
     class MyCustomListener(BaseEventListener):
         def setup_listeners(self, crewai_event_bus):
@@ -756,8 +756,8 @@ CrewAI는 LLM의 스트리밍 응답을 지원하여, 애플리케이션이 출
 
     ```python
     from crewai import LLM, Agent, Task, Crew
-    from crewai.events import LLMStreamChunkEvent
-    from crewai.events import BaseEventListener
+    from crewai.utilities.events import LLMStreamChunkEvent
+    from crewai.utilities.events.base_event_listener import BaseEventListener
 
     class MyCustomListener(BaseEventListener):
         def setup_listeners(self, crewai_event_bus):

docs/ko/concepts/memory.mdx

@@ -985,8 +985,8 @@ CrewAI는 다음과 같은 메모리 관련 이벤트를 발생시킵니다:
 애플리케이션을 최적화하기 위해 메모리 작업 타이밍을 추적하세요:
 
 ```python
-from crewai.events import (
-    BaseEventListener,
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
     MemoryQueryCompletedEvent,
     MemorySaveCompletedEvent
 )
@@ -1020,8 +1020,8 @@ memory_monitor = MemoryPerformanceMonitor()
 디버깅 및 인사이트를 위해 메모리 작업을 로깅합니다:
 
 ```python
-from crewai.events import (
-    BaseEventListener,
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
     MemorySaveStartedEvent,
     MemoryQueryStartedEvent,
     MemoryRetrievalCompletedEvent
@@ -1061,8 +1061,8 @@ memory_logger = MemoryLogger()
 메모리 오류를 캡처하고 대응합니다:
 
 ```python
-from crewai.events import (
-    BaseEventListener,
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
     MemorySaveFailedEvent,
     MemoryQueryFailedEvent
 )
@@ -1111,8 +1111,8 @@ error_tracker = MemoryErrorTracker(notify_email="admin@example.com")
 메모리 이벤트는 분석 및 모니터링 플랫폼으로 전달되어 성능 지표를 추적하고, 이상 징후를 감지하며, 메모리 사용 패턴을 시각화할 수 있습니다:
 
 ```python
-from crewai.events import (
-    BaseEventListener,
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events import (
     MemoryQueryCompletedEvent,
     MemorySaveCompletedEvent
 )

docs/ko/concepts/tasks.mdx

@@ -59,7 +59,6 @@ crew = Crew(
 | **Pydantic 출력** _(선택 사항)_   | `output_pydantic`     | `Optional[Type[BaseModel]]`       | 태스크 출력용 Pydantic 모델입니다.                                                                             |
 | **콜백** _(선택 사항)_            | `callback`            | `Optional[Any]`                  | 태스크 완료 후 실행할 함수/객체입니다.                                                                         |
 | **가드레일** _(선택 사항)_        | `guardrail`           | `Optional[Callable]`                | 다음 태스크로 진행하기 전에 태스크 출력을 검증하는 함수입니다.                                               |
-| **가드레일 최대 재시도** _(선택 사항)_ | `guardrail_max_retries` | `Optional[int]`          | 가드레일 검증 실패 시 최대 재시도 횟수입니다. 기본값은 3입니다.                                                |
 
 ## 작업 생성하기
 
@@ -449,7 +448,7 @@ task = Task(
     expected_output="A valid JSON object",
     agent=analyst,
     guardrail=validate_json_output,
-    guardrail_max_retries=3  # 재시도 횟수 제한
+    max_retries=3  # Limit retry attempts
 )
 ```
 
@@ -900,4 +899,4 @@ except RuntimeError as e:
 작업(task)은 CrewAI 에이전트의 행동을 이끄는 원동력입니다.
 작업과 그 결과를 적절하게 정의함으로써, 에이전트가 독립적으로 또는 협업 단위로 효과적으로 작동할 수 있는 기반을 마련할 수 있습니다.
 작업에 적합한 도구를 장착하고, 실행 과정을 이해하며, 견고한 검증 절차를 따르는 것은 CrewAI의 잠재력을 극대화하는 데 필수적입니다.
-이를 통해 에이전트가 할당된 작업에 효과적으로 준비되고, 작업이 의도대로 수행될 수 있습니다.
+이를 통해 에이전트가 할당된 작업에 효과적으로 준비되고, 작업이 의도대로 수행될 수 있습니다.

docs/ko/enterprise/features/integrations.mdx

@@ -58,7 +58,7 @@ Authentication Integrations를 사용하기 전에 다음이 준비되어 있는
 3. Authentication Integrations 섹션에서 원하는 서비스의 **Connect** 버튼을 클릭합니다.
 4. OAuth 인증 과정을 완료합니다.
 5. 사용 사례에 필요한 권한을 부여합니다.
-6. 완료! [CrewAI Enterprise](https://app.crewai.com)의 **Integration** 탭에서 Enterprise Token을 받습니다.
+6. [CrewAI Enterprise](https://app.crewai.com) 계정 페이지 - https://app.crewai.com/crewai_plus/settings/account 에서 Enterprise Token을 받습니다.
 
 <Frame>
   ![Integrations](/images/enterprise/enterprise_action_auth_token.png)
@@ -176,4 +176,4 @@ crew를 배포하고 각 통합을 특정 사용자에게 범위 지정할 수
 
 <Card title="도움이 필요하신가요?" icon="headset" href="mailto:support@crewai.com">
   통합 설정이나 문제 해결에 대한 지원이 필요하시면 저희 지원팀에 문의하세요.
-</Card>
+</Card>

docs/ko/enterprise/guides/automation-triggers.mdx

@@ -1,171 +0,0 @@
----
-title: "자동화 트리거"
-description: "연결된 통합에서 특정 이벤트가 발생할 때 CrewAI 워크플로우를 자동으로 실행합니다"
-icon: "bolt"
----
-
-자동화 트리거를 사용하면 연결된 통합에서 특정 이벤트가 발생할 때 CrewAI 배포를 자동으로 실행할 수 있어, 비즈니스 시스템의 실시간 변화에 반응하는 강력한 이벤트 기반 워크플로우를 만들 수 있습니다.
-
-## 개요
-
-자동화 트리거를 사용하면 다음을 수행할 수 있습니다:
-
-- **실시간 이벤트에 응답** - 특정 조건이 충족될 때 워크플로우를 자동으로 실행
-- **외부 시스템과 통합** - Gmail, Outlook, OneDrive, JIRA, Slack, Stripe 등의 플랫폼과 연결
-- **자동화 확장** - 수동 개입 없이 대용량 이벤트 처리
-- **컨텍스트 유지** - crew와 flow 내에서 트리거 데이터에 액세스
-
-## 자동화 트리거 관리
-
-### 사용 가능한 트리거 보기
-
-자동화 트리거에 액세스하고 관리하려면:
-
-1. CrewAI 대시보드에서 배포로 이동
-2. **트리거** 탭을 클릭하여 사용 가능한 모든 트리거 통합 보기
-
-<Frame>
-  <img src="/images/enterprise/list-available-triggers.png" alt="사용 가능한 자동화 트리거 목록" />
-</Frame>
-
-이 보기는 배포에 사용 가능한 모든 트리거 통합과 현재 연결 상태를 보여줍니다.
-
-### 트리거 활성화 및 비활성화
-
-각 트리거는 토글 스위치를 사용하여 쉽게 활성화하거나 비활성화할 수 있습니다:
-
-<Frame>
-  <img src="/images/enterprise/trigger-selected.png" alt="토글로 트리거 활성화 또는 비활성화" />
-</Frame>
-
-- **활성화됨 (파란색 토글)**: 트리거가 활성 상태이며 지정된 이벤트가 발생할 때 배포를 자동으로 실행합니다
-- **비활성화됨 (회색 토글)**: 트리거가 비활성 상태이며 이벤트에 응답하지 않습니다
-
-토글을 클릭하기만 하면 트리거 상태를 변경할 수 있습니다. 변경 사항은 즉시 적용됩니다.
-
-### 트리거 실행 모니터링
-
-트리거된 실행의 성능과 기록을 추적합니다:
-
-<Frame>
-  <img src="/images/enterprise/list-executions.png" alt="자동화에 의해 트리거된 실행 목록" />
-</Frame>
-
-## 자동화 구축
-
-자동화를 구축하기 전에 crew와 flow가 받을 트리거 페이로드의 구조를 이해하는 것이 도움이 됩니다.
-
-### 페이로드 샘플 저장소
-
-자동화를 구축하고 테스트하는 데 도움이 되도록 다양한 트리거 소스의 샘플 페이로드가 포함된 포괄적인 저장소를 유지 관리하고 있습니다:
-
-**🔗 [CrewAI Enterprise 트리거 페이로드 샘플](https://github.com/crewAIInc/crewai-enterprise-trigger-payload-samples)**
-
-이 저장소에는 다음이 포함되어 있습니다:
-
-- **실제 페이로드 예제** - 다양한 트리거 소스(Gmail, Google Drive 등)에서 가져온 예제
-- **페이로드 구조 문서** - 형식과 사용 가능한 필드를 보여주는 문서
-
-### Crew와 트리거
-
-기존 crew 정의는 트리거와 완벽하게 작동하며, 받은 페이로드를 분석하는 작업만 있으면 됩니다:
-
-```python
-@CrewBase
-class MyAutomatedCrew:
-    @agent
-    def researcher(self) -> Agent:
-        return Agent(
-            config=self.agents_config['researcher'],
-        )
-
-    @task
-    def parse_trigger_payload(self) -> Task:
-        return Task(
-            config=self.tasks_config['parse_trigger_payload'],
-            agent=self.researcher(),
-        )
-
-    @task
-    def analyze_trigger_content(self) -> Task:
-        return Task(
-            config=self.tasks_config['analyze_trigger_data'],
-            agent=self.researcher(),
-        )
-```
-
-crew는 자동으로 트리거 페이로드를 받고 표준 CrewAI 컨텍스트 메커니즘을 통해 액세스할 수 있습니다.
-
-### Flow와의 통합
-
-flow의 경우 트리거 데이터 처리 방법을 더 세밀하게 제어할 수 있습니다:
-
-#### 트리거 페이로드 액세스
-
-flow의 모든 `@start()` 메서드는 `crewai_trigger_payload`라는 추가 매개변수를 허용합니다:
-
-```python
-from crewai.flow import Flow, start, listen
-
-class MyAutomatedFlow(Flow):
-    @start()
-    def handle_trigger(self, crewai_trigger_payload: dict = None):
-        """
-        이 start 메서드는 트리거 데이터를 받을 수 있습니다
-        """
-        if crewai_trigger_payload:
-            # 트리거 데이터 처리
-            trigger_id = crewai_trigger_payload.get('id')
-            event_data = crewai_trigger_payload.get('payload', {})
-
-            # 다른 메서드에서 사용할 수 있도록 flow 상태에 저장
-            self.state.trigger_id = trigger_id
-            self.state.trigger_type = event_data
-
-            return event_data
-
-        # 수동 실행 처리
-        return None
-
-    @listen(handle_trigger)
-    def process_data(self, trigger_data):
-        """
-        트리거 데이터 처리
-        """
-        # ... 트리거 처리
-```
-
-#### Flow에서 Crew 트리거하기
-
-트리거된 flow 내에서 crew를 시작할 때 트리거 페이로드를 전달합니다:
-
-```python
-@start()
-def delegate_to_crew(self, crewai_trigger_payload: dict = None):
-    """
-    전문 crew에 처리 위임
-    """
-    crew = MySpecializedCrew()
-
-    # crew에 트리거 페이로드 전달
-    result = crew.crew().kickoff(
-        inputs={
-            'a_custom_parameter': "custom_value",
-            'crewai_trigger_payload': crewai_trigger_payload
-        },
-    )
-
-    return result
-```
-
-## 문제 해결
-
-**트리거가 작동하지 않는 경우:**
-- 트리거가 활성화되어 있는지 확인
-- 통합 연결 상태 확인
-
-**실행 실패:**
-- 오류 세부 정보는 실행 로그 확인
-- 개발 중인 경우 입력에 올바른 페이로드가 포함된 `crewai_trigger_payload` 매개변수가 포함되어 있는지 확인
-
-자동화 트리거는 CrewAI 배포를 기존 비즈니스 프로세스 및 도구와 완벽하게 통합할 수 있는 반응형 이벤트 기반 시스템으로 변환합니다.

docs/pt-BR/concepts/event-listener.mdx

@@ -44,12 +44,12 @@ Para criar um listener de evento personalizado, você precisa:
 Veja um exemplo simples de uma classe de listener de evento personalizado:
 
 ```python
-from crewai.events import (
+from crewai.utilities.events import (
     CrewKickoffStartedEvent,
     CrewKickoffCompletedEvent,
     AgentExecutionCompletedEvent,
 )
-from crewai.events import BaseEventListener
+from crewai.utilities.events.base_event_listener import BaseEventListener
 
 class MeuListenerPersonalizado(BaseEventListener):
     def __init__(self):
@@ -146,7 +146,7 @@ my_project/
 
 ```python
 # my_custom_listener.py
-from crewai.events import BaseEventListener
+from crewai.utilities.events.base_event_listener import BaseEventListener
 # ... importe events ...
 
 class MyCustomListener(BaseEventListener):
@@ -268,7 +268,7 @@ Campos adicionais variam pelo tipo de evento. Por exemplo, `CrewKickoffCompleted
 Para lidar temporariamente com eventos (útil para testes ou operações específicas), você pode usar o context manager `scoped_handlers`:
 
 ```python
-from crewai.events import crewai_event_bus, CrewKickoffStartedEvent
+from crewai.utilities.events import crewai_event_bus, CrewKickoffStartedEvent
 
 with crewai_event_bus.scoped_handlers():
     @crewai_event_bus.on(CrewKickoffStartedEvent)

docs/pt-BR/concepts/knowledge.mdx

@@ -681,11 +681,11 @@ O CrewAI emite eventos durante o processo de recuperação de knowledge que voc
 #### Exemplo: Monitorando Recuperação de Knowledge
 
 ```python
-from crewai.events import (
+from crewai.utilities.events import (
     KnowledgeRetrievalStartedEvent,
     KnowledgeRetrievalCompletedEvent,
-    BaseEventListener,
 )
+from crewai.utilities.events.base_event_listener import BaseEventListener
 
 class KnowledgeMonitorListener(BaseEventListener):
     def setup_listeners(self, crewai_event_bus):

docs/pt-BR/concepts/llms.mdx

@@ -708,10 +708,10 @@ O CrewAI suporta respostas em streaming de LLMs, permitindo que sua aplicação
     O CrewAI emite eventos para cada chunk recebido durante o streaming:
 
     ```python
-    from crewai.events import (
+    from crewai.utilities.events import (
       LLMStreamChunkEvent
     )
-    from crewai.events import BaseEventListener
+    from crewai.utilities.events.base_event_listener import BaseEventListener
 
     class MyCustomListener(BaseEventListener):
         def setup_listeners(self, crewai_event_bus):

docs/pt-BR/concepts/tasks.mdx

@@ -59,7 +59,6 @@ crew = Crew(
 | **Output Pydantic** _(opcional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`  | Um modelo Pydantic para a saída da tarefa.                                                                         |
 | **Callback** _(opcional)_        | `callback`        | `Optional[Any]`              | Função/objeto a ser executado após a conclusão da tarefa.                                                          |
 | **Guardrail** _(opcional)_       | `guardrail`       | `Optional[Callable]`             | Função para validar a saída da tarefa antes de prosseguir para a próxima tarefa.                                |
-| **Max Tentativas Guardrail** _(opcional)_ | `guardrail_max_retries` | `Optional[int]`    | Número máximo de tentativas quando a validação do guardrail falha. Padrão é 3.                                   |
 
 ## Criando Tarefas
 
@@ -451,7 +450,7 @@ task = Task(
     expected_output="Um objeto JSON válido",
     agent=analyst,
     guardrail=validate_json_output,
-    guardrail_max_retries=3  # Limite de tentativas
+    max_retries=3  # Limite de tentativas
 )
 ```
 
@@ -936,7 +935,7 @@ task = Task(
     description="Gerar dados",
     expected_output="Dados válidos",
     guardrail=validate_data,
-    guardrail_max_retries=5  # Sobrescreve o limite padrão de tentativas
+    max_retries=5  # Sobrescreve o limite padrão de tentativas
 )
 ```
 

docs/pt-BR/enterprise/features/integrations.mdx

@@ -58,7 +58,7 @@ Antes de usar as Integrações de Autenticação, certifique-se de que você pos
 3. Clique em **Conectar** no serviço desejado na seção Integrações de Autenticação
 4. Complete o fluxo de autenticação OAuth
 5. Conceda as permissões necessárias para seu caso de uso
-6. Pronto! Obtenha seu Token Enterprise do [CrewAI Enterprise](https://app.crewai.com) na aba **Integration**
+6. Obtenha seu Token Enterprise na sua página de conta do [CrewAI Enterprise](https://app.crewai.com) - https://app.crewai.com/crewai_plus/settings/account
 
 <Frame>
   ![Integrações](/images/enterprise/enterprise_action_auth_token.png)
@@ -176,4 +176,4 @@ Use o `user_bearer_token` para direcionar a integração a um usuário específi
 
 <Card title="Precisa de ajuda?" icon="headset" href="mailto:support@crewai.com">
   Entre em contato com nosso time de suporte para assistência com a configuração de integrações ou solução de problemas.
-</Card>
+</Card>

docs/pt-BR/enterprise/guides/automation-triggers.mdx

@@ -1,171 +0,0 @@
----
-title: "Triggers de Automação"
-description: "Execute automaticamente seus workflows CrewAI quando eventos específicos ocorrem em integrações conectadas"
-icon: "bolt"
----
-
-Os triggers de automação permitem executar automaticamente suas implantações CrewAI quando eventos específicos ocorrem em suas integrações conectadas, criando workflows poderosos orientados por eventos que respondem a mudanças em tempo real em seus sistemas de negócio.
-
-## Visão Geral
-
-Com triggers de automação, você pode:
-
-- **Responder a eventos em tempo real** - Execute workflows automaticamente quando condições específicas forem atendidas
-- **Integrar com sistemas externos** - Conecte com plataformas como Gmail, Outlook, OneDrive, JIRA, Slack, Stripe e muito mais
-- **Escalar sua automação** - Lide com eventos de alto volume sem intervenção manual
-- **Manter contexto** - Acesse dados do trigger dentro de suas crews e flows
-
-## Gerenciando Triggers de Automação
-
-### Visualizando Triggers Disponíveis
-
-Para acessar e gerenciar seus triggers de automação:
-
-1. Navegue até sua implantação no painel do CrewAI
-2. Clique na aba **Triggers** para visualizar todas as integrações de trigger disponíveis
-
-<Frame>
-  <img src="/images/enterprise/list-available-triggers.png" alt="Lista de triggers de automação disponíveis" />
-</Frame>
-
-Esta visualização mostra todas as integrações de trigger disponíveis para sua implantação, junto com seus status de conexão atuais.
-
-### Habilitando e Desabilitando Triggers
-
-Cada trigger pode ser facilmente habilitado ou desabilitado usando o botão de alternância:
-
-<Frame>
-  <img src="/images/enterprise/trigger-selected.png" alt="Habilitar ou desabilitar triggers com alternância" />
-</Frame>
-
-- **Habilitado (alternância azul)**: O trigger está ativo e executará automaticamente sua implantação quando os eventos especificados ocorrerem
-- **Desabilitado (alternância cinza)**: O trigger está inativo e não responderá a eventos
-
-Simplesmente clique na alternância para mudar o estado do trigger. As alterações entram em vigor imediatamente.
-
-### Monitorando Execuções de Trigger
-
-Acompanhe o desempenho e histórico de suas execuções acionadas:
-
-<Frame>
-  <img src="/images/enterprise/list-executions.png" alt="Lista de execuções acionadas por automação" />
-</Frame>
-
-## Construindo Automação
-
-Antes de construir sua automação, é útil entender a estrutura dos payloads de trigger que suas crews e flows receberão.
-
-### Repositório de Amostras de Payload
-
-Mantemos um repositório abrangente com amostras de payload de várias fontes de trigger para ajudá-lo a construir e testar suas automações:
-
-**🔗 [Amostras de Payload de Trigger CrewAI Enterprise](https://github.com/crewAIInc/crewai-enterprise-trigger-payload-samples)**
-
-Este repositório contém:
-
-- **Exemplos reais de payload** de diferentes fontes de trigger (Gmail, Google Drive, etc.)
-- **Documentação da estrutura de payload** mostrando o formato e campos disponíveis
-
-### Triggers com Crew
-
-Suas definições de crew existentes funcionam perfeitamente com triggers, você só precisa ter uma tarefa para analisar o payload recebido:
-
-```python
-@CrewBase
-class MinhaCrewAutomatizada:
-    @agent
-    def pesquisador(self) -> Agent:
-        return Agent(
-            config=self.agents_config['pesquisador'],
-        )
-
-    @task
-    def analisar_payload_trigger(self) -> Task:
-        return Task(
-            config=self.tasks_config['analisar_payload_trigger'],
-            agent=self.pesquisador(),
-        )
-
-    @task
-    def analisar_conteudo_trigger(self) -> Task:
-        return Task(
-            config=self.tasks_config['analisar_dados_trigger'],
-            agent=self.pesquisador(),
-        )
-```
-
-A crew receberá automaticamente e pode acessar o payload do trigger através dos mecanismos de contexto padrão do CrewAI.
-
-### Integração com Flows
-
-Para flows, você tem mais controle sobre como os dados do trigger são tratados:
-
-#### Acessando Payload do Trigger
-
-Todos os métodos `@start()` em seus flows aceitarão um parâmetro adicional chamado `crewai_trigger_payload`:
-
-```python
-from crewai.flow import Flow, start, listen
-
-class MeuFlowAutomatizado(Flow):
-    @start()
-    def lidar_com_trigger(self, crewai_trigger_payload: dict = None):
-        """
-        Este método start pode receber dados do trigger
-        """
-        if crewai_trigger_payload:
-            # Processa os dados do trigger
-            trigger_id = crewai_trigger_payload.get('id')
-            dados_evento = crewai_trigger_payload.get('payload', {})
-
-            # Armazena no estado do flow para uso por outros métodos
-            self.state.trigger_id = trigger_id
-            self.state.trigger_type = dados_evento
-
-            return dados_evento
-
-        # Lida com execução manual
-        return None
-
-    @listen(lidar_com_trigger)
-    def processar_dados(self, dados_trigger):
-        """
-        Processa os dados do trigger
-        """
-        # ... processa o trigger
-```
-
-#### Acionando Crews a partir de Flows
-
-Ao iniciar uma crew dentro de um flow que foi acionado, passe o payload do trigger conforme ele:
-
-```python
-@start()
-def delegar_para_crew(self, crewai_trigger_payload: dict = None):
-    """
-    Delega processamento para uma crew especializada
-    """
-    crew = MinhaCrewEspecializada()
-
-    # Passa o payload do trigger para a crew
-    resultado = crew.crew().kickoff(
-        inputs={
-            'parametro_personalizado': "valor_personalizado",
-            'crewai_trigger_payload': crewai_trigger_payload
-        },
-    )
-
-    return resultado
-```
-
-## Solução de Problemas
-
-**Trigger não está sendo disparado:**
-- Verifique se o trigger está habilitado
-- Verifique o status de conexão da integração
-
-**Falhas de execução:**
-- Verifique os logs de execução para detalhes do erro
-- Se você está desenvolvendo, certifique-se de que as entradas incluem o parâmetro `crewai_trigger_payload` com o payload correto
-
-Os triggers de automação transformam suas implantações CrewAI em sistemas responsivos orientados por eventos que podem se integrar perfeitamente com seus processos de negócio e ferramentas existentes.

pyproject.toml

@@ -48,7 +48,7 @@ Documentation = "https://docs.crewai.com"
 Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
-tools = ["crewai-tools~=0.69.0"]
+tools = ["crewai-tools~=0.62.1"]
 embeddings = [
     "tiktoken~=0.8.0"
 ]
@@ -68,16 +68,12 @@ docling = [
 aisuite = [
     "aisuite>=0.1.10",
 ]
-qdrant = [
-    "qdrant-client[fastembed]>=1.14.3",
-]
 
 [tool.uv]
 dev-dependencies = [
-    "ruff>=0.12.11",
-    "mypy>=1.17.1",
-    "pre-commit>=4.3.0",
-    "bandit>=1.8.6",
+    "ruff>=0.8.2",
+    "mypy>=1.10.0",
+    "pre-commit>=3.6.0",
     "pillow>=10.2.0",
     "cairosvg>=2.7.1",
     "pytest>=8.0.0",
@@ -89,41 +85,15 @@ dev-dependencies = [
     "pytest-timeout>=2.3.1",
     "pytest-xdist>=3.6.1",
     "pytest-split>=0.9.0",
-    "types-requests==2.32.*",
-    "types-pyyaml==6.0.*",
-    "types-regex==2024.11.6.*",
-    "types-appdirs==1.4.*",
 ]
 
 [project.scripts]
 crewai = "crewai.cli.cli:crewai"
 
-[tool.ruff]
-exclude = [
-    "src/crewai/cli/templates",
-]
-fix = true
-
-[tool.ruff.lint]
-select = [
-    "B006",
-    "UP006",
-    "UP007",
-    "UP035",
-    "UP037",
-    "UP004",
-    "UP008",
-    "UP010",
-    "UP018",
-    "UP031",
-    "UP032",
-    "I001",
-    "I002",
-]
-
 [tool.mypy]
-strict = true
-exclude = ["src/crewai/cli/templates"]
+ignore_missing_imports = true
+disable_error_code = 'import-untyped'
+exclude = ["cli/templates"]
 
 [tool.bandit]
 exclude_dirs = ["src/crewai/cli/templates"]

src/crewai/__init__.py

@@ -1,30 +1,4 @@
 import warnings
-from typing import Any
-
-
-def _suppress_pydantic_deprecation_warnings() -> None:
-    """Suppress Pydantic deprecation warnings using targeted monkey patch."""
-    original_warn = warnings.warn
-
-    def filtered_warn(
-        message: Any,
-        category: type | None = None,
-        stacklevel: int = 1,
-        source: Any = None,
-    ) -> Any:
-        if (
-            category
-            and hasattr(category, "__module__")
-            and category.__module__ == "pydantic.warnings"
-        ):
-            return None
-        return original_warn(message, category, stacklevel + 1, source)
-
-    setattr(warnings, "warn", filtered_warn)
-
-
-_suppress_pydantic_deprecation_warnings()
-
 import threading
 import urllib.request
 
@@ -41,10 +15,17 @@ from crewai.tasks.llm_guardrail import LLMGuardrail
 from crewai.tasks.task_output import TaskOutput
 from crewai.telemetry.telemetry import Telemetry
 
+warnings.filterwarnings(
+    "ignore",
+    message="Pydantic serializer warnings:",
+    category=UserWarning,
+    module="pydantic.main",
+)
+
 _telemetry_submitted = False
 
 
-def _track_install() -> None:
+def _track_install():
     """Track package installation/first-use via Scarf analytics."""
     global _telemetry_submitted
 
@@ -55,7 +36,7 @@ def _track_install() -> None:
         pixel_url = "https://api.scarf.sh/v2/packages/CrewAI/crewai/docs/00f2dad1-8334-4a39-934e-003b2e1146db"
 
         req = urllib.request.Request(pixel_url)
-        req.add_header("User-Agent", f"CrewAI-Python/{__version__}")
+        req.add_header('User-Agent', f'CrewAI-Python/{__version__}')
 
         with urllib.request.urlopen(req, timeout=2):  # nosec B310
             _telemetry_submitted = True
@@ -64,7 +45,7 @@ def _track_install() -> None:
         pass
 
 
-def _track_install_async() -> None:
+def _track_install_async():
     """Track installation in background thread to avoid blocking imports."""
     if not Telemetry._is_telemetry_disabled():
         thread = threading.Thread(target=_track_install, daemon=True)
@@ -73,7 +54,7 @@ def _track_install_async() -> None:
 
 _track_install_async()
 
-__version__ = "0.177.0"
+__version__ = "0.165.1"
 __all__ = [
     "Agent",
     "Crew",

src/crewai/agent.py

@@ -1,18 +1,7 @@
 import shutil
 import subprocess
 import time
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    Union,
-)
+from typing import Any, Callable, Dict, List, Literal, Optional, Sequence, Tuple, Type, Union
 
 from pydantic import Field, InstanceOf, PrivateAttr, model_validator
 
@@ -38,17 +27,17 @@ from crewai.utilities.agent_utils import (
 )
 from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_FILE
 from crewai.utilities.converter import generate_model_description
-from crewai.events.types.agent_events import (
+from crewai.utilities.events.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionErrorEvent,
     AgentExecutionStartedEvent,
 )
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.memory_events import (
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.utilities.events.memory_events import (
     MemoryRetrievalStartedEvent,
     MemoryRetrievalCompletedEvent,
 )
-from crewai.events.types.knowledge_events import (
+from crewai.utilities.events.knowledge_events import (
     KnowledgeQueryCompletedEvent,
     KnowledgeQueryFailedEvent,
     KnowledgeQueryStartedEvent,
@@ -173,7 +162,7 @@ class Agent(BaseAgent):
     )
     guardrail: Optional[Union[Callable[[Any], Tuple[bool, Any]], str]] = Field(
         default=None,
-        description="Function or string description of a guardrail to validate agent output",
+        description="Function or string description of a guardrail to validate agent output"
     )
     guardrail_max_retries: int = Field(
         default=3, description="Maximum number of retries when guardrail fails"
@@ -287,7 +276,7 @@ class Agent(BaseAgent):
         self._inject_date_to_task(task)
 
         if self.tools_handler:
-            self.tools_handler.last_used_tool = None
+            self.tools_handler.last_used_tool = {}  # type: ignore # Incompatible types in assignment (expression has type "dict[Never, Never]", variable has type "ToolCalling")
 
         task_prompt = task.prompt()
 
@@ -320,20 +309,15 @@ class Agent(BaseAgent):
                 event=MemoryRetrievalStartedEvent(
                     task_id=str(task.id) if task else None,
                     source_type="agent",
-                    from_agent=self,
-                    from_task=task,
                 ),
             )
 
             start_time = time.time()
-
             contextual_memory = ContextualMemory(
                 self.crew._short_term_memory,
                 self.crew._long_term_memory,
                 self.crew._entity_memory,
                 self.crew._external_memory,
-                agent=self,
-                task=task,
             )
             memory = contextual_memory.build_context_for_task(task, context)
             if memory.strip() != "":
@@ -346,14 +330,13 @@ class Agent(BaseAgent):
                     memory_content=memory,
                     retrieval_time_ms=(time.time() - start_time) * 1000,
                     source_type="agent",
-                    from_agent=self,
-                    from_task=task,
                 ),
             )
         knowledge_config = (
             self.knowledge_config.model_dump() if self.knowledge_config else {}
         )
 
+
         if self.knowledge or (self.crew and self.crew.knowledge):
             crewai_event_bus.emit(
                 self,

src/crewai/agents/__init__.py

@@ -1,5 +1,5 @@
-from crewai.agents.cache.cache_handler import CacheHandler
-from crewai.agents.parser import parse, AgentAction, AgentFinish, OutputParserException
-from crewai.agents.tools_handler import ToolsHandler
+from .cache.cache_handler import CacheHandler
+from .parser import CrewAgentParser
+from .tools_handler import ToolsHandler
 
-__all__ = ["CacheHandler", "parse", "AgentAction", "AgentFinish", "OutputParserException", "ToolsHandler"]
+__all__ = ["CacheHandler", "CrewAgentParser", "ToolsHandler"]

src/crewai/agents/agent_adapters/langgraph/langgraph_adapter.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, AsyncIterable, Dict, List, Optional
 
 from pydantic import Field, PrivateAttr
 
@@ -14,14 +14,15 @@ from crewai.tools.agent_tools.agent_tools import AgentTools
 from crewai.tools.base_tool import BaseTool
 from crewai.utilities import Logger
 from crewai.utilities.converter import Converter
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.agent_events import (
+from crewai.utilities.events import crewai_event_bus
+from crewai.utilities.events.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionErrorEvent,
     AgentExecutionStartedEvent,
 )
 
 try:
+    from langchain_core.messages import ToolMessage
     from langgraph.checkpoint.memory import MemorySaver
     from langgraph.prebuilt import create_react_agent
 

src/crewai/agents/agent_adapters/openai_agents/openai_adapter.py

@@ -10,8 +10,8 @@ from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.tools import BaseTool
 from crewai.tools.agent_tools.agent_tools import AgentTools
 from crewai.utilities import Logger
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.agent_events import (
+from crewai.utilities.events import crewai_event_bus
+from crewai.utilities.events.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionErrorEvent,
     AgentExecutionStartedEvent,

src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -7,7 +7,7 @@ from crewai.utilities import I18N
 from crewai.utilities.converter import ConverterError
 from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
 from crewai.utilities.printer import Printer
-from crewai.events.event_listener import event_listener
+from crewai.utilities.events.event_listener import event_listener
 
 if TYPE_CHECKING:
     from crewai.agents.agent_builder.base_agent import BaseAgent
@@ -43,6 +43,7 @@ class CrewAgentExecutorMixin:
                         metadata={
                             "observation": self.task.description,
                         },
+                        agent=self.agent.role,
                     )
             except Exception as e:
                 print(f"Failed to add to short term memory: {e}")
@@ -64,6 +65,7 @@ class CrewAgentExecutorMixin:
                         "description": self.task.description,
                         "messages": self.messages,
                     },
+                    agent=self.agent.role,
                 )
             except Exception as e:
                 print(f"Failed to add to external memory: {e}")
@@ -98,8 +100,8 @@ class CrewAgentExecutorMixin:
                 )
                 self.crew._long_term_memory.save(long_term_memory)
 
-                entity_memories = [
-                    EntityMemoryItem(
+                for entity in evaluation.entities:
+                    entity_memory = EntityMemoryItem(
                         name=entity.name,
                         type=entity.type,
                         description=entity.description,
@@ -107,10 +109,7 @@ class CrewAgentExecutorMixin:
                             [f"- {r}" for r in entity.relationships]
                         ),
                     )
-                    for entity in evaluation.entities
-                ]
-                if entity_memories:
-                    self.crew._entity_memory.save(entity_memories)
+                    self.crew._entity_memory.save(entity_memory)
             except AttributeError as e:
                 print(f"Missing attributes for long term memory: {e}")
                 pass
@@ -159,9 +158,7 @@ class CrewAgentExecutorMixin:
             self._printer.print(content=prompt, color="bold_yellow")
             response = input()
             if response.strip() != "":
-                self._printer.print(
-                    content="\nProcessing your feedback...", color="cyan"
-                )
+                self._printer.print(content="\nProcessing your feedback...", color="cyan")
             return response
         finally:
             event_listener.formatter.resume_live_updates()

src/crewai/agents/constants.py

@@ -1,27 +0,0 @@
-"""Constants for agent-related modules."""
-
-import re
-from typing import Final
-
-# crewai.agents.parser constants
-
-FINAL_ANSWER_ACTION: Final[str] = "Final Answer:"
-MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE: Final[str] = (
-    "I did it wrong. Invalid Format: I missed the 'Action:' after 'Thought:'. I will do right next, and don't use a tool I have already used.\n"
-)
-MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE: Final[str] = (
-    "I did it wrong. Invalid Format: I missed the 'Action Input:' after 'Action:'. I will do right next, and don't use a tool I have already used.\n"
-)
-FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE: Final[str] = (
-    "I did it wrong. Tried to both perform Action and give a Final Answer at the same time, I must do one or the other"
-)
-UNABLE_TO_REPAIR_JSON_RESULTS: Final[list[str]] = ['""', "{}"]
-ACTION_INPUT_REGEX: Final[re.Pattern[str]] = re.compile(
-    r"Action\s*\d*\s*:\s*(.*?)\s*Action\s*\d*\s*Input\s*\d*\s*:\s*(.*)", re.DOTALL
-)
-ACTION_REGEX: Final[re.Pattern[str]] = re.compile(
-    r"Action\s*\d*\s*:\s*(.*?)", re.DOTALL
-)
-ACTION_INPUT_ONLY_REGEX: Final[re.Pattern[str]] = re.compile(
-    r"\s*Action\s*\d*\s*Input\s*\d*\s*:\s*(.*)", re.DOTALL
-)

src/crewai/agents/crew_agent_executor.py

@@ -30,11 +30,11 @@ from crewai.utilities.constants import MAX_LLM_RETRY, TRAINING_DATA_FILE
 from crewai.utilities.logger import Logger
 from crewai.utilities.tool_utils import execute_tool_and_check_finality
 from crewai.utilities.training_handler import CrewTrainingHandler
-from crewai.events.types.logging_events import (
+from crewai.utilities.events.agent_events import (
     AgentLogsStartedEvent,
     AgentLogsExecutionEvent,
 )
-from crewai.events.event_bus import crewai_event_bus
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
 
 
 class CrewAgentExecutor(CrewAgentExecutorMixin):
@@ -54,11 +54,11 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         tools_description: str,
         tools_handler: ToolsHandler,
         step_callback: Any = None,
-        original_tools: List[Any] | None = None,
+        original_tools: List[Any] = [],
         function_calling_llm: Any = None,
         respect_context_window: bool = False,
         request_within_rpm_limit: Optional[Callable[[], bool]] = None,
-        callbacks: List[Any] | None = None,
+        callbacks: List[Any] = [],
     ):
         self._i18n: I18N = I18N()
         self.llm: BaseLLM = llm
@@ -70,10 +70,10 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         self.tools_names = tools_names
         self.stop = stop_words
         self.max_iter = max_iter
-        self.callbacks = callbacks or []
+        self.callbacks = callbacks
         self._printer: Printer = Printer()
         self.tools_handler = tools_handler
-        self.original_tools = original_tools or []
+        self.original_tools = original_tools
         self.step_callback = step_callback
         self.use_stop_words = self.llm.supports_stop_words()
         self.tools_description = tools_description
@@ -122,6 +122,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             handle_unknown_error(self._printer, e)
             raise
 
+
         if self.ask_for_human_input:
             formatted_answer = self._handle_human_feedback(formatted_answer)
 
@@ -155,7 +156,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     messages=self.messages,
                     callbacks=self.callbacks,
                     printer=self._printer,
-                    from_task=self.task,
+                    from_task=self.task
                 )
                 formatted_answer = process_llm_response(answer, self.use_stop_words)
 

src/crewai/agents/parser.py

@@ -1,67 +1,50 @@
-"""Agent output parsing module for ReAct-style LLM responses.
-
-This module provides parsing functionality for agent outputs that follow
-the ReAct (Reasoning and Acting) format, converting them into structured
-AgentAction or AgentFinish objects.
-"""
-
-from dataclasses import dataclass
+import re
+from typing import Any, Optional, Union
 
 from json_repair import repair_json
 
-from crewai.agents.constants import (
-    ACTION_INPUT_REGEX,
-    ACTION_REGEX,
-    ACTION_INPUT_ONLY_REGEX,
-    FINAL_ANSWER_ACTION,
-    MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE,
-    MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
-    UNABLE_TO_REPAIR_JSON_RESULTS,
-)
 from crewai.utilities import I18N
 
-_I18N = I18N()
+FINAL_ANSWER_ACTION = "Final Answer:"
+MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action:' after 'Thought:'. I will do right next, and don't use a tool I have already used.\n"
+MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE = "I did it wrong. Invalid Format: I missed the 'Action Input:' after 'Action:'. I will do right next, and don't use a tool I have already used.\n"
+FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = "I did it wrong. Tried to both perform Action and give a Final Answer at the same time, I must do one or the other"
 
 
-@dataclass
 class AgentAction:
-    """Represents an action to be taken by an agent."""
-
     thought: str
     tool: str
     tool_input: str
     text: str
-    result: str | None = None
+    result: str
+
+    def __init__(self, thought: str, tool: str, tool_input: str, text: str):
+        self.thought = thought
+        self.tool = tool
+        self.tool_input = tool_input
+        self.text = text
 
 
-@dataclass
 class AgentFinish:
-    """Represents the final answer from an agent."""
-
     thought: str
     output: str
     text: str
 
+    def __init__(self, thought: str, output: str, text: str):
+        self.thought = thought
+        self.output = output
+        self.text = text
+
 
 class OutputParserException(Exception):
-    """Exception raised when output parsing fails.
+    error: str
 
-    Attributes:
-        error: The error message.
-    """
-
-    def __init__(self, error: str) -> None:
-        """Initialize OutputParserException.
-
-        Args:
-            error: The error message.
-        """
+    def __init__(self, error: str):
         self.error = error
-        super().__init__(error)
 
 
-def parse(text: str) -> AgentAction | AgentFinish:
-    """Parse agent output text into AgentAction or AgentFinish.
+class CrewAgentParser:
+    """Parses ReAct-style LLM calls that have a single tool input.
 
     Expects output to be in one of two formats.
 
@@ -79,117 +62,108 @@ def parse(text: str) -> AgentAction | AgentFinish:
 
     Thought: agent thought here
     Final Answer: The temperature is 100 degrees
-
-    Args:
-        text: The agent output text to parse.
-
-    Returns:
-        AgentAction or AgentFinish based on the content.
-
-    Raises:
-        OutputParserException: If the text format is invalid.
     """
-    thought = _extract_thought(text)
-    includes_answer = FINAL_ANSWER_ACTION in text
-    action_match = ACTION_INPUT_REGEX.search(text)
 
-    if includes_answer:
-        final_answer = text.split(FINAL_ANSWER_ACTION)[-1].strip()
-        # Check whether the final answer ends with triple backticks.
-        if final_answer.endswith("```"):
-            # Count occurrences of triple backticks in the final answer.
-            count = final_answer.count("```")
-            # If count is odd then it's an unmatched trailing set; remove it.
-            if count % 2 != 0:
-                final_answer = final_answer[:-3].rstrip()
-        return AgentFinish(thought=thought, output=final_answer, text=text)
+    _i18n: I18N = I18N()
+    agent: Any = None
 
-    elif action_match:
-        action = action_match.group(1)
-        clean_action = _clean_action(action)
+    def __init__(self, agent: Optional[Any] = None):
+        self.agent = agent
 
-        action_input = action_match.group(2).strip()
+    @staticmethod
+    def parse_text(text: str) -> Union[AgentAction, AgentFinish]:
+        """
+        Static method to parse text into an AgentAction or AgentFinish without needing to instantiate the class.
 
-        tool_input = action_input.strip(" ").strip('"')
-        safe_tool_input = _safe_repair_json(tool_input)
+        Args:
+            text: The text to parse.
 
-        return AgentAction(
-            thought=thought, tool=clean_action, tool_input=safe_tool_input, text=text
+        Returns:
+            Either an AgentAction or AgentFinish based on the parsed content.
+        """
+        parser = CrewAgentParser()
+        return parser.parse(text)
+
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        thought = self._extract_thought(text)
+        includes_answer = FINAL_ANSWER_ACTION in text
+        regex = (
+            r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
         )
+        action_match = re.search(regex, text, re.DOTALL)
+        if includes_answer:
+            final_answer = text.split(FINAL_ANSWER_ACTION)[-1].strip()
+            # Check whether the final answer ends with triple backticks.
+            if final_answer.endswith("```"):
+                # Count occurrences of triple backticks in the final answer.
+                count = final_answer.count("```")
+                # If count is odd then it's an unmatched trailing set; remove it.
+                if count % 2 != 0:
+                    final_answer = final_answer[:-3].rstrip()
+            return AgentFinish(thought, final_answer, text)
 
-    if not ACTION_REGEX.search(text):
-        raise OutputParserException(
-            f"{MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE}\n{_I18N.slice('final_answer_format')}",
-        )
-    elif not ACTION_INPUT_ONLY_REGEX.search(text):
-        raise OutputParserException(
-            MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
-        )
-    else:
-        err_format = _I18N.slice("format_without_tools")
-        error = f"{err_format}"
-        raise OutputParserException(
-            error,
-        )
+        elif action_match:
+            action = action_match.group(1)
+            clean_action = self._clean_action(action)
 
+            action_input = action_match.group(2).strip()
 
-def _extract_thought(text: str) -> str:
-    """Extract the thought portion from the text.
+            tool_input = action_input.strip(" ").strip('"')
+            safe_tool_input = self._safe_repair_json(tool_input)
 
-    Args:
-        text: The full agent output text.
+            return AgentAction(thought, clean_action, safe_tool_input, text)
 
-    Returns:
-        The extracted thought string.
-    """
-    thought_index = text.find("\nAction")
-    if thought_index == -1:
-        thought_index = text.find("\nFinal Answer")
-    if thought_index == -1:
-        return ""
-    thought = text[:thought_index].strip()
-    # Remove any triple backticks from the thought string
-    thought = thought.replace("```", "").strip()
-    return thought
+        if not re.search(r"Action\s*\d*\s*:[\s]*(.*?)", text, re.DOTALL):
+            raise OutputParserException(
+                f"{MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE}\n{self._i18n.slice('final_answer_format')}",
+            )
+        elif not re.search(
+            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)", text, re.DOTALL
+        ):
+            raise OutputParserException(
+                MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
+            )
+        else:
+            format = self._i18n.slice("format_without_tools")
+            error = f"{format}"
+            raise OutputParserException(
+                error,
+            )
 
+    def _extract_thought(self, text: str) -> str:
+        thought_index = text.find("\nAction")
+        if thought_index == -1:
+            thought_index = text.find("\nFinal Answer")
+        if thought_index == -1:
+            return ""
+        thought = text[:thought_index].strip()
+        # Remove any triple backticks from the thought string
+        thought = thought.replace("```", "").strip()
+        return thought
 
-def _clean_action(text: str) -> str:
-    """Clean action string by removing non-essential formatting characters.
+    def _clean_action(self, text: str) -> str:
+        """Clean action string by removing non-essential formatting characters."""
+        return text.strip().strip("*").strip()
 
-    Args:
-        text: The action text to clean.
+    def _safe_repair_json(self, tool_input: str) -> str:
+        UNABLE_TO_REPAIR_JSON_RESULTS = ['""', "{}"]
 
-    Returns:
-        The cleaned action string.
-    """
-    return text.strip().strip("*").strip()
+        # Skip repair if the input starts and ends with square brackets
+        # Explanation: The JSON parser has issues handling inputs that are enclosed in square brackets ('[]').
+        # These are typically valid JSON arrays or strings that do not require repair. Attempting to repair such inputs
+        # might lead to unintended alterations, such as wrapping the entire input in additional layers or modifying
+        # the structure in a way that changes its meaning. By skipping the repair for inputs that start and end with
+        # square brackets, we preserve the integrity of these valid JSON structures and avoid unnecessary modifications.
+        if tool_input.startswith("[") and tool_input.endswith("]"):
+            return tool_input
 
+        # Before repair, handle common LLM issues:
+        # 1. Replace """ with " to avoid JSON parser errors
 
-def _safe_repair_json(tool_input: str) -> str:
-    """Safely repair JSON input.
+        tool_input = tool_input.replace('"""', '"')
 
-    Args:
-        tool_input: The tool input string to repair.
+        result = repair_json(tool_input)
+        if result in UNABLE_TO_REPAIR_JSON_RESULTS:
+            return tool_input
 
-    Returns:
-        The repaired JSON string or original if repair fails.
-    """
-    # Skip repair if the input starts and ends with square brackets
-    # Explanation: The JSON parser has issues handling inputs that are enclosed in square brackets ('[]').
-    # These are typically valid JSON arrays or strings that do not require repair. Attempting to repair such inputs
-    # might lead to unintended alterations, such as wrapping the entire input in additional layers or modifying
-    # the structure in a way that changes its meaning. By skipping the repair for inputs that start and end with
-    # square brackets, we preserve the integrity of these valid JSON structures and avoid unnecessary modifications.
-    if tool_input.startswith("[") and tool_input.endswith("]"):
-        return tool_input
-
-    # Before repair, handle common LLM issues:
-    # 1. Replace """ with " to avoid JSON parser errors
-
-    tool_input = tool_input.replace('"""', '"')
-
-    result = repair_json(tool_input)
-    if result in UNABLE_TO_REPAIR_JSON_RESULTS:
-        return tool_input
-
-    return str(result)
+        return str(result)

src/crewai/agents/tools_handler.py

@@ -1,41 +1,29 @@
-"""Tools handler for managing tool execution and caching."""
+from typing import Any, Optional, Union
 
-from crewai.tools.cache_tools.cache_tools import CacheTools
-from crewai.tools.tool_calling import InstructorToolCalling, ToolCalling
-from crewai.agents.cache.cache_handler import CacheHandler
+from ..tools.cache_tools.cache_tools import CacheTools
+from ..tools.tool_calling import InstructorToolCalling, ToolCalling
+from .cache.cache_handler import CacheHandler
 
 
 class ToolsHandler:
-    """Callback handler for tool usage.
+    """Callback handler for tool usage."""
 
-    Attributes:
-        last_used_tool: The most recently used tool calling instance.
-        cache: Optional cache handler for storing tool outputs.
-    """
+    last_used_tool: ToolCalling = {}  # type: ignore # BUG?: Incompatible types in assignment (expression has type "Dict[...]", variable has type "ToolCalling")
+    cache: Optional[CacheHandler]
 
-    def __init__(self, cache: CacheHandler | None = None) -> None:
-        """Initialize the callback handler.
-
-        Args:
-            cache: Optional cache handler for storing tool outputs.
-        """
-        self.cache: CacheHandler | None = cache
-        self.last_used_tool: ToolCalling | InstructorToolCalling | None = None
+    def __init__(self, cache: Optional[CacheHandler] = None):
+        """Initialize the callback handler."""
+        self.cache = cache
+        self.last_used_tool = {}  # type: ignore # BUG?: same as above
 
     def on_tool_use(
         self,
-        calling: ToolCalling | InstructorToolCalling,
+        calling: Union[ToolCalling, InstructorToolCalling],
         output: str,
         should_cache: bool = True,
-    ) -> None:
-        """Run when tool ends running.
-
-        Args:
-            calling: The tool calling instance.
-            output: The output from the tool execution.
-            should_cache: Whether to cache the tool output.
-        """
-        self.last_used_tool = calling
+    ) -> Any:
+        """Run when tool ends running."""
+        self.last_used_tool = calling  # type: ignore # BUG?: Incompatible types in assignment (expression has type "Union[ToolCalling, InstructorToolCalling]", variable has type "ToolCalling")
         if self.cache and should_cache and calling.tool_name != CacheTools().name:
             self.cache.add(
                 tool=calling.tool_name,

src/crewai/cli/authentication/constants.py

@@ -1 +1,6 @@
 ALGORITHMS = ["RS256"]
+
+#TODO: The AUTH0 constants should be removed after WorkOS migration is completed
+AUTH0_DOMAIN = "crewai.us.auth0.com"
+AUTH0_CLIENT_ID = "DEVC5Fw6NlRoSzmDCcOhVq85EfLBjKa8"
+AUTH0_AUDIENCE = "https://crewai.us.auth0.com/api/v2/"

src/crewai/cli/authentication/main.py

@@ -7,27 +7,24 @@ from rich.console import Console
 from pydantic import BaseModel, Field
 
 
-from .utils import validate_jwt_token
-from crewai.cli.shared.token_manager import TokenManager
+from .utils import TokenManager, validate_jwt_token
+from urllib.parse import quote
+from crewai.cli.plus_api import PlusAPI
 from crewai.cli.config import Settings
+from crewai.cli.authentication.constants import (
+    AUTH0_AUDIENCE,
+    AUTH0_CLIENT_ID,
+    AUTH0_DOMAIN,
+)
 
 console = Console()
 
 
 class Oauth2Settings(BaseModel):
-    provider: str = Field(
-        description="OAuth2 provider used for authentication (e.g., workos, okta, auth0)."
-    )
-    client_id: str = Field(
-        description="OAuth2 client ID issued by the provider, used during authentication requests."
-    )
-    domain: str = Field(
-        description="OAuth2 provider's domain (e.g., your-org.auth0.com) used for issuing tokens."
-    )
-    audience: Optional[str] = Field(
-        description="OAuth2 audience value, typically used to identify the target API or resource.",
-        default=None,
-    )
+    provider: str = Field(description="OAuth2 provider used for authentication (e.g., workos, okta, auth0).")
+    client_id: str = Field(description="OAuth2 client ID issued by the provider, used during authentication requests.")
+    domain: str = Field(description="OAuth2 provider's domain (e.g., your-org.auth0.com) used for issuing tokens.")
+    audience: Optional[str] = Field(description="OAuth2 audience value, typically used to identify the target API or resource.", default=None)
 
     @classmethod
     def from_settings(cls):
@@ -47,15 +44,11 @@ class ProviderFactory:
         settings = settings or Oauth2Settings.from_settings()
 
         import importlib
-
-        module = importlib.import_module(
-            f"crewai.cli.authentication.providers.{settings.provider.lower()}"
-        )
+        module = importlib.import_module(f"crewai.cli.authentication.providers.{settings.provider.lower()}")
         provider = getattr(module, f"{settings.provider.capitalize()}Provider")
 
         return provider(settings)
 
-
 class AuthenticationCommand:
     def __init__(self):
         self.token_manager = TokenManager()
@@ -65,12 +58,26 @@ class AuthenticationCommand:
         """Sign up to CrewAI+"""
         console.print("Signing in to CrewAI Enterprise...\n", style="bold blue")
 
+        # TODO: WORKOS - Next line and conditional are temporary until migration to WorkOS is complete.
+        user_provider = self._determine_user_provider()
+        if user_provider == "auth0":
+            settings = Oauth2Settings(
+                provider="auth0",
+                client_id=AUTH0_CLIENT_ID,
+                domain=AUTH0_DOMAIN,
+                audience=AUTH0_AUDIENCE
+            )
+            self.oauth2_provider = ProviderFactory.from_settings(settings)
+        # End of temporary code.
+
         device_code_data = self._get_device_code()
         self._display_auth_instructions(device_code_data)
 
         return self._poll_for_token(device_code_data)
 
-    def _get_device_code(self) -> Dict[str, Any]:
+    def _get_device_code(
+        self
+    ) -> Dict[str, Any]:
         """Get the device code to authenticate the user."""
 
         device_code_payload = {
@@ -79,9 +86,7 @@ class AuthenticationCommand:
             "audience": self.oauth2_provider.get_audience(),
         }
         response = requests.post(
-            url=self.oauth2_provider.get_authorize_url(),
-            data=device_code_payload,
-            timeout=20,
+            url=self.oauth2_provider.get_authorize_url(), data=device_code_payload, timeout=20
         )
         response.raise_for_status()
         return response.json()
@@ -92,7 +97,9 @@ class AuthenticationCommand:
         console.print("2. Enter the following code: ", device_code_data["user_code"])
         webbrowser.open(device_code_data["verification_uri_complete"])
 
-    def _poll_for_token(self, device_code_data: Dict[str, Any]) -> None:
+    def _poll_for_token(
+        self, device_code_data: Dict[str, Any]
+    ) -> None:
         """Polls the server for the token until it is received, or max attempts are reached."""
 
         token_payload = {
@@ -105,9 +112,7 @@ class AuthenticationCommand:
 
         attempts = 0
         while True and attempts < 10:
-            response = requests.post(
-                self.oauth2_provider.get_token_url(), data=token_payload, timeout=30
-            )
+            response = requests.post(self.oauth2_provider.get_token_url(), data=token_payload, timeout=30)
             token_data = response.json()
 
             if response.status_code == 200:
@@ -187,3 +192,30 @@ class AuthenticationCommand:
                 "\nRun [bold]crewai login[/bold] to try logging in again.\n",
                 style="yellow",
             )
+
+    # TODO: WORKOS - This method is temporary until migration to WorkOS is complete.
+    def _determine_user_provider(self) -> str:
+        """Determine which provider to use for authentication."""
+
+        console.print(
+            "Enter your CrewAI Enterprise account email: ", style="bold blue", end=""
+        )
+        email = input()
+        email_encoded = quote(email)
+
+        # It's not correct to call this method directly, but it's temporary until migration is complete.
+        response = PlusAPI("")._make_request(
+            "GET", f"/crewai_plus/api/v1/me/provider?email={email_encoded}"
+        )
+
+        if response.status_code == 200:
+            if response.json().get("provider") == "auth0":
+                return "auth0"
+            else:
+                return "workos"
+        else:
+            console.print(
+                "Error: Failed to authenticate with crewai enterprise. Ensure that you are using the latest crewai version and please try again. If the problem persists, contact support@crewai.com.",
+                style="red",
+            )
+            raise SystemExit

src/crewai/cli/authentication/token.py

@@ -1,4 +1,4 @@
-from crewai.cli.shared.token_manager import TokenManager
+from .utils import TokenManager
 
 
 class AuthError(Exception):

src/crewai/cli/authentication/utils.py

@@ -1,5 +1,12 @@
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
 import jwt
 from jwt import PyJWKClient
+from cryptography.fernet import Fernet
 
 
 def validate_jwt_token(
@@ -60,3 +67,118 @@ def validate_jwt_token(
         raise Exception(f"JWKS or key processing error: {str(e)}")
     except jwt.InvalidTokenError as e:
         raise Exception(f"Invalid token: {str(e)}")
+
+
+class TokenManager:
+    def __init__(self, file_path: str = "tokens.enc") -> None:
+        """
+        Initialize the TokenManager class.
+
+        :param file_path: The file path to store the encrypted tokens. Default is "tokens.enc".
+        """
+        self.file_path = file_path
+        self.key = self._get_or_create_key()
+        self.fernet = Fernet(self.key)
+
+    def _get_or_create_key(self) -> bytes:
+        """
+        Get or create the encryption key.
+
+        :return: The encryption key.
+        """
+        key_filename = "secret.key"
+        key = self.read_secure_file(key_filename)
+
+        if key is not None:
+            return key
+
+        new_key = Fernet.generate_key()
+        self.save_secure_file(key_filename, new_key)
+        return new_key
+
+    def save_tokens(self, access_token: str, expires_at: int) -> None:
+        """
+        Save the access token and its expiration time.
+
+        :param access_token: The access token to save.
+        :param expires_at: The UNIX timestamp of the expiration time.
+        """
+        expiration_time = datetime.fromtimestamp(expires_at)
+        data = {
+            "access_token": access_token,
+            "expiration": expiration_time.isoformat(),
+        }
+        encrypted_data = self.fernet.encrypt(json.dumps(data).encode())
+        self.save_secure_file(self.file_path, encrypted_data)
+
+    def get_token(self) -> Optional[str]:
+        """
+        Get the access token if it is valid and not expired.
+
+        :return: The access token if valid and not expired, otherwise None.
+        """
+        encrypted_data = self.read_secure_file(self.file_path)
+
+        decrypted_data = self.fernet.decrypt(encrypted_data)  # type: ignore
+        data = json.loads(decrypted_data)
+
+        expiration = datetime.fromisoformat(data["expiration"])
+        if expiration <= datetime.now():
+            return None
+
+        return data["access_token"]
+
+    def get_secure_storage_path(self) -> Path:
+        """
+        Get the secure storage path based on the operating system.
+
+        :return: The secure storage path.
+        """
+        if sys.platform == "win32":
+            # Windows: Use %LOCALAPPDATA%
+            base_path = os.environ.get("LOCALAPPDATA")
+        elif sys.platform == "darwin":
+            # macOS: Use ~/Library/Application Support
+            base_path = os.path.expanduser("~/Library/Application Support")
+        else:
+            # Linux and other Unix-like: Use ~/.local/share
+            base_path = os.path.expanduser("~/.local/share")
+
+        app_name = "crewai/credentials"
+        storage_path = Path(base_path) / app_name
+
+        storage_path.mkdir(parents=True, exist_ok=True)
+
+        return storage_path
+
+    def save_secure_file(self, filename: str, content: bytes) -> None:
+        """
+        Save the content to a secure file.
+
+        :param filename: The name of the file.
+        :param content: The content to save.
+        """
+        storage_path = self.get_secure_storage_path()
+        file_path = storage_path / filename
+
+        with open(file_path, "wb") as f:
+            f.write(content)
+
+        # Set appropriate permissions (read/write for owner only)
+        os.chmod(file_path, 0o600)
+
+    def read_secure_file(self, filename: str) -> Optional[bytes]:
+        """
+        Read the content of a secure file.
+
+        :param filename: The name of the file.
+        :return: The content of the file if it exists, otherwise None.
+        """
+        storage_path = self.get_secure_storage_path()
+        file_path = storage_path / filename
+
+        if not file_path.exists():
+            return None
+
+        with open(file_path, "rb") as f:
+            return f.read()

src/crewai/cli/config.py

@@ -11,7 +11,6 @@ from crewai.cli.constants import (
     CREWAI_ENTERPRISE_DEFAULT_OAUTH2_CLIENT_ID,
     CREWAI_ENTERPRISE_DEFAULT_OAUTH2_DOMAIN,
 )
-from crewai.cli.shared.token_manager import TokenManager
 
 DEFAULT_CONFIG_PATH = Path.home() / ".config" / "crewai" / "settings.json"
 
@@ -54,7 +53,6 @@ HIDDEN_SETTINGS_KEYS = [
     "tool_repository_password",
 ]
 
-
 class Settings(BaseModel):
     enterprise_base_url: Optional[str] = Field(
         default=DEFAULT_CLI_SETTINGS["enterprise_base_url"],
@@ -76,12 +74,12 @@ class Settings(BaseModel):
 
     oauth2_provider: str = Field(
         description="OAuth2 provider used for authentication (e.g., workos, okta, auth0).",
-        default=DEFAULT_CLI_SETTINGS["oauth2_provider"],
+        default=DEFAULT_CLI_SETTINGS["oauth2_provider"]
     )
 
     oauth2_audience: Optional[str] = Field(
         description="OAuth2 audience value, typically used to identify the target API or resource.",
-        default=DEFAULT_CLI_SETTINGS["oauth2_audience"],
+        default=DEFAULT_CLI_SETTINGS["oauth2_audience"]
     )
 
     oauth2_client_id: str = Field(
@@ -91,7 +89,7 @@ class Settings(BaseModel):
 
     oauth2_domain: str = Field(
         description="OAuth2 provider's domain (e.g., your-org.auth0.com) used for issuing tokens.",
-        default=DEFAULT_CLI_SETTINGS["oauth2_domain"],
+        default=DEFAULT_CLI_SETTINGS["oauth2_domain"]
     )
 
     def __init__(self, config_path: Path = DEFAULT_CONFIG_PATH, **data):
@@ -118,7 +116,6 @@ class Settings(BaseModel):
         """Reset all settings to default values"""
         self._reset_user_settings()
         self._reset_cli_settings()
-        self._clear_auth_tokens()
         self.dump()
 
     def dump(self) -> None:
@@ -142,7 +139,3 @@ class Settings(BaseModel):
         """Reset all CLI settings to default values"""
         for key in CLI_SETTINGS_KEYS:
             setattr(self, key, DEFAULT_CLI_SETTINGS.get(key))
-
-    def _clear_auth_tokens(self) -> None:
-        """Clear all authentication tokens"""
-        TokenManager().clear_tokens()

src/crewai/cli/plus_api.py

@@ -117,19 +117,17 @@ class PlusAPI:
     def get_organizations(self) -> requests.Response:
         return self._make_request("GET", self.ORGANIZATIONS_RESOURCE)
 
+    def send_trace_batch(self, payload) -> requests.Response:
+        return self._make_request("POST", self.TRACING_RESOURCE, json=payload)
+
     def initialize_trace_batch(self, payload) -> requests.Response:
         return self._make_request(
-            "POST",
-            f"{self.TRACING_RESOURCE}/batches",
-            json=payload,
-            timeout=30,
+            "POST", f"{self.TRACING_RESOURCE}/batches", json=payload
         )
 
     def initialize_ephemeral_trace_batch(self, payload) -> requests.Response:
         return self._make_request(
-            "POST",
-            f"{self.EPHEMERAL_TRACING_RESOURCE}/batches",
-            json=payload,
+            "POST", f"{self.EPHEMERAL_TRACING_RESOURCE}/batches", json=payload
         )
 
     def send_trace_events(self, trace_batch_id: str, payload) -> requests.Response:
@@ -137,7 +135,6 @@ class PlusAPI:
             "POST",
             f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}/events",
             json=payload,
-            timeout=30,
         )
 
     def send_ephemeral_trace_events(
@@ -147,7 +144,6 @@ class PlusAPI:
             "POST",
             f"{self.EPHEMERAL_TRACING_RESOURCE}/batches/{trace_batch_id}/events",
             json=payload,
-            timeout=30,
         )
 
     def finalize_trace_batch(self, trace_batch_id: str, payload) -> requests.Response:
@@ -155,7 +151,6 @@ class PlusAPI:
             "PATCH",
             f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
             json=payload,
-            timeout=30,
         )
 
     def finalize_ephemeral_trace_batch(
@@ -165,5 +160,4 @@ class PlusAPI:
             "PATCH",
             f"{self.EPHEMERAL_TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
             json=payload,
-            timeout=30,
         )

src/crewai/cli/settings/main.py

@@ -10,9 +10,8 @@ console = Console()
 class SettingsCommand(BaseCommand):
     """A class to handle CLI configuration commands."""
 
-    def __init__(self, settings_kwargs: dict[str, Any] | None = None):
+    def __init__(self, settings_kwargs: dict[str, Any] = {}):
         super().__init__()
-        settings_kwargs = settings_kwargs or {}
         self.settings = Settings(**settings_kwargs)
 
     def list(self) -> None:

src/crewai/cli/shared/token_manager.py

@@ -1,141 +0,0 @@
-import json
-import os
-import sys
-from datetime import datetime
-from pathlib import Path
-from typing import Optional
-from cryptography.fernet import Fernet
-
-
-class TokenManager:
-    def __init__(self, file_path: str = "tokens.enc") -> None:
-        """
-        Initialize the TokenManager class.
-
-        :param file_path: The file path to store the encrypted tokens. Default is "tokens.enc".
-        """
-        self.file_path = file_path
-        self.key = self._get_or_create_key()
-        self.fernet = Fernet(self.key)
-
-    def _get_or_create_key(self) -> bytes:
-        """
-        Get or create the encryption key.
-
-        :return: The encryption key.
-        """
-        key_filename = "secret.key"
-        key = self.read_secure_file(key_filename)
-
-        if key is not None:
-            return key
-
-        new_key = Fernet.generate_key()
-        self.save_secure_file(key_filename, new_key)
-        return new_key
-
-    def save_tokens(self, access_token: str, expires_at: int) -> None:
-        """
-        Save the access token and its expiration time.
-
-        :param access_token: The access token to save.
-        :param expires_at: The UNIX timestamp of the expiration time.
-        """
-        expiration_time = datetime.fromtimestamp(expires_at)
-        data = {
-            "access_token": access_token,
-            "expiration": expiration_time.isoformat(),
-        }
-        encrypted_data = self.fernet.encrypt(json.dumps(data).encode())
-        self.save_secure_file(self.file_path, encrypted_data)
-
-    def get_token(self) -> Optional[str]:
-        """
-        Get the access token if it is valid and not expired.
-
-        :return: The access token if valid and not expired, otherwise None.
-        """
-        encrypted_data = self.read_secure_file(self.file_path)
-        if encrypted_data is None:
-            return None
-
-        decrypted_data = self.fernet.decrypt(encrypted_data)  # type: ignore
-        data = json.loads(decrypted_data)
-
-        expiration = datetime.fromisoformat(data["expiration"])
-        if expiration <= datetime.now():
-            return None
-
-        return data["access_token"]
-
-    def clear_tokens(self) -> None:
-        """
-        Clear the tokens.
-        """
-        self.delete_secure_file(self.file_path)
-
-    def get_secure_storage_path(self) -> Path:
-        """
-        Get the secure storage path based on the operating system.
-
-        :return: The secure storage path.
-        """
-        if sys.platform == "win32":
-            # Windows: Use %LOCALAPPDATA%
-            base_path = os.environ.get("LOCALAPPDATA")
-        elif sys.platform == "darwin":
-            # macOS: Use ~/Library/Application Support
-            base_path = os.path.expanduser("~/Library/Application Support")
-        else:
-            # Linux and other Unix-like: Use ~/.local/share
-            base_path = os.path.expanduser("~/.local/share")
-
-        app_name = "crewai/credentials"
-        storage_path = Path(base_path) / app_name
-
-        storage_path.mkdir(parents=True, exist_ok=True)
-
-        return storage_path
-
-    def save_secure_file(self, filename: str, content: bytes) -> None:
-        """
-        Save the content to a secure file.
-
-        :param filename: The name of the file.
-        :param content: The content to save.
-        """
-        storage_path = self.get_secure_storage_path()
-        file_path = storage_path / filename
-
-        with open(file_path, "wb") as f:
-            f.write(content)
-
-        # Set appropriate permissions (read/write for owner only)
-        os.chmod(file_path, 0o600)
-
-    def read_secure_file(self, filename: str) -> Optional[bytes]:
-        """
-        Read the content of a secure file.
-
-        :param filename: The name of the file.
-        :return: The content of the file if it exists, otherwise None.
-        """
-        storage_path = self.get_secure_storage_path()
-        file_path = storage_path / filename
-
-        if not file_path.exists():
-            return None
-
-        with open(file_path, "rb") as f:
-            return f.read()
-
-    def delete_secure_file(self, filename: str) -> None:
-        """
-        Delete the secure file.
-
-        :param filename: The name of the file.
-        """
-        storage_path = self.get_secure_storage_path()
-        file_path = storage_path / filename
-        if file_path.exists():
-            file_path.unlink(missing_ok=True)

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.14"
 dependencies = [
-    "crewai[tools]>=0.177.0,<1.0.0"
+    "crewai[tools]>=0.165.1,<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.14"
 dependencies = [
-    "crewai[tools]>=0.177.0,<1.0.0",
+    "crewai[tools]>=0.165.1,<1.0.0",
 ]
 
 [project.scripts]

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

@@ -5,7 +5,7 @@ description = "Power up your crews with {{folder_name}}"
 readme = "README.md"
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]>=0.177.0"
+    "crewai[tools]>=0.165.1"
 ]
 
 [tool.crewai]

src/crewai/crew.py

@@ -59,7 +59,7 @@ from crewai.utilities import I18N, FileHandler, Logger, RPMController
 from crewai.utilities.constants import NOT_SPECIFIED, TRAINING_DATA_FILE
 from crewai.utilities.evaluators.crew_evaluator_handler import CrewEvaluator
 from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
-from crewai.events.types.crew_events import (
+from crewai.utilities.events.crew_events import (
     CrewKickoffCompletedEvent,
     CrewKickoffFailedEvent,
     CrewKickoffStartedEvent,
@@ -70,14 +70,14 @@ from crewai.events.types.crew_events import (
     CrewTrainFailedEvent,
     CrewTrainStartedEvent,
 )
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.event_listener import EventListener
-from crewai.events.listeners.tracing.trace_listener import (
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.utilities.events.event_listener import EventListener
+from crewai.utilities.events.listeners.tracing.trace_listener import (
     TraceCollectionListener,
 )
 
 
-from crewai.events.listeners.tracing.utils import (
+from crewai.utilities.events.listeners.tracing.utils import (
     is_tracing_enabled,
 )
 from crewai.utilities.formatter import (
@@ -559,10 +559,9 @@ class Crew(FlowTrackable, BaseModel):
         CrewTrainingHandler(filename).initialize_file()
 
     def train(
-        self, n_iterations: int, filename: str, inputs: Optional[Dict[str, Any]] = None
+        self, n_iterations: int, filename: str, inputs: Optional[Dict[str, Any]] = {}
     ) -> None:
         """Trains the crew for a given number of iterations."""
-        inputs = inputs or {}
         try:
             crewai_event_bus.emit(
                 self,
@@ -703,11 +702,8 @@ class Crew(FlowTrackable, BaseModel):
         self._task_output_handler.reset()
         return results
 
-    async def kickoff_async(
-        self, inputs: Optional[Dict[str, Any]] = None
-    ) -> CrewOutput:
+    async def kickoff_async(self, inputs: Optional[Dict[str, Any]] = {}) -> CrewOutput:
         """Asynchronous kickoff method to start the crew execution."""
-        inputs = inputs or {}
         return await asyncio.to_thread(self.kickoff, inputs)
 
     async def kickoff_for_each_async(self, inputs: List[Dict]) -> List[CrewOutput]:

src/crewai/events/__init__.py

@@ -1,56 +0,0 @@
-"""CrewAI events system for monitoring and extending agent behavior.
-
-This module provides the event infrastructure that allows users to:
-- Monitor agent, task, and crew execution
-- Track memory operations and performance
-- Build custom logging and analytics
-- Extend CrewAI with custom event handlers
-"""
-
-from crewai.events.base_event_listener import BaseEventListener
-from crewai.events.event_bus import crewai_event_bus
-
-from crewai.events.types.memory_events import (
-    MemoryQueryCompletedEvent,
-    MemorySaveCompletedEvent,
-    MemorySaveStartedEvent,
-    MemoryQueryStartedEvent,
-    MemoryRetrievalCompletedEvent,
-    MemorySaveFailedEvent,
-    MemoryQueryFailedEvent,
-)
-
-from crewai.events.types.knowledge_events import (
-    KnowledgeRetrievalStartedEvent,
-    KnowledgeRetrievalCompletedEvent,
-)
-
-from crewai.events.types.crew_events import (
-    CrewKickoffStartedEvent,
-    CrewKickoffCompletedEvent,
-)
-from crewai.events.types.agent_events import (
-    AgentExecutionCompletedEvent,
-)
-
-from crewai.events.types.llm_events import (
-    LLMStreamChunkEvent,
-)
-
-__all__ = [
-    "BaseEventListener",
-    "crewai_event_bus",
-    "MemoryQueryCompletedEvent",
-    "MemorySaveCompletedEvent",
-    "MemorySaveStartedEvent",
-    "MemoryQueryStartedEvent",
-    "MemoryRetrievalCompletedEvent",
-    "MemorySaveFailedEvent",
-    "MemoryQueryFailedEvent",
-    "KnowledgeRetrievalStartedEvent",
-    "KnowledgeRetrievalCompletedEvent",
-    "CrewKickoffStartedEvent",
-    "CrewKickoffCompletedEvent",
-    "AgentExecutionCompletedEvent",
-    "LLMStreamChunkEvent",
-]

src/crewai/events/base_event_listener.py

@@ -1,15 +0,0 @@
-from abc import ABC, abstractmethod
-
-from crewai.events.event_bus import CrewAIEventsBus, crewai_event_bus
-
-
-class BaseEventListener(ABC):
-    verbose: bool = False
-
-    def __init__(self):
-        super().__init__()
-        self.setup_listeners(crewai_event_bus)
-
-    @abstractmethod
-    def setup_listeners(self, crewai_event_bus: CrewAIEventsBus):
-        pass

src/crewai/events/event_bus.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-import threading
-from contextlib import contextmanager
-from typing import Any, Callable, Dict, List, Type, TypeVar, cast
-
-from blinker import Signal
-
-from crewai.events.base_events import BaseEvent
-from crewai.events.event_types import EventTypes
-
-EventT = TypeVar("EventT", bound=BaseEvent)
-
-
-class CrewAIEventsBus:
-    """
-    A singleton event bus that uses blinker signals for event handling.
-    Allows both internal (Flow/Crew) and external event handling.
-    """
-
-    _instance = None
-    _lock = threading.Lock()
-
-    def __new__(cls):
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:  # prevent race condition
-                    cls._instance = super(CrewAIEventsBus, cls).__new__(cls)
-                    cls._instance._initialize()
-        return cls._instance
-
-    def _initialize(self) -> None:
-        """Initialize the event bus internal state"""
-        self._signal = Signal("crewai_event_bus")
-        self._handlers: Dict[Type[BaseEvent], List[Callable]] = {}
-
-    def on(
-        self, event_type: Type[EventT]
-    ) -> Callable[[Callable[[Any, EventT], None]], Callable[[Any, EventT], None]]:
-        """
-        Decorator to register an event handler for a specific event type.
-
-        Usage:
-            @crewai_event_bus.on(AgentExecutionCompletedEvent)
-            def on_agent_execution_completed(
-                source: Any, event: AgentExecutionCompletedEvent
-            ):
-                print(f"👍 Agent '{event.agent}' completed task")
-                print(f"   Output: {event.output}")
-        """
-
-        def decorator(
-            handler: Callable[[Any, EventT], None],
-        ) -> Callable[[Any, EventT], None]:
-            if event_type not in self._handlers:
-                self._handlers[event_type] = []
-            self._handlers[event_type].append(
-                cast(Callable[[Any, EventT], None], handler)
-            )
-            return handler
-
-        return decorator
-
-    def emit(self, source: Any, event: BaseEvent) -> None:
-        """
-        Emit an event to all registered handlers
-
-        Args:
-            source: The object emitting the event
-            event: The event instance to emit
-        """
-        for event_type, handlers in self._handlers.items():
-            if isinstance(event, event_type):
-                for handler in handlers:
-                    try:
-                        handler(source, event)
-                    except Exception as e:
-                        print(
-                            f"[EventBus Error] Handler '{handler.__name__}' failed for event '{event_type.__name__}': {e}"
-                        )
-
-        self._signal.send(source, event=event)
-
-    def register_handler(
-        self, event_type: Type[EventTypes], handler: Callable[[Any, EventTypes], None]
-    ) -> None:
-        """Register an event handler for a specific event type"""
-        if event_type not in self._handlers:
-            self._handlers[event_type] = []
-        self._handlers[event_type].append(
-            cast(Callable[[Any, EventTypes], None], handler)
-        )
-
-    @contextmanager
-    def scoped_handlers(self):
-        """
-        Context manager for temporary event handling scope.
-        Useful for testing or temporary event handling.
-
-        Usage:
-            with crewai_event_bus.scoped_handlers():
-                @crewai_event_bus.on(CrewKickoffStarted)
-                def temp_handler(source, event):
-                    print("Temporary handler")
-                # Do stuff...
-            # Handlers are cleared after the context
-        """
-        previous_handlers = self._handlers.copy()
-        self._handlers.clear()
-        try:
-            yield
-        finally:
-            self._handlers = previous_handlers
-
-
-# Global instance
-crewai_event_bus = CrewAIEventsBus()

src/crewai/events/listeners/__init__.py

@@ -1,5 +0,0 @@
-"""Event listener implementations for CrewAI.
-
-This module contains various event listener implementations
-for handling memory, tracing, and other event-driven functionality.
-"""

src/crewai/events/types/__init__.py

@@ -1,5 +0,0 @@
-"""Event type definitions for CrewAI.
-
-This module contains all event types used throughout the CrewAI system
-for monitoring and extending agent, crew, task, and tool execution.
-"""

src/crewai/events/types/logging_events.py

@@ -1,25 +0,0 @@
-"""Agent logging events that don't reference BaseAgent to avoid circular imports."""
-
-from typing import Any, Optional
-
-from crewai.events.base_events import BaseEvent
-
-
-class AgentLogsStartedEvent(BaseEvent):
-    """Event emitted when agent logs should be shown at start"""
-
-    agent_role: str
-    task_description: Optional[str] = None
-    verbose: bool = False
-    type: str = "agent_logs_started"
-
-
-class AgentLogsExecutionEvent(BaseEvent):
-    """Event emitted when agent logs should be shown during execution"""
-
-    agent_role: str
-    formatted_answer: Any
-    verbose: bool = False
-    type: str = "agent_logs_execution"
-
-    model_config = {"arbitrary_types_allowed": True}

src/crewai/events/types/reasoning_events.py

@@ -1,47 +0,0 @@
-from crewai.events.base_events import BaseEvent
-from typing import Any, Optional
-
-
-class ReasoningEvent(BaseEvent):
-    """Base event for reasoning events."""
-
-    type: str
-    attempt: int = 1
-    agent_role: str
-    task_id: str
-    task_name: Optional[str] = None
-    from_task: Optional[Any] = None
-    agent_id: Optional[str] = None
-    from_agent: Optional[Any] = None
-
-    def __init__(self, **data):
-        super().__init__(**data)
-        self._set_task_params(data)
-        self._set_agent_params(data)
-
-
-class AgentReasoningStartedEvent(ReasoningEvent):
-    """Event emitted when an agent starts reasoning about a task."""
-
-    type: str = "agent_reasoning_started"
-    agent_role: str
-    task_id: str
-
-
-class AgentReasoningCompletedEvent(ReasoningEvent):
-    """Event emitted when an agent finishes its reasoning process."""
-
-    type: str = "agent_reasoning_completed"
-    agent_role: str
-    task_id: str
-    plan: str
-    ready: bool
-
-
-class AgentReasoningFailedEvent(ReasoningEvent):
-    """Event emitted when the reasoning process fails."""
-
-    type: str = "agent_reasoning_failed"
-    agent_role: str
-    task_id: str
-    error: str

src/crewai/experimental/evaluation/agent_evaluator.py

@@ -1,42 +1,28 @@
 import threading
-from typing import Any, Optional
+from typing import Any
 
-from crewai.experimental.evaluation.base_evaluator import (
-    AgentEvaluationResult,
-    AggregationStrategy,
-)
+from crewai.experimental.evaluation.base_evaluator import AgentEvaluationResult, AggregationStrategy
 from crewai.agent import Agent
 from crewai.task import Task
 from crewai.experimental.evaluation.evaluation_display import EvaluationDisplayFormatter
-from crewai.events.types.agent_events import (
-    AgentEvaluationStartedEvent,
-    AgentEvaluationCompletedEvent,
-    AgentEvaluationFailedEvent,
-)
+from crewai.utilities.events.agent_events import AgentEvaluationStartedEvent, AgentEvaluationCompletedEvent, AgentEvaluationFailedEvent
 from crewai.experimental.evaluation import BaseEvaluator, create_evaluation_callbacks
 from collections.abc import Sequence
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.utils.console_formatter import ConsoleFormatter
-from crewai.events.types.task_events import TaskCompletedEvent
-from crewai.events.types.agent_events import LiteAgentExecutionCompletedEvent
-from crewai.experimental.evaluation.base_evaluator import (
-    AgentAggregatedEvaluationResult,
-    EvaluationScore,
-    MetricCategory,
-)
-
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.utilities.events.utils.console_formatter import ConsoleFormatter
+from crewai.utilities.events.task_events import TaskCompletedEvent
+from crewai.utilities.events.agent_events import LiteAgentExecutionCompletedEvent
+from crewai.experimental.evaluation.base_evaluator import AgentAggregatedEvaluationResult, EvaluationScore, MetricCategory
 
 class ExecutionState:
-    current_agent_id: Optional[str] = None
-    current_task_id: Optional[str] = None
-
     def __init__(self):
         self.traces = {}
+        self.current_agent_id: str | None = None
+        self.current_task_id: str | None = None
         self.iteration = 1
         self.iterations_results = {}
         self.agent_evaluators = {}
 
-
 class AgentEvaluator:
     def __init__(
         self,
@@ -59,45 +45,27 @@ class AgentEvaluator:
 
     @property
     def _execution_state(self) -> ExecutionState:
-        if not hasattr(self._thread_local, "execution_state"):
+        if not hasattr(self._thread_local, 'execution_state'):
             self._thread_local.execution_state = ExecutionState()
         return self._thread_local.execution_state
 
     def _subscribe_to_events(self) -> None:
         from typing import cast
-
-        crewai_event_bus.register_handler(
-            TaskCompletedEvent, cast(Any, self._handle_task_completed)
-        )
-        crewai_event_bus.register_handler(
-            LiteAgentExecutionCompletedEvent,
-            cast(Any, self._handle_lite_agent_completed),
-        )
+        crewai_event_bus.register_handler(TaskCompletedEvent, cast(Any, self._handle_task_completed))
+        crewai_event_bus.register_handler(LiteAgentExecutionCompletedEvent, cast(Any, self._handle_lite_agent_completed))
 
     def _handle_task_completed(self, source: Any, event: TaskCompletedEvent) -> None:
         assert event.task is not None
         agent = event.task.agent
-        if (
-            agent
-            and str(getattr(agent, "id", "unknown"))
-            in self._execution_state.agent_evaluators
-        ):
-            self.emit_evaluation_started_event(
-                agent_role=agent.role,
-                agent_id=str(agent.id),
-                task_id=str(event.task.id),
-            )
+        if agent and str(getattr(agent, 'id', 'unknown')) in self._execution_state.agent_evaluators:
+            self.emit_evaluation_started_event(agent_role=agent.role, agent_id=str(agent.id), task_id=str(event.task.id))
 
             state = ExecutionState()
             state.current_agent_id = str(agent.id)
             state.current_task_id = str(event.task.id)
 
-            assert (
-                state.current_agent_id is not None and state.current_task_id is not None
-            )
-            trace = self.callback.get_trace(
-                state.current_agent_id, state.current_task_id
-            )
+            assert state.current_agent_id is not None and state.current_task_id is not None
+            trace = self.callback.get_trace(state.current_agent_id, state.current_task_id)
 
             if not trace:
                 return
@@ -107,28 +75,19 @@ class AgentEvaluator:
                 task=event.task,
                 execution_trace=trace,
                 final_output=event.output,
-                state=state,
+                state=state
             )
 
             current_iteration = self._execution_state.iteration
             if current_iteration not in self._execution_state.iterations_results:
                 self._execution_state.iterations_results[current_iteration] = {}
 
-            if (
-                agent.role
-                not in self._execution_state.iterations_results[current_iteration]
-            ):
-                self._execution_state.iterations_results[current_iteration][
-                    agent.role
-                ] = []
+            if agent.role not in self._execution_state.iterations_results[current_iteration]:
+                self._execution_state.iterations_results[current_iteration][agent.role] = []
 
-            self._execution_state.iterations_results[current_iteration][
-                agent.role
-            ].append(result)
+            self._execution_state.iterations_results[current_iteration][agent.role].append(result)
 
-    def _handle_lite_agent_completed(
-        self, source: object, event: LiteAgentExecutionCompletedEvent
-    ) -> None:
+    def _handle_lite_agent_completed(self, source: object, event: LiteAgentExecutionCompletedEvent) -> None:
         agent_info = event.agent_info
         agent_id = str(agent_info["id"])
 
@@ -146,12 +105,8 @@ class AgentEvaluator:
             if not target_agent:
                 return
 
-            assert (
-                state.current_agent_id is not None and state.current_task_id is not None
-            )
-            trace = self.callback.get_trace(
-                state.current_agent_id, state.current_task_id
-            )
+            assert state.current_agent_id is not None and state.current_task_id is not None
+            trace = self.callback.get_trace(state.current_agent_id, state.current_task_id)
 
             if not trace:
                 return
@@ -160,7 +115,7 @@ class AgentEvaluator:
                 agent=target_agent,
                 execution_trace=trace,
                 final_output=event.output,
-                state=state,
+                state=state
             )
 
             current_iteration = self._execution_state.iteration
@@ -168,17 +123,10 @@ class AgentEvaluator:
                 self._execution_state.iterations_results[current_iteration] = {}
 
             agent_role = target_agent.role
-            if (
-                agent_role
-                not in self._execution_state.iterations_results[current_iteration]
-            ):
-                self._execution_state.iterations_results[current_iteration][
-                    agent_role
-                ] = []
+            if agent_role not in self._execution_state.iterations_results[current_iteration]:
+                self._execution_state.iterations_results[current_iteration][agent_role] = []
 
-            self._execution_state.iterations_results[current_iteration][
-                agent_role
-            ].append(result)
+            self._execution_state.iterations_results[current_iteration][agent_role].append(result)
 
     def set_iteration(self, iteration: int) -> None:
         self._execution_state.iteration = iteration
@@ -187,26 +135,14 @@ class AgentEvaluator:
         self._execution_state.iterations_results = {}
 
     def get_evaluation_results(self) -> dict[str, list[AgentEvaluationResult]]:
-        if (
-            self._execution_state.iterations_results
-            and self._execution_state.iteration
-            in self._execution_state.iterations_results
-        ):
-            return self._execution_state.iterations_results[
-                self._execution_state.iteration
-            ]
+        if self._execution_state.iterations_results and self._execution_state.iteration in self._execution_state.iterations_results:
+            return self._execution_state.iterations_results[self._execution_state.iteration]
         return {}
 
     def display_results_with_iterations(self) -> None:
-        self.display_formatter.display_summary_results(
-            self._execution_state.iterations_results
-        )
+        self.display_formatter.display_summary_results(self._execution_state.iterations_results)
 
-    def get_agent_evaluation(
-        self,
-        strategy: AggregationStrategy = AggregationStrategy.SIMPLE_AVERAGE,
-        include_evaluation_feedback: bool = True,
-    ) -> dict[str, AgentAggregatedEvaluationResult]:
+    def get_agent_evaluation(self, strategy: AggregationStrategy = AggregationStrategy.SIMPLE_AVERAGE, include_evaluation_feedback: bool = True) -> dict[str, AgentAggregatedEvaluationResult]:
         agent_results = {}
         with crewai_event_bus.scoped_handlers():
             task_results = self.get_evaluation_results()
@@ -220,16 +156,13 @@ class AgentEvaluator:
                     agent_id=agent_id,
                     agent_role=agent_role,
                     results=results,
-                    strategy=strategy,
+                    strategy=strategy
                 )
 
                 agent_results[agent_role] = aggregated_result
 
-            if (
-                self._execution_state.iterations_results
-                and self._execution_state.iteration
-                == max(self._execution_state.iterations_results.keys(), default=0)
-            ):
+
+            if self._execution_state.iterations_results and self._execution_state.iteration == max(self._execution_state.iterations_results.keys(), default=0):
                 self.display_results_with_iterations()
 
             if include_evaluation_feedback:
@@ -238,9 +171,7 @@ class AgentEvaluator:
         return agent_results
 
     def display_evaluation_with_feedback(self) -> None:
-        self.display_formatter.display_evaluation_with_feedback(
-            self._execution_state.iterations_results
-        )
+        self.display_formatter.display_evaluation_with_feedback(self._execution_state.iterations_results)
 
     def evaluate(
         self,
@@ -252,91 +183,46 @@ class AgentEvaluator:
     ) -> AgentEvaluationResult:
         result = AgentEvaluationResult(
             agent_id=state.current_agent_id or str(agent.id),
-            task_id=state.current_task_id or (str(task.id) if task else "unknown_task"),
+            task_id=state.current_task_id or (str(task.id) if task else "unknown_task")
         )
 
         assert self.evaluators is not None
         task_id = str(task.id) if task else None
         for evaluator in self.evaluators:
             try:
-                self.emit_evaluation_started_event(
-                    agent_role=agent.role, agent_id=str(agent.id), task_id=task_id
-                )
+                self.emit_evaluation_started_event(agent_role=agent.role, agent_id=str(agent.id), task_id=task_id)
                 score = evaluator.evaluate(
                     agent=agent,
                     task=task,
                     execution_trace=execution_trace,
-                    final_output=final_output,
+                    final_output=final_output
                 )
                 result.metrics[evaluator.metric_category] = score
-                self.emit_evaluation_completed_event(
-                    agent_role=agent.role,
-                    agent_id=str(agent.id),
-                    task_id=task_id,
-                    metric_category=evaluator.metric_category,
-                    score=score,
-                )
+                self.emit_evaluation_completed_event(agent_role=agent.role, agent_id=str(agent.id), task_id=task_id, metric_category=evaluator.metric_category, score=score)
             except Exception as e:
-                self.emit_evaluation_failed_event(
-                    agent_role=agent.role,
-                    agent_id=str(agent.id),
-                    task_id=task_id,
-                    error=str(e),
-                )
-                self.console_formatter.print(
-                    f"Error in {evaluator.metric_category.value} evaluator: {str(e)}"
-                )
+                self.emit_evaluation_failed_event(agent_role=agent.role, agent_id=str(agent.id), task_id=task_id, error=str(e))
+                self.console_formatter.print(f"Error in {evaluator.metric_category.value} evaluator: {str(e)}")
 
         return result
 
-    def emit_evaluation_started_event(
-        self, agent_role: str, agent_id: str, task_id: str | None = None
-    ):
+    def emit_evaluation_started_event(self, agent_role: str, agent_id: str, task_id: str | None = None):
         crewai_event_bus.emit(
             self,
-            AgentEvaluationStartedEvent(
-                agent_role=agent_role,
-                agent_id=agent_id,
-                task_id=task_id,
-                iteration=self._execution_state.iteration,
-            ),
+            AgentEvaluationStartedEvent(agent_role=agent_role, agent_id=agent_id, task_id=task_id, iteration=self._execution_state.iteration)
         )
 
-    def emit_evaluation_completed_event(
-        self,
-        agent_role: str,
-        agent_id: str,
-        task_id: str | None = None,
-        metric_category: MetricCategory | None = None,
-        score: EvaluationScore | None = None,
-    ):
+    def emit_evaluation_completed_event(self, agent_role: str, agent_id: str, task_id: str | None = None, metric_category: MetricCategory | None = None, score: EvaluationScore | None = None):
         crewai_event_bus.emit(
             self,
-            AgentEvaluationCompletedEvent(
-                agent_role=agent_role,
-                agent_id=agent_id,
-                task_id=task_id,
-                iteration=self._execution_state.iteration,
-                metric_category=metric_category,
-                score=score,
-            ),
+            AgentEvaluationCompletedEvent(agent_role=agent_role, agent_id=agent_id, task_id=task_id, iteration=self._execution_state.iteration, metric_category=metric_category, score=score)
         )
 
-    def emit_evaluation_failed_event(
-        self, agent_role: str, agent_id: str, error: str, task_id: str | None = None
-    ):
+    def emit_evaluation_failed_event(self, agent_role: str, agent_id: str, error: str, task_id: str | None = None):
         crewai_event_bus.emit(
             self,
-            AgentEvaluationFailedEvent(
-                agent_role=agent_role,
-                agent_id=agent_id,
-                task_id=task_id,
-                iteration=self._execution_state.iteration,
-                error=error,
-            ),
+            AgentEvaluationFailedEvent(agent_role=agent_role, agent_id=agent_id, task_id=task_id, iteration=self._execution_state.iteration, error=error)
         )
 
-
 def create_default_evaluator(agents: list[Agent], llm: None = None):
     from crewai.experimental.evaluation import (
         GoalAlignmentEvaluator,
@@ -344,7 +230,7 @@ def create_default_evaluator(agents: list[Agent], llm: None = None):
         ToolSelectionEvaluator,
         ParameterExtractionEvaluator,
         ToolInvocationEvaluator,
-        ReasoningEfficiencyEvaluator,
+        ReasoningEfficiencyEvaluator
     )
 
     evaluators = [

src/crewai/experimental/evaluation/evaluation_display.py

@@ -3,28 +3,18 @@ from typing import Dict, Any, List
 from rich.table import Table
 from rich.box import HEAVY_EDGE, ROUNDED
 from collections.abc import Sequence
-from crewai.experimental.evaluation.base_evaluator import (
-    AgentAggregatedEvaluationResult,
-    AggregationStrategy,
-    AgentEvaluationResult,
-    MetricCategory,
-)
+from crewai.experimental.evaluation.base_evaluator import AgentAggregatedEvaluationResult, AggregationStrategy, AgentEvaluationResult, MetricCategory
 from crewai.experimental.evaluation import EvaluationScore
-from crewai.events.utils.console_formatter import ConsoleFormatter
+from crewai.utilities.events.utils.console_formatter import ConsoleFormatter
 from crewai.utilities.llm_utils import create_llm
 
-
 class EvaluationDisplayFormatter:
     def __init__(self):
         self.console_formatter = ConsoleFormatter()
 
-    def display_evaluation_with_feedback(
-        self, iterations_results: Dict[int, Dict[str, List[Any]]]
-    ):
+    def display_evaluation_with_feedback(self, iterations_results: Dict[int, Dict[str, List[Any]]]):
         if not iterations_results:
-            self.console_formatter.print(
-                "[yellow]No evaluation results to display[/yellow]"
-            )
+            self.console_formatter.print("[yellow]No evaluation results to display[/yellow]")
             return
 
         all_agent_roles: set[str] = set()
@@ -32,9 +22,7 @@ class EvaluationDisplayFormatter:
             all_agent_roles.update(iter_results.keys())
 
         for agent_role in sorted(all_agent_roles):
-            self.console_formatter.print(
-                f"\n[bold cyan]Agent: {agent_role}[/bold cyan]"
-            )
+            self.console_formatter.print(f"\n[bold cyan]Agent: {agent_role}[/bold cyan]")
 
             for iter_num, results in sorted(iterations_results.items()):
                 if agent_role not in results or not results[agent_role]:
@@ -74,7 +62,9 @@ class EvaluationDisplayFormatter:
 
                         table.add_section()
                         table.add_row(
-                            metric.title(), score_text, evaluation_score.feedback or ""
+                            metric.title(),
+                            score_text,
+                            evaluation_score.feedback or ""
                         )
 
                 if aggregated_result.overall_score is not None:
@@ -92,26 +82,19 @@ class EvaluationDisplayFormatter:
                     table.add_row(
                         "Overall Score",
                         f"[{overall_color}]{overall_score:.1f}[/]",
-                        "Overall agent evaluation score",
+                        "Overall agent evaluation score"
                     )
 
                 self.console_formatter.print(table)
 
-    def display_summary_results(
-        self,
-        iterations_results: Dict[int, Dict[str, List[AgentAggregatedEvaluationResult]]],
-    ):
+    def display_summary_results(self, iterations_results: Dict[int, Dict[str, List[AgentAggregatedEvaluationResult]]]):
         if not iterations_results:
-            self.console_formatter.print(
-                "[yellow]No evaluation results to display[/yellow]"
-            )
+            self.console_formatter.print("[yellow]No evaluation results to display[/yellow]")
             return
 
         self.console_formatter.print("\n")
 
-        table = Table(
-            title="Agent Performance Scores \n (1-10 Higher is better)", box=HEAVY_EDGE
-        )
+        table = Table(title="Agent Performance Scores \n (1-10 Higher is better)", box=HEAVY_EDGE)
 
         table.add_column("Agent/Metric", style="cyan")
 
@@ -140,14 +123,11 @@ class EvaluationDisplayFormatter:
                     agent_id=agent_id,
                     agent_role=agent_role,
                     results=agent_results,
-                    strategy=AggregationStrategy.SIMPLE_AVERAGE,
+                    strategy=AggregationStrategy.SIMPLE_AVERAGE
                 )
 
-                valid_scores = [
-                    score.score
-                    for score in aggregated_result.metrics.values()
-                    if score.score is not None
-                ]
+                valid_scores = [score.score for score in aggregated_result.metrics.values()
+                               if score.score is not None]
                 if valid_scores:
                     avg_score = sum(valid_scores) / len(valid_scores)
                     agent_scores_by_iteration[iter_num] = avg_score
@@ -157,9 +137,7 @@ class EvaluationDisplayFormatter:
             if not agent_scores_by_iteration:
                 continue
 
-            avg_across_iterations = sum(agent_scores_by_iteration.values()) / len(
-                agent_scores_by_iteration
-            )
+            avg_across_iterations = sum(agent_scores_by_iteration.values()) / len(agent_scores_by_iteration)
 
             row = [f"[bold]{agent_role}[/bold]"]
 
@@ -200,13 +178,9 @@ class EvaluationDisplayFormatter:
                 row = [f"  - {metric.title()}"]
 
                 for iter_num in sorted(iterations_results.keys()):
-                    if (
-                        iter_num in agent_metrics_by_iteration
-                        and metric in agent_metrics_by_iteration[iter_num]
-                    ):
-                        metric_score = agent_metrics_by_iteration[iter_num][
-                            metric
-                        ].score
+                    if (iter_num in agent_metrics_by_iteration and
+                            metric in agent_metrics_by_iteration[iter_num]):
+                        metric_score = agent_metrics_by_iteration[iter_num][metric].score
                         if metric_score is not None:
                             metric_scores.append(metric_score)
                             if metric_score >= 8.0:
@@ -251,9 +225,7 @@ class EvaluationDisplayFormatter:
         results: Sequence[AgentEvaluationResult],
         strategy: AggregationStrategy = AggregationStrategy.SIMPLE_AVERAGE,
     ) -> AgentAggregatedEvaluationResult:
-        metrics_by_category: dict[MetricCategory, list[EvaluationScore]] = defaultdict(
-            list
-        )
+        metrics_by_category: dict[MetricCategory, list[EvaluationScore]] = defaultdict(list)
 
         for result in results:
             for metric_name, evaluation_score in result.metrics.items():
@@ -274,20 +246,19 @@ class EvaluationDisplayFormatter:
                         metric=category.title(),
                         feedbacks=feedbacks,
                         scores=[s.score for s in scores],
-                        strategy=strategy,
+                        strategy=strategy
                     )
                 else:
                     feedback_summary = feedbacks[0]
 
             aggregated_metrics[category] = EvaluationScore(
-                score=avg_score, feedback=feedback_summary
+                score=avg_score,
+                feedback=feedback_summary
             )
 
         overall_score = None
         if aggregated_metrics:
-            valid_scores = [
-                m.score for m in aggregated_metrics.values() if m.score is not None
-            ]
+            valid_scores = [m.score for m in aggregated_metrics.values() if m.score is not None]
             if valid_scores:
                 overall_score = sum(valid_scores) / len(valid_scores)
 
@@ -297,7 +268,7 @@ class EvaluationDisplayFormatter:
             metrics=aggregated_metrics,
             overall_score=overall_score,
             task_count=len(results),
-            aggregation_strategy=strategy,
+            aggregation_strategy=strategy
         )
 
     def _summarize_feedbacks(
@@ -306,12 +277,10 @@ class EvaluationDisplayFormatter:
         metric: str,
         feedbacks: List[str],
         scores: List[float | None],
-        strategy: AggregationStrategy,
+        strategy: AggregationStrategy
     ) -> str:
         if len(feedbacks) <= 2 and all(len(fb) < 200 for fb in feedbacks):
-            return "\n\n".join(
-                [f"Feedback {i+1}: {fb}" for i, fb in enumerate(feedbacks)]
-            )
+            return "\n\n".join([f"Feedback {i+1}: {fb}" for i, fb in enumerate(feedbacks)])
 
         try:
             llm = create_llm()
@@ -321,26 +290,20 @@ class EvaluationDisplayFormatter:
                 if len(feedback) > 500:
                     feedback = feedback[:500] + "..."
                 score_text = f"{score:.1f}" if score is not None else "N/A"
-                formatted_feedbacks.append(
-                    f"Feedback #{i+1} (Score: {score_text}):\n{feedback}"
-                )
+                formatted_feedbacks.append(f"Feedback #{i+1} (Score: {score_text}):\n{feedback}")
 
             all_feedbacks = "\n\n" + "\n\n---\n\n".join(formatted_feedbacks)
 
             strategy_guidance = ""
             if strategy == AggregationStrategy.BEST_PERFORMANCE:
-                strategy_guidance = (
-                    "Focus on the highest-scoring aspects and strengths demonstrated."
-                )
+                strategy_guidance = "Focus on the highest-scoring aspects and strengths demonstrated."
             elif strategy == AggregationStrategy.WORST_PERFORMANCE:
                 strategy_guidance = "Focus on areas that need improvement and common issues across tasks."
             else:
                 strategy_guidance = "Provide a balanced analysis of strengths and weaknesses across all tasks."
 
             prompt = [
-                {
-                    "role": "system",
-                    "content": f"""You are an expert evaluator creating a comprehensive summary of agent performance feedback.
+                {"role": "system", "content": f"""You are an expert evaluator creating a comprehensive summary of agent performance feedback.
                 Your job is to synthesize multiple feedback points about the same metric across different tasks.
 
                 Create a concise, insightful summary that captures the key patterns and themes from all feedback.
@@ -352,18 +315,14 @@ class EvaluationDisplayFormatter:
                 3. Highlighting patterns across tasks
                 4. 150-250 words in length
 
-                The summary should be directly usable as final feedback for the agent's performance on this metric.""",
-                },
-                {
-                    "role": "user",
-                    "content": f"""I need a synthesized summary of the following feedback for:
+                The summary should be directly usable as final feedback for the agent's performance on this metric."""},
+                {"role": "user", "content": f"""I need a synthesized summary of the following feedback for:
 
                 Agent Role: {agent_role}
                 Metric: {metric.title()}
 
                 {all_feedbacks}
-                """,
-                },
+                """}
             ]
             assert llm is not None
             response = llm.call(prompt)
@@ -371,6 +330,4 @@ class EvaluationDisplayFormatter:
             return response
 
         except Exception:
-            return "Synthesized from multiple tasks: " + "\n\n".join(
-                [f"- {fb[:500]}..." for fb in feedbacks]
-            )
+            return "Synthesized from multiple tasks: " + "\n\n".join([f"- {fb[:500]}..." for fb in feedbacks])

src/crewai/experimental/evaluation/evaluation_listener.py

@@ -5,23 +5,25 @@ from collections.abc import Sequence
 
 from crewai.agent import Agent
 from crewai.task import Task
-from crewai.events.base_event_listener import BaseEventListener
-from crewai.events.event_bus import CrewAIEventsBus
-from crewai.events.types.agent_events import (
+from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.utilities.events.crewai_event_bus import CrewAIEventsBus
+from crewai.utilities.events.agent_events import (
     AgentExecutionStartedEvent,
     AgentExecutionCompletedEvent,
     LiteAgentExecutionStartedEvent,
-    LiteAgentExecutionCompletedEvent,
+    LiteAgentExecutionCompletedEvent
 )
-from crewai.events.types.tool_usage_events import (
+from crewai.utilities.events.tool_usage_events import (
     ToolUsageFinishedEvent,
     ToolUsageErrorEvent,
     ToolExecutionErrorEvent,
     ToolSelectionErrorEvent,
-    ToolValidateInputErrorEvent,
+    ToolValidateInputErrorEvent
+)
+from crewai.utilities.events.llm_events import (
+    LLMCallStartedEvent,
+    LLMCallCompletedEvent
 )
-from crewai.events.types.llm_events import LLMCallStartedEvent, LLMCallCompletedEvent
-
 
 class EvaluationTraceCallback(BaseEventListener):
     """Event listener for collecting execution traces for evaluation.
@@ -66,49 +68,27 @@ class EvaluationTraceCallback(BaseEventListener):
 
         @event_bus.on(ToolUsageFinishedEvent)
         def on_tool_completed(source, event: ToolUsageFinishedEvent):
-            self.on_tool_use(
-                event.tool_name, event.tool_args, event.output, success=True
-            )
+            self.on_tool_use(event.tool_name, event.tool_args, event.output, success=True)
 
         @event_bus.on(ToolUsageErrorEvent)
         def on_tool_usage_error(source, event: ToolUsageErrorEvent):
-            self.on_tool_use(
-                event.tool_name,
-                event.tool_args,
-                event.error,
-                success=False,
-                error_type="usage_error",
-            )
+            self.on_tool_use(event.tool_name, event.tool_args, event.error,
+                           success=False, error_type="usage_error")
 
         @event_bus.on(ToolExecutionErrorEvent)
         def on_tool_execution_error(source, event: ToolExecutionErrorEvent):
-            self.on_tool_use(
-                event.tool_name,
-                event.tool_args,
-                event.error,
-                success=False,
-                error_type="execution_error",
-            )
+            self.on_tool_use(event.tool_name, event.tool_args, event.error,
+                           success=False, error_type="execution_error")
 
         @event_bus.on(ToolSelectionErrorEvent)
         def on_tool_selection_error(source, event: ToolSelectionErrorEvent):
-            self.on_tool_use(
-                event.tool_name,
-                event.tool_args,
-                event.error,
-                success=False,
-                error_type="selection_error",
-            )
+            self.on_tool_use(event.tool_name, event.tool_args, event.error,
+                           success=False, error_type="selection_error")
 
         @event_bus.on(ToolValidateInputErrorEvent)
         def on_tool_validate_input_error(source, event: ToolValidateInputErrorEvent):
-            self.on_tool_use(
-                event.tool_name,
-                event.tool_args,
-                event.error,
-                success=False,
-                error_type="validation_error",
-            )
+            self.on_tool_use(event.tool_name, event.tool_args, event.error,
+                           success=False, error_type="validation_error")
 
         @event_bus.on(LLMCallStartedEvent)
         def on_llm_call_started(source, event: LLMCallStartedEvent):
@@ -119,7 +99,7 @@ class EvaluationTraceCallback(BaseEventListener):
             self.on_llm_call_end(event.messages, event.response)
 
     def on_lite_agent_start(self, agent_info: dict[str, Any]):
-        self.current_agent_id = agent_info["id"]
+        self.current_agent_id = agent_info['id']
         self.current_task_id = "lite_task"
 
         trace_key = f"{self.current_agent_id}_{self.current_task_id}"
@@ -130,7 +110,7 @@ class EvaluationTraceCallback(BaseEventListener):
             tool_uses=[],
             llm_calls=[],
             start_time=datetime.now(),
-            final_output=None,
+            final_output=None
         )
 
     def _init_trace(self, trace_key: str, **kwargs: Any):
@@ -148,7 +128,7 @@ class EvaluationTraceCallback(BaseEventListener):
             tool_uses=[],
             llm_calls=[],
             start_time=datetime.now(),
-            final_output=None,
+            final_output=None
         )
 
     def on_agent_finish(self, agent: Agent, task: Task, output: Any):
@@ -171,14 +151,8 @@ class EvaluationTraceCallback(BaseEventListener):
 
         self._reset_current()
 
-    def on_tool_use(
-        self,
-        tool_name: str,
-        tool_args: dict[str, Any] | str,
-        result: Any,
-        success: bool = True,
-        error_type: str | None = None,
-    ):
+    def on_tool_use(self, tool_name: str, tool_args: dict[str, Any] | str, result: Any,
+                   success: bool = True, error_type: str | None = None):
         if not self.current_agent_id or not self.current_task_id:
             return
 
@@ -189,7 +163,7 @@ class EvaluationTraceCallback(BaseEventListener):
                 "args": tool_args,
                 "result": result,
                 "success": success,
-                "timestamp": datetime.now(),
+                "timestamp": datetime.now()
             }
 
             # Add error information if applicable
@@ -199,11 +173,7 @@ class EvaluationTraceCallback(BaseEventListener):
 
             self.traces[trace_key]["tool_uses"].append(tool_use)
 
-    def on_llm_call_start(
-        self,
-        messages: str | Sequence[dict[str, Any]] | None,
-        tools: Sequence[dict[str, Any]] | None = None,
-    ):
+    def on_llm_call_start(self, messages: str | Sequence[dict[str, Any]] | None, tools: Sequence[dict[str, Any]] | None = None):
         if not self.current_agent_id or not self.current_task_id:
             return
 
@@ -216,12 +186,10 @@ class EvaluationTraceCallback(BaseEventListener):
             "tools": tools,
             "start_time": datetime.now(),
             "response": None,
-            "end_time": None,
+            "end_time": None
         }
 
-    def on_llm_call_end(
-        self, messages: str | list[dict[str, Any]] | None, response: Any
-    ):
+    def on_llm_call_end(self, messages: str | list[dict[str, Any]] | None, response: Any):
         if not self.current_agent_id or not self.current_task_id:
             return
 
@@ -245,7 +213,7 @@ class EvaluationTraceCallback(BaseEventListener):
             "response": response,
             "start_time": start_time,
             "end_time": current_time,
-            "total_tokens": total_tokens,
+            "total_tokens": total_tokens
         }
 
         self.traces[trace_key]["llm_calls"].append(llm_call)
@@ -259,7 +227,7 @@ class EvaluationTraceCallback(BaseEventListener):
 
 
 def create_evaluation_callbacks() -> EvaluationTraceCallback:
-    from crewai.events.event_bus import crewai_event_bus
+    from crewai.utilities.events.crewai_event_bus import crewai_event_bus
 
     callback = EvaluationTraceCallback()
     callback.setup_listeners(crewai_event_bus)

src/crewai/flow/flow.py

@@ -25,8 +25,8 @@ from crewai.flow.flow_visualizer import plot_flow
 from crewai.flow.persistence.base import FlowPersistence
 from crewai.flow.types import FlowExecutionData
 from crewai.flow.utils import get_possible_return_constants
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.flow_events import (
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.utilities.events.flow_events import (
     FlowCreatedEvent,
     FlowFinishedEvent,
     FlowPlotEvent,
@@ -35,10 +35,10 @@ from crewai.events.types.flow_events import (
     MethodExecutionFinishedEvent,
     MethodExecutionStartedEvent,
 )
-from crewai.events.listeners.tracing.trace_listener import (
+from crewai.utilities.events.listeners.tracing.trace_listener import (
     TraceCollectionListener,
 )
-from crewai.events.listeners.tracing.utils import (
+from crewai.utilities.events.listeners.tracing.utils import (
     is_tracing_enabled,
 )
 from crewai.utilities.printer import Printer
@@ -474,7 +474,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
         self._method_outputs: List[Any] = []  # List to store all method outputs
         self._completed_methods: Set[str] = set()  # Track completed methods for reload
         self._persistence: Optional[FlowPersistence] = persistence
-        self._is_execution_resuming: bool = False
 
         # Initialize state with initial values
         self._state = self._create_initial_state()
@@ -830,9 +829,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
                 # Clear completed methods and outputs for a fresh start
                 self._completed_methods.clear()
                 self._method_outputs.clear()
-            else:
-                # We're restoring from persistence, set the flag
-                self._is_execution_resuming = True
 
             if inputs:
                 # Override the id in the state if it exists in inputs
@@ -884,9 +880,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
             ]
             await asyncio.gather(*tasks)
 
-            # Clear the resumption flag after initial execution completes
-            self._is_execution_resuming = False
-
             final_output = self._method_outputs[-1] if self._method_outputs else None
 
             crewai_event_bus.emit(
@@ -923,23 +916,19 @@ class Flow(Generic[T], metaclass=FlowMeta):
         - Automatically injects crewai_trigger_payload if available in flow inputs
         """
         if start_method_name in self._completed_methods:
-            if self._is_execution_resuming:
-                # During resumption, skip execution but continue listeners
-                last_output = self._method_outputs[-1] if self._method_outputs else None
-                await self._execute_listeners(start_method_name, last_output)
-                return
-            # For cyclic flows, clear from completed to allow re-execution
-            self._completed_methods.discard(start_method_name)
+            last_output = self._method_outputs[-1] if self._method_outputs else None
+            await self._execute_listeners(start_method_name, last_output)
+            return
 
         method = self._methods[start_method_name]
         enhanced_method = self._inject_trigger_payload_for_start_method(method)
 
-        result = await self._execute_method(start_method_name, enhanced_method)
+        result = await self._execute_method(
+            start_method_name, enhanced_method
+        )
         await self._execute_listeners(start_method_name, result)
 
-    def _inject_trigger_payload_for_start_method(
-        self, original_method: Callable
-    ) -> Callable:
+    def _inject_trigger_payload_for_start_method(self, original_method: Callable) -> Callable:
         def prepare_kwargs(*args, **kwargs):
             inputs = baggage.get_baggage("flow_inputs") or {}
             trigger_payload = inputs.get("crewai_trigger_payload")
@@ -952,17 +941,15 @@ class Flow(Generic[T], metaclass=FlowMeta):
             elif trigger_payload is not None:
                 self._log_flow_event(
                     f"Trigger payload available but {original_method.__name__} doesn't accept crewai_trigger_payload parameter",
-                    color="yellow",
+                    color="yellow"
                 )
             return args, kwargs
 
         if asyncio.iscoroutinefunction(original_method):
-
             async def enhanced_method(*args, **kwargs):
                 args, kwargs = prepare_kwargs(*args, **kwargs)
                 return await original_method(*args, **kwargs)
         else:
-
             def enhanced_method(*args, **kwargs):
                 args, kwargs = prepare_kwargs(*args, **kwargs)
                 return original_method(*args, **kwargs)
@@ -1063,15 +1050,11 @@ class Flow(Generic[T], metaclass=FlowMeta):
             for router_name in routers_triggered:
                 await self._execute_single_listener(router_name, result)
                 # After executing router, the router's result is the path
-                router_result = (
-                    self._method_outputs[-1] if self._method_outputs else None
-                )
+                router_result = self._method_outputs[-1]
                 if router_result:  # Only add non-None results
                     router_results.append(router_result)
                 current_trigger = (
-                    str(router_result)
-                    if router_result is not None
-                    else ""  # Update for next iteration of router chain
+                    router_result  # Update for next iteration of router chain
                 )
 
         # Now execute normal listeners for all router results and the original trigger
@@ -1089,24 +1072,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
                     ]
                     await asyncio.gather(*tasks)
 
-                if current_trigger in router_results:
-                    # Find start methods triggered by this router result
-                    for method_name in self._start_methods:
-                        # Check if this start method is triggered by the current trigger
-                        if method_name in self._listeners:
-                            condition_type, trigger_methods = self._listeners[
-                                method_name
-                            ]
-                            if current_trigger in trigger_methods:
-                                # Only execute if this is a cycle (method was already completed)
-                                if method_name in self._completed_methods:
-                                    # For router-triggered start methods in cycles, temporarily clear resumption flag
-                                    # to allow cyclic execution
-                                    was_resuming = self._is_execution_resuming
-                                    self._is_execution_resuming = False
-                                    await self._execute_start_method(method_name)
-                                    self._is_execution_resuming = was_resuming
-
     def _find_triggered_methods(
         self, trigger_method: str, router_only: bool
     ) -> List[str]:
@@ -1144,9 +1109,6 @@ class Flow(Generic[T], metaclass=FlowMeta):
             if router_only != is_router:
                 continue
 
-            if not router_only and listener_name in self._start_methods:
-                continue
-
             if condition_type == "OR":
                 # If the trigger_method matches any in methods, run this
                 if trigger_method in methods:
@@ -1196,13 +1158,10 @@ class Flow(Generic[T], metaclass=FlowMeta):
         Catches and logs any exceptions during execution, preventing
         individual listener failures from breaking the entire flow.
         """
-        if listener_name in self._completed_methods:
-            if self._is_execution_resuming:
-                # During resumption, skip execution but continue listeners
-                await self._execute_listeners(listener_name, None)
-                return
-            # For cyclic flows, clear from completed to allow re-execution
-            self._completed_methods.discard(listener_name)
+        # TODO: greyson fix
+        # if listener_name in self._completed_methods:
+        #     await self._execute_listeners(listener_name, None)
+        #     return
 
         try:
             method = self._methods[listener_name]

src/crewai/knowledge/storage/knowledge_storage.py

@@ -1,4 +1,6 @@
+import contextlib
 import hashlib
+import io
 import logging
 import os
 import shutil
@@ -18,7 +20,23 @@ from crewai.utilities.constants import KNOWLEDGE_DIRECTORY
 from crewai.utilities.logger import Logger
 from crewai.utilities.paths import db_storage_path
 from crewai.utilities.chromadb import create_persistent_client
-from crewai.utilities.logger_utils import suppress_logging
+
+
+@contextlib.contextmanager
+def suppress_logging(
+    logger_name="chromadb.segment.impl.vector.local_persistent_hnsw",
+    level=logging.ERROR,
+):
+    logger = logging.getLogger(logger_name)
+    original_level = logger.getEffectiveLevel()
+    logger.setLevel(level)
+    with (
+        contextlib.redirect_stdout(io.StringIO()),
+        contextlib.redirect_stderr(io.StringIO()),
+        contextlib.suppress(UserWarning),
+    ):
+        yield
+    logger.setLevel(original_level)
 
 
 class KnowledgeStorage(BaseKnowledgeStorage):
@@ -46,9 +64,7 @@ class KnowledgeStorage(BaseKnowledgeStorage):
         filter: Optional[dict] = None,
         score_threshold: float = 0.35,
     ) -> List[Dict[str, Any]]:
-        with suppress_logging(
-            "chromadb.segment.impl.vector.local_persistent_hnsw", logging.ERROR
-        ):
+        with suppress_logging():
             if self.collection:
                 fetched = self.collection.query(
                     query_texts=query,

src/crewai/lite_agent.py

@@ -62,14 +62,19 @@ from crewai.utilities.agent_utils import (
     render_text_description_and_args,
 )
 from crewai.utilities.converter import generate_model_description
-from crewai.events.types.logging_events import AgentLogsExecutionEvent
-from crewai.events.types.agent_events import (
+from crewai.utilities.events.agent_events import (
+    AgentLogsExecutionEvent,
     LiteAgentExecutionCompletedEvent,
     LiteAgentExecutionErrorEvent,
     LiteAgentExecutionStartedEvent,
 )
-from crewai.events.event_bus import crewai_event_bus
-
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.utilities.events.llm_events import (
+    LLMCallCompletedEvent,
+    LLMCallFailedEvent,
+    LLMCallStartedEvent,
+    LLMCallType,
+)
 from crewai.utilities.llm_utils import create_llm
 from crewai.utilities.printer import Printer
 from crewai.utilities.token_counter_callback import TokenCalcHandler
@@ -514,6 +519,19 @@ class LiteAgent(FlowTrackable, BaseModel):
 
                 enforce_rpm_limit(self.request_within_rpm_limit)
 
+                llm = cast(LLM, self.llm)
+                model = llm.model if hasattr(llm, "model") else "unknown"
+                crewai_event_bus.emit(
+                    self,
+                    event=LLMCallStartedEvent(
+                        messages=self._messages,
+                        tools=None,
+                        callbacks=self._callbacks,
+                        from_agent=self,
+                        model=model,
+                    ),
+                )
+
                 try:
                     answer = get_llm_response(
                         llm=cast(LLM, self.llm),
@@ -523,7 +541,23 @@ class LiteAgent(FlowTrackable, BaseModel):
                         from_agent=self,
                     )
 
+                    # Emit LLM call completed event
+                    crewai_event_bus.emit(
+                        self,
+                        event=LLMCallCompletedEvent(
+                            messages=self._messages,
+                            response=answer,
+                            call_type=LLMCallType.LLM_CALL,
+                            from_agent=self,
+                            model=model,
+                        ),
+                    )
                 except Exception as e:
+                    # Emit LLM call failed event
+                    crewai_event_bus.emit(
+                        self,
+                        event=LLMCallFailedEvent(error=str(e), from_agent=self),
+                    )
                     raise e
 
                 formatted_answer = process_llm_response(answer, self.use_stop_words)

src/crewai/llm.py

@@ -23,14 +23,14 @@ from dotenv import load_dotenv
 from litellm.types.utils import ChatCompletionDeltaToolCall
 from pydantic import BaseModel, Field
 
-from crewai.events.types.llm_events import (
+from crewai.utilities.events.llm_events import (
     LLMCallCompletedEvent,
     LLMCallFailedEvent,
     LLMCallStartedEvent,
     LLMCallType,
     LLMStreamChunkEvent,
 )
-from crewai.events.types.tool_usage_events import (
+from crewai.utilities.events.tool_usage_events import (
     ToolUsageStartedEvent,
     ToolUsageFinishedEvent,
     ToolUsageErrorEvent,
@@ -52,7 +52,7 @@ import io
 from typing import TextIO
 
 from crewai.llms.base_llm import BaseLLM
-from crewai.events.event_bus import crewai_event_bus
+from crewai.utilities.events import crewai_event_bus
 from crewai.utilities.exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededException,
 )
@@ -311,7 +311,7 @@ class LLM(BaseLLM):
         api_base: Optional[str] = None,
         api_version: Optional[str] = None,
         api_key: Optional[str] = None,
-        callbacks: List[Any] | None = None,
+        callbacks: List[Any] = [],
         reasoning_effort: Optional[Literal["none", "low", "medium", "high"]] = None,
         stream: bool = False,
         **kwargs,
@@ -351,7 +351,7 @@ class LLM(BaseLLM):
         else:
             self.stop = stop
 
-        self.set_callbacks(callbacks or [])
+        self.set_callbacks(callbacks)
         self.set_env_callbacks()
 
     def _is_anthropic_model(self, model: str) -> bool:
@@ -851,9 +851,7 @@ class LLM(BaseLLM):
             return tool_calls
 
         # --- 7) Handle tool calls if present
-        tool_result = self._handle_tool_call(
-            tool_calls, available_functions, from_task, from_agent
-        )
+        tool_result = self._handle_tool_call(tool_calls, available_functions)
         if tool_result is not None:
             return tool_result
         # --- 8) If tool call handling didn't return a result, emit completion event and return text response
@@ -870,8 +868,6 @@ class LLM(BaseLLM):
         self,
         tool_calls: List[Any],
         available_functions: Optional[Dict[str, Any]] = None,
-        from_task: Optional[Any] = None,
-        from_agent: Optional[Any] = None,
     ) -> Optional[str]:
         """Handle a tool call from the LLM.
 
@@ -906,8 +902,6 @@ class LLM(BaseLLM):
                     event=ToolUsageStartedEvent(
                         tool_name=function_name,
                         tool_args=function_args,
-                        from_agent=from_agent,
-                        from_task=from_task,
                     ),
                 )
 
@@ -920,17 +914,12 @@ class LLM(BaseLLM):
                         tool_args=function_args,
                         started_at=started_at,
                         finished_at=datetime.now(),
-                        from_task=from_task,
-                        from_agent=from_agent,
                     ),
                 )
 
                 # --- 3.3) Emit success event
                 self._handle_emit_call_events(
-                    response=result,
-                    call_type=LLMCallType.TOOL_CALL,
-                    from_task=from_task,
-                    from_agent=from_agent,
+                    response=result, call_type=LLMCallType.TOOL_CALL
                 )
                 return result
             except Exception as e:
@@ -950,8 +939,6 @@ class LLM(BaseLLM):
                         tool_name=function_name,
                         tool_args=function_args,
                         error=f"Tool execution error: {str(e)}",
-                        from_task=from_task,
-                        from_agent=from_agent,
                     ),
                 )
         return None
@@ -1152,11 +1139,7 @@ class LLM(BaseLLM):
 
         # TODO: Remove this code after merging PR https://github.com/BerriAI/litellm/pull/10917
         # Ollama doesn't supports last message to be 'assistant'
-        if (
-            "ollama" in self.model.lower()
-            and messages
-            and messages[-1]["role"] == "assistant"
-        ):
+        if "ollama" in self.model.lower() and messages and messages[-1]["role"] == "assistant":
             return messages + [{"role": "user", "content": ""}]
 
         # Handle Anthropic models

src/crewai/memory/contextual/contextual_memory.py

@@ -1,4 +1,4 @@
-from typing import Optional, TYPE_CHECKING
+from typing import Optional
 
 from crewai.memory import (
     EntityMemory,
@@ -7,10 +7,6 @@ from crewai.memory import (
     ShortTermMemory,
 )
 
-if TYPE_CHECKING:
-    from crewai.agent import Agent
-    from crewai.task import Task
-
 
 class ContextualMemory:
     def __init__(
@@ -19,28 +15,11 @@ class ContextualMemory:
         ltm: LongTermMemory,
         em: EntityMemory,
         exm: ExternalMemory,
-        agent: Optional["Agent"] = None,
-        task: Optional["Task"] = None,
     ):
         self.stm = stm
         self.ltm = ltm
         self.em = em
         self.exm = exm
-        self.agent = agent
-        self.task = task
-
-        if self.stm is not None:
-            self.stm.agent = self.agent
-            self.stm.task = self.task
-        if self.ltm is not None:
-            self.ltm.agent = self.agent
-            self.ltm.task = self.task
-        if self.em is not None:
-            self.em.agent = self.agent
-            self.em.task = self.task
-        if self.exm is not None:
-            self.exm.agent = self.agent
-            self.exm.task = self.task
 
     def build_context_for_task(self, task, context) -> str:
         """
@@ -70,7 +49,10 @@ class ContextualMemory:
 
         stm_results = self.stm.search(query)
         formatted_results = "\n".join(
-            [f"- {result['context']}" for result in stm_results]
+            [
+                f"- {result['context']}"
+                for result in stm_results
+            ]
         )
         return f"Recent Insights:\n{formatted_results}" if stm_results else ""
 
@@ -107,7 +89,10 @@ class ContextualMemory:
 
         em_results = self.em.search(query)
         formatted_results = "\n".join(
-            [f"- {result['context']}" for result in em_results]  # type: ignore #  Invalid index type "str" for "str"; expected type "SupportsIndex | slice"
+            [
+                f"- {result['context']}"
+                for result in em_results
+            ]  # type: ignore #  Invalid index type "str" for "str"; expected type "SupportsIndex | slice"
         )
         return f"Entities:\n{formatted_results}" if em_results else ""
 

src/crewai/memory/entity/entity_memory.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Optional
 import time
 
 from pydantic import PrivateAttr
@@ -6,8 +6,8 @@ from pydantic import PrivateAttr
 from crewai.memory.entity.entity_memory_item import EntityMemoryItem
 from crewai.memory.memory import Memory
 from crewai.memory.storage.rag_storage import RAGStorage
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.memory_events import (
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.utilities.events.memory_events import (
     MemoryQueryStartedEvent,
     MemoryQueryCompletedEvent,
     MemoryQueryFailedEvent,
@@ -24,7 +24,7 @@ class EntityMemory(Memory):
     Inherits from the Memory class.
     """
 
-    _memory_provider: str | None = PrivateAttr()
+    _memory_provider: Optional[str] = PrivateAttr()
 
     def __init__(self, crew=None, embedder_config=None, storage=None, path=None):
         memory_provider = embedder_config.get("provider") if embedder_config else None
@@ -35,7 +35,7 @@ class EntityMemory(Memory):
                 raise ImportError(
                     "Mem0 is not installed. Please install it with `pip install mem0ai`."
                 )
-            config = embedder_config.get("config") if embedder_config else None
+            config = embedder_config.get("config")
             storage = Mem0Storage(type="short_term", crew=crew, config=config)
         else:
             storage = (
@@ -53,99 +53,47 @@ class EntityMemory(Memory):
         super().__init__(storage=storage)
         self._memory_provider = memory_provider
 
-    def save(
-        self,
-        value: EntityMemoryItem | list[EntityMemoryItem],
-        metadata: dict[str, Any] | None = None,
-    ) -> None:
-        """Saves one or more entity items into the SQLite storage.
-
-        Args:
-            value: Single EntityMemoryItem or list of EntityMemoryItems to save.
-            metadata: Optional metadata dict (included for supertype compatibility but not used).
-
-        Notes:
-            The metadata parameter is included to satisfy the supertype signature but is not
-            used - entity metadata is extracted from the EntityMemoryItem objects themselves.
-        """
-
-        if not value:
-            return
-
-        items = value if isinstance(value, list) else [value]
-        is_batch = len(items) > 1
-
-        metadata = {"entity_count": len(items)} if is_batch else items[0].metadata
+    def save(self, item: EntityMemoryItem) -> None:  # type: ignore # BUG?: Signature of "save" incompatible with supertype "Memory"
+        """Saves an entity item into the SQLite storage."""
         crewai_event_bus.emit(
             self,
             event=MemorySaveStartedEvent(
-                metadata=metadata,
+                metadata=item.metadata,
                 source_type="entity_memory",
-                from_agent=self.agent,
-                from_task=self.task,
             ),
         )
 
         start_time = time.time()
-        saved_count = 0
-        errors = []
-
         try:
-            for item in items:
-                try:
-                    if self._memory_provider == "mem0":
-                        data = f"""
-                        Remember details about the following entity:
-                        Name: {item.name}
-                        Type: {item.type}
-                        Entity Description: {item.description}
-                        """
-                    else:
-                        data = f"{item.name}({item.type}): {item.description}"
-
-                    super().save(data, item.metadata)
-                    saved_count += 1
-                except Exception as e:
-                    errors.append(f"{item.name}: {str(e)}")
-
-            if is_batch:
-                emit_value = f"Saved {saved_count} entities"
-                metadata = {"entity_count": saved_count, "errors": errors}
+            if self._memory_provider == "mem0":
+                data = f"""
+                Remember details about the following entity:
+                Name: {item.name}
+                Type: {item.type}
+                Entity Description: {item.description}
+                """
             else:
-                emit_value = f"{items[0].name}({items[0].type}): {items[0].description}"
-                metadata = items[0].metadata
+                data = f"{item.name}({item.type}): {item.description}"
 
+            super().save(data, item.metadata)
+
+            # Emit memory save completed event
             crewai_event_bus.emit(
                 self,
                 event=MemorySaveCompletedEvent(
-                    value=emit_value,
-                    metadata=metadata,
+                    value=data,
+                    metadata=item.metadata,
                     save_time_ms=(time.time() - start_time) * 1000,
                     source_type="entity_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
-
-            if errors:
-                raise Exception(
-                    f"Partial save: {len(errors)} failed out of {len(items)}"
-                )
-
         except Exception as e:
-            fail_metadata = (
-                {"entity_count": len(items), "saved": saved_count}
-                if is_batch
-                else items[0].metadata
-            )
             crewai_event_bus.emit(
                 self,
                 event=MemorySaveFailedEvent(
-                    metadata=fail_metadata,
+                    metadata=item.metadata,
                     error=str(e),
                     source_type="entity_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
             raise
@@ -163,8 +111,6 @@ class EntityMemory(Memory):
                 limit=limit,
                 score_threshold=score_threshold,
                 source_type="entity_memory",
-                from_agent=self.agent,
-                from_task=self.task,
             ),
         )
 
@@ -183,8 +129,6 @@ class EntityMemory(Memory):
                     score_threshold=score_threshold,
                     query_time_ms=(time.time() - start_time) * 1000,
                     source_type="entity_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
 

src/crewai/memory/external/external_memory.py

@@ -4,8 +4,8 @@ import time
 from crewai.memory.external.external_memory_item import ExternalMemoryItem
 from crewai.memory.memory import Memory
 from crewai.memory.storage.interface import Storage
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.memory_events import (
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.utilities.events.memory_events import (
     MemoryQueryStartedEvent,
     MemoryQueryCompletedEvent,
     MemoryQueryFailedEvent,
@@ -53,6 +53,7 @@ class ExternalMemory(Memory):
         self,
         value: Any,
         metadata: Optional[Dict[str, Any]] = None,
+        agent: Optional[str] = None,
     ) -> None:
         """Saves a value into the external storage."""
         crewai_event_bus.emit(
@@ -60,30 +61,24 @@ class ExternalMemory(Memory):
             event=MemorySaveStartedEvent(
                 value=value,
                 metadata=metadata,
+                agent_role=agent,
                 source_type="external_memory",
-                from_agent=self.agent,
-                from_task=self.task,
             ),
         )
 
         start_time = time.time()
         try:
-            item = ExternalMemoryItem(
-                value=value,
-                metadata=metadata,
-                agent=self.agent.role if self.agent else None,
-            )
-            super().save(value=item.value, metadata=item.metadata)
+            item = ExternalMemoryItem(value=value, metadata=metadata, agent=agent)
+            super().save(value=item.value, metadata=item.metadata, agent=item.agent)
 
             crewai_event_bus.emit(
                 self,
                 event=MemorySaveCompletedEvent(
                     value=value,
                     metadata=metadata,
+                    agent_role=agent,
                     save_time_ms=(time.time() - start_time) * 1000,
                     source_type="external_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
         except Exception as e:
@@ -92,10 +87,9 @@ class ExternalMemory(Memory):
                 event=MemorySaveFailedEvent(
                     value=value,
                     metadata=metadata,
+                    agent_role=agent,
                     error=str(e),
                     source_type="external_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
             raise
@@ -113,8 +107,6 @@ class ExternalMemory(Memory):
                 limit=limit,
                 score_threshold=score_threshold,
                 source_type="external_memory",
-                from_agent=self.agent,
-                from_task=self.task,
             ),
         )
 
@@ -133,8 +125,6 @@ class ExternalMemory(Memory):
                     score_threshold=score_threshold,
                     query_time_ms=(time.time() - start_time) * 1000,
                     source_type="external_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
 

src/crewai/memory/long_term/long_term_memory.py

@@ -3,8 +3,8 @@ import time
 
 from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
 from crewai.memory.memory import Memory
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.memory_events import (
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.utilities.events.memory_events import (
     MemoryQueryStartedEvent,
     MemoryQueryCompletedEvent,
     MemoryQueryFailedEvent,
@@ -37,17 +37,13 @@ class LongTermMemory(Memory):
                 metadata=item.metadata,
                 agent_role=item.agent,
                 source_type="long_term_memory",
-                from_agent=self.agent,
-                from_task=self.task,
             ),
         )
 
         start_time = time.time()
         try:
             metadata = item.metadata
-            metadata.update(
-                {"agent": item.agent, "expected_output": item.expected_output}
-            )
+            metadata.update({"agent": item.agent, "expected_output": item.expected_output})
             self.storage.save(  # type: ignore # BUG?: Unexpected keyword argument "task_description","score","datetime" for "save" of "Storage"
                 task_description=item.task,
                 score=metadata["quality"],
@@ -63,8 +59,6 @@ class LongTermMemory(Memory):
                     agent_role=item.agent,
                     save_time_ms=(time.time() - start_time) * 1000,
                     source_type="long_term_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
         except Exception as e:
@@ -80,19 +74,13 @@ class LongTermMemory(Memory):
             )
             raise
 
-    def search(  # type: ignore # signature of "search" incompatible with supertype "Memory"
-        self,
-        task: str,
-        latest_n: int = 3,
-    ) -> List[Dict[str, Any]]:  # type: ignore # signature of "search" incompatible with supertype "Memory"
+    def search(self, task: str, latest_n: int = 3) -> List[Dict[str, Any]]:  # type: ignore # signature of "search" incompatible with supertype "Memory"
         crewai_event_bus.emit(
             self,
             event=MemoryQueryStartedEvent(
                 query=task,
                 limit=latest_n,
                 source_type="long_term_memory",
-                from_agent=self.agent,
-                from_task=self.task,
             ),
         )
 
@@ -108,8 +96,6 @@ class LongTermMemory(Memory):
                     limit=latest_n,
                     query_time_ms=(time.time() - start_time) * 1000,
                     source_type="long_term_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
 

src/crewai/memory/memory.py

@@ -1,11 +1,7 @@
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
+from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel
 
-if TYPE_CHECKING:
-    from crewai.agent import Agent
-    from crewai.task import Task
-
 
 class Memory(BaseModel):
     """
@@ -16,38 +12,19 @@ class Memory(BaseModel):
     crew: Optional[Any] = None
 
     storage: Any
-    _agent: Optional["Agent"] = None
-    _task: Optional["Task"] = None
 
     def __init__(self, storage: Any, **data: Any):
         super().__init__(storage=storage, **data)
 
-    @property
-    def task(self) -> Optional["Task"]:
-        """Get the current task associated with this memory."""
-        return self._task
-
-    @task.setter
-    def task(self, task: Optional["Task"]) -> None:
-        """Set the current task associated with this memory."""
-        self._task = task
-
-    @property
-    def agent(self) -> Optional["Agent"]:
-        """Get the current agent associated with this memory."""
-        return self._agent
-
-    @agent.setter
-    def agent(self, agent: Optional["Agent"]) -> None:
-        """Set the current agent associated with this memory."""
-        self._agent = agent
-
     def save(
         self,
         value: Any,
         metadata: Optional[Dict[str, Any]] = None,
+        agent: Optional[str] = None,
     ) -> None:
         metadata = metadata or {}
+        if agent:
+            metadata["agent"] = agent
 
         self.storage.save(value, metadata)
 

src/crewai/memory/short_term/short_term_memory.py

@@ -6,8 +6,8 @@ from pydantic import PrivateAttr
 from crewai.memory.memory import Memory
 from crewai.memory.short_term.short_term_memory_item import ShortTermMemoryItem
 from crewai.memory.storage.rag_storage import RAGStorage
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.memory_events import (
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.utilities.events.memory_events import (
     MemoryQueryStartedEvent,
     MemoryQueryCompletedEvent,
     MemoryQueryFailedEvent,
@@ -37,7 +37,7 @@ class ShortTermMemory(Memory):
                 raise ImportError(
                     "Mem0 is not installed. Please install it with `pip install mem0ai`."
                 )
-            config = embedder_config.get("config") if embedder_config else None
+            config = embedder_config.get("config")
             storage = Mem0Storage(type="short_term", crew=crew, config=config)
         else:
             storage = (
@@ -57,42 +57,34 @@ class ShortTermMemory(Memory):
         self,
         value: Any,
         metadata: Optional[Dict[str, Any]] = None,
+        agent: Optional[str] = None,
     ) -> None:
         crewai_event_bus.emit(
             self,
             event=MemorySaveStartedEvent(
                 value=value,
                 metadata=metadata,
+                agent_role=agent,
                 source_type="short_term_memory",
-                from_agent=self.agent,
-                from_task=self.task,
             ),
         )
 
         start_time = time.time()
         try:
-            item = ShortTermMemoryItem(
-                data=value,
-                metadata=metadata,
-                agent=self.agent.role if self.agent else None,
-            )
+            item = ShortTermMemoryItem(data=value, metadata=metadata, agent=agent)
             if self._memory_provider == "mem0":
-                item.data = (
-                    f"Remember the following insights from Agent run: {item.data}"
-                )
+                item.data = f"Remember the following insights from Agent run: {item.data}"
 
-            super().save(value=item.data, metadata=item.metadata)
+            super().save(value=item.data, metadata=item.metadata, agent=item.agent)
 
             crewai_event_bus.emit(
                 self,
                 event=MemorySaveCompletedEvent(
                     value=value,
                     metadata=metadata,
-                    # agent_role=agent,
+                    agent_role=agent,
                     save_time_ms=(time.time() - start_time) * 1000,
                     source_type="short_term_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
         except Exception as e:
@@ -101,10 +93,9 @@ class ShortTermMemory(Memory):
                 event=MemorySaveFailedEvent(
                     value=value,
                     metadata=metadata,
+                    agent_role=agent,
                     error=str(e),
                     source_type="short_term_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
             raise
@@ -122,8 +113,6 @@ class ShortTermMemory(Memory):
                 limit=limit,
                 score_threshold=score_threshold,
                 source_type="short_term_memory",
-                from_agent=self.agent,
-                from_task=self.task,
             ),
         )
 
@@ -142,8 +131,6 @@ class ShortTermMemory(Memory):
                     score_threshold=score_threshold,
                     query_time_ms=(time.time() - start_time) * 1000,
                     source_type="short_term_memory",
-                    from_agent=self.agent,
-                    from_task=self.task,
                 ),
             )
 

src/crewai/memory/storage/kickoff_task_outputs_storage.py

@@ -18,7 +18,9 @@ class KickoffTaskOutputsSQLiteStorage:
     An updated SQLite storage class for kickoff task outputs storage.
     """
 
-    def __init__(self, db_path: Optional[str] = None) -> None:
+    def __init__(
+        self, db_path: Optional[str] = None
+    ) -> None:
         if db_path is None:
             # Get the parent directory of the default db path and create our db file there
             db_path = str(Path(db_storage_path()) / "latest_kickoff_task_outputs.db")
@@ -65,7 +67,7 @@ class KickoffTaskOutputsSQLiteStorage:
         output: Dict[str, Any],
         task_index: int,
         was_replayed: bool = False,
-        inputs: Dict[str, Any] | None = None,
+        inputs: Dict[str, Any] = {},
     ) -> None:
         """Add a new task output record to the database.
 
@@ -79,7 +81,6 @@ class KickoffTaskOutputsSQLiteStorage:
         Raises:
             DatabaseOperationError: If saving the task output fails due to SQLite errors.
         """
-        inputs = inputs or {}
         try:
             with sqlite3.connect(self.db_path) as conn:
                 conn.execute("BEGIN TRANSACTION")
@@ -145,9 +146,7 @@ class KickoffTaskOutputsSQLiteStorage:
                 conn.commit()
 
                 if cursor.rowcount == 0:
-                    logger.warning(
-                        f"No row found with task_index {task_index}. No update performed."
-                    )
+                    logger.warning(f"No row found with task_index {task_index}. No update performed.")
         except sqlite3.Error as e:
             error_msg = DatabaseError.format_error(DatabaseError.UPDATE_ERROR, e)
             logger.error(error_msg)

src/crewai/memory/storage/rag_storage.py

@@ -1,3 +1,5 @@
+import contextlib
+import io
 import logging
 import os
 import shutil
@@ -10,10 +12,26 @@ from crewai.rag.embeddings.configurator import EmbeddingConfigurator
 from crewai.utilities.chromadb import create_persistent_client
 from crewai.utilities.constants import MAX_FILE_NAME_LENGTH
 from crewai.utilities.paths import db_storage_path
-from crewai.utilities.logger_utils import suppress_logging
 import warnings
 
 
+@contextlib.contextmanager
+def suppress_logging(
+    logger_name="chromadb.segment.impl.vector.local_persistent_hnsw",
+    level=logging.ERROR,
+):
+    logger = logging.getLogger(logger_name)
+    original_level = logger.getEffectiveLevel()
+    logger.setLevel(level)
+    with (
+        contextlib.redirect_stdout(io.StringIO()),
+        contextlib.redirect_stderr(io.StringIO()),
+        contextlib.suppress(UserWarning),
+    ):
+        yield
+    logger.setLevel(original_level)
+
+
 class RAGStorage(BaseRAGStorage):
     """
     Extends Storage to handle embeddings for memory entries, improving
@@ -104,9 +122,7 @@ class RAGStorage(BaseRAGStorage):
             self._initialize_app()
 
         try:
-            with suppress_logging(
-                "chromadb.segment.impl.vector.local_persistent_hnsw", logging.ERROR
-            ):
+            with suppress_logging():
                 response = self.collection.query(query_texts=query, n_results=limit)
 
             results = []

src/crewai/rag/__init__.py

@@ -1,58 +1 @@
-"""RAG (Retrieval-Augmented Generation) infrastructure for CrewAI."""
-
-import sys
-import importlib
-from types import ModuleType
-from typing import Any
-
-from crewai.rag.config.types import RagConfigType
-from crewai.rag.config.utils import set_rag_config
-
-
-_module_path = __path__
-_module_file = __file__
-
-class _RagModule(ModuleType):
-    """Module wrapper to intercept attribute setting for config."""
-
-    __path__ = _module_path
-    __file__ = _module_file
-
-    def __init__(self, module_name: str):
-        """Initialize the module wrapper.
-
-        Args:
-            module_name: Name of the module.
-        """
-        super().__init__(module_name)
-
-    def __setattr__(self, name: str, value: RagConfigType) -> None:
-        """Set module attributes.
-
-        Args:
-            name: Attribute name.
-            value: Attribute value.
-        """
-        if name == "config":
-            return set_rag_config(value)
-        raise AttributeError(f"Setting attribute '{name}' is not allowed.")
-
-    def __getattr__(self, name: str) -> Any:
-        """Get module attributes.
-
-        Args:
-            name: Attribute name.
-
-        Returns:
-            The requested attribute.
-
-        Raises:
-            AttributeError: If attribute doesn't exist.
-        """
-        try:
-            return importlib.import_module(f"{self.__name__}.{name}")
-        except ImportError:
-            raise AttributeError(f"module '{self.__name__}' has no attribute '{name}'")
-
-
-sys.modules[__name__] = _RagModule(__name__)
+"""RAG (Retrieval-Augmented Generation) infrastructure for CrewAI."""

src/crewai/rag/chromadb/client.py

@@ -1,578 +0,0 @@
-"""ChromaDB client implementation."""
-
-import logging
-from typing import Any
-
-from chromadb.api.types import (
-    Embeddable,
-    EmbeddingFunction as ChromaEmbeddingFunction,
-    QueryResult,
-)
-from typing_extensions import Unpack
-
-from crewai.rag.chromadb.types import (
-    ChromaDBClientType,
-    ChromaDBCollectionCreateParams,
-    ChromaDBCollectionSearchParams,
-)
-from crewai.rag.chromadb.utils import (
-    _extract_search_params,
-    _is_async_client,
-    _is_sync_client,
-    _prepare_documents_for_chromadb,
-    _process_query_results,
-    _sanitize_collection_name,
-)
-from crewai.utilities.logger_utils import suppress_logging
-from crewai.rag.core.base_client import (
-    BaseClient,
-    BaseCollectionParams,
-    BaseCollectionAddParams,
-)
-from crewai.rag.types import SearchResult
-
-
-class ChromaDBClient(BaseClient):
-    """ChromaDB implementation of the BaseClient protocol.
-
-    Provides vector database operations for ChromaDB, supporting both
-    synchronous and asynchronous clients.
-
-    Attributes:
-        client: ChromaDB client instance (ClientAPI or AsyncClientAPI).
-        embedding_function: Function to generate embeddings for documents.
-    """
-
-    def __init__(
-        self,
-        client: ChromaDBClientType,
-        embedding_function: ChromaEmbeddingFunction[Embeddable],
-    ) -> None:
-        """Initialize ChromaDBClient with client and embedding function.
-
-        Args:
-            client: Pre-configured ChromaDB client instance.
-            embedding_function: Embedding function for text to vector conversion.
-        """
-        self.client = client
-        self.embedding_function = embedding_function
-
-    def create_collection(
-        self, **kwargs: Unpack[ChromaDBCollectionCreateParams]
-    ) -> None:
-        """Create a new collection in ChromaDB.
-
-        Uses the client's default embedding function if none provided.
-
-        Keyword Args:
-            collection_name: Name of the collection to create. Must be unique.
-            configuration: Optional collection configuration specifying distance metrics,
-                HNSW parameters, or other backend-specific settings.
-            metadata: Optional metadata dictionary to attach to the collection.
-            embedding_function: Optional custom embedding function. If not provided,
-                uses the client's default embedding function.
-            data_loader: Optional data loader for batch loading data into the collection.
-            get_or_create: If True, returns existing collection if it already exists
-                instead of raising an error. Defaults to False.
-
-        Raises:
-            TypeError: If AsyncClientAPI is used instead of ClientAPI for sync operations.
-            ValueError: If collection with the same name already exists and get_or_create
-                is False.
-            ConnectionError: If unable to connect to ChromaDB server.
-
-        Example:
-            >>> client = ChromaDBClient()
-            >>> client.create_collection(
-            ...     collection_name="documents",
-            ...     metadata={"description": "Product documentation"},
-            ...     get_or_create=True
-            ... )
-        """
-        if not _is_sync_client(self.client):
-            raise TypeError(
-                "Synchronous method create_collection() requires a ClientAPI. "
-                "Use acreate_collection() for AsyncClientAPI."
-            )
-
-        metadata = kwargs.get("metadata", {})
-        if "hnsw:space" not in metadata:
-            metadata["hnsw:space"] = "cosine"
-
-        self.client.create_collection(
-            name=_sanitize_collection_name(kwargs["collection_name"]),
-            configuration=kwargs.get("configuration"),
-            metadata=metadata,
-            embedding_function=kwargs.get(
-                "embedding_function", self.embedding_function
-            ),
-            data_loader=kwargs.get("data_loader"),
-            get_or_create=kwargs.get("get_or_create", False),
-        )
-
-    async def acreate_collection(
-        self, **kwargs: Unpack[ChromaDBCollectionCreateParams]
-    ) -> None:
-        """Create a new collection in ChromaDB asynchronously.
-
-        Creates a new collection with the specified name and optional configuration.
-        If an embedding function is not provided, uses the client's default embedding function.
-
-        Keyword Args:
-            collection_name: Name of the collection to create. Must be unique.
-            configuration: Optional collection configuration specifying distance metrics,
-                HNSW parameters, or other backend-specific settings.
-            metadata: Optional metadata dictionary to attach to the collection.
-            embedding_function: Optional custom embedding function. If not provided,
-                uses the client's default embedding function.
-            data_loader: Optional data loader for batch loading data into the collection.
-            get_or_create: If True, returns existing collection if it already exists
-                instead of raising an error. Defaults to False.
-
-        Raises:
-            TypeError: If ClientAPI is used instead of AsyncClientAPI for async operations.
-            ValueError: If collection with the same name already exists and get_or_create
-                is False.
-            ConnectionError: If unable to connect to ChromaDB server.
-
-        Example:
-            >>> import asyncio
-            >>> async def main():
-            ...     client = ChromaDBClient()
-            ...     await client.acreate_collection(
-            ...         collection_name="documents",
-            ...         metadata={"description": "Product documentation"},
-            ...         get_or_create=True
-            ...     )
-            >>> asyncio.run(main())
-        """
-        if not _is_async_client(self.client):
-            raise TypeError(
-                "Asynchronous method acreate_collection() requires an AsyncClientAPI. "
-                "Use create_collection() for ClientAPI."
-            )
-
-        metadata = kwargs.get("metadata", {})
-        if "hnsw:space" not in metadata:
-            metadata["hnsw:space"] = "cosine"
-
-        await self.client.create_collection(
-            name=_sanitize_collection_name(kwargs["collection_name"]),
-            configuration=kwargs.get("configuration"),
-            metadata=metadata,
-            embedding_function=kwargs.get(
-                "embedding_function", self.embedding_function
-            ),
-            data_loader=kwargs.get("data_loader"),
-            get_or_create=kwargs.get("get_or_create", False),
-        )
-
-    def get_or_create_collection(
-        self, **kwargs: Unpack[ChromaDBCollectionCreateParams]
-    ) -> Any:
-        """Get an existing collection or create it if it doesn't exist.
-
-        Returns existing collection if found, otherwise creates a new one.
-
-        Keyword Args:
-            collection_name: Name of the collection to get or create.
-            configuration: Optional collection configuration specifying distance metrics,
-                HNSW parameters, or other backend-specific settings.
-            metadata: Optional metadata dictionary to attach to the collection.
-            embedding_function: Optional custom embedding function. If not provided,
-                uses the client's default embedding function.
-            data_loader: Optional data loader for batch loading data into the collection.
-
-        Returns:
-            A ChromaDB Collection object.
-
-        Raises:
-            TypeError: If AsyncClientAPI is used instead of ClientAPI for sync operations.
-            ConnectionError: If unable to connect to ChromaDB server.
-
-        Example:
-            >>> client = ChromaDBClient()
-            >>> collection = client.get_or_create_collection(
-            ...     collection_name="documents",
-            ...     metadata={"description": "Product documentation"}
-            ... )
-        """
-        if not _is_sync_client(self.client):
-            raise TypeError(
-                "Synchronous method get_or_create_collection() requires a ClientAPI. "
-                "Use aget_or_create_collection() for AsyncClientAPI."
-            )
-
-        metadata = kwargs.get("metadata", {})
-        if "hnsw:space" not in metadata:
-            metadata["hnsw:space"] = "cosine"
-
-        return self.client.get_or_create_collection(
-            name=_sanitize_collection_name(kwargs["collection_name"]),
-            configuration=kwargs.get("configuration"),
-            metadata=metadata,
-            embedding_function=kwargs.get(
-                "embedding_function", self.embedding_function
-            ),
-            data_loader=kwargs.get("data_loader"),
-        )
-
-    async def aget_or_create_collection(
-        self, **kwargs: Unpack[ChromaDBCollectionCreateParams]
-    ) -> Any:
-        """Get an existing collection or create it if it doesn't exist asynchronously.
-
-        Returns existing collection if found, otherwise creates a new one.
-
-        Keyword Args:
-            collection_name: Name of the collection to get or create.
-            configuration: Optional collection configuration specifying distance metrics,
-                HNSW parameters, or other backend-specific settings.
-            metadata: Optional metadata dictionary to attach to the collection.
-            embedding_function: Optional custom embedding function. If not provided,
-                uses the client's default embedding function.
-            data_loader: Optional data loader for batch loading data into the collection.
-
-        Returns:
-            A ChromaDB AsyncCollection object.
-
-        Raises:
-            TypeError: If ClientAPI is used instead of AsyncClientAPI for async operations.
-            ConnectionError: If unable to connect to ChromaDB server.
-
-        Example:
-            >>> import asyncio
-            >>> async def main():
-            ...     client = ChromaDBClient()
-            ...     collection = await client.aget_or_create_collection(
-            ...         collection_name="documents",
-            ...         metadata={"description": "Product documentation"}
-            ...     )
-            >>> asyncio.run(main())
-        """
-        if not _is_async_client(self.client):
-            raise TypeError(
-                "Asynchronous method aget_or_create_collection() requires an AsyncClientAPI. "
-                "Use get_or_create_collection() for ClientAPI."
-            )
-
-        metadata = kwargs.get("metadata", {})
-        if "hnsw:space" not in metadata:
-            metadata["hnsw:space"] = "cosine"
-
-        return await self.client.get_or_create_collection(
-            name=_sanitize_collection_name(kwargs["collection_name"]),
-            configuration=kwargs.get("configuration"),
-            metadata=metadata,
-            embedding_function=kwargs.get(
-                "embedding_function", self.embedding_function
-            ),
-            data_loader=kwargs.get("data_loader"),
-        )
-
-    def add_documents(self, **kwargs: Unpack[BaseCollectionAddParams]) -> None:
-        """Add documents with their embeddings to a collection.
-
-        Performs an upsert operation - documents with existing IDs are updated.
-        Generates embeddings automatically using the configured embedding function.
-
-        Keyword Args:
-            collection_name: The name of the collection to add documents to.
-            documents: List of BaseRecord dicts containing:
-                - content: The text content (required)
-                - doc_id: Optional unique identifier (auto-generated if missing)
-                - metadata: Optional metadata dictionary
-
-        Raises:
-            TypeError: If AsyncClientAPI is used instead of ClientAPI for sync operations.
-            ValueError: If collection doesn't exist or documents list is empty.
-            ConnectionError: If unable to connect to ChromaDB server.
-        """
-        if not _is_sync_client(self.client):
-            raise TypeError(
-                "Synchronous method add_documents() requires a ClientAPI. "
-                "Use aadd_documents() for AsyncClientAPI."
-            )
-
-        collection_name = kwargs["collection_name"]
-        documents = kwargs["documents"]
-
-        if not documents:
-            raise ValueError("Documents list cannot be empty")
-
-        collection = self.client.get_collection(
-            name=_sanitize_collection_name(collection_name),
-            embedding_function=self.embedding_function,
-        )
-
-        prepared = _prepare_documents_for_chromadb(documents)
-        collection.upsert(
-            ids=prepared.ids,
-            documents=prepared.texts,
-            metadatas=prepared.metadatas,
-        )
-
-    async def aadd_documents(self, **kwargs: Unpack[BaseCollectionAddParams]) -> None:
-        """Add documents with their embeddings to a collection asynchronously.
-
-        Performs an upsert operation - documents with existing IDs are updated.
-        Generates embeddings automatically using the configured embedding function.
-
-        Keyword Args:
-            collection_name: The name of the collection to add documents to.
-            documents: List of BaseRecord dicts containing:
-                - content: The text content (required)
-                - doc_id: Optional unique identifier (auto-generated if missing)
-                - metadata: Optional metadata dictionary
-
-        Raises:
-            TypeError: If ClientAPI is used instead of AsyncClientAPI for async operations.
-            ValueError: If collection doesn't exist or documents list is empty.
-            ConnectionError: If unable to connect to ChromaDB server.
-        """
-        if not _is_async_client(self.client):
-            raise TypeError(
-                "Asynchronous method aadd_documents() requires an AsyncClientAPI. "
-                "Use add_documents() for ClientAPI."
-            )
-
-        collection_name = kwargs["collection_name"]
-        documents = kwargs["documents"]
-
-        if not documents:
-            raise ValueError("Documents list cannot be empty")
-
-        collection = await self.client.get_collection(
-            name=_sanitize_collection_name(collection_name),
-            embedding_function=self.embedding_function,
-        )
-        prepared = _prepare_documents_for_chromadb(documents)
-        await collection.upsert(
-            ids=prepared.ids,
-            documents=prepared.texts,
-            metadatas=prepared.metadatas,
-        )
-
-    def search(
-        self, **kwargs: Unpack[ChromaDBCollectionSearchParams]
-    ) -> list[SearchResult]:
-        """Search for similar documents using a query.
-
-        Performs semantic search to find documents similar to the query text.
-        Uses the configured embedding function to generate query embeddings.
-
-        Keyword Args:
-            collection_name: Name of the collection to search in.
-            query: The text query to search for.
-            limit: Maximum number of results to return (default: 10).
-            metadata_filter: Optional filter for metadata fields.
-            score_threshold: Optional minimum similarity score (0-1) for results.
-            where: Optional ChromaDB where clause for metadata filtering.
-            where_document: Optional ChromaDB where clause for document content filtering.
-            include: Optional list of fields to include in results.
-
-        Returns:
-            List of SearchResult dicts containing id, content, metadata, and score.
-
-        Raises:
-            TypeError: If AsyncClientAPI is used instead of ClientAPI for sync operations.
-            ValueError: If collection doesn't exist.
-            ConnectionError: If unable to connect to ChromaDB server.
-        """
-        if not _is_sync_client(self.client):
-            raise TypeError(
-                "Synchronous method search() requires a ClientAPI. "
-                "Use asearch() for AsyncClientAPI."
-            )
-
-        params = _extract_search_params(kwargs)
-
-        collection = self.client.get_collection(
-            name=_sanitize_collection_name(params.collection_name),
-            embedding_function=self.embedding_function,
-        )
-
-        where = params.where if params.where is not None else params.metadata_filter
-
-        with suppress_logging(
-            "chromadb.segment.impl.vector.local_persistent_hnsw", logging.ERROR
-        ):
-            results: QueryResult = collection.query(
-                query_texts=[params.query],
-                n_results=params.limit,
-                where=where,
-                where_document=params.where_document,
-                include=params.include,
-            )
-
-        return _process_query_results(
-            collection=collection,
-            results=results,
-            params=params,
-        )
-
-    async def asearch(
-        self, **kwargs: Unpack[ChromaDBCollectionSearchParams]
-    ) -> list[SearchResult]:
-        """Search for similar documents using a query asynchronously.
-
-        Performs semantic search to find documents similar to the query text.
-        Uses the configured embedding function to generate query embeddings.
-
-        Keyword Args:
-            collection_name: Name of the collection to search in.
-            query: The text query to search for.
-            limit: Maximum number of results to return (default: 10).
-            metadata_filter: Optional filter for metadata fields.
-            score_threshold: Optional minimum similarity score (0-1) for results.
-            where: Optional ChromaDB where clause for metadata filtering.
-            where_document: Optional ChromaDB where clause for document content filtering.
-            include: Optional list of fields to include in results.
-
-        Returns:
-            List of SearchResult dicts containing id, content, metadata, and score.
-
-        Raises:
-            TypeError: If ClientAPI is used instead of AsyncClientAPI for async operations.
-            ValueError: If collection doesn't exist.
-            ConnectionError: If unable to connect to ChromaDB server.
-        """
-        if not _is_async_client(self.client):
-            raise TypeError(
-                "Asynchronous method asearch() requires an AsyncClientAPI. "
-                "Use search() for ClientAPI."
-            )
-
-        params = _extract_search_params(kwargs)
-
-        collection = await self.client.get_collection(
-            name=_sanitize_collection_name(params.collection_name),
-            embedding_function=self.embedding_function,
-        )
-
-        where = params.where if params.where is not None else params.metadata_filter
-
-        with suppress_logging(
-            "chromadb.segment.impl.vector.local_persistent_hnsw", logging.ERROR
-        ):
-            results: QueryResult = await collection.query(
-                query_texts=[params.query],
-                n_results=params.limit,
-                where=where,
-                where_document=params.where_document,
-                include=params.include,
-            )
-
-        return _process_query_results(
-            collection=collection,
-            results=results,
-            params=params,
-        )
-
-    def delete_collection(self, **kwargs: Unpack[BaseCollectionParams]) -> None:
-        """Delete a collection and all its data.
-
-        Permanently removes a collection and all documents, embeddings, and metadata it contains.
-        This operation cannot be undone.
-
-        Keyword Args:
-            collection_name: Name of the collection to delete.
-
-        Raises:
-            TypeError: If AsyncClientAPI is used instead of ClientAPI for sync operations.
-            ValueError: If collection doesn't exist.
-            ConnectionError: If unable to connect to ChromaDB server.
-
-        Example:
-            >>> client = ChromaDBClient()
-            >>> client.delete_collection(collection_name="old_documents")
-        """
-        if not _is_sync_client(self.client):
-            raise TypeError(
-                "Synchronous method delete_collection() requires a ClientAPI. "
-                "Use adelete_collection() for AsyncClientAPI."
-            )
-
-        collection_name = kwargs["collection_name"]
-        self.client.delete_collection(name=_sanitize_collection_name(collection_name))
-
-    async def adelete_collection(self, **kwargs: Unpack[BaseCollectionParams]) -> None:
-        """Delete a collection and all its data asynchronously.
-
-        Permanently removes a collection and all documents, embeddings, and metadata it contains.
-        This operation cannot be undone.
-
-        Keyword Args:
-            collection_name: Name of the collection to delete.
-
-        Raises:
-            TypeError: If ClientAPI is used instead of AsyncClientAPI for async operations.
-            ValueError: If collection doesn't exist.
-            ConnectionError: If unable to connect to ChromaDB server.
-
-        Example:
-            >>> import asyncio
-            >>> async def main():
-            ...     client = ChromaDBClient()
-            ...     await client.adelete_collection(collection_name="old_documents")
-            >>> asyncio.run(main())
-        """
-        if not _is_async_client(self.client):
-            raise TypeError(
-                "Asynchronous method adelete_collection() requires an AsyncClientAPI. "
-                "Use delete_collection() for ClientAPI."
-            )
-
-        collection_name = kwargs["collection_name"]
-        await self.client.delete_collection(
-            name=_sanitize_collection_name(collection_name)
-        )
-
-    def reset(self) -> None:
-        """Reset the vector database by deleting all collections and data.
-
-        Completely clears the ChromaDB instance, removing all collections,
-        documents, embeddings, and metadata. This operation cannot be undone.
-        Use with extreme caution in production environments.
-
-        Raises:
-            TypeError: If AsyncClientAPI is used instead of ClientAPI for sync operations.
-            ConnectionError: If unable to connect to ChromaDB server.
-
-        Example:
-            >>> client = ChromaDBClient()
-            >>> client.reset()  # Removes ALL data from ChromaDB
-        """
-        if not _is_sync_client(self.client):
-            raise TypeError(
-                "Synchronous method reset() requires a ClientAPI. "
-                "Use areset() for AsyncClientAPI."
-            )
-
-        self.client.reset()
-
-    async def areset(self) -> None:
-        """Reset the vector database by deleting all collections and data asynchronously.
-
-        Completely clears the ChromaDB instance, removing all collections,
-        documents, embeddings, and metadata. This operation cannot be undone.
-        Use with extreme caution in production environments.
-
-        Raises:
-            TypeError: If ClientAPI is used instead of AsyncClientAPI for async operations.
-            ConnectionError: If unable to connect to ChromaDB server.
-
-        Example:
-            >>> import asyncio
-            >>> async def main():
-            ...     client = ChromaDBClient()
-            ...     await client.areset()  # Removes ALL data from ChromaDB
-            >>> asyncio.run(main())
-        """
-        if not _is_async_client(self.client):
-            raise TypeError(
-                "Asynchronous method areset() requires an AsyncClientAPI. "
-                "Use reset() for ClientAPI."
-            )
-
-        await self.client.reset()

src/crewai/rag/chromadb/config.py

@@ -1,65 +0,0 @@
-"""ChromaDB configuration model."""
-
-import warnings
-from dataclasses import field
-from typing import Literal, cast
-from pydantic.dataclasses import dataclass as pyd_dataclass
-from chromadb.config import Settings
-from chromadb.utils.embedding_functions import DefaultEmbeddingFunction
-
-from crewai.rag.chromadb.types import ChromaEmbeddingFunctionWrapper
-from crewai.rag.config.base import BaseRagConfig
-from crewai.rag.chromadb.constants import (
-    DEFAULT_TENANT,
-    DEFAULT_DATABASE,
-    DEFAULT_STORAGE_PATH,
-)
-
-
-warnings.filterwarnings(
-    "ignore",
-    message=".*Mixing V1 models and V2 models.*",
-    category=UserWarning,
-    module="pydantic._internal._generate_schema",
-)
-
-warnings.filterwarnings(
-    "ignore",
-    message=r".*'model_fields'.*is deprecated.*",
-    module=r"^chromadb(\.|$)",
-)
-
-
-def _default_settings() -> Settings:
-    """Create default ChromaDB settings.
-
-    Returns:
-        Settings with persistent storage and reset enabled.
-    """
-    return Settings(
-        persist_directory=DEFAULT_STORAGE_PATH,
-        allow_reset=True,
-        is_persistent=True,
-    )
-
-
-def _default_embedding_function() -> ChromaEmbeddingFunctionWrapper:
-    """Create default ChromaDB embedding function.
-
-    Returns:
-        Default embedding function using all-MiniLM-L6-v2 via ONNX.
-    """
-    return cast(ChromaEmbeddingFunctionWrapper, DefaultEmbeddingFunction())
-
-
-@pyd_dataclass(frozen=True)
-class ChromaDBConfig(BaseRagConfig):
-    """Configuration for ChromaDB client."""
-
-    provider: Literal["chromadb"] = field(default="chromadb", init=False)
-    tenant: str = DEFAULT_TENANT
-    database: str = DEFAULT_DATABASE
-    settings: Settings = field(default_factory=_default_settings)
-    embedding_function: ChromaEmbeddingFunctionWrapper = field(
-        default_factory=_default_embedding_function
-    )

src/crewai/rag/chromadb/constants.py

@@ -1,17 +0,0 @@
-"""Constants for ChromaDB configuration."""
-
-import re
-from typing import Final
-
-from crewai.utilities.paths import db_storage_path
-
-DEFAULT_TENANT: Final[str] = "default_tenant"
-DEFAULT_DATABASE: Final[str] = "default_database"
-DEFAULT_STORAGE_PATH: Final[str] = db_storage_path()
-
-MIN_COLLECTION_LENGTH: Final[int] = 3
-MAX_COLLECTION_LENGTH: Final[int] = 63
-DEFAULT_COLLECTION: Final[str] = "default_collection"
-
-INVALID_CHARS_PATTERN: Final[re.Pattern[str]] = re.compile(r"[^a-zA-Z0-9_-]")
-IPV4_PATTERN: Final[re.Pattern[str]] = re.compile(r"^(\d{1,3}\.){3}\d{1,3}$")

src/crewai/rag/chromadb/factory.py

@@ -1,40 +0,0 @@
-"""Factory functions for creating ChromaDB clients."""
-
-import os
-from hashlib import md5
-import portalocker
-from chromadb import PersistentClient
-
-from crewai.rag.chromadb.config import ChromaDBConfig
-from crewai.rag.chromadb.client import ChromaDBClient
-
-
-def create_client(config: ChromaDBConfig) -> ChromaDBClient:
-    """Create a ChromaDBClient from configuration.
-
-    Args:
-        config: ChromaDB configuration object.
-
-    Returns:
-        Configured ChromaDBClient instance.
-
-    Notes:
-        Need to update to use chromadb.Client to support more client types in the near future.
-    """
-
-    persist_dir = config.settings.persist_directory
-    lock_id = md5(persist_dir.encode(), usedforsecurity=False).hexdigest()
-    lockfile = os.path.join(persist_dir, f"chromadb-{lock_id}.lock")
-
-    with portalocker.Lock(lockfile):
-        client = PersistentClient(
-            path=persist_dir,
-            settings=config.settings,
-            tenant=config.tenant,
-            database=config.database,
-        )
-
-    return ChromaDBClient(
-        client=client,
-        embedding_function=config.embedding_function,
-    )

src/crewai/rag/chromadb/types.py

@@ -1,102 +0,0 @@
-"""Type definitions specific to ChromaDB implementation."""
-
-from collections.abc import Mapping
-from typing import Any, NamedTuple
-
-from pydantic import GetCoreSchemaHandler
-from pydantic_core import CoreSchema, core_schema
-from chromadb.api import ClientAPI, AsyncClientAPI
-from chromadb.api.configuration import CollectionConfigurationInterface
-from chromadb.api.types import (
-    CollectionMetadata,
-    DataLoader,
-    Embeddable,
-    EmbeddingFunction as ChromaEmbeddingFunction,
-    Include,
-    Loadable,
-    Where,
-    WhereDocument,
-)
-
-from crewai.rag.core.base_client import BaseCollectionParams, BaseCollectionSearchParams
-
-ChromaDBClientType = ClientAPI | AsyncClientAPI
-
-
-class ChromaEmbeddingFunctionWrapper(ChromaEmbeddingFunction[Embeddable]):
-    """Base class for ChromaDB EmbeddingFunction to work with Pydantic validation."""
-
-    @classmethod
-    def __get_pydantic_core_schema__(
-        cls, _source_type: Any, _handler: GetCoreSchemaHandler
-    ) -> CoreSchema:
-        """Generate Pydantic core schema for ChromaDB EmbeddingFunction.
-
-        This allows Pydantic to handle ChromaDB's EmbeddingFunction type
-        without requiring arbitrary_types_allowed=True.
-        """
-        return core_schema.any_schema()
-
-
-class PreparedDocuments(NamedTuple):
-    """Prepared documents ready for ChromaDB insertion.
-
-    Attributes:
-        ids: List of document IDs
-        texts: List of document texts
-        metadatas: List of document metadata mappings
-    """
-
-    ids: list[str]
-    texts: list[str]
-    metadatas: list[Mapping[str, str | int | float | bool]]
-
-
-class ExtractedSearchParams(NamedTuple):
-    """Extracted search parameters for ChromaDB queries.
-
-    Attributes:
-        collection_name: Name of the collection to search
-        query: Search query text
-        limit: Maximum number of results
-        metadata_filter: Optional metadata filter
-        score_threshold: Optional minimum similarity score
-        where: Optional ChromaDB where clause
-        where_document: Optional ChromaDB document filter
-        include: Fields to include in results
-    """
-
-    collection_name: str
-    query: str
-    limit: int
-    metadata_filter: dict[str, Any] | None
-    score_threshold: float | None
-    where: Where | None
-    where_document: WhereDocument | None
-    include: Include
-
-
-class ChromaDBCollectionCreateParams(BaseCollectionParams, total=False):
-    """Parameters for creating a ChromaDB collection.
-
-    This class extends BaseCollectionParams to include any additional
-    parameters specific to ChromaDB collection creation.
-    """
-
-    configuration: CollectionConfigurationInterface
-    metadata: CollectionMetadata
-    embedding_function: ChromaEmbeddingFunction[Embeddable]
-    data_loader: DataLoader[Loadable]
-    get_or_create: bool
-
-
-class ChromaDBCollectionSearchParams(BaseCollectionSearchParams, total=False):
-    """Parameters for searching a ChromaDB collection.
-
-    This class extends BaseCollectionSearchParams to include ChromaDB-specific
-    search parameters like where clauses and include options.
-    """
-
-    where: Where
-    where_document: WhereDocument
-    include: Include

src/crewai/rag/chromadb/utils.py

@@ -1,280 +0,0 @@
-"""Utility functions for ChromaDB client implementation."""
-
-import hashlib
-from collections.abc import Mapping
-from typing import Literal, TypeGuard, cast
-
-from chromadb.api import AsyncClientAPI, ClientAPI
-from chromadb.api.types import (
-    Include,
-    IncludeEnum,
-    QueryResult,
-)
-from chromadb.api.models.AsyncCollection import AsyncCollection
-from chromadb.api.models.Collection import Collection
-from crewai.rag.chromadb.constants import (
-    DEFAULT_COLLECTION,
-    INVALID_CHARS_PATTERN,
-    IPV4_PATTERN,
-    MAX_COLLECTION_LENGTH,
-    MIN_COLLECTION_LENGTH,
-)
-from crewai.rag.chromadb.types import (
-    ChromaDBClientType,
-    ChromaDBCollectionSearchParams,
-    ExtractedSearchParams,
-    PreparedDocuments,
-)
-from crewai.rag.types import BaseRecord, SearchResult
-
-
-def _is_sync_client(client: ChromaDBClientType) -> TypeGuard[ClientAPI]:
-    """Type guard to check if the client is a synchronous ClientAPI.
-
-    Args:
-        client: The client to check.
-
-    Returns:
-        True if the client is a ClientAPI, False otherwise.
-    """
-    return isinstance(client, ClientAPI)
-
-
-def _is_async_client(client: ChromaDBClientType) -> TypeGuard[AsyncClientAPI]:
-    """Type guard to check if the client is an asynchronous AsyncClientAPI.
-
-    Args:
-        client: The client to check.
-
-    Returns:
-        True if the client is an AsyncClientAPI, False otherwise.
-    """
-    return isinstance(client, AsyncClientAPI)
-
-
-def _prepare_documents_for_chromadb(
-    documents: list[BaseRecord],
-) -> PreparedDocuments:
-    """Prepare documents for ChromaDB by extracting IDs, texts, and metadata.
-
-    Args:
-        documents: List of BaseRecord documents to prepare.
-
-    Returns:
-        PreparedDocuments with ids, texts, and metadatas ready for ChromaDB.
-    """
-    ids: list[str] = []
-    texts: list[str] = []
-    metadatas: list[Mapping[str, str | int | float | bool]] = []
-
-    for doc in documents:
-        if "doc_id" in doc:
-            ids.append(doc["doc_id"])
-        else:
-            content_hash = hashlib.sha256(doc["content"].encode()).hexdigest()[:16]
-            ids.append(content_hash)
-
-        texts.append(doc["content"])
-        metadata = doc.get("metadata")
-        if metadata:
-            if isinstance(metadata, list):
-                metadatas.append(metadata[0] if metadata else {})
-            else:
-                metadatas.append(metadata)
-        else:
-            metadatas.append({})
-
-    return PreparedDocuments(ids, texts, metadatas)
-
-
-def _extract_search_params(
-    kwargs: ChromaDBCollectionSearchParams,
-) -> ExtractedSearchParams:
-    """Extract search parameters from kwargs.
-
-    Args:
-        kwargs: Keyword arguments containing search parameters.
-
-    Returns:
-        ExtractedSearchParams with all extracted parameters.
-    """
-    return ExtractedSearchParams(
-        collection_name=kwargs["collection_name"],
-        query=kwargs["query"],
-        limit=kwargs.get("limit", 10),
-        metadata_filter=kwargs.get("metadata_filter"),
-        score_threshold=kwargs.get("score_threshold"),
-        where=kwargs.get("where"),
-        where_document=kwargs.get("where_document"),
-        include=kwargs.get(
-            "include",
-            [IncludeEnum.metadatas, IncludeEnum.documents, IncludeEnum.distances],
-        ),
-    )
-
-
-def _convert_distance_to_score(
-    distance: float,
-    distance_metric: Literal["l2", "cosine", "ip"],
-) -> float:
-    """Convert ChromaDB distance to similarity score.
-
-    Notes:
-        Assuming all embedding are unit-normalized for now, including custom embeddings.
-
-    Args:
-        distance: The distance value from ChromaDB.
-        distance_metric: The distance metric used ("l2", "cosine", or "ip").
-
-    Returns:
-        Similarity score in range [0, 1] where 1 is most similar.
-    """
-    if distance_metric == "cosine":
-        score = 1.0 - 0.5 * distance
-        return max(0.0, min(1.0, score))
-    raise ValueError(f"Unsupported distance metric: {distance_metric}")
-
-
-def _convert_chromadb_results_to_search_results(
-    results: QueryResult,
-    include: Include,
-    distance_metric: Literal["l2", "cosine", "ip"],
-    score_threshold: float | None = None,
-) -> list[SearchResult]:
-    """Convert ChromaDB query results to SearchResult format.
-
-    Args:
-        results: ChromaDB query results.
-        include: List of fields that were included in the query.
-        distance_metric: The distance metric used by the collection.
-        score_threshold: Optional minimum similarity score (0-1) for results.
-
-    Returns:
-        List of SearchResult dicts containing id, content, metadata, and score.
-    """
-    search_results: list[SearchResult] = []
-
-    include_strings = [item.value for item in include]
-
-    ids = results["ids"][0] if results.get("ids") else []
-
-    documents_list = results.get("documents")
-    documents = (
-        documents_list[0] if documents_list and "documents" in include_strings else []
-    )
-
-    metadatas_list = results.get("metadatas")
-    metadatas = (
-        metadatas_list[0] if metadatas_list and "metadatas" in include_strings else []
-    )
-
-    distances_list = results.get("distances")
-    distances = (
-        distances_list[0] if distances_list and "distances" in include_strings else []
-    )
-
-    for i, doc_id in enumerate(ids):
-        if not distances or i >= len(distances):
-            continue
-
-        distance = distances[i]
-        score = _convert_distance_to_score(
-            distance=distance, distance_metric=distance_metric
-        )
-
-        if score_threshold and score < score_threshold:
-            continue
-
-        result: SearchResult = {
-            "id": doc_id,
-            "content": documents[i] if documents and i < len(documents) else "",
-            "metadata": dict(metadatas[i]) if metadatas and i < len(metadatas) else {},
-            "score": score,
-        }
-        search_results.append(result)
-
-    return search_results
-
-
-def _process_query_results(
-    collection: Collection | AsyncCollection,
-    results: QueryResult,
-    params: ExtractedSearchParams,
-) -> list[SearchResult]:
-    """Process ChromaDB query results and convert to SearchResult format.
-
-    Args:
-        collection: The ChromaDB collection (sync or async) that was queried.
-        results: Raw query results from ChromaDB.
-        params: The search parameters used for the query.
-
-    Returns:
-        List of SearchResult dicts containing id, content, metadata, and score.
-    """
-
-    distance_metric = cast(
-        Literal["l2", "cosine", "ip"],
-        collection.metadata.get("hnsw:space", "l2") if collection.metadata else "l2",
-    )
-
-    return _convert_chromadb_results_to_search_results(
-        results=results,
-        include=params.include,
-        distance_metric=distance_metric,
-        score_threshold=params.score_threshold,
-    )
-
-
-def _is_ipv4_pattern(name: str) -> bool:
-    """Check if a string matches an IPv4 address pattern.
-
-    Args:
-        name: The string to check
-
-    Returns:
-        True if the string matches an IPv4 pattern, False otherwise
-    """
-    return bool(IPV4_PATTERN.match(name))
-
-
-def _sanitize_collection_name(
-    name: str | None, max_collection_length: int = MAX_COLLECTION_LENGTH
-) -> str:
-    """Sanitize a collection name to meet ChromaDB requirements.
-
-    Requirements:
-    1. 3-63 characters long
-    2. Starts and ends with alphanumeric character
-    3. Contains only alphanumeric characters, underscores, or hyphens
-    4. No consecutive periods
-    5. Not a valid IPv4 address
-
-    Args:
-        name: The original collection name to sanitize
-        max_collection_length: Maximum allowed length for the collection name
-
-    Returns:
-        A sanitized collection name that meets ChromaDB requirements
-    """
-    if not name:
-        return DEFAULT_COLLECTION
-
-    if _is_ipv4_pattern(name):
-        name = f"ip_{name}"
-
-    sanitized = INVALID_CHARS_PATTERN.sub("_", name)
-
-    if not sanitized[0].isalnum():
-        sanitized = "a" + sanitized
-
-    if not sanitized[-1].isalnum():
-        sanitized = sanitized[:-1] + "z"
-
-    if len(sanitized) < MIN_COLLECTION_LENGTH:
-        sanitized = sanitized + "x" * (MIN_COLLECTION_LENGTH - len(sanitized))
-    if len(sanitized) > max_collection_length:
-        sanitized = sanitized[:max_collection_length]
-        if not sanitized[-1].isalnum():
-            sanitized = sanitized[:-1] + "z"
-
-    return sanitized

src/crewai/rag/config/__init__.py

@@ -1 +0,0 @@
-"""RAG client configuration management using ContextVars for thread-safe provider switching."""

src/crewai/rag/config/base.py

@@ -1,16 +0,0 @@
-"""Base configuration class for RAG providers."""
-
-from dataclasses import field
-from typing import Any
-
-from pydantic.dataclasses import dataclass as pyd_dataclass
-
-from crewai.rag.config.optional_imports.types import SupportedProvider
-
-
-@pyd_dataclass(frozen=True)
-class BaseRagConfig:
-    """Base class for RAG configuration with Pydantic serialization support."""
-
-    provider: SupportedProvider = field(init=False)
-    embedding_function: Any | None = field(default=None)

src/crewai/rag/config/constants.py

@@ -1,8 +0,0 @@
-"""Constants for RAG configuration."""
-
-from typing import Final
-
-DISCRIMINATOR: Final[str] = "provider"
-
-DEFAULT_RAG_CONFIG_PATH: Final[str] = "crewai.rag.chromadb.config"
-DEFAULT_RAG_CONFIG_CLASS: Final[str] = "ChromaDBConfig"

src/crewai/rag/config/optional_imports/__init__.py

@@ -1 +0,0 @@
-"""Optional imports for RAG configuration providers."""

src/crewai/rag/config/optional_imports/base.py

@@ -1,26 +0,0 @@
-"""Base classes for missing provider configurations."""
-
-from typing import Literal
-from dataclasses import field
-
-from pydantic import ConfigDict
-from pydantic.dataclasses import dataclass as pyd_dataclass
-
-
-@pyd_dataclass(config=ConfigDict(extra="forbid"))
-class _MissingProvider:
-    """Base class for missing provider configurations.
-
-    Raises RuntimeError when instantiated to indicate missing dependencies.
-    """
-
-    provider: Literal["chromadb", "qdrant", "__missing__"] = field(
-        default="__missing__"
-    )
-
-    def __post_init__(self) -> None:
-        """Raises error indicating the provider is not installed."""
-        raise RuntimeError(
-            f"provider '{self.provider}' requested but not installed. "
-            f"Install the extra: `uv add crewai'[{self.provider}]'`."
-        )

src/crewai/rag/config/optional_imports/protocols.py

@@ -1,27 +0,0 @@
-"""Protocol definitions for RAG factory modules."""
-
-from __future__ import annotations
-
-from typing import Protocol, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from crewai.rag.chromadb.client import ChromaDBClient
-    from crewai.rag.chromadb.config import ChromaDBConfig
-    from crewai.rag.qdrant.client import QdrantClient
-    from crewai.rag.qdrant.config import QdrantConfig
-
-
-class ChromaFactoryModule(Protocol):
-    """Protocol for ChromaDB factory module."""
-
-    def create_client(self, config: ChromaDBConfig) -> ChromaDBClient:
-        """Creates a ChromaDB client from configuration."""
-        ...
-
-
-class QdrantFactoryModule(Protocol):
-    """Protocol for Qdrant factory module."""
-
-    def create_client(self, config: QdrantConfig) -> QdrantClient:
-        """Creates a Qdrant client from configuration."""
-        ...

src/crewai/rag/config/optional_imports/providers.py

@@ -1,22 +0,0 @@
-"""Provider-specific missing configuration classes."""
-
-from typing import Literal
-from dataclasses import field
-from pydantic import ConfigDict
-from pydantic.dataclasses import dataclass as pyd_dataclass
-
-from crewai.rag.config.optional_imports.base import _MissingProvider
-
-
-@pyd_dataclass(config=ConfigDict(extra="forbid"))
-class MissingChromaDBConfig(_MissingProvider):
-    """Placeholder for missing ChromaDB configuration."""
-
-    provider: Literal["chromadb"] = field(default="chromadb")
-
-
-@pyd_dataclass(config=ConfigDict(extra="forbid"))
-class MissingQdrantConfig(_MissingProvider):
-    """Placeholder for missing Qdrant configuration."""
-
-    provider: Literal["qdrant"] = field(default="qdrant")

src/crewai/rag/config/optional_imports/types.py

@@ -1,8 +0,0 @@
-"""Type definitions for optional imports."""
-
-from typing import Annotated, Literal
-
-SupportedProvider = Annotated[
-    Literal["chromadb", "qdrant"],
-    "Supported RAG provider types, add providers here as they become available",
-]

src/crewai/rag/config/types.py

@@ -1,34 +0,0 @@
-"""Type definitions for RAG configuration."""
-
-from typing import Annotated, TypeAlias, TYPE_CHECKING
-from pydantic import Field
-
-from crewai.rag.config.constants import DISCRIMINATOR
-
-# Linter freaks out on conditional imports, assigning in the type checking fixes it
-if TYPE_CHECKING:
-    from crewai.rag.chromadb.config import ChromaDBConfig as ChromaDBConfig_
-
-    ChromaDBConfig = ChromaDBConfig_
-    from crewai.rag.qdrant.config import QdrantConfig as QdrantConfig_
-
-    QdrantConfig = QdrantConfig_
-else:
-    try:
-        from crewai.rag.chromadb.config import ChromaDBConfig
-    except ImportError:
-        from crewai.rag.config.optional_imports.providers import (
-            MissingChromaDBConfig as ChromaDBConfig,
-        )
-
-    try:
-        from crewai.rag.qdrant.config import QdrantConfig
-    except ImportError:
-        from crewai.rag.config.optional_imports.providers import (
-            MissingQdrantConfig as QdrantConfig,
-        )
-
-SupportedProviderConfig: TypeAlias = ChromaDBConfig | QdrantConfig
-RagConfigType: TypeAlias = Annotated[
-    SupportedProviderConfig, Field(discriminator=DISCRIMINATOR)
-]