fix: resolve remaining lint issues in console formatter

- Add ClassVar import for proper type annotation
- Fix variable shadowing by renaming nested loop variables
- Break long comment lines to meet 88 character limit
- All lint checks now pass locally

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

.github/workflows/build-uv-cache.yml

@@ -1,46 +0,0 @@
-name: Build uv cache
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "uv.lock"
-      - "pyproject.toml"
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  build-cache:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v6
-        with:
-          version: "0.8.4"
-          python-version: ${{ matrix.python-version }}
-          enable-cache: false
-
-      - name: Install dependencies and populate cache
-        run: |
-          echo "Building global UV cache for Python ${{ matrix.python-version }}..."
-          uv sync --all-groups --all-extras --no-install-project
-          echo "Cache populated successfully"
-
-      - name: Save uv caches
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            ~/.cache/uv
-            ~/.local/share/uv
-            .venv
-          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}

.github/workflows/codeql.yml

@@ -1,102 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL Advanced"
-
-on:
-  push:
-    branches: [ "main" ]
-    paths-ignore:
-      - "src/crewai/cli/templates/**"
-  pull_request:
-    branches: [ "main" ]
-    paths-ignore:
-      - "src/crewai/cli/templates/**"
-
-jobs:
-  analyze:
-    name: Analyze (${{ matrix.language }})
-    # Runner size impacts CodeQL analysis time. To learn more, please see:
-    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
-    #   - https://gh.io/supported-runners-and-hardware-resources
-    #   - https://gh.io/using-larger-runners (GitHub.com only)
-    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
-    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
-    permissions:
-      # required for all workflows
-      security-events: write
-
-      # required to fetch internal or private CodeQL packs
-      packages: read
-
-      # only required for workflows in private repositories
-      actions: read
-      contents: read
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-        - language: actions
-          build-mode: none
-        - language: python
-          build-mode: none
-        # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift'
-        # Use `c-cpp` to analyze code written in C, C++ or both
-        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
-        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
-        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
-        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
-        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
-        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-
-    # Add any setup steps before running the `github/codeql-action/init` action.
-    # This includes steps like installing compilers or runtimes (`actions/setup-node`
-    # or others). This is typically only required for manual builds.
-    # - name: Setup runtime (example)
-    #   uses: actions/setup-example@v1
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
-      with:
-        languages: ${{ matrix.language }}
-        build-mode: ${{ matrix.build-mode }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-
-        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-    # If the analyze step fails for one of the languages you are analyzing with
-    # "We were unable to automatically build your code", modify the matrix above
-    # to set the build mode to "manual" for that language. Then modify this step
-    # to build your code.
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-    - if: matrix.build-mode == 'manual'
-      shell: bash
-      run: |
-        echo 'If you are using a "manual" build mode for one or more of the' \
-          'languages you are analyzing, replace this with the commands to build' \
-          'your code, for example:'
-        echo '  make bootstrap'
-        echo '  make release'
-        exit 1
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
-      with:
-        category: "/language:${{matrix.language}}"

.github/workflows/linter.yml

@@ -2,9 +2,6 @@ name: Lint
 
 on: [pull_request]
 
-permissions:
-  contents: read
-
 jobs:
   lint:
     runs-on: ubuntu-latest
@@ -18,27 +15,19 @@ jobs:
       - name: Fetch Target Branch
         run: git fetch origin $TARGET_BRANCH --depth=1
 
-      - name: Restore global uv cache
-        id: cache-restore
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            ~/.cache/uv
-            ~/.local/share/uv
-            .venv
-          key: uv-main-py3.11-${{ hashFiles('uv.lock') }}
-          restore-keys: |
-            uv-main-py3.11-
-
       - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
-          version: "0.8.4"
-          python-version: "3.11"
-          enable-cache: false
+          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 --all-groups --all-extras --no-install-project
+        run: uv sync --dev --no-install-project
 
       - name: Get Changed Python Files
         id: changed-files
@@ -56,13 +45,3 @@ jobs:
             | tr ' ' '\n' \
             | grep -v 'src/crewai/cli/templates/' \
             | xargs -I{} uv run ruff check "{}"
-
-      - name: Save uv caches
-        if: steps.cache-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            ~/.cache/uv
-            ~/.local/share/uv
-            .venv
-          key: uv-main-py3.11-${{ hashFiles('uv.lock') }}

.github/workflows/security-checker.yml

@@ -0,0 +1,29 @@
+name: Security Checker
+
+on: [pull_request]
+
+jobs:
+  security-check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+        with:
+          enable-cache: true
+          cache-dependency-glob: |
+            **/pyproject.toml
+            **/uv.lock
+
+      - name: Set up Python
+        run: uv python install 3.11
+
+      - name: Install dependencies
+        run: uv sync --dev --no-install-project
+
+      - name: Run Bandit
+        run: uv run bandit -c pyproject.toml -r src/ -ll
+

.github/workflows/tests.yml

@@ -3,7 +3,7 @@ name: Run Tests
 on: [pull_request]
 
 permissions:
-  contents: read
+  contents: write
 
 env:
   OPENAI_API_KEY: fake-api-key
@@ -22,76 +22,29 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
-        with:
-          fetch-depth: 0  # Fetch all history for proper diff
-
-      - name: Restore global uv cache
-        id: cache-restore
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            ~/.cache/uv
-            ~/.local/share/uv
-            .venv
-          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
-          restore-keys: |
-            uv-main-py${{ matrix.python-version }}-
 
       - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
-          version: "0.8.4"
-          python-version: ${{ matrix.python-version }}
-          enable-cache: false
+          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 the project
-        run: uv sync --all-groups --all-extras
-
-      - name: Restore test durations
-        uses: actions/cache/restore@v4
-        with:
-          path: .test_durations_py*
-          key: test-durations-py${{ matrix.python-version }}
+        run: uv sync --dev --all-extras
 
       - name: Run tests (group ${{ matrix.group }} of 8)
         run: |
-          PYTHON_VERSION_SAFE=$(echo "${{ matrix.python-version }}" | tr '.' '_')
-          DURATION_FILE=".test_durations_py${PYTHON_VERSION_SAFE}"
-          
-          # Temporarily always skip cached durations to fix test splitting
-          # When durations don't match, pytest-split runs duplicate tests instead of splitting
-          echo "Using even test splitting (duration cache disabled until fix merged)"
-          DURATIONS_ARG=""
-          
-          # Original logic (disabled temporarily):
-          # if [ ! -f "$DURATION_FILE" ]; then
-          #   echo "No cached durations found, tests will be split evenly"
-          #   DURATIONS_ARG=""
-          # elif git diff origin/${{ github.base_ref }}...HEAD --name-only 2>/dev/null | grep -q "^tests/.*\.py$"; then
-          #   echo "Test files have changed, skipping cached durations to avoid mismatches"
-          #   DURATIONS_ARG=""
-          # else
-          #   echo "No test changes detected, using cached test durations for optimal splitting"
-          #   DURATIONS_ARG="--durations-path=${DURATION_FILE}"
-          # fi
-          
           uv run pytest \
             --block-network \
             --timeout=30 \
             -vv \
             --splits 8 \
             --group ${{ matrix.group }} \
-            $DURATIONS_ARG \
             --durations=10 \
             -n auto \
             --maxfail=3
-
-      - name: Save uv caches
-        if: steps.cache-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            ~/.cache/uv
-            ~/.local/share/uv
-            .venv
-          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}

.github/workflows/type-checker.yml

@@ -3,7 +3,7 @@ name: Run Type Checks
 on: [pull_request]
 
 permissions:
-  contents: read
+  contents: write
 
 jobs:
   type-checker-matrix:
@@ -20,27 +20,19 @@ jobs:
         with:
           fetch-depth: 0 # Fetch all history for proper diff
 
-      - name: Restore global uv cache
-        id: cache-restore
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            ~/.cache/uv
-            ~/.local/share/uv
-            .venv
-          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
-          restore-keys: |
-            uv-main-py${{ matrix.python-version }}-
-
       - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
-          version: "0.8.4"
-          python-version: ${{ matrix.python-version }}
-          enable-cache: false
+          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 --all-groups --all-extras
+        run: uv sync --dev --no-install-project
 
       - name: Get changed Python files
         id: changed-files
@@ -74,16 +66,6 @@ jobs:
         if: steps.changed-files.outputs.has_changes == 'false'
         run: echo "No Python files in src/ were modified - skipping type checks"
 
-      - name: Save uv caches
-        if: steps.cache-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            ~/.cache/uv
-            ~/.local/share/uv
-            .venv
-          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
-
   # Summary job to provide single status for branch protection
   type-checker:
     name: type-checker

.github/workflows/update-test-durations.yml

@@ -1,71 +0,0 @@
-name: Update Test Durations
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - 'tests/**/*.py'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  update-durations:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ['3.10', '3.11', '3.12', '3.13']
-    env:
-      OPENAI_API_KEY: fake-api-key
-      PYTHONUNBUFFERED: 1
-    
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Restore global uv cache
-        id: cache-restore
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            ~/.cache/uv
-            ~/.local/share/uv
-            .venv
-          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
-          restore-keys: |
-            uv-main-py${{ matrix.python-version }}-
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v6
-        with:
-          version: "0.8.4"
-          python-version: ${{ matrix.python-version }}
-          enable-cache: false
-
-      - name: Install the project
-        run: uv sync --all-groups --all-extras
-
-      - name: Run all tests and store durations
-        run: |
-          PYTHON_VERSION_SAFE=$(echo "${{ matrix.python-version }}" | tr '.' '_')
-          uv run pytest --store-durations --durations-path=.test_durations_py${PYTHON_VERSION_SAFE} -n auto
-        continue-on-error: true
-
-      - name: Save durations to cache
-        if: always()
-        uses: actions/cache/save@v4
-        with:
-          path: .test_durations_py*
-          key: test-durations-py${{ matrix.python-version }}
-
-      - name: Save uv caches
-        if: steps.cache-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            ~/.cache/uv
-            ~/.local/share/uv
-            .venv
-          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}

.pre-commit-config.yaml

@@ -1,19 +1,14 @@
 repos:
-  - repo: local
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.11
     hooks:
       - id: ruff
-        name: ruff
-        entry: uv run ruff check
-        language: system
-        types: [python]
+        args: ["--config", "pyproject.toml"]
       - id: ruff-format
-        name: ruff-format
-        entry: uv run ruff format
-        language: system
-        types: [python]
+        args: ["--config", "pyproject.toml"]
+  
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.17.1
+    hooks:
       - id: mypy
-        name: mypy
-        entry: uv run mypy
-        language: system
-        types: [python]
-        exclude: ^tests/
+        args: ["--config-file", "pyproject.toml"]

docs/en/changelog.mdx

@@ -5,82 +5,6 @@ icon: "clock"
 mode: "wide"
 ---
 
-<Update label="Sep 20, 2025">
-  ## v0.193.2
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.2)
-
-  ## What's Changed
-
-  - Updated pyproject templates to use the right version
-
-</Update>
-
-<Update label="Sep 20, 2025">
-  ## v0.193.1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.1)
-
-  ## What's Changed
-
-  - Series of minor fixes and linter improvements
-
-</Update>
-
-<Update label="Sep 19, 2025">
-  ## v0.193.0
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.0)
-
-  ## Core Improvements & Fixes
-  
-  - Fixed handling of the `model` parameter during OpenAI adapter initialization  
-  - Resolved test duration cache issues in CI workflows  
-  - Fixed flaky test related to repeated tool usage by agents  
-  - Added missing event exports to `__init__.py` for consistent module behavior  
-  - Dropped message storage from metadata in Mem0 to reduce bloat  
-  - Fixed L2 distance metric support for backward compatibility in vector search  
-
-  ## New Features & Enhancements
-  
-  - Introduced thread-safe platform context management  
-  - Added test duration caching for optimized `pytest-split` runs  
-  - Added ephemeral trace improvements for better trace control  
-  - Made search parameters for RAG, knowledge, and memory fully configurable  
-  - Enabled ChromaDB to use OpenAI API for embedding functions  
-  - Added deeper observability tools for user-level insights  
-  - Unified RAG storage system with instance-specific client support  
-
-  ## Documentation & Guides
-  
-  - Updated `RagTool` references to reflect CrewAI native RAG implementation  
-  - Improved internal docs for `langgraph` and `openai` agent adapters with type annotations and docstrings  
-
-</Update>
-
-<Update label="Sep 11, 2025">
-  ## v0.186.1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.186.1)
-
-  ## What's Changed
-
-  - Fixed version not being found and silently failing reversion  
-  - Bumped CrewAI version to 0.186.1 and updated dependencies in the CLI  
-
-</Update>
-
-<Update label="Sep 10, 2025">
-  ## v0.186.0
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.186.0)
-
-  ## What's Changed
-
-  - Refer to the GitHub release notes for detailed changes
-
-</Update>
-
 <Update label="Sep 04, 2025">
   ## v0.177.0
 

docs/en/concepts/cli.mdx

@@ -404,10 +404,6 @@ crewai config reset
 After resetting configuration, re-run `crewai login` to authenticate again.
 </Tip>
 
-<Tip>
-CrewAI CLI handles authentication to the Tool Repository automatically when adding packages to your project. Just append `crewai` before any `uv` command to use it. E.g. `crewai uv add requests`. For more information, see [Tool Repository](https://docs.crewai.com/enterprise/features/tool-repository) docs.
-</Tip>
-
 <Note>
 Configuration settings are stored in `~/.config/crewai/settings.json`. Some settings like organization name and UUID are read-only and managed through authentication and organization commands. Tool repository related settings are hidden and cannot be set directly by users.
 </Note>

docs/en/concepts/memory.mdx

@@ -7,7 +7,7 @@ mode: "wide"
 
 ## Overview
 
-The CrewAI framework provides a sophisticated memory system designed to significantly enhance AI agent capabilities. CrewAI offers **two distinct memory approaches** that serve different use cases:
+The CrewAI framework provides a sophisticated memory system designed to significantly enhance AI agent capabilities. CrewAI offers **three distinct memory approaches** that serve different use cases:
 
 1. **Basic Memory System** - Built-in short-term, long-term, and entity memory
 2. **External Memory** - Standalone external memory providers

docs/en/enterprise/features/tool-repository.mdx

@@ -52,36 +52,6 @@ researcher = Agent(
 )
 ```
 
-## Adding other packages after installing a tool
-
-After installing a tool from the CrewAI Enterprise Tool Repository, you need to use the `crewai uv` command to add other packages to your project.
-Using pure `uv` commands will fail due to authentication to tool repository being handled by the CLI. By using the `crewai uv` command, you can add other packages to your project without having to worry about authentication.
-Any `uv` command can be used with the `crewai uv` command, making it a powerful tool for managing your project's dependencies without the hassle of managing authentication through environment variables or other methods.
-
-Say that you have installed a custom tool from the CrewAI Enterprise Tool Repository called "my-tool":
-
-```bash
-crewai tool install my-tool
-```
-
-And now you want to add another package to your project, you can use the following command:
-
-```bash
-crewai uv add requests
-```
-
-Other commands like `uv sync` or `uv remove` can also be used with the `crewai uv` command:
-
-```bash
-crewai uv sync
-```
-
-```bash
-crewai uv remove requests
-```
-
-This will add the package to your project and update `pyproject.toml` accordingly.
-
 ## Creating and Publishing Tools
 
 To create a new tool project:

docs/en/mcp/overview.mdx

@@ -142,7 +142,7 @@ with MCPServerAdapter(server_params, "tool_name", connect_timeout=60) as mcp_too
 
 ## Using with CrewBase
 
-To use MCPServer tools within a CrewBase class, use the `get_mcp_tools` method. Server configurations should be provided via the `mcp_server_params` attribute. You can pass either a single configuration or a list of multiple server configurations.
+To use MCPServer tools within a CrewBase class, use the `mcp_tools` method. Server configurations should be provided via the mcp_server_params attribute. You can pass either a single configuration or a list of multiple server configurations.
 
 ```python
 @CrewBase
@@ -175,34 +175,6 @@ class CrewWithMCP:
     # ... rest of your crew setup ...
 ```
 
-### Connection Timeout Configuration
-
-You can configure the connection timeout for MCP servers by setting the `mcp_connect_timeout` class attribute. If no timeout is specified, it defaults to 30 seconds.
-
-```python
-@CrewBase
-class CrewWithMCP:
-  mcp_server_params = [...]
-  mcp_connect_timeout = 60  # 60 seconds timeout for all MCP connections
-
-  @agent
-  def your_agent(self):
-      return Agent(config=self.agents_config["your_agent"], tools=self.get_mcp_tools())
-```
-
-```python
-@CrewBase
-class CrewWithDefaultTimeout:
-  mcp_server_params = [...]
-  # No mcp_connect_timeout specified - uses default 30 seconds
-
-  @agent
-  def your_agent(self):
-      return Agent(config=self.agents_config["your_agent"], tools=self.get_mcp_tools())
-```
-
-### Filtering Tools
-
 You can filter which tools are available to your agent by passing a list of tool names to the `get_mcp_tools` method.
 
 ```python
@@ -214,22 +186,6 @@ def another_agent(self):
     )
 ```
 
-The timeout configuration applies to all MCP tool calls within the crew:
-
-```python
-@CrewBase
-class CrewWithCustomTimeout:
-  mcp_server_params = [...]
-  mcp_connect_timeout = 90  # 90 seconds timeout for all MCP connections
-
-  @agent
-  def filtered_agent(self):
-      return Agent(
-        config=self.agents_config["your_agent"],
-        tools=self.get_mcp_tools("tool_1", "tool_2") # specific tools with custom timeout
-      )
-```
-
 ## Explore MCP Integrations
 
 <CardGroup cols={2}>

docs/en/quickstart.mdx

@@ -27,7 +27,7 @@ Follow the steps below to get Crewing! 🚣‍♂️
   <Step title="Navigate to your new crew project">
     <CodeGroup>
       ```shell Terminal
-      cd latest_ai_development
+      cd latest-ai-development
       ```
     </CodeGroup>
   </Step>

docs/en/tools/ai-ml/ragtool.mdx

@@ -9,7 +9,7 @@ mode: "wide"
 
 ## Description
 
-The `RagTool` is designed to answer questions by leveraging the power of Retrieval-Augmented Generation (RAG) through CrewAI's native RAG system.
+The `RagTool` is designed to answer questions by leveraging the power of Retrieval-Augmented Generation (RAG) through EmbedChain.
 It provides a dynamic knowledge base that can be queried to retrieve relevant information from various data sources.
 This tool is particularly useful for applications that require access to a vast array of information and need to provide contextually relevant answers.
 
@@ -76,8 +76,8 @@ The `RagTool` can be used with a wide variety of data sources, including:
 The `RagTool` accepts the following parameters:
 
 - **summarize**: Optional. Whether to summarize the retrieved content. Default is `False`.
-- **adapter**: Optional. A custom adapter for the knowledge base. If not provided, a CrewAIRagAdapter will be used.
-- **config**: Optional. Configuration for the underlying CrewAI RAG system.
+- **adapter**: Optional. A custom adapter for the knowledge base. If not provided, an EmbedchainAdapter will be used.
+- **config**: Optional. Configuration for the underlying EmbedChain App.
 
 ## Adding Content
 
@@ -130,23 +130,44 @@ from crewai_tools import RagTool
 
 # Create a RAG tool with custom configuration
 config = {
-    "vectordb": {
-        "provider": "qdrant",
+    "app": {
+        "name": "custom_app",
+    },
+    "llm": {
+        "provider": "openai",
         "config": {
-            "collection_name": "my-collection"
+            "model": "gpt-4",
         }
     },
     "embedding_model": {
         "provider": "openai",
         "config": {
-            "model": "text-embedding-3-small"
+            "model": "text-embedding-ada-002"
         }
+    },
+    "vectordb": {
+        "provider": "elasticsearch",
+        "config": {
+            "collection_name": "my-collection",
+            "cloud_id": "deployment-name:xxxx",
+            "api_key": "your-key",
+            "verify_certs": False
+        }
+    },
+    "chunker": {
+        "chunk_size": 400,
+        "chunk_overlap": 100,
+        "length_function": "len",
+        "min_chunk_size": 0
     }
 }
 
 rag_tool = RagTool(config=config, summarize=True)
 ```
 
+The internal RAG tool utilizes the Embedchain adapter, allowing you to pass any configuration options that are supported by Embedchain.
+You can refer to the [Embedchain documentation](https://docs.embedchain.ai/components/introduction) for details.
+Make sure to review the configuration options available in the .yaml file.
 
 ## Conclusion
 The `RagTool` provides a powerful way to create and query knowledge bases from various data sources. By leveraging Retrieval-Augmented Generation, it enables agents to access and retrieve relevant information efficiently, enhancing their ability to provide accurate and contextually appropriate responses.

docs/ko/changelog.mdx

@@ -5,82 +5,6 @@ icon: "clock"
 mode: "wide"
 ---
 
-<Update label="2025년 9월 20일">
-  ## v0.193.2
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.193.2)
-
-  ## 변경 사항
-  
-  - 올바른 버전을 사용하도록 pyproject 템플릿 업데이트
-
-</Update>
-
-<Update label="2025년 9월 20일">
-  ## v0.193.1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.193.1)
-
-  ## 변경 사항
-  
-  - 일련의 사소한 수정 및 린터 개선
-
-</Update>
-
-<Update label="2025년 9월 19일">
-  ## v0.193.0
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.193.0)
-
-  ## 핵심 개선 사항 및 수정 사항
-  
-  - OpenAI 어댑터 초기화 중 `model` 매개변수 처리 수정  
-  - CI 워크플로에서 테스트 소요 시간 캐시 문제 해결  
-  - 에이전트의 반복 도구 사용과 관련된 불안정한 테스트 수정  
-  - 일관된 모듈 동작을 위해 누락된 이벤트 내보내기를 `__init__.py`에 추가  
-  - 메타데이터 부하를 줄이기 위해 Mem0에서 메시지 저장 제거  
-  - 벡터 검색의 하위 호환성을 위해 L2 거리 메트릭 지원 수정  
-
-  ## 새로운 기능 및 향상 사항
-  
-  - 스레드 안전한 플랫폼 컨텍스트 관리 도입  
-  - `pytest-split` 실행 최적화를 위한 테스트 소요 시간 캐싱 추가  
-  - 더 나은 추적 제어를 위한 일시적(trace) 개선  
-  - RAG, 지식, 메모리 검색 매개변수를 완전 구성 가능하게 변경  
-  - ChromaDB가 임베딩 함수에 OpenAI API를 사용할 수 있도록 지원  
-  - 사용자 수준 인사이트를 위한 심화된 관찰 가능성 도구 추가  
-  - 인스턴스별 클라이언트를 지원하는 통합 RAG 스토리지 시스템  
-
-  ## 문서 및 가이드
-  
-  - CrewAI 네이티브 RAG 구현을 반영하도록 `RagTool` 참조 업데이트  
-  - 타입 주석과 도크스트링을 포함해 `langgraph` 및 `openai` 에이전트 어댑터 내부 문서 개선  
-
-</Update>
-
-<Update label="2025년 9월 11일">
-  ## v0.186.1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.186.1)
-
-  ## 변경 사항
-  
-  - 버전을 찾지 못해 조용히 되돌리는(reversion) 문제 수정  
-  - CLI에서 CrewAI 버전을 0.186.1로 올리고 의존성 업데이트  
-
-</Update>
-
-<Update label="2025년 9월 10일">
-  ## v0.186.0
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.186.0)
-
-  ## 변경 사항
-  
-  - 자세한 변경 사항은 GitHub 릴리스 노트를 참조하세요
-
-</Update>
-
 <Update label="2025년 9월 4일">
   ## v0.177.0
 

docs/ko/mcp/overview.mdx

@@ -7,8 +7,8 @@ mode: "wide"
 
 ## 개요
 
-[Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP)는 AI 에이전트가 MCP 서버로 알려진 외부 서비스와 통신함으로써 LLM에 컨텍스트를 제공할 수 있도록 표준화된 방식을 제공합니다.
-`crewai-tools` 라이브러리는 CrewAI의 기능을 확장하여, 이러한 MCP 서버에서 제공하는 툴을 에이전트에 원활하게 통합할 수 있도록 해줍니다.
+[Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP)는 AI 에이전트가 MCP 서버로 알려진 외부 서비스와 통신함으로써 LLM에 컨텍스트를 제공할 수 있도록 표준화된 방식을 제공합니다.  
+`crewai-tools` 라이브러리는 CrewAI의 기능을 확장하여, 이러한 MCP 서버에서 제공하는 툴을 에이전트에 원활하게 통합할 수 있도록 해줍니다.  
 이를 통해 여러분의 crew는 방대한 기능 에코시스템에 접근할 수 있습니다.
 
 현재 다음과 같은 전송 메커니즘을 지원합니다:
@@ -142,7 +142,7 @@ with MCPServerAdapter(server_params, "tool_name", connect_timeout=60) as mcp_too
 
 ## CrewBase와 함께 사용하기
 
-CrewBase 클래스 내에서 MCPServer 도구를 사용하려면 `get_mcp_tools` 메서드를 사용하세요. 서버 구성은 `mcp_server_params` 속성을 통해 제공되어야 합니다. 단일 구성 또는 여러 서버 구성을 리스트 형태로 전달할 수 있습니다.
+CrewBase 클래스 내에서 MCPServer 도구를 사용하려면 `mcp_tools` 메서드를 사용하세요. 서버 구성은 mcp_server_params 속성을 통해 제공되어야 합니다. 단일 구성 또는 여러 서버 구성을 리스트 형태로 전달할 수 있습니다.
 
 ```python
 @CrewBase
@@ -175,34 +175,6 @@ class CrewWithMCP:
     # ... 나머지 crew 설정 ...
 ```
 
-### 연결 타임아웃 구성
-
-`mcp_connect_timeout` 클래스 속성을 설정하여 MCP 서버의 연결 타임아웃을 구성할 수 있습니다. 타임아웃을 지정하지 않으면 기본값으로 30초가 사용됩니다.
-
-```python
-@CrewBase
-class CrewWithMCP:
-  mcp_server_params = [...]
-  mcp_connect_timeout = 60  # 모든 MCP 연결에 60초 타임아웃
-
-  @agent
-  def your_agent(self):
-      return Agent(config=self.agents_config["your_agent"], tools=self.get_mcp_tools())
-```
-
-```python
-@CrewBase
-class CrewWithDefaultTimeout:
-  mcp_server_params = [...]
-  # mcp_connect_timeout 지정하지 않음 - 기본 30초 사용
-
-  @agent
-  def your_agent(self):
-      return Agent(config=self.agents_config["your_agent"], tools=self.get_mcp_tools())
-```
-
-### 도구 필터링
-
 `get_mcp_tools` 메서드에 도구 이름의 리스트를 전달하여, 에이전트에 제공되는 도구를 필터링할 수 있습니다.
 
 ```python
@@ -214,22 +186,6 @@ def another_agent(self):
     )
 ```
 
-타임아웃 구성은 crew 내의 모든 MCP 도구 호출에 적용됩니다:
-
-```python
-@CrewBase
-class CrewWithCustomTimeout:
-  mcp_server_params = [...]
-  mcp_connect_timeout = 90  # 모든 MCP 연결에 90초 타임아웃
-
-  @agent
-  def filtered_agent(self):
-      return Agent(
-        config=self.agents_config["your_agent"],
-        tools=self.get_mcp_tools("tool_1", "tool_2") # 사용자 지정 타임아웃으로 특정 도구
-      )
-```
-
 ## MCP 통합 탐색
 
 <CardGroup cols={2}>
@@ -305,4 +261,4 @@ SSE 전송은 적절하게 보안되지 않은 경우 DNS 리바인딩 공격에
 
 ### 제한 사항
 *   **지원되는 프리미티브**: 현재 `MCPServerAdapter`는 주로 MCP `tools`를 어댑팅하는 기능을 지원합니다. 다른 MCP 프리미티브(예: `prompts` 또는 `resources`)는 현재 이 어댑터를 통해 CrewAI 컴포넌트로 직접 통합되어 있지 않습니다.
-*   **출력 처리**: 어댑터는 일반적으로 MCP tool의 주요 텍스트 출력(예: `.content[0].text`)을 처리합니다. 복잡하거나 멀티모달 출력의 경우 이 패턴에 맞지 않으면 별도의 커스텀 처리가 필요할 수 있습니다.
+*   **출력 처리**: 어댑터는 일반적으로 MCP tool의 주요 텍스트 출력(예: `.content[0].text`)을 처리합니다. 복잡하거나 멀티모달 출력의 경우 이 패턴에 맞지 않으면 별도의 커스텀 처리가 필요할 수 있습니다.

docs/ko/quickstart.mdx

@@ -27,7 +27,7 @@ mode: "wide"
   <Step title="새로운 crew 프로젝트로 이동하기">
     <CodeGroup>
       ```shell Terminal
-      cd latest_ai_development
+      cd latest-ai-development
       ```
     </CodeGroup>
   </Step>

docs/pt-BR/changelog.mdx

@@ -5,82 +5,6 @@ icon: "clock"
 mode: "wide"
 ---
 
-<Update label="20 set 2025">
-  ## v0.193.2
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.2)
-
-  ## O que Mudou
-
-  - Atualizados templates do pyproject para usar a versão correta
-
-</Update>
-
-<Update label="20 set 2025">
-  ## v0.193.1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.1)
-
-  ## O que Mudou
-
-  - Série de pequenas correções e melhorias de linter
-
-</Update>
-
-<Update label="19 set 2025">
-  ## v0.193.0
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.0)
-
-  ## Melhorias e Correções Principais
-  
-  - Corrigido manuseio do parâmetro `model` durante a inicialização do adaptador OpenAI  
-  - Resolvidos problemas de cache da duração de testes nos fluxos de CI  
-  - Corrigido teste instável relacionado ao uso repetido de ferramentas pelos agentes  
-  - Adicionadas exportações de eventos ausentes no `__init__.py` para comportamento consistente do módulo  
-  - Removido armazenamento de mensagem dos metadados no Mem0 para reduzir inchaço  
-  - Corrigido suporte à métrica de distância L2 para compatibilidade retroativa na busca vetorial  
-
-  ## Novos Recursos e Melhorias
-  
-  - Introduzida gestão de contexto de plataforma com segurança de threads  
-  - Adicionado cache da duração de testes para execuções otimizadas do `pytest-split`  
-  - Melhorias de traces efêmeros para melhor controle de rastreamento  
-  - Parâmetros de busca para RAG, conhecimento e memória totalmente configuráveis  
-  - Habilitado ChromaDB para usar a OpenAI API para funções de embedding  
-  - Adicionadas ferramentas de observabilidade mais profundas para insights ao nível do usuário  
-  - Sistema de armazenamento RAG unificado com suporte a cliente específico por instância  
-
-  ## Documentação e Guias
-  
-  - Atualizadas referências do `RagTool` para refletir a implementação nativa de RAG do CrewAI  
-  - Melhorada documentação interna para adaptadores de agente `langgraph` e `openai` com anotações de tipo e docstrings  
-
-</Update>
-
-<Update label="11 set 2025">
-  ## v0.186.1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.186.1)
-
-  ## O que Mudou
-
-  - Corrigida falha silenciosa de reversão quando a versão não era encontrada  
-  - Versão do CrewAI atualizada para 0.186.1 e dependências do CLI atualizadas  
-
-</Update>
-
-<Update label="10 set 2025">
-  ## v0.186.0
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.186.0)
-
-  ## O que Mudou
-
-  - Consulte as notas de lançamento no GitHub para detalhes completos
-
-</Update>
-
 <Update label="04 set 2025">
   ## v0.177.0
 

docs/pt-BR/mcp/overview.mdx

@@ -118,7 +118,7 @@ with MCPServerAdapter(server_params, connect_timeout=60) as mcp_tools:
 
 ## Usando com CrewBase
 
-Para usar ferramentas de servidores MCP dentro de uma classe CrewBase, utilize o método `get_mcp_tools`. As configurações dos servidores devem ser fornecidas via o atributo `mcp_server_params`. Você pode passar uma configuração única ou uma lista com múltiplas configurações.
+Para usar ferramentas de servidores MCP dentro de uma classe CrewBase, utilize o método `mcp_tools`. As configurações dos servidores devem ser fornecidas via o atributo mcp_server_params. Você pode passar uma configuração única ou uma lista com múltiplas configurações.
 
 ```python
 @CrewBase
@@ -146,65 +146,10 @@ class CrewWithMCP:
 
   @agent
   def your_agent(self):
-      return Agent(config=self.agents_config["your_agent"], tools=self.get_mcp_tools()) # obter todas as ferramentas disponíveis
+      return Agent(config=self.agents_config["your_agent"], tools=self.get_mcp_tools()) # você também pode filtrar quais ferramentas estarão disponíveis
 
     # ... restante da configuração do seu crew ...
 ```
-
-### Configuração de Timeout de Conexão
-
-Você pode configurar o timeout de conexão para servidores MCP definindo o atributo de classe `mcp_connect_timeout`. Se nenhum timeout for especificado, o padrão é 30 segundos.
-
-```python
-@CrewBase
-class CrewWithMCP:
-  mcp_server_params = [...]
-  mcp_connect_timeout = 60  # timeout de 60 segundos para todas as conexões MCP
-
-  @agent
-  def your_agent(self):
-      return Agent(config=self.agents_config["your_agent"], tools=self.get_mcp_tools())
-```
-
-```python
-@CrewBase
-class CrewWithDefaultTimeout:
-  mcp_server_params = [...]
-  # Nenhum mcp_connect_timeout especificado - usa padrão de 30 segundos
-
-  @agent
-  def your_agent(self):
-      return Agent(config=self.agents_config["your_agent"], tools=self.get_mcp_tools())
-```
-
-### Filtragem de Ferramentas
-
-Você pode filtrar quais ferramentas estão disponíveis para seu agente passando uma lista de nomes de ferramentas para o método `get_mcp_tools`.
-
-```python
-@agent
-def another_agent(self):
-    return Agent(
-      config=self.agents_config["your_agent"],
-      tools=self.get_mcp_tools("tool_1", "tool_2") # obter ferramentas específicas
-    )
-```
-
-A configuração de timeout se aplica a todas as chamadas de ferramentas MCP dentro do crew:
-
-```python
-@CrewBase
-class CrewWithCustomTimeout:
-  mcp_server_params = [...]
-  mcp_connect_timeout = 90  # timeout de 90 segundos para todas as conexões MCP
-
-  @agent
-  def filtered_agent(self):
-      return Agent(
-        config=self.agents_config["your_agent"],
-        tools=self.get_mcp_tools("tool_1", "tool_2") # ferramentas específicas com timeout personalizado
-      )
-```
 ## Explore Integrações MCP
 
 <CardGroup cols={2}>

docs/pt-BR/quickstart.mdx

@@ -27,7 +27,7 @@ Siga os passos abaixo para começar a tripular! 🚣‍♂️
   <Step title="Navegue até o novo projeto da sua tripulação">
     <CodeGroup>
       ```shell Terminal
-      cd latest_ai_development
+      cd latest-ai-development
       ```
     </CodeGroup>
   </Step>

pyproject.toml

@@ -9,7 +9,7 @@ authors = [
 ]
 dependencies = [
     # Core Dependencies
-    "pydantic>=2.11.9",
+    "pydantic>=2.4.2",
     "openai>=1.13.3",
     "litellm==1.74.9",
     "instructor>=1.3.3",
@@ -21,12 +21,13 @@ dependencies = [
     "opentelemetry-sdk>=1.30.0",
     "opentelemetry-exporter-otlp-proto-http>=1.30.0",
     # Data Handling
-    "chromadb~=1.1.0",
+    "chromadb>=0.5.23",
     "tokenizers>=0.20.3",
+    "onnxruntime==1.22.0",
     "openpyxl>=3.1.5",
     "pyvis>=0.3.2",
     # Authentication and Security
-    "python-dotenv>=1.1.1",
+    "python-dotenv>=1.0.0",
     "pyjwt>=2.9.0",
     # Configuration and Utils
     "click>=8.1.7",
@@ -39,7 +40,6 @@ dependencies = [
     "blinker>=1.9.0",
     "json5>=0.10.0",
     "portalocker==2.7.0",
-    "pydantic-settings>=2.10.1",
 ]
 
 [project.urls]
@@ -48,9 +48,7 @@ Documentation = "https://docs.crewai.com"
 Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
-tools = [
-    "crewai-tools>=0.74.0",
-]
+tools = ["crewai-tools~=0.69.0"]
 embeddings = [
     "tiktoken~=0.8.0"
 ]
@@ -73,30 +71,24 @@ aisuite = [
 qdrant = [
     "qdrant-client[fastembed]>=1.14.3",
 ]
-aws = [
-    "boto3>=1.40.38",
-]
-watson = [
-    "ibm-watsonx-ai>=1.3.39",
-]
-voyageai = [
-    "voyageai>=0.3.5",
-]
 
-[dependency-groups]
-dev = [
-    "ruff>=0.13.1",
-    "mypy>=1.18.2",
+[tool.uv]
+dev-dependencies = [
+    "ruff>=0.12.11",
+    "mypy>=1.17.1",
     "pre-commit>=4.3.0",
     "bandit>=1.8.6",
-    "pytest>=8.4.2",
-    "pytest-asyncio>=1.2.0",
-    "pytest-subprocess>=1.5.3",
-    "pytest-recording>=0.13.4",
-    "pytest-randomly>=4.0.1",
-    "pytest-timeout>=2.4.0",
-    "pytest-xdist>=3.8.0",
-    "pytest-split>=0.10.0",
+    "pillow>=10.2.0",
+    "cairosvg>=2.7.1",
+    "pytest>=8.0.0",
+    "python-dotenv>=1.0.0",
+    "pytest-asyncio>=0.23.7",
+    "pytest-subprocess>=1.5.2",
+    "pytest-recording>=0.13.2",
+    "pytest-randomly>=3.16.0",
+    "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.*",
@@ -139,15 +131,9 @@ select = [
     "I001",   # sort imports
     "I002",   # remove unused imports
 ]
-ignore = ["E501"]  # ignore line too long globally
-
-[tool.ruff.lint.per-file-ignores]
-"tests/**/*.py" = ["S101", "RET504"]  # Allow assert statements and unnecessary assignments before return in tests
 
 [tool.mypy]
-exclude = ["src/crewai/cli/templates", "tests/"]
-plugins = ["pydantic.mypy"]
-
+exclude = ["src/crewai/cli/templates", "tests"]
 
 [tool.bandit]
 exclude_dirs = ["src/crewai/cli/templates"]

src/crewai/__init__.py

@@ -1,21 +1,6 @@
-import threading
-import urllib.request
 import warnings
 from typing import Any
 
-from crewai.agent import Agent
-from crewai.crew import Crew
-from crewai.crews.crew_output import CrewOutput
-from crewai.flow.flow import Flow
-from crewai.knowledge.knowledge import Knowledge
-from crewai.llm import LLM
-from crewai.llms.base_llm import BaseLLM
-from crewai.process import Process
-from crewai.task import Task
-from crewai.tasks.llm_guardrail import LLMGuardrail
-from crewai.tasks.task_output import TaskOutput
-from crewai.telemetry.telemetry import Telemetry
-
 
 def _suppress_pydantic_deprecation_warnings() -> None:
     """Suppress Pydantic deprecation warnings using targeted monkey patch."""
@@ -35,12 +20,27 @@ def _suppress_pydantic_deprecation_warnings() -> None:
             return None
         return original_warn(message, category, stacklevel + 1, source)
 
-    warnings.warn = filtered_warn  # type: ignore[assignment]
+    setattr(warnings, "warn", filtered_warn)
 
 
 _suppress_pydantic_deprecation_warnings()
 
-__version__ = "0.201.1"
+import threading
+import urllib.request
+
+from crewai.agent import Agent
+from crewai.crew import Crew
+from crewai.crews.crew_output import CrewOutput
+from crewai.flow.flow import Flow
+from crewai.knowledge.knowledge import Knowledge
+from crewai.llm import LLM
+from crewai.llms.base_llm import BaseLLM
+from crewai.process import Process
+from crewai.task import Task
+from crewai.tasks.llm_guardrail import LLMGuardrail
+from crewai.tasks.task_output import TaskOutput
+from crewai.telemetry.telemetry import Telemetry
+
 _telemetry_submitted = False
 
 
@@ -54,12 +54,13 @@ def _track_install() -> None:
     try:
         pixel_url = "https://api.scarf.sh/v2/packages/CrewAI/crewai/docs/00f2dad1-8334-4a39-934e-003b2e1146db"
 
-        req = urllib.request.Request(pixel_url)  # noqa: S310
+        req = urllib.request.Request(pixel_url)
         req.add_header("User-Agent", f"CrewAI-Python/{__version__}")
 
-        with urllib.request.urlopen(req, timeout=2):  # noqa: S310
+        with urllib.request.urlopen(req, timeout=2):  # nosec B310
             _telemetry_submitted = True
-    except Exception:  # noqa: S110
+
+    except Exception:
         pass
 
 
@@ -71,17 +72,19 @@ def _track_install_async() -> None:
 
 
 _track_install_async()
+
+__version__ = "0.177.0"
 __all__ = [
-    "LLM",
     "Agent",
-    "BaseLLM",
     "Crew",
     "CrewOutput",
-    "Flow",
-    "Knowledge",
-    "LLMGuardrail",
     "Process",
     "Task",
+    "LLM",
+    "BaseLLM",
+    "Flow",
+    "Knowledge",
     "TaskOutput",
+    "LLMGuardrail",
     "__version__",
 ]

src/crewai/agent.py

@@ -1,10 +1,17 @@
 import shutil
 import subprocess
 import time
-from collections.abc import Callable, Sequence
 from typing import (
     Any,
+    Callable,
+    Dict,
+    List,
     Literal,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
 )
 
 from pydantic import Field, InstanceOf, PrivateAttr, model_validator
@@ -12,31 +19,12 @@ from pydantic import Field, InstanceOf, PrivateAttr, model_validator
 from crewai.agents import CacheHandler
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.agents.crew_agent_executor import CrewAgentExecutor
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.agent_events import (
-    AgentExecutionCompletedEvent,
-    AgentExecutionErrorEvent,
-    AgentExecutionStartedEvent,
-)
-from crewai.events.types.knowledge_events import (
-    KnowledgeQueryCompletedEvent,
-    KnowledgeQueryFailedEvent,
-    KnowledgeQueryStartedEvent,
-    KnowledgeRetrievalCompletedEvent,
-    KnowledgeRetrievalStartedEvent,
-    KnowledgeSearchQueryFailedEvent,
-)
-from crewai.events.types.memory_events import (
-    MemoryRetrievalCompletedEvent,
-    MemoryRetrievalStartedEvent,
-)
 from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.knowledge.utils.knowledge_utils import extract_knowledge_context
 from crewai.lite_agent import LiteAgent, LiteAgentOutput
 from crewai.llm import BaseLLM
 from crewai.memory.contextual.contextual_memory import ContextualMemory
-from crewai.rag.embeddings.types import EmbedderConfig
 from crewai.security import Fingerprint
 from crewai.task import Task
 from crewai.tools import BaseTool
@@ -50,6 +38,24 @@ from crewai.utilities.agent_utils import (
 )
 from crewai.utilities.constants import TRAINED_AGENTS_DATA_FILE, TRAINING_DATA_FILE
 from crewai.utilities.converter import generate_model_description
+from crewai.events.types.agent_events import (
+    AgentExecutionCompletedEvent,
+    AgentExecutionErrorEvent,
+    AgentExecutionStartedEvent,
+)
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.memory_events import (
+    MemoryRetrievalStartedEvent,
+    MemoryRetrievalCompletedEvent,
+)
+from crewai.events.types.knowledge_events import (
+    KnowledgeQueryCompletedEvent,
+    KnowledgeQueryFailedEvent,
+    KnowledgeQueryStartedEvent,
+    KnowledgeRetrievalCompletedEvent,
+    KnowledgeRetrievalStartedEvent,
+    KnowledgeSearchQueryFailedEvent,
+)
 from crewai.utilities.llm_utils import create_llm
 from crewai.utilities.token_counter_callback import TokenCalcHandler
 from crewai.utilities.training_handler import CrewTrainingHandler
@@ -81,36 +87,36 @@ class Agent(BaseAgent):
     """
 
     _times_executed: int = PrivateAttr(default=0)
-    max_execution_time: int | None = Field(
+    max_execution_time: Optional[int] = Field(
         default=None,
         description="Maximum execution time for an agent to execute a task",
     )
     agent_ops_agent_name: str = None  # type: ignore # Incompatible types in assignment (expression has type "None", variable has type "str")
     agent_ops_agent_id: str = None  # type: ignore # Incompatible types in assignment (expression has type "None", variable has type "str")
-    step_callback: Any | None = Field(
+    step_callback: Optional[Any] = Field(
         default=None,
         description="Callback to be executed after each step of the agent execution.",
     )
-    use_system_prompt: bool | None = Field(
+    use_system_prompt: Optional[bool] = Field(
         default=True,
         description="Use system prompt for the agent.",
     )
-    llm: str | InstanceOf[BaseLLM] | Any = Field(
+    llm: Union[str, InstanceOf[BaseLLM], Any] = Field(
         description="Language model that will run the agent.", default=None
     )
-    function_calling_llm: str | InstanceOf[BaseLLM] | Any | None = Field(
+    function_calling_llm: Optional[Union[str, InstanceOf[BaseLLM], Any]] = Field(
         description="Language model that will run the agent.", default=None
     )
-    system_template: str | None = Field(
+    system_template: Optional[str] = Field(
         default=None, description="System format for the agent."
     )
-    prompt_template: str | None = Field(
+    prompt_template: Optional[str] = Field(
         default=None, description="Prompt format for the agent."
     )
-    response_template: str | None = Field(
+    response_template: Optional[str] = Field(
         default=None, description="Response format for the agent."
     )
-    allow_code_execution: bool | None = Field(
+    allow_code_execution: Optional[bool] = Field(
         default=False, description="Enable code execution for the agent."
     )
     respect_context_window: bool = Field(
@@ -141,31 +147,31 @@ class Agent(BaseAgent):
         default=False,
         description="Whether the agent should reflect and create a plan before executing a task.",
     )
-    max_reasoning_attempts: int | None = Field(
+    max_reasoning_attempts: Optional[int] = Field(
         default=None,
         description="Maximum number of reasoning attempts before executing the task. If None, will try until ready.",
     )
-    embedder: EmbedderConfig | None = Field(
+    embedder: Optional[Dict[str, Any]] = Field(
         default=None,
         description="Embedder configuration for the agent.",
     )
-    agent_knowledge_context: str | None = Field(
+    agent_knowledge_context: Optional[str] = Field(
         default=None,
         description="Knowledge context for the agent.",
     )
-    crew_knowledge_context: str | None = Field(
+    crew_knowledge_context: Optional[str] = Field(
         default=None,
         description="Knowledge context for the crew.",
     )
-    knowledge_search_query: str | None = Field(
+    knowledge_search_query: Optional[str] = Field(
         default=None,
         description="Knowledge search query for the agent dynamically generated by the agent.",
     )
-    from_repository: str | None = Field(
+    from_repository: Optional[str] = Field(
         default=None,
         description="The Agent's role to be used from your repository.",
     )
-    guardrail: Callable[[Any], tuple[bool, Any]] | str | None = Field(
+    guardrail: Optional[Union[Callable[[Any], Tuple[bool, Any]], str]] = Field(
         default=None,
         description="Function or string description of a guardrail to validate agent output",
     )
@@ -174,7 +180,7 @@ class Agent(BaseAgent):
     )
 
     @model_validator(mode="before")
-    def validate_from_repository(cls, v): # noqa: N805
+    def validate_from_repository(cls, v):
         if v is not None and (from_repository := v.get("from_repository")):
             return load_agent_from_repository(from_repository) | v
         return v
@@ -202,7 +208,7 @@ class Agent(BaseAgent):
             self.cache_handler = CacheHandler()
         self.set_cache_handler(self.cache_handler)
 
-    def set_knowledge(self, crew_embedder: EmbedderConfig | None = None):
+    def set_knowledge(self, crew_embedder: Optional[Dict[str, Any]] = None):
         try:
             if self.embedder is None and crew_embedder:
                 self.embedder = crew_embedder
@@ -218,7 +224,7 @@ class Agent(BaseAgent):
                     )
                     self.knowledge.add_sources()
         except (TypeError, ValueError) as e:
-            raise ValueError(f"Invalid Knowledge Configuration: {e!s}") from e
+            raise ValueError(f"Invalid Knowledge Configuration: {str(e)}")
 
     def _is_any_available_memory(self) -> bool:
         """Check if any memory is available."""
@@ -238,8 +244,8 @@ class Agent(BaseAgent):
     def execute_task(
         self,
         task: Task,
-        context: str | None = None,
-        tools: list[BaseTool] | None = None,
+        context: Optional[str] = None,
+        tools: Optional[List[BaseTool]] = None,
     ) -> str:
         """Execute a task with the agent.
 
@@ -272,9 +278,11 @@ class Agent(BaseAgent):
                 task.description += f"\n\nReasoning Plan:\n{reasoning_output.plan.plan}"
             except Exception as e:
                 if hasattr(self, "_logger"):
-                    self._logger.log("error", f"Error during reasoning process: {e!s}")
+                    self._logger.log(
+                        "error", f"Error during reasoning process: {str(e)}"
+                    )
                 else:
-                    print(f"Error during reasoning process: {e!s}")
+                    print(f"Error during reasoning process: {str(e)}")
 
         self._inject_date_to_task(task)
 
@@ -327,7 +335,7 @@ class Agent(BaseAgent):
                 agent=self,
                 task=task,
             )
-            memory = contextual_memory.build_context_for_task(task, context)  # type: ignore[arg-type]
+            memory = contextual_memory.build_context_for_task(task, context)
             if memory.strip() != "":
                 task_prompt += self.i18n.slice("memory").format(memory=memory)
 
@@ -517,14 +525,14 @@ class Agent(BaseAgent):
 
             try:
                 return future.result(timeout=timeout)
-            except concurrent.futures.TimeoutError as e:
+            except concurrent.futures.TimeoutError:
                 future.cancel()
                 raise TimeoutError(
                     f"Task '{task.description}' execution timed out after {timeout} seconds. Consider increasing max_execution_time or optimizing the task."
-                ) from e
+                )
             except Exception as e:
                 future.cancel()
-                raise RuntimeError(f"Task execution failed: {e!s}") from e
+                raise RuntimeError(f"Task execution failed: {str(e)}")
 
     def _execute_without_timeout(self, task_prompt: str, task: Task) -> str:
         """Execute a task without a timeout.
@@ -546,14 +554,14 @@ class Agent(BaseAgent):
         )["output"]
 
     def create_agent_executor(
-        self, tools: list[BaseTool] | None = None, task=None
+        self, tools: Optional[List[BaseTool]] = None, task=None
     ) -> None:
         """Create an agent executor for the agent.
 
         Returns:
             An instance of the CrewAgentExecutor class.
         """
-        raw_tools: list[BaseTool] = tools or self.tools or []
+        raw_tools: List[BaseTool] = tools or self.tools or []
         parsed_tools = parse_tools(raw_tools)
 
         prompt = Prompts(
@@ -579,7 +587,7 @@ class Agent(BaseAgent):
             agent=self,
             crew=self.crew,
             tools=parsed_tools,
-            prompt=prompt,  # type: ignore[arg-type]
+            prompt=prompt,
             original_tools=raw_tools,
             stop_words=stop_words,
             max_iter=self.max_iter,
@@ -595,9 +603,10 @@ class Agent(BaseAgent):
             callbacks=[TokenCalcHandler(self._token_process)],
         )
 
-    def get_delegation_tools(self, agents: list[BaseAgent]):
+    def get_delegation_tools(self, agents: List[BaseAgent]):
         agent_tools = AgentTools(agents=agents)
-        return agent_tools.tools()
+        tools = agent_tools.tools()
+        return tools
 
     def get_multimodal_tools(self) -> Sequence[BaseTool]:
         from crewai.tools.agent_tools.add_image_tool import AddImageTool
@@ -645,7 +654,7 @@ class Agent(BaseAgent):
                 )
         return task_prompt
 
-    def _render_text_description(self, tools: list[Any]) -> str:
+    def _render_text_description(self, tools: List[Any]) -> str:
         """Render the tool name and description in plain text.
 
         Output will be in the format of:
@@ -655,13 +664,15 @@ class Agent(BaseAgent):
             search: This tool is used for search
             calculator: This tool is used for math
         """
-        return "\n".join(
+        description = "\n".join(
             [
                 f"Tool name: {tool.name}\nTool description:\n{tool.description}"
                 for tool in tools
             ]
         )
 
+        return description
+
     def _inject_date_to_task(self, task):
         """Inject the current date into the task description if inject_date is enabled."""
         if self.inject_date:
@@ -685,13 +696,13 @@ class Agent(BaseAgent):
                 if not is_valid:
                     raise ValueError(f"Invalid date format: {self.date_format}")
 
-                current_date = datetime.now().strftime(self.date_format)
+                current_date: str = datetime.now().strftime(self.date_format)
                 task.description += f"\n\nCurrent Date: {current_date}"
             except Exception as e:
                 if hasattr(self, "_logger"):
-                    self._logger.log("warning", f"Failed to inject date: {e!s}")
+                    self._logger.log("warning", f"Failed to inject date: {str(e)}")
                 else:
-                    print(f"Warning: Failed to inject date: {e!s}")
+                    print(f"Warning: Failed to inject date: {str(e)}")
 
     def _validate_docker_installation(self) -> None:
         """Check if Docker is installed and running."""
@@ -702,15 +713,15 @@ class Agent(BaseAgent):
 
         try:
             subprocess.run(
-                ["/usr/bin/docker", "info"],
+                ["docker", "info"],
                 check=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
             )
-        except subprocess.CalledProcessError as e:
+        except subprocess.CalledProcessError:
             raise RuntimeError(
                 f"Docker is not running. Please start Docker to use code execution with agent: {self.role}"
-            ) from e
+            )
 
     def __repr__(self):
         return f"Agent(role={self.role}, goal={self.goal}, backstory={self.backstory})"
@@ -785,8 +796,8 @@ class Agent(BaseAgent):
 
     def kickoff(
         self,
-        messages: str | list[dict[str, str]],
-        response_format: type[Any] | None = None,
+        messages: Union[str, List[Dict[str, str]]],
+        response_format: Optional[Type[Any]] = None,
     ) -> LiteAgentOutput:
         """
         Execute the agent with the given messages using a LiteAgent instance.
@@ -825,8 +836,8 @@ class Agent(BaseAgent):
 
     async def kickoff_async(
         self,
-        messages: str | list[dict[str, str]],
-        response_format: type[Any] | None = None,
+        messages: Union[str, List[Dict[str, str]]],
+        response_format: Optional[Type[Any]] = None,
     ) -> LiteAgentOutput:
         """
         Execute the agent asynchronously with the given messages using a LiteAgent instance.

src/crewai/agents/__init__.py

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

src/crewai/agents/agent_adapters/base_agent_adapter.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, Dict, List, Optional
 
-from pydantic import ConfigDict, PrivateAttr
+from pydantic import PrivateAttr
 
 from crewai.agent import BaseAgent
 from crewai.tools import BaseTool
@@ -16,21 +16,22 @@ class BaseAgentAdapter(BaseAgent, ABC):
     """
 
     adapted_structured_output: bool = False
-    _agent_config: dict[str, Any] | None = PrivateAttr(default=None)
+    _agent_config: Optional[Dict[str, Any]] = PrivateAttr(default=None)
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = {"arbitrary_types_allowed": True}
 
-    def __init__(self, agent_config: dict[str, Any] | None = None, **kwargs: Any):
+    def __init__(self, agent_config: Optional[Dict[str, Any]] = None, **kwargs: Any):
         super().__init__(adapted_agent=True, **kwargs)
         self._agent_config = agent_config
 
     @abstractmethod
-    def configure_tools(self, tools: list[BaseTool] | None = None) -> None:
+    def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None:
         """Configure and adapt tools for the specific agent implementation.
 
         Args:
             tools: Optional list of BaseTool instances to be configured
         """
+        pass
 
     def configure_structured_output(self, structured_output: Any) -> None:
         """Configure the structured output for the specific agent implementation.
@@ -38,3 +39,4 @@ class BaseAgentAdapter(BaseAgent, ABC):
         Args:
             structured_output: The structured output to be configured
         """
+        pass

src/crewai/agents/agent_adapters/base_converter_adapter.py

@@ -1,58 +1,29 @@
-"""Base converter adapter for structured output conversion."""
-
-from __future__ import annotations
-
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter
-    from crewai.task import Task
 
 
 class BaseConverterAdapter(ABC):
-    """Abstract base class for converter adapters in CrewAI.
+    """Base class for all converter adapters in CrewAI.
 
-    Defines the common interface for converting agent outputs to structured formats.
-    All converter adapters must implement the methods defined here.
+    This abstract class defines the common interface and functionality that all
+    converter adapters must implement for converting structured output.
     """
 
-    def __init__(self, agent_adapter: BaseAgentAdapter) -> None:
-        """Initialize the converter adapter.
-
-        Args:
-            agent_adapter: The agent adapter to configure for structured output.
-        """
+    def __init__(self, agent_adapter):
         self.agent_adapter = agent_adapter
 
     @abstractmethod
-    def configure_structured_output(self, task: Task) -> None:
+    def configure_structured_output(self, task) -> None:
         """Configure agents to return structured output.
-
-        Must support both JSON and Pydantic output formats.
-
-        Args:
-            task: The task requiring structured output.
+        Must support json and pydantic output.
         """
+        pass
 
     @abstractmethod
     def enhance_system_prompt(self, base_prompt: str) -> str:
-        """Enhance the system prompt with structured output instructions.
-
-        Args:
-            base_prompt: The original system prompt.
-
-        Returns:
-            Enhanced prompt with structured output guidance.
-        """
+        """Enhance the system prompt with structured output instructions."""
+        pass
 
     @abstractmethod
     def post_process_result(self, result: str) -> str:
-        """Post-process the result to ensure proper string format.
-
-        Args:
-            result: The raw result from agent execution.
-
-        Returns:
-            Processed result as a string.
-        """
+        """Post-process the result to ensure it matches the expected format: string."""
+        pass

src/crewai/agents/agent_adapters/base_tool_adapter.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, List, Optional
 
 from crewai.tools.base_tool import BaseTool
 
@@ -12,22 +12,23 @@ class BaseToolAdapter(ABC):
     different frameworks and platforms.
     """
 
-    original_tools: list[BaseTool]
-    converted_tools: list[Any]
+    original_tools: List[BaseTool]
+    converted_tools: List[Any]
 
-    def __init__(self, tools: list[BaseTool] | None = None):
+    def __init__(self, tools: Optional[List[BaseTool]] = None):
         self.original_tools = tools or []
         self.converted_tools = []
 
     @abstractmethod
-    def configure_tools(self, tools: list[BaseTool]) -> None:
+    def configure_tools(self, tools: List[BaseTool]) -> None:
         """Configure and convert tools for the specific implementation.
 
         Args:
             tools: List of BaseTool instances to be configured and converted
         """
+        pass
 
-    def tools(self) -> list[Any]:
+    def tools(self) -> List[Any]:
         """Return all converted tools."""
         return self.converted_tools
 

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

@@ -1,56 +1,47 @@
-"""LangGraph agent adapter for CrewAI integration.
+from typing import Any, Dict, List, Optional
 
-This module contains the LangGraphAgentAdapter class that integrates LangGraph ReAct agents
-with CrewAI's agent system. Provides memory persistence, tool integration, and structured
-output functionality.
-"""
-
-from collections.abc import Callable
-from typing import Any, cast
-
-from pydantic import ConfigDict, Field, PrivateAttr
+from pydantic import Field, PrivateAttr
 
 from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter
 from crewai.agents.agent_adapters.langgraph.langgraph_tool_adapter import (
     LangGraphToolAdapter,
 )
-from crewai.agents.agent_adapters.langgraph.protocols import (
-    LangGraphCheckPointMemoryModule,
-    LangGraphPrebuiltModule,
-)
 from crewai.agents.agent_adapters.langgraph.structured_output_converter import (
     LangGraphConverterAdapter,
 )
 from crewai.agents.agent_builder.base_agent import BaseAgent
+from crewai.tools.agent_tools.agent_tools import AgentTools
+from crewai.tools.base_tool import BaseTool
+from crewai.utilities import Logger
+from crewai.utilities.converter import Converter
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionErrorEvent,
     AgentExecutionStartedEvent,
 )
-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.import_utils import require
+
+try:
+    from langgraph.checkpoint.memory import MemorySaver
+    from langgraph.prebuilt import create_react_agent
+
+    LANGGRAPH_AVAILABLE = True
+except ImportError:
+    LANGGRAPH_AVAILABLE = False
 
 
 class LangGraphAgentAdapter(BaseAgentAdapter):
-    """Adapter for LangGraph agents to work with CrewAI.
+    """Adapter for LangGraph agents to work with CrewAI."""
 
-    This adapter integrates LangGraph's ReAct agents with CrewAI's agent system,
-    providing memory persistence, tool integration, and structured output support.
-    """
+    model_config = {"arbitrary_types_allowed": True}
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    _logger: Logger = PrivateAttr(default_factory=Logger)
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger())
     _tool_adapter: LangGraphToolAdapter = PrivateAttr()
     _graph: Any = PrivateAttr(default=None)
     _memory: Any = PrivateAttr(default=None)
     _max_iterations: int = PrivateAttr(default=10)
     function_calling_llm: Any = Field(default=None)
-    step_callback: Callable[..., Any] | None = Field(default=None)
+    step_callback: Any = Field(default=None)
 
     model: str = Field(default="gpt-4o")
     verbose: bool = Field(default=False)
@@ -60,24 +51,17 @@ class LangGraphAgentAdapter(BaseAgentAdapter):
         role: str,
         goal: str,
         backstory: str,
-        tools: list[BaseTool] | None = None,
+        tools: Optional[List[BaseTool]] = None,
         llm: Any = None,
         max_iterations: int = 10,
-        agent_config: dict[str, Any] | None = None,
+        agent_config: Optional[Dict[str, Any]] = None,
         **kwargs,
-    ) -> None:
-        """Initialize the LangGraph agent adapter.
-
-        Args:
-            role: The role description for the agent.
-            goal: The primary goal the agent should achieve.
-            backstory: Background information about the agent.
-            tools: Optional list of tools available to the agent.
-            llm: Language model to use, defaults to gpt-4o.
-            max_iterations: Maximum number of iterations for task execution.
-            agent_config: Additional configuration for the LangGraph agent.
-            **kwargs: Additional arguments passed to the base adapter.
-        """
+    ):
+        """Initialize the LangGraph agent adapter."""
+        if not LANGGRAPH_AVAILABLE:
+            raise ImportError(
+                "LangGraph Agent Dependencies are not installed. Please install it using `uv add langchain-core langgraph`"
+            )
         super().__init__(
             role=role,
             goal=goal,
@@ -88,65 +72,46 @@ class LangGraphAgentAdapter(BaseAgentAdapter):
             **kwargs,
         )
         self._tool_adapter = LangGraphToolAdapter(tools=tools)
-        self._converter_adapter: LangGraphConverterAdapter = LangGraphConverterAdapter(
-            self
-        )
+        self._converter_adapter = LangGraphConverterAdapter(self)
         self._max_iterations = max_iterations
         self._setup_graph()
 
     def _setup_graph(self) -> None:
-        """Set up the LangGraph workflow graph.
+        """Set up the LangGraph workflow graph."""
+        try:
+            self._memory = MemorySaver()
 
-        Initializes the memory saver and creates a ReAct agent with the configured
-        tools, memory checkpointer, and debug settings.
-        """
+            converted_tools: List[Any] = self._tool_adapter.tools()
+            if self._agent_config:
+                self._graph = create_react_agent(
+                    model=self.llm,
+                    tools=converted_tools,
+                    checkpointer=self._memory,
+                    debug=self.verbose,
+                    **self._agent_config,
+                )
+            else:
+                self._graph = create_react_agent(
+                    model=self.llm,
+                    tools=converted_tools or [],
+                    checkpointer=self._memory,
+                    debug=self.verbose,
+                )
 
-        memory_saver: type[Any] = cast(
-            LangGraphCheckPointMemoryModule,
-            require(
-                "langgraph.checkpoint.memory",
-                purpose="LangGraph core functionality",
-            ),
-        ).MemorySaver
-        create_react_agent: Callable[..., Any] = cast(
-            LangGraphPrebuiltModule,
-            require(
-                "langgraph.prebuilt",
-                purpose="LangGraph core functionality",
-            ),
-        ).create_react_agent
-
-        self._memory = memory_saver()
-
-        converted_tools: list[Any] = self._tool_adapter.tools()
-        if self._agent_config:
-            self._graph = create_react_agent(
-                model=self.llm,
-                tools=converted_tools,
-                checkpointer=self._memory,
-                debug=self.verbose,
-                **self._agent_config,
-            )
-        else:
-            self._graph = create_react_agent(
-                model=self.llm,
-                tools=converted_tools or [],
-                checkpointer=self._memory,
-                debug=self.verbose,
+        except ImportError as e:
+            self._logger.log(
+                "error", f"Failed to import LangGraph dependencies: {str(e)}"
             )
+            raise
+        except Exception as e:
+            self._logger.log("error", f"Error setting up LangGraph agent: {str(e)}")
+            raise
 
     def _build_system_prompt(self) -> str:
-        """Build a system prompt for the LangGraph agent.
-
-        Creates a prompt that includes the agent's role, goal, and backstory,
-        then enhances it through the converter adapter for structured output.
-
-        Returns:
-            The complete system prompt string.
-        """
+        """Build a system prompt for the LangGraph agent."""
         base_prompt = f"""
             You are {self.role}.
-
+        
             Your goal is: {self.goal}
 
             Your backstory: {self.backstory}
@@ -158,25 +123,10 @@ class LangGraphAgentAdapter(BaseAgentAdapter):
     def execute_task(
         self,
         task: Any,
-        context: str | None = None,
-        tools: list[BaseTool] | None = None,
+        context: Optional[str] = None,
+        tools: Optional[List[BaseTool]] = None,
     ) -> str:
-        """Execute a task using the LangGraph workflow.
-
-        Configures the agent, processes the task through the LangGraph workflow,
-        and handles event emission for execution tracking.
-
-        Args:
-            task: The task object to execute.
-            context: Optional context information for the task.
-            tools: Optional additional tools for this specific execution.
-
-        Returns:
-            The final answer from the task execution.
-
-        Raises:
-            Exception: If task execution fails.
-        """
+        """Execute a task using the LangGraph workflow."""
         self.create_agent_executor(tools)
 
         self.configure_structured_output(task)
@@ -201,11 +151,9 @@ class LangGraphAgentAdapter(BaseAgentAdapter):
 
             session_id = f"task_{id(task)}"
 
-            config: dict[str, dict[str, str]] = {
-                "configurable": {"thread_id": session_id}
-            }
+            config = {"configurable": {"thread_id": session_id}}
 
-            result: dict[str, Any] = self._graph.invoke(
+            result = self._graph.invoke(
                 {
                     "messages": [
                         ("system", self._build_system_prompt()),
@@ -215,10 +163,10 @@ class LangGraphAgentAdapter(BaseAgentAdapter):
                 config,
             )
 
-            messages: list[Any] = result.get("messages", [])
-            last_message: Any = messages[-1] if messages else None
+            messages = result.get("messages", [])
+            last_message = messages[-1] if messages else None
 
-            final_answer: str = ""
+            final_answer = ""
             if isinstance(last_message, dict):
                 final_answer = last_message.get("content", "")
             elif hasattr(last_message, "content"):
@@ -238,7 +186,7 @@ class LangGraphAgentAdapter(BaseAgentAdapter):
             return final_answer
 
         except Exception as e:
-            self._logger.log("error", f"Error executing LangGraph task: {e!s}")
+            self._logger.log("error", f"Error executing LangGraph task: {str(e)}")
             crewai_event_bus.emit(
                 self,
                 event=AgentExecutionErrorEvent(
@@ -249,67 +197,29 @@ class LangGraphAgentAdapter(BaseAgentAdapter):
             )
             raise
 
-    def create_agent_executor(self, tools: list[BaseTool] | None = None) -> None:
-        """Configure the LangGraph agent for execution.
-
-        Args:
-            tools: Optional tools to configure for the agent.
-        """
+    def create_agent_executor(self, tools: Optional[List[BaseTool]] = None) -> None:
+        """Configure the LangGraph agent for execution."""
         self.configure_tools(tools)
 
-    def configure_tools(self, tools: list[BaseTool] | None = None) -> None:
-        """Configure tools for the LangGraph agent.
-
-        Merges additional tools with existing ones and updates the graph's
-        available tools through the tool adapter.
-
-        Args:
-            tools: Optional additional tools to configure.
-        """
+    def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None:
+        """Configure tools for the LangGraph agent."""
         if tools:
-            all_tools: list[BaseTool] = list(self.tools or []) + list(tools or [])
+            all_tools = list(self.tools or []) + list(tools or [])
             self._tool_adapter.configure_tools(all_tools)
-            available_tools: list[Any] = self._tool_adapter.tools()
+            available_tools = self._tool_adapter.tools()
             self._graph.tools = available_tools
 
-    def get_delegation_tools(self, agents: list[BaseAgent]) -> list[BaseTool]:
-        """Implement delegation tools support for LangGraph.
-
-        Creates delegation tools that allow this agent to delegate tasks to other agents.
-
-        Args:
-            agents: List of agents available for delegation.
-
-        Returns:
-            List of delegation tools.
-        """
-        agent_tools: AgentTools = AgentTools(agents=agents)
+    def get_delegation_tools(self, agents: List[BaseAgent]) -> List[BaseTool]:
+        """Implement delegation tools support for LangGraph."""
+        agent_tools = AgentTools(agents=agents)
         return agent_tools.tools()
 
-    @staticmethod
     def get_output_converter(
-        llm: Any, text: str, model: Any, instructions: str
-    ) -> Converter:
-        """Convert output format if needed.
-
-        Args:
-            llm: Language model instance.
-            text: Text to convert.
-            model: Model configuration.
-            instructions: Conversion instructions.
-
-        Returns:
-            Converter instance for output transformation.
-        """
+        self, llm: Any, text: str, model: Any, instructions: str
+    ) -> Any:
+        """Convert output format if needed."""
         return Converter(llm=llm, text=text, model=model, instructions=instructions)
 
-    def configure_structured_output(self, task: Any) -> None:
-        """Configure the structured output for LangGraph.
-
-        Uses the converter adapter to set up structured output formatting
-        based on the task requirements.
-
-        Args:
-            task: Task object containing output requirements.
-        """
+    def configure_structured_output(self, task) -> None:
+        """Configure the structured output for LangGraph."""
         self._converter_adapter.configure_structured_output(task)

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

@@ -1,72 +1,38 @@
-"""LangGraph tool adapter for CrewAI tool integration.
-
-This module contains the LangGraphToolAdapter class that converts CrewAI tools
-to LangGraph-compatible format using langchain_core.tools.
-"""
-
 import inspect
-from collections.abc import Awaitable
-from typing import Any
+from typing import Any, List, Optional
 
 from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter
 from crewai.tools.base_tool import BaseTool
 
 
 class LangGraphToolAdapter(BaseToolAdapter):
-    """Adapts CrewAI tools to LangGraph agent tool compatible format.
+    """Adapts CrewAI tools to LangGraph agent tool compatible format"""
 
-    Converts CrewAI BaseTool instances to langchain_core.tools format
-    that can be used by LangGraph agents.
-    """
+    def __init__(self, tools: Optional[List[BaseTool]] = None):
+        self.original_tools = tools or []
+        self.converted_tools = []
 
-    def __init__(self, tools: list[BaseTool] | None = None) -> None:
-        """Initialize the tool adapter.
-
-        Args:
-            tools: Optional list of CrewAI tools to adapt.
+    def configure_tools(self, tools: List[BaseTool]) -> None:
         """
-        super().__init__()
-        self.original_tools: list[BaseTool] = tools or []
-        self.converted_tools: list[Any] = []
-
-    def configure_tools(self, tools: list[BaseTool]) -> None:
-        """Configure and convert CrewAI tools to LangGraph-compatible format.
-
-        LangGraph expects tools in langchain_core.tools format. This method
-        converts CrewAI BaseTool instances to StructuredTool instances.
-
-        Args:
-            tools: List of CrewAI tools to convert.
+        Configure and convert CrewAI tools to LangGraph-compatible format.
+        LangGraph expects tools in langchain_core.tools format.
         """
-        from langchain_core.tools import BaseTool as LangChainBaseTool
-        from langchain_core.tools import StructuredTool
+        from langchain_core.tools import BaseTool, StructuredTool
 
-        converted_tools: list[Any] = []
+        converted_tools = []
         if self.original_tools:
-            all_tools: list[BaseTool] = tools + self.original_tools
+            all_tools = tools + self.original_tools
         else:
             all_tools = tools
         for tool in all_tools:
-            if isinstance(tool, LangChainBaseTool):
+            if isinstance(tool, BaseTool):
                 converted_tools.append(tool)
                 continue
 
-            sanitized_name: str = self.sanitize_tool_name(tool.name)
+            sanitized_name = self.sanitize_tool_name(tool.name)
 
-            async def tool_wrapper(
-                *args: Any, tool: BaseTool = tool, **kwargs: Any
-            ) -> Any:
-                """Wrapper function to adapt CrewAI tool calls to LangGraph format.
-
-                Args:
-                    *args: Positional arguments for the tool.
-                    tool: The CrewAI tool to wrap.
-                    **kwargs: Keyword arguments for the tool.
-
-                Returns:
-                    The result from the tool execution.
-                """
-                output: Any | Awaitable[Any]
+            async def tool_wrapper(*args, tool=tool, **kwargs):
+                output = None
                 if len(args) > 0 and isinstance(args[0], str):
                     output = tool.run(args[0])
                 elif "input" in kwargs:
@@ -75,12 +41,12 @@ class LangGraphToolAdapter(BaseToolAdapter):
                     output = tool.run(**kwargs)
 
                 if inspect.isawaitable(output):
-                    result: Any = await output
+                    result = await output
                 else:
                     result = output
                 return result
 
-            converted_tool: StructuredTool = StructuredTool(
+            converted_tool = StructuredTool(
                 name=sanitized_name,
                 description=tool.description,
                 func=tool_wrapper,
@@ -91,10 +57,5 @@ class LangGraphToolAdapter(BaseToolAdapter):
 
         self.converted_tools = converted_tools
 
-    def tools(self) -> list[Any]:
-        """Get the list of converted tools.
-
-        Returns:
-            List of LangGraph-compatible tools.
-        """
+    def tools(self) -> List[Any]:
         return self.converted_tools or []

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

@@ -1,55 +0,0 @@
-"""Type protocols for LangGraph modules."""
-
-from typing import Any, Protocol, runtime_checkable
-
-
-@runtime_checkable
-class LangGraphMemorySaver(Protocol):
-    """Protocol for LangGraph MemorySaver.
-
-    Defines the interface for LangGraph's memory persistence mechanism.
-    """
-
-    def __init__(self) -> None:
-        """Initialize the memory saver."""
-        ...
-
-
-@runtime_checkable
-class LangGraphCheckPointMemoryModule(Protocol):
-    """Protocol for LangGraph checkpoint memory module.
-
-    Defines the interface for modules containing memory checkpoint functionality.
-    """
-
-    MemorySaver: type[LangGraphMemorySaver]
-
-
-@runtime_checkable
-class LangGraphPrebuiltModule(Protocol):
-    """Protocol for LangGraph prebuilt module.
-
-    Defines the interface for modules containing prebuilt agent factories.
-    """
-
-    def create_react_agent(
-        self,
-        model: Any,
-        tools: list[Any],
-        checkpointer: Any,
-        debug: bool = False,
-        **kwargs: Any,
-    ) -> Any:
-        """Create a ReAct agent with the given configuration.
-
-        Args:
-            model: The language model to use for the agent.
-            tools: List of tools available to the agent.
-            checkpointer: Memory checkpointer for state persistence.
-            debug: Whether to enable debug mode.
-            **kwargs: Additional configuration options.
-
-        Returns:
-            The configured ReAct agent instance.
-        """
-        ...

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

@@ -1,45 +1,21 @@
-"""LangGraph structured output converter for CrewAI task integration.
-
-This module contains the LangGraphConverterAdapter class that handles structured
-output conversion for LangGraph agents, supporting JSON and Pydantic model formats.
-"""
-
 import json
-import re
-from typing import Any, Literal
 
 from crewai.agents.agent_adapters.base_converter_adapter import BaseConverterAdapter
 from crewai.utilities.converter import generate_model_description
 
 
 class LangGraphConverterAdapter(BaseConverterAdapter):
-    """Adapter for handling structured output conversion in LangGraph agents.
+    """Adapter for handling structured output conversion in LangGraph agents"""
 
-    Converts task output requirements into system prompt modifications and
-    post-processing logic to ensure agents return properly structured outputs.
-    """
+    def __init__(self, agent_adapter):
+        """Initialize the converter adapter with a reference to the agent adapter"""
+        self.agent_adapter = agent_adapter
+        self._output_format = None
+        self._schema = None
+        self._system_prompt_appendix = None
 
-    def __init__(self, agent_adapter: Any) -> None:
-        """Initialize the converter adapter with a reference to the agent adapter.
-
-        Args:
-            agent_adapter: The LangGraph agent adapter instance.
-        """
-        super().__init__(agent_adapter=agent_adapter)
-        self.agent_adapter: Any = agent_adapter
-        self._output_format: Literal["json", "pydantic"] | None = None
-        self._schema: str | None = None
-        self._system_prompt_appendix: str | None = None
-
-    def configure_structured_output(self, task: Any) -> None:
-        """Configure the structured output for LangGraph.
-
-        Analyzes the task's output requirements and sets up the necessary
-        formatting and validation logic.
-
-        Args:
-            task: The task object containing output format specifications.
-        """
+    def configure_structured_output(self, task) -> None:
+        """Configure the structured output for LangGraph."""
         if not (task.output_json or task.output_pydantic):
             self._output_format = None
             self._schema = None
@@ -56,14 +32,7 @@ class LangGraphConverterAdapter(BaseConverterAdapter):
         self._system_prompt_appendix = self._generate_system_prompt_appendix()
 
     def _generate_system_prompt_appendix(self) -> str:
-        """Generate an appendix for the system prompt to enforce structured output.
-
-        Creates instructions that are appended to the system prompt to guide
-        the agent in producing properly formatted output.
-
-        Returns:
-            System prompt appendix string, or empty string if no structured output.
-        """
+        """Generate an appendix for the system prompt to enforce structured output"""
         if not self._output_format or not self._schema:
             return ""
 
@@ -72,36 +41,19 @@ Important: Your final answer MUST be provided in the following structured format
 
 {self._schema}
 
-DO NOT include any markdown code blocks, backticks, or other formatting around your response.
+DO NOT include any markdown code blocks, backticks, or other formatting around your response. 
 The output should be raw JSON that exactly matches the specified schema.
 """
 
     def enhance_system_prompt(self, original_prompt: str) -> str:
-        """Add structured output instructions to the system prompt if needed.
-
-        Args:
-            original_prompt: The base system prompt.
-
-        Returns:
-            Enhanced system prompt with structured output instructions.
-        """
+        """Add structured output instructions to the system prompt if needed"""
         if not self._system_prompt_appendix:
             return original_prompt
 
         return f"{original_prompt}\n{self._system_prompt_appendix}"
 
     def post_process_result(self, result: str) -> str:
-        """Post-process the result to ensure it matches the expected format.
-
-        Attempts to extract and validate JSON content from agent responses,
-        handling cases where JSON may be wrapped in markdown or other formatting.
-
-        Args:
-            result: The raw result string from the agent.
-
-        Returns:
-            Processed result string, ideally in valid JSON format.
-        """
+        """Post-process the result to ensure it matches the expected format"""
         if not self._output_format:
             return result
 
@@ -113,16 +65,16 @@ The output should be raw JSON that exactly matches the specified schema.
                 return result
             except json.JSONDecodeError:
                 # Try to extract JSON from the text
-                json_match: re.Match[str] | None = re.search(
-                    r"(\{.*})", result, re.DOTALL
-                )
+                import re
+
+                json_match = re.search(r"(\{.*\})", result, re.DOTALL)
                 if json_match:
                     try:
-                        extracted: str = json_match.group(1)
+                        extracted = json_match.group(1)
                         # Validate it's proper JSON
                         json.loads(extracted)
                         return extracted
-                    except json.JSONDecodeError:
+                    except:
                         pass
 
         return result

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

@@ -1,99 +1,78 @@
-"""OpenAI agents adapter for CrewAI integration.
+from typing import Any, List, Optional
 
-This module contains the OpenAIAgentAdapter class that integrates OpenAI Assistants
-with CrewAI's agent system, providing tool integration and structured output support.
-"""
-
-from typing import Any, cast
-
-from pydantic import ConfigDict, Field, PrivateAttr
-from typing_extensions import Unpack
+from pydantic import Field, PrivateAttr
 
 from crewai.agents.agent_adapters.base_agent_adapter import BaseAgentAdapter
-from crewai.agents.agent_adapters.openai_agents.openai_agent_tool_adapter import (
-    OpenAIAgentToolAdapter,
-)
-from crewai.agents.agent_adapters.openai_agents.protocols import (
-    AgentKwargs,
-    OpenAIAgentsModule,
-)
-from crewai.agents.agent_adapters.openai_agents.protocols import (
-    OpenAIAgent as OpenAIAgentProtocol,
-)
 from crewai.agents.agent_adapters.openai_agents.structured_output_converter import (
     OpenAIConverterAdapter,
 )
 from crewai.agents.agent_builder.base_agent import BaseAgent
+from crewai.tools import BaseTool
+from crewai.tools.agent_tools.agent_tools import AgentTools
+from crewai.utilities import Logger
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionErrorEvent,
     AgentExecutionStartedEvent,
 )
-from crewai.tools import BaseTool
-from crewai.tools.agent_tools.agent_tools import AgentTools
-from crewai.utilities import Logger
-from crewai.utilities.import_utils import require
 
-openai_agents_module = cast(
-    OpenAIAgentsModule,
-    require(
-        "agents",
-        purpose="OpenAI agents functionality",
-    ),
-)
-OpenAIAgent = openai_agents_module.Agent
-Runner = openai_agents_module.Runner
-enable_verbose_stdout_logging = openai_agents_module.enable_verbose_stdout_logging
+try:
+    from agents import Agent as OpenAIAgent  # type: ignore
+    from agents import Runner, enable_verbose_stdout_logging  # type: ignore
+
+    from .openai_agent_tool_adapter import OpenAIAgentToolAdapter
+
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
 
 
 class OpenAIAgentAdapter(BaseAgentAdapter):
-    """Adapter for OpenAI Assistants.
+    """Adapter for OpenAI Assistants"""
 
-    Integrates OpenAI Assistants API with CrewAI's agent system, providing
-    tool configuration, structured output handling, and task execution.
-    """
+    model_config = {"arbitrary_types_allowed": True}
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    _openai_agent: OpenAIAgentProtocol = PrivateAttr()
-    _logger: Logger = PrivateAttr(default_factory=Logger)
-    _active_thread: str | None = PrivateAttr(default=None)
+    _openai_agent: "OpenAIAgent" = PrivateAttr()
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger())
+    _active_thread: Optional[str] = PrivateAttr(default=None)
     function_calling_llm: Any = Field(default=None)
     step_callback: Any = Field(default=None)
-    _tool_adapter: OpenAIAgentToolAdapter = PrivateAttr()
+    _tool_adapter: "OpenAIAgentToolAdapter" = PrivateAttr()
     _converter_adapter: OpenAIConverterAdapter = PrivateAttr()
 
     def __init__(
         self,
-        **kwargs: Unpack[AgentKwargs],
-    ) -> None:
-        """Initialize the OpenAI agent adapter.
-
-        Args:
-            **kwargs: All initialization arguments including role, goal, backstory,
-                     model, tools, and agent_config.
-
-        Raises:
-            ImportError: If OpenAI agent dependencies are not installed.
-        """
-        self.llm = kwargs.pop("model", "gpt-4o-mini")
-        super().__init__(**kwargs)
-        self._tool_adapter = OpenAIAgentToolAdapter(tools=kwargs.get("tools"))
-        self._converter_adapter = OpenAIConverterAdapter(agent_adapter=self)
+        model: str = "gpt-4o-mini",
+        tools: Optional[List[BaseTool]] = None,
+        agent_config: Optional[dict] = None,
+        **kwargs,
+    ):
+        if not OPENAI_AVAILABLE:
+            raise ImportError(
+                "OpenAI Agent Dependencies are not installed. Please install it using `uv add openai-agents`"
+            )
+        else:
+            role = kwargs.pop("role", None)
+            goal = kwargs.pop("goal", None)
+            backstory = kwargs.pop("backstory", None)
+            super().__init__(
+                role=role,
+                goal=goal,
+                backstory=backstory,
+                tools=tools,
+                agent_config=agent_config,
+                **kwargs,
+            )
+            self._tool_adapter = OpenAIAgentToolAdapter(tools=tools)
+            self.llm = model
+            self._converter_adapter = OpenAIConverterAdapter(self)
 
     def _build_system_prompt(self) -> str:
-        """Build a system prompt for the OpenAI agent.
-
-        Creates a prompt containing the agent's role, goal, and backstory,
-        then enhances it with structured output instructions if needed.
-
-        Returns:
-            The complete system prompt string.
-        """
+        """Build a system prompt for the OpenAI agent."""
         base_prompt = f"""
             You are {self.role}.
-
+        
             Your goal is: {self.goal}
 
             Your backstory: {self.backstory}
@@ -105,25 +84,10 @@ class OpenAIAgentAdapter(BaseAgentAdapter):
     def execute_task(
         self,
         task: Any,
-        context: str | None = None,
-        tools: list[BaseTool] | None = None,
+        context: Optional[str] = None,
+        tools: Optional[List[BaseTool]] = None,
     ) -> str:
-        """Execute a task using the OpenAI Assistant.
-
-        Configures the assistant, processes the task, and handles event emission
-        for execution tracking.
-
-        Args:
-            task: The task object to execute.
-            context: Optional context information for the task.
-            tools: Optional additional tools for this execution.
-
-        Returns:
-            The final answer from the task execution.
-
-        Raises:
-            Exception: If task execution fails.
-        """
+        """Execute a task using the OpenAI Assistant"""
         self._converter_adapter.configure_structured_output(task)
         self.create_agent_executor(tools)
 
@@ -131,7 +95,7 @@ class OpenAIAgentAdapter(BaseAgentAdapter):
             enable_verbose_stdout_logging()
 
         try:
-            task_prompt: str = task.prompt()
+            task_prompt = task.prompt()
             if context:
                 task_prompt = self.i18n.slice("task_with_context").format(
                     task=task_prompt, context=context
@@ -145,8 +109,8 @@ class OpenAIAgentAdapter(BaseAgentAdapter):
                     task=task,
                 ),
             )
-            result: Any = self.agent_executor.run_sync(self._openai_agent, task_prompt)
-            final_answer: str = self.handle_execution_result(result)
+            result = self.agent_executor.run_sync(self._openai_agent, task_prompt)
+            final_answer = self.handle_execution_result(result)
             crewai_event_bus.emit(
                 self,
                 event=AgentExecutionCompletedEvent(
@@ -156,7 +120,7 @@ class OpenAIAgentAdapter(BaseAgentAdapter):
             return final_answer
 
         except Exception as e:
-            self._logger.log("error", f"Error executing OpenAI task: {e!s}")
+            self._logger.log("error", f"Error executing OpenAI task: {str(e)}")
             crewai_event_bus.emit(
                 self,
                 event=AgentExecutionErrorEvent(
@@ -167,22 +131,15 @@ class OpenAIAgentAdapter(BaseAgentAdapter):
             )
             raise
 
-    def create_agent_executor(self, tools: list[BaseTool] | None = None) -> None:
-        """Configure the OpenAI agent for execution.
-
-        While OpenAI handles execution differently through Runner,
-        this method sets up tools and agent configuration.
-
-        Args:
-            tools: Optional tools to configure for the agent.
-
-        Notes:
-            TODO: Properly type agent_executor in BaseAgent to avoid type issues
-            when assigning Runner class to this attribute.
+    def create_agent_executor(self, tools: Optional[List[BaseTool]] = None) -> None:
         """
-        all_tools: list[BaseTool] = list(self.tools or []) + list(tools or [])
+        Configure the OpenAI agent for execution.
+        While OpenAI handles execution differently through Runner,
+        we can use this method to set up tools and configurations.
+        """
+        all_tools = list(self.tools or []) + list(tools or [])
 
-        instructions: str = self._build_system_prompt()
+        instructions = self._build_system_prompt()
         self._openai_agent = OpenAIAgent(
             name=self.role,
             instructions=instructions,
@@ -195,48 +152,27 @@ class OpenAIAgentAdapter(BaseAgentAdapter):
 
         self.agent_executor = Runner
 
-    def configure_tools(self, tools: list[BaseTool] | None = None) -> None:
-        """Configure tools for the OpenAI Assistant.
-
-        Args:
-            tools: Optional tools to configure for the assistant.
-        """
+    def configure_tools(self, tools: Optional[List[BaseTool]] = None) -> None:
+        """Configure tools for the OpenAI Assistant"""
         if tools:
             self._tool_adapter.configure_tools(tools)
             if self._tool_adapter.converted_tools:
                 self._openai_agent.tools = self._tool_adapter.converted_tools
 
     def handle_execution_result(self, result: Any) -> str:
-        """Process OpenAI Assistant execution result.
-
-        Converts any structured output to a string through the converter adapter.
-
-        Args:
-            result: The execution result from the OpenAI assistant.
-
-        Returns:
-            Processed result as a string.
-        """
+        """Process OpenAI Assistant execution result converting any structured output to a string"""
         return self._converter_adapter.post_process_result(result.final_output)
 
-    def get_delegation_tools(self, agents: list[BaseAgent]) -> list[BaseTool]:
-        """Implement delegation tools support.
+    def get_delegation_tools(self, agents: List[BaseAgent]) -> List[BaseTool]:
+        """Implement delegation tools support"""
+        agent_tools = AgentTools(agents=agents)
+        tools = agent_tools.tools()
+        return tools
 
-        Creates delegation tools that allow this agent to delegate tasks to other agents.
-
-        Args:
-            agents: List of agents available for delegation.
-
-        Returns:
-            List of delegation tools.
-        """
-        agent_tools: AgentTools = AgentTools(agents=agents)
-        return agent_tools.tools()
-
-    def configure_structured_output(self, task: Any) -> None:
+    def configure_structured_output(self, task) -> None:
         """Configure the structured output for the specific agent implementation.
 
         Args:
-            task: The task object containing output format specifications.
+            structured_output: The structured output to be configured
         """
         self._converter_adapter.configure_structured_output(task)

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

@@ -1,125 +1,57 @@
-"""OpenAI agent tool adapter for CrewAI tool integration.
-
-This module contains the OpenAIAgentToolAdapter class that converts CrewAI tools
-to OpenAI Assistant-compatible format using the agents library.
-"""
-
 import inspect
-import json
-import re
-from collections.abc import Awaitable
-from typing import Any, cast
+from typing import Any, List, Optional
+
+from agents import FunctionTool, Tool
 
 from crewai.agents.agent_adapters.base_tool_adapter import BaseToolAdapter
-from crewai.agents.agent_adapters.openai_agents.protocols import (
-    OpenAIFunctionTool,
-    OpenAITool,
-)
 from crewai.tools import BaseTool
-from crewai.utilities.import_utils import require
-
-agents_module = cast(
-    Any,
-    require(
-        "agents",
-        purpose="OpenAI agents functionality",
-    ),
-)
-FunctionTool = agents_module.FunctionTool
-Tool = agents_module.Tool
 
 
 class OpenAIAgentToolAdapter(BaseToolAdapter):
-    """Adapter for OpenAI Assistant tools.
+    """Adapter for OpenAI Assistant tools"""
 
-    Converts CrewAI BaseTool instances to OpenAI Assistant FunctionTool format
-    that can be used by OpenAI agents.
-    """
+    def __init__(self, tools: Optional[List[BaseTool]] = None):
+        self.original_tools = tools or []
 
-    def __init__(self, tools: list[BaseTool] | None = None) -> None:
-        """Initialize the tool adapter.
-
-        Args:
-            tools: Optional list of CrewAI tools to adapt.
-        """
-        super().__init__()
-        self.original_tools: list[BaseTool] = tools or []
-        self.converted_tools: list[OpenAITool] = []
-
-    def configure_tools(self, tools: list[BaseTool]) -> None:
-        """Configure tools for the OpenAI Assistant.
-
-        Merges provided tools with original tools and converts them to
-        OpenAI Assistant format.
-
-        Args:
-            tools: List of CrewAI tools to configure.
-        """
+    def configure_tools(self, tools: List[BaseTool]) -> None:
+        """Configure tools for the OpenAI Assistant"""
         if self.original_tools:
-            all_tools: list[BaseTool] = tools + self.original_tools
+            all_tools = tools + self.original_tools
         else:
             all_tools = tools
         if all_tools:
             self.converted_tools = self._convert_tools_to_openai_format(all_tools)
 
-    @staticmethod
     def _convert_tools_to_openai_format(
-        tools: list[BaseTool] | None,
-    ) -> list[OpenAITool]:
-        """Convert CrewAI tools to OpenAI Assistant tool format.
-
-        Args:
-            tools: List of CrewAI tools to convert.
-
-        Returns:
-            List of OpenAI Assistant FunctionTool instances.
-        """
+        self, tools: Optional[List[BaseTool]]
+    ) -> List[Tool]:
+        """Convert CrewAI tools to OpenAI Assistant tool format"""
         if not tools:
             return []
 
         def sanitize_tool_name(name: str) -> str:
-            """Convert tool name to match OpenAI's required pattern.
+            """Convert tool name to match OpenAI's required pattern"""
+            import re
 
-            Args:
-                name: Original tool name.
+            sanitized = re.sub(r"[^a-zA-Z0-9_-]", "_", name).lower()
+            return sanitized
 
-            Returns:
-                Sanitized tool name matching OpenAI requirements.
-            """
-
-            return re.sub(r"[^a-zA-Z0-9_-]", "_", name).lower()
-
-        def create_tool_wrapper(tool: BaseTool) -> Any:
-            """Create a wrapper function that handles the OpenAI function tool interface.
-
-            Args:
-                tool: The CrewAI tool to wrap.
-
-            Returns:
-                Async wrapper function for OpenAI agent integration.
-            """
+        def create_tool_wrapper(tool: BaseTool):
+            """Create a wrapper function that handles the OpenAI function tool interface"""
 
             async def wrapper(context_wrapper: Any, arguments: Any) -> Any:
-                """Wrapper function to adapt CrewAI tool calls to OpenAI format.
-
-                Args:
-                    context_wrapper: OpenAI context wrapper.
-                    arguments: Tool arguments from OpenAI.
-
-                Returns:
-                    Tool execution result.
-                """
                 # Get the parameter name from the schema
-                param_name: str = next(
-                    iter(tool.args_schema.model_json_schema()["properties"].keys())
-                )
+                param_name = list(
+                    tool.args_schema.model_json_schema()["properties"].keys()
+                )[0]
 
                 # Handle different argument types
-                args_dict: dict[str, Any]
                 if isinstance(arguments, dict):
                     args_dict = arguments
                 elif isinstance(arguments, str):
                     try:
+                        import json
+
                         args_dict = json.loads(arguments)
                     except json.JSONDecodeError:
                         args_dict = {param_name: arguments}
@@ -127,11 +59,11 @@ class OpenAIAgentToolAdapter(BaseToolAdapter):
                     args_dict = {param_name: str(arguments)}
 
                 # Run the tool with the processed arguments
-                output: Any | Awaitable[Any] = tool._run(**args_dict)
+                output = tool._run(**args_dict)
 
                 # Await if the tool returned a coroutine
                 if inspect.isawaitable(output):
-                    result: Any = await output
+                    result = await output
                 else:
                     result = output
 
@@ -142,20 +74,17 @@ class OpenAIAgentToolAdapter(BaseToolAdapter):
 
             return wrapper
 
-        openai_tools: list[OpenAITool] = []
+        openai_tools = []
         for tool in tools:
-            schema: dict[str, Any] = tool.args_schema.model_json_schema()
+            schema = tool.args_schema.model_json_schema()
 
             schema.update({"additionalProperties": False, "type": "object"})
 
-            openai_tool: OpenAIFunctionTool = cast(
-                OpenAIFunctionTool,
-                FunctionTool(
-                    name=sanitize_tool_name(tool.name),
-                    description=tool.description,
-                    params_json_schema=schema,
-                    on_invoke_tool=create_tool_wrapper(tool),
-                ),
+            openai_tool = FunctionTool(
+                name=sanitize_tool_name(tool.name),
+                description=tool.description,
+                params_json_schema=schema,
+                on_invoke_tool=create_tool_wrapper(tool),
             )
             openai_tools.append(openai_tool)
 

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

@@ -1,74 +0,0 @@
-"""Type protocols for OpenAI agents modules."""
-
-from collections.abc import Callable
-from typing import Any, Protocol, TypedDict, runtime_checkable
-
-from crewai.tools.base_tool import BaseTool
-
-
-class AgentKwargs(TypedDict, total=False):
-    """Typed dict for agent initialization kwargs."""
-
-    role: str
-    goal: str
-    backstory: str
-    model: str
-    tools: list[BaseTool] | None
-    agent_config: dict[str, Any] | None
-
-
-@runtime_checkable
-class OpenAIAgent(Protocol):
-    """Protocol for OpenAI Agent."""
-
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        model: str,
-        **kwargs: Any,
-    ) -> None:
-        """Initialize the OpenAI agent."""
-        ...
-
-    tools: list[Any]
-    output_type: Any
-
-
-@runtime_checkable
-class OpenAIRunner(Protocol):
-    """Protocol for OpenAI Runner."""
-
-    @classmethod
-    def run_sync(cls, agent: OpenAIAgent, message: str) -> Any:
-        """Run agent synchronously with a message."""
-        ...
-
-
-@runtime_checkable
-class OpenAIAgentsModule(Protocol):
-    """Protocol for OpenAI agents module."""
-
-    Agent: type[OpenAIAgent]
-    Runner: type[OpenAIRunner]
-    enable_verbose_stdout_logging: Callable[[], None]
-
-
-@runtime_checkable
-class OpenAITool(Protocol):
-    """Protocol for OpenAI Tool."""
-
-
-@runtime_checkable
-class OpenAIFunctionTool(Protocol):
-    """Protocol for OpenAI FunctionTool."""
-
-    def __init__(
-        self,
-        name: str,
-        description: str,
-        params_json_schema: dict[str, Any],
-        on_invoke_tool: Any,
-    ) -> None:
-        """Initialize the function tool."""
-        ...

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

@@ -1,12 +1,5 @@
-"""OpenAI structured output converter for CrewAI task integration.
-
-This module contains the OpenAIConverterAdapter class that handles structured
-output conversion for OpenAI agents, supporting JSON and Pydantic model formats.
-"""
-
 import json
 import re
-from typing import Any, Literal
 
 from crewai.agents.agent_adapters.base_converter_adapter import BaseConverterAdapter
 from crewai.utilities.converter import generate_model_description
@@ -14,7 +7,8 @@ from crewai.utilities.i18n import I18N
 
 
 class OpenAIConverterAdapter(BaseConverterAdapter):
-    """Adapter for handling structured output conversion in OpenAI agents.
+    """
+    Adapter for handling structured output conversion in OpenAI agents.
 
     This adapter enhances the OpenAI agent to handle structured output formats
     and post-processes the results when needed.
@@ -25,23 +19,19 @@ class OpenAIConverterAdapter(BaseConverterAdapter):
         _output_model: The Pydantic model for the output
     """
 
-    def __init__(self, agent_adapter: Any) -> None:
-        """Initialize the converter adapter with a reference to the agent adapter.
+    def __init__(self, agent_adapter):
+        """Initialize the converter adapter with a reference to the agent adapter"""
+        self.agent_adapter = agent_adapter
+        self._output_format = None
+        self._schema = None
+        self._output_model = None
 
-        Args:
-            agent_adapter: The OpenAI agent adapter instance.
+    def configure_structured_output(self, task) -> None:
         """
-        super().__init__(agent_adapter=agent_adapter)
-        self.agent_adapter: Any = agent_adapter
-        self._output_format: Literal["json", "pydantic"] | None = None
-        self._schema: str | None = None
-        self._output_model: Any = None
-
-    def configure_structured_output(self, task: Any) -> None:
-        """Configure the structured output for OpenAI agent based on task requirements.
+        Configure the structured output for OpenAI agent based on task requirements.
 
         Args:
-            task: The task containing output format requirements.
+            task: The task containing output format requirements
         """
         # Reset configuration
         self._output_format = None
@@ -65,18 +55,19 @@ class OpenAIConverterAdapter(BaseConverterAdapter):
             self._output_model = task.output_pydantic
 
     def enhance_system_prompt(self, base_prompt: str) -> str:
-        """Enhance the base system prompt with structured output requirements if needed.
+        """
+        Enhance the base system prompt with structured output requirements if needed.
 
         Args:
-            base_prompt: The original system prompt.
+            base_prompt: The original system prompt
 
         Returns:
-            Enhanced system prompt with output format instructions if needed.
+            Enhanced system prompt with output format instructions if needed
         """
         if not self._output_format:
             return base_prompt
 
-        output_schema: str = (
+        output_schema = (
             I18N()
             .slice("formatted_task_instructions")
             .format(output_format=self._schema)
@@ -85,15 +76,16 @@ class OpenAIConverterAdapter(BaseConverterAdapter):
         return f"{base_prompt}\n\n{output_schema}"
 
     def post_process_result(self, result: str) -> str:
-        """Post-process the result to ensure it matches the expected format.
+        """
+        Post-process the result to ensure it matches the expected format.
 
         This method attempts to extract valid JSON from the result if necessary.
 
         Args:
-            result: The raw result from the agent.
+            result: The raw result from the agent
 
         Returns:
-            Processed result conforming to the expected output format.
+            Processed result conforming to the expected output format
         """
         if not self._output_format:
             return result
@@ -105,30 +97,26 @@ class OpenAIConverterAdapter(BaseConverterAdapter):
                 return result
             except json.JSONDecodeError:
                 # Try to extract JSON from markdown code blocks
-                code_block_pattern: str = r"```(?:json)?\s*([\s\S]*?)```"
-                code_blocks: list[str] = re.findall(code_block_pattern, result)
+                code_block_pattern = r"```(?:json)?\s*([\s\S]*?)```"
+                code_blocks = re.findall(code_block_pattern, result)
 
                 for block in code_blocks:
-                    stripped_block = block.strip()
                     try:
-                        json.loads(stripped_block)
-                        return stripped_block
+                        json.loads(block.strip())
+                        return block.strip()
                     except json.JSONDecodeError:
-                        pass
+                        continue
 
                 # Try to extract any JSON-like structure
-                json_pattern: str = r"(\{[\s\S]*\})"
-                json_matches: list[str] = re.findall(json_pattern, result, re.DOTALL)
+                json_pattern = r"(\{[\s\S]*\})"
+                json_matches = re.findall(json_pattern, result, re.DOTALL)
 
                 for match in json_matches:
-                    is_valid = True
                     try:
                         json.loads(match)
-                    except json.JSONDecodeError:
-                        is_valid = False
-
-                    if is_valid:
                         return match
+                    except json.JSONDecodeError:
+                        continue
 
         # If all extraction attempts fail, return the original
         return str(result)

src/crewai/agents/agent_builder/base_agent.py

@@ -1,9 +1,8 @@
 import uuid
 from abc import ABC, abstractmethod
-from collections.abc import Callable
 from copy import copy as shallow_copy
 from hashlib import md5
-from typing import Any, TypeVar
+from typing import Any, Callable, Dict, List, Optional, TypeVar
 
 from pydantic import (
     UUID4,
@@ -22,11 +21,11 @@ from crewai.agents.tools_handler import ToolsHandler
 from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.knowledge_config import KnowledgeConfig
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
-from crewai.rag.embeddings.types import EmbedderConfig
 from crewai.security.security_config import SecurityConfig
 from crewai.tools.base_tool import BaseTool, Tool
 from crewai.utilities import I18N, Logger, RPMController
 from crewai.utilities.config import process_config
+from crewai.utilities.converter import Converter
 from crewai.utilities.string_utils import interpolate_only
 
 T = TypeVar("T", bound="BaseAgent")
@@ -82,17 +81,17 @@ class BaseAgent(ABC, BaseModel):
 
     __hash__ = object.__hash__  # type: ignore
     _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=False))
-    _rpm_controller: RPMController | None = PrivateAttr(default=None)
+    _rpm_controller: Optional[RPMController] = PrivateAttr(default=None)
     _request_within_rpm_limit: Any = PrivateAttr(default=None)
-    _original_role: str | None = PrivateAttr(default=None)
-    _original_goal: str | None = PrivateAttr(default=None)
-    _original_backstory: str | None = PrivateAttr(default=None)
+    _original_role: Optional[str] = PrivateAttr(default=None)
+    _original_goal: Optional[str] = PrivateAttr(default=None)
+    _original_backstory: Optional[str] = PrivateAttr(default=None)
     _token_process: TokenProcess = PrivateAttr(default_factory=TokenProcess)
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     role: str = Field(description="Role of the agent")
     goal: str = Field(description="Objective of the agent")
     backstory: str = Field(description="Backstory of the agent")
-    config: dict[str, Any] | None = Field(
+    config: Optional[Dict[str, Any]] = Field(
         description="Configuration for the agent", default=None, exclude=True
     )
     cache: bool = Field(
@@ -101,7 +100,7 @@ class BaseAgent(ABC, BaseModel):
     verbose: bool = Field(
         default=False, description="Verbose mode for the Agent Execution"
     )
-    max_rpm: int | None = Field(
+    max_rpm: Optional[int] = Field(
         default=None,
         description="Maximum number of requests per minute for the agent execution to be respected.",
     )
@@ -109,7 +108,7 @@ class BaseAgent(ABC, BaseModel):
         default=False,
         description="Enable agent to delegate and ask questions among each other.",
     )
-    tools: list[BaseTool] | None = Field(
+    tools: Optional[List[BaseTool]] = Field(
         default_factory=list, description="Tools at agents' disposal"
     )
     max_iter: int = Field(
@@ -123,27 +122,27 @@ class BaseAgent(ABC, BaseModel):
     )
     crew: Any = Field(default=None, description="Crew to which the agent belongs.")
     i18n: I18N = Field(default=I18N(), description="Internationalization settings.")
-    cache_handler: InstanceOf[CacheHandler] | None = Field(
+    cache_handler: Optional[InstanceOf[CacheHandler]] = Field(
         default=None, description="An instance of the CacheHandler class."
     )
     tools_handler: InstanceOf[ToolsHandler] = Field(
         default_factory=ToolsHandler,
         description="An instance of the ToolsHandler class.",
     )
-    tools_results: list[dict[str, Any]] = Field(
+    tools_results: List[Dict[str, Any]] = Field(
         default=[], description="Results of the tools used by the agent."
     )
-    max_tokens: int | None = Field(
+    max_tokens: Optional[int] = Field(
         default=None, description="Maximum number of tokens for the agent's execution."
     )
-    knowledge: Knowledge | None = Field(
+    knowledge: Optional[Knowledge] = Field(
         default=None, description="Knowledge for the agent."
     )
-    knowledge_sources: list[BaseKnowledgeSource] | None = Field(
+    knowledge_sources: Optional[List[BaseKnowledgeSource]] = Field(
         default=None,
         description="Knowledge sources for the agent.",
     )
-    knowledge_storage: Any | None = Field(
+    knowledge_storage: Optional[Any] = Field(
         default=None,
         description="Custom knowledge storage for the agent.",
     )
@@ -151,13 +150,13 @@ class BaseAgent(ABC, BaseModel):
         default_factory=SecurityConfig,
         description="Security configuration for the agent, including fingerprinting.",
     )
-    callbacks: list[Callable] = Field(
+    callbacks: List[Callable] = Field(
         default=[], description="Callbacks to be used for the agent"
     )
     adapted_agent: bool = Field(
         default=False, description="Whether the agent is adapted"
     )
-    knowledge_config: KnowledgeConfig | None = Field(
+    knowledge_config: Optional[KnowledgeConfig] = Field(
         default=None,
         description="Knowledge configuration for the agent such as limits and threshold",
     )
@@ -169,7 +168,7 @@ class BaseAgent(ABC, BaseModel):
 
     @field_validator("tools")
     @classmethod
-    def validate_tools(cls, tools: list[Any]) -> list[BaseTool]:
+    def validate_tools(cls, tools: List[Any]) -> List[BaseTool]:
         """Validate and process the tools provided to the agent.
 
         This method ensures that each tool is either an instance of BaseTool
@@ -222,7 +221,7 @@ class BaseAgent(ABC, BaseModel):
 
     @field_validator("id", mode="before")
     @classmethod
-    def _deny_user_set_id(cls, v: UUID4 | None) -> None:
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
         if v:
             raise PydanticCustomError(
                 "may_not_set_field", "This field is not to be set by the user.", {}
@@ -253,8 +252,8 @@ class BaseAgent(ABC, BaseModel):
     def execute_task(
         self,
         task: Any,
-        context: str | None = None,
-        tools: list[BaseTool] | None = None,
+        context: Optional[str] = None,
+        tools: Optional[List[BaseTool]] = None,
     ) -> str:
         pass
 
@@ -263,8 +262,9 @@ class BaseAgent(ABC, BaseModel):
         pass
 
     @abstractmethod
-    def get_delegation_tools(self, agents: list["BaseAgent"]) -> list[BaseTool]:
+    def get_delegation_tools(self, agents: List["BaseAgent"]) -> List[BaseTool]:
         """Set the task tools that init BaseAgenTools class."""
+        pass
 
     def copy(self: T) -> T:  # type: ignore # Signature of "copy" incompatible with supertype "BaseModel"
         """Create a deep copy of the Agent."""
@@ -309,7 +309,7 @@ class BaseAgent(ABC, BaseModel):
 
         copied_data = self.model_dump(exclude=exclude)
         copied_data = {k: v for k, v in copied_data.items() if v is not None}
-        return type(self)(
+        copied_agent = type(self)(
             **copied_data,
             llm=existing_llm,
             tools=self.tools,
@@ -318,7 +318,9 @@ class BaseAgent(ABC, BaseModel):
             knowledge_storage=copied_knowledge_storage,
         )
 
-    def interpolate_inputs(self, inputs: dict[str, Any]) -> None:
+        return copied_agent
+
+    def interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
         """Interpolate inputs into the agent description and backstory."""
         if self._original_role is None:
             self._original_role = self.role
@@ -360,5 +362,5 @@ class BaseAgent(ABC, BaseModel):
             self._rpm_controller = rpm_controller
             self.create_agent_executor()
 
-    def set_knowledge(self, crew_embedder: EmbedderConfig | None = None):
+    def set_knowledge(self, crew_embedder: Optional[Dict[str, Any]] = None):
         pass

src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -1,13 +1,13 @@
 import time
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict, List
 
-from crewai.events.event_listener import event_listener
 from crewai.memory.entity.entity_memory_item import EntityMemoryItem
 from crewai.memory.long_term.long_term_memory_item import LongTermMemoryItem
 from crewai.utilities import I18N
 from crewai.utilities.converter import ConverterError
 from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
 from crewai.utilities.printer import Printer
+from crewai.events.event_listener import event_listener
 
 if TYPE_CHECKING:
     from crewai.agents.agent_builder.base_agent import BaseAgent
@@ -21,7 +21,7 @@ class CrewAgentExecutorMixin:
     task: "Task"
     iterations: int
     max_iter: int
-    messages: list[dict[str, str]]
+    messages: List[Dict[str, str]]
     _i18n: I18N
     _printer: Printer = Printer()
 
@@ -46,6 +46,7 @@ class CrewAgentExecutorMixin:
                     )
             except Exception as e:
                 print(f"Failed to add to short term memory: {e}")
+                pass
 
     def _create_external_memory(self, output) -> None:
         """Create and save a external-term memory item if conditions are met."""
@@ -66,6 +67,7 @@ class CrewAgentExecutorMixin:
                 )
             except Exception as e:
                 print(f"Failed to add to external memory: {e}")
+                pass
 
     def _create_long_term_memory(self, output) -> None:
         """Create and save long-term and entity memory items based on evaluation."""
@@ -111,8 +113,10 @@ class CrewAgentExecutorMixin:
                     self.crew._entity_memory.save(entity_memories)
             except AttributeError as e:
                 print(f"Missing attributes for long term memory: {e}")
+                pass
             except Exception as e:
                 print(f"Failed to add to long term memory: {e}")
+                pass
         elif (
             self.crew
             and self.crew._long_term_memory

src/crewai/agents/agent_builder/utilities/base_output_converter.py

@@ -1,32 +1,29 @@
-"""Base output converter for transforming text into structured formats."""
-
-from __future__ import annotations
-
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, Optional
 
 from pydantic import BaseModel, Field
 
 
 class OutputConverter(BaseModel, ABC):
-    """Abstract base class for converting text to structured formats.
+    """
+    Abstract base class for converting task results into structured formats.
 
-    Uses language models to transform unstructured text into either Pydantic models
-    or JSON objects based on provided instructions and target schemas.
+    This class provides a framework for converting unstructured text into
+    either Pydantic models or JSON, tailored for specific agent requirements.
+    It uses a language model to interpret and structure the input text based
+    on given instructions.
 
     Attributes:
-        text: The input text to be converted.
-        llm: The language model used for conversion.
-        model: The target Pydantic model class for structuring output.
-        instructions: Specific instructions for the conversion process.
-        max_attempts: Maximum number of conversion attempts (default: 3).
+        text (str): The input text to be converted.
+        llm (Any): The language model used for conversion.
+        model (Any): The target model for structuring the output.
+        instructions (str): Specific instructions for the conversion process.
+        max_attempts (int): Maximum number of conversion attempts (default: 3).
     """
 
     text: str = Field(description="Text to be converted.")
     llm: Any = Field(description="The language model to be used to convert the text.")
-    model: type[BaseModel] = Field(
-        description="The model to be used to convert the text."
-    )
+    model: Any = Field(description="The model to be used to convert the text.")
     instructions: str = Field(description="Conversion instructions to the LLM.")
     max_attempts: int = Field(
         description="Max number of attempts to try to get the output formatted.",
@@ -34,23 +31,11 @@ class OutputConverter(BaseModel, ABC):
     )
 
     @abstractmethod
-    def to_pydantic(self, current_attempt: int = 1) -> BaseModel:
-        """Convert text to a Pydantic model instance.
-
-        Args:
-            current_attempt: Current attempt number for retry logic.
-
-        Returns:
-            Pydantic model instance with structured data.
-        """
+    def to_pydantic(self, current_attempt=1) -> BaseModel:
+        """Convert text to pydantic."""
+        pass
 
     @abstractmethod
-    def to_json(self, current_attempt: int = 1) -> dict[str, Any]:
-        """Convert text to a JSON dictionary.
-
-        Args:
-            current_attempt: Current attempt number for retry logic.
-
-        Returns:
-            Dictionary containing structured JSON data.
-        """
+    def to_json(self, current_attempt=1) -> dict:
+        """Convert text to json."""
+        pass

src/crewai/agents/agent_builder/utilities/base_token_process.py

@@ -1,25 +1,8 @@
-"""Token usage tracking utilities.
-
-This module provides utilities for tracking token consumption and request
-metrics during agent execution.
-"""
-
 from crewai.types.usage_metrics import UsageMetrics
 
 
 class TokenProcess:
-    """Track token usage during agent processing.
-
-    Attributes:
-        total_tokens: Total number of tokens used.
-        prompt_tokens: Number of tokens used in prompts.
-        cached_prompt_tokens: Number of cached prompt tokens used.
-        completion_tokens: Number of tokens used in completions.
-        successful_requests: Number of successful requests made.
-    """
-
     def __init__(self) -> None:
-        """Initialize token tracking with zero values."""
         self.total_tokens: int = 0
         self.prompt_tokens: int = 0
         self.cached_prompt_tokens: int = 0
@@ -27,45 +10,20 @@ class TokenProcess:
         self.successful_requests: int = 0
 
     def sum_prompt_tokens(self, tokens: int) -> None:
-        """Add prompt tokens to the running totals.
-
-        Args:
-            tokens: Number of prompt tokens to add.
-        """
         self.prompt_tokens += tokens
         self.total_tokens += tokens
 
     def sum_completion_tokens(self, tokens: int) -> None:
-        """Add completion tokens to the running totals.
-
-        Args:
-            tokens: Number of completion tokens to add.
-        """
         self.completion_tokens += tokens
         self.total_tokens += tokens
 
     def sum_cached_prompt_tokens(self, tokens: int) -> None:
-        """Add cached prompt tokens to the running total.
-
-        Args:
-            tokens: Number of cached prompt tokens to add.
-        """
         self.cached_prompt_tokens += tokens
 
     def sum_successful_requests(self, requests: int) -> None:
-        """Add successful requests to the running total.
-
-        Args:
-            requests: Number of successful requests to add.
-        """
         self.successful_requests += requests
 
     def get_summary(self) -> UsageMetrics:
-        """Get a summary of all tracked metrics.
-
-        Returns:
-            UsageMetrics object with current totals.
-        """
         return UsageMetrics(
             total_tokens=self.total_tokens,
             prompt_tokens=self.prompt_tokens,

src/crewai/agents/cache/cache_handler.py

@@ -1,45 +1,15 @@
-"""Cache handler for tool usage results."""
-
-from typing import Any
+from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, PrivateAttr
 
 
 class CacheHandler(BaseModel):
-    """Handles caching of tool execution results.
+    """Callback handler for tool usage."""
 
-    Provides in-memory caching for tool outputs based on tool name and input.
+    _cache: Dict[str, Any] = PrivateAttr(default_factory=dict)
 
-    Notes:
-        - TODO: Make thread-safe.
-    """
-
-    _cache: dict[str, Any] = PrivateAttr(default_factory=dict)
-
-    def add(self, tool: str, input: str, output: Any) -> None:
-        """Add a tool result to the cache.
-
-        Args:
-            tool: Name of the tool.
-            input: Input string used for the tool.
-            output: Output result from tool execution.
-
-        Notes:
-            - TODO: Rename 'input' parameter to avoid shadowing builtin.
-        """
+    def add(self, tool, input, output):
         self._cache[f"{tool}-{input}"] = output
 
-    def read(self, tool: str, input: str) -> Any | None:
-        """Retrieve a cached tool result.
-
-        Args:
-            tool: Name of the tool.
-            input: Input string used for the tool.
-
-        Returns:
-            Cached result if found, None otherwise.
-
-        Notes:
-            - TODO: Rename 'input' parameter to avoid shadowing builtin.
-        """
+    def read(self, tool, input) -> Optional[str]:
         return self._cache.get(f"{tool}-{input}")

src/crewai/agents/crew_agent_executor.py

@@ -12,7 +12,7 @@ from crewai.agents.agent_builder.base_agent_executor_mixin import CrewAgentExecu
 from crewai.agents.parser import (
     AgentAction,
     AgentFinish,
-    OutputParserError,
+    OutputParserException,
 )
 from crewai.agents.tools_handler import ToolsHandler
 from crewai.events.event_bus import crewai_event_bus
@@ -228,7 +228,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 self._invoke_step_callback(formatted_answer)
                 self._append_message(formatted_answer.text)
 
-            except OutputParserError as e:  # noqa: PERF203
+            except OutputParserException as e:
                 formatted_answer = handle_output_parser_exception(
                     e=e,
                     messages=self.messages,
@@ -251,20 +251,17 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         i18n=self._i18n,
                     )
                     continue
-                handle_unknown_error(self._printer, e)
-                raise e
+                else:
+                    handle_unknown_error(self._printer, e)
+                    raise e
             finally:
                 self.iterations += 1
 
         # During the invoke loop, formatted_answer alternates between AgentAction
         # (when the agent is using tools) and eventually becomes AgentFinish
-        # (when the agent reaches a final answer). This check confirms we've
+        # (when the agent reaches a final answer). This assertion confirms we've
         # reached a final answer and helps type checking understand this transition.
-        if not isinstance(formatted_answer, AgentFinish):
-            raise RuntimeError(
-                "Agent execution ended without reaching a final answer. "
-                f"Got {type(formatted_answer).__name__} instead of AgentFinish."
-            )
+        assert isinstance(formatted_answer, AgentFinish)
         self._show_logs(formatted_answer)
         return formatted_answer
 
@@ -327,7 +324,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             self.agent,
             AgentLogsStartedEvent(
                 agent_role=self.agent.role,
-                task_description=(self.task.description if self.task else "Not Found"),
+                task_description=(
+                    getattr(self.task, "description") if self.task else "Not Found"
+                ),
                 verbose=self.agent.verbose
                 or (hasattr(self, "crew") and getattr(self.crew, "verbose", False)),
             ),
@@ -416,7 +415,8 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         """
         prompt = prompt.replace("{input}", inputs["input"])
         prompt = prompt.replace("{tool_names}", inputs["tool_names"])
-        return prompt.replace("{tools}", inputs["tools"])
+        prompt = prompt.replace("{tools}", inputs["tools"])
+        return prompt
 
     def _handle_human_feedback(self, formatted_answer: AgentFinish) -> AgentFinish:
         """Process human feedback.

src/crewai/agents/parser.py

@@ -7,18 +7,18 @@ AgentAction or AgentFinish objects.
 
 from dataclasses import dataclass
 
-from json_repair import repair_json  # type: ignore[import-untyped]
+from json_repair import repair_json
 
 from crewai.agents.constants import (
-    ACTION_INPUT_ONLY_REGEX,
     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.i18n import I18N
+from crewai.utilities import I18N
 
 _I18N = I18N()
 
@@ -43,7 +43,7 @@ class AgentFinish:
     text: str
 
 
-class OutputParserError(Exception):
+class OutputParserException(Exception):
     """Exception raised when output parsing fails.
 
     Attributes:
@@ -51,7 +51,7 @@ class OutputParserError(Exception):
     """
 
     def __init__(self, error: str) -> None:
-        """Initialize OutputParserError.
+        """Initialize OutputParserException.
 
         Args:
             error: The error message.
@@ -87,7 +87,7 @@ def parse(text: str) -> AgentAction | AgentFinish:
         AgentAction or AgentFinish based on the content.
 
     Raises:
-        OutputParserError: If the text format is invalid.
+        OutputParserException: If the text format is invalid.
     """
     thought = _extract_thought(text)
     includes_answer = FINAL_ANSWER_ACTION in text
@@ -104,7 +104,7 @@ def parse(text: str) -> AgentAction | AgentFinish:
                 final_answer = final_answer[:-3].rstrip()
         return AgentFinish(thought=thought, output=final_answer, text=text)
 
-    if action_match:
+    elif action_match:
         action = action_match.group(1)
         clean_action = _clean_action(action)
 
@@ -118,18 +118,19 @@ def parse(text: str) -> AgentAction | AgentFinish:
         )
 
     if not ACTION_REGEX.search(text):
-        raise OutputParserError(
+        raise OutputParserException(
             f"{MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE}\n{_I18N.slice('final_answer_format')}",
         )
-    if not ACTION_INPUT_ONLY_REGEX.search(text):
-        raise OutputParserError(
+    elif not ACTION_INPUT_ONLY_REGEX.search(text):
+        raise OutputParserException(
             MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
         )
-    err_format = _I18N.slice("format_without_tools")
-    error = f"{err_format}"
-    raise OutputParserError(
-        error,
-    )
+    else:
+        err_format = _I18N.slice("format_without_tools")
+        error = f"{err_format}"
+        raise OutputParserException(
+            error,
+        )
 
 
 def _extract_thought(text: str) -> str:
@@ -148,7 +149,8 @@ def _extract_thought(text: str) -> str:
         return ""
     thought = text[:thought_index].strip()
     # Remove any triple backticks from the thought string
-    return thought.replace("```", "").strip()
+    thought = thought.replace("```", "").strip()
+    return thought
 
 
 def _clean_action(text: str) -> str:

src/crewai/agents/tools_handler.py

@@ -1,10 +1,8 @@
 """Tools handler for managing tool execution and caching."""
 
-import json
-
-from crewai.agents.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:
@@ -39,16 +37,8 @@ class ToolsHandler:
         """
         self.last_used_tool = calling
         if self.cache and should_cache and calling.tool_name != CacheTools().name:
-            # Convert arguments to string for cache
-            input_str = ""
-            if calling.arguments:
-                if isinstance(calling.arguments, dict):
-                    input_str = json.dumps(calling.arguments)
-                else:
-                    input_str = str(calling.arguments)
-
             self.cache.add(
                 tool=calling.tool_name,
-                input=input_str,
+                input=calling.arguments,
                 output=output,
             )

src/crewai/cli/authentication/providers/auth0.py

@@ -1,6 +1,5 @@
 from crewai.cli.authentication.providers.base_provider import BaseProvider
 
-
 class Auth0Provider(BaseProvider):
     def get_authorize_url(self) -> str:
         return f"https://{self._get_domain()}/oauth/device/code"
@@ -15,20 +14,13 @@ class Auth0Provider(BaseProvider):
         return f"https://{self._get_domain()}/"
 
     def get_audience(self) -> str:
-        if self.settings.audience is None:
-            raise ValueError(
-                "Audience is required. Please set it in the configuration."
-            )
+        assert self.settings.audience is not None, "Audience is required"
         return self.settings.audience
 
     def get_client_id(self) -> str:
-        if self.settings.client_id is None:
-            raise ValueError(
-                "Client ID is required. Please set it in the configuration."
-            )
+        assert self.settings.client_id is not None, "Client ID is required"
         return self.settings.client_id
 
     def _get_domain(self) -> str:
-        if self.settings.domain is None:
-            raise ValueError("Domain is required. Please set it in the configuration.")
+        assert self.settings.domain is not None, "Domain is required"
         return self.settings.domain

src/crewai/cli/authentication/providers/base_provider.py

@@ -1,26 +1,30 @@
 from abc import ABC, abstractmethod
-
 from crewai.cli.authentication.main import Oauth2Settings
 
-
 class BaseProvider(ABC):
     def __init__(self, settings: Oauth2Settings):
         self.settings = settings
 
     @abstractmethod
-    def get_authorize_url(self) -> str: ...
+    def get_authorize_url(self) -> str:
+        ...
 
     @abstractmethod
-    def get_token_url(self) -> str: ...
+    def get_token_url(self) -> str:
+        ...
 
     @abstractmethod
-    def get_jwks_url(self) -> str: ...
+    def get_jwks_url(self) -> str:
+        ...
 
     @abstractmethod
-    def get_issuer(self) -> str: ...
+    def get_issuer(self) -> str:
+        ...
 
     @abstractmethod
-    def get_audience(self) -> str: ...
+    def get_audience(self) -> str:
+        ...
 
     @abstractmethod
-    def get_client_id(self) -> str: ...
+    def get_client_id(self) -> str:
+        ...

src/crewai/cli/authentication/providers/okta.py

@@ -1,6 +1,5 @@
 from crewai.cli.authentication.providers.base_provider import BaseProvider
 
-
 class OktaProvider(BaseProvider):
     def get_authorize_url(self) -> str:
         return f"https://{self.settings.domain}/oauth2/default/v1/device/authorize"
@@ -15,15 +14,9 @@ class OktaProvider(BaseProvider):
         return f"https://{self.settings.domain}/oauth2/default"
 
     def get_audience(self) -> str:
-        if self.settings.audience is None:
-            raise ValueError(
-                "Audience is required. Please set it in the configuration."
-            )
+        assert self.settings.audience is not None
         return self.settings.audience
 
     def get_client_id(self) -> str:
-        if self.settings.client_id is None:
-            raise ValueError(
-                "Client ID is required. Please set it in the configuration."
-            )
+        assert self.settings.client_id is not None
         return self.settings.client_id

src/crewai/cli/authentication/providers/workos.py

@@ -1,6 +1,5 @@
 from crewai.cli.authentication.providers.base_provider import BaseProvider
 
-
 class WorkosProvider(BaseProvider):
     def get_authorize_url(self) -> str:
         return f"https://{self._get_domain()}/oauth2/device_authorization"
@@ -18,13 +17,9 @@ class WorkosProvider(BaseProvider):
         return self.settings.audience or ""
 
     def get_client_id(self) -> str:
-        if self.settings.client_id is None:
-            raise ValueError(
-                "Client ID is required. Please set it in the configuration."
-            )
+        assert self.settings.client_id is not None, "Client ID is required"
         return self.settings.client_id
 
     def _get_domain(self) -> str:
-        if self.settings.domain is None:
-            raise ValueError("Domain is required. Please set it in the configuration.")
+        assert self.settings.domain is not None, "Domain is required"
         return self.settings.domain

src/crewai/cli/authentication/utils.py

@@ -17,6 +17,8 @@ def validate_jwt_token(
                        missing required claims).
     """
 
+    decoded_token = None
+
     try:
         jwk_client = PyJWKClient(jwks_url)
         signing_key = jwk_client.get_signing_key_from_jwt(jwt_token)
@@ -24,7 +26,7 @@ def validate_jwt_token(
         _unverified_decoded_token = jwt.decode(
             jwt_token, options={"verify_signature": False}
         )
-        return jwt.decode(
+        decoded_token = jwt.decode(
             jwt_token,
             signing_key.key,
             algorithms=["RS256"],
@@ -38,22 +40,23 @@ def validate_jwt_token(
                 "require": ["exp", "iat", "iss", "aud", "sub"],
             },
         )
+        return decoded_token
 
-    except jwt.ExpiredSignatureError as e:
-        raise Exception("Token has expired.") from e
-    except jwt.InvalidAudienceError as e:
+    except jwt.ExpiredSignatureError:
+        raise Exception("Token has expired.")
+    except jwt.InvalidAudienceError:
         actual_audience = _unverified_decoded_token.get("aud", "[no audience found]")
         raise Exception(
             f"Invalid token audience. Got: '{actual_audience}'. Expected: '{audience}'"
-        ) from e
-    except jwt.InvalidIssuerError as e:
+        )
+    except jwt.InvalidIssuerError:
         actual_issuer = _unverified_decoded_token.get("iss", "[no issuer found]")
         raise Exception(
             f"Invalid token issuer. Got: '{actual_issuer}'. Expected: '{issuer}'"
-        ) from e
+        )
     except jwt.MissingRequiredClaimError as e:
-        raise Exception(f"Token is missing required claims: {e!s}") from e
+        raise Exception(f"Token is missing required claims: {str(e)}")
     except jwt.exceptions.PyJWKClientError as e:
-        raise Exception(f"JWKS or key processing error: {e!s}") from e
+        raise Exception(f"JWKS or key processing error: {str(e)}")
     except jwt.InvalidTokenError as e:
-        raise Exception(f"Invalid token: {e!s}") from e
+        raise Exception(f"Invalid token: {str(e)}")

src/crewai/cli/cli.py

@@ -1,16 +1,13 @@
-import os
-import subprocess
 from importlib.metadata import version as get_version
+from typing import Optional
 
 import click
-
-from crewai.cli.add_crew_to_flow import add_crew_to_flow
 from crewai.cli.config import Settings
+from crewai.cli.settings.main import SettingsCommand
+from crewai.cli.add_crew_to_flow import add_crew_to_flow
 from crewai.cli.create_crew import create_crew
 from crewai.cli.create_flow import create_flow
 from crewai.cli.crew_chat import run_chat
-from crewai.cli.settings.main import SettingsCommand
-from crewai.cli.utils import build_env_with_tool_repository_credentials, read_toml
 from crewai.memory.storage.kickoff_task_outputs_storage import (
     KickoffTaskOutputsSQLiteStorage,
 )
@@ -37,46 +34,6 @@ def crewai():
     """Top-level command group for crewai."""
 
 
-@crewai.command(
-    name="uv",
-    context_settings=dict(
-        ignore_unknown_options=True,
-    ),
-)
-@click.argument("uv_args", nargs=-1, type=click.UNPROCESSED)
-def uv(uv_args):
-    """A wrapper around uv commands that adds custom tool authentication through env vars."""
-    env = os.environ.copy()
-    try:
-        pyproject_data = read_toml()
-        sources = pyproject_data.get("tool", {}).get("uv", {}).get("sources", {})
-
-        for source_config in sources.values():
-            if isinstance(source_config, dict):
-                index = source_config.get("index")
-                if index:
-                    index_env = build_env_with_tool_repository_credentials(index)
-                    env.update(index_env)
-    except (FileNotFoundError, KeyError) as e:
-        raise SystemExit(
-            "Error. A valid pyproject.toml file is required. Check that a valid pyproject.toml file exists in the current directory."
-        ) from e
-    except Exception as e:
-        raise SystemExit(f"Error: {e}") from e
-
-    try:
-        subprocess.run(  # noqa: S603
-            ["uv", *uv_args],  # noqa: S607
-            capture_output=False,
-            env=env,
-            text=True,
-            check=True,
-        )
-    except subprocess.CalledProcessError as e:
-        click.secho(f"uv command failed with exit code {e.returncode}", fg="red")
-        raise SystemExit(e.returncode) from e
-
-
 @crewai.command()
 @click.argument("type", type=click.Choice(["crew", "flow"]))
 @click.argument("name")
@@ -280,6 +237,13 @@ def login():
 @crewai.group()
 def deploy():
     """Deploy the Crew CLI group."""
+    pass
+
+
+@crewai.group()
+def tool():
+    """Tool Repository related commands."""
+    pass
 
 
 @deploy.command(name="create")
@@ -299,7 +263,7 @@ def deploy_list():
 
 @deploy.command(name="push")
 @click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
-def deploy_push(uuid: str | None):
+def deploy_push(uuid: Optional[str]):
     """Deploy the Crew."""
     deploy_cmd = DeployCommand()
     deploy_cmd.deploy(uuid=uuid)
@@ -307,7 +271,7 @@ def deploy_push(uuid: str | None):
 
 @deploy.command(name="status")
 @click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
-def deply_status(uuid: str | None):
+def deply_status(uuid: Optional[str]):
     """Get the status of a deployment."""
     deploy_cmd = DeployCommand()
     deploy_cmd.get_crew_status(uuid=uuid)
@@ -315,7 +279,7 @@ def deply_status(uuid: str | None):
 
 @deploy.command(name="logs")
 @click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
-def deploy_logs(uuid: str | None):
+def deploy_logs(uuid: Optional[str]):
     """Get the logs of a deployment."""
     deploy_cmd = DeployCommand()
     deploy_cmd.get_crew_logs(uuid=uuid)
@@ -323,17 +287,12 @@ def deploy_logs(uuid: str | None):
 
 @deploy.command(name="remove")
 @click.option("-u", "--uuid", type=str, help="Crew UUID parameter")
-def deploy_remove(uuid: str | None):
+def deploy_remove(uuid: Optional[str]):
     """Remove a deployment."""
     deploy_cmd = DeployCommand()
     deploy_cmd.remove_crew(uuid=uuid)
 
 
-@crewai.group()
-def tool():
-    """Tool Repository related commands."""
-
-
 @tool.command(name="create")
 @click.argument("handle")
 def tool_create(handle: str):
@@ -368,6 +327,7 @@ def tool_publish(is_public: bool, force: bool):
 @crewai.group()
 def flow():
     """Flow related commands."""
+    pass
 
 
 @flow.command(name="kickoff")
@@ -399,7 +359,7 @@ def chat():
     and using the Chat LLM to generate responses.
     """
     click.secho(
-        "\nStarting a conversation with the Crew\nType 'exit' or Ctrl+C to quit.\n",
+        "\nStarting a conversation with the Crew\n" "Type 'exit' or Ctrl+C to quit.\n",
     )
 
     run_chat()
@@ -408,6 +368,7 @@ def chat():
 @crewai.group(invoke_without_command=True)
 def org():
     """Organization management commands."""
+    pass
 
 
 @org.command("list")
@@ -435,6 +396,7 @@ def current():
 @crewai.group()
 def enterprise():
     """Enterprise Configuration commands."""
+    pass
 
 
 @enterprise.command("configure")
@@ -448,6 +410,7 @@ def enterprise_configure(enterprise_url: str):
 @crewai.group()
 def config():
     """CLI Configuration commands."""
+    pass
 
 
 @config.command("list")

src/crewai/cli/config.py

@@ -1,61 +1,20 @@
 import json
-import tempfile
-from logging import getLogger
 from pathlib import Path
+from typing import Optional
 
 from pydantic import BaseModel, Field
 
 from crewai.cli.constants import (
+    DEFAULT_CREWAI_ENTERPRISE_URL,
+    CREWAI_ENTERPRISE_DEFAULT_OAUTH2_PROVIDER,
     CREWAI_ENTERPRISE_DEFAULT_OAUTH2_AUDIENCE,
     CREWAI_ENTERPRISE_DEFAULT_OAUTH2_CLIENT_ID,
     CREWAI_ENTERPRISE_DEFAULT_OAUTH2_DOMAIN,
-    CREWAI_ENTERPRISE_DEFAULT_OAUTH2_PROVIDER,
-    DEFAULT_CREWAI_ENTERPRISE_URL,
 )
 from crewai.cli.shared.token_manager import TokenManager
 
-logger = getLogger(__name__)
-
 DEFAULT_CONFIG_PATH = Path.home() / ".config" / "crewai" / "settings.json"
 
-
-def get_writable_config_path() -> Path | None:
-    """
-    Find a writable location for the config file with fallback options.
-
-    Tries in order:
-    1. Default: ~/.config/crewai/settings.json
-    2. Temp directory: /tmp/crewai_settings.json (or OS equivalent)
-    3. Current directory: ./crewai_settings.json
-    4. In-memory only (returns None)
-
-    Returns:
-        Path object for writable config location, or None if no writable location found
-    """
-    fallback_paths = [
-        DEFAULT_CONFIG_PATH,  # Default location
-        Path(tempfile.gettempdir()) / "crewai_settings.json",  # Temporary directory
-        Path.cwd() / "crewai_settings.json",  # Current working directory
-    ]
-
-    for config_path in fallback_paths:
-        try:
-            config_path.parent.mkdir(parents=True, exist_ok=True)
-            test_file = config_path.parent / ".crewai_write_test"
-            try:
-                test_file.write_text("test")
-                test_file.unlink()  # Clean up test file
-                logger.info(f"Using config path: {config_path}")
-                return config_path
-            except Exception:  # noqa: S112
-                continue
-
-        except Exception:  # noqa: S112
-            continue
-
-    return None
-
-
 # Settings that are related to the user's account
 USER_SETTINGS_KEYS = [
     "tool_repository_username",
@@ -97,20 +56,20 @@ HIDDEN_SETTINGS_KEYS = [
 
 
 class Settings(BaseModel):
-    enterprise_base_url: str | None = Field(
+    enterprise_base_url: Optional[str] = Field(
         default=DEFAULT_CLI_SETTINGS["enterprise_base_url"],
         description="Base URL of the CrewAI Enterprise instance",
     )
-    tool_repository_username: str | None = Field(
+    tool_repository_username: Optional[str] = Field(
         None, description="Username for interacting with the Tool Repository"
     )
-    tool_repository_password: str | None = Field(
+    tool_repository_password: Optional[str] = Field(
         None, description="Password for interacting with the Tool Repository"
     )
-    org_name: str | None = Field(
+    org_name: Optional[str] = Field(
         None, description="Name of the currently active organization"
     )
-    org_uuid: str | None = Field(
+    org_uuid: Optional[str] = Field(
         None, description="UUID of the currently active organization"
     )
     config_path: Path = Field(default=DEFAULT_CONFIG_PATH, frozen=True, exclude=True)
@@ -120,7 +79,7 @@ class Settings(BaseModel):
         default=DEFAULT_CLI_SETTINGS["oauth2_provider"],
     )
 
-    oauth2_audience: str | None = Field(
+    oauth2_audience: Optional[str] = Field(
         description="OAuth2 audience value, typically used to identify the target API or resource.",
         default=DEFAULT_CLI_SETTINGS["oauth2_audience"],
     )
@@ -135,32 +94,16 @@ class Settings(BaseModel):
         default=DEFAULT_CLI_SETTINGS["oauth2_domain"],
     )
 
-    def __init__(self, config_path: Path | None = None, **data):
-        """Load Settings from config path with fallback support"""
-        if config_path is None:
-            config_path = get_writable_config_path()
-
-        # If config_path is None, we're in memory-only mode
-        if config_path is None:
-            merged_data = {**data}
-            # Dummy path for memory-only mode
-            super().__init__(config_path=Path("/dev/null"), **merged_data)
-            return
-
-        try:
-            config_path.parent.mkdir(parents=True, exist_ok=True)
-        except Exception:
-            merged_data = {**data}
-            # Dummy path for memory-only mode
-            super().__init__(config_path=Path("/dev/null"), **merged_data)
-            return
+    def __init__(self, config_path: Path = DEFAULT_CONFIG_PATH, **data):
+        """Load Settings from config path"""
+        config_path.parent.mkdir(parents=True, exist_ok=True)
 
         file_data = {}
         if config_path.is_file():
             try:
                 with config_path.open("r") as f:
                     file_data = json.load(f)
-            except Exception:
+            except json.JSONDecodeError:
                 file_data = {}
 
         merged_data = {**file_data, **data}
@@ -180,22 +123,15 @@ class Settings(BaseModel):
 
     def dump(self) -> None:
         """Save current settings to settings.json"""
-        if str(self.config_path) == "/dev/null":
-            return
+        if self.config_path.is_file():
+            with self.config_path.open("r") as f:
+                existing_data = json.load(f)
+        else:
+            existing_data = {}
 
-        try:
-            if self.config_path.is_file():
-                with self.config_path.open("r") as f:
-                    existing_data = json.load(f)
-            else:
-                existing_data = {}
-
-            updated_data = {**existing_data, **self.model_dump(exclude_unset=True)}
-            with self.config_path.open("w") as f:
-                json.dump(updated_data, f, indent=4)
-
-        except Exception:  # noqa: S110
-            pass
+        updated_data = {**existing_data, **self.model_dump(exclude_unset=True)}
+        with self.config_path.open("w") as f:
+            json.dump(updated_data, f, indent=4)
 
     def _reset_user_settings(self) -> None:
         """Reset all user settings to default values"""

src/crewai/cli/create_crew.py

@@ -16,72 +16,48 @@ from crewai.cli.utils import copy_template, load_env_vars, write_env_file
 def create_folder_structure(name, parent_folder=None):
     import keyword
     import re
-
-    name = name.rstrip("/")
-
+    
+    name = name.rstrip('/')
+    
     if not name.strip():
         raise ValueError("Project name cannot be empty or contain only whitespace")
-
+    
     folder_name = name.replace(" ", "_").replace("-", "_").lower()
-    folder_name = re.sub(r"[^a-zA-Z0-9_]", "", folder_name)
-
+    folder_name = re.sub(r'[^a-zA-Z0-9_]', '', folder_name)
+    
     # Check if the name starts with invalid characters or is primarily invalid
-    if re.match(r"^[^a-zA-Z0-9_-]+", name):
-        raise ValueError(
-            f"Project name '{name}' contains no valid characters for a Python module name"
-        )
-
+    if re.match(r'^[^a-zA-Z0-9_-]+', name):
+        raise ValueError(f"Project name '{name}' contains no valid characters for a Python module name")
+    
     if not folder_name:
-        raise ValueError(
-            f"Project name '{name}' contains no valid characters for a Python module name"
-        )
-
+        raise ValueError(f"Project name '{name}' contains no valid characters for a Python module name")
+    
     if folder_name[0].isdigit():
-        raise ValueError(
-            f"Project name '{name}' would generate folder name '{folder_name}' which cannot start with a digit (invalid Python module name)"
-        )
-
+        raise ValueError(f"Project name '{name}' would generate folder name '{folder_name}' which cannot start with a digit (invalid Python module name)")
+    
     if keyword.iskeyword(folder_name):
-        raise ValueError(
-            f"Project name '{name}' would generate folder name '{folder_name}' which is a reserved Python keyword"
-        )
-
+        raise ValueError(f"Project name '{name}' would generate folder name '{folder_name}' which is a reserved Python keyword")
+    
     if not folder_name.isidentifier():
-        raise ValueError(
-            f"Project name '{name}' would generate invalid Python module name '{folder_name}'"
-        )
-
+        raise ValueError(f"Project name '{name}' would generate invalid Python module name '{folder_name}'")
+    
     class_name = name.replace("_", " ").replace("-", " ").title().replace(" ", "")
-
-    class_name = re.sub(r"[^a-zA-Z0-9_]", "", class_name)
-
+    
+    class_name = re.sub(r'[^a-zA-Z0-9_]', '', class_name)
+    
     if not class_name:
-        raise ValueError(
-            f"Project name '{name}' contains no valid characters for a Python class name"
-        )
-
+        raise ValueError(f"Project name '{name}' contains no valid characters for a Python class name")
+    
     if class_name[0].isdigit():
-        raise ValueError(
-            f"Project name '{name}' would generate class name '{class_name}' which cannot start with a digit"
-        )
-
+        raise ValueError(f"Project name '{name}' would generate class name '{class_name}' which cannot start with a digit")
+    
     # Check if the original name (before title casing) is a keyword
-    original_name_clean = re.sub(
-        r"[^a-zA-Z0-9_]", "", name.replace("_", "").replace("-", "").lower()
-    )
-    if (
-        keyword.iskeyword(original_name_clean)
-        or keyword.iskeyword(class_name)
-        or class_name in ("True", "False", "None")
-    ):
-        raise ValueError(
-            f"Project name '{name}' would generate class name '{class_name}' which is a reserved Python keyword"
-        )
-
+    original_name_clean = re.sub(r'[^a-zA-Z0-9_]', '', name.replace("_", "").replace("-", "").lower())
+    if keyword.iskeyword(original_name_clean) or keyword.iskeyword(class_name) or class_name in ('True', 'False', 'None'):
+        raise ValueError(f"Project name '{name}' would generate class name '{class_name}' which is a reserved Python keyword")
+    
     if not class_name.isidentifier():
-        raise ValueError(
-            f"Project name '{name}' would generate invalid Python class name '{class_name}'"
-        )
+        raise ValueError(f"Project name '{name}' would generate invalid Python class name '{class_name}'")
 
     if parent_folder:
         folder_path = Path(parent_folder) / folder_name
@@ -196,7 +172,7 @@ def create_crew(name, provider=None, skip_provider=False, parent_folder=None):
             )
 
         # Check if the selected provider has predefined models
-        if MODELS.get(selected_provider):
+        if selected_provider in MODELS and MODELS[selected_provider]:
             while True:
                 selected_model = select_model(selected_provider, provider_models)
                 if selected_model is None:  # User typed 'q'

src/crewai/cli/crew_chat.py

@@ -5,7 +5,7 @@ import sys
 import threading
 import time
 from pathlib import Path
-from typing import Any
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 import click
 import tomli
@@ -116,7 +116,7 @@ def show_loading(event: threading.Event):
     print()
 
 
-def initialize_chat_llm(crew: Crew) -> LLM | BaseLLM | None:
+def initialize_chat_llm(crew: Crew) -> Optional[LLM | BaseLLM]:
     """Initializes the chat LLM and handles exceptions."""
     try:
         return create_llm(crew.chat_llm)
@@ -157,7 +157,7 @@ def build_system_message(crew_chat_inputs: ChatInputs) -> str:
     )
 
 
-def create_tool_function(crew: Crew, messages: list[dict[str, str]]) -> Any:
+def create_tool_function(crew: Crew, messages: List[Dict[str, str]]) -> Any:
     """Creates a wrapper function for running the crew tool with messages."""
 
     def run_crew_tool_with_messages(**kwargs):
@@ -193,7 +193,7 @@ def chat_loop(chat_llm, messages, crew_tool_schema, available_functions):
                 user_input, chat_llm, messages, crew_tool_schema, available_functions
             )
 
-        except KeyboardInterrupt:  # noqa: PERF203
+        except KeyboardInterrupt:
             click.echo("\nExiting chat. Goodbye!")
             break
         except Exception as e:
@@ -221,9 +221,9 @@ def get_user_input() -> str:
 def handle_user_input(
     user_input: str,
     chat_llm: LLM,
-    messages: list[dict[str, str]],
-    crew_tool_schema: dict[str, Any],
-    available_functions: dict[str, Any],
+    messages: List[Dict[str, str]],
+    crew_tool_schema: Dict[str, Any],
+    available_functions: Dict[str, Any],
 ) -> None:
     if user_input.strip().lower() == "exit":
         click.echo("Exiting chat. Goodbye!")
@@ -281,7 +281,7 @@ def generate_crew_tool_schema(crew_inputs: ChatInputs) -> dict:
     }
 
 
-def run_crew_tool(crew: Crew, messages: list[dict[str, str]], **kwargs):
+def run_crew_tool(crew: Crew, messages: List[Dict[str, str]], **kwargs):
     """
     Runs the crew using crew.kickoff(inputs=kwargs) and returns the output.
 
@@ -304,8 +304,9 @@ def run_crew_tool(crew: Crew, messages: list[dict[str, str]], **kwargs):
         crew_output = crew.kickoff(inputs=kwargs)
 
         # Convert CrewOutput to a string to send back to the user
-        return str(crew_output)
+        result = str(crew_output)
 
+        return result
     except Exception as e:
         # Exit the chat and show the error message
         click.secho("An error occurred while running the crew:", fg="red")
@@ -313,7 +314,7 @@ def run_crew_tool(crew: Crew, messages: list[dict[str, str]], **kwargs):
         sys.exit(1)
 
 
-def load_crew_and_name() -> tuple[Crew, str]:
+def load_crew_and_name() -> Tuple[Crew, str]:
     """
     Loads the crew by importing the crew class from the user's project.
 
@@ -350,17 +351,15 @@ def load_crew_and_name() -> tuple[Crew, str]:
     try:
         crew_module = __import__(crew_module_name, fromlist=[crew_class_name])
     except ImportError as e:
-        raise ImportError(
-            f"Failed to import crew module {crew_module_name}: {e}"
-        ) from e
+        raise ImportError(f"Failed to import crew module {crew_module_name}: {e}")
 
     # Get the crew class from the module
     try:
         crew_class = getattr(crew_module, crew_class_name)
-    except AttributeError as e:
+    except AttributeError:
         raise AttributeError(
             f"Crew class {crew_class_name} not found in module {crew_module_name}"
-        ) from e
+        )
 
     # Instantiate the crew
     crew_instance = crew_class().crew()
@@ -396,7 +395,7 @@ def generate_crew_chat_inputs(crew: Crew, crew_name: str, chat_llm) -> ChatInput
     )
 
 
-def fetch_required_inputs(crew: Crew) -> set[str]:
+def fetch_required_inputs(crew: Crew) -> Set[str]:
     """
     Extracts placeholders from the crew's tasks and agents.
 
@@ -406,8 +405,8 @@ def fetch_required_inputs(crew: Crew) -> set[str]:
     Returns:
         Set[str]: A set of placeholder names.
     """
-    placeholder_pattern = re.compile(r"\{(.+?)}")
-    required_inputs: set[str] = set()
+    placeholder_pattern = re.compile(r"\{(.+?)\}")
+    required_inputs: Set[str] = set()
 
     # Scan tasks
     for task in crew.tasks:
@@ -436,7 +435,7 @@ def generate_input_description_with_ai(input_name: str, crew: Crew, chat_llm) ->
     """
     # Gather context from tasks and agents where the input is used
     context_texts = []
-    placeholder_pattern = re.compile(r"\{(.+?)}")
+    placeholder_pattern = re.compile(r"\{(.+?)\}")
 
     for task in crew.tasks:
         if (
@@ -480,7 +479,9 @@ def generate_input_description_with_ai(input_name: str, crew: Crew, chat_llm) ->
         f"{context}"
     )
     response = chat_llm.call(messages=[{"role": "user", "content": prompt}])
-    return response.strip()
+    description = response.strip()
+
+    return description
 
 
 def generate_crew_description_with_ai(crew: Crew, chat_llm) -> str:
@@ -496,7 +497,7 @@ def generate_crew_description_with_ai(crew: Crew, chat_llm) -> str:
     """
     # Gather context from tasks and agents
     context_texts = []
-    placeholder_pattern = re.compile(r"\{(.+?)}")
+    placeholder_pattern = re.compile(r"\{(.+?)\}")
 
     for task in crew.tasks:
         # Replace placeholders with input names
@@ -530,4 +531,6 @@ def generate_crew_description_with_ai(crew: Crew, chat_llm) -> str:
         f"{context}"
     )
     response = chat_llm.call(messages=[{"role": "user", "content": prompt}])
-    return response.strip()
+    crew_description = response.strip()
+
+    return crew_description

src/crewai/cli/git.py

@@ -14,15 +14,11 @@ class Repository:
 
         self.fetch()
 
-    @staticmethod
-    def is_git_installed() -> bool:
+    def is_git_installed(self) -> bool:
         """Check if Git is installed and available in the system."""
         try:
             subprocess.run(
-                ["git", "--version"],  # noqa: S607
-                capture_output=True,
-                check=True,
-                text=True,
+                ["git", "--version"], capture_output=True, check=True, text=True
             )
             return True
         except (subprocess.CalledProcessError, FileNotFoundError):
@@ -30,26 +26,22 @@ class Repository:
 
     def fetch(self) -> None:
         """Fetch latest updates from the remote."""
-        subprocess.run(["git", "fetch"], cwd=self.path, check=True)  # noqa: S607
+        subprocess.run(["git", "fetch"], cwd=self.path, check=True)
 
     def status(self) -> str:
         """Get the git status in porcelain format."""
         return subprocess.check_output(
-            ["git", "status", "--branch", "--porcelain"],  # noqa: S607
+            ["git", "status", "--branch", "--porcelain"],
             cwd=self.path,
             encoding="utf-8",
         ).strip()
 
-    @lru_cache(maxsize=None)  # noqa: B019
+    @lru_cache(maxsize=None)
     def is_git_repo(self) -> bool:
-        """Check if the current directory is a git repository.
-
-        Notes:
-          - TODO: This method is cached to avoid redundant checks, but using lru_cache on methods can lead to memory leaks
-        """
+        """Check if the current directory is a git repository."""
         try:
             subprocess.check_output(
-                ["git", "rev-parse", "--is-inside-work-tree"],  # noqa: S607
+                ["git", "rev-parse", "--is-inside-work-tree"],
                 cwd=self.path,
                 encoding="utf-8",
             )
@@ -72,13 +64,14 @@ class Repository:
         """Return True if the Git repository is fully synced with the remote, False otherwise."""
         if self.has_uncommitted_changes() or self.is_ahead_or_behind():
             return False
-        return True
+        else:
+            return True
 
     def origin_url(self) -> str | None:
         """Get the Git repository's remote URL."""
         try:
             result = subprocess.run(
-                ["git", "remote", "get-url", "origin"],  # noqa: S607
+                ["git", "remote", "get-url", "origin"],
                 cwd=self.path,
                 capture_output=True,
                 text=True,

src/crewai/cli/install_crew.py

@@ -12,8 +12,8 @@ def install_crew(proxy_options: list[str]) -> None:
     Install the crew by running the UV command to lock and install.
     """
     try:
-        command = ["uv", "sync", *proxy_options]
-        subprocess.run(command, check=True, capture_output=False, text=True)  # noqa: S603
+        command = ["uv", "sync"] + proxy_options
+        subprocess.run(command, check=True, capture_output=False, text=True)
 
     except subprocess.CalledProcessError as e:
         click.echo(f"An error occurred while running the crew: {e}", err=True)

src/crewai/cli/plus_api.py

@@ -1,10 +1,11 @@
+from typing import List, Optional
 from urllib.parse import urljoin
 
 import requests
 
 from crewai.cli.config import Settings
-from crewai.cli.constants import DEFAULT_CREWAI_ENTERPRISE_URL
 from crewai.cli.version import get_crewai_version
+from crewai.cli.constants import DEFAULT_CREWAI_ENTERPRISE_URL
 
 
 class PlusAPI:
@@ -55,9 +56,9 @@ class PlusAPI:
         handle: str,
         is_public: bool,
         version: str,
-        description: str | None,
+        description: Optional[str],
         encoded_file: str,
-        available_exports: list[str] | None = None,
+        available_exports: Optional[List[str]] = None,
     ):
         params = {
             "handle": handle,
@@ -166,13 +167,3 @@ class PlusAPI:
             json=payload,
             timeout=30,
         )
-
-    def mark_trace_batch_as_failed(
-        self, trace_batch_id: str, error_message: str
-    ) -> requests.Response:
-        return self._make_request(
-            "PATCH",
-            f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}",
-            json={"status": "failed", "failure_reason": error_message},
-            timeout=30,
-        )

src/crewai/cli/provider.py

@@ -1,10 +1,10 @@
-import json
 import os
+import certifi
+import json
 import time
 from collections import defaultdict
 from pathlib import Path
 
-import certifi
 import click
 import requests
 
@@ -25,7 +25,7 @@ def select_choice(prompt_message, choices):
 
     provider_models = get_provider_data()
     if not provider_models:
-        return None
+        return
     click.secho(prompt_message, fg="cyan")
     for idx, choice in enumerate(choices, start=1):
         click.secho(f"{idx}. {choice}", fg="cyan")
@@ -67,7 +67,7 @@ def select_provider(provider_models):
     all_providers = sorted(set(predefined_providers + list(provider_models.keys())))
 
     provider = select_choice(
-        "Select a provider to set up:", [*predefined_providers, "other"]
+        "Select a provider to set up:", predefined_providers + ["other"]
     )
     if provider is None:  # User typed 'q'
         return None
@@ -102,9 +102,10 @@ def select_model(provider, provider_models):
         click.secho(f"No models available for provider '{provider}'.", fg="red")
         return None
 
-    return select_choice(
+    selected_model = select_choice(
         f"Select a model to use for {provider.capitalize()}:", available_models
     )
+    return selected_model
 
 
 def load_provider_data(cache_file, cache_expiry):
@@ -164,7 +165,7 @@ def fetch_provider_data(cache_file):
     Returns:
     - dict or None: The fetched provider data or None if the operation fails.
     """
-    ssl_config = os.environ["SSL_CERT_FILE"] = certifi.where()
+    ssl_config = os.environ['SSL_CERT_FILE'] = certifi.where()
 
     try:
         response = requests.get(JSON_URL, stream=True, timeout=60, verify=ssl_config)

src/crewai/cli/run_crew.py

@@ -1,5 +1,6 @@
 import subprocess
 from enum import Enum
+from typing import List, Optional
 
 import click
 from packaging import version
@@ -56,7 +57,7 @@ def execute_command(crew_type: CrewType) -> None:
     command = ["uv", "run", "kickoff" if crew_type == CrewType.FLOW else "run_crew"]
 
     try:
-        subprocess.run(command, capture_output=False, text=True, check=True)  # noqa: S603
+        subprocess.run(command, capture_output=False, text=True, check=True)
 
     except subprocess.CalledProcessError as e:
         handle_error(e, crew_type)

src/crewai/cli/shared/token_manager.py

@@ -3,7 +3,7 @@ import os
 import sys
 from datetime import datetime
 from pathlib import Path
-
+from typing import Optional
 from cryptography.fernet import Fernet
 
 
@@ -49,7 +49,7 @@ class TokenManager:
         encrypted_data = self.fernet.encrypt(json.dumps(data).encode())
         self.save_secure_file(self.file_path, encrypted_data)
 
-    def get_token(self) -> str | None:
+    def get_token(self) -> Optional[str]:
         """
         Get the access token if it is valid and not expired.
 
@@ -113,7 +113,7 @@ class TokenManager:
         # Set appropriate permissions (read/write for owner only)
         os.chmod(file_path, 0o600)
 
-    def read_secure_file(self, filename: str) -> bytes | None:
+    def read_secure_file(self, filename: str) -> Optional[bytes]:
         """
         Read the content of a secure file.
 

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.201.1,<1.0.0"
+    "crewai[tools]>=0.177.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.201.1,<1.0.0",
+    "crewai[tools]>=0.177.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.201.1"
+    "crewai[tools]>=0.177.0"
 ]
 
 [tool.crewai]

src/crewai/cli/tools/main.py

@@ -12,7 +12,6 @@ from crewai.cli import git
 from crewai.cli.command import BaseCommand, PlusAPIMixin
 from crewai.cli.config import Settings
 from crewai.cli.utils import (
-    build_env_with_tool_repository_credentials,
     extract_available_exports,
     get_project_description,
     get_project_name,
@@ -43,7 +42,8 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
         if project_root.exists():
             click.secho(f"Folder {folder_name} already exists.", fg="red")
             raise SystemExit
-        os.makedirs(project_root)
+        else:
+            os.makedirs(project_root)
 
         click.secho(f"Creating custom tool {folder_name}...", fg="green", bold=True)
 
@@ -56,7 +56,7 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
         os.chdir(project_root)
         try:
             self.login()
-            subprocess.run(["git", "init"], check=True)  # noqa: S607
+            subprocess.run(["git", "init"], check=True)
             console.print(
                 f"[green]Created custom tool [bold]{folder_name}[/bold]. Run [bold]cd {project_root}[/bold] to start working.[/green]"
             )
@@ -76,10 +76,10 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
             raise SystemExit()
 
         project_name = get_project_name(require=True)
-        assert isinstance(project_name, str)  # noqa: S101
+        assert isinstance(project_name, str)
 
         project_version = get_project_version(require=True)
-        assert isinstance(project_version, str)  # noqa: S101
+        assert isinstance(project_version, str)
 
         project_description = get_project_description(require=False)
         encoded_tarball = None
@@ -94,8 +94,8 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
         self._print_current_organization()
 
         with tempfile.TemporaryDirectory() as temp_build_dir:
-            subprocess.run(  # noqa: S603
-                ["uv", "build", "--sdist", "--out-dir", temp_build_dir],  # noqa: S607
+            subprocess.run(
+                ["uv", "build", "--sdist", "--out-dir", temp_build_dir],
                 check=True,
                 capture_output=False,
             )
@@ -146,7 +146,7 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
                 style="bold red",
             )
             raise SystemExit
-        if get_response.status_code != 200:
+        elif get_response.status_code != 200:
             console.print(
                 "Failed to get tool details. Please try again later.", style="bold red"
             )
@@ -196,10 +196,10 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
         else:
             add_package_command.extend(["--index", index, tool_handle])
 
-        add_package_result = subprocess.run(  # noqa: S603
+        add_package_result = subprocess.run(
             add_package_command,
             capture_output=False,
-            env=build_env_with_tool_repository_credentials(repository_handle),
+            env=self._build_env_with_credentials(repository_handle),
             text=True,
             check=True,
         )
@@ -221,6 +221,20 @@ class ToolCommand(BaseCommand, PlusAPIMixin):
             )
             raise SystemExit
 
+    def _build_env_with_credentials(self, repository_handle: str):
+        repository_handle = repository_handle.upper().replace("-", "_")
+        settings = Settings()
+
+        env = os.environ.copy()
+        env[f"UV_INDEX_{repository_handle}_USERNAME"] = str(
+            settings.tool_repository_username or ""
+        )
+        env[f"UV_INDEX_{repository_handle}_PASSWORD"] = str(
+            settings.tool_repository_password or ""
+        )
+
+        return env
+
     def _print_current_organization(self) -> None:
         settings = Settings()
         if settings.org_uuid:

src/crewai/cli/utils.py

@@ -5,13 +5,12 @@ import sys
 from functools import reduce
 from inspect import getmro, isclass, isfunction, ismethod
 from pathlib import Path
-from typing import Any, get_type_hints
+from typing import Any, Dict, List, get_type_hints
 
 import click
 import tomli
 from rich.console import Console
 
-from crewai.cli.config import Settings
 from crewai.cli.constants import ENV_VARS
 from crewai.crew import Crew
 from crewai.flow import Flow
@@ -42,7 +41,8 @@ def copy_template(src, dst, name, class_name, folder_name):
 def read_toml(file_path: str = "pyproject.toml"):
     """Read the content of a TOML file and return it as a dictionary."""
     with open(file_path, "rb") as f:
-        return tomli.load(f)
+        toml_dict = tomli.load(f)
+    return toml_dict
 
 
 def parse_toml(content):
@@ -77,7 +77,7 @@ def get_project_description(
 
 
 def _get_project_attribute(
-    pyproject_path: str, keys: list[str], require: bool
+    pyproject_path: str, keys: List[str], require: bool
 ) -> Any | None:
     """Get an attribute from the pyproject.toml file."""
     attribute = None
@@ -96,20 +96,16 @@ def _get_project_attribute(
     except FileNotFoundError:
         console.print(f"Error: {pyproject_path} not found.", style="bold red")
     except KeyError:
+        console.print(f"Error: {pyproject_path} is not a valid pyproject.toml file.", style="bold red")
+    except tomllib.TOMLDecodeError if sys.version_info >= (3, 11) else Exception as e:  # type: ignore
         console.print(
-            f"Error: {pyproject_path} is not a valid pyproject.toml file.",
+            f"Error: {pyproject_path} is not a valid TOML file."
+            if sys.version_info >= (3, 11)
+            else f"Error reading the pyproject.toml file: {e}",
             style="bold red",
         )
     except Exception as e:
-        # Handle TOML decode errors for Python 3.11+
-        if sys.version_info >= (3, 11) and isinstance(e, tomllib.TOMLDecodeError):  # type: ignore
-            console.print(
-                f"Error: {pyproject_path} is not a valid TOML file.", style="bold red"
-            )
-        else:
-            console.print(
-                f"Error reading the pyproject.toml file: {e}", style="bold red"
-            )
+        console.print(f"Error reading the pyproject.toml file: {e}", style="bold red")
 
     if require and not attribute:
         console.print(
@@ -121,7 +117,7 @@ def _get_project_attribute(
     return attribute
 
 
-def _get_nested_value(data: dict[str, Any], keys: list[str]) -> Any:
+def _get_nested_value(data: Dict[str, Any], keys: List[str]) -> Any:
     return reduce(dict.__getitem__, keys, data)
 
 
@@ -300,10 +296,7 @@ def get_crews(crew_path: str = "crew.py", require: bool = False) -> list[Crew]:
                                 try:
                                     crew_instances.extend(fetch_crews(module_attr))
                                 except Exception as e:
-                                    console.print(
-                                        f"Error processing attribute {attr_name}: {e}",
-                                        style="bold red",
-                                    )
+                                    console.print(f"Error processing attribute {attr_name}: {e}", style="bold red")
                                     continue
 
                             # If we found crew instances, break out of the loop
@@ -311,15 +304,12 @@ def get_crews(crew_path: str = "crew.py", require: bool = False) -> list[Crew]:
                                 break
 
                         except Exception as exec_error:
-                            console.print(
-                                f"Error executing module: {exec_error}",
-                                style="bold red",
-                            )
+                            console.print(f"Error executing module: {exec_error}", style="bold red")
 
                     except (ImportError, AttributeError) as e:
                         if require:
                             console.print(
-                                f"Error importing crew from {crew_path}: {e!s}",
+                                f"Error importing crew from {crew_path}: {str(e)}",
                                 style="bold red",
                             )
                         continue
@@ -335,9 +325,9 @@ def get_crews(crew_path: str = "crew.py", require: bool = False) -> list[Crew]:
     except Exception as e:
         if require:
             console.print(
-                f"Unexpected error while loading crew: {e!s}", style="bold red"
+                f"Unexpected error while loading crew: {str(e)}", style="bold red"
             )
-            raise SystemExit from e
+            raise SystemExit
     return crew_instances
 
 
@@ -358,7 +348,8 @@ def get_crew_instance(module_attr) -> Crew | None:
 
     if isinstance(module_attr, Crew):
         return module_attr
-    return None
+    else:
+        return None
 
 
 def fetch_crews(module_attr) -> list[Crew]:
@@ -411,26 +402,11 @@ def extract_available_exports(dir_path: str = "src"):
         return available_exports
 
     except Exception as e:
-        console.print(f"[red]Error: Could not extract tool classes: {e!s}[/red]")
+        console.print(f"[red]Error: Could not extract tool classes: {str(e)}[/red]")
         console.print(
             "Please ensure your project contains valid tools (classes inheriting from BaseTool or functions with @tool decorator)."
         )
-        raise SystemExit(1) from e
-
-
-def build_env_with_tool_repository_credentials(repository_handle: str):
-    repository_handle = repository_handle.upper().replace("-", "_")
-    settings = Settings()
-
-    env = os.environ.copy()
-    env[f"UV_INDEX_{repository_handle}_USERNAME"] = str(
-        settings.tool_repository_username or ""
-    )
-    env[f"UV_INDEX_{repository_handle}_PASSWORD"] = str(
-        settings.tool_repository_password or ""
-    )
-
-    return env
+        raise SystemExit(1)
 
 
 def _load_tools_from_init(init_file: Path) -> list[dict[str, Any]]:
@@ -464,8 +440,8 @@ def _load_tools_from_init(init_file: Path) -> list[dict[str, Any]]:
         ]
 
     except Exception as e:
-        console.print(f"[red]Warning: Could not load {init_file}: {e!s}[/red]")
-        raise SystemExit(1) from e
+        console.print(f"[red]Warning: Could not load {init_file}: {str(e)}[/red]")
+        raise SystemExit(1)
 
     finally:
         sys.modules.pop("temp_module", None)

src/crewai/context.py

@@ -1,25 +0,0 @@
-import os
-import contextvars
-from typing import Optional
-from contextlib import contextmanager
-
-_platform_integration_token: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
-    "platform_integration_token", default=None
-)
-
-def set_platform_integration_token(integration_token: str) -> None:
-    _platform_integration_token.set(integration_token)
-
-def get_platform_integration_token() -> Optional[str]:
-    token = _platform_integration_token.get()
-    if token is None:
-        token = os.getenv("CREWAI_PLATFORM_INTEGRATION_TOKEN")
-    return token
-
-@contextmanager
-def platform_context(integration_token: str):
-    token = _platform_integration_token.set(integration_token)
-    try:
-        yield
-    finally:
-        _platform_integration_token.reset(token)

src/crewai/crew.py

@@ -3,17 +3,26 @@ import json
 import re
 import uuid
 import warnings
-from collections.abc import Callable
 from concurrent.futures import Future
 from copy import copy as shallow_copy
 from hashlib import md5
 from typing import (
     Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
     cast,
 )
 
 from opentelemetry import baggage
 from opentelemetry.context import attach, detach
+
+from crewai.utilities.crew.models import CrewContext
+
 from pydantic import (
     UUID4,
     BaseModel,
@@ -30,15 +39,26 @@ from crewai.agent import Agent
 from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.agents.cache import CacheHandler
 from crewai.crews.crew_output import CrewOutput
-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.events.listeners.tracing.utils import (
-    is_tracing_enabled,
-    should_auto_collect_first_time_traces,
-)
+from crewai.flow.flow_trackable import FlowTrackable
+from crewai.knowledge.knowledge import Knowledge
+from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
+from crewai.llm import LLM, BaseLLM
+from crewai.memory.entity.entity_memory import EntityMemory
+from crewai.memory.external.external_memory import ExternalMemory
+from crewai.memory.long_term.long_term_memory import LongTermMemory
+from crewai.memory.short_term.short_term_memory import ShortTermMemory
+from crewai.process import Process
+from crewai.security import Fingerprint, SecurityConfig
+from crewai.task import Task
+from crewai.tasks.conditional_task import ConditionalTask
+from crewai.tasks.task_output import TaskOutput
+from crewai.tools.agent_tools.agent_tools import AgentTools
+from crewai.tools.base_tool import BaseTool, Tool
+from crewai.types.usage_metrics import UsageMetrics
+from crewai.utilities import I18N, FileHandler, Logger, RPMController
+from crewai.utilities.constants import NOT_SPECIFIED, TRAINING_DATA_FILE
+from crewai.utilities.evaluators.crew_evaluator_handler import CrewEvaluator
+from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
 from crewai.events.types.crew_events import (
     CrewKickoffCompletedEvent,
     CrewKickoffFailedEvent,
@@ -50,29 +70,16 @@ from crewai.events.types.crew_events import (
     CrewTrainFailedEvent,
     CrewTrainStartedEvent,
 )
-from crewai.flow.flow_trackable import FlowTrackable
-from crewai.knowledge.knowledge import Knowledge
-from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
-from crewai.llm import LLM, BaseLLM
-from crewai.memory.entity.entity_memory import EntityMemory
-from crewai.memory.external.external_memory import ExternalMemory
-from crewai.memory.long_term.long_term_memory import LongTermMemory
-from crewai.memory.short_term.short_term_memory import ShortTermMemory
-from crewai.process import Process
-from crewai.rag.embeddings.types import EmbedderConfig
-from crewai.rag.types import SearchResult
-from crewai.security import Fingerprint, SecurityConfig
-from crewai.task import Task
-from crewai.tasks.conditional_task import ConditionalTask
-from crewai.tasks.task_output import TaskOutput
-from crewai.tools.agent_tools.agent_tools import AgentTools
-from crewai.tools.base_tool import BaseTool, Tool
-from crewai.types.usage_metrics import UsageMetrics
-from crewai.utilities import I18N, FileHandler, Logger, RPMController
-from crewai.utilities.constants import NOT_SPECIFIED, TRAINING_DATA_FILE
-from crewai.utilities.crew.models import CrewContext
-from crewai.utilities.evaluators.crew_evaluator_handler import CrewEvaluator
-from crewai.utilities.evaluators.task_evaluator import TaskEvaluator
+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.events.listeners.tracing.utils import (
+    is_tracing_enabled,
+)
 from crewai.utilities.formatter import (
     aggregate_raw_outputs_from_task_outputs,
     aggregate_raw_outputs_from_tasks,
@@ -87,40 +94,28 @@ warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
 
 class Crew(FlowTrackable, BaseModel):
     """
-    Represents a group of agents, defining how they should collaborate and the
-    tasks they should perform.
+    Represents a group of agents, defining how they should collaborate and the tasks they should perform.
 
     Attributes:
-        tasks: list of tasks assigned to the crew.
-        agents: list of agents part of this crew.
+        tasks: List of tasks assigned to the crew.
+        agents: List of agents part of this crew.
         manager_llm: The language model that will run manager agent.
         manager_agent: Custom agent that will be used as manager.
-        memory: Whether the crew should use memory to store memories of it's
-            execution.
-        cache: Whether the crew should use a cache to store the results of the
-            tools execution.
-        function_calling_llm: The language model that will run the tool calling
-            for all the agents.
-        process: The process flow that the crew will follow (e.g., sequential,
-            hierarchical).
+        memory: Whether the crew should use memory to store memories of it's execution.
+        cache: Whether the crew should use a cache to store the results of the tools execution.
+        function_calling_llm: The language model that will run the tool calling for all the agents.
+        process: The process flow that the crew will follow (e.g., sequential, hierarchical).
         verbose: Indicates the verbosity level for logging during execution.
         config: Configuration settings for the crew.
-        max_rpm: Maximum number of requests per minute for the crew execution to
-            be respected.
+        max_rpm: Maximum number of requests per minute for the crew execution to be respected.
         prompt_file: Path to the prompt json file to be used for the crew.
         id: A unique identifier for the crew instance.
-        task_callback: Callback to be executed after each task for every agents
-            execution.
-        step_callback: Callback to be executed after each step for every agents
-            execution.
-        share_crew: Whether you want to share the complete crew information and
-            execution with crewAI to make the library better, and allow us to
-            train models.
+        task_callback: Callback to be executed after each task for every agents execution.
+        step_callback: Callback to be executed after each step for every agents execution.
+        share_crew: Whether you want to share the complete crew information and execution with crewAI to make the library better, and allow us to train models.
         planning: Plan the crew execution and add the plan to the crew.
-        chat_llm: The language model used for orchestrating chat interactions
-            with the crew.
-        security_config: Security configuration for the crew, including
-            fingerprinting.
+        chat_llm: The language model used for orchestrating chat interactions with the crew.
+        security_config: Security configuration for the crew, including fingerprinting.
     """
 
     __hash__ = object.__hash__  # type: ignore
@@ -129,13 +124,13 @@ class Crew(FlowTrackable, BaseModel):
     _logger: Logger = PrivateAttr()
     _file_handler: FileHandler = PrivateAttr()
     _cache_handler: InstanceOf[CacheHandler] = PrivateAttr(default=CacheHandler())
-    _short_term_memory: InstanceOf[ShortTermMemory] | None = PrivateAttr()
-    _long_term_memory: InstanceOf[LongTermMemory] | None = PrivateAttr()
-    _entity_memory: InstanceOf[EntityMemory] | None = PrivateAttr()
-    _external_memory: InstanceOf[ExternalMemory] | None = PrivateAttr()
-    _train: bool | None = PrivateAttr(default=False)
-    _train_iteration: int | None = PrivateAttr()
-    _inputs: dict[str, Any] | None = PrivateAttr(default=None)
+    _short_term_memory: Optional[InstanceOf[ShortTermMemory]] = PrivateAttr()
+    _long_term_memory: Optional[InstanceOf[LongTermMemory]] = PrivateAttr()
+    _entity_memory: Optional[InstanceOf[EntityMemory]] = PrivateAttr()
+    _external_memory: Optional[InstanceOf[ExternalMemory]] = PrivateAttr()
+    _train: Optional[bool] = PrivateAttr(default=False)
+    _train_iteration: Optional[int] = PrivateAttr()
+    _inputs: Optional[Dict[str, Any]] = PrivateAttr(default=None)
     _logging_color: str = PrivateAttr(
         default="bold_purple",
     )
@@ -143,121 +138,107 @@ class Crew(FlowTrackable, BaseModel):
         default_factory=TaskOutputStorageHandler
     )
 
-    name: str | None = Field(default="crew")
+    name: Optional[str] = Field(default="crew")
     cache: bool = Field(default=True)
-    tasks: list[Task] = Field(default_factory=list)
-    agents: list[BaseAgent] = Field(default_factory=list)
+    tasks: List[Task] = Field(default_factory=list)
+    agents: List[BaseAgent] = Field(default_factory=list)
     process: Process = Field(default=Process.sequential)
     verbose: bool = Field(default=False)
     memory: bool = Field(
         default=False,
-        description="If crew should use memory to store memories of it's execution",
+        description="Whether the crew should use memory to store memories of it's execution",
     )
-    short_term_memory: InstanceOf[ShortTermMemory] | None = Field(
+    short_term_memory: Optional[InstanceOf[ShortTermMemory]] = Field(
         default=None,
         description="An Instance of the ShortTermMemory to be used by the Crew",
     )
-    long_term_memory: InstanceOf[LongTermMemory] | None = Field(
+    long_term_memory: Optional[InstanceOf[LongTermMemory]] = Field(
         default=None,
         description="An Instance of the LongTermMemory to be used by the Crew",
     )
-    entity_memory: InstanceOf[EntityMemory] | None = Field(
+    entity_memory: Optional[InstanceOf[EntityMemory]] = Field(
         default=None,
         description="An Instance of the EntityMemory to be used by the Crew",
     )
-    external_memory: InstanceOf[ExternalMemory] | None = Field(
+    external_memory: Optional[InstanceOf[ExternalMemory]] = Field(
         default=None,
         description="An Instance of the ExternalMemory to be used by the Crew",
     )
-    embedder: EmbedderConfig | None = Field(
+    embedder: Optional[dict] = Field(
         default=None,
         description="Configuration for the embedder to be used for the crew.",
     )
-    usage_metrics: UsageMetrics | None = Field(
+    usage_metrics: Optional[UsageMetrics] = Field(
         default=None,
         description="Metrics for the LLM usage during all tasks execution.",
     )
-    manager_llm: str | InstanceOf[BaseLLM] | Any | None = Field(
+    manager_llm: Optional[Union[str, InstanceOf[BaseLLM], Any]] = Field(
         description="Language model that will run the agent.", default=None
     )
-    manager_agent: BaseAgent | None = Field(
+    manager_agent: Optional[BaseAgent] = Field(
         description="Custom agent that will be used as manager.", default=None
     )
-    function_calling_llm: str | InstanceOf[LLM] | Any | None = Field(
+    function_calling_llm: Optional[Union[str, InstanceOf[LLM], Any]] = Field(
         description="Language model that will run the agent.", default=None
     )
-    config: Json | dict[str, Any] | None = Field(default=None)
+    config: Optional[Union[Json, Dict[str, Any]]] = Field(default=None)
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
-    share_crew: bool | None = Field(default=False)
-    step_callback: Any | None = Field(
+    share_crew: Optional[bool] = Field(default=False)
+    step_callback: Optional[Any] = Field(
         default=None,
         description="Callback to be executed after each step for all agents execution.",
     )
-    task_callback: Any | None = Field(
+    task_callback: Optional[Any] = Field(
         default=None,
         description="Callback to be executed after each task for all agents execution.",
     )
-    before_kickoff_callbacks: list[
-        Callable[[dict[str, Any] | None], dict[str, Any] | None]
+    before_kickoff_callbacks: List[
+        Callable[[Optional[Dict[str, Any]]], Optional[Dict[str, Any]]]
     ] = Field(
         default_factory=list,
-        description=(
-            "List of callbacks to be executed before crew kickoff. "
-            "It may be used to adjust inputs before the crew is executed."
-        ),
+        description="List of callbacks to be executed before crew kickoff. It may be used to adjust inputs before the crew is executed.",
     )
-    after_kickoff_callbacks: list[Callable[[CrewOutput], CrewOutput]] = Field(
+    after_kickoff_callbacks: List[Callable[[CrewOutput], CrewOutput]] = Field(
         default_factory=list,
-        description=(
-            "List of callbacks to be executed after crew kickoff. "
-            "It may be used to adjust the output of the crew."
-        ),
+        description="List of callbacks to be executed after crew kickoff. It may be used to adjust the output of the crew.",
     )
-    max_rpm: int | None = Field(
+    max_rpm: Optional[int] = Field(
         default=None,
-        description=(
-            "Maximum number of requests per minute for the crew execution "
-            "to be respected."
-        ),
+        description="Maximum number of requests per minute for the crew execution to be respected.",
     )
-    prompt_file: str | None = Field(
+    prompt_file: Optional[str] = Field(
         default=None,
         description="Path to the prompt json file to be used for the crew.",
     )
-    output_log_file: bool | str | None = Field(
+    output_log_file: Optional[Union[bool, str]] = Field(
         default=None,
         description="Path to the log file to be saved",
     )
-    planning: bool | None = Field(
+    planning: Optional[bool] = Field(
         default=False,
         description="Plan the crew execution and add the plan to the crew.",
     )
-    planning_llm: str | InstanceOf[BaseLLM] | Any | None = Field(
+    planning_llm: Optional[Union[str, InstanceOf[BaseLLM], Any]] = Field(
         default=None,
-        description=(
-            "Language model that will run the AgentPlanner if planning is True."
-        ),
+        description="Language model that will run the AgentPlanner if planning is True.",
     )
-    task_execution_output_json_files: list[str] | None = Field(
+    task_execution_output_json_files: Optional[List[str]] = Field(
         default=None,
-        description="list of file paths for task execution JSON files.",
+        description="List of file paths for task execution JSON files.",
     )
-    execution_logs: list[dict[str, Any]] = Field(
+    execution_logs: List[Dict[str, Any]] = Field(
         default=[],
-        description="list of execution logs for tasks",
+        description="List of execution logs for tasks",
     )
-    knowledge_sources: list[BaseKnowledgeSource] | None = Field(
+    knowledge_sources: Optional[List[BaseKnowledgeSource]] = Field(
         default=None,
-        description=(
-            "Knowledge sources for the crew. Add knowledge sources to the "
-            "knowledge object."
-        ),
+        description="Knowledge sources for the crew. Add knowledge sources to the knowledge object.",
     )
-    chat_llm: str | InstanceOf[BaseLLM] | Any | None = Field(
+    chat_llm: Optional[Union[str, InstanceOf[BaseLLM], Any]] = Field(
         default=None,
         description="LLM used to handle chatting with the crew.",
     )
-    knowledge: Knowledge | None = Field(
+    knowledge: Optional[Knowledge] = Field(
         default=None,
         description="Knowledge for the crew.",
     )
@@ -265,18 +246,18 @@ class Crew(FlowTrackable, BaseModel):
         default_factory=SecurityConfig,
         description="Security configuration for the crew, including fingerprinting.",
     )
-    token_usage: UsageMetrics | None = Field(
+    token_usage: Optional[UsageMetrics] = Field(
         default=None,
         description="Metrics for the LLM usage during all tasks execution.",
     )
-    tracing: bool | None = Field(
+    tracing: Optional[bool] = Field(
         default=False,
         description="Whether to enable tracing for the crew.",
     )
 
     @field_validator("id", mode="before")
     @classmethod
-    def _deny_user_set_id(cls, v: UUID4 | None) -> None:
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
         """Prevent manual setting of the 'id' field by users."""
         if v:
             raise PydanticCustomError(
@@ -285,7 +266,9 @@ class Crew(FlowTrackable, BaseModel):
 
     @field_validator("config", mode="before")
     @classmethod
-    def check_config_type(cls, v: Json | dict[str, Any]) -> Json | dict[str, Any]:
+    def check_config_type(
+        cls, v: Union[Json, Dict[str, Any]]
+    ) -> Union[Json, Dict[str, Any]]:
         """Validates that the config is a valid type.
         Args:
             v: The config to be validated.
@@ -298,16 +281,12 @@ class Crew(FlowTrackable, BaseModel):
 
     @model_validator(mode="after")
     def set_private_attrs(self) -> "Crew":
-        """set private attributes."""
+        """Set private attributes."""
 
         self._cache_handler = CacheHandler()
         event_listener = EventListener()
 
-        if (
-            is_tracing_enabled()
-            or self.tracing
-            or should_auto_collect_first_time_traces()
-        ):
+        if is_tracing_enabled() or self.tracing:
             trace_listener = TraceCollectionListener()
             trace_listener.setup_listeners(crewai_event_bus)
         event_listener.verbose = self.verbose
@@ -335,8 +314,7 @@ class Crew(FlowTrackable, BaseModel):
     def create_crew_memory(self) -> "Crew":
         """Initialize private memory attributes."""
         self._external_memory = (
-            # External memory does not support a default value since it was
-            # designed to be managed entirely externally
+            # External memory doesn’t support a default value since it was designed to be managed entirely externally
             self.external_memory.set_crew(self) if self.external_memory else None
         )
 
@@ -377,10 +355,7 @@ class Crew(FlowTrackable, BaseModel):
             if not self.manager_llm and not self.manager_agent:
                 raise PydanticCustomError(
                     "missing_manager_llm_or_manager_agent",
-                    (
-                        "Attribute `manager_llm` or `manager_agent` is required "
-                        "when using hierarchical process."
-                    ),
+                    "Attribute `manager_llm` or `manager_agent` is required when using hierarchical process.",
                     {},
                 )
 
@@ -423,10 +398,7 @@ class Crew(FlowTrackable, BaseModel):
                 if task.agent is None:
                     raise PydanticCustomError(
                         "missing_agent_in_task",
-                        (
-                            f"Sequential process error: Agent is missing in the task "
-                            f"with the following description: {task.description}"
-                        ),  # type: ignore # Dynamic string in error message
+                        f"Sequential process error: Agent is missing in the task with the following description: {task.description}",  # type: ignore # Argument of type "str" cannot be assigned to parameter "message_template" of type "LiteralString"
                         {},
                     )
 
@@ -487,10 +459,7 @@ class Crew(FlowTrackable, BaseModel):
             if task.async_execution and isinstance(task, ConditionalTask):
                 raise PydanticCustomError(
                     "invalid_async_conditional_task",
-                    (
-                        f"Conditional Task: {task.description}, "
-                        f"cannot be executed asynchronously."
-                    ),
+                    f"Conditional Task: {task.description} , cannot be executed asynchronously.",  # type: ignore # Argument of type "str" cannot be assigned to parameter "message_template" of type "LiteralString"
                     {},
                 )
         return self
@@ -509,9 +478,7 @@ class Crew(FlowTrackable, BaseModel):
                         for j in range(i - 1, -1, -1):
                             if self.tasks[j] == context_task:
                                 raise ValueError(
-                                    f"Task '{task.description}' is asynchronous and "
-                                    f"cannot include other sequential asynchronous "
-                                    f"tasks in its context."
+                                    f"Task '{task.description}' is asynchronous and cannot include other sequential asynchronous tasks in its context."
                                 )
                             if not self.tasks[j].async_execution:
                                 break
@@ -529,15 +496,13 @@ class Crew(FlowTrackable, BaseModel):
                         continue  # Skip context tasks not in the main tasks list
                     if task_indices[id(context_task)] > task_indices[id(task)]:
                         raise ValueError(
-                            f"Task '{task.description}' has a context dependency "
-                            f"on a future task '{context_task.description}', "
-                            f"which is not allowed."
+                            f"Task '{task.description}' has a context dependency on a future task '{context_task.description}', which is not allowed."
                         )
         return self
 
     @property
     def key(self) -> str:
-        source: list[str] = [agent.key for agent in self.agents] + [
+        source: List[str] = [agent.key for agent in self.agents] + [
             task.key for task in self.tasks
         ]
         return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
@@ -553,9 +518,9 @@ class Crew(FlowTrackable, BaseModel):
         return self.security_config.fingerprint
 
     def _setup_from_config(self):
+        assert self.config is not None, "Config should not be None."
+
         """Initializes agents and tasks from the provided config."""
-        if self.config is None:
-            raise ValueError("Config should not be None.")
         if not self.config.get("agents") or not self.config.get("tasks"):
             raise PydanticCustomError(
                 "missing_keys_in_config", "Config should have 'agents' and 'tasks'.", {}
@@ -565,7 +530,7 @@ class Crew(FlowTrackable, BaseModel):
         self.agents = [Agent(**agent) for agent in self.config["agents"]]
         self.tasks = [self._create_task(task) for task in self.config["tasks"]]
 
-    def _create_task(self, task_config: dict[str, Any]) -> Task:
+    def _create_task(self, task_config: Dict[str, Any]) -> Task:
         """Creates a task instance from its configuration.
 
         Args:
@@ -594,7 +559,7 @@ class Crew(FlowTrackable, BaseModel):
         CrewTrainingHandler(filename).initialize_file()
 
     def train(
-        self, n_iterations: int, filename: str, inputs: dict[str, Any] | None = None
+        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 {}
@@ -623,8 +588,7 @@ class Crew(FlowTrackable, BaseModel):
                         training_data=training_data, agent_id=str(agent.id)
                     )
                     CrewTrainingHandler(filename).save_trained_data(
-                        agent_id=str(agent.role),
-                        trained_data=result.model_dump(),  # type: ignore[arg-type]
+                        agent_id=str(agent.role), trained_data=result.model_dump()
                     )
 
             crewai_event_bus.emit(
@@ -647,7 +611,7 @@ class Crew(FlowTrackable, BaseModel):
 
     def kickoff(
         self,
-        inputs: dict[str, Any] | None = None,
+        inputs: Optional[Dict[str, Any]] = None,
     ) -> CrewOutput:
         ctx = baggage.set_baggage(
             "crew_context", CrewContext(id=str(self.id), key=self.key)
@@ -718,9 +682,9 @@ class Crew(FlowTrackable, BaseModel):
         finally:
             detach(token)
 
-    def kickoff_for_each(self, inputs: list[dict[str, Any]]) -> list[CrewOutput]:
-        """Executes the Crew's workflow for each input and aggregates results."""
-        results: list[CrewOutput] = []
+    def kickoff_for_each(self, inputs: List[Dict[str, Any]]) -> List[CrewOutput]:
+        """Executes the Crew's workflow for each input in the list and aggregates results."""
+        results: List[CrewOutput] = []
 
         # Initialize the parent crew's usage metrics
         total_usage_metrics = UsageMetrics()
@@ -739,12 +703,14 @@ class Crew(FlowTrackable, BaseModel):
         self._task_output_handler.reset()
         return results
 
-    async def kickoff_async(self, inputs: dict[str, Any] | None = None) -> 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]:
+    async def kickoff_for_each_async(self, inputs: List[Dict]) -> List[CrewOutput]:
         crew_copies = [self.copy() for _ in inputs]
 
         async def run_crew(crew, input_data):
@@ -773,9 +739,7 @@ class Crew(FlowTrackable, BaseModel):
             tasks=self.tasks, planning_agent_llm=self.planning_llm
         )._handle_crew_planning()
 
-        for task, step_plan in zip(
-            self.tasks, result.list_of_plans_per_task, strict=False
-        ):
+        for task, step_plan in zip(self.tasks, result.list_of_plans_per_task):
             task.description += step_plan.plan
 
     def _store_execution_log(
@@ -812,7 +776,7 @@ class Crew(FlowTrackable, BaseModel):
         return self._execute_tasks(self.tasks)
 
     def _run_hierarchical_process(self) -> CrewOutput:
-        """Creates and assigns a manager agent to complete the tasks."""
+        """Creates and assigns a manager agent to make sure the crew completes the tasks."""
         self._create_manager_agent()
         return self._execute_tasks(self.tasks)
 
@@ -843,24 +807,23 @@ class Crew(FlowTrackable, BaseModel):
 
     def _execute_tasks(
         self,
-        tasks: list[Task],
-        start_index: int | None = 0,
+        tasks: List[Task],
+        start_index: Optional[int] = 0,
         was_replayed: bool = False,
     ) -> CrewOutput:
         """Executes tasks sequentially and returns the final output.
 
         Args:
             tasks (List[Task]): List of tasks to execute
-            manager (Optional[BaseAgent], optional): Manager agent to use for
-                delegation. Defaults to None.
+            manager (Optional[BaseAgent], optional): Manager agent to use for delegation. Defaults to None.
 
         Returns:
             CrewOutput: Final output of the crew
         """
 
-        task_outputs: list[TaskOutput] = []
-        futures: list[tuple[Task, Future[TaskOutput], int]] = []
-        last_sync_output: TaskOutput | None = None
+        task_outputs: List[TaskOutput] = []
+        futures: List[Tuple[Task, Future[TaskOutput], int]] = []
+        last_sync_output: Optional[TaskOutput] = None
 
         for task_index, task in enumerate(tasks):
             if start_index is not None and task_index < start_index:
@@ -875,9 +838,7 @@ class Crew(FlowTrackable, BaseModel):
             agent_to_use = self._get_agent_to_use(task)
             if agent_to_use is None:
                 raise ValueError(
-                    f"No agent available for task: {task.description}. "
-                    f"Ensure that either the task has an assigned agent "
-                    f"or a manager agent is provided."
+                    f"No agent available for task: {task.description}. Ensure that either the task has an assigned agent or a manager agent is provided."
                 )
 
             # Determine which tools to use - task tools take precedence over agent tools
@@ -886,7 +847,7 @@ class Crew(FlowTrackable, BaseModel):
             tools_for_task = self._prepare_tools(
                 agent_to_use,
                 task,
-                cast(list[Tool] | list[BaseTool], tools_for_task),
+                cast(Union[List[Tool], List[BaseTool]], tools_for_task),
             )
 
             self._log_task_start(task, agent_to_use.role)
@@ -906,7 +867,7 @@ class Crew(FlowTrackable, BaseModel):
                 future = task.execute_async(
                     agent=agent_to_use,
                     context=context,
-                    tools=cast(list[BaseTool], tools_for_task),
+                    tools=cast(List[BaseTool], tools_for_task),
                 )
                 futures.append((task, future, task_index))
             else:
@@ -918,7 +879,7 @@ class Crew(FlowTrackable, BaseModel):
                 task_output = task.execute_sync(
                     agent=agent_to_use,
                     context=context,
-                    tools=cast(list[BaseTool], tools_for_task),
+                    tools=cast(List[BaseTool], tools_for_task),
                 )
                 task_outputs.append(task_output)
                 self._process_task_result(task, task_output)
@@ -932,11 +893,11 @@ class Crew(FlowTrackable, BaseModel):
     def _handle_conditional_task(
         self,
         task: ConditionalTask,
-        task_outputs: list[TaskOutput],
-        futures: list[tuple[Task, Future[TaskOutput], int]],
+        task_outputs: List[TaskOutput],
+        futures: List[Tuple[Task, Future[TaskOutput], int]],
         task_index: int,
         was_replayed: bool,
-    ) -> TaskOutput | None:
+    ) -> Optional[TaskOutput]:
         if futures:
             task_outputs = self._process_async_tasks(futures, was_replayed)
             futures.clear()
@@ -956,8 +917,8 @@ class Crew(FlowTrackable, BaseModel):
         return None
 
     def _prepare_tools(
-        self, agent: BaseAgent, task: Task, tools: list[Tool] | list[BaseTool]
-    ) -> list[BaseTool]:
+        self, agent: BaseAgent, task: Task, tools: Union[List[Tool], List[BaseTool]]
+    ) -> List[BaseTool]:
         # Add delegation tools if agent allows delegation
         if hasattr(agent, "allow_delegation") and getattr(
             agent, "allow_delegation", False
@@ -986,22 +947,22 @@ class Crew(FlowTrackable, BaseModel):
         ):
             tools = self._add_multimodal_tools(agent, tools)
 
-        # Return a List[BaseTool] compatible with Task.execute_sync and execute_async
-        return cast(list[BaseTool], tools)
+        # Return a List[BaseTool] which is compatible with both Task.execute_sync and Task.execute_async
+        return cast(List[BaseTool], tools)
 
-    def _get_agent_to_use(self, task: Task) -> BaseAgent | None:
+    def _get_agent_to_use(self, task: Task) -> Optional[BaseAgent]:
         if self.process == Process.hierarchical:
             return self.manager_agent
         return task.agent
 
     def _merge_tools(
         self,
-        existing_tools: list[Tool] | list[BaseTool],
-        new_tools: list[Tool] | list[BaseTool],
-    ) -> list[BaseTool]:
-        """Merge new tools into existing tools list, avoiding duplicates."""
+        existing_tools: Union[List[Tool], List[BaseTool]],
+        new_tools: Union[List[Tool], List[BaseTool]],
+    ) -> List[BaseTool]:
+        """Merge new tools into existing tools list, avoiding duplicates by tool name."""
         if not new_tools:
-            return cast(list[BaseTool], existing_tools)
+            return cast(List[BaseTool], existing_tools)
 
         # Create mapping of tool names to new tools
         new_tool_map = {tool.name: tool for tool in new_tools}
@@ -1012,41 +973,41 @@ class Crew(FlowTrackable, BaseModel):
         # Add all new tools
         tools.extend(new_tools)
 
-        return cast(list[BaseTool], tools)
+        return cast(List[BaseTool], tools)
 
     def _inject_delegation_tools(
         self,
-        tools: list[Tool] | list[BaseTool],
+        tools: Union[List[Tool], List[BaseTool]],
         task_agent: BaseAgent,
-        agents: list[BaseAgent],
-    ) -> list[BaseTool]:
+        agents: List[BaseAgent],
+    ) -> List[BaseTool]:
         if hasattr(task_agent, "get_delegation_tools"):
             delegation_tools = task_agent.get_delegation_tools(agents)
             # Cast delegation_tools to the expected type for _merge_tools
-            return self._merge_tools(tools, cast(list[BaseTool], delegation_tools))
-        return cast(list[BaseTool], tools)
+            return self._merge_tools(tools, cast(List[BaseTool], delegation_tools))
+        return cast(List[BaseTool], tools)
 
     def _add_multimodal_tools(
-        self, agent: BaseAgent, tools: list[Tool] | list[BaseTool]
-    ) -> list[BaseTool]:
+        self, agent: BaseAgent, tools: Union[List[Tool], List[BaseTool]]
+    ) -> List[BaseTool]:
         if hasattr(agent, "get_multimodal_tools"):
             multimodal_tools = agent.get_multimodal_tools()
             # Cast multimodal_tools to the expected type for _merge_tools
-            return self._merge_tools(tools, cast(list[BaseTool], multimodal_tools))
-        return cast(list[BaseTool], tools)
+            return self._merge_tools(tools, cast(List[BaseTool], multimodal_tools))
+        return cast(List[BaseTool], tools)
 
     def _add_code_execution_tools(
-        self, agent: BaseAgent, tools: list[Tool] | list[BaseTool]
-    ) -> list[BaseTool]:
+        self, agent: BaseAgent, tools: Union[List[Tool], List[BaseTool]]
+    ) -> List[BaseTool]:
         if hasattr(agent, "get_code_execution_tools"):
             code_tools = agent.get_code_execution_tools()
             # Cast code_tools to the expected type for _merge_tools
-            return self._merge_tools(tools, cast(list[BaseTool], code_tools))
-        return cast(list[BaseTool], tools)
+            return self._merge_tools(tools, cast(List[BaseTool], code_tools))
+        return cast(List[BaseTool], tools)
 
     def _add_delegation_tools(
-        self, task: Task, tools: list[Tool] | list[BaseTool]
-    ) -> list[BaseTool]:
+        self, task: Task, tools: Union[List[Tool], List[BaseTool]]
+    ) -> List[BaseTool]:
         agents_for_delegation = [agent for agent in self.agents if agent != task.agent]
         if len(self.agents) > 1 and len(agents_for_delegation) > 0 and task.agent:
             if not tools:
@@ -1054,20 +1015,17 @@ class Crew(FlowTrackable, BaseModel):
             tools = self._inject_delegation_tools(
                 tools, task.agent, agents_for_delegation
             )
-        return cast(list[BaseTool], tools)
+        return cast(List[BaseTool], tools)
 
     def _log_task_start(self, task: Task, role: str = "None"):
         if self.output_log_file:
             self._file_handler.log(
-                task_name=task.name,  # type: ignore[arg-type]
-                task=task.description,
-                agent=role,
-                status="started",
+                task_name=task.name, task=task.description, agent=role, status="started"
             )
 
     def _update_manager_tools(
-        self, task: Task, tools: list[Tool] | list[BaseTool]
-    ) -> list[BaseTool]:
+        self, task: Task, tools: Union[List[Tool], List[BaseTool]]
+    ) -> List[BaseTool]:
         if self.manager_agent:
             if task.agent:
                 tools = self._inject_delegation_tools(tools, task.agent, [task.agent])
@@ -1075,30 +1033,31 @@ class Crew(FlowTrackable, BaseModel):
                 tools = self._inject_delegation_tools(
                     tools, self.manager_agent, self.agents
                 )
-        return cast(list[BaseTool], tools)
+        return cast(List[BaseTool], tools)
 
-    def _get_context(self, task: Task, task_outputs: list[TaskOutput]) -> str:
+    def _get_context(self, task: Task, task_outputs: List[TaskOutput]) -> str:
         if not task.context:
             return ""
 
-        return (
+        context = (
             aggregate_raw_outputs_from_task_outputs(task_outputs)
             if task.context is NOT_SPECIFIED
             else aggregate_raw_outputs_from_tasks(task.context)
         )
+        return context
 
     def _process_task_result(self, task: Task, output: TaskOutput) -> None:
         role = task.agent.role if task.agent is not None else "None"
         if self.output_log_file:
             self._file_handler.log(
-                task_name=task.name,  # type: ignore[arg-type]
+                task_name=task.name,
                 task=task.description,
                 agent=role,
                 status="completed",
                 output=output.raw,
             )
 
-    def _create_crew_output(self, task_outputs: list[TaskOutput]) -> CrewOutput:
+    def _create_crew_output(self, task_outputs: List[TaskOutput]) -> CrewOutput:
         if not task_outputs:
             raise ValueError("No task outputs available to create crew output.")
 
@@ -1129,10 +1088,10 @@ class Crew(FlowTrackable, BaseModel):
 
     def _process_async_tasks(
         self,
-        futures: list[tuple[Task, Future[TaskOutput], int]],
+        futures: List[Tuple[Task, Future[TaskOutput], int]],
         was_replayed: bool = False,
-    ) -> list[TaskOutput]:
-        task_outputs: list[TaskOutput] = []
+    ) -> List[TaskOutput]:
+        task_outputs: List[TaskOutput] = []
         for future_task, future, task_index in futures:
             task_output = future.result()
             task_outputs.append(task_output)
@@ -1142,7 +1101,9 @@ class Crew(FlowTrackable, BaseModel):
             )
         return task_outputs
 
-    def _find_task_index(self, task_id: str, stored_outputs: list[Any]) -> int | None:
+    def _find_task_index(
+        self, task_id: str, stored_outputs: List[Any]
+    ) -> Optional[int]:
         return next(
             (
                 index
@@ -1152,8 +1113,9 @@ class Crew(FlowTrackable, BaseModel):
             None,
         )
 
-    def replay(self, task_id: str, inputs: dict[str, Any] | None = None) -> CrewOutput:
-        """Replay the crew execution from a specific task."""
+    def replay(
+        self, task_id: str, inputs: Optional[Dict[str, Any]] = None
+    ) -> CrewOutput:
         stored_outputs = self._task_output_handler.load()
         if not stored_outputs:
             raise ValueError(f"Task with id {task_id} not found in the crew's tasks.")
@@ -1189,19 +1151,19 @@ class Crew(FlowTrackable, BaseModel):
             self.tasks[i].output = task_output
 
         self._logging_color = "bold_blue"
-        return self._execute_tasks(self.tasks, start_index, True)
+        result = self._execute_tasks(self.tasks, start_index, True)
+        return result
 
     def query_knowledge(
-        self, query: list[str], results_limit: int = 3, score_threshold: float = 0.35
-    ) -> list[SearchResult] | None:
-        """Query the crew's knowledge base for relevant information."""
+        self, query: List[str], results_limit: int = 3, score_threshold: float = 0.35
+    ) -> Union[List[Dict[str, Any]], None]:
         if self.knowledge:
             return self.knowledge.query(
                 query, results_limit=results_limit, score_threshold=score_threshold
             )
         return None
 
-    def fetch_inputs(self) -> set[str]:
+    def fetch_inputs(self) -> Set[str]:
         """
         Gathers placeholders (e.g., {something}) referenced in tasks or agents.
         Scans each task's 'description' + 'expected_output', and each agent's
@@ -1210,11 +1172,11 @@ class Crew(FlowTrackable, BaseModel):
         Returns a set of all discovered placeholder names.
         """
         placeholder_pattern = re.compile(r"\{(.+?)\}")
-        required_inputs: set[str] = set()
+        required_inputs: Set[str] = set()
 
         # Scan tasks for inputs
         for task in self.tasks:
-            # description and expected_output might contain e.g. {topic}, {user_name}
+            # description and expected_output might contain e.g. {topic}, {user_name}, etc.
             text = f"{task.description or ''} {task.expected_output or ''}"
             required_inputs.update(placeholder_pattern.findall(text))
 
@@ -1268,7 +1230,7 @@ class Crew(FlowTrackable, BaseModel):
             cloned_tasks.append(cloned_task)
             task_mapping[task.key] = cloned_task
 
-        for cloned_task, original_task in zip(cloned_tasks, self.tasks, strict=False):
+        for cloned_task, original_task in zip(cloned_tasks, self.tasks):
             if isinstance(original_task.context, list):
                 cloned_context = [
                     task_mapping[context_task.key]
@@ -1294,7 +1256,7 @@ class Crew(FlowTrackable, BaseModel):
         copied_data.pop("agents", None)
         copied_data.pop("tasks", None)
 
-        return Crew(
+        copied_crew = Crew(
             **copied_data,
             agents=cloned_agents,
             tasks=cloned_tasks,
@@ -1304,13 +1266,15 @@ class Crew(FlowTrackable, BaseModel):
             manager_llm=manager_llm,
         )
 
+        return copied_crew
+
     def _set_tasks_callbacks(self) -> None:
         """Sets callback for every task suing task_callback"""
         for task in self.tasks:
             if not task.callback:
                 task.callback = self.task_callback
 
-    def _interpolate_inputs(self, inputs: dict[str, Any]) -> None:
+    def _interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
         """Interpolates the inputs in the tasks and agents."""
         [
             task.interpolate_inputs_and_add_conversation_history(
@@ -1343,13 +1307,10 @@ class Crew(FlowTrackable, BaseModel):
     def test(
         self,
         n_iterations: int,
-        eval_llm: str | InstanceOf[BaseLLM],
-        inputs: dict[str, Any] | None = None,
+        eval_llm: Union[str, InstanceOf[BaseLLM]],
+        inputs: Optional[Dict[str, Any]] = None,
     ) -> None:
-        """Test and evaluate the Crew with the given inputs for n iterations.
-
-        Uses concurrent.futures for concurrent execution.
-        """
+        """Test and evaluate the Crew with the given inputs for n iterations concurrently using concurrent.futures."""
         try:
             # Create LLM instance and ensure it's of type LLM for CrewEvaluator
             llm_instance = create_llm(eval_llm)
@@ -1389,11 +1350,7 @@ class Crew(FlowTrackable, BaseModel):
             raise
 
     def __repr__(self):
-        return (
-            f"Crew(id={self.id}, process={self.process}, "
-            f"number_of_agents={len(self.agents)}, "
-            f"number_of_tasks={len(self.tasks)})"
-        )
+        return f"Crew(id={self.id}, process={self.process}, number_of_agents={len(self.agents)}, number_of_tasks={len(self.tasks)})"
 
     def reset_memories(self, command_type: str) -> None:
         """Reset specific or all memories for the crew.
@@ -1407,7 +1364,7 @@ class Crew(FlowTrackable, BaseModel):
             ValueError: If an invalid command type is provided.
             RuntimeError: If memory reset operation fails.
         """
-        valid_types = frozenset(
+        VALID_TYPES = frozenset(
             [
                 "long",
                 "short",
@@ -1420,10 +1377,9 @@ class Crew(FlowTrackable, BaseModel):
             ]
         )
 
-        if command_type not in valid_types:
+        if command_type not in VALID_TYPES:
             raise ValueError(
-                f"Invalid command type. Must be one of: "
-                f"{', '.join(sorted(valid_types))}"
+                f"Invalid command type. Must be one of: {', '.join(sorted(VALID_TYPES))}"
             )
 
         try:
@@ -1433,7 +1389,7 @@ class Crew(FlowTrackable, BaseModel):
                 self._reset_specific_memory(command_type)
 
         except Exception as e:
-            error_msg = f"Failed to reset {command_type} memory: {e!s}"
+            error_msg = f"Failed to reset {command_type} memory: {str(e)}"
             self._logger.log("error", error_msg)
             raise RuntimeError(error_msg) from e
 
@@ -1441,7 +1397,7 @@ class Crew(FlowTrackable, BaseModel):
         """Reset all available memory systems."""
         memory_systems = self._get_memory_systems()
 
-        for config in memory_systems.values():
+        for memory_type, config in memory_systems.items():
             if (system := config.get("system")) is not None:
                 name = config.get("name")
                 try:
@@ -1449,13 +1405,11 @@ class Crew(FlowTrackable, BaseModel):
                     reset_fn(system)
                     self._logger.log(
                         "info",
-                        f"[Crew ({self.name if self.name else self.id})] "
-                        f"{name} memory has been reset",
+                        f"[Crew ({self.name if self.name else self.id})] {name} memory has been reset",
                     )
                 except Exception as e:
                     raise RuntimeError(
-                        f"[Crew ({self.name if self.name else self.id})] "
-                        f"Failed to reset {name} memory: {e!s}"
+                        f"[Crew ({self.name if self.name else self.id})] Failed to reset {name} memory: {str(e)}"
                     ) from e
 
     def _reset_specific_memory(self, memory_type: str) -> None:
@@ -1480,21 +1434,18 @@ class Crew(FlowTrackable, BaseModel):
             reset_fn(system)
             self._logger.log(
                 "info",
-                f"[Crew ({self.name if self.name else self.id})] "
-                f"{name} memory has been reset",
+                f"[Crew ({self.name if self.name else self.id})] {name} memory has been reset",
             )
         except Exception as e:
             raise RuntimeError(
-                f"[Crew ({self.name if self.name else self.id})] "
-                f"Failed to reset {name} memory: {e!s}"
+                f"[Crew ({self.name if self.name else self.id})] Failed to reset {name} memory: {str(e)}"
             ) from e
 
     def _get_memory_systems(self):
         """Get all available memory systems with their configuration.
 
         Returns:
-            Dict containing all memory systems with their reset functions and
-            display names.
+            Dict containing all memory systems with their reset functions and display names.
         """
 
         def default_reset(memory):
@@ -1555,7 +1506,7 @@ class Crew(FlowTrackable, BaseModel):
             },
         }
 
-    def reset_knowledge(self, knowledges: list[Knowledge]) -> None:
+    def reset_knowledge(self, knowledges: List[Knowledge]) -> None:
         """Reset crew and agent knowledge storage."""
         for ks in knowledges:
             ks.reset()

src/crewai/crews/crew_output.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any
+from typing import Any, Dict, Optional
 
 from pydantic import BaseModel, Field
 
@@ -12,21 +12,19 @@ class CrewOutput(BaseModel):
     """Class that represents the result of a crew."""
 
     raw: str = Field(description="Raw output of crew", default="")
-    pydantic: BaseModel | None = Field(
+    pydantic: Optional[BaseModel] = Field(
         description="Pydantic output of Crew", default=None
     )
-    json_dict: dict[str, Any] | None = Field(
+    json_dict: Optional[Dict[str, Any]] = Field(
         description="JSON dict output of Crew", default=None
     )
     tasks_output: list[TaskOutput] = Field(
         description="Output of each task", default=[]
     )
-    token_usage: UsageMetrics = Field(
-        description="Processed token summary", default_factory=UsageMetrics
-    )
+    token_usage: UsageMetrics = Field(description="Processed token summary", default={})
 
     @property
-    def json(self) -> str | None:  # type: ignore[override]
+    def json(self) -> Optional[str]:
         if self.tasks_output[-1].output_format != OutputFormat.JSON:
             raise ValueError(
                 "No JSON output found in the final task. Please make sure to set the output_json property in the final task in your crew."
@@ -34,7 +32,7 @@ class CrewOutput(BaseModel):
 
         return json.dumps(self.json_dict)
 
-    def to_dict(self) -> dict[str, Any]:
+    def to_dict(self) -> Dict[str, Any]:
         """Convert json_output and pydantic_output to a dictionary."""
         output_dict = {}
         if self.json_dict:
@@ -46,9 +44,10 @@ class CrewOutput(BaseModel):
     def __getitem__(self, key):
         if self.pydantic and hasattr(self.pydantic, key):
             return getattr(self.pydantic, key)
-        if self.json_dict and key in self.json_dict:
+        elif self.json_dict and key in self.json_dict:
             return self.json_dict[key]
-        raise KeyError(f"Key '{key}' not found in CrewOutput.")
+        else:
+            raise KeyError(f"Key '{key}' not found in CrewOutput.")
 
     def __str__(self):
         if self.pydantic:

src/crewai/events/__init__.py

@@ -9,158 +9,48 @@ This module provides the event infrastructure that allows users to:
 
 from crewai.events.base_event_listener import BaseEventListener
 from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.agent_events import (
-    AgentEvaluationCompletedEvent,
-    AgentEvaluationFailedEvent,
-    AgentEvaluationStartedEvent,
-    AgentExecutionCompletedEvent,
-    AgentExecutionErrorEvent,
-    AgentExecutionStartedEvent,
-    LiteAgentExecutionCompletedEvent,
-    LiteAgentExecutionErrorEvent,
-    LiteAgentExecutionStartedEvent,
-)
-from crewai.events.types.crew_events import (
-    CrewKickoffCompletedEvent,
-    CrewKickoffFailedEvent,
-    CrewKickoffStartedEvent,
-    CrewTestCompletedEvent,
-    CrewTestFailedEvent,
-    CrewTestResultEvent,
-    CrewTestStartedEvent,
-    CrewTrainCompletedEvent,
-    CrewTrainFailedEvent,
-    CrewTrainStartedEvent,
-)
-from crewai.events.types.flow_events import (
-    FlowCreatedEvent,
-    FlowEvent,
-    FlowFinishedEvent,
-    FlowPlotEvent,
-    FlowStartedEvent,
-    MethodExecutionFailedEvent,
-    MethodExecutionFinishedEvent,
-    MethodExecutionStartedEvent,
-)
-from crewai.events.types.knowledge_events import (
-    KnowledgeQueryCompletedEvent,
-    KnowledgeQueryFailedEvent,
-    KnowledgeQueryStartedEvent,
-    KnowledgeRetrievalCompletedEvent,
-    KnowledgeRetrievalStartedEvent,
-    KnowledgeSearchQueryFailedEvent,
-)
-from crewai.events.types.llm_events import (
-    LLMCallCompletedEvent,
-    LLMCallFailedEvent,
-    LLMCallStartedEvent,
-    LLMStreamChunkEvent,
-)
-from crewai.events.types.llm_guardrail_events import (
-    LLMGuardrailCompletedEvent,
-    LLMGuardrailStartedEvent,
-)
-from crewai.events.types.logging_events import (
-    AgentLogsExecutionEvent,
-    AgentLogsStartedEvent,
-)
+
 from crewai.events.types.memory_events import (
     MemoryQueryCompletedEvent,
-    MemoryQueryFailedEvent,
+    MemorySaveCompletedEvent,
+    MemorySaveStartedEvent,
     MemoryQueryStartedEvent,
     MemoryRetrievalCompletedEvent,
-    MemoryRetrievalStartedEvent,
-    MemorySaveCompletedEvent,
     MemorySaveFailedEvent,
-    MemorySaveStartedEvent,
+    MemoryQueryFailedEvent,
 )
-from crewai.events.types.reasoning_events import (
-    AgentReasoningCompletedEvent,
-    AgentReasoningFailedEvent,
-    AgentReasoningStartedEvent,
-    ReasoningEvent,
+
+from crewai.events.types.knowledge_events import (
+    KnowledgeRetrievalStartedEvent,
+    KnowledgeRetrievalCompletedEvent,
 )
-from crewai.events.types.task_events import (
-    TaskCompletedEvent,
-    TaskEvaluationEvent,
-    TaskFailedEvent,
-    TaskStartedEvent,
+
+from crewai.events.types.crew_events import (
+    CrewKickoffStartedEvent,
+    CrewKickoffCompletedEvent,
 )
-from crewai.events.types.tool_usage_events import (
-    ToolExecutionErrorEvent,
-    ToolSelectionErrorEvent,
-    ToolUsageErrorEvent,
-    ToolUsageEvent,
-    ToolUsageFinishedEvent,
-    ToolUsageStartedEvent,
-    ToolValidateInputErrorEvent,
+from crewai.events.types.agent_events import (
+    AgentExecutionCompletedEvent,
+)
+
+from crewai.events.types.llm_events import (
+    LLMStreamChunkEvent,
 )
 
 __all__ = [
-    "AgentEvaluationCompletedEvent",
-    "AgentEvaluationFailedEvent",
-    "AgentEvaluationStartedEvent",
-    "AgentExecutionCompletedEvent",
-    "AgentExecutionErrorEvent",
-    "AgentExecutionStartedEvent",
-    "AgentLogsExecutionEvent",
-    "AgentLogsStartedEvent",
-    "AgentReasoningCompletedEvent",
-    "AgentReasoningFailedEvent",
-    "AgentReasoningStartedEvent",
     "BaseEventListener",
-    "CrewKickoffCompletedEvent",
-    "CrewKickoffFailedEvent",
-    "CrewKickoffStartedEvent",
-    "CrewTestCompletedEvent",
-    "CrewTestFailedEvent",
-    "CrewTestResultEvent",
-    "CrewTestStartedEvent",
-    "CrewTrainCompletedEvent",
-    "CrewTrainFailedEvent",
-    "CrewTrainStartedEvent",
-    "FlowCreatedEvent",
-    "FlowEvent",
-    "FlowFinishedEvent",
-    "FlowPlotEvent",
-    "FlowStartedEvent",
-    "KnowledgeQueryCompletedEvent",
-    "KnowledgeQueryFailedEvent",
-    "KnowledgeQueryStartedEvent",
-    "KnowledgeRetrievalCompletedEvent",
-    "KnowledgeRetrievalStartedEvent",
-    "KnowledgeSearchQueryFailedEvent",
-    "LLMCallCompletedEvent",
-    "LLMCallFailedEvent",
-    "LLMCallStartedEvent",
-    "LLMGuardrailCompletedEvent",
-    "LLMGuardrailStartedEvent",
-    "LLMStreamChunkEvent",
-    "LiteAgentExecutionCompletedEvent",
-    "LiteAgentExecutionErrorEvent",
-    "LiteAgentExecutionStartedEvent",
+    "crewai_event_bus",
     "MemoryQueryCompletedEvent",
-    "MemoryQueryFailedEvent",
+    "MemorySaveCompletedEvent",
+    "MemorySaveStartedEvent",
     "MemoryQueryStartedEvent",
     "MemoryRetrievalCompletedEvent",
-    "MemoryRetrievalStartedEvent",
-    "MemorySaveCompletedEvent",
     "MemorySaveFailedEvent",
-    "MemorySaveStartedEvent",
-    "MethodExecutionFailedEvent",
-    "MethodExecutionFinishedEvent",
-    "MethodExecutionStartedEvent",
-    "ReasoningEvent",
-    "TaskCompletedEvent",
-    "TaskEvaluationEvent",
-    "TaskFailedEvent",
-    "TaskStartedEvent",
-    "ToolExecutionErrorEvent",
-    "ToolSelectionErrorEvent",
-    "ToolUsageErrorEvent",
-    "ToolUsageEvent",
-    "ToolUsageFinishedEvent",
-    "ToolUsageStartedEvent",
-    "ToolValidateInputErrorEvent",
-    "crewai_event_bus",
-]
+    "MemoryQueryFailedEvent",
+    "KnowledgeRetrievalStartedEvent",
+    "KnowledgeRetrievalCompletedEvent",
+    "CrewKickoffStartedEvent",
+    "CrewKickoffCompletedEvent",
+    "AgentExecutionCompletedEvent",
+    "LLMStreamChunkEvent",
+]

src/crewai/events/base_events.py

@@ -1,6 +1,5 @@
 from datetime import datetime, timezone
-from typing import Any
-
+from typing import Any, Dict, Optional
 from pydantic import BaseModel, Field
 
 from crewai.utilities.serialization import to_serializable
@@ -11,11 +10,11 @@ class BaseEvent(BaseModel):
 
     timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     type: str
-    source_fingerprint: str | None = None  # UUID string of the source entity
-    source_type: str | None = (
+    source_fingerprint: Optional[str] = None  # UUID string of the source entity
+    source_type: Optional[str] = (
         None  # "agent", "task", "crew", "memory", "entity_memory", "short_term_memory", "long_term_memory", "external_memory"
     )
-    fingerprint_metadata: dict[str, Any] | None = None  # Any relevant metadata
+    fingerprint_metadata: Optional[Dict[str, Any]] = None  # Any relevant metadata
 
     def to_json(self, exclude: set[str] | None = None):
         """
@@ -29,13 +28,13 @@ class BaseEvent(BaseModel):
         """
         return to_serializable(self, exclude=exclude)
 
-    def _set_task_params(self, data: dict[str, Any]):
+    def _set_task_params(self, data: Dict[str, Any]):
         if "from_task" in data and (task := data["from_task"]):
             self.task_id = task.id
             self.task_name = task.name or task.description
             self.from_task = None
 
-    def _set_agent_params(self, data: dict[str, Any]):
+    def _set_agent_params(self, data: Dict[str, Any]):
         task = data.get("from_task", None)
         agent = task.agent if task else data.get("from_agent", None)
 

src/crewai/events/event_bus.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 import threading
-from collections.abc import Callable
 from contextlib import contextmanager
-from typing import Any, TypeVar, cast
+from typing import Any, Callable, Dict, List, Type, TypeVar, cast
 
 from blinker import Signal
 
@@ -26,17 +25,17 @@ class CrewAIEventsBus:
         if cls._instance is None:
             with cls._lock:
                 if cls._instance is None:  # prevent race condition
-                    cls._instance = super().__new__(cls)
+                    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]] = {}
+        self._handlers: Dict[Type[BaseEvent], List[Callable]] = {}
 
     def on(
-        self, event_type: type[EventT]
+        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.
@@ -62,18 +61,6 @@ class CrewAIEventsBus:
 
         return decorator
 
-    @staticmethod
-    def _call_handler(
-        handler: Callable, source: Any, event: BaseEvent, event_type: type
-    ) -> None:
-        """Call a single handler with error handling."""
-        try:
-            handler(source, event)
-        except Exception as e:
-            print(
-                f"[EventBus Error] Handler '{handler.__name__}' failed for event '{event_type.__name__}': {e}"
-            )
-
     def emit(self, source: Any, event: BaseEvent) -> None:
         """
         Emit an event to all registered handlers
@@ -85,12 +72,17 @@ class CrewAIEventsBus:
         for event_type, handlers in self._handlers.items():
             if isinstance(event, event_type):
                 for handler in handlers:
-                    self._call_handler(handler, source, event, event_type)
+                    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]
+        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:

src/crewai/events/event_listener.py

@@ -1,30 +1,15 @@
 from __future__ import annotations
 
 from io import StringIO
-from typing import Any
+from typing import Any, Dict
 
 from pydantic import Field, PrivateAttr
-
+from crewai.llm import LLM
+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.events.base_event_listener import BaseEventListener
-from crewai.events.types.agent_events import (
-    AgentExecutionCompletedEvent,
-    AgentExecutionStartedEvent,
-    LiteAgentExecutionCompletedEvent,
-    LiteAgentExecutionErrorEvent,
-    LiteAgentExecutionStartedEvent,
-)
-from crewai.events.types.crew_events import (
-    CrewKickoffCompletedEvent,
-    CrewKickoffFailedEvent,
-    CrewKickoffStartedEvent,
-    CrewTestCompletedEvent,
-    CrewTestFailedEvent,
-    CrewTestResultEvent,
-    CrewTestStartedEvent,
-    CrewTrainCompletedEvent,
-    CrewTrainFailedEvent,
-    CrewTrainStartedEvent,
-)
 from crewai.events.types.knowledge_events import (
     KnowledgeQueryCompletedEvent,
     KnowledgeQueryFailedEvent,
@@ -40,21 +25,34 @@ from crewai.events.types.llm_events import (
     LLMStreamChunkEvent,
 )
 from crewai.events.types.llm_guardrail_events import (
-    LLMGuardrailCompletedEvent,
     LLMGuardrailStartedEvent,
-)
-from crewai.events.types.logging_events import (
-    AgentLogsExecutionEvent,
-    AgentLogsStartedEvent,
+    LLMGuardrailCompletedEvent,
 )
 from crewai.events.utils.console_formatter import ConsoleFormatter
-from crewai.llm import LLM
-from crewai.task import Task
-from crewai.telemetry.telemetry import Telemetry
-from crewai.utilities import Logger
-from crewai.utilities.constants import EMITTER_COLOR
 
-from .listeners.memory_listener import MemoryListener
+from crewai.events.types.agent_events import (
+    AgentExecutionCompletedEvent,
+    AgentExecutionStartedEvent,
+    LiteAgentExecutionCompletedEvent,
+    LiteAgentExecutionErrorEvent,
+    LiteAgentExecutionStartedEvent,
+)
+from crewai.events.types.logging_events import (
+    AgentLogsStartedEvent,
+    AgentLogsExecutionEvent,
+)
+from crewai.events.types.crew_events import (
+    CrewKickoffCompletedEvent,
+    CrewKickoffFailedEvent,
+    CrewKickoffStartedEvent,
+    CrewTestCompletedEvent,
+    CrewTestFailedEvent,
+    CrewTestResultEvent,
+    CrewTestStartedEvent,
+    CrewTrainCompletedEvent,
+    CrewTrainFailedEvent,
+    CrewTrainStartedEvent,
+)
 from .types.flow_events import (
     FlowCreatedEvent,
     FlowFinishedEvent,
@@ -63,24 +61,26 @@ from .types.flow_events import (
     MethodExecutionFinishedEvent,
     MethodExecutionStartedEvent,
 )
-from .types.reasoning_events import (
-    AgentReasoningCompletedEvent,
-    AgentReasoningFailedEvent,
-    AgentReasoningStartedEvent,
-)
 from .types.task_events import TaskCompletedEvent, TaskFailedEvent, TaskStartedEvent
 from .types.tool_usage_events import (
     ToolUsageErrorEvent,
     ToolUsageFinishedEvent,
     ToolUsageStartedEvent,
 )
+from .types.reasoning_events import (
+    AgentReasoningStartedEvent,
+    AgentReasoningCompletedEvent,
+    AgentReasoningFailedEvent,
+)
+
+from .listeners.memory_listener import MemoryListener
 
 
 class EventListener(BaseEventListener):
     _instance = None
     _telemetry: Telemetry = PrivateAttr(default_factory=lambda: Telemetry())
     logger = Logger(verbose=True, default_color=EMITTER_COLOR)
-    execution_spans: dict[Task, Any] = Field(default_factory=dict)
+    execution_spans: Dict[Task, Any] = Field(default_factory=dict)
     next_chunk = 0
     text_stream = StringIO()
     knowledge_retrieval_in_progress = False

src/crewai/events/event_types.py

@@ -1,10 +1,11 @@
+from typing import Union
+
 from crewai.events.types.agent_events import (
     AgentExecutionCompletedEvent,
     AgentExecutionErrorEvent,
     AgentExecutionStartedEvent,
     LiteAgentExecutionCompletedEvent,
 )
-
 from .types.crew_events import (
     CrewKickoffCompletedEvent,
     CrewKickoffFailedEvent,
@@ -23,14 +24,6 @@ from .types.flow_events import (
     MethodExecutionFinishedEvent,
     MethodExecutionStartedEvent,
 )
-from .types.knowledge_events import (
-    KnowledgeQueryCompletedEvent,
-    KnowledgeQueryFailedEvent,
-    KnowledgeQueryStartedEvent,
-    KnowledgeRetrievalCompletedEvent,
-    KnowledgeRetrievalStartedEvent,
-    KnowledgeSearchQueryFailedEvent,
-)
 from .types.llm_events import (
     LLMCallCompletedEvent,
     LLMCallFailedEvent,
@@ -41,21 +34,6 @@ from .types.llm_guardrail_events import (
     LLMGuardrailCompletedEvent,
     LLMGuardrailStartedEvent,
 )
-from .types.memory_events import (
-    MemoryQueryCompletedEvent,
-    MemoryQueryFailedEvent,
-    MemoryQueryStartedEvent,
-    MemoryRetrievalCompletedEvent,
-    MemoryRetrievalStartedEvent,
-    MemorySaveCompletedEvent,
-    MemorySaveFailedEvent,
-    MemorySaveStartedEvent,
-)
-from .types.reasoning_events import (
-    AgentReasoningCompletedEvent,
-    AgentReasoningFailedEvent,
-    AgentReasoningStartedEvent,
-)
 from .types.task_events import (
     TaskCompletedEvent,
     TaskFailedEvent,
@@ -66,53 +44,77 @@ from .types.tool_usage_events import (
     ToolUsageFinishedEvent,
     ToolUsageStartedEvent,
 )
-
-EventTypes = (
-    CrewKickoffStartedEvent
-    | CrewKickoffCompletedEvent
-    | CrewKickoffFailedEvent
-    | CrewTestStartedEvent
-    | CrewTestCompletedEvent
-    | CrewTestFailedEvent
-    | CrewTrainStartedEvent
-    | CrewTrainCompletedEvent
-    | CrewTrainFailedEvent
-    | AgentExecutionStartedEvent
-    | AgentExecutionCompletedEvent
-    | LiteAgentExecutionCompletedEvent
-    | TaskStartedEvent
-    | TaskCompletedEvent
-    | TaskFailedEvent
-    | FlowStartedEvent
-    | FlowFinishedEvent
-    | MethodExecutionStartedEvent
-    | MethodExecutionFinishedEvent
-    | MethodExecutionFailedEvent
-    | AgentExecutionErrorEvent
-    | ToolUsageFinishedEvent
-    | ToolUsageErrorEvent
-    | ToolUsageStartedEvent
-    | LLMCallStartedEvent
-    | LLMCallCompletedEvent
-    | LLMCallFailedEvent
-    | LLMStreamChunkEvent
-    | LLMGuardrailStartedEvent
-    | LLMGuardrailCompletedEvent
-    | AgentReasoningStartedEvent
-    | AgentReasoningCompletedEvent
-    | AgentReasoningFailedEvent
-    | KnowledgeRetrievalStartedEvent
-    | KnowledgeRetrievalCompletedEvent
-    | KnowledgeQueryStartedEvent
-    | KnowledgeQueryCompletedEvent
-    | KnowledgeQueryFailedEvent
-    | KnowledgeSearchQueryFailedEvent
-    | MemorySaveStartedEvent
-    | MemorySaveCompletedEvent
-    | MemorySaveFailedEvent
-    | MemoryQueryStartedEvent
-    | MemoryQueryCompletedEvent
-    | MemoryQueryFailedEvent
-    | MemoryRetrievalStartedEvent
-    | MemoryRetrievalCompletedEvent
+from .types.reasoning_events import (
+    AgentReasoningStartedEvent,
+    AgentReasoningCompletedEvent,
+    AgentReasoningFailedEvent,
 )
+from .types.knowledge_events import (
+    KnowledgeRetrievalStartedEvent,
+    KnowledgeRetrievalCompletedEvent,
+    KnowledgeQueryStartedEvent,
+    KnowledgeQueryCompletedEvent,
+    KnowledgeQueryFailedEvent,
+    KnowledgeSearchQueryFailedEvent,
+)
+
+from .types.memory_events import (
+    MemorySaveStartedEvent,
+    MemorySaveCompletedEvent,
+    MemorySaveFailedEvent,
+    MemoryQueryStartedEvent,
+    MemoryQueryCompletedEvent,
+    MemoryQueryFailedEvent,
+    MemoryRetrievalStartedEvent,
+    MemoryRetrievalCompletedEvent,
+)
+
+EventTypes = Union[
+    CrewKickoffStartedEvent,
+    CrewKickoffCompletedEvent,
+    CrewKickoffFailedEvent,
+    CrewTestStartedEvent,
+    CrewTestCompletedEvent,
+    CrewTestFailedEvent,
+    CrewTrainStartedEvent,
+    CrewTrainCompletedEvent,
+    CrewTrainFailedEvent,
+    AgentExecutionStartedEvent,
+    AgentExecutionCompletedEvent,
+    LiteAgentExecutionCompletedEvent,
+    TaskStartedEvent,
+    TaskCompletedEvent,
+    TaskFailedEvent,
+    FlowStartedEvent,
+    FlowFinishedEvent,
+    MethodExecutionStartedEvent,
+    MethodExecutionFinishedEvent,
+    MethodExecutionFailedEvent,
+    AgentExecutionErrorEvent,
+    ToolUsageFinishedEvent,
+    ToolUsageErrorEvent,
+    ToolUsageStartedEvent,
+    LLMCallStartedEvent,
+    LLMCallCompletedEvent,
+    LLMCallFailedEvent,
+    LLMStreamChunkEvent,
+    LLMGuardrailStartedEvent,
+    LLMGuardrailCompletedEvent,
+    AgentReasoningStartedEvent,
+    AgentReasoningCompletedEvent,
+    AgentReasoningFailedEvent,
+    KnowledgeRetrievalStartedEvent,
+    KnowledgeRetrievalCompletedEvent,
+    KnowledgeQueryStartedEvent,
+    KnowledgeQueryCompletedEvent,
+    KnowledgeQueryFailedEvent,
+    KnowledgeSearchQueryFailedEvent,
+    MemorySaveStartedEvent,
+    MemorySaveCompletedEvent,
+    MemorySaveFailedEvent,
+    MemoryQueryStartedEvent,
+    MemoryQueryCompletedEvent,
+    MemoryQueryFailedEvent,
+    MemoryRetrievalStartedEvent,
+    MemoryRetrievalCompletedEvent,
+]

src/crewai/events/listeners/__init__.py

@@ -2,4 +2,4 @@
 
 This module contains various event listener implementations
 for handling memory, tracing, and other event-driven functionality.
-"""
+"""

src/crewai/events/listeners/memory_listener.py

@@ -1,12 +1,12 @@
 from crewai.events.base_event_listener import BaseEventListener
 from crewai.events.types.memory_events import (
-    MemoryQueryCompletedEvent,
-    MemoryQueryFailedEvent,
     MemoryRetrievalCompletedEvent,
     MemoryRetrievalStartedEvent,
+    MemoryQueryFailedEvent,
+    MemoryQueryCompletedEvent,
+    MemorySaveStartedEvent,
     MemorySaveCompletedEvent,
     MemorySaveFailedEvent,
-    MemorySaveStartedEvent,
 )
 
 

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

@@ -1,229 +0,0 @@
-import logging
-import uuid
-import webbrowser
-from pathlib import Path
-
-from rich.console import Console
-from rich.panel import Panel
-
-from crewai.events.listeners.tracing.trace_batch_manager import TraceBatchManager
-from crewai.events.listeners.tracing.utils import (
-    mark_first_execution_completed,
-    prompt_user_for_trace_viewing,
-    should_auto_collect_first_time_traces,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def _update_or_create_env_file():
-    """Update or create .env file with CREWAI_TRACING_ENABLED=true."""
-    env_path = Path(".env")
-    env_content = ""
-    variable_name = "CREWAI_TRACING_ENABLED"
-    variable_value = "true"
-
-    # Read existing content if file exists
-    if env_path.exists():
-        with open(env_path, "r") as f:
-            env_content = f.read()
-
-    # Check if CREWAI_TRACING_ENABLED is already set
-    lines = env_content.splitlines()
-    variable_exists = False
-    updated_lines = []
-
-    for line in lines:
-        if line.strip().startswith(f"{variable_name}="):
-            # Update existing variable
-            updated_lines.append(f"{variable_name}={variable_value}")
-            variable_exists = True
-        else:
-            updated_lines.append(line)
-
-    # Add variable if it doesn't exist
-    if not variable_exists:
-        if updated_lines and not updated_lines[-1].strip():
-            # If last line is empty, replace it
-            updated_lines[-1] = f"{variable_name}={variable_value}"
-        else:
-            # Add new line and then the variable
-            updated_lines.append(f"{variable_name}={variable_value}")
-
-    # Write updated content
-    with open(env_path, "w") as f:
-        f.write("\n".join(updated_lines))
-        if updated_lines:  # Add final newline if there's content
-            f.write("\n")
-
-
-class FirstTimeTraceHandler:
-    """Handles the first-time user trace collection and display flow."""
-
-    def __init__(self):
-        self.is_first_time: bool = False
-        self.collected_events: bool = False
-        self.trace_batch_id: str | None = None
-        self.ephemeral_url: str | None = None
-        self.batch_manager: TraceBatchManager | None = None
-
-    def initialize_for_first_time_user(self) -> bool:
-        """Check if this is first time and initialize collection."""
-        self.is_first_time = should_auto_collect_first_time_traces()
-        return self.is_first_time
-
-    def set_batch_manager(self, batch_manager: TraceBatchManager):
-        """Set reference to batch manager for sending events."""
-        self.batch_manager = batch_manager
-
-    def mark_events_collected(self):
-        """Mark that events have been collected during execution."""
-        self.collected_events = True
-
-    def handle_execution_completion(self):
-        """Handle the completion flow as shown in your diagram."""
-        if not self.is_first_time or not self.collected_events:
-            return
-
-        try:
-            user_wants_traces = prompt_user_for_trace_viewing(timeout_seconds=20)
-
-            if user_wants_traces:
-                self._initialize_backend_and_send_events()
-
-                # Enable tracing for future runs by updating .env file
-                try:
-                    _update_or_create_env_file()
-                except Exception:  # noqa: S110
-                    pass
-
-                if self.ephemeral_url:
-                    self._display_ephemeral_trace_link()
-
-            mark_first_execution_completed()
-
-        except Exception as e:
-            self._gracefully_fail(f"Error in trace handling: {e}")
-            mark_first_execution_completed()
-
-    def _initialize_backend_and_send_events(self):
-        """Initialize backend batch and send collected events."""
-        if not self.batch_manager:
-            return
-
-        try:
-            if not self.batch_manager.backend_initialized:
-                original_metadata = (
-                    self.batch_manager.current_batch.execution_metadata
-                    if self.batch_manager.current_batch
-                    else {}
-                )
-
-                user_context = {
-                    "privacy_level": "standard",
-                    "user_id": "first_time_user",
-                    "session_id": str(uuid.uuid4()),
-                    "trace_id": self.batch_manager.trace_batch_id,
-                }
-
-                execution_metadata = {
-                    "execution_type": original_metadata.get("execution_type", "crew"),
-                    "crew_name": original_metadata.get(
-                        "crew_name", "First Time Execution"
-                    ),
-                    "flow_name": original_metadata.get("flow_name"),
-                    "agent_count": original_metadata.get("agent_count", 1),
-                    "task_count": original_metadata.get("task_count", 1),
-                    "crewai_version": original_metadata.get("crewai_version"),
-                }
-
-                self.batch_manager._initialize_backend_batch(
-                    user_context=user_context,
-                    execution_metadata=execution_metadata,
-                    use_ephemeral=True,
-                )
-                self.batch_manager.backend_initialized = True
-
-            if self.batch_manager.event_buffer:
-                self.batch_manager._send_events_to_backend()
-
-            self.batch_manager.finalize_batch()
-            self.ephemeral_url = self.batch_manager.ephemeral_trace_url
-
-            if not self.ephemeral_url:
-                self._show_local_trace_message()
-
-        except Exception as e:
-            self._gracefully_fail(f"Backend initialization failed: {e}")
-
-    def _display_ephemeral_trace_link(self):
-        """Display the ephemeral trace link to the user and automatically open browser."""
-        console = Console()
-
-        try:
-            webbrowser.open(self.ephemeral_url)
-        except Exception:  # noqa: S110
-            pass
-
-        panel_content = f"""
-🎉 Your First CrewAI Execution Trace is Ready!
-
-View your execution details here:
-{self.ephemeral_url}
-
-This trace shows:
-• Agent decisions and interactions
-• Task execution timeline
-• Tool usage and results
-• LLM calls and responses
-
-✅ Tracing has been enabled for future runs! (CREWAI_TRACING_ENABLED=true added to .env)
-You can also add tracing=True to your Crew(tracing=True) / Flow(tracing=True) for more control.
-
-📝 Note: This link will expire in 24 hours.
-        """.strip()
-
-        panel = Panel(
-            panel_content,
-            title="🔍 Execution Trace Generated",
-            border_style="bright_green",
-            padding=(1, 2),
-        )
-
-        console.print("\n")
-        console.print(panel)
-        console.print()
-
-    def _gracefully_fail(self, error_message: str):
-        """Handle errors gracefully without disrupting user experience."""
-        console = Console()
-        console.print(f"[yellow]Note: {error_message}[/yellow]")
-
-        logger.debug(f"First-time trace error: {error_message}")
-
-    def _show_local_trace_message(self):
-        """Show message when traces were collected locally but couldn't be uploaded."""
-        console = Console()
-
-        panel_content = f"""
-📊 Your execution traces were collected locally!
-
-Unfortunately, we couldn't upload them to the server right now, but here's what we captured:
-• {len(self.batch_manager.event_buffer)} trace events
-• Execution duration: {self.batch_manager.calculate_duration("execution")}ms
-• Batch ID: {self.batch_manager.trace_batch_id}
-
-Tracing has been enabled for future runs! (CREWAI_TRACING_ENABLED=true added to .env)
-The traces include agent decisions, task execution, and tool usage.
-    """.strip()
-
-        panel = Panel(
-            panel_content,
-            title="🔍 Local Traces Collected",
-            border_style="yellow",
-            padding=(1, 2),
-        )
-
-        console.print("\n")
-        console.print(panel)
-        console.print()

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

@@ -1,18 +1,18 @@
 import uuid
-from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from logging import getLogger
-from typing import Any
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, field
 
+from crewai.utilities.constants import CREWAI_BASE_URL
+from crewai.cli.authentication.token import AuthError, get_auth_token
+
+from crewai.cli.version import get_crewai_version
+from crewai.cli.plus_api import PlusAPI
 from rich.console import Console
 from rich.panel import Panel
 
-from crewai.cli.authentication.token import AuthError, get_auth_token
-from crewai.cli.plus_api import PlusAPI
-from crewai.cli.version import get_crewai_version
 from crewai.events.listeners.tracing.types import TraceEvent
-from crewai.events.listeners.tracing.utils import should_auto_collect_first_time_traces
-from crewai.utilities.constants import CREWAI_BASE_URL
+from logging import getLogger
 
 logger = getLogger(__name__)
 
@@ -23,11 +23,11 @@ class TraceBatch:
 
     version: str = field(default_factory=get_crewai_version)
     batch_id: str = field(default_factory=lambda: str(uuid.uuid4()))
-    user_context: dict[str, str] = field(default_factory=dict)
-    execution_metadata: dict[str, Any] = field(default_factory=dict)
-    events: list[TraceEvent] = field(default_factory=list)
+    user_context: Dict[str, str] = field(default_factory=dict)
+    execution_metadata: Dict[str, Any] = field(default_factory=dict)
+    events: List[TraceEvent] = field(default_factory=list)
 
-    def to_dict(self) -> dict[str, Any]:
+    def to_dict(self) -> Dict[str, Any]:
         return {
             "version": self.version,
             "batch_id": self.batch_id,
@@ -40,28 +40,26 @@ class TraceBatch:
 class TraceBatchManager:
     """Single responsibility: Manage batches and event buffering"""
 
+    is_current_batch_ephemeral: bool = False
+    trace_batch_id: Optional[str] = None
+    current_batch: Optional[TraceBatch] = None
+    event_buffer: List[TraceEvent] = []
+    execution_start_times: Dict[str, datetime] = {}
+    batch_owner_type: Optional[str] = None
+    batch_owner_id: Optional[str] = None
+
     def __init__(self):
-        self.is_current_batch_ephemeral: bool = False
-        self.trace_batch_id: str | None = None
-        self.current_batch: TraceBatch | None = None
-        self.event_buffer: list[TraceEvent] = []
-        self.execution_start_times: dict[str, datetime] = {}
-        self.batch_owner_type: str | None = None
-        self.batch_owner_id: str | None = None
-        self.backend_initialized: bool = False
-        self.ephemeral_trace_url: str | None = None
         try:
             self.plus_api = PlusAPI(
                 api_key=get_auth_token(),
             )
         except AuthError:
             self.plus_api = PlusAPI(api_key="")
-        self.ephemeral_trace_url = None
 
     def initialize_batch(
         self,
-        user_context: dict[str, str],
-        execution_metadata: dict[str, Any],
+        user_context: Dict[str, str],
+        execution_metadata: Dict[str, Any],
         use_ephemeral: bool = False,
     ) -> TraceBatch:
         """Initialize a new trace batch"""
@@ -72,21 +70,14 @@ class TraceBatchManager:
         self.is_current_batch_ephemeral = use_ephemeral
 
         self.record_start_time("execution")
-
-        if should_auto_collect_first_time_traces():
-            self.trace_batch_id = self.current_batch.batch_id
-        else:
-            self._initialize_backend_batch(
-                user_context, execution_metadata, use_ephemeral
-            )
-            self.backend_initialized = True
+        self._initialize_backend_batch(user_context, execution_metadata, use_ephemeral)
 
         return self.current_batch
 
     def _initialize_backend_batch(
         self,
-        user_context: dict[str, str],
-        execution_metadata: dict[str, Any],
+        user_context: Dict[str, str],
+        execution_metadata: Dict[str, Any],
         use_ephemeral: bool = False,
     ):
         """Send batch initialization to backend"""
@@ -138,6 +129,13 @@ class TraceBatchManager:
                     if not use_ephemeral
                     else response_data["ephemeral_trace_id"]
                 )
+                console = Console()
+                panel = Panel(
+                    f"✅ Trace batch initialized with session ID: {self.trace_batch_id}",
+                    title="Trace Batch Initialization",
+                    border_style="green",
+                )
+                console.print(panel)
             else:
                 logger.warning(
                     f"Trace batch initialization returned status {response.status_code}. Continuing without tracing."
@@ -145,7 +143,7 @@ class TraceBatchManager:
 
         except Exception as e:
             logger.warning(
-                f"Error initializing trace batch: {e}. Continuing without tracing."
+                f"Error initializing trace batch: {str(e)}. Continuing without tracing."
             )
 
     def add_event(self, trace_event: TraceEvent):
@@ -156,6 +154,7 @@ class TraceBatchManager:
         """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 500
+
         try:
             payload = {
                 "events": [event.to_dict() for event in self.event_buffer],
@@ -179,19 +178,19 @@ class TraceBatchManager:
             if response.status_code in [200, 201]:
                 self.event_buffer.clear()
                 return 200
-
-            logger.warning(
-                f"Failed to send events: {response.status_code}. Events will be lost."
-            )
-            return 500
+            else:
+                logger.warning(
+                    f"Failed to send events: {response.status_code}. Events will be lost."
+                )
+                return 500
 
         except Exception as e:
             logger.warning(
-                f"Error sending events to backend: {e}. Events will be lost."
+                f"Error sending events to backend: {str(e)}. Events will be lost."
             )
             return 500
 
-    def finalize_batch(self) -> TraceBatch | None:
+    def finalize_batch(self) -> Optional[TraceBatch]:
         """Finalize batch and return it for sending"""
         if not self.current_batch:
             return None
@@ -200,9 +199,6 @@ class TraceBatchManager:
         if self.event_buffer:
             events_sent_to_backend_status = self._send_events_to_backend()
             if events_sent_to_backend_status == 500:
-                self.plus_api.mark_trace_batch_as_failed(
-                    self.trace_batch_id, "Error sending events to backend"
-                )
                 return None
         self._finalize_backend_batch()
 
@@ -250,39 +246,21 @@ class TraceBatchManager:
                     if not self.is_current_batch_ephemeral and access_code is None
                     else f"{CREWAI_BASE_URL}/crewai_plus/ephemeral_trace_batches/{self.trace_batch_id}?access_code={access_code}"
                 )
-
-                if self.is_current_batch_ephemeral:
-                    self.ephemeral_trace_url = return_link
-
-                # Create a properly formatted message with URL on its own line
-                message_parts = [
-                    f"✅ Trace batch finalized with session ID: {self.trace_batch_id}",
-                    "",
-                    f"🔗 View here: {return_link}",
-                ]
-
-                if access_code:
-                    message_parts.append(f"🔑 Access Code: {access_code}")
-
                 panel = Panel(
-                    "\n".join(message_parts),
+                    f"✅ Trace batch finalized with session ID: {self.trace_batch_id}. View here: {return_link} {f', Access Code: {access_code}' if access_code else ''}",
                     title="Trace Batch Finalization",
                     border_style="green",
                 )
-                if not should_auto_collect_first_time_traces():
-                    console.print(panel)
+                console.print(panel)
 
             else:
                 logger.error(
                     f"❌ Failed to finalize trace batch: {response.status_code} - {response.text}"
                 )
-                self.plus_api.mark_trace_batch_as_failed(
-                    self.trace_batch_id, response.text
-                )
 
         except Exception as e:
-            logger.error(f"❌ Error finalizing trace batch: {e}")
-            self.plus_api.mark_trace_batch_as_failed(self.trace_batch_id, str(e))
+            logger.error(f"❌ Error finalizing trace batch: {str(e)}")
+            # TODO: send error to app
 
     def _cleanup_batch_data(self):
         """Clean up batch data after successful finalization to free memory"""
@@ -299,7 +277,7 @@ class TraceBatchManager:
                 self.batch_sequence = 0
 
         except Exception as e:
-            logger.error(f"Warning: Error during cleanup: {e}")
+            logger.error(f"Warning: Error during cleanup: {str(e)}")
 
     def has_events(self) -> bool:
         """Check if there are events in the buffer"""
@@ -328,7 +306,7 @@ class TraceBatchManager:
             return duration_ms
         return 0
 
-    def get_trace_id(self) -> str | None:
+    def get_trace_id(self) -> Optional[str]:
         """Get current trace ID"""
         if self.current_batch:
             return self.current_batch.user_context.get("trace_id")

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

@@ -1,59 +1,28 @@
 import os
 import uuid
-from typing import Any, ClassVar
 
-from crewai.cli.authentication.token import AuthError, get_auth_token
-from crewai.cli.version import get_crewai_version
+from typing import Dict, Any, Optional
+
 from crewai.events.base_event_listener import BaseEventListener
-from crewai.events.listeners.tracing.first_time_trace_handler import (
-    FirstTimeTraceHandler,
-)
-from crewai.events.listeners.tracing.types import TraceEvent
-from crewai.events.listeners.tracing.utils import safe_serialize_to_dict
 from crewai.events.types.agent_events import (
     AgentExecutionCompletedEvent,
-    AgentExecutionErrorEvent,
     AgentExecutionStartedEvent,
+    LiteAgentExecutionStartedEvent,
     LiteAgentExecutionCompletedEvent,
     LiteAgentExecutionErrorEvent,
-    LiteAgentExecutionStartedEvent,
+    AgentExecutionErrorEvent,
+)
+from crewai.events.listeners.tracing.types import TraceEvent
+from crewai.events.types.reasoning_events import (
+    AgentReasoningStartedEvent,
+    AgentReasoningCompletedEvent,
+    AgentReasoningFailedEvent,
 )
 from crewai.events.types.crew_events import (
     CrewKickoffCompletedEvent,
     CrewKickoffFailedEvent,
     CrewKickoffStartedEvent,
 )
-from crewai.events.types.flow_events import (
-    FlowCreatedEvent,
-    FlowFinishedEvent,
-    FlowPlotEvent,
-    FlowStartedEvent,
-    MethodExecutionFailedEvent,
-    MethodExecutionFinishedEvent,
-    MethodExecutionStartedEvent,
-)
-from crewai.events.types.llm_events import (
-    LLMCallCompletedEvent,
-    LLMCallFailedEvent,
-    LLMCallStartedEvent,
-)
-from crewai.events.types.llm_guardrail_events import (
-    LLMGuardrailCompletedEvent,
-    LLMGuardrailStartedEvent,
-)
-from crewai.events.types.memory_events import (
-    MemoryQueryCompletedEvent,
-    MemoryQueryFailedEvent,
-    MemoryQueryStartedEvent,
-    MemorySaveCompletedEvent,
-    MemorySaveFailedEvent,
-    MemorySaveStartedEvent,
-)
-from crewai.events.types.reasoning_events import (
-    AgentReasoningCompletedEvent,
-    AgentReasoningFailedEvent,
-    AgentReasoningStartedEvent,
-)
 from crewai.events.types.task_events import (
     TaskCompletedEvent,
     TaskFailedEvent,
@@ -64,16 +33,49 @@ from crewai.events.types.tool_usage_events import (
     ToolUsageFinishedEvent,
     ToolUsageStartedEvent,
 )
+from crewai.events.types.llm_events import (
+    LLMCallCompletedEvent,
+    LLMCallFailedEvent,
+    LLMCallStartedEvent,
+)
+
+from crewai.events.types.flow_events import (
+    FlowCreatedEvent,
+    FlowStartedEvent,
+    FlowFinishedEvent,
+    MethodExecutionStartedEvent,
+    MethodExecutionFinishedEvent,
+    MethodExecutionFailedEvent,
+    FlowPlotEvent,
+)
+from crewai.events.types.llm_guardrail_events import (
+    LLMGuardrailStartedEvent,
+    LLMGuardrailCompletedEvent,
+)
+from crewai.utilities.serialization import to_serializable
+
 
 from .trace_batch_manager import TraceBatchManager
 
+from crewai.events.types.memory_events import (
+    MemoryQueryStartedEvent,
+    MemoryQueryCompletedEvent,
+    MemoryQueryFailedEvent,
+    MemorySaveStartedEvent,
+    MemorySaveCompletedEvent,
+    MemorySaveFailedEvent,
+)
+
+from crewai.cli.authentication.token import AuthError, get_auth_token
+from crewai.cli.version import get_crewai_version
+
 
 class TraceCollectionListener(BaseEventListener):
     """
     Trace collection listener that orchestrates trace collection
     """
 
-    complex_events: ClassVar[list[str]] = [
+    complex_events = [
         "task_started",
         "task_completed",
         "llm_call_started",
@@ -86,14 +88,14 @@ class TraceCollectionListener(BaseEventListener):
     _initialized = False
     _listeners_setup = False
 
-    def __new__(cls, batch_manager: TraceBatchManager | None = None):
+    def __new__(cls, batch_manager=None):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
         return cls._instance
 
     def __init__(
         self,
-        batch_manager: TraceBatchManager | None = None,
+        batch_manager: Optional[TraceBatchManager] = None,
     ):
         if self._initialized:
             return
@@ -101,19 +103,16 @@ class TraceCollectionListener(BaseEventListener):
         super().__init__()
         self.batch_manager = batch_manager or TraceBatchManager()
         self._initialized = True
-        self.first_time_handler = FirstTimeTraceHandler()
-
-        if self.first_time_handler.initialize_for_first_time_user():
-            self.first_time_handler.set_batch_manager(self.batch_manager)
 
     def _check_authenticated(self) -> bool:
         """Check if tracing should be enabled"""
         try:
-            return bool(get_auth_token())
+            res = bool(get_auth_token())
+            return res
         except AuthError:
             return False
 
-    def _get_user_context(self) -> dict[str, str]:
+    def _get_user_context(self) -> Dict[str, str]:
         """Extract user context for tracing"""
         return {
             "user_id": os.getenv("CREWAI_USER_ID", "anonymous"),
@@ -162,14 +161,8 @@ class TraceCollectionListener(BaseEventListener):
         @event_bus.on(FlowFinishedEvent)
         def on_flow_finished(source, event):
             self._handle_trace_event("flow_finished", source, event)
-
             if self.batch_manager.batch_owner_type == "flow":
-                if self.first_time_handler.is_first_time:
-                    self.first_time_handler.mark_events_collected()
-                    self.first_time_handler.handle_execution_completion()
-                else:
-                    # Normal flow finalization
-                    self.batch_manager.finalize_batch()
+                self.batch_manager.finalize_batch()
 
         @event_bus.on(FlowPlotEvent)
         def on_flow_plot(source, event):
@@ -188,20 +181,12 @@ class TraceCollectionListener(BaseEventListener):
         def on_crew_completed(source, event):
             self._handle_trace_event("crew_kickoff_completed", source, event)
             if self.batch_manager.batch_owner_type == "crew":
-                if self.first_time_handler.is_first_time:
-                    self.first_time_handler.mark_events_collected()
-                    self.first_time_handler.handle_execution_completion()
-                else:
-                    self.batch_manager.finalize_batch()
+                self.batch_manager.finalize_batch()
 
         @event_bus.on(CrewKickoffFailedEvent)
         def on_crew_failed(source, event):
             self._handle_trace_event("crew_kickoff_failed", source, event)
-            if self.first_time_handler.is_first_time:
-                self.first_time_handler.mark_events_collected()
-                self.first_time_handler.handle_execution_completion()
-            else:
-                self.batch_manager.finalize_batch()
+            self.batch_manager.finalize_batch()
 
         @event_bus.on(TaskStartedEvent)
         def on_task_started(source, event):
@@ -340,19 +325,17 @@ class TraceCollectionListener(BaseEventListener):
         self._initialize_batch(user_context, execution_metadata)
 
     def _initialize_batch(
-        self, user_context: dict[str, str], execution_metadata: dict[str, Any]
+        self, user_context: Dict[str, str], execution_metadata: Dict[str, Any]
     ):
-        """Initialize trace batch - auto-enable ephemeral for first-time users."""
-
-        if self.first_time_handler.is_first_time:
-            return self.batch_manager.initialize_batch(
+        """Initialize trace batch if ephemeral"""
+        if not self._check_authenticated():
+            self.batch_manager.initialize_batch(
                 user_context, execution_metadata, use_ephemeral=True
             )
-
-        use_ephemeral = not self._check_authenticated()
-        return self.batch_manager.initialize_batch(
-            user_context, execution_metadata, use_ephemeral=use_ephemeral
-        )
+        else:
+            self.batch_manager.initialize_batch(
+                user_context, execution_metadata, use_ephemeral=False
+            )
 
     def _handle_trace_event(self, event_type: str, source: Any, event: Any):
         """Generic handler for context end events"""
@@ -388,11 +371,11 @@ class TraceCollectionListener(BaseEventListener):
 
     def _build_event_data(
         self, event_type: str, event: Any, source: Any
-    ) -> dict[str, Any]:
+    ) -> Dict[str, Any]:
         """Build event data"""
         if event_type not in self.complex_events:
-            return safe_serialize_to_dict(event)
-        if event_type == "task_started":
+            return self._safe_serialize_to_dict(event)
+        elif event_type == "task_started":
             return {
                 "task_description": event.task.description,
                 "expected_output": event.task.expected_output,
@@ -401,7 +384,7 @@ class TraceCollectionListener(BaseEventListener):
                 "agent_role": source.agent.role,
                 "task_id": str(event.task.id),
             }
-        if event_type == "task_completed":
+        elif event_type == "task_completed":
             return {
                 "task_description": event.task.description if event.task else None,
                 "task_name": event.task.name or event.task.description
@@ -414,31 +397,63 @@ class TraceCollectionListener(BaseEventListener):
                 else None,
                 "agent_role": event.output.agent if event.output else None,
             }
-        if event_type == "agent_execution_started":
+        elif event_type == "agent_execution_started":
             return {
                 "agent_role": event.agent.role,
                 "agent_goal": event.agent.goal,
                 "agent_backstory": event.agent.backstory,
             }
-        if event_type == "agent_execution_completed":
+        elif event_type == "agent_execution_completed":
             return {
                 "agent_role": event.agent.role,
                 "agent_goal": event.agent.goal,
                 "agent_backstory": event.agent.backstory,
             }
-        if event_type == "llm_call_started":
-            event_data = safe_serialize_to_dict(event)
+        elif event_type == "llm_call_started":
+            event_data = self._safe_serialize_to_dict(event)
             event_data["task_name"] = (
                 event.task_name or event.task_description
                 if hasattr(event, "task_name") and event.task_name
                 else None
             )
             return event_data
-        if event_type == "llm_call_completed":
-            return safe_serialize_to_dict(event)
+        elif event_type == "llm_call_completed":
+            return self._safe_serialize_to_dict(event)
+        else:
+            return {
+                "event_type": event_type,
+                "event": self._safe_serialize_to_dict(event),
+                "source": source,
+            }
 
-        return {
-            "event_type": event_type,
-            "event": safe_serialize_to_dict(event),
-            "source": source,
-        }
+    # TODO: move to utils
+    def _safe_serialize_to_dict(
+        self, obj, exclude: set[str] | None = None
+    ) -> Dict[str, Any]:
+        """Safely serialize an object to a dictionary for event data."""
+        try:
+            serialized = to_serializable(obj, exclude)
+            if isinstance(serialized, dict):
+                return serialized
+            else:
+                return {"serialized_data": serialized}
+        except Exception as e:
+            return {"serialization_error": str(e), "object_type": type(obj).__name__}
+
+    # TODO: move to utils
+    def _truncate_messages(self, messages, max_content_length=500, max_messages=5):
+        """Truncate message content and limit number of messages"""
+        if not messages or not isinstance(messages, list):
+            return messages
+
+        # Limit number of messages
+        limited_messages = messages[:max_messages]
+
+        # Truncate each message content
+        for msg in limited_messages:
+            if isinstance(msg, dict) and "content" in msg:
+                content = msg["content"]
+                if len(content) > max_content_length:
+                    msg["content"] = content[:max_content_length] + "..."
+
+        return limited_messages

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

@@ -1,7 +1,7 @@
-import uuid
-from dataclasses import asdict, dataclass, field
+from dataclasses import dataclass, field, asdict
 from datetime import datetime, timezone
-from typing import Any
+from typing import Dict, Any
+import uuid
 
 
 @dataclass
@@ -13,7 +13,7 @@ class TraceEvent:
         default_factory=lambda: datetime.now(timezone.utc).isoformat()
     )
     type: str = ""
-    event_data: dict[str, Any] = field(default_factory=dict)
+    event_data: Dict[str, Any] = field(default_factory=dict)
 
-    def to_dict(self) -> dict[str, Any]:
+    def to_dict(self) -> Dict[str, Any]:
         return asdict(self)

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

@@ -1,25 +1,17 @@
-import getpass
-import hashlib
-import json
-import logging
 import os
 import platform
-import re
-import subprocess
 import uuid
-from datetime import datetime
+import hashlib
+import subprocess
+import getpass
 from pathlib import Path
-from typing import Any
+from datetime import datetime
+import re
+import json
 
 import click
-from rich.console import Console
-from rich.panel import Panel
-from rich.text import Text
 
 from crewai.utilities.paths import db_storage_path
-from crewai.utilities.serialization import to_serializable
-
-logger = logging.getLogger(__name__)
 
 
 def is_tracing_enabled() -> bool:
@@ -51,167 +43,49 @@ def _get_machine_id() -> str:
 
     try:
         mac = ":".join(
-            [f"{(uuid.getnode() >> b) & 0xFF:02x}" for b in range(0, 12, 2)][::-1]
+            ["{:02x}".format((uuid.getnode() >> b) & 0xFF) for b in range(0, 12, 2)][
+                ::-1
+            ]
         )
         parts.append(mac)
-    except Exception:  # noqa: S110
+    except Exception:
         pass
 
-    try:
-        sysname = platform.system()
-        parts.append(sysname)
-    except Exception:
-        sysname = "unknown"
-        parts.append(sysname)
+    sysname = platform.system()
+    parts.append(sysname)
 
     try:
         if sysname == "Darwin":
-            try:
-                res = subprocess.run(
-                    ["/usr/sbin/system_profiler", "SPHardwareDataType"],
-                    capture_output=True,
-                    text=True,
-                    timeout=2,
-                )
-                m = re.search(r"Hardware UUID:\s*([A-Fa-f0-9\-]+)", res.stdout)
-                if m:
-                    parts.append(m.group(1))
-            except Exception:  # noqa: S110
-                pass
-
+            res = subprocess.run(
+                ["system_profiler", "SPHardwareDataType"],
+                capture_output=True,
+                text=True,
+                timeout=2,
+            )
+            m = re.search(r"Hardware UUID:\s*([A-Fa-f0-9\-]+)", res.stdout)
+            if m:
+                parts.append(m.group(1))
         elif sysname == "Linux":
-            linux_id = _get_linux_machine_id()
-            if linux_id:
-                parts.append(linux_id)
-
-        elif sysname == "Windows":
             try:
-                res = subprocess.run(
-                    [
-                        "C:\\Windows\\System32\\wbem\\wmic.exe",
-                        "csproduct",
-                        "get",
-                        "UUID",
-                    ],
-                    capture_output=True,
-                    text=True,
-                    timeout=2,
-                )
-                lines = [
-                    line.strip() for line in res.stdout.splitlines() if line.strip()
-                ]
-                if len(lines) >= 2:
-                    parts.append(lines[1])
-            except Exception:  # noqa: S110
-                pass
-        else:
-            generic_id = _get_generic_system_id()
-            if generic_id:
-                parts.append(generic_id)
-
-    except Exception:  # noqa: S110
+                parts.append(Path("/etc/machine-id").read_text().strip())
+            except Exception:
+                parts.append(Path("/sys/class/dmi/id/product_uuid").read_text().strip())
+        elif sysname == "Windows":
+            res = subprocess.run(
+                ["wmic", "csproduct", "get", "UUID"],
+                capture_output=True,
+                text=True,
+                timeout=2,
+            )
+            lines = [line.strip() for line in res.stdout.splitlines() if line.strip()]
+            if len(lines) >= 2:
+                parts.append(lines[1])
+    except Exception:
         pass
 
-    if len(parts) <= 1:
-        try:
-            import socket
-
-            parts.append(socket.gethostname())
-        except Exception:  # noqa: S110
-            pass
-
-        try:
-            parts.append(getpass.getuser())
-        except Exception:  # noqa: S110
-            pass
-
-        try:
-            parts.append(platform.machine())
-            parts.append(platform.processor())
-        except Exception:  # noqa: S110
-            pass
-
-    if not parts:
-        parts.append("unknown-system")
-        parts.append(str(uuid.uuid4()))
-
     return hashlib.sha256("".join(parts).encode()).hexdigest()
 
 
-def _get_linux_machine_id() -> str | None:
-    linux_id_sources = [
-        "/etc/machine-id",
-        "/sys/class/dmi/id/product_uuid",
-        "/proc/sys/kernel/random/boot_id",
-        "/sys/class/dmi/id/board_serial",
-        "/sys/class/dmi/id/chassis_serial",
-    ]
-
-    for source in linux_id_sources:
-        try:
-            path = Path(source)
-            if path.exists() and path.is_file():
-                content = path.read_text().strip()
-                if content and content.lower() not in [
-                    "unknown",
-                    "to be filled by o.e.m.",
-                    "",
-                ]:
-                    return content
-        except Exception:  # noqa: S112, PERF203
-            continue
-
-    try:
-        import socket
-
-        hostname = socket.gethostname()
-        arch = platform.machine()
-        if hostname and arch:
-            return f"{hostname}-{arch}"
-    except Exception:  # noqa: S110
-        pass
-
-    return None
-
-
-def _get_generic_system_id() -> str | None:
-    try:
-        parts = []
-
-        try:
-            import socket
-
-            hostname = socket.gethostname()
-            if hostname:
-                parts.append(hostname)
-        except Exception:  # noqa: S110
-            pass
-
-        try:
-            parts.append(platform.machine())
-            parts.append(platform.processor())
-            parts.append(platform.architecture()[0])
-        except Exception:  # noqa: S110
-            pass
-
-        try:
-            container_id = os.environ.get(
-                "HOSTNAME", os.environ.get("CONTAINER_ID", "")
-            )
-            if container_id:
-                parts.append(container_id)
-        except Exception:  # noqa: S110
-            pass
-
-        if parts:
-            return "-".join(filter(None, parts))
-
-    except Exception:  # noqa: S110
-        pass
-
-    return None
-
-
 def _user_data_file() -> Path:
     base = Path(db_storage_path())
     base.mkdir(parents=True, exist_ok=True)
@@ -223,8 +97,8 @@ def _load_user_data() -> dict:
     if p.exists():
         try:
             return json.loads(p.read_text())
-        except (json.JSONDecodeError, OSError, PermissionError) as e:
-            logger.warning(f"Failed to load user data: {e}")
+        except Exception:
+            pass
     return {}
 
 
@@ -232,8 +106,8 @@ def _save_user_data(data: dict) -> None:
     try:
         p = _user_data_file()
         p.write_text(json.dumps(data, indent=2))
-    except (OSError, PermissionError) as e:
-        logger.warning(f"Failed to save user data: {e}")
+    except Exception:
+        pass
 
 
 def get_user_id() -> str:
@@ -277,103 +151,3 @@ def mark_first_execution_done() -> None:
         }
     )
     _save_user_data(data)
-
-
-def safe_serialize_to_dict(obj, exclude: set[str] | None = None) -> dict[str, Any]:
-    """Safely serialize an object to a dictionary for event data."""
-    try:
-        serialized = to_serializable(obj, exclude)
-        if isinstance(serialized, dict):
-            return serialized
-        return {"serialized_data": serialized}
-    except Exception as e:
-        return {"serialization_error": str(e), "object_type": type(obj).__name__}
-
-
-def truncate_messages(messages, max_content_length=500, max_messages=5):
-    """Truncate message content and limit number of messages"""
-    if not messages or not isinstance(messages, list):
-        return messages
-
-    limited_messages = messages[:max_messages]
-
-    for msg in limited_messages:
-        if isinstance(msg, dict) and "content" in msg:
-            content = msg["content"]
-            if len(content) > max_content_length:
-                msg["content"] = content[:max_content_length] + "..."
-
-    return limited_messages
-
-
-def should_auto_collect_first_time_traces() -> bool:
-    """True if we should auto-collect traces for first-time user."""
-    if _is_test_environment():
-        return False
-    return is_first_execution()
-
-
-def prompt_user_for_trace_viewing(timeout_seconds: int = 20) -> bool:
-    """
-    Prompt user if they want to see their traces with timeout.
-    Returns True if user wants to see traces, False otherwise.
-    """
-    if _is_test_environment():
-        return False
-
-    try:
-        import threading
-
-        console = Console()
-
-        content = Text()
-        content.append("🔍 ", style="cyan bold")
-        content.append(
-            "Detailed execution traces are available!\n\n", style="cyan bold"
-        )
-        content.append("View insights including:\n", style="white")
-        content.append("  • Agent decision-making process\n", style="bright_blue")
-        content.append("  • Task execution flow and timing\n", style="bright_blue")
-        content.append("  • Tool usage details", style="bright_blue")
-
-        panel = Panel(
-            content,
-            title="[bold cyan]Execution Traces[/bold cyan]",
-            border_style="cyan",
-            padding=(1, 2),
-        )
-        console.print("\n")
-        console.print(panel)
-
-        prompt_text = click.style(
-            f"Would you like to view your execution traces? [y/N] ({timeout_seconds}s timeout): ",
-            fg="white",
-            bold=True,
-        )
-        click.echo(prompt_text, nl=False)
-
-        result = [False]
-
-        def get_input():
-            try:
-                response = input().strip().lower()
-                result[0] = response in ["y", "yes"]
-            except (EOFError, KeyboardInterrupt):
-                result[0] = False
-
-        input_thread = threading.Thread(target=get_input, daemon=True)
-        input_thread.start()
-        input_thread.join(timeout=timeout_seconds)
-
-        if input_thread.is_alive():
-            return False
-
-        return result[0]
-
-    except Exception:
-        return False
-
-
-def mark_first_execution_completed() -> None:
-    """Mark first execution as completed (called after trace prompt)."""
-    mark_first_execution_done()

src/crewai/events/types/__init__.py

@@ -2,4 +2,4 @@
 
 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

@@ -2,15 +2,14 @@
 
 from __future__ import annotations
 
-from collections.abc import Sequence
-from typing import Any
+from typing import Any, Dict, List, Optional, Sequence, Union
 
-from pydantic import ConfigDict, model_validator
+from pydantic import model_validator
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
-from crewai.events.base_events import BaseEvent
 from crewai.tools.base_tool import BaseTool
 from crewai.tools.structured_tool import CrewStructuredTool
+from crewai.events.base_events import BaseEvent
 
 
 class AgentExecutionStartedEvent(BaseEvent):
@@ -18,11 +17,11 @@ class AgentExecutionStartedEvent(BaseEvent):
 
     agent: BaseAgent
     task: Any
-    tools: Sequence[BaseTool | CrewStructuredTool] | None
+    tools: Optional[Sequence[Union[BaseTool, CrewStructuredTool]]]
     task_prompt: str
     type: str = "agent_execution_started"
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = {"arbitrary_types_allowed": True}
 
     @model_validator(mode="after")
     def set_fingerprint_data(self):
@@ -46,7 +45,7 @@ class AgentExecutionCompletedEvent(BaseEvent):
     output: str
     type: str = "agent_execution_completed"
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = {"arbitrary_types_allowed": True}
 
     @model_validator(mode="after")
     def set_fingerprint_data(self):
@@ -70,7 +69,7 @@ class AgentExecutionErrorEvent(BaseEvent):
     error: str
     type: str = "agent_execution_error"
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = {"arbitrary_types_allowed": True}
 
     @model_validator(mode="after")
     def set_fingerprint_data(self):
@@ -90,18 +89,18 @@ class AgentExecutionErrorEvent(BaseEvent):
 class LiteAgentExecutionStartedEvent(BaseEvent):
     """Event emitted when a LiteAgent starts executing"""
 
-    agent_info: dict[str, Any]
-    tools: Sequence[BaseTool | CrewStructuredTool] | None
-    messages: str | list[dict[str, str]]
+    agent_info: Dict[str, Any]
+    tools: Optional[Sequence[Union[BaseTool, CrewStructuredTool]]]
+    messages: Union[str, List[Dict[str, str]]]
     type: str = "lite_agent_execution_started"
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = {"arbitrary_types_allowed": True}
 
 
 class LiteAgentExecutionCompletedEvent(BaseEvent):
     """Event emitted when a LiteAgent completes execution"""
 
-    agent_info: dict[str, Any]
+    agent_info: Dict[str, Any]
     output: str
     type: str = "lite_agent_execution_completed"
 
@@ -109,7 +108,7 @@ class LiteAgentExecutionCompletedEvent(BaseEvent):
 class LiteAgentExecutionErrorEvent(BaseEvent):
     """Event emitted when a LiteAgent encounters an error during execution"""
 
-    agent_info: dict[str, Any]
+    agent_info: Dict[str, Any]
     error: str
     type: str = "lite_agent_execution_error"
 

src/crewai/events/types/crew_events.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Dict, Optional, Union
 
 from crewai.events.base_events import BaseEvent
 
@@ -11,8 +11,8 @@ else:
 class CrewBaseEvent(BaseEvent):
     """Base class for crew events with fingerprint handling"""
 
-    crew_name: str | None
-    crew: Crew | None = None
+    crew_name: Optional[str]
+    crew: Optional[Crew] = None
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -38,7 +38,7 @@ class CrewBaseEvent(BaseEvent):
 class CrewKickoffStartedEvent(CrewBaseEvent):
     """Event emitted when a crew starts execution"""
 
-    inputs: dict[str, Any] | None
+    inputs: Optional[Dict[str, Any]]
     type: str = "crew_kickoff_started"
 
 
@@ -62,7 +62,7 @@ class CrewTrainStartedEvent(CrewBaseEvent):
 
     n_iterations: int
     filename: str
-    inputs: dict[str, Any] | None
+    inputs: Optional[Dict[str, Any]]
     type: str = "crew_train_started"
 
 
@@ -85,8 +85,8 @@ class CrewTestStartedEvent(CrewBaseEvent):
     """Event emitted when a crew starts testing"""
 
     n_iterations: int
-    eval_llm: str | Any | None
-    inputs: dict[str, Any] | None
+    eval_llm: Optional[Union[str, Any]]
+    inputs: Optional[Dict[str, Any]]
     type: str = "crew_test_started"
 
 

src/crewai/events/types/flow_events.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Dict, Optional, Union
 
 from pydantic import BaseModel, ConfigDict
 
@@ -16,7 +16,7 @@ class FlowStartedEvent(FlowEvent):
     """Event emitted when a flow starts execution"""
 
     flow_name: str
-    inputs: dict[str, Any] | None = None
+    inputs: Optional[Dict[str, Any]] = None
     type: str = "flow_started"
 
 
@@ -32,8 +32,8 @@ class MethodExecutionStartedEvent(FlowEvent):
 
     flow_name: str
     method_name: str
-    state: dict[str, Any] | BaseModel
-    params: dict[str, Any] | None = None
+    state: Union[Dict[str, Any], BaseModel]
+    params: Optional[Dict[str, Any]] = None
     type: str = "method_execution_started"
 
 
@@ -43,7 +43,7 @@ class MethodExecutionFinishedEvent(FlowEvent):
     flow_name: str
     method_name: str
     result: Any = None
-    state: dict[str, Any] | BaseModel
+    state: Union[Dict[str, Any], BaseModel]
     type: str = "method_execution_finished"
 
 
@@ -62,7 +62,7 @@ class FlowFinishedEvent(FlowEvent):
     """Event emitted when a flow completes execution"""
 
     flow_name: str
-    result: Any | None = None
+    result: Optional[Any] = None
     type: str = "flow_finished"
 
 

src/crewai/events/types/knowledge_events.py

@@ -1,6 +1,7 @@
-from crewai.agents.agent_builder.base_agent import BaseAgent
 from crewai.events.base_events import BaseEvent
 
+from crewai.agents.agent_builder.base_agent import BaseAgent
+
 
 class KnowledgeRetrievalStartedEvent(BaseEvent):
     """Event emitted when a knowledge retrieval is started."""

src/crewai/events/types/llm_events.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Any
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
@@ -7,14 +7,14 @@ from crewai.events.base_events import BaseEvent
 
 
 class LLMEventBase(BaseEvent):
-    task_name: str | None = None
-    task_id: str | None = None
+    task_name: Optional[str] = None
+    task_id: Optional[str] = None
 
-    agent_id: str | None = None
-    agent_role: str | None = None
+    agent_id: Optional[str] = None
+    agent_role: Optional[str] = None
 
-    from_task: Any | None = None
-    from_agent: Any | None = None
+    from_task: Optional[Any] = None
+    from_agent: Optional[Any] = None
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -38,11 +38,11 @@ class LLMCallStartedEvent(LLMEventBase):
     """
 
     type: str = "llm_call_started"
-    model: str | None = None
-    messages: str | list[dict[str, Any]] | None = None
-    tools: list[dict[str, Any]] | None = None
-    callbacks: list[Any] | None = None
-    available_functions: dict[str, Any] | None = None
+    model: Optional[str] = None
+    messages: Optional[Union[str, List[Dict[str, Any]]]] = None
+    tools: Optional[List[dict[str, Any]]] = None
+    callbacks: Optional[List[Any]] = None
+    available_functions: Optional[Dict[str, Any]] = None
 
 
 class LLMCallCompletedEvent(LLMEventBase):
@@ -52,7 +52,7 @@ class LLMCallCompletedEvent(LLMEventBase):
     messages: str | list[dict[str, Any]] | None = None
     response: Any
     call_type: LLMCallType
-    model: str | None = None
+    model: Optional[str] = None
 
 
 class LLMCallFailedEvent(LLMEventBase):
@@ -64,13 +64,13 @@ class LLMCallFailedEvent(LLMEventBase):
 
 class FunctionCall(BaseModel):
     arguments: str
-    name: str | None = None
+    name: Optional[str] = None
 
 
 class ToolCall(BaseModel):
-    id: str | None = None
+    id: Optional[str] = None
     function: FunctionCall
-    type: str | None = None
+    type: Optional[str] = None
     index: int
 
 
@@ -79,4 +79,4 @@ class LLMStreamChunkEvent(LLMEventBase):
 
     type: str = "llm_stream_chunk"
     chunk: str
-    tool_call: ToolCall | None = None
+    tool_call: Optional[ToolCall] = None

src/crewai/events/types/llm_guardrail_events.py

@@ -1,6 +1,5 @@
-from collections.abc import Callable
 from inspect import getsource
-from typing import Any
+from typing import Any, Callable, Optional, Union
 
 from crewai.events.base_events import BaseEvent
 
@@ -14,12 +13,12 @@ class LLMGuardrailStartedEvent(BaseEvent):
     """
 
     type: str = "llm_guardrail_started"
-    guardrail: str | Callable
+    guardrail: Union[str, Callable]
     retry_count: int
 
     def __init__(self, **data):
-        from crewai.tasks.hallucination_guardrail import HallucinationGuardrail
         from crewai.tasks.llm_guardrail import LLMGuardrail
+        from crewai.tasks.hallucination_guardrail import HallucinationGuardrail
 
         super().__init__(**data)
 
@@ -42,5 +41,5 @@ class LLMGuardrailCompletedEvent(BaseEvent):
     type: str = "llm_guardrail_completed"
     success: bool
     result: Any
-    error: str | None = None
+    error: Optional[str] = None
     retry_count: int

src/crewai/events/types/logging_events.py

@@ -1,8 +1,6 @@
 """Agent logging events that don't reference BaseAgent to avoid circular imports."""
 
-from typing import Any
-
-from pydantic import ConfigDict
+from typing import Any, Optional
 
 from crewai.events.base_events import BaseEvent
 
@@ -11,7 +9,7 @@ class AgentLogsStartedEvent(BaseEvent):
     """Event emitted when agent logs should be shown at start"""
 
     agent_role: str
-    task_description: str | None = None
+    task_description: Optional[str] = None
     verbose: bool = False
     type: str = "agent_logs_started"
 
@@ -24,4 +22,4 @@ class AgentLogsExecutionEvent(BaseEvent):
     verbose: bool = False
     type: str = "agent_logs_execution"
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = {"arbitrary_types_allowed": True}

src/crewai/events/types/memory_events.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Dict, Optional
 
 from crewai.events.base_events import BaseEvent
 
@@ -7,12 +7,12 @@ class MemoryBaseEvent(BaseEvent):
     """Base event for memory operations"""
 
     type: str
-    task_id: str | None = None
-    task_name: str | None = None
-    from_task: Any | None = None
-    from_agent: Any | None = None
-    agent_role: str | None = None
-    agent_id: str | None = None
+    task_id: Optional[str] = None
+    task_name: Optional[str] = None
+    from_task: Optional[Any] = None
+    from_agent: Optional[Any] = None
+    agent_role: Optional[str] = None
+    agent_id: Optional[str] = None
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -26,7 +26,7 @@ class MemoryQueryStartedEvent(MemoryBaseEvent):
     type: str = "memory_query_started"
     query: str
     limit: int
-    score_threshold: float | None = None
+    score_threshold: Optional[float] = None
 
 
 class MemoryQueryCompletedEvent(MemoryBaseEvent):
@@ -36,7 +36,7 @@ class MemoryQueryCompletedEvent(MemoryBaseEvent):
     query: str
     results: Any
     limit: int
-    score_threshold: float | None = None
+    score_threshold: Optional[float] = None
     query_time_ms: float
 
 
@@ -46,7 +46,7 @@ class MemoryQueryFailedEvent(MemoryBaseEvent):
     type: str = "memory_query_failed"
     query: str
     limit: int
-    score_threshold: float | None = None
+    score_threshold: Optional[float] = None
     error: str
 
 
@@ -54,9 +54,9 @@ class MemorySaveStartedEvent(MemoryBaseEvent):
     """Event emitted when a memory save operation is started"""
 
     type: str = "memory_save_started"
-    value: str | None = None
-    metadata: dict[str, Any] | None = None
-    agent_role: str | None = None
+    value: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+    agent_role: Optional[str] = None
 
 
 class MemorySaveCompletedEvent(MemoryBaseEvent):
@@ -64,8 +64,8 @@ class MemorySaveCompletedEvent(MemoryBaseEvent):
 
     type: str = "memory_save_completed"
     value: str
-    metadata: dict[str, Any] | None = None
-    agent_role: str | None = None
+    metadata: Optional[Dict[str, Any]] = None
+    agent_role: Optional[str] = None
     save_time_ms: float
 
 
@@ -73,9 +73,9 @@ class MemorySaveFailedEvent(MemoryBaseEvent):
     """Event emitted when a memory save operation fails"""
 
     type: str = "memory_save_failed"
-    value: str | None = None
-    metadata: dict[str, Any] | None = None
-    agent_role: str | None = None
+    value: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+    agent_role: Optional[str] = None
     error: str
 
 
@@ -83,13 +83,13 @@ class MemoryRetrievalStartedEvent(MemoryBaseEvent):
     """Event emitted when memory retrieval for a task prompt starts"""
 
     type: str = "memory_retrieval_started"
-    task_id: str | None = None
+    task_id: Optional[str] = None
 
 
 class MemoryRetrievalCompletedEvent(MemoryBaseEvent):
     """Event emitted when memory retrieval for a task prompt completes successfully"""
 
     type: str = "memory_retrieval_completed"
-    task_id: str | None = None
+    task_id: Optional[str] = None
     memory_content: str
     retrieval_time_ms: float

src/crewai/events/types/reasoning_events.py

@@ -1,6 +1,5 @@
-from typing import Any
-
 from crewai.events.base_events import BaseEvent
+from typing import Any, Optional
 
 
 class ReasoningEvent(BaseEvent):
@@ -10,10 +9,10 @@ class ReasoningEvent(BaseEvent):
     attempt: int = 1
     agent_role: str
     task_id: str
-    task_name: str | None = None
-    from_task: Any | None = None
-    agent_id: str | None = None
-    from_agent: Any | None = None
+    task_name: Optional[str] = None
+    from_task: Optional[Any] = None
+    agent_id: Optional[str] = None
+    from_agent: Optional[Any] = None
 
     def __init__(self, **data):
         super().__init__(**data)

src/crewai/events/types/task_events.py

@@ -1,15 +1,15 @@
-from typing import Any
+from typing import Any, Optional
 
-from crewai.events.base_events import BaseEvent
 from crewai.tasks.task_output import TaskOutput
+from crewai.events.base_events import BaseEvent
 
 
 class TaskStartedEvent(BaseEvent):
     """Event emitted when a task starts"""
 
     type: str = "task_started"
-    context: str | None
-    task: Any | None = None
+    context: Optional[str]
+    task: Optional[Any] = None
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -29,7 +29,7 @@ class TaskCompletedEvent(BaseEvent):
 
     output: TaskOutput
     type: str = "task_completed"
-    task: Any | None = None
+    task: Optional[Any] = None
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -49,7 +49,7 @@ class TaskFailedEvent(BaseEvent):
 
     error: str
     type: str = "task_failed"
-    task: Any | None = None
+    task: Optional[Any] = None
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -69,7 +69,7 @@ class TaskEvaluationEvent(BaseEvent):
 
     type: str = "task_evaluation"
     evaluation_type: str
-    task: Any | None = None
+    task: Optional[Any] = None
 
     def __init__(self, **data):
         super().__init__(**data)

src/crewai/events/types/tool_usage_events.py

@@ -1,8 +1,5 @@
-from collections.abc import Callable
 from datetime import datetime
-from typing import Any
-
-from pydantic import ConfigDict
+from typing import Any, Callable, Dict, Optional
 
 from crewai.events.base_events import BaseEvent
 
@@ -10,21 +7,21 @@ from crewai.events.base_events import BaseEvent
 class ToolUsageEvent(BaseEvent):
     """Base event for tool usage tracking"""
 
-    agent_key: str | None = None
-    agent_role: str | None = None
-    agent_id: str | None = None
+    agent_key: Optional[str] = None
+    agent_role: Optional[str] = None
+    agent_id: Optional[str] = None
     tool_name: str
-    tool_args: dict[str, Any] | str
-    tool_class: str | None = None
+    tool_args: Dict[str, Any] | str
+    tool_class: Optional[str] = None
     run_attempts: int | None = None
     delegations: int | None = None
-    agent: Any | None = None
-    task_name: str | None = None
-    task_id: str | None = None
-    from_task: Any | None = None
-    from_agent: Any | None = None
+    agent: Optional[Any] = None
+    task_name: Optional[str] = None
+    task_id: Optional[str] = None
+    from_task: Optional[Any] = None
+    from_agent: Optional[Any] = None
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = {"arbitrary_types_allowed": True}
 
     def __init__(self, **data):
         super().__init__(**data)
@@ -84,9 +81,9 @@ class ToolExecutionErrorEvent(BaseEvent):
     error: Any
     type: str = "tool_execution_error"
     tool_name: str
-    tool_args: dict[str, Any]
+    tool_args: Dict[str, Any]
     tool_class: Callable
-    agent: Any | None = None
+    agent: Optional[Any] = None
 
     def __init__(self, **data):
         super().__init__(**data)

src/crewai/events/utils/console_formatter.py

@@ -693,7 +693,7 @@ class ConsoleFormatter:
         if tool_branch is not None and "Thinking" in str(tool_branch.label):
             thinking_branch_to_remove = tool_branch
 
-        # Method 2: Fallback - search for any thinking node if tool_branch is None or not thinking
+        # Method 2: Fallback - search for any thinking node if tool_branch is None
         if thinking_branch_to_remove is None:
             parents = [
                 self.current_lite_agent_branch,
@@ -752,7 +752,7 @@ class ConsoleFormatter:
         if tool_branch is not None and "Thinking" in str(tool_branch.label):
             thinking_branch_to_update = tool_branch
 
-        # Method 2: Fallback - search for any thinking node if tool_branch is None or not thinking
+        # Method 2: Fallback - search for any thinking node if tool_branch is None
         if thinking_branch_to_update is None:
             parents = [
                 self.current_lite_agent_branch,
@@ -1376,11 +1376,20 @@ class ConsoleFormatter:
 
         if isinstance(formatted_answer, AgentAction):
             thought = re.sub(r"\n+", "\n", formatted_answer.thought)
-            formatted_json = json.dumps(
-                formatted_answer.tool_input,
-                indent=2,
-                ensure_ascii=False,
-            )
+
+            try:
+                parsed_input = json.loads(formatted_answer.tool_input)
+                formatted_json = json.dumps(
+                    parsed_input,
+                    indent=2,
+                    ensure_ascii=False,
+                )
+            except (json.JSONDecodeError, TypeError):
+                formatted_json = json.dumps(
+                    formatted_answer.tool_input,
+                    indent=2,
+                    ensure_ascii=False,
+                )
 
             # Create content for the action panel
             content = Text()

src/crewai/experimental/__init__.py

@@ -1,39 +1,40 @@
 from crewai.experimental.evaluation import (
-    AgentEvaluationResult,
-    AgentEvaluator,
     BaseEvaluator,
     EvaluationScore,
-    EvaluationTraceCallback,
-    ExperimentResult,
-    ExperimentResults,
-    ExperimentRunner,
-    GoalAlignmentEvaluator,
     MetricCategory,
-    ParameterExtractionEvaluator,
-    ReasoningEfficiencyEvaluator,
+    AgentEvaluationResult,
     SemanticQualityEvaluator,
-    ToolInvocationEvaluator,
+    GoalAlignmentEvaluator,
+    ReasoningEfficiencyEvaluator,
     ToolSelectionEvaluator,
-    create_default_evaluator,
+    ParameterExtractionEvaluator,
+    ToolInvocationEvaluator,
+    EvaluationTraceCallback,
     create_evaluation_callbacks,
+    AgentEvaluator,
+    create_default_evaluator,
+    ExperimentRunner,
+    ExperimentResults,
+    ExperimentResult,
 )
 
+
 __all__ = [
-    "AgentEvaluationResult",
-    "AgentEvaluator",
     "BaseEvaluator",
     "EvaluationScore",
-    "EvaluationTraceCallback",
-    "ExperimentResult",
-    "ExperimentResults",
-    "ExperimentRunner",
-    "GoalAlignmentEvaluator",
     "MetricCategory",
-    "ParameterExtractionEvaluator",
-    "ReasoningEfficiencyEvaluator",
+    "AgentEvaluationResult",
     "SemanticQualityEvaluator",
-    "ToolInvocationEvaluator",
+    "GoalAlignmentEvaluator",
+    "ReasoningEfficiencyEvaluator",
     "ToolSelectionEvaluator",
-    "create_default_evaluator",
+    "ParameterExtractionEvaluator",
+    "ToolInvocationEvaluator",
+    "EvaluationTraceCallback",
     "create_evaluation_callbacks",
-]
+    "AgentEvaluator",
+    "create_default_evaluator",
+    "ExperimentRunner",
+    "ExperimentResults",
+    "ExperimentResult"
+]

src/crewai/experimental/evaluation/__init__.py

@@ -1,47 +1,51 @@
-from crewai.experimental.evaluation.agent_evaluator import (
-    AgentEvaluator,
-    create_default_evaluator,
-)
 from crewai.experimental.evaluation.base_evaluator import (
-    AgentEvaluationResult,
     BaseEvaluator,
     EvaluationScore,
     MetricCategory,
+    AgentEvaluationResult
 )
+
+from crewai.experimental.evaluation.metrics import (
+    SemanticQualityEvaluator,
+    GoalAlignmentEvaluator,
+    ReasoningEfficiencyEvaluator,
+    ToolSelectionEvaluator,
+    ParameterExtractionEvaluator,
+    ToolInvocationEvaluator
+)
+
 from crewai.experimental.evaluation.evaluation_listener import (
     EvaluationTraceCallback,
-    create_evaluation_callbacks,
+    create_evaluation_callbacks
 )
+
+from crewai.experimental.evaluation.agent_evaluator import (
+    AgentEvaluator,
+    create_default_evaluator
+)
+
 from crewai.experimental.evaluation.experiment import (
-    ExperimentResult,
-    ExperimentResults,
     ExperimentRunner,
-)
-from crewai.experimental.evaluation.metrics import (
-    GoalAlignmentEvaluator,
-    ParameterExtractionEvaluator,
-    ReasoningEfficiencyEvaluator,
-    SemanticQualityEvaluator,
-    ToolInvocationEvaluator,
-    ToolSelectionEvaluator,
+    ExperimentResults,
+    ExperimentResult
 )
 
 __all__ = [
-    "AgentEvaluationResult",
-    "AgentEvaluator",
     "BaseEvaluator",
     "EvaluationScore",
-    "EvaluationTraceCallback",
-    "ExperimentResult",
-    "ExperimentResults",
-    "ExperimentRunner",
-    "GoalAlignmentEvaluator",
     "MetricCategory",
-    "ParameterExtractionEvaluator",
-    "ReasoningEfficiencyEvaluator",
+    "AgentEvaluationResult",
     "SemanticQualityEvaluator",
-    "ToolInvocationEvaluator",
+    "GoalAlignmentEvaluator",
+    "ReasoningEfficiencyEvaluator",
     "ToolSelectionEvaluator",
-    "create_default_evaluator",
+    "ParameterExtractionEvaluator",
+    "ToolInvocationEvaluator",
+    "EvaluationTraceCallback",
     "create_evaluation_callbacks",
+    "AgentEvaluator",
+    "create_default_evaluator",
+    "ExperimentRunner",
+    "ExperimentResults",
+    "ExperimentResult"
 ]

src/crewai/experimental/evaluation/agent_evaluator.py

@@ -1,36 +1,34 @@
 import threading
-from collections.abc import Sequence
-from typing import Any
+from typing import Any, Optional
 
-from crewai.agent import Agent
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from crewai.events.event_bus import crewai_event_bus
-from crewai.events.types.agent_events import (
-    AgentEvaluationCompletedEvent,
-    AgentEvaluationFailedEvent,
-    AgentEvaluationStartedEvent,
-    LiteAgentExecutionCompletedEvent,
-)
-from crewai.events.types.task_events import TaskCompletedEvent
-from crewai.events.utils.console_formatter import ConsoleFormatter
 from crewai.experimental.evaluation.base_evaluator import (
-    AgentAggregatedEvaluationResult,
     AgentEvaluationResult,
     AggregationStrategy,
-    BaseEvaluator,
+)
+from crewai.agent import Agent
+from crewai.task import Task
+from crewai.experimental.evaluation.evaluation_display import EvaluationDisplayFormatter
+from crewai.events.types.agent_events import (
+    AgentEvaluationStartedEvent,
+    AgentEvaluationCompletedEvent,
+    AgentEvaluationFailedEvent,
+)
+from crewai.experimental.evaluation import BaseEvaluator, create_evaluation_callbacks
+from collections.abc import Sequence
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.utils.console_formatter import ConsoleFormatter
+from crewai.events.types.task_events import TaskCompletedEvent
+from crewai.events.types.agent_events import LiteAgentExecutionCompletedEvent
+from crewai.experimental.evaluation.base_evaluator import (
+    AgentAggregatedEvaluationResult,
     EvaluationScore,
     MetricCategory,
 )
-from crewai.experimental.evaluation.evaluation_display import EvaluationDisplayFormatter
-from crewai.experimental.evaluation.evaluation_listener import (
-    create_evaluation_callbacks,
-)
-from crewai.task import Task
 
 
 class ExecutionState:
-    current_agent_id: str | None = None
-    current_task_id: str | None = None
+    current_agent_id: Optional[str] = None
+    current_task_id: Optional[str] = None
 
     def __init__(self):
         self.traces = {}
@@ -42,10 +40,10 @@ class ExecutionState:
 class AgentEvaluator:
     def __init__(
         self,
-        agents: list[Agent] | list[BaseAgent],
+        agents: list[Agent],
         evaluators: Sequence[BaseEvaluator] | None = None,
     ):
-        self.agents: list[Agent] | list[BaseAgent] = agents
+        self.agents: list[Agent] = agents
         self.evaluators: Sequence[BaseEvaluator] | None = evaluators
 
         self.callback = create_evaluation_callbacks()
@@ -77,8 +75,7 @@ class AgentEvaluator:
         )
 
     def _handle_task_completed(self, source: Any, event: TaskCompletedEvent) -> None:
-        if event.task is None:
-            raise ValueError("TaskCompletedEvent must have a task")
+        assert event.task is not None
         agent = event.task.agent
         if (
             agent
@@ -95,8 +92,9 @@ class AgentEvaluator:
             state.current_agent_id = str(agent.id)
             state.current_task_id = str(event.task.id)
 
-            if state.current_agent_id is None or state.current_task_id is None:
-                raise ValueError("Agent ID and Task ID must not be None")
+            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
             )
@@ -148,8 +146,9 @@ class AgentEvaluator:
             if not target_agent:
                 return
 
-            if state.current_agent_id is None or state.current_task_id is None:
-                raise ValueError("Agent ID and Task ID must not be None")
+            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
             )
@@ -245,7 +244,7 @@ class AgentEvaluator:
 
     def evaluate(
         self,
-        agent: Agent | BaseAgent,
+        agent: Agent,
         execution_trace: dict[str, Any],
         final_output: Any,
         state: ExecutionState,
@@ -256,8 +255,7 @@ class AgentEvaluator:
             task_id=state.current_task_id or (str(task.id) if task else "unknown_task"),
         )
 
-        if self.evaluators is None:
-            raise ValueError("Evaluators must be initialized")
+        assert self.evaluators is not None
         task_id = str(task.id) if task else None
         for evaluator in self.evaluators:
             try:
@@ -278,7 +276,7 @@ class AgentEvaluator:
                     metric_category=evaluator.metric_category,
                     score=score,
                 )
-            except Exception as e:  # noqa: PERF203
+            except Exception as e:
                 self.emit_evaluation_failed_event(
                     agent_role=agent.role,
                     agent_id=str(agent.id),
@@ -286,7 +284,7 @@ class AgentEvaluator:
                     error=str(e),
                 )
                 self.console_formatter.print(
-                    f"Error in {evaluator.metric_category.value} evaluator: {e!s}"
+                    f"Error in {evaluator.metric_category.value} evaluator: {str(e)}"
                 )
 
         return result
@@ -339,14 +337,14 @@ class AgentEvaluator:
         )
 
 
-def create_default_evaluator(agents: list[Agent] | list[BaseAgent], llm: None = None):
+def create_default_evaluator(agents: list[Agent], llm: None = None):
     from crewai.experimental.evaluation import (
         GoalAlignmentEvaluator,
-        ParameterExtractionEvaluator,
-        ReasoningEfficiencyEvaluator,
         SemanticQualityEvaluator,
-        ToolInvocationEvaluator,
         ToolSelectionEvaluator,
+        ParameterExtractionEvaluator,
+        ToolInvocationEvaluator,
+        ReasoningEfficiencyEvaluator,
     )
 
     evaluators = [

src/crewai/experimental/evaluation/base_evaluator.py

@@ -1,17 +1,15 @@
 import abc
 import enum
 from enum import Enum
-from typing import Any
+from typing import Any, Dict, List, Optional
 
 from pydantic import BaseModel, Field
 
 from crewai.agent import Agent
-from crewai.agents.agent_builder.base_agent import BaseAgent
-from crewai.llm import BaseLLM
 from crewai.task import Task
+from crewai.llm import BaseLLM
 from crewai.utilities.llm_utils import create_llm
 
-
 class MetricCategory(enum.Enum):
     GOAL_ALIGNMENT = "goal_alignment"
     SEMANTIC_QUALITY = "semantic_quality"
@@ -21,7 +19,7 @@ class MetricCategory(enum.Enum):
     TOOL_INVOCATION = "tool_invocation"
 
     def title(self):
-        return self.value.replace("_", " ").title()
+        return self.value.replace('_', ' ').title()
 
 
 class EvaluationScore(BaseModel):
@@ -29,13 +27,15 @@ class EvaluationScore(BaseModel):
         default=5.0,
         description="Numeric score from 0-10 where 0 is worst and 10 is best, None if not applicable",
         ge=0.0,
-        le=10.0,
+        le=10.0
     )
     feedback: str = Field(
-        default="", description="Detailed feedback explaining the evaluation score"
+        default="",
+        description="Detailed feedback explaining the evaluation score"
     )
     raw_response: str | None = Field(
-        default=None, description="Raw response from the evaluator (e.g., LLM)"
+        default=None,
+        description="Raw response from the evaluator (e.g., LLM)"
     )
 
     def __str__(self) -> str:
@@ -56,8 +56,8 @@ class BaseEvaluator(abc.ABC):
     @abc.abstractmethod
     def evaluate(
         self,
-        agent: Agent | BaseAgent,
-        execution_trace: dict[str, Any],
+        agent: Agent,
+        execution_trace: Dict[str, Any],
         final_output: Any,
         task: Task | None = None,
     ) -> EvaluationScore:
@@ -67,8 +67,9 @@ class BaseEvaluator(abc.ABC):
 class AgentEvaluationResult(BaseModel):
     agent_id: str = Field(description="ID of the evaluated agent")
     task_id: str = Field(description="ID of the task that was executed")
-    metrics: dict[MetricCategory, EvaluationScore] = Field(
-        default_factory=dict, description="Evaluation scores for each metric category"
+    metrics: Dict[MetricCategory, EvaluationScore] = Field(
+        default_factory=dict,
+        description="Evaluation scores for each metric category"
     )
 
 
@@ -80,23 +81,33 @@ class AggregationStrategy(Enum):
 
 
 class AgentAggregatedEvaluationResult(BaseModel):
-    agent_id: str = Field(default="", description="ID of the agent")
-    agent_role: str = Field(default="", description="Role of the agent")
+    agent_id: str = Field(
+        default="",
+        description="ID of the agent"
+    )
+    agent_role: str = Field(
+        default="",
+        description="Role of the agent"
+    )
     task_count: int = Field(
-        default=0, description="Number of tasks included in this aggregation"
+        default=0,
+        description="Number of tasks included in this aggregation"
     )
     aggregation_strategy: AggregationStrategy = Field(
         default=AggregationStrategy.SIMPLE_AVERAGE,
-        description="Strategy used for aggregation",
+        description="Strategy used for aggregation"
     )
-    metrics: dict[MetricCategory, EvaluationScore] = Field(
-        default_factory=dict, description="Aggregated metrics across all tasks"
+    metrics: Dict[MetricCategory, EvaluationScore] = Field(
+        default_factory=dict,
+        description="Aggregated metrics across all tasks"
     )
-    task_results: list[str] = Field(
-        default_factory=list, description="IDs of tasks included in this aggregation"
+    task_results: List[str] = Field(
+        default_factory=list,
+        description="IDs of tasks included in this aggregation"
     )
-    overall_score: float | None = Field(
-        default=None, description="Overall score for this agent"
+    overall_score: Optional[float] = Field(
+        default=None,
+        description="Overall score for this agent"
     )
 
     def __str__(self) -> str:
@@ -108,7 +119,7 @@ class AgentAggregatedEvaluationResult(BaseModel):
             result += f"\n\n- {category.value.upper()}: {score.score}/10\n"
 
             if score.feedback:
-                detailed_feedback = "\n  ".join(score.feedback.split("\n"))
+                detailed_feedback = "\n  ".join(score.feedback.split('\n'))
                 result += f"  {detailed_feedback}\n"
 
-        return result
+        return result

src/crewai/experimental/evaluation/evaluation_display.py

@@ -1,18 +1,16 @@
 from collections import defaultdict
-from collections.abc import Sequence
-from typing import Any
-
-from rich.box import HEAVY_EDGE, ROUNDED
+from typing import Dict, Any, List
 from rich.table import Table
-
-from crewai.events.utils.console_formatter import ConsoleFormatter
+from rich.box import HEAVY_EDGE, ROUNDED
+from collections.abc import Sequence
 from crewai.experimental.evaluation.base_evaluator import (
     AgentAggregatedEvaluationResult,
-    AgentEvaluationResult,
     AggregationStrategy,
-    EvaluationScore,
+    AgentEvaluationResult,
     MetricCategory,
 )
+from crewai.experimental.evaluation import EvaluationScore
+from crewai.events.utils.console_formatter import ConsoleFormatter
 from crewai.utilities.llm_utils import create_llm
 
 
@@ -21,7 +19,7 @@ class EvaluationDisplayFormatter:
         self.console_formatter = ConsoleFormatter()
 
     def display_evaluation_with_feedback(
-        self, iterations_results: dict[int, dict[str, list[Any]]]
+        self, iterations_results: Dict[int, Dict[str, List[Any]]]
     ):
         if not iterations_results:
             self.console_formatter.print(
@@ -101,7 +99,7 @@ class EvaluationDisplayFormatter:
 
     def display_summary_results(
         self,
-        iterations_results: dict[int, dict[str, list[AgentEvaluationResult]]],
+        iterations_results: Dict[int, Dict[str, List[AgentAggregatedEvaluationResult]]],
     ):
         if not iterations_results:
             self.console_formatter.print(
@@ -282,7 +280,7 @@ class EvaluationDisplayFormatter:
                     feedback_summary = feedbacks[0]
 
             aggregated_metrics[category] = EvaluationScore(
-                score=avg_score, feedback=feedback_summary or ""
+                score=avg_score, feedback=feedback_summary
             )
 
         overall_score = None
@@ -306,25 +304,25 @@ class EvaluationDisplayFormatter:
         self,
         agent_role: str,
         metric: str,
-        feedbacks: list[str],
-        scores: list[float | None],
+        feedbacks: List[str],
+        scores: List[float | None],
         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)]
+                [f"Feedback {i+1}: {fb}" for i, fb in enumerate(feedbacks)]
             )
 
         try:
             llm = create_llm()
 
             formatted_feedbacks = []
-            for i, (feedback, score) in enumerate(zip(feedbacks, scores, strict=False)):
+            for i, (feedback, score) in enumerate(zip(feedbacks, scores)):
                 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}"
+                    f"Feedback #{i+1} (Score: {score_text}):\n{feedback}"
                 )
 
             all_feedbacks = "\n\n" + "\n\n---\n\n".join(formatted_feedbacks)
@@ -367,9 +365,10 @@ class EvaluationDisplayFormatter:
                 """,
                 },
             ]
-            if llm is None:
-                raise ValueError("LLM must be initialized")
-            return llm.call(prompt)
+            assert llm is not None
+            response = llm.call(prompt)
+
+            return response
 
         except Exception:
             return "Synthesized from multiple tasks: " + "\n\n".join(

src/crewai/experimental/evaluation/evaluation_listener.py

@@ -1,25 +1,26 @@
-from collections.abc import Sequence
 from datetime import datetime
-from typing import Any
+from typing import Any, Dict, Optional
 
-from crewai.agents.agent_builder.base_agent import BaseAgent
+from collections.abc import Sequence
+
+from crewai.agent import Agent
+from crewai.task import Task
 from crewai.events.base_event_listener import BaseEventListener
 from crewai.events.event_bus import CrewAIEventsBus
 from crewai.events.types.agent_events import (
-    AgentExecutionCompletedEvent,
     AgentExecutionStartedEvent,
-    LiteAgentExecutionCompletedEvent,
+    AgentExecutionCompletedEvent,
     LiteAgentExecutionStartedEvent,
+    LiteAgentExecutionCompletedEvent,
 )
-from crewai.events.types.llm_events import LLMCallCompletedEvent, LLMCallStartedEvent
 from crewai.events.types.tool_usage_events import (
+    ToolUsageFinishedEvent,
+    ToolUsageErrorEvent,
     ToolExecutionErrorEvent,
     ToolSelectionErrorEvent,
-    ToolUsageErrorEvent,
-    ToolUsageFinishedEvent,
     ToolValidateInputErrorEvent,
 )
-from crewai.task import Task
+from crewai.events.types.llm_events import LLMCallStartedEvent, LLMCallCompletedEvent
 
 
 class EvaluationTraceCallback(BaseEventListener):
@@ -135,7 +136,7 @@ class EvaluationTraceCallback(BaseEventListener):
     def _init_trace(self, trace_key: str, **kwargs: Any):
         self.traces[trace_key] = kwargs
 
-    def on_agent_start(self, agent: BaseAgent, task: Task):
+    def on_agent_start(self, agent: Agent, task: Task):
         self.current_agent_id = agent.id
         self.current_task_id = task.id
 
@@ -150,7 +151,7 @@ class EvaluationTraceCallback(BaseEventListener):
             final_output=None,
         )
 
-    def on_agent_finish(self, agent: BaseAgent, task: Task, output: Any):
+    def on_agent_finish(self, agent: Agent, task: Task, output: Any):
         trace_key = f"{agent.id}_{task.id}"
         if trace_key in self.traces:
             self.traces[trace_key]["final_output"] = output
@@ -252,7 +253,7 @@ class EvaluationTraceCallback(BaseEventListener):
         if hasattr(self, "current_llm_call"):
             self.current_llm_call = {}
 
-    def get_trace(self, agent_id: str, task_id: str) -> dict[str, Any] | None:
+    def get_trace(self, agent_id: str, task_id: str) -> Optional[Dict[str, Any]]:
         trace_key = f"{agent_id}_{task_id}"
         return self.traces.get(trace_key)
 

src/crewai/experimental/evaluation/experiment/__init__.py

@@ -1,7 +1,8 @@
-from crewai.experimental.evaluation.experiment.result import (
-    ExperimentResult,
-    ExperimentResults,
-)
 from crewai.experimental.evaluation.experiment.runner import ExperimentRunner
+from crewai.experimental.evaluation.experiment.result import ExperimentResults, ExperimentResult
 
-__all__ = ["ExperimentResult", "ExperimentResults", "ExperimentRunner"]
+__all__ = [
+    "ExperimentRunner",
+    "ExperimentResults",
+    "ExperimentResult"
+]