fix: restore typing imports to resolve F821 undefined name errors

- Add back Dict, List, Tuple, Type imports that are used throughout the code
- Consolidate duplicate imports in llm.py
- Match existing codebase patterns for type annotations
- Maintain quota limit handling functionality while fixing CI issues

Co-Authored-By: João <joao@crewai.com>

.github/workflows/linter.yml

@@ -15,8 +15,19 @@ jobs:
       - name: Fetch Target Branch
         run: git fetch origin $TARGET_BRANCH --depth=1
 
-      - name: Install Ruff
-        run: pip install ruff
+      - 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: Get Changed Python Files
         id: changed-files
@@ -33,4 +44,4 @@ jobs:
           echo "${{ steps.changed-files.outputs.files }}" \
             | tr ' ' '\n' \
             | grep -v 'src/crewai/cli/templates/' \
-            | xargs -I{} ruff check "{}"
+            | xargs -I{} uv run ruff check "{}"

.github/workflows/security-checker.yml

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

.github/workflows/type-checker.yml

@@ -6,21 +6,78 @@ permissions:
   contents: write
 
 jobs:
-  type-checker:
+  type-checker-matrix:
+    name: type-checker (${{ matrix.python-version }})
     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:
-          python-version: "3.11.9"
+          fetch-depth: 0  # Fetch all history for proper diff
 
-      - name: Install Requirements
+      - 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
         run: |
-          pip install mypy
+          # 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
+          
+          # 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
-        run: mypy src
+      - 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

.pre-commit-config.yaml

@@ -1,7 +1,14 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.8.2
+    rev: v0.12.11
     hooks:
       - id: ruff
-        args: ["--fix"]
+        args: ["--config", "pyproject.toml"]
       - 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

@@ -1,4 +0,0 @@
-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/landing_page_generator)
+- [Landing Page Generator](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/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/trip_planner)
-- [Stock Analysis](https://github.com/crewAIInc/crewAI-examples/tree/main/stock_analysis)
+- [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)
 
 ### 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/job-posting) or watch a video below:
+[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/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/trip_planner) or watch a video below:
+[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/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/stock_analysis) or watch a video below:
+[Check out code for this example](https://github.com/crewAIInc/crewAI-examples/tree/main/crews/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/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.utilities.events import (
+from crewai.events import (
     CrewKickoffStartedEvent,
     CrewKickoffCompletedEvent,
     AgentExecutionCompletedEvent,
 )
-from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.events import BaseEventListener
 
 class MyCustomListener(BaseEventListener):
     def __init__(self):
@@ -146,7 +146,7 @@ my_project/
 
 ```python
 # my_custom_listener.py
-from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.events 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.utilities.events import crewai_event_bus, CrewKickoffStartedEvent
+from crewai.events import crewai_event_bus, CrewKickoffStartedEvent
 
 with crewai_event_bus.scoped_handlers():
     @crewai_event_bus.on(CrewKickoffStartedEvent)

docs/en/concepts/knowledge.mdx

@@ -681,11 +681,11 @@ CrewAI emits events during the knowledge retrieval process that you can listen f
 #### Example: Monitoring Knowledge Retrieval
 
 ```python
-from crewai.utilities.events import (
+from crewai.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.utilities.events import (
+    from crewai.events import (
       LLMStreamChunkEvent
     )
-    from crewai.utilities.events.base_event_listener import BaseEventListener
+    from crewai.events 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.utilities.events import LLMStreamChunkEvent
-    from crewai.utilities.events.base_event_listener import BaseEventListener
+    from crewai.events import LLMStreamChunkEvent
+    from crewai.events import BaseEventListener
 
     class MyCustomListener(BaseEventListener):
         def setup_listeners(self, crewai_event_bus):

docs/en/concepts/memory.mdx

@@ -1041,8 +1041,8 @@ CrewAI emits the following memory-related events:
 Track memory operation timing to optimize your application:
 
 ```python
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events import (
+from crewai.events import (
+    BaseEventListener,
     MemoryQueryCompletedEvent,
     MemorySaveCompletedEvent
 )
@@ -1076,8 +1076,8 @@ memory_monitor = MemoryPerformanceMonitor()
 Log memory operations for debugging and insights:
 
 ```python
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events import (
+from crewai.events import (
+    BaseEventListener,
     MemorySaveStartedEvent,
     MemoryQueryStartedEvent,
     MemoryRetrievalCompletedEvent
@@ -1117,8 +1117,8 @@ memory_logger = MemoryLogger()
 Capture and respond to memory errors:
 
 ```python
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events import (
+from crewai.events import (
+    BaseEventListener,
     MemorySaveFailedEvent,
     MemoryQueryFailedEvent
 )
@@ -1167,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.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events import (
+from crewai.events import (
+    BaseEventListener,
     MemoryQueryCompletedEvent,
     MemorySaveCompletedEvent
 )

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.
+description: The `WeaviateVectorSearchTool` is designed to search a Weaviate vector database for semantically similar documents using hybrid search.
 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 embeddings 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 and keyword search 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,6 +39,7 @@ 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",
 )
@@ -63,6 +64,7 @@ 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`.
 
@@ -78,6 +80,7 @@ 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",
@@ -128,6 +131,7 @@ 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",
 )
@@ -145,6 +149,7 @@ 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.utilities.events import (
+from crewai.events import (
     CrewKickoffStartedEvent,
     CrewKickoffCompletedEvent,
     AgentExecutionCompletedEvent,
 )
-from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.events import BaseEventListener
 
 class MyCustomListener(BaseEventListener):
     def __init__(self):
@@ -146,7 +146,7 @@ my_project/
 
 ```python
 # my_custom_listener.py
-from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.events import BaseEventListener
 # ... import events ...
 
 class MyCustomListener(BaseEventListener):
@@ -279,7 +279,7 @@ CrewAI는 여러분이 청취할 수 있는 다양한 이벤트를 제공합니
 임시 이벤트 처리가 필요한 경우(테스트 또는 특정 작업에 유용함), `scoped_handlers` 컨텍스트 관리자를 사용할 수 있습니다:
 
 ```python
-from crewai.utilities.events import crewai_event_bus, CrewKickoffStartedEvent
+from crewai.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.utilities.events import (
+from crewai.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.utilities.events import (
+    from crewai.events import (
       LLMStreamChunkEvent
     )
-    from crewai.utilities.events.base_event_listener import BaseEventListener
+    from crewai.events 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.utilities.events import LLMStreamChunkEvent
-    from crewai.utilities.events.base_event_listener import BaseEventListener
+    from crewai.events import LLMStreamChunkEvent
+    from crewai.events 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.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events import (
+from crewai.events import (
+    BaseEventListener,
     MemoryQueryCompletedEvent,
     MemorySaveCompletedEvent
 )
@@ -1020,8 +1020,8 @@ memory_monitor = MemoryPerformanceMonitor()
 디버깅 및 인사이트를 위해 메모리 작업을 로깅합니다:
 
 ```python
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events import (
+from crewai.events import (
+    BaseEventListener,
     MemorySaveStartedEvent,
     MemoryQueryStartedEvent,
     MemoryRetrievalCompletedEvent
@@ -1061,8 +1061,8 @@ memory_logger = MemoryLogger()
 메모리 오류를 캡처하고 대응합니다:
 
 ```python
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events import (
+from crewai.events import (
+    BaseEventListener,
     MemorySaveFailedEvent,
     MemoryQueryFailedEvent
 )
@@ -1111,8 +1111,8 @@ error_tracker = MemoryErrorTracker(notify_email="admin@example.com")
 메모리 이벤트는 분석 및 모니터링 플랫폼으로 전달되어 성능 지표를 추적하고, 이상 징후를 감지하며, 메모리 사용 패턴을 시각화할 수 있습니다:
 
 ```python
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events import (
+from crewai.events import (
+    BaseEventListener,
     MemoryQueryCompletedEvent,
     MemorySaveCompletedEvent
 )

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.utilities.events import (
+from crewai.events import (
     CrewKickoffStartedEvent,
     CrewKickoffCompletedEvent,
     AgentExecutionCompletedEvent,
 )
-from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.events import BaseEventListener
 
 class MeuListenerPersonalizado(BaseEventListener):
     def __init__(self):
@@ -146,7 +146,7 @@ my_project/
 
 ```python
 # my_custom_listener.py
-from crewai.utilities.events.base_event_listener import BaseEventListener
+from crewai.events 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.utilities.events import crewai_event_bus, CrewKickoffStartedEvent
+from crewai.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.utilities.events import (
+from crewai.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.utilities.events import (
+    from crewai.events import (
       LLMStreamChunkEvent
     )
-    from crewai.utilities.events.base_event_listener import BaseEventListener
+    from crewai.events import BaseEventListener
 
     class MyCustomListener(BaseEventListener):
         def setup_listeners(self, crewai_event_bus):

pyproject.toml

@@ -48,7 +48,7 @@ Documentation = "https://docs.crewai.com"
 Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
-tools = ["crewai-tools~=0.62.1"]
+tools = ["crewai-tools~=0.65.0"]
 embeddings = [
     "tiktoken~=0.8.0"
 ]
@@ -74,9 +74,10 @@ qdrant = [
 
 [tool.uv]
 dev-dependencies = [
-    "ruff>=0.8.2",
-    "mypy>=1.10.0",
-    "pre-commit>=3.6.0",
+    "ruff>=0.12.11",
+    "mypy>=1.17.1",
+    "pre-commit>=4.3.0",
+    "bandit>=1.8.6",
     "pillow>=10.2.0",
     "cairosvg>=2.7.1",
     "pytest>=8.0.0",
@@ -88,15 +89,43 @@ 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",
+    "UP040",
+    "UP004",
+    "UP008",
+    "UP010",
+    "UP018",
+    "UP031",
+    "UP032",
+    "UP034",
+    "I001",
+    "I002",
+]
+
 [tool.mypy]
-ignore_missing_imports = true
-disable_error_code = 'import-untyped'
-exclude = ["cli/templates"]
+strict = true
+exclude = ["src/crewai/cli/templates"]
 
 [tool.bandit]
 exclude_dirs = ["src/crewai/cli/templates"]

src/crewai/__init__.py

@@ -54,7 +54,7 @@ def _track_install_async():
 
 _track_install_async()
 
-__version__ = "0.165.1"
+__version__ = "0.175.0"
 __all__ = [
     "Agent",
     "Crew",

src/crewai/agent.py

@@ -3,16 +3,15 @@ import subprocess
 import time
 from typing import (
     Any,
-    Callable,
     Dict,
     List,
     Literal,
     Optional,
-    Sequence,
     Tuple,
     Type,
     Union,
 )
+from collections.abc import Callable, Sequence
 
 from pydantic import Field, InstanceOf, PrivateAttr, model_validator
 
@@ -38,17 +37,21 @@ 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.utilities.events.agent_events import (
+from crewai.events.types.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionErrorEvent,
     AgentExecutionStartedEvent,
 )
-from crewai.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.memory_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
     MemoryRetrievalStartedEvent,
     MemoryRetrievalCompletedEvent,
 )
-from crewai.utilities.events.knowledge_events import (
+from crewai.utilities.exceptions import (
+    LLMContextLengthExceededException,
+    LLMQuotaLimitExceededException,
+)
+from crewai.events.types.knowledge_events import (
     KnowledgeQueryCompletedEvent,
     KnowledgeQueryFailedEvent,
     KnowledgeQueryStartedEvent,
@@ -461,6 +464,26 @@ class Agent(BaseAgent):
                 ),
             )
             raise e
+        except LLMContextLengthExceededException as e:
+            crewai_event_bus.emit(
+                self,
+                event=AgentExecutionErrorEvent(
+                    agent=self,
+                    task=task,
+                    error=str(e),
+                ),
+            )
+            raise e
+        except LLMQuotaLimitExceededException as e:
+            crewai_event_bus.emit(
+                self,
+                event=AgentExecutionErrorEvent(
+                    agent=self,
+                    task=task,
+                    error=str(e),
+                ),
+            )
+            raise e
         except Exception as e:
             if e.__class__.__module__.startswith("litellm"):
                 # Do not retry on litellm errors

src/crewai/agents/__init__.py

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

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

@@ -1,4 +1,4 @@
-from typing import Any, AsyncIterable, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from pydantic import Field, PrivateAttr
 
@@ -14,15 +14,14 @@ 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.utilities.events import crewai_event_bus
-from crewai.utilities.events.agent_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.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.utilities.events import crewai_event_bus
-from crewai.utilities.events.agent_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.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.utilities.events.event_listener import event_listener
+from crewai.events.event_listener import event_listener
 
 if TYPE_CHECKING:
     from crewai.agents.agent_builder.base_agent import BaseAgent
@@ -98,8 +98,8 @@ class CrewAgentExecutorMixin:
                 )
                 self.crew._long_term_memory.save(long_term_memory)
 
-                for entity in evaluation.entities:
-                    entity_memory = EntityMemoryItem(
+                entity_memories = [
+                    EntityMemoryItem(
                         name=entity.name,
                         type=entity.type,
                         description=entity.description,
@@ -107,7 +107,10 @@ class CrewAgentExecutorMixin:
                             [f"- {r}" for r in entity.relationships]
                         ),
                     )
-                    self.crew._entity_memory.save(entity_memory)
+                    for entity in evaluation.entities
+                ]
+                if entity_memories:
+                    self.crew._entity_memory.save(entity_memories)
             except AttributeError as e:
                 print(f"Missing attributes for long term memory: {e}")
                 pass

src/crewai/agents/constants.py

@@ -0,0 +1,27 @@
+"""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

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
+from collections.abc import Callable
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.agents.agent_builder.base_agent_executor_mixin import CrewAgentExecutorMixin
@@ -30,11 +31,15 @@ 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.utilities.events.agent_events import (
+from crewai.events.types.logging_events import (
     AgentLogsStartedEvent,
     AgentLogsExecutionEvent,
 )
-from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.events.event_bus import crewai_event_bus
+from crewai.utilities.exceptions import (
+    LLMContextLengthExceededException,
+    LLMQuotaLimitExceededException,
+)
 
 
 class CrewAgentExecutor(CrewAgentExecutorMixin):
@@ -54,11 +59,11 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         tools_description: str,
         tools_handler: ToolsHandler,
         step_callback: Any = None,
-        original_tools: List[Any] = [],
+        original_tools: List[Any] | None = None,
         function_calling_llm: Any = None,
         respect_context_window: bool = False,
         request_within_rpm_limit: Optional[Callable[[], bool]] = None,
-        callbacks: List[Any] = [],
+        callbacks: List[Any] | None = None,
     ):
         self._i18n: I18N = I18N()
         self.llm: BaseLLM = llm
@@ -70,10 +75,10 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         self.tools_names = tools_names
         self.stop = stop_words
         self.max_iter = max_iter
-        self.callbacks = callbacks
+        self.callbacks = callbacks or []
         self._printer: Printer = Printer()
         self.tools_handler = tools_handler
-        self.original_tools = original_tools
+        self.original_tools = original_tools or []
         self.step_callback = step_callback
         self.use_stop_words = self.llm.supports_stop_words()
         self.tools_description = tools_description
@@ -122,7 +127,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             handle_unknown_error(self._printer, e)
             raise
 
-
         if self.ask_for_human_input:
             formatted_answer = self._handle_human_feedback(formatted_answer)
 
@@ -156,7 +160,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)
 
@@ -202,6 +206,10 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     printer=self._printer,
                 )
 
+            except LLMContextLengthExceededException as e:
+                raise e
+            except LLMQuotaLimitExceededException as e:
+                raise e
             except Exception as e:
                 if e.__class__.__module__.startswith("litellm"):
                     # Do not retry on litellm errors

src/crewai/agents/parser.py

@@ -1,50 +1,67 @@
-import re
-from typing import Any, Optional, Union
+"""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
 
 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
 
-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"
+_I18N = I18N()
 
 
+@dataclass
 class AgentAction:
+    """Represents an action to be taken by an agent."""
+
     thought: str
     tool: str
     tool_input: str
     text: str
-    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
+    result: str | None = None
 
 
+@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):
-    error: str
+    """Exception raised when output parsing fails.
 
-    def __init__(self, error: str):
+    Attributes:
+        error: The error message.
+    """
+
+    def __init__(self, error: str) -> None:
+        """Initialize OutputParserException.
+
+        Args:
+            error: The error message.
+        """
         self.error = error
+        super().__init__(error)
 
 
-class CrewAgentParser:
-    """Parses ReAct-style LLM calls that have a single tool input.
+def parse(text: str) -> AgentAction | AgentFinish:
+    """Parse agent output text into AgentAction or AgentFinish.
 
     Expects output to be in one of two formats.
 
@@ -62,108 +79,117 @@ class CrewAgentParser:
 
     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)
 
-    _i18n: I18N = I18N()
-    agent: Any = None
+    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)
 
-    def __init__(self, agent: Optional[Any] = None):
-        self.agent = agent
+    elif action_match:
+        action = action_match.group(1)
+        clean_action = _clean_action(action)
 
-    @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.
+        action_input = action_match.group(2).strip()
 
-        Args:
-            text: The text to parse.
+        tool_input = action_input.strip(" ").strip('"')
+        safe_tool_input = _safe_repair_json(tool_input)
 
-        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]*(.*)"
+        return AgentAction(
+            thought=thought, tool=clean_action, tool_input=safe_tool_input, text=text
         )
-        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)
 
-        elif action_match:
-            action = action_match.group(1)
-            clean_action = self._clean_action(action)
+    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,
+        )
 
-            action_input = action_match.group(2).strip()
 
-            tool_input = action_input.strip(" ").strip('"')
-            safe_tool_input = self._safe_repair_json(tool_input)
+def _extract_thought(text: str) -> str:
+    """Extract the thought portion from the text.
 
-            return AgentAction(thought, clean_action, safe_tool_input, text)
+    Args:
+        text: The full agent output text.
 
-        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,
-            )
+    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
 
-    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(self, text: str) -> str:
-        """Clean action string by removing non-essential formatting characters."""
-        return text.strip().strip("*").strip()
+def _clean_action(text: str) -> str:
+    """Clean action string by removing non-essential formatting characters.
 
-    def _safe_repair_json(self, tool_input: str) -> str:
-        UNABLE_TO_REPAIR_JSON_RESULTS = ['""', "{}"]
+    Args:
+        text: The action text to clean.
 
-        # 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
+    Returns:
+        The cleaned action string.
+    """
+    return text.strip().strip("*").strip()
 
-        # Before repair, handle common LLM issues:
-        # 1. Replace """ with " to avoid JSON parser errors
 
-        tool_input = tool_input.replace('"""', '"')
+def _safe_repair_json(tool_input: str) -> str:
+    """Safely repair JSON input.
 
-        result = repair_json(tool_input)
-        if result in UNABLE_TO_REPAIR_JSON_RESULTS:
-            return tool_input
+    Args:
+        tool_input: The tool input string to repair.
 
-        return str(result)
+    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)

src/crewai/agents/tools_handler.py

@@ -1,29 +1,41 @@
-from typing import Any, Optional, Union
+"""Tools handler for managing tool execution and caching."""
 
-from ..tools.cache_tools.cache_tools import CacheTools
-from ..tools.tool_calling import InstructorToolCalling, ToolCalling
-from .cache.cache_handler import CacheHandler
+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
 
 
 class ToolsHandler:
-    """Callback handler for tool usage."""
+    """Callback handler for tool usage.
 
-    last_used_tool: Optional[ToolCalling] = None
-    cache: Optional[CacheHandler]
+    Attributes:
+        last_used_tool: The most recently used tool calling instance.
+        cache: Optional cache handler for storing tool outputs.
+    """
 
-    def __init__(self, cache: Optional[CacheHandler] = None):
-        """Initialize the callback handler."""
-        self.cache = cache
-        self.last_used_tool = None
+    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 on_tool_use(
         self,
-        calling: Union[ToolCalling, InstructorToolCalling],
+        calling: ToolCalling | InstructorToolCalling,
         output: str,
         should_cache: bool = True,
-    ) -> 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")
+    ) -> 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
         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,6 +1 @@
 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

@@ -9,14 +9,7 @@ from pydantic import BaseModel, Field
 
 from .utils import validate_jwt_token
 from crewai.cli.shared.token_manager import TokenManager
-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()
 
@@ -72,18 +65,6 @@ 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)
 
@@ -206,30 +187,3 @@ 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/plus_api.py

@@ -119,12 +119,17 @@ class PlusAPI:
 
     def initialize_trace_batch(self, payload) -> requests.Response:
         return self._make_request(
-            "POST", f"{self.TRACING_RESOURCE}/batches", json=payload
+            "POST",
+            f"{self.TRACING_RESOURCE}/batches",
+            json=payload,
+            timeout=30,
         )
 
     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:
@@ -150,6 +155,7 @@ class PlusAPI:
             "PATCH",
             f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
             json=payload,
+            timeout=30,
         )
 
     def finalize_ephemeral_trace_batch(
@@ -159,4 +165,5 @@ class PlusAPI:
             "PATCH",
             f"{self.EPHEMERAL_TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
             json=payload,
+            timeout=30,
         )

src/crewai/cli/settings/main.py

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

src/crewai/cli/shared/token_manager.py

@@ -56,6 +56,8 @@ class TokenManager:
         :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)

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.165.1,<1.0.0"
+    "crewai[tools]>=0.175.0,<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.165.1,<1.0.0",
+    "crewai[tools]>=0.175.0,<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.165.1"
+    "crewai[tools]>=0.175.0"
 ]
 
 [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.utilities.events.crew_events import (
+from crewai.events.types.crew_events import (
     CrewKickoffCompletedEvent,
     CrewKickoffFailedEvent,
     CrewKickoffStartedEvent,
@@ -70,14 +70,14 @@ from crewai.utilities.events.crew_events import (
     CrewTrainFailedEvent,
     CrewTrainStartedEvent,
 )
-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 (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.event_listener import EventListener
+from crewai.events.listeners.tracing.trace_listener import (
     TraceCollectionListener,
 )
 
 
-from crewai.utilities.events.listeners.tracing.utils import (
+from crewai.events.listeners.tracing.utils import (
     is_tracing_enabled,
 )
 from crewai.utilities.formatter import (
@@ -559,9 +559,10 @@ class Crew(FlowTrackable, BaseModel):
         CrewTrainingHandler(filename).initialize_file()
 
     def train(
-        self, n_iterations: int, filename: str, inputs: Optional[Dict[str, Any]] = {}
+        self, n_iterations: int, filename: str, inputs: Optional[Dict[str, Any]] = None
     ) -> None:
         """Trains the crew for a given number of iterations."""
+        inputs = inputs or {}
         try:
             crewai_event_bus.emit(
                 self,
@@ -702,8 +703,11 @@ class Crew(FlowTrackable, BaseModel):
         self._task_output_handler.reset()
         return results
 
-    async def kickoff_async(self, inputs: Optional[Dict[str, Any]] = {}) -> CrewOutput:
+    async def kickoff_async(
+        self, inputs: Optional[Dict[str, Any]] = None
+    ) -> 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

@@ -0,0 +1,56 @@
+"""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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,117 @@
+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/event_listener.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from io import StringIO
 from typing import Any, Dict
 
@@ -7,8 +9,8 @@ from crewai.task import Task
 from crewai.telemetry.telemetry import Telemetry
 from crewai.utilities import Logger
 from crewai.utilities.constants import EMITTER_COLOR
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events.knowledge_events import (
+from crewai.events.base_event_listener import BaseEventListener
+from crewai.events.types.knowledge_events import (
     KnowledgeQueryCompletedEvent,
     KnowledgeQueryFailedEvent,
     KnowledgeQueryStartedEvent,
@@ -16,28 +18,30 @@ from crewai.utilities.events.knowledge_events import (
     KnowledgeRetrievalStartedEvent,
     KnowledgeSearchQueryFailedEvent,
 )
-from crewai.utilities.events.llm_events import (
+from crewai.events.types.llm_events import (
     LLMCallCompletedEvent,
     LLMCallFailedEvent,
     LLMCallStartedEvent,
     LLMStreamChunkEvent,
 )
-from crewai.utilities.events.llm_guardrail_events import (
+from crewai.events.types.llm_guardrail_events import (
     LLMGuardrailStartedEvent,
     LLMGuardrailCompletedEvent,
 )
-from crewai.utilities.events.utils.console_formatter import ConsoleFormatter
+from crewai.events.utils.console_formatter import ConsoleFormatter
 
-from .agent_events import (
+from crewai.events.types.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionStartedEvent,
-    AgentLogsStartedEvent,
-    AgentLogsExecutionEvent,
     LiteAgentExecutionCompletedEvent,
     LiteAgentExecutionErrorEvent,
     LiteAgentExecutionStartedEvent,
 )
-from .crew_events import (
+from crewai.events.types.logging_events import (
+    AgentLogsStartedEvent,
+    AgentLogsExecutionEvent,
+)
+from crewai.events.types.crew_events import (
     CrewKickoffCompletedEvent,
     CrewKickoffFailedEvent,
     CrewKickoffStartedEvent,
@@ -49,7 +53,7 @@ from .crew_events import (
     CrewTrainFailedEvent,
     CrewTrainStartedEvent,
 )
-from .flow_events import (
+from .types.flow_events import (
     FlowCreatedEvent,
     FlowFinishedEvent,
     FlowStartedEvent,
@@ -57,13 +61,13 @@ from .flow_events import (
     MethodExecutionFinishedEvent,
     MethodExecutionStartedEvent,
 )
-from .task_events import TaskCompletedEvent, TaskFailedEvent, TaskStartedEvent
-from .tool_usage_events import (
+from .types.task_events import TaskCompletedEvent, TaskFailedEvent, TaskStartedEvent
+from .types.tool_usage_events import (
     ToolUsageErrorEvent,
     ToolUsageFinishedEvent,
     ToolUsageStartedEvent,
 )
-from .reasoning_events import (
+from .types.reasoning_events import (
     AgentReasoningStartedEvent,
     AgentReasoningCompletedEvent,
     AgentReasoningFailedEvent,
@@ -162,7 +166,7 @@ class EventListener(BaseEventListener):
             span = self._telemetry.task_started(crew=source.agent.crew, task=source)
             self.execution_spans[source] = span
             # Pass both task ID and task name (if set)
-            task_name = source.name if hasattr(source, 'name') and source.name else None
+            task_name = source.name if hasattr(source, "name") and source.name else None
             self.formatter.create_task_branch(
                 self.formatter.current_crew_tree, source.id, task_name
             )
@@ -176,13 +180,13 @@ class EventListener(BaseEventListener):
             self.execution_spans[source] = None
 
             # Pass task name if it exists
-            task_name = source.name if hasattr(source, 'name') and source.name else None
+            task_name = source.name if hasattr(source, "name") and source.name else None
             self.formatter.update_task_status(
                 self.formatter.current_crew_tree,
                 source.id,
                 source.agent.role,
                 "completed",
-                task_name
+                task_name,
             )
 
         @crewai_event_bus.on(TaskFailedEvent)
@@ -194,13 +198,13 @@ class EventListener(BaseEventListener):
                 self.execution_spans[source] = None
 
             # Pass task name if it exists
-            task_name = source.name if hasattr(source, 'name') and source.name else None
+            task_name = source.name if hasattr(source, "name") and source.name else None
             self.formatter.update_task_status(
                 self.formatter.current_crew_tree,
                 source.id,
                 source.agent.role,
                 "failed",
-                task_name
+                task_name,
             )
 
         # ----------- AGENT EVENTS -----------

src/crewai/events/event_types.py

@@ -1,12 +1,12 @@
 from typing import Union
 
-from .agent_events import (
+from crewai.events.types.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionErrorEvent,
     AgentExecutionStartedEvent,
     LiteAgentExecutionCompletedEvent,
 )
-from .crew_events import (
+from .types.crew_events import (
     CrewKickoffCompletedEvent,
     CrewKickoffFailedEvent,
     CrewKickoffStartedEvent,
@@ -17,39 +17,39 @@ from .crew_events import (
     CrewTrainFailedEvent,
     CrewTrainStartedEvent,
 )
-from .flow_events import (
+from .types.flow_events import (
     FlowFinishedEvent,
     FlowStartedEvent,
     MethodExecutionFailedEvent,
     MethodExecutionFinishedEvent,
     MethodExecutionStartedEvent,
 )
-from .llm_events import (
+from .types.llm_events import (
     LLMCallCompletedEvent,
     LLMCallFailedEvent,
     LLMCallStartedEvent,
     LLMStreamChunkEvent,
 )
-from .llm_guardrail_events import (
+from .types.llm_guardrail_events import (
     LLMGuardrailCompletedEvent,
     LLMGuardrailStartedEvent,
 )
-from .task_events import (
+from .types.task_events import (
     TaskCompletedEvent,
     TaskFailedEvent,
     TaskStartedEvent,
 )
-from .tool_usage_events import (
+from .types.tool_usage_events import (
     ToolUsageErrorEvent,
     ToolUsageFinishedEvent,
     ToolUsageStartedEvent,
 )
-from .reasoning_events import (
+from .types.reasoning_events import (
     AgentReasoningStartedEvent,
     AgentReasoningCompletedEvent,
     AgentReasoningFailedEvent,
 )
-from .knowledge_events import (
+from .types.knowledge_events import (
     KnowledgeRetrievalStartedEvent,
     KnowledgeRetrievalCompletedEvent,
     KnowledgeQueryStartedEvent,
@@ -58,7 +58,7 @@ from .knowledge_events import (
     KnowledgeSearchQueryFailedEvent,
 )
 
-from .memory_events import (
+from .types.memory_events import (
     MemorySaveStartedEvent,
     MemorySaveCompletedEvent,
     MemorySaveFailedEvent,

src/crewai/events/listeners/__init__.py

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

src/crewai/events/listeners/memory_listener.py

@@ -1,5 +1,5 @@
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events.memory_events import (
+from crewai.events.base_event_listener import BaseEventListener
+from crewai.events.types.memory_events import (
     MemoryRetrievalCompletedEvent,
     MemoryRetrievalStartedEvent,
     MemoryQueryFailedEvent,
@@ -9,8 +9,8 @@ from crewai.utilities.events.memory_events import (
     MemorySaveFailedEvent,
 )
 
-class MemoryListener(BaseEventListener):
 
+class MemoryListener(BaseEventListener):
     def __init__(self, formatter):
         super().__init__()
         self.formatter = formatter
@@ -19,9 +19,7 @@ class MemoryListener(BaseEventListener):
 
     def setup_listeners(self, crewai_event_bus):
         @crewai_event_bus.on(MemoryRetrievalStartedEvent)
-        def on_memory_retrieval_started(
-            source, event: MemoryRetrievalStartedEvent
-        ):
+        def on_memory_retrieval_started(source, event: MemoryRetrievalStartedEvent):
             if self.memory_retrieval_in_progress:
                 return
 
@@ -33,9 +31,7 @@ class MemoryListener(BaseEventListener):
             )
 
         @crewai_event_bus.on(MemoryRetrievalCompletedEvent)
-        def on_memory_retrieval_completed(
-            source, event: MemoryRetrievalCompletedEvent
-        ):
+        def on_memory_retrieval_completed(source, event: MemoryRetrievalCompletedEvent):
             if not self.memory_retrieval_in_progress:
                 return
 
@@ -44,7 +40,7 @@ class MemoryListener(BaseEventListener):
                 self.formatter.current_agent_branch,
                 self.formatter.current_crew_tree,
                 event.memory_content,
-                event.retrieval_time_ms
+                event.retrieval_time_ms,
             )
 
         @crewai_event_bus.on(MemoryQueryCompletedEvent)
@@ -107,4 +103,4 @@ class MemoryListener(BaseEventListener):
                 event.error,
                 event.source_type,
                 self.formatter.current_crew_tree,
-            )
+            )

src/crewai/events/listeners/tracing/trace_batch_manager.py

@@ -11,7 +11,7 @@ from crewai.cli.plus_api import PlusAPI
 from rich.console import Console
 from rich.panel import Panel
 
-from crewai.utilities.events.listeners.tracing.types import TraceEvent
+from crewai.events.listeners.tracing.types import TraceEvent
 from logging import getLogger
 
 logger = getLogger(__name__)
@@ -50,7 +50,9 @@ class TraceBatchManager:
 
     def __init__(self):
         try:
-            self.plus_api = PlusAPI(api_key=get_auth_token())
+            self.plus_api = PlusAPI(
+                api_key=get_auth_token(),
+            )
         except AuthError:
             self.plus_api = PlusAPI(api_key="")
 
@@ -114,7 +116,13 @@ class TraceBatchManager:
                 else self.plus_api.initialize_trace_batch(payload)
             )
 
-            if response.status_code == 201 or response.status_code == 200:
+            if response is None:
+                logger.warning(
+                    "Trace batch initialization failed gracefully. Continuing without tracing."
+                )
+                return
+
+            if response.status_code in [201, 200]:
                 response_data = response.json()
                 self.trace_batch_id = (
                     response_data["trace_id"]
@@ -129,21 +137,23 @@ class TraceBatchManager:
                 )
                 console.print(panel)
             else:
-                logger.error(
-                    f"❌ Failed to initialize trace batch: {response.status_code} - {response.text}"
+                logger.warning(
+                    f"Trace batch initialization returned status {response.status_code}. Continuing without tracing."
                 )
 
         except Exception as e:
-            logger.error(f"❌ Error initializing trace batch: {str(e)}")
+            logger.warning(
+                f"Error initializing trace batch: {str(e)}. Continuing without tracing."
+            )
 
     def add_event(self, trace_event: TraceEvent):
         """Add event to buffer"""
         self.event_buffer.append(trace_event)
 
-    def _send_events_to_backend(self):
-        """Send buffered events to backend"""
+    def _send_events_to_backend(self) -> int:
+        """Send buffered events to backend with graceful failure handling"""
         if not self.plus_api or not self.trace_batch_id or not self.event_buffer:
-            return
+            return 500
 
         try:
             payload = {
@@ -155,24 +165,30 @@ class TraceBatchManager:
                 },
             }
 
-            if not self.trace_batch_id:
-                raise Exception("❌ Trace batch ID not found")
-
             response = (
                 self.plus_api.send_ephemeral_trace_events(self.trace_batch_id, payload)
                 if self.is_current_batch_ephemeral
                 else self.plus_api.send_trace_events(self.trace_batch_id, payload)
             )
 
-            if response.status_code == 200 or response.status_code == 201:
+            if response is None:
+                logger.warning("Failed to send trace events. Events will be lost.")
+                return 500
+
+            if response.status_code in [200, 201]:
                 self.event_buffer.clear()
+                return 200
             else:
-                logger.error(
-                    f"❌ Failed to send events: {response.status_code} - {response.text}"
+                logger.warning(
+                    f"Failed to send events: {response.status_code}. Events will be lost."
                 )
+                return 500
 
         except Exception as e:
-            logger.error(f"❌ Error sending events to backend: {str(e)}")
+            logger.warning(
+                f"Error sending events to backend: {str(e)}. Events will be lost."
+            )
+            return 500
 
     def finalize_batch(self) -> Optional[TraceBatch]:
         """Finalize batch and return it for sending"""
@@ -181,7 +197,9 @@ class TraceBatchManager:
 
         self.current_batch.events = self.event_buffer.copy()
         if self.event_buffer:
-            self._send_events_to_backend()
+            events_sent_to_backend_status = self._send_events_to_backend()
+            if events_sent_to_backend_status == 500:
+                return None
         self._finalize_backend_batch()
 
         finalized_batch = self.current_batch

src/crewai/events/listeners/tracing/trace_listener.py

@@ -3,8 +3,8 @@ import uuid
 
 from typing import Dict, Any, Optional
 
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events.agent_events import (
+from crewai.events.base_event_listener import BaseEventListener
+from crewai.events.types.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionStartedEvent,
     LiteAgentExecutionStartedEvent,
@@ -12,34 +12,34 @@ from crewai.utilities.events.agent_events import (
     LiteAgentExecutionErrorEvent,
     AgentExecutionErrorEvent,
 )
-from crewai.utilities.events.listeners.tracing.types import TraceEvent
-from crewai.utilities.events.reasoning_events import (
+from crewai.events.listeners.tracing.types import TraceEvent
+from crewai.events.types.reasoning_events import (
     AgentReasoningStartedEvent,
     AgentReasoningCompletedEvent,
     AgentReasoningFailedEvent,
 )
-from crewai.utilities.events.crew_events import (
+from crewai.events.types.crew_events import (
     CrewKickoffCompletedEvent,
     CrewKickoffFailedEvent,
     CrewKickoffStartedEvent,
 )
-from crewai.utilities.events.task_events import (
+from crewai.events.types.task_events import (
     TaskCompletedEvent,
     TaskFailedEvent,
     TaskStartedEvent,
 )
-from crewai.utilities.events.tool_usage_events import (
+from crewai.events.types.tool_usage_events import (
     ToolUsageErrorEvent,
     ToolUsageFinishedEvent,
     ToolUsageStartedEvent,
 )
-from crewai.utilities.events.llm_events import (
+from crewai.events.types.llm_events import (
     LLMCallCompletedEvent,
     LLMCallFailedEvent,
     LLMCallStartedEvent,
 )
 
-from crewai.utilities.events.flow_events import (
+from crewai.events.types.flow_events import (
     FlowCreatedEvent,
     FlowStartedEvent,
     FlowFinishedEvent,
@@ -48,7 +48,7 @@ from crewai.utilities.events.flow_events import (
     MethodExecutionFailedEvent,
     FlowPlotEvent,
 )
-from crewai.utilities.events.llm_guardrail_events import (
+from crewai.events.types.llm_guardrail_events import (
     LLMGuardrailStartedEvent,
     LLMGuardrailCompletedEvent,
 )
@@ -57,7 +57,7 @@ from crewai.utilities.serialization import to_serializable
 
 from .trace_batch_manager import TraceBatchManager
 
-from crewai.utilities.events.memory_events import (
+from crewai.events.types.memory_events import (
     MemoryQueryStartedEvent,
     MemoryQueryCompletedEvent,
     MemoryQueryFailedEvent,

src/crewai/events/types/__init__.py

@@ -0,0 +1,5 @@
+"""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/agent_events.py

@@ -1,13 +1,15 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union
+"""Agent-related events moved to break circular dependencies."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Sequence, Union
+
+from pydantic import model_validator
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.tools.base_tool import BaseTool
 from crewai.tools.structured_tool import CrewStructuredTool
-
-from .base_events import BaseEvent
-
-if TYPE_CHECKING:
-    from crewai.agents.agent_builder.base_agent import BaseAgent
+from crewai.events.base_events import BaseEvent
 
 
 class AgentExecutionStartedEvent(BaseEvent):
@@ -21,9 +23,9 @@ class AgentExecutionStartedEvent(BaseEvent):
 
     model_config = {"arbitrary_types_allowed": True}
 
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the agent
+    @model_validator(mode="after")
+    def set_fingerprint_data(self):
+        """Set fingerprint data from the agent if available."""
         if hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
             self.source_fingerprint = self.agent.fingerprint.uuid_str
             self.source_type = "agent"
@@ -32,6 +34,7 @@ class AgentExecutionStartedEvent(BaseEvent):
                 and self.agent.fingerprint.metadata
             ):
                 self.fingerprint_metadata = self.agent.fingerprint.metadata
+        return self
 
 
 class AgentExecutionCompletedEvent(BaseEvent):
@@ -42,9 +45,11 @@ class AgentExecutionCompletedEvent(BaseEvent):
     output: str
     type: str = "agent_execution_completed"
 
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the agent
+    model_config = {"arbitrary_types_allowed": True}
+
+    @model_validator(mode="after")
+    def set_fingerprint_data(self):
+        """Set fingerprint data from the agent if available."""
         if hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
             self.source_fingerprint = self.agent.fingerprint.uuid_str
             self.source_type = "agent"
@@ -53,6 +58,7 @@ class AgentExecutionCompletedEvent(BaseEvent):
                 and self.agent.fingerprint.metadata
             ):
                 self.fingerprint_metadata = self.agent.fingerprint.metadata
+        return self
 
 
 class AgentExecutionErrorEvent(BaseEvent):
@@ -63,9 +69,11 @@ class AgentExecutionErrorEvent(BaseEvent):
     error: str
     type: str = "agent_execution_error"
 
-    def __init__(self, **data):
-        super().__init__(**data)
-        # Set fingerprint data from the agent
+    model_config = {"arbitrary_types_allowed": True}
+
+    @model_validator(mode="after")
+    def set_fingerprint_data(self):
+        """Set fingerprint data from the agent if available."""
         if hasattr(self.agent, "fingerprint") and self.agent.fingerprint:
             self.source_fingerprint = self.agent.fingerprint.uuid_str
             self.source_type = "agent"
@@ -74,6 +82,7 @@ class AgentExecutionErrorEvent(BaseEvent):
                 and self.agent.fingerprint.metadata
             ):
                 self.fingerprint_metadata = self.agent.fingerprint.metadata
+        return self
 
 
 # New event classes for LiteAgent
@@ -104,26 +113,6 @@ class LiteAgentExecutionErrorEvent(BaseEvent):
     type: str = "lite_agent_execution_error"
 
 
-# New logging events
-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}
-
 # Agent Eval events
 class AgentEvaluationStartedEvent(BaseEvent):
     agent_id: str
@@ -132,6 +121,7 @@ class AgentEvaluationStartedEvent(BaseEvent):
     iteration: int
     type: str = "agent_evaluation_started"
 
+
 class AgentEvaluationCompletedEvent(BaseEvent):
     agent_id: str
     agent_role: str
@@ -141,6 +131,7 @@ class AgentEvaluationCompletedEvent(BaseEvent):
     score: Any
     type: str = "agent_evaluation_completed"
 
+
 class AgentEvaluationFailedEvent(BaseEvent):
     agent_id: str
     agent_role: str

src/crewai/events/types/crew_events.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Any, Dict, Optional, Union
 
-from crewai.utilities.events.base_events import BaseEvent
+from crewai.events.base_events import BaseEvent
 
 if TYPE_CHECKING:
     from crewai.crew import Crew

src/crewai/events/types/flow_events.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, Optional, Union
 
 from pydantic import BaseModel, ConfigDict
 
-from .base_events import BaseEvent
+from crewai.events.base_events import BaseEvent
 
 
 class FlowEvent(BaseEvent):

src/crewai/events/types/knowledge_events.py

@@ -1,10 +1,6 @@
-from typing import TYPE_CHECKING, Any
+from crewai.events.base_events import BaseEvent
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
-from crewai.utilities.events.base_events import BaseEvent
-
-if TYPE_CHECKING:
-    from crewai.agents.agent_builder.base_agent import BaseAgent
 
 
 class KnowledgeRetrievalStartedEvent(BaseEvent):
@@ -20,7 +16,7 @@ class KnowledgeRetrievalCompletedEvent(BaseEvent):
     query: str
     type: str = "knowledge_search_query_completed"
     agent: BaseAgent
-    retrieved_knowledge: Any
+    retrieved_knowledge: str
 
 
 class KnowledgeQueryStartedEvent(BaseEvent):

src/crewai/events/types/llm_events.py

@@ -3,7 +3,7 @@ from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
-from crewai.utilities.events.base_events import BaseEvent
+from crewai.events.base_events import BaseEvent
 
 
 class LLMEventBase(BaseEvent):

src/crewai/events/types/llm_guardrail_events.py

@@ -1,7 +1,7 @@
 from inspect import getsource
 from typing import Any, Callable, Optional, Union
 
-from crewai.utilities.events.base_events import BaseEvent
+from crewai.events.base_events import BaseEvent
 
 
 class LLMGuardrailStartedEvent(BaseEvent):

src/crewai/events/types/logging_events.py

@@ -0,0 +1,25 @@
+"""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/memory_events.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, Optional
 
-from crewai.utilities.events.base_events import BaseEvent
+from crewai.events.base_events import BaseEvent
 
 
 class MemoryBaseEvent(BaseEvent):

src/crewai/events/types/reasoning_events.py

@@ -1,4 +1,4 @@
-from crewai.utilities.events.base_events import BaseEvent
+from crewai.events.base_events import BaseEvent
 from typing import Any, Optional
 
 

src/crewai/events/types/task_events.py

@@ -1,7 +1,7 @@
 from typing import Any, Optional
 
 from crewai.tasks.task_output import TaskOutput
-from crewai.utilities.events.base_events import BaseEvent
+from crewai.events.base_events import BaseEvent
 
 
 class TaskStartedEvent(BaseEvent):

src/crewai/events/types/tool_usage_events.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import Any, Callable, Dict, Optional
 
-from .base_events import BaseEvent
+from crewai.events.base_events import BaseEvent
 
 
 class ToolUsageEvent(BaseEvent):

src/crewai/events/utils/console_formatter.py

@@ -227,7 +227,7 @@ class ConsoleFormatter:
             return None
 
         task_content = Text()
-        
+
         # Display task name if available, otherwise just the ID
         if task_name:
             task_content.append("📋 Task: ", style="yellow bold")
@@ -235,7 +235,7 @@ class ConsoleFormatter:
             task_content.append(f" (ID: {task_id})", style="yellow dim")
         else:
             task_content.append(f"📋 Task: {task_id}", style="yellow bold")
-            
+
         task_content.append("\nStatus: ", style="white")
         task_content.append("Executing Task...", style="yellow dim")
 

src/crewai/experimental/evaluation/agent_evaluator.py

@@ -1,18 +1,30 @@
 import threading
 from typing import Any, Optional
 
-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.utilities.events.agent_events import AgentEvaluationStartedEvent, AgentEvaluationCompletedEvent, AgentEvaluationFailedEvent
+from crewai.events.types.agent_events import (
+    AgentEvaluationStartedEvent,
+    AgentEvaluationCompletedEvent,
+    AgentEvaluationFailedEvent,
+)
 from crewai.experimental.evaluation import BaseEvaluator, create_evaluation_callbacks
 from collections.abc import Sequence
-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
+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,
+)
+
 
 class ExecutionState:
     current_agent_id: Optional[str] = None
@@ -24,6 +36,7 @@ class ExecutionState:
         self.iterations_results = {}
         self.agent_evaluators = {}
 
+
 class AgentEvaluator:
     def __init__(
         self,
@@ -46,27 +59,45 @@ 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
@@ -76,19 +107,28 @@ 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"])
 
@@ -106,8 +146,12 @@ 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
@@ -116,7 +160,7 @@ class AgentEvaluator:
                 agent=target_agent,
                 execution_trace=trace,
                 final_output=event.output,
-                state=state
+                state=state,
             )
 
             current_iteration = self._execution_state.iteration
@@ -124,10 +168,17 @@ 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
@@ -136,14 +187,26 @@ 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()
@@ -157,13 +220,16 @@ 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:
@@ -172,7 +238,9 @@ 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,
@@ -184,46 +252,91 @@ 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,
@@ -231,7 +344,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,18 +3,28 @@ 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.utilities.events.utils.console_formatter import ConsoleFormatter
+from crewai.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()
@@ -22,7 +32,9 @@ 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]:
@@ -62,9 +74,7 @@ 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:
@@ -82,19 +92,26 @@ 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")
 
@@ -123,11 +140,14 @@ 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
@@ -137,7 +157,9 @@ 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]"]
 
@@ -178,9 +200,13 @@ 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:
@@ -225,7 +251,9 @@ 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():
@@ -246,19 +274,20 @@ 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)
 
@@ -268,7 +297,7 @@ class EvaluationDisplayFormatter:
             metrics=aggregated_metrics,
             overall_score=overall_score,
             task_count=len(results),
-            aggregation_strategy=strategy
+            aggregation_strategy=strategy,
         )
 
     def _summarize_feedbacks(
@@ -277,10 +306,12 @@ 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()
@@ -290,20 +321,26 @@ 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.
@@ -315,14 +352,18 @@ 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)
@@ -330,4 +371,6 @@ 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,25 +5,23 @@ from collections.abc import Sequence
 
 from crewai.agent import Agent
 from crewai.task import Task
-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 (
+from crewai.events.base_event_listener import BaseEventListener
+from crewai.events.event_bus import CrewAIEventsBus
+from crewai.events.types.agent_events import (
     AgentExecutionStartedEvent,
     AgentExecutionCompletedEvent,
     LiteAgentExecutionStartedEvent,
-    LiteAgentExecutionCompletedEvent
+    LiteAgentExecutionCompletedEvent,
 )
-from crewai.utilities.events.tool_usage_events import (
+from crewai.events.types.tool_usage_events import (
     ToolUsageFinishedEvent,
     ToolUsageErrorEvent,
     ToolExecutionErrorEvent,
     ToolSelectionErrorEvent,
-    ToolValidateInputErrorEvent
-)
-from crewai.utilities.events.llm_events import (
-    LLMCallStartedEvent,
-    LLMCallCompletedEvent
+    ToolValidateInputErrorEvent,
 )
+from crewai.events.types.llm_events import LLMCallStartedEvent, LLMCallCompletedEvent
+
 
 class EvaluationTraceCallback(BaseEventListener):
     """Event listener for collecting execution traces for evaluation.
@@ -68,27 +66,49 @@ 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):
@@ -99,7 +119,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}"
@@ -110,7 +130,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):
@@ -128,7 +148,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):
@@ -151,8 +171,14 @@ 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
 
@@ -163,7 +189,7 @@ class EvaluationTraceCallback(BaseEventListener):
                 "args": tool_args,
                 "result": result,
                 "success": success,
-                "timestamp": datetime.now()
+                "timestamp": datetime.now(),
             }
 
             # Add error information if applicable
@@ -173,7 +199,11 @@ 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
 
@@ -186,10 +216,12 @@ 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
 
@@ -213,7 +245,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)
@@ -227,7 +259,7 @@ class EvaluationTraceCallback(BaseEventListener):
 
 
 def create_evaluation_callbacks() -> EvaluationTraceCallback:
-    from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+    from crewai.events.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.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.flow_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.flow_events import (
     FlowCreatedEvent,
     FlowFinishedEvent,
     FlowPlotEvent,
@@ -35,10 +35,10 @@ from crewai.utilities.events.flow_events import (
     MethodExecutionFinishedEvent,
     MethodExecutionStartedEvent,
 )
-from crewai.utilities.events.listeners.tracing.trace_listener import (
+from crewai.events.listeners.tracing.trace_listener import (
     TraceCollectionListener,
 )
-from crewai.utilities.events.listeners.tracing.utils import (
+from crewai.events.listeners.tracing.utils import (
     is_tracing_enabled,
 )
 from crewai.utilities.printer import Printer
@@ -934,12 +934,12 @@ class Flow(Generic[T], metaclass=FlowMeta):
         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,15 +952,17 @@ 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)

src/crewai/knowledge/storage/knowledge_storage.py

@@ -1,6 +1,4 @@
-import contextlib
 import hashlib
-import io
 import logging
 import os
 import shutil
@@ -20,23 +18,7 @@ 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
-
-
-@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)
+from crewai.utilities.logger_utils import suppress_logging
 
 
 class KnowledgeStorage(BaseKnowledgeStorage):
@@ -64,7 +46,9 @@ class KnowledgeStorage(BaseKnowledgeStorage):
         filter: Optional[dict] = None,
         score_threshold: float = 0.35,
     ) -> List[Dict[str, Any]]:
-        with suppress_logging():
+        with suppress_logging(
+            "chromadb.segment.impl.vector.local_persistent_hnsw", logging.ERROR
+        ):
             if self.collection:
                 fetched = self.collection.query(
                     query_texts=query,

src/crewai/lite_agent.py

@@ -62,13 +62,13 @@ from crewai.utilities.agent_utils import (
     render_text_description_and_args,
 )
 from crewai.utilities.converter import generate_model_description
-from crewai.utilities.events.agent_events import (
-    AgentLogsExecutionEvent,
+from crewai.events.types.logging_events import AgentLogsExecutionEvent
+from crewai.events.types.agent_events import (
     LiteAgentExecutionCompletedEvent,
     LiteAgentExecutionErrorEvent,
     LiteAgentExecutionStartedEvent,
 )
-from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.events.event_bus import crewai_event_bus
 
 from crewai.utilities.llm_utils import create_llm
 from crewai.utilities.printer import Printer

src/crewai/llm.py

@@ -23,24 +23,25 @@ from dotenv import load_dotenv
 from litellm.types.utils import ChatCompletionDeltaToolCall
 from pydantic import BaseModel, Field
 
-from crewai.utilities.events.llm_events import (
+from crewai.events.types.llm_events import (
     LLMCallCompletedEvent,
     LLMCallFailedEvent,
     LLMCallStartedEvent,
     LLMCallType,
     LLMStreamChunkEvent,
 )
-from crewai.utilities.events.tool_usage_events import (
+from crewai.events.types.tool_usage_events import (
     ToolUsageStartedEvent,
     ToolUsageFinishedEvent,
     ToolUsageErrorEvent,
 )
+from crewai.utilities.exceptions import LLMQuotaLimitExceededException
 
 with warnings.catch_warnings():
     warnings.simplefilter("ignore", UserWarning)
     import litellm
     from litellm import Choices
-    from litellm.exceptions import ContextWindowExceededError
+    from litellm.exceptions import ContextWindowExceededError, RateLimitError
     from litellm.litellm_core_utils.get_supported_openai_params import (
         get_supported_openai_params,
     )
@@ -52,7 +53,7 @@ import io
 from typing import TextIO
 
 from crewai.llms.base_llm import BaseLLM
-from crewai.utilities.events import crewai_event_bus
+from crewai.events.event_bus import crewai_event_bus
 from crewai.utilities.exceptions.context_window_exceeding_exception import (
     LLMContextLengthExceededException,
 )
@@ -311,7 +312,7 @@ class LLM(BaseLLM):
         api_base: Optional[str] = None,
         api_version: Optional[str] = None,
         api_key: Optional[str] = None,
-        callbacks: List[Any] = [],
+        callbacks: List[Any] | None = None,
         reasoning_effort: Optional[Literal["none", "low", "medium", "high"]] = None,
         stream: bool = False,
         **kwargs,
@@ -351,7 +352,7 @@ class LLM(BaseLLM):
         else:
             self.stop = stop
 
-        self.set_callbacks(callbacks)
+        self.set_callbacks(callbacks or [])
         self.set_env_callbacks()
 
     def _is_anthropic_model(self, model: str) -> bool:
@@ -669,6 +670,10 @@ class LLM(BaseLLM):
             )
             return full_response
 
+        except RateLimitError as e:
+            # Convert litellm's rate limit error to our own exception type
+            # for graceful quota limit handling
+            raise LLMQuotaLimitExceededException(str(e))
         except ContextWindowExceededError as e:
             # Catch context window errors from litellm and convert them to our own exception type.
             # This exception is handled by CrewAgentExecutor._invoke_loop() which can then
@@ -812,6 +817,10 @@ class LLM(BaseLLM):
             # length issues appropriately.
             response = litellm.completion(**params)
 
+        except RateLimitError as e:
+            # Convert litellm's rate limit error to our own exception type
+            # for graceful quota limit handling
+            raise LLMQuotaLimitExceededException(str(e))
         except ContextWindowExceededError as e:
             # Convert litellm's context window error to our own exception type
             # for consistent handling in the rest of the codebase
@@ -950,6 +959,8 @@ 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

src/crewai/memory/entity/entity_memory.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Any
 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.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.memory_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
     MemoryQueryStartedEvent,
     MemoryQueryCompletedEvent,
     MemoryQueryFailedEvent,
@@ -24,7 +24,7 @@ class EntityMemory(Memory):
     Inherits from the Memory class.
     """
 
-    _memory_provider: Optional[str] = PrivateAttr()
+    _memory_provider: str | None = PrivateAttr()
 
     def __init__(self, crew=None, embedder_config=None, storage=None, path=None):
         memory_provider = embedder_config.get("provider") if embedder_config else None
@@ -53,12 +53,33 @@ class EntityMemory(Memory):
         super().__init__(storage=storage)
         self._memory_provider = memory_provider
 
-    def save(self, item: EntityMemoryItem) -> None:  # type: ignore # BUG?: Signature of "save" incompatible with supertype "Memory"
-        """Saves an entity item into the SQLite storage."""
+    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
         crewai_event_bus.emit(
             self,
             event=MemorySaveStartedEvent(
-                metadata=item.metadata,
+                metadata=metadata,
                 source_type="entity_memory",
                 from_agent=self.agent,
                 from_task=self.task,
@@ -66,36 +87,61 @@ class EntityMemory(Memory):
         )
 
         start_time = time.time()
+        saved_count = 0
+        errors = []
+
         try:
-            if self._memory_provider == "mem0":
-                data = f"""
-                Remember details about the following entity:
-                Name: {item.name}
-                Type: {item.type}
-                Entity Description: {item.description}
-                """
+            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}
             else:
-                data = f"{item.name}({item.type}): {item.description}"
+                emit_value = f"{items[0].name}({items[0].type}): {items[0].description}"
+                metadata = items[0].metadata
 
-            super().save(data, item.metadata)
-
-            # Emit memory save completed event
             crewai_event_bus.emit(
                 self,
                 event=MemorySaveCompletedEvent(
-                    value=data,
-                    metadata=item.metadata,
+                    value=emit_value,
+                    metadata=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=item.metadata,
+                    metadata=fail_metadata,
                     error=str(e),
                     source_type="entity_memory",
                     from_agent=self.agent,

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.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.memory_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
     MemoryQueryStartedEvent,
     MemoryQueryCompletedEvent,
     MemoryQueryFailedEvent,

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.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.memory_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
     MemoryQueryStartedEvent,
     MemoryQueryCompletedEvent,
     MemoryQueryFailedEvent,

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.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.memory_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
     MemoryQueryStartedEvent,
     MemoryQueryCompletedEvent,
     MemoryQueryFailedEvent,

src/crewai/memory/storage/kickoff_task_outputs_storage.py

@@ -18,9 +18,7 @@ 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")
@@ -67,7 +65,7 @@ class KickoffTaskOutputsSQLiteStorage:
         output: Dict[str, Any],
         task_index: int,
         was_replayed: bool = False,
-        inputs: Dict[str, Any] = {},
+        inputs: Dict[str, Any] | None = None,
     ) -> None:
         """Add a new task output record to the database.
 
@@ -81,6 +79,7 @@ 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")
@@ -146,7 +145,9 @@ 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,5 +1,3 @@
-import contextlib
-import io
 import logging
 import os
 import shutil
@@ -12,26 +10,10 @@ 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
@@ -122,7 +104,9 @@ class RAGStorage(BaseRAGStorage):
             self._initialize_app()
 
         try:
-            with suppress_logging():
+            with suppress_logging(
+                "chromadb.segment.impl.vector.local_persistent_hnsw", logging.ERROR
+            ):
                 response = self.collection.query(query_texts=query, n_results=limit)
 
             results = []

src/crewai/rag/chromadb/client.py

@@ -1,5 +1,6 @@
 """ChromaDB client implementation."""
 
+import logging
 from typing import Any
 
 from chromadb.api.types import (
@@ -20,7 +21,9 @@ from crewai.rag.chromadb.utils import (
     _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,
@@ -97,7 +100,7 @@ class ChromaDBClient(BaseClient):
             metadata["hnsw:space"] = "cosine"
 
         self.client.create_collection(
-            name=kwargs["collection_name"],
+            name=_sanitize_collection_name(kwargs["collection_name"]),
             configuration=kwargs.get("configuration"),
             metadata=metadata,
             embedding_function=kwargs.get(
@@ -154,7 +157,7 @@ class ChromaDBClient(BaseClient):
             metadata["hnsw:space"] = "cosine"
 
         await self.client.create_collection(
-            name=kwargs["collection_name"],
+            name=_sanitize_collection_name(kwargs["collection_name"]),
             configuration=kwargs.get("configuration"),
             metadata=metadata,
             embedding_function=kwargs.get(
@@ -205,7 +208,7 @@ class ChromaDBClient(BaseClient):
             metadata["hnsw:space"] = "cosine"
 
         return self.client.get_or_create_collection(
-            name=kwargs["collection_name"],
+            name=_sanitize_collection_name(kwargs["collection_name"]),
             configuration=kwargs.get("configuration"),
             metadata=metadata,
             embedding_function=kwargs.get(
@@ -258,7 +261,7 @@ class ChromaDBClient(BaseClient):
             metadata["hnsw:space"] = "cosine"
 
         return await self.client.get_or_create_collection(
-            name=kwargs["collection_name"],
+            name=_sanitize_collection_name(kwargs["collection_name"]),
             configuration=kwargs.get("configuration"),
             metadata=metadata,
             embedding_function=kwargs.get(
@@ -298,12 +301,12 @@ class ChromaDBClient(BaseClient):
             raise ValueError("Documents list cannot be empty")
 
         collection = self.client.get_collection(
-            name=collection_name,
+            name=_sanitize_collection_name(collection_name),
             embedding_function=self.embedding_function,
         )
 
         prepared = _prepare_documents_for_chromadb(documents)
-        collection.add(
+        collection.upsert(
             ids=prepared.ids,
             documents=prepared.texts,
             metadatas=prepared.metadatas,
@@ -340,11 +343,11 @@ class ChromaDBClient(BaseClient):
             raise ValueError("Documents list cannot be empty")
 
         collection = await self.client.get_collection(
-            name=collection_name,
+            name=_sanitize_collection_name(collection_name),
             embedding_function=self.embedding_function,
         )
         prepared = _prepare_documents_for_chromadb(documents)
-        await collection.add(
+        await collection.upsert(
             ids=prepared.ids,
             documents=prepared.texts,
             metadatas=prepared.metadatas,
@@ -385,19 +388,22 @@ class ChromaDBClient(BaseClient):
         params = _extract_search_params(kwargs)
 
         collection = self.client.get_collection(
-            name=params.collection_name,
+            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
 
-        results: QueryResult = collection.query(
-            query_texts=[params.query],
-            n_results=params.limit,
-            where=where,
-            where_document=params.where_document,
-            include=params.include,
-        )
+        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,
@@ -440,19 +446,22 @@ class ChromaDBClient(BaseClient):
         params = _extract_search_params(kwargs)
 
         collection = await self.client.get_collection(
-            name=params.collection_name,
+            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
 
-        results: QueryResult = await collection.query(
-            query_texts=[params.query],
-            n_results=params.limit,
-            where=where,
-            where_document=params.where_document,
-            include=params.include,
-        )
+        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,
@@ -485,7 +494,7 @@ class ChromaDBClient(BaseClient):
             )
 
         collection_name = kwargs["collection_name"]
-        self.client.delete_collection(name=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.
@@ -515,7 +524,9 @@ class ChromaDBClient(BaseClient):
             )
 
         collection_name = kwargs["collection_name"]
-        await self.client.delete_collection(name=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.

src/crewai/rag/chromadb/config.py

@@ -23,6 +23,12 @@ warnings.filterwarnings(
     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.

src/crewai/rag/chromadb/constants.py

@@ -1,10 +1,17 @@
 """Constants for ChromaDB configuration."""
 
-import os
+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] = os.path.join(db_storage_path(), "chromadb")
+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,6 +1,9 @@
 """Factory functions for creating ChromaDB clients."""
 
-from chromadb import Client
+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
@@ -14,11 +17,24 @@ def create_client(config: ChromaDBConfig) -> ChromaDBClient:
 
     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(
-            settings=config.settings, tenant=config.tenant, database=config.database
-        ),
+        client=client,
         embedding_function=config.embedding_function,
     )

src/crewai/rag/chromadb/utils.py

@@ -12,6 +12,13 @@ from chromadb.api.types import (
 )
 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,
@@ -216,3 +223,58 @@ def _process_query_results(
         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/task.py

@@ -43,12 +43,12 @@ from crewai.utilities.config import process_config
 from crewai.utilities.constants import NOT_SPECIFIED, _NotSpecified
 from crewai.utilities.guardrail import process_guardrail, GuardrailResult
 from crewai.utilities.converter import Converter, convert_to_model
-from crewai.utilities.events import (
+from crewai.events.event_types import (
     TaskCompletedEvent,
     TaskFailedEvent,
     TaskStartedEvent,
 )
-from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+from crewai.events.event_bus import crewai_event_bus
 from crewai.utilities.i18n import I18N
 from crewai.utilities.printer import Printer
 from crewai.utilities.string_utils import interpolate_only
@@ -160,11 +160,10 @@ class Task(BaseModel):
     )
     max_retries: Optional[int] = Field(
         default=None,
-        description="[DEPRECATED] Maximum number of retries when guardrail fails. Use guardrail_max_retries instead. Will be removed in v1.0.0"
+        description="[DEPRECATED] Maximum number of retries when guardrail fails. Use guardrail_max_retries instead. Will be removed in v1.0.0",
     )
     guardrail_max_retries: int = Field(
-        default=3,
-        description="Maximum number of retries when guardrail fails"
+        default=3, description="Maximum number of retries when guardrail fails"
     )
     retry_count: int = Field(default=0, description="Current number of retries")
     start_time: Optional[datetime.datetime] = Field(
@@ -367,7 +366,7 @@ class Task(BaseModel):
                 "The 'max_retries' parameter is deprecated and will be removed in CrewAI v1.0.0. "
                 "Please use 'guardrail_max_retries' instead.",
                 DeprecationWarning,
-                stacklevel=2
+                stacklevel=2,
             )
             self.guardrail_max_retries = self.max_retries
         return self
@@ -532,11 +531,11 @@ class Task(BaseModel):
     def _process_guardrail(self, task_output: TaskOutput) -> GuardrailResult:
         assert self._guardrail is not None
 
-        from crewai.utilities.events import (
+        from crewai.events.event_types import (
             LLMGuardrailCompletedEvent,
             LLMGuardrailStartedEvent,
         )
-        from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+        from crewai.events.event_bus import crewai_event_bus
 
         crewai_event_bus.emit(
             self,

src/crewai/tools/tool_usage.py

@@ -20,8 +20,8 @@ from crewai.utilities.agent_utils import (
     get_tool_names,
     render_text_description_and_args,
 )
-from crewai.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.tool_usage_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.tool_usage_events import (
     ToolSelectionErrorEvent,
     ToolUsageErrorEvent,
     ToolUsageFinishedEvent,

src/crewai/utilities/agent_utils.py

@@ -2,12 +2,12 @@ import json
 import re
 from typing import Any, Callable, Dict, List, Optional, Sequence, Union
 
+from crewai.agents.constants import FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE
 from crewai.agents.parser import (
-    FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE,
     AgentAction,
     AgentFinish,
-    CrewAgentParser,
     OutputParserException,
+    parse,
 )
 from crewai.llm import LLM
 from crewai.llms.base_llm import BaseLLM
@@ -25,6 +25,7 @@ from crewai.cli.config import Settings
 
 console = Console()
 
+
 def parse_tools(tools: List[BaseTool]) -> List[CrewStructuredTool]:
     """Parse tools to be used for the task."""
     tools_list = []
@@ -122,7 +123,7 @@ def format_message_for_llm(prompt: str, role: str = "user") -> Dict[str, str]:
 def format_answer(answer: str) -> Union[AgentAction, AgentFinish]:
     """Format a response from the LLM into an AgentAction or AgentFinish."""
     try:
-        return CrewAgentParser.parse_text(answer)
+        return parse(answer)
     except Exception:
         # If parsing fails, return a default AgentFinish
         return AgentFinish(
@@ -446,9 +447,16 @@ def show_agent_logs(
 def _print_current_organization():
     settings = Settings()
     if settings.org_uuid:
-        console.print(f"Fetching agent from organization: {settings.org_name} ({settings.org_uuid})", style="bold blue")
+        console.print(
+            f"Fetching agent from organization: {settings.org_name} ({settings.org_uuid})",
+            style="bold blue",
+        )
     else:
-        console.print("No organization currently set. We recommend setting one before using: `crewai org switch <org_id>` command.", style="yellow")
+        console.print(
+            "No organization currently set. We recommend setting one before using: `crewai org switch <org_id>` command.",
+            style="yellow",
+        )
+
 
 def load_agent_from_repository(from_repository: str) -> Dict[str, Any]:
     attributes: Dict[str, Any] = {}

src/crewai/utilities/constants.py

@@ -16,4 +16,4 @@ class _NotSpecified:
 # Unlike `None`, which might be a valid value from the user, `NOT_SPECIFIED` allows
 # us to distinguish between "not passed at all" and "explicitly passed None" or "[]".
 NOT_SPECIFIED = _NotSpecified()
-CREWAI_BASE_URL = "https://app.crewai.com/"
+CREWAI_BASE_URL = "https://app.crewai.com"

src/crewai/utilities/evaluators/crew_evaluator_handler.py

@@ -9,8 +9,8 @@ from crewai.agent import Agent
 from crewai.llm import BaseLLM
 from crewai.task import Task
 from crewai.tasks.task_output import TaskOutput
-from crewai.utilities.events import crewai_event_bus
-from crewai.utilities.events.crew_events import CrewTestResultEvent
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.crew_events import CrewTestResultEvent
 
 
 class TaskEvaluationPydanticOutput(BaseModel):

src/crewai/utilities/evaluators/task_evaluator.py

@@ -3,7 +3,8 @@ from typing import List
 from pydantic import BaseModel, Field
 
 from crewai.utilities import Converter
-from crewai.utilities.events import TaskEvaluationEvent, crewai_event_bus
+from crewai.events.types.task_events import TaskEvaluationEvent
+from crewai.events.event_bus import crewai_event_bus
 from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser
 from crewai.utilities.training_converter import TrainingConverter
 

src/crewai/utilities/events/__init__.py

@@ -1,124 +1,140 @@
-from .crew_events import (
-    CrewKickoffStartedEvent,
-    CrewKickoffCompletedEvent,
-    CrewKickoffFailedEvent,
-    CrewTrainStartedEvent,
-    CrewTrainCompletedEvent,
-    CrewTrainFailedEvent,
-    CrewTestStartedEvent,
-    CrewTestCompletedEvent,
-    CrewTestFailedEvent,
-)
-from .llm_guardrail_events import (
-    LLMGuardrailCompletedEvent,
-    LLMGuardrailStartedEvent,
-)
-from .agent_events import (
-    AgentExecutionStartedEvent,
-    AgentExecutionCompletedEvent,
-    AgentExecutionErrorEvent,
-    AgentEvaluationStartedEvent,
-    AgentEvaluationCompletedEvent,
-    AgentEvaluationFailedEvent,
-)
-from .task_events import (
-    TaskStartedEvent,
-    TaskCompletedEvent,
-    TaskFailedEvent,
-    TaskEvaluationEvent,
-)
-from .flow_events import (
-    FlowCreatedEvent,
-    FlowStartedEvent,
-    FlowFinishedEvent,
-    FlowPlotEvent,
-    MethodExecutionStartedEvent,
-    MethodExecutionFinishedEvent,
-    MethodExecutionFailedEvent,
-)
-from .crewai_event_bus import CrewAIEventsBus, crewai_event_bus
-from .tool_usage_events import (
-    ToolUsageFinishedEvent,
-    ToolUsageErrorEvent,
-    ToolUsageStartedEvent,
-    ToolExecutionErrorEvent,
-    ToolSelectionErrorEvent,
-    ToolUsageEvent,
-    ToolValidateInputErrorEvent,
-)
-from .llm_events import (
-    LLMCallCompletedEvent,
-    LLMCallFailedEvent,
-    LLMCallStartedEvent,
-    LLMCallType,
-    LLMStreamChunkEvent,
+"""Backwards compatibility - this module has moved to crewai.events."""
+
+import warnings
+from abc import ABC
+from collections.abc import Callable
+from typing import Any, Type, TypeVar
+
+from typing_extensions import deprecated
+import crewai.events as new_events
+from crewai.events.base_events import BaseEvent
+from crewai.events.event_types import EventTypes
+
+EventT = TypeVar("EventT", bound=BaseEvent)
+
+
+warnings.warn(
+    "Importing from 'crewai.utilities.events' is deprecated and will be removed in v1.0.0. "
+    "Please use 'crewai.events' instead.",
+    DeprecationWarning,
+    stacklevel=2
 )
 
-from .memory_events import (
-    MemorySaveStartedEvent,
-    MemorySaveCompletedEvent,
-    MemorySaveFailedEvent,
-    MemoryQueryStartedEvent,
-    MemoryQueryCompletedEvent,
-    MemoryQueryFailedEvent,
-    MemoryRetrievalStartedEvent,
-    MemoryRetrievalCompletedEvent,
-)
 
-# events
-from .event_listener import EventListener
+@deprecated("Use 'from crewai.events import BaseEventListener' instead")
+class BaseEventListener(new_events.BaseEventListener, ABC):
+    """Deprecated: Use crewai.events.BaseEventListener instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import crewai_event_bus' instead")
+class crewai_event_bus:  # noqa: N801
+    """Deprecated: Use crewai.events.crewai_event_bus instead."""
+
+    @classmethod
+    def on(
+        cls, event_type: Type[EventT]
+    ) -> Callable[[Callable[[Any, EventT], None]], Callable[[Any, EventT], None]]:
+        """Delegate to the actual event bus instance."""
+        return new_events.crewai_event_bus.on(event_type)
+
+    @classmethod
+    def emit(cls, source: Any, event: BaseEvent) -> None:
+        """Delegate to the actual event bus instance."""
+        return new_events.crewai_event_bus.emit(source, event)
+
+    @classmethod
+    def register_handler(
+        cls, event_type: Type[EventTypes], handler: Callable[[Any, EventTypes], None]
+    ) -> None:
+        """Delegate to the actual event bus instance."""
+        return new_events.crewai_event_bus.register_handler(event_type, handler)
+
+    @classmethod
+    def scoped_handlers(cls) -> Any:
+        """Delegate to the actual event bus instance."""
+        return new_events.crewai_event_bus.scoped_handlers()
+
+@deprecated("Use 'from crewai.events import CrewKickoffStartedEvent' instead")
+class CrewKickoffStartedEvent(new_events.CrewKickoffStartedEvent):
+    """Deprecated: Use crewai.events.CrewKickoffStartedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import CrewKickoffCompletedEvent' instead")
+class CrewKickoffCompletedEvent(new_events.CrewKickoffCompletedEvent):
+    """Deprecated: Use crewai.events.CrewKickoffCompletedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import AgentExecutionCompletedEvent' instead")
+class AgentExecutionCompletedEvent(new_events.AgentExecutionCompletedEvent):
+    """Deprecated: Use crewai.events.AgentExecutionCompletedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import MemoryQueryCompletedEvent' instead")
+class MemoryQueryCompletedEvent(new_events.MemoryQueryCompletedEvent):
+    """Deprecated: Use crewai.events.MemoryQueryCompletedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import MemorySaveCompletedEvent' instead")
+class MemorySaveCompletedEvent(new_events.MemorySaveCompletedEvent):
+    """Deprecated: Use crewai.events.MemorySaveCompletedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import MemorySaveStartedEvent' instead")
+class MemorySaveStartedEvent(new_events.MemorySaveStartedEvent):
+    """Deprecated: Use crewai.events.MemorySaveStartedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import MemoryQueryStartedEvent' instead")
+class MemoryQueryStartedEvent(new_events.MemoryQueryStartedEvent):
+    """Deprecated: Use crewai.events.MemoryQueryStartedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import MemoryRetrievalCompletedEvent' instead")
+class MemoryRetrievalCompletedEvent(new_events.MemoryRetrievalCompletedEvent):
+    """Deprecated: Use crewai.events.MemoryRetrievalCompletedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import MemorySaveFailedEvent' instead")
+class MemorySaveFailedEvent(new_events.MemorySaveFailedEvent):
+    """Deprecated: Use crewai.events.MemorySaveFailedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import MemoryQueryFailedEvent' instead")
+class MemoryQueryFailedEvent(new_events.MemoryQueryFailedEvent):
+    """Deprecated: Use crewai.events.MemoryQueryFailedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import KnowledgeRetrievalStartedEvent' instead")
+class KnowledgeRetrievalStartedEvent(new_events.KnowledgeRetrievalStartedEvent):
+    """Deprecated: Use crewai.events.KnowledgeRetrievalStartedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import KnowledgeRetrievalCompletedEvent' instead")
+class KnowledgeRetrievalCompletedEvent(new_events.KnowledgeRetrievalCompletedEvent):
+    """Deprecated: Use crewai.events.KnowledgeRetrievalCompletedEvent instead."""
+    pass
+
+@deprecated("Use 'from crewai.events import LLMStreamChunkEvent' instead")
+class LLMStreamChunkEvent(new_events.LLMStreamChunkEvent):
+    """Deprecated: Use crewai.events.LLMStreamChunkEvent instead."""
+    pass
 
 __all__ = [
-    "EventListener",
-    "CrewAIEventsBus",
-    "crewai_event_bus",
-    "AgentExecutionStartedEvent",
-    "AgentExecutionCompletedEvent",
-    "AgentExecutionErrorEvent",
-    "AgentEvaluationStartedEvent",
-    "AgentEvaluationCompletedEvent",
-    "AgentEvaluationFailedEvent",
-    "TaskStartedEvent",
-    "TaskCompletedEvent",
-    "TaskFailedEvent",
-    "TaskEvaluationEvent",
-    "FlowCreatedEvent",
-    "FlowStartedEvent",
-    "FlowFinishedEvent",
-    "FlowPlotEvent",
-    "MethodExecutionStartedEvent",
-    "MethodExecutionFinishedEvent",
-    "MethodExecutionFailedEvent",
-    "LLMCallCompletedEvent",
-    "LLMCallFailedEvent",
-    "LLMCallStartedEvent",
-    "LLMCallType",
-    "LLMStreamChunkEvent",
-    "MemorySaveStartedEvent",
-    "MemorySaveCompletedEvent",
-    "MemorySaveFailedEvent",
-    "MemoryQueryStartedEvent",
-    "MemoryQueryCompletedEvent",
-    "MemoryQueryFailedEvent",
-    "MemoryRetrievalStartedEvent",
-    "MemoryRetrievalCompletedEvent",
-    "EventListener",
-    "CrewKickoffStartedEvent",
-    "CrewKickoffCompletedEvent",
-    "CrewKickoffFailedEvent",
-    "CrewTrainStartedEvent",
-    "CrewTrainCompletedEvent",
-    "CrewTrainFailedEvent",
-    "CrewTestStartedEvent",
-    "CrewTestCompletedEvent",
-    "CrewTestFailedEvent",
-    "LLMGuardrailCompletedEvent",
-    "LLMGuardrailStartedEvent",
-    "ToolUsageFinishedEvent",
-    "ToolUsageErrorEvent",
-    "ToolUsageStartedEvent",
-    "ToolExecutionErrorEvent",
-    "ToolSelectionErrorEvent",
-    "ToolUsageEvent",
-    "ToolValidateInputErrorEvent",
+    'BaseEventListener',
+    'crewai_event_bus',
+    'CrewKickoffStartedEvent',
+    'CrewKickoffCompletedEvent',
+    'AgentExecutionCompletedEvent',
+    'MemoryQueryCompletedEvent',
+    'MemorySaveCompletedEvent',
+    'MemorySaveStartedEvent',
+    'MemoryQueryStartedEvent',
+    'MemoryRetrievalCompletedEvent',
+    'MemorySaveFailedEvent',
+    'MemoryQueryFailedEvent',
+    'KnowledgeRetrievalStartedEvent',
+    'KnowledgeRetrievalCompletedEvent',
+    'LLMStreamChunkEvent',
 ]
+
+__deprecated__ = "Use 'crewai.events' instead of 'crewai.utilities.events'"

src/crewai/utilities/events/base_event_listener.py

@@ -1,16 +1,13 @@
-from abc import ABC, abstractmethod
-from logging import Logger
+"""Backwards compatibility stub for crewai.utilities.events.base_event_listener."""
 
-from crewai.utilities.events.crewai_event_bus import CrewAIEventsBus, crewai_event_bus
+import warnings
+from crewai.events import BaseEventListener
 
+warnings.warn(
+    "Importing from 'crewai.utilities.events.base_event_listener' is deprecated and will be removed in v1.0.0. "
+    "Please use 'from crewai.events import BaseEventListener' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-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
+__all__ = ["BaseEventListener"]

src/crewai/utilities/events/crewai_event_bus.py

@@ -1,115 +1,13 @@
-import threading
-from contextlib import contextmanager
-from typing import Any, Callable, Dict, List, Type, TypeVar, cast
+"""Backwards compatibility stub for crewai.utilities.events.crewai_event_bus."""
 
-from blinker import Signal
+import warnings
+from crewai.events import crewai_event_bus
 
-from crewai.utilities.events.base_events import BaseEvent
-from crewai.utilities.events.event_types import EventTypes
+warnings.warn(
+    "Importing from 'crewai.utilities.events.crewai_event_bus' is deprecated and will be removed in v1.0.0. "
+    "Please use 'from crewai.events import crewai_event_bus' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-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()
+__all__ = ["crewai_event_bus"]

src/crewai/utilities/exceptions/__init__.py

@@ -1 +1,4 @@
 """Exceptions for crewAI."""
+
+from crewai.utilities.exceptions.context_window_exceeding_exception import LLMContextLengthExceededException
+from crewai.utilities.exceptions.quota_limit_exception import LLMQuotaLimitExceededException

src/crewai/utilities/exceptions/quota_limit_exception.py

@@ -0,0 +1,31 @@
+class LLMQuotaLimitExceededException(Exception):
+    QUOTA_LIMIT_ERRORS = [
+        "quota exceeded",
+        "rate limit exceeded",
+        "resource exhausted",
+        "too many requests",
+        "quota limit reached",
+        "api quota exceeded",
+        "usage limit exceeded",
+        "billing quota exceeded",
+        "request limit exceeded",
+        "daily quota exceeded",
+        "monthly quota exceeded",
+    ]
+
+    def __init__(self, error_message: str):
+        self.original_error_message = error_message
+        super().__init__(self._get_error_message(error_message))
+
+    def _is_quota_limit_error(self, error_message: str) -> bool:
+        return any(
+            phrase.lower() in error_message.lower()
+            for phrase in self.QUOTA_LIMIT_ERRORS
+        )
+
+    def _get_error_message(self, error_message: str):
+        return (
+            f"LLM quota limit exceeded. Original error: {error_message}\n"
+            "Your API quota or rate limit has been reached. Please check your API usage, "
+            "upgrade your plan, or wait for the quota to reset before retrying."
+        )

src/crewai/utilities/guardrail.py

@@ -2,6 +2,7 @@ from typing import Any, Callable, Optional, Tuple, Union
 
 from pydantic import BaseModel, field_validator
 
+
 class GuardrailResult(BaseModel):
     """Result from a task guardrail execution.
 
@@ -14,6 +15,7 @@ class GuardrailResult(BaseModel):
         result (Any, optional): The validated/transformed result if successful
         error (str, optional): Error message if validation failed
     """
+
     success: bool
     result: Optional[Any] = None
     error: Optional[str] = None
@@ -24,9 +26,13 @@ class GuardrailResult(BaseModel):
         values = info.data
         if "success" in values:
             if values["success"] and v and "error" in values and values["error"]:
-                raise ValueError("Cannot have both result and error when success is True")
+                raise ValueError(
+                    "Cannot have both result and error when success is True"
+                )
             if not values["success"] and v and "result" in values and values["result"]:
-                raise ValueError("Cannot have both result and error when success is False")
+                raise ValueError(
+                    "Cannot have both result and error when success is False"
+                )
         return v
 
     @classmethod
@@ -44,11 +50,13 @@ class GuardrailResult(BaseModel):
         return cls(
             success=success,
             result=data if success else None,
-            error=data if not success else None
+            error=data if not success else None,
         )
 
 
-def process_guardrail(output: Any, guardrail: Callable, retry_count: int) -> GuardrailResult:
+def process_guardrail(
+    output: Any, guardrail: Callable, retry_count: int
+) -> GuardrailResult:
     """Process the guardrail for the agent output.
 
     Args:
@@ -60,21 +68,21 @@ def process_guardrail(output: Any, guardrail: Callable, retry_count: int) -> Gua
     from crewai.task import TaskOutput
     from crewai.lite_agent import LiteAgentOutput
 
-    assert isinstance(output, TaskOutput) or isinstance(output, LiteAgentOutput), "Output must be a TaskOutput or LiteAgentOutput"
+    assert isinstance(output, TaskOutput) or isinstance(
+        output, LiteAgentOutput
+    ), "Output must be a TaskOutput or LiteAgentOutput"
 
     assert guardrail is not None
 
-    from crewai.utilities.events import (
+    from crewai.events.types.llm_guardrail_events import (
         LLMGuardrailCompletedEvent,
         LLMGuardrailStartedEvent,
     )
-    from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+    from crewai.events.event_bus import crewai_event_bus
 
     crewai_event_bus.emit(
         None,
-        LLMGuardrailStartedEvent(
-            guardrail=guardrail, retry_count=retry_count
-        ),
+        LLMGuardrailStartedEvent(guardrail=guardrail, retry_count=retry_count),
     )
 
     result = guardrail(output)

src/crewai/utilities/logger_utils.py

@@ -0,0 +1,38 @@
+"""Logging utility functions for CrewAI."""
+
+import contextlib
+import io
+import logging
+from collections.abc import Generator
+
+
+@contextlib.contextmanager
+def suppress_logging(
+    logger_name: str,
+    level: int | str,
+) -> Generator[None, None, None]:
+    """Suppress verbose logging output from specified logger.
+
+    Commonly used to suppress ChromaDB's verbose HNSW index logging.
+
+    Args:
+        logger_name: The logger to suppress
+        level: The minimum level to allow (e.g., logging.ERROR or "ERROR")
+
+    Yields:
+        None
+
+    Example:
+        with suppress_logging("chromadb.segment.impl.vector.local_persistent_hnsw", logging.ERROR):
+            collection.query(query_texts=["test"])
+    """
+    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)

src/crewai/utilities/reasoning_handler.py

@@ -8,8 +8,8 @@ from crewai.agent import Agent
 from crewai.task import Task
 from crewai.utilities import I18N
 from crewai.llm import LLM
-from crewai.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.reasoning_events import (
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.reasoning_events import (
     AgentReasoningStartedEvent,
     AgentReasoningCompletedEvent,
     AgentReasoningFailedEvent,

src/crewai/utilities/task_output_storage_handler.py

@@ -10,8 +10,10 @@ from crewai.task import Task
 
 """Handles storage and retrieval of task execution outputs."""
 
+
 class ExecutionLog(BaseModel):
     """Represents a log entry for task execution."""
+
     task_id: str
     expected_output: Optional[str] = None
     output: Dict[str, Any]
@@ -26,6 +28,7 @@ class ExecutionLog(BaseModel):
 
 """Manages storage and retrieval of task outputs."""
 
+
 class TaskOutputStorageHandler:
     def __init__(self) -> None:
         self.storage = KickoffTaskOutputsSQLiteStorage()
@@ -55,9 +58,10 @@ class TaskOutputStorageHandler:
         task: Task,
         output: Dict[str, Any],
         task_index: int,
-        inputs: Dict[str, Any] = {},
+        inputs: Dict[str, Any] | None = None,
         was_replayed: bool = False,
     ):
+        inputs = inputs or {}
         self.storage.add(task, output, task_index, was_replayed, inputs)
 
     def reset(self):