more cassettes

* Improved the test for cache hitting between agents by filtering mock calls to ensure they include the expected 'tool' and 'input' keywords.
* Added assertions to verify the number of cache calls and their expected arguments, enhancing the reliability of the test.
* Cleaned up whitespace and improved readability in various test cases for better maintainability.

.github/workflows/tests.yml

@@ -7,18 +7,14 @@ permissions:
 
 env:
   OPENAI_API_KEY: fake-api-key
-  PYTHONUNBUFFERED: 1
 
 jobs:
   tests:
-    name: tests (${{ matrix.python-version }})
     runs-on: ubuntu-latest
     timeout-minutes: 15
     strategy:
-      fail-fast: true
       matrix:
         python-version: ['3.10', '3.11', '3.12', '3.13']
-        group: [1, 2, 3, 4, 5, 6, 7, 8]
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -27,9 +23,6 @@ jobs:
         uses: astral-sh/setup-uv@v3
         with:
           enable-cache: true
-          cache-dependency-glob: |
-            **/pyproject.toml
-            **/uv.lock
 
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
@@ -37,30 +30,5 @@ jobs:
       - name: Install the project
         run: uv sync --dev --all-extras
 
-      - name: Install SQLite with FTS5 support
-        run: |
-          # WORKAROUND: GitHub Actions' Ubuntu runner uses SQLite without FTS5 support compiled in.
-          # This is a temporary fix until the runner includes SQLite with FTS5 or Python's sqlite3
-          # module is compiled with FTS5 support by default.
-          # TODO: Remove this workaround once GitHub Actions runners include SQLite FTS5 support
-          
-          # Install pysqlite3-binary which has FTS5 support
-          uv pip install pysqlite3-binary
-          # Create a sitecustomize.py to override sqlite3 with pysqlite3
-          mkdir -p .pytest_sqlite_override
-          echo "import sys; import pysqlite3; sys.modules['sqlite3'] = pysqlite3" > .pytest_sqlite_override/sitecustomize.py
-          # Test FTS5 availability
-          PYTHONPATH=.pytest_sqlite_override uv run python -c "import sqlite3; print(f'SQLite version: {sqlite3.sqlite_version}')"
-          PYTHONPATH=.pytest_sqlite_override uv run python -c "import sqlite3; conn = sqlite3.connect(':memory:'); conn.execute('CREATE VIRTUAL TABLE test USING fts5(content)'); print('FTS5 module available')"
-
-      - name: Run tests (group ${{ matrix.group }} of 8)
-        run: |
-          PYTHONPATH=.pytest_sqlite_override uv run pytest \
-            --block-network \
-            --timeout=30 \
-            -vv \
-            --splits 8 \
-            --group ${{ matrix.group }} \
-            --durations=10 \
-            -n auto \
-            --maxfail=3
+      - name: Run tests
+        run: uv run pytest --block-network --timeout=60 -vv

docs/docs.json

@@ -94,7 +94,7 @@
                     "pages": [
                       "en/guides/advanced/customizing-prompts",
                       "en/guides/advanced/fingerprinting"
-
+                 
                     ]
                   }
                 ]
@@ -296,8 +296,7 @@
                   "en/enterprise/features/webhook-streaming",
                   "en/enterprise/features/traces",
                   "en/enterprise/features/hallucination-guardrail",
-                  "en/enterprise/features/integrations",
-                  "en/enterprise/features/agent-repositories"
+                  "en/enterprise/features/integrations"
                 ]
               },
               {
@@ -374,7 +373,7 @@
               }
             ]
           }
-
+ 
         ]
       },
       {
@@ -731,7 +730,7 @@
               }
             ]
           }
-
+ 
         ]
       }
     ]
@@ -775,7 +774,7 @@
       "destination": "/en/introduction"
     },
     {
-      "source": "/installation",
+      "source": "/installation", 
       "destination": "/en/installation"
     },
     {

docs/en/concepts/agents.mdx

@@ -526,103 +526,6 @@ agent = Agent(
 The context window management feature works automatically in the background. You don't need to call any special functions - just set `respect_context_window` to your preferred behavior and CrewAI handles the rest!
 </Note>
 
-## Direct Agent Interaction with `kickoff()`
-
-Agents can be used directly without going through a task or crew workflow using the `kickoff()` method. This provides a simpler way to interact with an agent when you don't need the full crew orchestration capabilities.
-
-### How `kickoff()` Works
-
-The `kickoff()` method allows you to send messages directly to an agent and get a response, similar to how you would interact with an LLM but with all the agent's capabilities (tools, reasoning, etc.).
-
-```python Code
-from crewai import Agent
-from crewai_tools import SerperDevTool
-
-# Create an agent
-researcher = Agent(
-    role="AI Technology Researcher",
-    goal="Research the latest AI developments",
-    tools=[SerperDevTool()],
-    verbose=True
-)
-
-# Use kickoff() to interact directly with the agent
-result = researcher.kickoff("What are the latest developments in language models?")
-
-# Access the raw response
-print(result.raw)
-```
-
-### Parameters and Return Values
-
-| Parameter         | Type                                | Description                                                               |
-| :---------------- | :---------------------------------- | :------------------------------------------------------------------------ |
-| `messages`        | `Union[str, List[Dict[str, str]]]`  | Either a string query or a list of message dictionaries with role/content |
-| `response_format` | `Optional[Type[Any]]`               | Optional Pydantic model for structured output                             |
-
-The method returns a `LiteAgentOutput` object with the following properties:
-
-- `raw`: String containing the raw output text
-- `pydantic`: Parsed Pydantic model (if a `response_format` was provided)
-- `agent_role`: Role of the agent that produced the output
-- `usage_metrics`: Token usage metrics for the execution
-
-### Structured Output
-
-You can get structured output by providing a Pydantic model as the `response_format`:
-
-```python Code
-from pydantic import BaseModel
-from typing import List
-
-class ResearchFindings(BaseModel):
-    main_points: List[str]
-    key_technologies: List[str]
-    future_predictions: str
-
-# Get structured output
-result = researcher.kickoff(
-    "Summarize the latest developments in AI for 2025",
-    response_format=ResearchFindings
-)
-
-# Access structured data
-print(result.pydantic.main_points)
-print(result.pydantic.future_predictions)
-```
-
-### Multiple Messages
-
-You can also provide a conversation history as a list of message dictionaries:
-
-```python Code
-messages = [
-    {"role": "user", "content": "I need information about large language models"},
-    {"role": "assistant", "content": "I'd be happy to help with that! What specifically would you like to know?"},
-    {"role": "user", "content": "What are the latest developments in 2025?"}
-]
-
-result = researcher.kickoff(messages)
-```
-
-### Async Support
-
-An asynchronous version is available via `kickoff_async()` with the same parameters:
-
-```python Code
-import asyncio
-
-async def main():
-    result = await researcher.kickoff_async("What are the latest developments in AI?")
-    print(result.raw)
-
-asyncio.run(main())
-```
-
-<Note>
-The `kickoff()` method uses a `LiteAgent` internally, which provides a simpler execution flow while preserving all of the agent's configuration (role, goal, backstory, tools, etc.).
-</Note>
-
 ## Important Considerations and Best Practices
 
 ### Security and Code Execution

docs/en/concepts/crews.mdx

@@ -32,7 +32,6 @@ A crew in crewAI represents a collaborative group of agents working together to
 | **Prompt File** _(optional)_          | `prompt_file`          | Path to the prompt JSON file to be used for the crew.                                                                                                                                                                                                     |
 | **Planning** *(optional)*             | `planning`             | Adds planning ability to the Crew. When activated before each Crew iteration, all Crew data is sent to an AgentPlanner that will plan the tasks and this plan will be added to each task description.                                                     |
 | **Planning LLM** *(optional)*         | `planning_llm`         | The language model used by the AgentPlanner in a planning process.                                                                                                                                                                                        |
-| **Knowledge Sources** _(optional)_    | `knowledge_sources`    | Knowledge sources available at the crew level, accessible to all the agents.                                                                                                                                                                                    |
 
 <Tip>
 **Crew Max RPM**: The `max_rpm` attribute sets the maximum number of requests per minute the crew can perform to avoid rate limits and will override individual agents' `max_rpm` settings if you set it.

docs/en/concepts/tasks.mdx

@@ -57,7 +57,6 @@ crew = Crew(
 | **Output JSON** _(optional)_     | `output_json`     | `Optional[Type[BaseModel]]`   | A Pydantic model to structure the JSON output.                                                                       |
 | **Output Pydantic** _(optional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`   | A Pydantic model for task output.                                                                                    |
 | **Callback** _(optional)_        | `callback`        | `Optional[Any]`               | Function/object to be executed after task completion.                                                                |
-| **Guardrail** _(optional)_       | `guardrail`       | `Optional[Union[Callable, str]]` | Function or string description to validate task output before proceeding to next task.                            |
 
 ## Creating Tasks
 
@@ -87,7 +86,6 @@ research_task:
   expected_output: >
     A list with 10 bullet points of the most relevant information about {topic}
   agent: researcher
-  guardrail: ensure each bullet contains a minimum of 100 words
 
 reporting_task:
   description: >
@@ -334,13 +332,9 @@ Task guardrails provide a way to validate and transform task outputs before they
 are passed to the next task. This feature helps ensure data quality and provides
 feedback to agents when their output doesn't meet specific criteria.
 
-**Guardrails can be defined in two ways:**
-1. **Function-based guardrails**: Python functions that implement custom validation logic
-2. **String-based guardrails**: Natural language descriptions that are automatically converted to LLM-powered validation
+### Using Task Guardrails
 
-### Function-Based Guardrails
-
-To add a function-based guardrail to a task, provide a validation function through the `guardrail` parameter:
+To add a guardrail to a task, provide a validation function through the `guardrail` parameter:
 
 ```python Code
 from typing import Tuple, Union, Dict, Any
@@ -378,82 +372,9 @@ blog_task = Task(
    - On success: it returns a tuple of `(bool, Any)`. For example: `(True, validated_result)`
    - On Failure: it returns a tuple of `(bool, str)`. For example: `(False, "Error message explain the failure")`
 
-### String-Based Guardrails
+### LLMGuardrail
 
-String-based guardrails allow you to describe validation criteria in natural language. When you provide a string instead of a function, CrewAI automatically converts it to an `LLMGuardrail` that uses an AI agent to validate the task output.
-
-#### Using String Guardrails in Python
-
-```python Code
-from crewai import Task
-
-# Simple string-based guardrail
-blog_task = Task(
-    description="Write a blog post about AI",
-    expected_output="A blog post under 200 words",
-    agent=blog_agent,
-    guardrail="Ensure the blog post is under 200 words and includes practical examples"
-)
-
-# More complex validation criteria
-research_task = Task(
-    description="Research AI trends for 2025",
-    expected_output="A comprehensive research report",
-    agent=research_agent,
-    guardrail="Ensure each finding includes a credible source and is backed by recent data from 2024-2025"
-)
-```
-
-#### Using String Guardrails in YAML
-
-```yaml
-research_task:
-  description: Research the latest AI developments
-  expected_output: A list of 10 bullet points about AI
-  agent: researcher
-  guardrail: ensure each bullet contains a minimum of 100 words
-
-validation_task:
-  description: Validate the research findings
-  expected_output: A validation report
-  agent: validator
-  guardrail: confirm all sources are from reputable publications and published within the last 2 years
-```
-
-#### How String Guardrails Work
-
-When you provide a string guardrail, CrewAI automatically:
-1. Creates an `LLMGuardrail` instance using the string as validation criteria
-2. Uses the task's agent LLM to power the validation
-3. Creates a temporary validation agent that checks the output against your criteria
-4. Returns detailed feedback if validation fails
-
-This approach is ideal when you want to use natural language to describe validation rules without writing custom validation functions.
-
-### LLMGuardrail Class
-
-The `LLMGuardrail` class is the underlying mechanism that powers string-based guardrails. You can also use it directly for more advanced control:
-
-```python Code
-from crewai import Task
-from crewai.tasks.llm_guardrail import LLMGuardrail
-from crewai.llm import LLM
-
-# Create a custom LLMGuardrail with specific LLM
-custom_guardrail = LLMGuardrail(
-    description="Ensure the response contains exactly 5 bullet points with proper citations",
-    llm=LLM(model="gpt-4o-mini")
-)
-
-task = Task(
-    description="Research AI safety measures",
-    expected_output="A detailed analysis with bullet points",
-    agent=research_agent,
-    guardrail=custom_guardrail
-)
-```
-
-**Note**: When you use a string guardrail, CrewAI automatically creates an `LLMGuardrail` instance using your task's agent LLM. Using `LLMGuardrail` directly gives you more control over the validation process and LLM selection.
+The `LLMGuardrail` class offers a robust mechanism for validating task outputs.
 
 ### Error Handling Best Practices
 
@@ -877,7 +798,166 @@ While creating and executing tasks, certain validation mechanisms are in place t
 
 These validations help in maintaining the consistency and reliability of task executions within the crewAI framework.
 
+## Task Guardrails
 
+Task guardrails provide a powerful way to validate, transform, or filter task outputs before they are passed to the next task. Guardrails are optional functions that execute before the next task starts, allowing you to ensure that task outputs meet specific requirements or formats.
+
+### Basic Usage
+
+#### Define your own logic to validate
+
+```python Code
+from typing import Tuple, Union
+from crewai import Task
+
+def validate_json_output(result: str) -> Tuple[bool, Union[dict, str]]:
+    """Validate that the output is valid JSON."""
+    try:
+        json_data = json.loads(result)
+        return (True, json_data)
+    except json.JSONDecodeError:
+        return (False, "Output must be valid JSON")
+
+task = Task(
+    description="Generate JSON data",
+    expected_output="Valid JSON object",
+    guardrail=validate_json_output
+)
+```
+
+#### Leverage a no-code approach for validation
+
+```python Code
+from crewai import Task
+
+task = Task(
+    description="Generate JSON data",
+    expected_output="Valid JSON object",
+    guardrail="Ensure the response is a valid JSON object"
+)
+```
+
+#### Using YAML
+
+```yaml
+research_task:
+  ...
+  guardrail: make sure each bullet contains a minimum of 100 words
+  ...
+```
+
+```python Code
+@CrewBase
+class InternalCrew:
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    ...
+    @task
+    def research_task(self):
+        return Task(config=self.tasks_config["research_task"])  # type: ignore[index]
+    ...
+```
+
+
+#### Use custom models for code generation
+
+```python Code
+from crewai import Task
+from crewai.llm import LLM
+
+task = Task(
+    description="Generate JSON data",
+    expected_output="Valid JSON object",
+    guardrail=LLMGuardrail(
+        description="Ensure the response is a valid JSON object",
+        llm=LLM(model="gpt-4o-mini"),
+    )
+)
+```
+
+### How Guardrails Work
+
+1. **Optional Attribute**: Guardrails are an optional attribute at the task level, allowing you to add validation only where needed.
+2. **Execution Timing**: The guardrail function is executed before the next task starts, ensuring valid data flow between tasks.
+3. **Return Format**: Guardrails must return a tuple of `(success, data)`:
+   - If `success` is `True`, `data` is the validated/transformed result
+   - If `success` is `False`, `data` is the error message
+4. **Result Routing**:
+   - On success (`True`), the result is automatically passed to the next task
+   - On failure (`False`), the error is sent back to the agent to generate a new answer
+
+### Common Use Cases
+
+#### Data Format Validation
+```python Code
+def validate_email_format(result: str) -> Tuple[bool, Union[str, str]]:
+    """Ensure the output contains a valid email address."""
+    import re
+    email_pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
+    if re.match(email_pattern, result.strip()):
+        return (True, result.strip())
+    return (False, "Output must be a valid email address")
+```
+
+#### Content Filtering
+```python Code
+def filter_sensitive_info(result: str) -> Tuple[bool, Union[str, str]]:
+    """Remove or validate sensitive information."""
+    sensitive_patterns = ['SSN:', 'password:', 'secret:']
+    for pattern in sensitive_patterns:
+        if pattern.lower() in result.lower():
+            return (False, f"Output contains sensitive information ({pattern})")
+    return (True, result)
+```
+
+#### Data Transformation
+```python Code
+def normalize_phone_number(result: str) -> Tuple[bool, Union[str, str]]:
+    """Ensure phone numbers are in a consistent format."""
+    import re
+    digits = re.sub(r'\D', '', result)
+    if len(digits) == 10:
+        formatted = f"({digits[:3]}) {digits[3:6]}-{digits[6:]}"
+        return (True, formatted)
+    return (False, "Output must be a 10-digit phone number")
+```
+
+### Advanced Features
+
+#### Chaining Multiple Validations
+```python Code
+def chain_validations(*validators):
+    """Chain multiple validators together."""
+    def combined_validator(result):
+        for validator in validators:
+            success, data = validator(result)
+            if not success:
+                return (False, data)
+            result = data
+        return (True, result)
+    return combined_validator
+
+# Usage
+task = Task(
+    description="Get user contact info",
+    expected_output="Email and phone",
+    guardrail=chain_validations(
+        validate_email_format,
+        filter_sensitive_info
+    )
+)
+```
+
+#### Custom Retry Logic
+```python Code
+task = Task(
+    description="Generate data",
+    expected_output="Valid data",
+    guardrail=validate_data,
+    max_retries=5  # Override default retry limit
+)
+```
 
 ## Creating Directories when Saving Files
 

docs/en/enterprise/features/agent-repositories.mdx

@@ -1,155 +0,0 @@
----
-title: 'Agent Repositories'
-description: 'Learn how to use Agent Repositories to share and reuse your agents across teams and projects'
-icon: 'database'
----
-
-Agent Repositories allow enterprise users to store, share, and reuse agent definitions across teams and projects. This feature enables organizations to maintain a centralized library of standardized agents, promoting consistency and reducing duplication of effort.
-
-## Benefits of Agent Repositories
-
-- **Standardization**: Maintain consistent agent definitions across your organization
-- **Reusability**: Create an agent once and use it in multiple crews and projects
-- **Governance**: Implement organization-wide policies for agent configurations
-- **Collaboration**: Enable teams to share and build upon each other's work
-
-## Using Agent Repositories
-
-### Prerequisites
-
-1. You must have an account at CrewAI, try the [free plan](https://app.crewai.com).
-2. You need to be authenticated using the CrewAI CLI.
-3. If you have more than one organization, make sure you are switched to the correct organization using the CLI command:
-
-```bash
-crewai org switch <org_id>
-```
-
-### Creating and Managing Agents in Repositories
-
-To create and manage agents in repositories,Enterprise Dashboard.
-
-### Loading Agents from Repositories
-
-You can load agents from repositories in your code using the `from_repository` parameter:
-
-```python
-from crewai import Agent
-
-# Create an agent by loading it from a repository
-# The agent is loaded with all its predefined configurations
-researcher = Agent(
-    from_repository="market-research-agent"
-)
-
-```
-
-### Overriding Repository Settings
-
-You can override specific settings from the repository by providing them in the configuration:
-
-```python
-researcher = Agent(
-    from_repository="market-research-agent",
-    goal="Research the latest trends in AI development",  # Override the repository goal
-    verbose=True  # Add a setting not in the repository
-)
-```
-
-### Example: Creating a Crew with Repository Agents
-
-```python
-from crewai import Crew, Agent, Task
-
-# Load agents from repositories
-researcher = Agent(
-    from_repository="market-research-agent"
-)
-
-writer = Agent(
-    from_repository="content-writer-agent"
-)
-
-# Create tasks
-research_task = Task(
-    description="Research the latest trends in AI",
-    agent=researcher
-)
-
-writing_task = Task(
-    description="Write a comprehensive report based on the research",
-    agent=writer
-)
-
-# Create the crew
-crew = Crew(
-    agents=[researcher, writer],
-    tasks=[research_task, writing_task],
-    verbose=True
-)
-
-# Run the crew
-result = crew.kickoff()
-```
-
-### Example: Using `kickoff()` with Repository Agents
-
-You can also use repository agents directly with the `kickoff()` method for simpler interactions:
-
-```python
-from crewai import Agent
-from pydantic import BaseModel
-from typing import List
-
-# Define a structured output format
-class MarketAnalysis(BaseModel):
-    key_trends: List[str]
-    opportunities: List[str]
-    recommendation: str
-
-# Load an agent from repository
-analyst = Agent(
-    from_repository="market-analyst-agent",
-    verbose=True
-)
-
-# Get a free-form response
-result = analyst.kickoff("Analyze the AI market in 2025")
-print(result.raw)  # Access the raw response
-
-# Get structured output
-structured_result = analyst.kickoff(
-    "Provide a structured analysis of the AI market in 2025",
-    response_format=MarketAnalysis
-)
-
-# Access structured data
-print(f"Key Trends: {structured_result.pydantic.key_trends}")
-print(f"Recommendation: {structured_result.pydantic.recommendation}")
-```
-
-## Best Practices
-
-1. **Naming Convention**: Use clear, descriptive names for your repository agents
-2. **Documentation**: Include comprehensive descriptions for each agent
-3. **Tool Management**: Ensure that tools referenced by repository agents are available in your environment
-4. **Access Control**: Manage permissions to ensure only authorized team members can modify repository agents
-
-## Organization Management
-
-To switch between organizations or see your current organization, use the CrewAI CLI:
-
-```bash
-# View current organization
-crewai org current
-
-# Switch to a different organization
-crewai org switch <org_id>
-
-# List all available organizations
-crewai org list
-```
-
-<Note>
-When loading agents from repositories, you must be authenticated and switched to the correct organization. If you receive errors, check your authentication status and organization settings using the CLI commands above.
-</Note>

docs/pt-BR/concepts/cli.mdx

@@ -76,7 +76,6 @@ Exemplo:
 crewai train -n 10 -f my_training_data.pkl
 ```
 
-```python
 # Exemplo de uso programático do comando train
 n_iterations = 2
 inputs = {"topic": "Treinamento CrewAI"}
@@ -90,7 +89,6 @@ try:
     )
 except Exception as e:
     raise Exception(f"Ocorreu um erro ao treinar a crew: {e}")
-```
 
 ### 4. Replay
 

docs/pt-BR/concepts/tasks.mdx

@@ -57,7 +57,6 @@ crew = Crew(
 | **Saída JSON** _(opcional)_      | `output_json`     | `Optional[Type[BaseModel]]`  | Um modelo Pydantic para estruturar a saída em JSON.                                                                |
 | **Output Pydantic** _(opcional)_ | `output_pydantic` | `Optional[Type[BaseModel]]`  | Um modelo Pydantic para a saída da tarefa.                                                                         |
 | **Callback** _(opcional)_        | `callback`        | `Optional[Any]`              | Função/objeto a ser executado após a conclusão da tarefa.                                                          |
-| **Guardrail** _(opcional)_       | `guardrail`       | `Optional[Union[Callable, str]]` | Função ou descrição em string para validar a saída da tarefa antes de prosseguir para a próxima tarefa.        |
 
 ## Criando Tarefas
 
@@ -87,7 +86,6 @@ research_task:
   expected_output: >
     Uma lista com 10 tópicos em bullet points das informações mais relevantes sobre {topic}
   agent: researcher
-  guardrail: garanta que cada bullet point contenha no mínimo 100 palavras
 
 reporting_task:
   description: >
@@ -332,13 +330,9 @@ analysis_task = Task(
 
 Guardrails (trilhas de proteção) de tarefas fornecem uma maneira de validar e transformar as saídas das tarefas antes que elas sejam passadas para a próxima tarefa. Esse recurso assegura a qualidade dos dados e oferece feedback aos agentes quando sua saída não atende a critérios específicos.
 
-**Guardrails podem ser definidos de duas maneiras:**
-1. **Guardrails baseados em função**: Funções Python que implementam lógica de validação customizada
-2. **Guardrails baseados em string**: Descrições em linguagem natural que são automaticamente convertidas em validação baseada em LLM
+### Usando Guardrails em Tarefas
 
-### Guardrails Baseados em Função
-
-Para adicionar um guardrail baseado em função a uma tarefa, forneça uma função de validação por meio do parâmetro `guardrail`:
+Para adicionar um guardrail a uma tarefa, forneça uma função de validação por meio do parâmetro `guardrail`:
 
 ```python Code
 from typing import Tuple, Union, Dict, Any
@@ -376,82 +370,9 @@ blog_task = Task(
    - Em caso de sucesso: retorna uma tupla `(True, resultado_validado)`
    - Em caso de falha: retorna uma tupla `(False, "mensagem de erro explicando a falha")`
 
-### Guardrails Baseados em String
+### LLMGuardrail
 
-Guardrails baseados em string permitem que você descreva critérios de validação em linguagem natural. Quando você fornece uma string em vez de uma função, o CrewAI automaticamente a converte em um `LLMGuardrail` que usa um agente de IA para validar a saída da tarefa.
-
-#### Usando Guardrails de String em Python
-
-```python Code
-from crewai import Task
-
-# Guardrail simples baseado em string
-blog_task = Task(
-    description="Escreva um post de blog sobre IA",
-    expected_output="Um post de blog com menos de 200 palavras",
-    agent=blog_agent,
-    guardrail="Garanta que o post do blog tenha menos de 200 palavras e inclua exemplos práticos"
-)
-
-# Critérios de validação mais complexos
-research_task = Task(
-    description="Pesquise tendências de IA para 2025",
-    expected_output="Um relatório abrangente de pesquisa",
-    agent=research_agent,
-    guardrail="Garanta que cada descoberta inclua uma fonte confiável e seja respaldada por dados recentes de 2024-2025"
-)
-```
-
-#### Usando Guardrails de String em YAML
-
-```yaml
-research_task:
-  description: Pesquise os últimos desenvolvimentos em IA
-  expected_output: Uma lista de 10 bullet points sobre IA
-  agent: researcher
-  guardrail: garanta que cada bullet point contenha no mínimo 100 palavras
-
-validation_task:
-  description: Valide os achados da pesquisa
-  expected_output: Um relatório de validação
-  agent: validator
-  guardrail: confirme que todas as fontes são de publicações respeitáveis e publicadas nos últimos 2 anos
-```
-
-#### Como Funcionam os Guardrails de String
-
-Quando você fornece um guardrail de string, o CrewAI automaticamente:
-1. Cria uma instância `LLMGuardrail` usando a string como critério de validação
-2. Usa o LLM do agente da tarefa para alimentar a validação
-3. Cria um agente temporário de validação que verifica a saída contra seus critérios
-4. Retorna feedback detalhado se a validação falhar
-
-Esta abordagem é ideal quando você quer usar linguagem natural para descrever regras de validação sem escrever funções de validação customizadas.
-
-### Classe LLMGuardrail
-
-A classe `LLMGuardrail` é o mecanismo subjacente que alimenta os guardrails baseados em string. Você também pode usá-la diretamente para maior controle avançado:
-
-```python Code
-from crewai import Task
-from crewai.tasks.llm_guardrail import LLMGuardrail
-from crewai.llm import LLM
-
-# Crie um LLMGuardrail customizado com LLM específico
-custom_guardrail = LLMGuardrail(
-    description="Garanta que a resposta contenha exatamente 5 bullet points com citações adequadas",
-    llm=LLM(model="gpt-4o-mini")
-)
-
-task = Task(
-    description="Pesquise medidas de segurança em IA",
-    expected_output="Uma análise detalhada com bullet points",
-    agent=research_agent,
-    guardrail=custom_guardrail
-)
-```
-
-**Nota**: Quando você usa um guardrail de string, o CrewAI automaticamente cria uma instância `LLMGuardrail` usando o LLM do agente da sua tarefa. Usar `LLMGuardrail` diretamente lhe dá mais controle sobre o processo de validação e seleção de LLM.
+A classe `LLMGuardrail` oferece um mecanismo robusto para validação das saídas das tarefas.
 
 ### Melhores Práticas de Tratamento de Erros
 

pyproject.toml

@@ -47,7 +47,7 @@ Documentation = "https://docs.crewai.com"
 Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
-tools = ["crewai-tools~=0.51.0"]
+tools = ["crewai-tools~=0.49.0"]
 embeddings = [
     "tiktoken~=0.8.0"
 ]
@@ -83,8 +83,6 @@ dev-dependencies = [
     "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",
 ]
 
 [project.scripts]

src/crewai/__init__.py

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

src/crewai/agent.py

@@ -210,6 +210,7 @@ class Agent(BaseAgent):
                         sources=self.knowledge_sources,
                         embedder=self.embedder,
                         collection_name=self.role,
+                        storage=self.knowledge_storage or None,
                     )
                     self.knowledge.add_sources()
         except (TypeError, ValueError) as e:
@@ -340,8 +341,7 @@ class Agent(BaseAgent):
             self.knowledge_config.model_dump() if self.knowledge_config else {}
         )
 
-
-        if self.knowledge or (self.crew and self.crew.knowledge):
+        if self.knowledge:
             crewai_event_bus.emit(
                 self,
                 event=KnowledgeRetrievalStartedEvent(
@@ -353,28 +353,25 @@ class Agent(BaseAgent):
                     task_prompt
                 )
                 if self.knowledge_search_query:
-                    # Quering agent specific knowledge
-                    if self.knowledge:
-                        agent_knowledge_snippets = self.knowledge.query(
-                            [self.knowledge_search_query], **knowledge_config
-                        )
-                        if agent_knowledge_snippets:
-                            self.agent_knowledge_context = extract_knowledge_context(
-                                agent_knowledge_snippets
-                            )
-                            if self.agent_knowledge_context:
-                                task_prompt += self.agent_knowledge_context
-
-                    # Quering crew specific knowledge
-                    knowledge_snippets = self.crew.query_knowledge(
+                    agent_knowledge_snippets = self.knowledge.query(
                         [self.knowledge_search_query], **knowledge_config
                     )
-                    if knowledge_snippets:
-                        self.crew_knowledge_context = extract_knowledge_context(
-                            knowledge_snippets
+                    if agent_knowledge_snippets:
+                        self.agent_knowledge_context = extract_knowledge_context(
+                            agent_knowledge_snippets
                         )
-                        if self.crew_knowledge_context:
-                            task_prompt += self.crew_knowledge_context
+                        if self.agent_knowledge_context:
+                            task_prompt += self.agent_knowledge_context
+                    if self.crew:
+                        knowledge_snippets = self.crew.query_knowledge(
+                            [self.knowledge_search_query], **knowledge_config
+                        )
+                        if knowledge_snippets:
+                            self.crew_knowledge_context = extract_knowledge_context(
+                                knowledge_snippets
+                            )
+                            if self.crew_knowledge_context:
+                                task_prompt += self.crew_knowledge_context
 
                     crewai_event_bus.emit(
                         self,

src/crewai/cli/authentication/constants.py

@@ -5,4 +5,4 @@ AUTH0_AUDIENCE = "https://crewai.us.auth0.com/api/v2/"
 
 WORKOS_DOMAIN = "login.crewai.com"
 WORKOS_CLI_CONNECT_APP_ID = "client_01JYT06R59SP0NXYGD994NFXXX"
-WORKOS_ENVIRONMENT_ID = "client_01JNJQWBJ4SPFN3SWJM5T7BDG8"
+WORKOS_ENVIRONMENT_ID = "client_01JNJQWB4HG8T5980R5VHP057C"

src/crewai/cli/authentication/utils.py

@@ -30,9 +30,6 @@ def validate_jwt_token(
         jwk_client = PyJWKClient(jwks_url)
         signing_key = jwk_client.get_signing_key_from_jwt(jwt_token)
 
-        _unverified_decoded_token = jwt.decode(
-            jwt_token, options={"verify_signature": False}
-        )
         decoded_token = jwt.decode(
             jwt_token,
             signing_key.key,
@@ -52,15 +49,9 @@ def validate_jwt_token(
     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}'"
-        )
+        raise Exception(f"Invalid token audience. Expected: '{audience}'")
     except jwt.InvalidIssuerError:
-        actual_issuer = _unverified_decoded_token.get("iss", "[no issuer found]")
-        raise Exception(
-            f"Invalid token issuer. Got: '{actual_issuer}'. Expected: '{issuer}'"
-        )
+        raise Exception(f"Invalid token issuer. Expected: '{issuer}'")
     except jwt.MissingRequiredClaimError as e:
         raise Exception(f"Token is missing required claims: {str(e)}")
     except jwt.exceptions.PyJWKClientError as e:

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

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]>=0.141.0,<1.0.0"
+    "crewai[tools]>=0.140.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.141.0,<1.0.0",
+    "crewai[tools]>=0.140.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.141.0"
+    "crewai[tools]>=0.140.0"
 ]
 
 [tool.crewai]

src/crewai/crew.py

@@ -18,11 +18,6 @@ from typing import (
     cast,
 )
 
-from opentelemetry import baggage
-from opentelemetry.context import attach, detach
-
-from crewai.utilities.crew.models import CrewContext
-
 from pydantic import (
     UUID4,
     BaseModel,
@@ -621,11 +616,6 @@ class Crew(FlowTrackable, BaseModel):
         self,
         inputs: Optional[Dict[str, Any]] = None,
     ) -> CrewOutput:
-        ctx = baggage.set_baggage(
-            "crew_context", CrewContext(id=str(self.id), key=self.key)
-        )
-        token = attach(ctx)
-
         try:
             for before_callback in self.before_kickoff_callbacks:
                 if inputs is None:
@@ -686,8 +676,6 @@ class Crew(FlowTrackable, BaseModel):
                 CrewKickoffFailedEvent(error=str(e), crew_name=self.name or "crew"),
             )
             raise
-        finally:
-            detach(token)
 
     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."""
@@ -1313,7 +1301,6 @@ class Crew(FlowTrackable, BaseModel):
         n_iterations: int,
         eval_llm: Union[str, InstanceOf[BaseLLM]],
         inputs: Optional[Dict[str, Any]] = None,
-        include_agent_eval: Optional[bool] = False
     ) -> None:
         """Test and evaluate the Crew with the given inputs for n iterations concurrently using concurrent.futures."""
         try:
@@ -1332,29 +1319,13 @@ class Crew(FlowTrackable, BaseModel):
                 ),
             )
             test_crew = self.copy()
-
-            # TODO: Refator to use a single Evaluator Manage class
             evaluator = CrewEvaluator(test_crew, llm_instance)
 
-            if include_agent_eval:
-                from crewai.experimental.evaluation import create_default_evaluator
-                agent_evaluator = create_default_evaluator(crew=test_crew)
-
             for i in range(1, n_iterations + 1):
                 evaluator.set_iteration(i)
-
-                if include_agent_eval:
-                    agent_evaluator.set_iteration(i)
-
                 test_crew.kickoff(inputs=inputs)
 
-                # TODO: Refactor to use ListenerEvents instead of trigger each iteration manually
-                if include_agent_eval:
-                    agent_evaluator.evaluate_current_iteration()
-
             evaluator.print_crew_evaluation_result()
-            if include_agent_eval:
-                agent_evaluator.get_agent_evaluation(include_evaluation_feedback=True)
 
             crewai_event_bus.emit(
                 self,

src/crewai/evaluation/__init__.py

@@ -1,53 +0,0 @@
-from crewai.evaluation.base_evaluator import (
-    BaseEvaluator,
-    EvaluationScore,
-    MetricCategory,
-    AgentEvaluationResult
-)
-
-from crewai.evaluation.metrics.semantic_quality_metrics import (
-    SemanticQualityEvaluator
-)
-
-from crewai.evaluation.metrics.goal_metrics import (
-    GoalAlignmentEvaluator
-)
-
-from crewai.evaluation.metrics.reasoning_metrics import (
-    ReasoningEfficiencyEvaluator
-)
-
-
-from crewai.evaluation.metrics.tools_metrics import (
-    ToolSelectionEvaluator,
-    ParameterExtractionEvaluator,
-    ToolInvocationEvaluator
-)
-
-from crewai.evaluation.evaluation_listener import (
-    EvaluationTraceCallback,
-    create_evaluation_callbacks
-)
-
-
-from crewai.evaluation.agent_evaluator import (
-    AgentEvaluator,
-    create_default_evaluator
-)
-
-__all__ = [
-    "BaseEvaluator",
-    "EvaluationScore",
-    "MetricCategory",
-    "AgentEvaluationResult",
-    "SemanticQualityEvaluator",
-    "GoalAlignmentEvaluator",
-    "ReasoningEfficiencyEvaluator",
-    "ToolSelectionEvaluator",
-    "ParameterExtractionEvaluator",
-    "ToolInvocationEvaluator",
-    "EvaluationTraceCallback",
-    "create_evaluation_callbacks",
-    "AgentEvaluator",
-    "create_default_evaluator"
-]

src/crewai/evaluation/agent_evaluator.py

@@ -1,178 +0,0 @@
-from crewai.evaluation.base_evaluator import AgentEvaluationResult, AggregationStrategy
-from crewai.agent import Agent
-from crewai.task import Task
-from crewai.evaluation.evaluation_display import EvaluationDisplayFormatter
-
-from typing import Any, Dict
-from collections import defaultdict
-from crewai.evaluation import BaseEvaluator, create_evaluation_callbacks
-from collections.abc import Sequence
-from crewai.crew import Crew
-from crewai.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.utils.console_formatter import ConsoleFormatter
-
-class AgentEvaluator:
-    def __init__(
-        self,
-        evaluators: Sequence[BaseEvaluator] | None = None,
-        crew: Crew | None = None,
-    ):
-        self.crew: Crew | None = crew
-        self.evaluators: Sequence[BaseEvaluator] | None = evaluators
-
-        self.agent_evaluators: dict[str, Sequence[BaseEvaluator] | None] = {}
-        if crew is not None:
-            assert crew and crew.agents is not None
-            for agent in crew.agents:
-                self.agent_evaluators[str(agent.id)] = self.evaluators
-
-        self.callback = create_evaluation_callbacks()
-        self.console_formatter = ConsoleFormatter()
-        self.display_formatter = EvaluationDisplayFormatter()
-
-        self.iteration = 1
-        self.iterations_results: dict[int, dict[str, list[AgentEvaluationResult]]] = {}
-
-    def set_iteration(self, iteration: int) -> None:
-        self.iteration = iteration
-
-    def evaluate_current_iteration(self) -> dict[str, list[AgentEvaluationResult]]:
-        if not self.crew:
-            raise ValueError("Cannot evaluate: no crew was provided to the evaluator.")
-
-        if not self.callback:
-            raise ValueError("Cannot evaluate: no callback was set. Use set_callback() method first.")
-
-        from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
-        evaluation_results: defaultdict[str, list[AgentEvaluationResult]] = defaultdict(list)
-
-        total_evals = 0
-        for agent in self.crew.agents:
-            for task in self.crew.tasks:
-                if task.agent and task.agent.id == agent.id and self.agent_evaluators.get(str(agent.id)):
-                    total_evals += 1
-
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[bold blue]{task.description}[/bold blue]"),
-            BarColumn(),
-            TextColumn("{task.percentage:.0f}% completed"),
-            console=self.console_formatter.console
-        ) as progress:
-            eval_task = progress.add_task(f"Evaluating agents (iteration {self.iteration})...", total=total_evals)
-
-            for agent in self.crew.agents:
-                evaluator = self.agent_evaluators.get(str(agent.id))
-                if not evaluator:
-                    continue
-
-                for task in self.crew.tasks:
-
-                    if task.agent and str(task.agent.id) != str(agent.id):
-                        continue
-
-                    trace = self.callback.get_trace(str(agent.id), str(task.id))
-                    if not trace:
-                        self.console_formatter.print(f"[yellow]Warning: No trace found for agent {agent.role} on task {task.description[:30]}...[/yellow]")
-                        progress.update(eval_task, advance=1)
-                        continue
-
-                    with crewai_event_bus.scoped_handlers():
-                        result = self.evaluate(
-                            agent=agent,
-                            task=task,
-                            execution_trace=trace,
-                            final_output=task.output
-                        )
-                        evaluation_results[agent.role].append(result)
-                        progress.update(eval_task, advance=1)
-
-        self.iterations_results[self.iteration] = evaluation_results
-        return evaluation_results
-
-    def get_evaluation_results(self):
-        if self.iteration in self.iterations_results:
-            return self.iterations_results[self.iteration]
-
-        return self.evaluate_current_iteration()
-
-    def display_results_with_iterations(self):
-        self.display_formatter.display_summary_results(self.iterations_results)
-
-    def get_agent_evaluation(self, strategy: AggregationStrategy = AggregationStrategy.SIMPLE_AVERAGE, include_evaluation_feedback: bool = False):
-        agent_results = {}
-        with crewai_event_bus.scoped_handlers():
-            task_results = self.get_evaluation_results()
-            for agent_role, results in task_results.items():
-                if not results:
-                    continue
-
-                agent_id = results[0].agent_id
-
-                aggregated_result = self.display_formatter._aggregate_agent_results(
-                    agent_id=agent_id,
-                    agent_role=agent_role,
-                    results=results,
-                    strategy=strategy
-                )
-
-                agent_results[agent_role] = aggregated_result
-
-
-            if self.iteration == max(self.iterations_results.keys()):
-                self.display_results_with_iterations()
-
-            if include_evaluation_feedback:
-                self.display_evaluation_with_feedback()
-
-        return agent_results
-
-    def display_evaluation_with_feedback(self):
-        self.display_formatter.display_evaluation_with_feedback(self.iterations_results)
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: Any
-    ) -> AgentEvaluationResult:
-        result = AgentEvaluationResult(
-            agent_id=str(agent.id),
-            task_id=str(task.id)
-        )
-        assert self.evaluators is not None
-        for evaluator in self.evaluators:
-            try:
-                score = evaluator.evaluate(
-                    agent=agent,
-                    task=task,
-                    execution_trace=execution_trace,
-                    final_output=final_output
-                )
-                result.metrics[evaluator.metric_category] = score
-            except Exception as e:
-                self.console_formatter.print(f"Error in {evaluator.metric_category.value} evaluator: {str(e)}")
-
-        return result
-
-def create_default_evaluator(crew, llm=None):
-    from crewai.evaluation import (
-        GoalAlignmentEvaluator,
-        SemanticQualityEvaluator,
-        ToolSelectionEvaluator,
-        ParameterExtractionEvaluator,
-        ToolInvocationEvaluator,
-        ReasoningEfficiencyEvaluator
-    )
-
-    evaluators = [
-        GoalAlignmentEvaluator(llm=llm),
-        SemanticQualityEvaluator(llm=llm),
-        ToolSelectionEvaluator(llm=llm),
-        ParameterExtractionEvaluator(llm=llm),
-        ToolInvocationEvaluator(llm=llm),
-        ReasoningEfficiencyEvaluator(llm=llm),
-    ]
-
-    return AgentEvaluator(evaluators=evaluators, crew=crew)

src/crewai/evaluation/base_evaluator.py

@@ -1,125 +0,0 @@
-import abc
-import enum
-from enum import Enum
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, Field
-
-from crewai.agent import Agent
-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"
-    REASONING_EFFICIENCY = "reasoning_efficiency"
-    TOOL_SELECTION = "tool_selection"
-    PARAMETER_EXTRACTION = "parameter_extraction"
-    TOOL_INVOCATION = "tool_invocation"
-
-    def title(self):
-        return self.value.replace('_', ' ').title()
-
-
-class EvaluationScore(BaseModel):
-    score: float | None = Field(
-        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
-    )
-    feedback: str = Field(
-        default="",
-        description="Detailed feedback explaining the evaluation score"
-    )
-    raw_response: str | None = Field(
-        default=None,
-        description="Raw response from the evaluator (e.g., LLM)"
-    )
-
-    def __str__(self) -> str:
-        if self.score is None:
-            return f"Score: N/A - {self.feedback}"
-        return f"Score: {self.score:.1f}/10 - {self.feedback}"
-
-
-class BaseEvaluator(abc.ABC):
-    def __init__(self, llm: BaseLLM | None = None):
-        self.llm: BaseLLM | None = create_llm(llm)
-
-    @property
-    @abc.abstractmethod
-    def metric_category(self) -> MetricCategory:
-        pass
-
-    @abc.abstractmethod
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: Any,
-    ) -> EvaluationScore:
-        pass
-
-
-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"
-    )
-
-
-class AggregationStrategy(Enum):
-    SIMPLE_AVERAGE = "simple_average"  # Equal weight to all tasks
-    WEIGHTED_BY_COMPLEXITY = "weighted_by_complexity"  # Weight by task complexity
-    BEST_PERFORMANCE = "best_performance"  # Use best scores across tasks
-    WORST_PERFORMANCE = "worst_performance"  # Use worst scores across tasks
-
-
-class AgentAggregatedEvaluationResult(BaseModel):
-    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"
-    )
-    aggregation_strategy: AggregationStrategy = Field(
-        default=AggregationStrategy.SIMPLE_AVERAGE,
-        description="Strategy used for aggregation"
-    )
-    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"
-    )
-    overall_score: Optional[float] = Field(
-        default=None,
-        description="Overall score for this agent"
-    )
-
-    def __str__(self) -> str:
-        result = f"Agent Evaluation: {self.agent_role}\n"
-        result += f"Strategy: {self.aggregation_strategy.value}\n"
-        result += f"Tasks evaluated: {self.task_count}\n"
-
-        for category, score in self.metrics.items():
-            result += f"\n\n- {category.value.upper()}: {score.score}/10\n"
-
-            if score.feedback:
-                detailed_feedback = "\n  ".join(score.feedback.split('\n'))
-                result += f"  {detailed_feedback}\n"
-
-        return result

src/crewai/evaluation/evaluation_display.py

@@ -1,341 +0,0 @@
-from collections import defaultdict
-from typing import Dict, Any, List
-from rich.table import Table
-from rich.box import HEAVY_EDGE, ROUNDED
-from collections.abc import Sequence
-from crewai.evaluation.base_evaluator import AgentAggregatedEvaluationResult, AggregationStrategy, AgentEvaluationResult, MetricCategory
-from crewai.evaluation import EvaluationScore
-from crewai.utilities.events.utils.console_formatter import ConsoleFormatter
-from crewai.utilities.llm_utils import create_llm
-
-class EvaluationDisplayFormatter:
-    def __init__(self):
-        self.console_formatter = ConsoleFormatter()
-
-    def display_evaluation_with_feedback(self, iterations_results: Dict[int, Dict[str, List[Any]]]):
-        if not iterations_results:
-            self.console_formatter.print("[yellow]No evaluation results to display[/yellow]")
-            return
-
-        # Get all agent roles across all iterations
-        all_agent_roles: set[str] = set()
-        for iter_results in iterations_results.values():
-            all_agent_roles.update(iter_results.keys())
-
-        for agent_role in sorted(all_agent_roles):
-            self.console_formatter.print(f"\n[bold cyan]Agent: {agent_role}[/bold cyan]")
-
-            # Process each iteration
-            for iter_num, results in sorted(iterations_results.items()):
-                if agent_role not in results or not results[agent_role]:
-                    continue
-
-                agent_results = results[agent_role]
-                agent_id = agent_results[0].agent_id
-
-                # Aggregate results for this agent in this iteration
-                aggregated_result = self._aggregate_agent_results(
-                    agent_id=agent_id,
-                    agent_role=agent_role,
-                    results=agent_results,
-                )
-
-                # Display iteration header
-                self.console_formatter.print(f"\n[bold]Iteration {iter_num}[/bold]")
-
-                # Create table for this iteration
-                table = Table(box=ROUNDED)
-                table.add_column("Metric", style="cyan")
-                table.add_column("Score (1-10)", justify="center")
-                table.add_column("Feedback", style="green")
-
-                # Add metrics to table
-                if aggregated_result.metrics:
-                    for metric, evaluation_score in aggregated_result.metrics.items():
-                        score = evaluation_score.score
-
-                        if isinstance(score, (int, float)):
-                            if score >= 8.0:
-                                score_text = f"[green]{score:.1f}[/green]"
-                            elif score >= 6.0:
-                                score_text = f"[cyan]{score:.1f}[/cyan]"
-                            elif score >= 4.0:
-                                score_text = f"[yellow]{score:.1f}[/yellow]"
-                            else:
-                                score_text = f"[red]{score:.1f}[/red]"
-                        else:
-                            score_text = "[dim]N/A[/dim]"
-
-                        table.add_section()
-                        table.add_row(
-                            metric.title(),
-                            score_text,
-                            evaluation_score.feedback or ""
-                        )
-
-                if aggregated_result.overall_score is not None:
-                    overall_score = aggregated_result.overall_score
-                    if overall_score >= 8.0:
-                        overall_color = "green"
-                    elif overall_score >= 6.0:
-                        overall_color = "cyan"
-                    elif overall_score >= 4.0:
-                        overall_color = "yellow"
-                    else:
-                        overall_color = "red"
-
-                    table.add_section()
-                    table.add_row(
-                        "Overall Score",
-                        f"[{overall_color}]{overall_score:.1f}[/]",
-                        "Overall agent evaluation score"
-                    )
-
-                # Print the table for this iteration
-                self.console_formatter.print(table)
-
-    def display_summary_results(self, iterations_results: Dict[int, Dict[str, List[AgentAggregatedEvaluationResult]]]):
-        if not iterations_results:
-            self.console_formatter.print("[yellow]No evaluation results to display[/yellow]")
-            return
-
-        self.console_formatter.print("\n")
-
-        table = Table(title="Agent Performance Scores \n (1-10 Higher is better)", box=HEAVY_EDGE)
-
-        table.add_column("Agent/Metric", style="cyan")
-
-        for iter_num in sorted(iterations_results.keys()):
-            run_label = f"Run {iter_num}"
-            table.add_column(run_label, justify="center")
-
-        table.add_column("Avg. Total", justify="center")
-
-        all_agent_roles: set[str] = set()
-        for results in iterations_results.values():
-            all_agent_roles.update(results.keys())
-
-        for agent_role in sorted(all_agent_roles):
-            agent_scores_by_iteration = {}
-            agent_metrics_by_iteration = {}
-
-            for iter_num, results in sorted(iterations_results.items()):
-                if agent_role not in results or not results[agent_role]:
-                    continue
-
-                agent_results = results[agent_role]
-                agent_id = agent_results[0].agent_id
-
-                aggregated_result = self._aggregate_agent_results(
-                    agent_id=agent_id,
-                    agent_role=agent_role,
-                    results=agent_results,
-                    strategy=AggregationStrategy.SIMPLE_AVERAGE
-                )
-
-                valid_scores = [score.score for score in aggregated_result.metrics.values()
-                               if score.score is not None]
-                if valid_scores:
-                    avg_score = sum(valid_scores) / len(valid_scores)
-                    agent_scores_by_iteration[iter_num] = avg_score
-
-                agent_metrics_by_iteration[iter_num] = aggregated_result.metrics
-
-            if not agent_scores_by_iteration:
-                continue
-
-            avg_across_iterations = sum(agent_scores_by_iteration.values()) / len(agent_scores_by_iteration)
-
-            row = [f"[bold]{agent_role}[/bold]"]
-
-            for iter_num in sorted(iterations_results.keys()):
-                if iter_num in agent_scores_by_iteration:
-                    score = agent_scores_by_iteration[iter_num]
-                    if score >= 8.0:
-                        color = "green"
-                    elif score >= 6.0:
-                        color = "cyan"
-                    elif score >= 4.0:
-                        color = "yellow"
-                    else:
-                        color = "red"
-                    row.append(f"[bold {color}]{score:.1f}[/]")
-                else:
-                    row.append("-")
-
-            if avg_across_iterations >= 8.0:
-                color = "green"
-            elif avg_across_iterations >= 6.0:
-                color = "cyan"
-            elif avg_across_iterations >= 4.0:
-                color = "yellow"
-            else:
-                color = "red"
-            row.append(f"[bold {color}]{avg_across_iterations:.1f}[/]")
-
-            table.add_row(*row)
-
-            all_metrics: set[Any] = set()
-            for metrics in agent_metrics_by_iteration.values():
-                all_metrics.update(metrics.keys())
-
-            for metric in sorted(all_metrics, key=lambda x: x.value):
-                metric_scores = []
-
-                row = [f"  - {metric.title()}"]
-
-                for iter_num in sorted(iterations_results.keys()):
-                    if (iter_num in agent_metrics_by_iteration and
-                            metric in agent_metrics_by_iteration[iter_num]):
-                        metric_score = agent_metrics_by_iteration[iter_num][metric].score
-                        if metric_score is not None:
-                            metric_scores.append(metric_score)
-                            if metric_score >= 8.0:
-                                color = "green"
-                            elif metric_score >= 6.0:
-                                color = "cyan"
-                            elif metric_score >= 4.0:
-                                color = "yellow"
-                            else:
-                                color = "red"
-                            row.append(f"[{color}]{metric_score:.1f}[/]")
-                        else:
-                            row.append("[dim]N/A[/dim]")
-                    else:
-                        row.append("-")
-
-                if metric_scores:
-                    avg = sum(metric_scores) / len(metric_scores)
-                    if avg >= 8.0:
-                        color = "green"
-                    elif avg >= 6.0:
-                        color = "cyan"
-                    elif avg >= 4.0:
-                        color = "yellow"
-                    else:
-                        color = "red"
-                    row.append(f"[{color}]{avg:.1f}[/]")
-                else:
-                    row.append("-")
-
-                table.add_row(*row)
-
-            table.add_row(*[""] * (len(sorted(iterations_results.keys())) + 2))
-
-        self.console_formatter.print(table)
-        self.console_formatter.print("\n")
-
-    def _aggregate_agent_results(
-        self,
-        agent_id: str,
-        agent_role: str,
-        results: Sequence[AgentEvaluationResult],
-        strategy: AggregationStrategy = AggregationStrategy.SIMPLE_AVERAGE,
-    ) -> AgentAggregatedEvaluationResult:
-        metrics_by_category: dict[MetricCategory, list[EvaluationScore]] = defaultdict(list)
-
-        for result in results:
-            for metric_name, evaluation_score in result.metrics.items():
-                metrics_by_category[metric_name].append(evaluation_score)
-
-        aggregated_metrics: dict[MetricCategory, EvaluationScore] = {}
-        for category, scores in metrics_by_category.items():
-            valid_scores = [s.score for s in scores if s.score is not None]
-            avg_score = sum(valid_scores) / len(valid_scores) if valid_scores else None
-
-            feedbacks = [s.feedback for s in scores if s.feedback]
-
-            feedback_summary = None
-            if feedbacks:
-                if len(feedbacks) > 1:
-                    # Use the summarization method for multiple feedbacks
-                    feedback_summary = self._summarize_feedbacks(
-                        agent_role=agent_role,
-                        metric=category.title(),
-                        feedbacks=feedbacks,
-                        scores=[s.score for s in scores],
-                        strategy=strategy
-                    )
-                else:
-                    feedback_summary = feedbacks[0]
-
-            aggregated_metrics[category] = EvaluationScore(
-                score=avg_score,
-                feedback=feedback_summary
-            )
-
-        overall_score = None
-        if aggregated_metrics:
-            valid_scores = [m.score for m in aggregated_metrics.values() if m.score is not None]
-            if valid_scores:
-                overall_score = sum(valid_scores) / len(valid_scores)
-
-        return AgentAggregatedEvaluationResult(
-            agent_id=agent_id,
-            agent_role=agent_role,
-            metrics=aggregated_metrics,
-            overall_score=overall_score,
-            task_count=len(results),
-            aggregation_strategy=strategy
-        )
-
-    def _summarize_feedbacks(
-        self,
-        agent_role: str,
-        metric: str,
-        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)])
-
-        try:
-            llm = create_llm()
-
-            formatted_feedbacks = []
-            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}")
-
-            all_feedbacks = "\n\n" + "\n\n---\n\n".join(formatted_feedbacks)
-
-            strategy_guidance = ""
-            if strategy == AggregationStrategy.BEST_PERFORMANCE:
-                strategy_guidance = "Focus on the highest-scoring aspects and strengths demonstrated."
-            elif strategy == AggregationStrategy.WORST_PERFORMANCE:
-                strategy_guidance = "Focus on areas that need improvement and common issues across tasks."
-            else:  # Default/average strategies
-                strategy_guidance = "Provide a balanced analysis of strengths and weaknesses across all tasks."
-
-            prompt = [
-                {"role": "system", "content": f"""You are an expert evaluator creating a comprehensive summary of agent performance feedback.
-                Your job is to synthesize multiple feedback points about the same metric across different tasks.
-
-                Create a concise, insightful summary that captures the key patterns and themes from all feedback.
-                {strategy_guidance}
-
-                Your summary should be:
-                1. Specific and concrete (not vague or general)
-                2. Focused on actionable insights
-                3. Highlighting patterns across tasks
-                4. 150-250 words in length
-
-                The summary should be directly usable as final feedback for the agent's performance on this metric."""},
-                {"role": "user", "content": f"""I need a synthesized summary of the following feedback for:
-
-                Agent Role: {agent_role}
-                Metric: {metric.title()}
-
-                {all_feedbacks}
-                """}
-            ]
-            assert llm is not None
-            response = llm.call(prompt)
-
-            return response
-
-        except Exception:
-            return "Synthesized from multiple tasks: " + "\n\n".join([f"- {fb[:500]}..." for fb in feedbacks])

src/crewai/evaluation/evaluation_listener.py

@@ -1,190 +0,0 @@
-from datetime import datetime
-from typing import Any, Dict, Optional
-
-from collections.abc import Sequence
-
-from crewai.agent import Agent
-from crewai.task import Task
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events.crewai_event_bus import CrewAIEventsBus
-from crewai.utilities.events.agent_events import (
-    AgentExecutionStartedEvent,
-    AgentExecutionCompletedEvent
-)
-from crewai.utilities.events.tool_usage_events import (
-    ToolUsageFinishedEvent,
-    ToolUsageErrorEvent,
-    ToolExecutionErrorEvent,
-    ToolSelectionErrorEvent,
-    ToolValidateInputErrorEvent
-)
-from crewai.utilities.events.llm_events import (
-    LLMCallStartedEvent,
-    LLMCallCompletedEvent
-)
-
-class EvaluationTraceCallback(BaseEventListener):
-    """Event listener for collecting execution traces for evaluation.
-
-    This listener attaches to the event bus to collect detailed information
-    about the execution process, including agent steps, tool uses, knowledge
-    retrievals, and final output - all for use in agent evaluation.
-    """
-
-    _instance = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._initialized = False
-        return cls._instance
-
-    def __init__(self):
-        if not hasattr(self, "_initialized") or not self._initialized:
-            super().__init__()
-            self.traces = {}
-            self.current_agent_id = None
-            self.current_task_id = None
-            self._initialized = True
-
-    def setup_listeners(self, event_bus: CrewAIEventsBus):
-        @event_bus.on(AgentExecutionStartedEvent)
-        def on_agent_started(source, event: AgentExecutionStartedEvent):
-            self.on_agent_start(event.agent, event.task)
-
-        @event_bus.on(AgentExecutionCompletedEvent)
-        def on_agent_completed(source, event: AgentExecutionCompletedEvent):
-            self.on_agent_finish(event.agent, event.task, event.output)
-
-        @event_bus.on(ToolUsageFinishedEvent)
-        def on_tool_completed(source, event: ToolUsageFinishedEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.output, success=True)
-
-        @event_bus.on(ToolUsageErrorEvent)
-        def on_tool_usage_error(source, event: ToolUsageErrorEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.error,
-                           success=False, error_type="usage_error")
-
-        @event_bus.on(ToolExecutionErrorEvent)
-        def on_tool_execution_error(source, event: ToolExecutionErrorEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.error,
-                           success=False, error_type="execution_error")
-
-        @event_bus.on(ToolSelectionErrorEvent)
-        def on_tool_selection_error(source, event: ToolSelectionErrorEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.error,
-                           success=False, error_type="selection_error")
-
-        @event_bus.on(ToolValidateInputErrorEvent)
-        def on_tool_validate_input_error(source, event: ToolValidateInputErrorEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.error,
-                           success=False, error_type="validation_error")
-
-        @event_bus.on(LLMCallStartedEvent)
-        def on_llm_call_started(source, event: LLMCallStartedEvent):
-            self.on_llm_call_start(event.messages, event.tools)
-
-        @event_bus.on(LLMCallCompletedEvent)
-        def on_llm_call_completed(source, event: LLMCallCompletedEvent):
-            self.on_llm_call_end(event.messages, event.response)
-
-    def on_agent_start(self, agent: Agent, task: Task):
-        self.current_agent_id = agent.id
-        self.current_task_id = task.id
-
-        trace_key = f"{agent.id}_{task.id}"
-        self.traces[trace_key] = {
-            "agent_id": agent.id,
-            "task_id": task.id,
-            "tool_uses": [],
-            "llm_calls": [],
-            "start_time": datetime.now(),
-            "final_output": None
-        }
-
-    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
-            self.traces[trace_key]["end_time"] = datetime.now()
-
-        self.current_agent_id = None
-        self.current_task_id = None
-
-    def on_tool_use(self, tool_name: str, tool_args: dict[str, Any] | str, result: Any,
-                   success: bool = True, error_type: str | None = None):
-        if not self.current_agent_id or not self.current_task_id:
-            return
-
-        trace_key = f"{self.current_agent_id}_{self.current_task_id}"
-        if trace_key in self.traces:
-            tool_use = {
-                "tool": tool_name,
-                "args": tool_args,
-                "result": result,
-                "success": success,
-                "timestamp": datetime.now()
-            }
-
-            # Add error information if applicable
-            if not success and error_type:
-                tool_use["error"] = True
-                tool_use["error_type"] = error_type
-
-            self.traces[trace_key]["tool_uses"].append(tool_use)
-
-    def on_llm_call_start(self, messages: str | Sequence[dict[str, Any]] | None, tools: Sequence[dict[str, Any]] | None = None):
-        if not self.current_agent_id or not self.current_task_id:
-            return
-
-        trace_key = f"{self.current_agent_id}_{self.current_task_id}"
-        if trace_key not in self.traces:
-            return
-
-        self.current_llm_call = {
-            "messages": messages,
-            "tools": tools,
-            "start_time": datetime.now(),
-            "response": None,
-            "end_time": None
-        }
-
-    def on_llm_call_end(self, messages: str | list[dict[str, Any]] | None, response: Any):
-        if not self.current_agent_id or not self.current_task_id:
-            return
-
-        trace_key = f"{self.current_agent_id}_{self.current_task_id}"
-        if trace_key not in self.traces:
-            return
-
-        total_tokens = 0
-        if hasattr(response, "usage") and hasattr(response.usage, "total_tokens"):
-            total_tokens = response.usage.total_tokens
-
-        current_time = datetime.now()
-        start_time = None
-        if hasattr(self, "current_llm_call") and self.current_llm_call:
-            start_time = self.current_llm_call.get("start_time")
-
-        if not start_time:
-            start_time = current_time
-        llm_call = {
-            "messages": messages,
-            "response": response,
-            "start_time": start_time,
-            "end_time": current_time,
-            "total_tokens": total_tokens
-        }
-
-        self.traces[trace_key]["llm_calls"].append(llm_call)
-
-        if hasattr(self, "current_llm_call"):
-            self.current_llm_call = {}
-
-    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)
-
-
-def create_evaluation_callbacks() -> EvaluationTraceCallback:
-    return EvaluationTraceCallback()

src/crewai/evaluation/json_parser.py

@@ -1,30 +0,0 @@
-"""Robust JSON parsing utilities for evaluation responses."""
-
-import json
-import re
-from typing import Any
-
-
-def extract_json_from_llm_response(text: str) -> dict[str, Any]:
-    try:
-        return json.loads(text)
-    except json.JSONDecodeError:
-        pass
-
-    json_patterns = [
-        # Standard markdown code blocks with json
-        r'```json\s*([\s\S]*?)\s*```',
-        # Code blocks without language specifier
-        r'```\s*([\s\S]*?)\s*```',
-        # Inline code with JSON
-        r'`([{\\[].*[}\]])`',
-    ]
-
-    for pattern in json_patterns:
-        matches = re.findall(pattern, text, re.IGNORECASE | re.DOTALL)
-        for match in matches:
-            try:
-                return json.loads(match.strip())
-            except json.JSONDecodeError:
-                continue
-    raise ValueError("No valid JSON found in the response")

src/crewai/evaluation/metrics/goal_metrics.py

@@ -1,66 +0,0 @@
-from typing import Any, Dict
-
-from crewai.agent import Agent
-from crewai.task import Task
-
-from crewai.evaluation.base_evaluator import BaseEvaluator, EvaluationScore, MetricCategory
-from crewai.evaluation.json_parser import extract_json_from_llm_response
-
-class GoalAlignmentEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.GOAL_ALIGNMENT
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: Any,
-    ) -> EvaluationScore:
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing how well an AI agent's output aligns with its assigned task goal.
-
-Score the agent's goal alignment on a scale from 0-10 where:
-- 0: Complete misalignment, agent did not understand or attempt the task goal
-- 5: Partial alignment, agent attempted the task but missed key requirements
-- 10: Perfect alignment, agent fully satisfied all task requirements
-
-Consider:
-1. Did the agent correctly interpret the task goal?
-2. Did the final output directly address the requirements?
-3. Did the agent focus on relevant aspects of the task?
-4. Did the agent provide all requested information or deliverables?
-
-Return your evaluation as JSON with fields 'score' (number) and 'feedback' (string).
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Agent goal: {agent.goal}
-Task description: {task.description}
-Expected output: {task.expected_output}
-
-Agent's final output:
-{final_output}
-
-Evaluate how well the agent's output aligns with the assigned task goal.
-"""}
-        ]
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data: dict[str, Any] = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-
-            return EvaluationScore(
-                score=evaluation_data.get("score", 0),
-                feedback=evaluation_data.get("feedback", response),
-                raw_response=response
-            )
-        except Exception:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Failed to parse evaluation. Raw response: {response}",
-                raw_response=response
-            )

src/crewai/evaluation/metrics/reasoning_metrics.py

@@ -1,355 +0,0 @@
-"""Agent reasoning efficiency evaluators.
-
-This module provides evaluator implementations for:
-- Reasoning efficiency
-- Loop detection
-- Thinking-to-action ratio
-"""
-
-import logging
-import re
-from enum import Enum
-from typing import Any, Dict, List, Tuple
-import numpy as np
-from collections.abc import Sequence
-
-from crewai.agent import Agent
-from crewai.task import Task
-
-from crewai.evaluation.base_evaluator import BaseEvaluator, EvaluationScore, MetricCategory
-from crewai.evaluation.json_parser import extract_json_from_llm_response
-from crewai.tasks.task_output import TaskOutput
-
-class ReasoningPatternType(Enum):
-    EFFICIENT = "efficient"  # Good reasoning flow
-    LOOP = "loop"  # Agent is stuck in a loop
-    VERBOSE = "verbose"  # Agent is unnecessarily verbose
-    INDECISIVE = "indecisive"  # Agent struggles to make decisions
-    SCATTERED = "scattered"  # Agent jumps between topics without focus
-
-
-class ReasoningEfficiencyEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.REASONING_EFFICIENCY
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: TaskOutput,
-    ) -> EvaluationScore:
-        llm_calls = execution_trace.get("llm_calls", [])
-
-        if not llm_calls or len(llm_calls) < 2:
-            return EvaluationScore(
-                score=None,
-                feedback="Insufficient LLM calls to evaluate reasoning efficiency."
-            )
-
-        total_calls = len(llm_calls)
-        total_tokens = sum(call.get("total_tokens", 0) for call in llm_calls)
-        avg_tokens_per_call = total_tokens / total_calls if total_calls > 0 else 0
-        time_intervals = []
-        has_reliable_timing = True
-        for i in range(1, len(llm_calls)):
-            start_time = llm_calls[i-1].get("end_time")
-            end_time = llm_calls[i].get("start_time")
-            if start_time and end_time and start_time != end_time:
-                try:
-                    interval = end_time - start_time
-                    time_intervals.append(interval.total_seconds() if hasattr(interval, 'total_seconds') else 0)
-                except Exception:
-                    has_reliable_timing = False
-            else:
-                has_reliable_timing = False
-
-        loop_detected, loop_details = self._detect_loops(llm_calls)
-        pattern_analysis = self._analyze_reasoning_patterns(llm_calls)
-
-        efficiency_metrics = {
-            "total_llm_calls": total_calls,
-            "total_tokens": total_tokens,
-            "avg_tokens_per_call": avg_tokens_per_call,
-            "reasoning_pattern": pattern_analysis["primary_pattern"].value,
-            "loops_detected": loop_detected,
-        }
-
-        if has_reliable_timing and time_intervals:
-            efficiency_metrics["avg_time_between_calls"] = np.mean(time_intervals)
-
-        loop_info = f"Detected {len(loop_details)} potential reasoning loops." if loop_detected else "No significant reasoning loops detected."
-
-        call_samples = self._get_call_samples(llm_calls)
-
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing the reasoning efficiency of an AI agent's thought process.
-
-Evaluate the agent's reasoning efficiency across these five key subcategories:
-
-1. Focus (0-10): How well the agent stays on topic and avoids unnecessary tangents
-2. Progression (0-10): How effectively the agent builds on previous thoughts rather than repeating or circling
-3. Decision Quality (0-10): How decisively and appropriately the agent makes decisions
-4. Conciseness (0-10): How efficiently the agent communicates without unnecessary verbosity
-5. Loop Avoidance (0-10): How well the agent avoids getting stuck in repetitive thinking patterns
-
-For each subcategory, provide a score from 0-10 where:
-- 0: Completely inefficient
-- 5: Moderately efficient
-- 10: Highly efficient
-
-The overall score should be a weighted average of these subcategories.
-
-Return your evaluation as JSON with the following structure:
-{
-    "overall_score": float,
-    "scores": {
-        "focus": float,
-        "progression": float,
-        "decision_quality": float,
-        "conciseness": float,
-        "loop_avoidance": float
-    },
-    "feedback": string (general feedback about overall reasoning efficiency),
-    "optimization_suggestions": string (concrete suggestions for improving reasoning efficiency),
-    "detected_patterns": string (describe any inefficient reasoning patterns you observe)
-}"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Reasoning efficiency metrics:
-- Total LLM calls: {efficiency_metrics["total_llm_calls"]}
-- Average tokens per call: {efficiency_metrics["avg_tokens_per_call"]:.1f}
-- Primary reasoning pattern: {efficiency_metrics["reasoning_pattern"]}
-- {loop_info}
-{"- Average time between calls: {:.2f} seconds".format(efficiency_metrics.get("avg_time_between_calls", 0)) if "avg_time_between_calls" in efficiency_metrics else ""}
-
-Sample of agent reasoning flow (chronological sequence):
-{call_samples}
-
-Agent's final output:
-{final_output.raw[:500]}... (truncated)
-
-Evaluate the reasoning efficiency of this agent based on these interaction patterns.
-Identify any inefficient reasoning patterns and provide specific suggestions for optimization.
-"""}
-        ]
-
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data = extract_json_from_llm_response(response)
-
-            scores = evaluation_data.get("scores", {})
-            focus = scores.get("focus", 5.0)
-            progression = scores.get("progression", 5.0)
-            decision_quality = scores.get("decision_quality", 5.0)
-            conciseness = scores.get("conciseness", 5.0)
-            loop_avoidance = scores.get("loop_avoidance", 5.0)
-
-            overall_score = evaluation_data.get("overall_score", evaluation_data.get("score", 5.0))
-            feedback = evaluation_data.get("feedback", "No detailed feedback provided.")
-            optimization_suggestions = evaluation_data.get("optimization_suggestions", "No specific suggestions provided.")
-
-            detailed_feedback = "Reasoning Efficiency Evaluation:\n"
-            detailed_feedback += f"• Focus: {focus}/10 - Staying on topic without tangents\n"
-            detailed_feedback += f"• Progression: {progression}/10 - Building on previous thinking\n"
-            detailed_feedback += f"• Decision Quality: {decision_quality}/10 - Making appropriate decisions\n"
-            detailed_feedback += f"• Conciseness: {conciseness}/10 - Communicating efficiently\n"
-            detailed_feedback += f"• Loop Avoidance: {loop_avoidance}/10 - Avoiding repetitive patterns\n\n"
-
-            detailed_feedback += f"Feedback:\n{feedback}\n\n"
-            detailed_feedback += f"Optimization Suggestions:\n{optimization_suggestions}"
-
-            return EvaluationScore(
-                score=float(overall_score),
-                feedback=detailed_feedback,
-                raw_response=response
-            )
-        except Exception as e:
-            logging.warning(f"Failed to parse reasoning efficiency evaluation: {e}")
-            return EvaluationScore(
-                score=None,
-                feedback=f"Failed to parse reasoning efficiency evaluation. Raw response: {response[:200]}...",
-                raw_response=response
-            )
-
-    def _detect_loops(self, llm_calls: List[Dict]) -> Tuple[bool, List[Dict]]:
-        loop_details = []
-
-        messages = []
-        for call in llm_calls:
-            content = call.get("response", "")
-            if isinstance(content, str):
-                messages.append(content)
-            elif isinstance(content, list) and len(content) > 0:
-                # Handle message list format
-                for msg in content:
-                    if isinstance(msg, dict) and "content" in msg:
-                        messages.append(msg["content"])
-
-        # Simple n-gram based similarity detection
-        # For a more robust implementation, consider using embedding-based similarity
-        for i in range(len(messages) - 2):
-            for j in range(i + 1, len(messages) - 1):
-                # Check for repeated patterns (simplistic approach)
-                # A more sophisticated approach would use semantic similarity
-                similarity = self._calculate_text_similarity(messages[i], messages[j])
-                if similarity > 0.7:  # Arbitrary threshold
-                    loop_details.append({
-                        "first_occurrence": i,
-                        "second_occurrence": j,
-                        "similarity": similarity,
-                        "snippet": messages[i][:100] + "..."
-                    })
-
-        return len(loop_details) > 0, loop_details
-
-    def _calculate_text_similarity(self, text1: str, text2: str) -> float:
-        text1 = re.sub(r'\s+', ' ', text1.lower()).strip()
-        text2 = re.sub(r'\s+', ' ', text2.lower()).strip()
-
-        # Simple Jaccard similarity on word sets
-        words1 = set(text1.split())
-        words2 = set(text2.split())
-
-        intersection = len(words1.intersection(words2))
-        union = len(words1.union(words2))
-
-        return intersection / union if union > 0 else 0.0
-
-    def _analyze_reasoning_patterns(self, llm_calls: List[Dict]) -> Dict[str, Any]:
-        call_lengths = []
-        response_times = []
-
-        for call in llm_calls:
-            content = call.get("response", "")
-            if isinstance(content, str):
-                call_lengths.append(len(content))
-            elif isinstance(content, list) and len(content) > 0:
-                # Handle message list format
-                total_length = 0
-                for msg in content:
-                    if isinstance(msg, dict) and "content" in msg:
-                        total_length += len(msg["content"])
-                call_lengths.append(total_length)
-
-            start_time = call.get("start_time")
-            end_time = call.get("end_time")
-            if start_time and end_time:
-                try:
-                    response_times.append(end_time - start_time)
-                except Exception:
-                    pass
-
-        avg_length = np.mean(call_lengths) if call_lengths else 0
-        std_length = np.std(call_lengths) if call_lengths else 0
-        length_trend = self._calculate_trend(call_lengths)
-
-        primary_pattern = ReasoningPatternType.EFFICIENT
-        details = "Agent demonstrates efficient reasoning patterns."
-
-        loop_score = self._calculate_loop_likelihood(call_lengths, response_times)
-        if loop_score > 0.7:
-            primary_pattern = ReasoningPatternType.LOOP
-            details = "Agent appears to be stuck in repetitive thinking patterns."
-        elif avg_length > 1000 and std_length / avg_length < 0.3:
-            primary_pattern = ReasoningPatternType.VERBOSE
-            details = "Agent is consistently verbose across interactions."
-        elif len(llm_calls) > 10 and length_trend > 0.5:
-            primary_pattern = ReasoningPatternType.INDECISIVE
-            details = "Agent shows signs of indecisiveness with increasing message lengths."
-        elif std_length / avg_length > 0.8:
-            primary_pattern = ReasoningPatternType.SCATTERED
-            details = "Agent shows inconsistent reasoning flow with highly variable responses."
-
-        return {
-            "primary_pattern": primary_pattern,
-            "details": details,
-            "metrics": {
-                "avg_length": avg_length,
-                "std_length": std_length,
-                "length_trend": length_trend,
-                "loop_score": loop_score
-            }
-        }
-
-    def _calculate_trend(self, values: Sequence[float | int]) -> float:
-        if not values or len(values) < 2:
-            return 0.0
-
-        try:
-            x = np.arange(len(values))
-            y = np.array(values)
-
-            # Simple linear regression
-            slope = np.polyfit(x, y, 1)[0]
-
-            # Normalize slope to -1 to 1 range
-            max_possible_slope = max(values) - min(values)
-            if max_possible_slope > 0:
-                normalized_slope = slope / max_possible_slope
-                return max(min(normalized_slope, 1.0), -1.0)
-            return 0.0
-        except Exception:
-            return 0.0
-
-    def _calculate_loop_likelihood(self, call_lengths: Sequence[float], response_times: Sequence[float]) -> float:
-        if not call_lengths or len(call_lengths) < 3:
-            return 0.0
-
-        indicators = []
-
-        if len(call_lengths) >= 4:
-            repeated_lengths = 0
-            for i in range(len(call_lengths) - 2):
-                ratio = call_lengths[i] / call_lengths[i + 2] if call_lengths[i + 2] > 0 else 0
-                if 0.85 <= ratio <= 1.15:
-                    repeated_lengths += 1
-
-            length_repetition_score = repeated_lengths / (len(call_lengths) - 2)
-            indicators.append(length_repetition_score)
-
-        if response_times and len(response_times) >= 3:
-            try:
-                std_time = np.std(response_times)
-                mean_time = np.mean(response_times)
-                if mean_time > 0:
-                    time_consistency = 1.0 - (std_time / mean_time)
-                    indicators.append(max(0, time_consistency - 0.3) * 1.5)
-            except Exception:
-                pass
-
-        return np.mean(indicators) if indicators else 0.0
-
-    def _get_call_samples(self, llm_calls: List[Dict]) -> str:
-        samples = []
-
-        if len(llm_calls) <= 6:
-            sample_indices = list(range(len(llm_calls)))
-        else:
-            sample_indices = [0, 1, len(llm_calls) // 2 - 1, len(llm_calls) // 2,
-                             len(llm_calls) - 2, len(llm_calls) - 1]
-
-        for idx in sample_indices:
-            call = llm_calls[idx]
-            content = call.get("response", "")
-
-            if isinstance(content, str):
-                sample = content
-            elif isinstance(content, list) and len(content) > 0:
-                sample_parts = []
-                for msg in content:
-                    if isinstance(msg, dict) and "content" in msg:
-                        sample_parts.append(msg["content"])
-                sample = "\n".join(sample_parts)
-            else:
-                sample = str(content)
-
-            truncated = sample[:200] + "..." if len(sample) > 200 else sample
-            samples.append(f"Call {idx + 1}:\n{truncated}\n")
-
-        return "\n".join(samples)

src/crewai/evaluation/metrics/semantic_quality_metrics.py

@@ -1,65 +0,0 @@
-from typing import Any, Dict
-
-from crewai.agent import Agent
-from crewai.task import Task
-
-from crewai.evaluation.base_evaluator import BaseEvaluator, EvaluationScore, MetricCategory
-from crewai.evaluation.json_parser import extract_json_from_llm_response
-
-class SemanticQualityEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.SEMANTIC_QUALITY
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: Any,
-    ) -> EvaluationScore:
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing the semantic quality of an AI agent's output.
-
-Score the semantic quality on a scale from 0-10 where:
-- 0: Completely incoherent, confusing, or logically flawed output
-- 5: Moderately clear and logical output with some issues
-- 10: Exceptionally clear, coherent, and logically sound output
-
-Consider:
-1. Is the output well-structured and organized?
-2. Is the reasoning logical and well-supported?
-3. Is the language clear, precise, and appropriate for the task?
-4. Are claims supported by evidence when appropriate?
-5. Is the output free from contradictions and logical fallacies?
-
-Return your evaluation as JSON with fields 'score' (number) and 'feedback' (string).
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Agent's final output:
-{final_output}
-
-Evaluate the semantic quality and reasoning of this output.
-"""}
-        ]
-
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data: dict[str, Any] = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-            return EvaluationScore(
-                score=float(evaluation_data["score"]) if evaluation_data.get("score") is not None else None,
-                feedback=evaluation_data.get("feedback", response),
-                raw_response=response
-            )
-        except Exception:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Failed to parse evaluation. Raw response: {response}",
-                raw_response=response
-            )

src/crewai/evaluation/metrics/tools_metrics.py

@@ -1,400 +0,0 @@
-import json
-from typing import Dict, Any
-
-from crewai.evaluation.base_evaluator import BaseEvaluator, EvaluationScore, MetricCategory
-from crewai.evaluation.json_parser import extract_json_from_llm_response
-from crewai.agent import Agent
-from crewai.task import Task
-
-
-class ToolSelectionEvaluator(BaseEvaluator):
-
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.TOOL_SELECTION
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: str,
-    ) -> EvaluationScore:
-        tool_uses = execution_trace.get("tool_uses", [])
-        tool_count = len(tool_uses)
-        unique_tool_types = set([tool.get("tool", "Unknown tool") for tool in tool_uses])
-
-        if tool_count == 0:
-            if not agent.tools:
-                return EvaluationScore(
-                    score=None,
-                    feedback="Agent had no tools available to use."
-                )
-            else:
-                return EvaluationScore(
-                    score=None,
-                    feedback="Agent had tools available but didn't use any."
-                )
-
-        available_tools_info = ""
-        if agent.tools:
-            for tool in agent.tools:
-                available_tools_info += f"- {tool.name}: {tool.description}\n"
-        else:
-            available_tools_info = "No tools available"
-
-        tool_types_summary = "Tools selected by the agent:\n"
-        for tool_type in sorted(unique_tool_types):
-            tool_types_summary += f"- {tool_type}\n"
-
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing if an AI agent selected the most appropriate tools for a given task.
-
-You must evaluate based on these 2 criteria:
-1. Relevance (0-10): Were the tools chosen directly aligned with the task's goals?
-2. Coverage (0-10): Did the agent select ALL appropriate tools from the AVAILABLE tools?
-
-IMPORTANT:
-- ONLY consider tools that are listed as available to the agent
-- DO NOT suggest tools that aren't in the 'Available tools' list
-- DO NOT evaluate the quality or accuracy of tool outputs/results
-- DO NOT evaluate how many times each tool was used
-- DO NOT evaluate how the agent used the parameters
-- DO NOT evaluate whether the agent interpreted the task correctly
-
-Focus ONLY on whether the correct CATEGORIES of tools were selected from what was available.
-
-Return your evaluation as JSON with these fields:
-- scores: {"relevance": number, "coverage": number}
-- overall_score: number (average of all scores, 0-10)
-- feedback: string (focused ONLY on tool selection decisions from available tools)
-- improvement_suggestions: string (ONLY suggest better selection from the AVAILABLE tools list, NOT new tools)
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Available tools for this agent:
-{available_tools_info}
-
-{tool_types_summary}
-
-Based ONLY on the task description and comparing the AVAILABLE tools with those that were selected (listed above), evaluate if the agent selected the appropriate tool types for this task.
-
-IMPORTANT:
-- ONLY evaluate selection from tools listed as available
-- DO NOT suggest new tools that aren't in the available tools list
-- DO NOT evaluate tool usage or results
-"""}
-        ]
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-
-            scores = evaluation_data.get("scores", {})
-            relevance = scores.get("relevance", 5.0)
-            coverage = scores.get("coverage", 5.0)
-            overall_score = float(evaluation_data.get("overall_score", 5.0))
-
-            feedback = "Tool Selection Evaluation:\n"
-            feedback += f"• Relevance: {relevance}/10 - Selection of appropriate tool types for the task\n"
-            feedback += f"• Coverage: {coverage}/10 - Selection of all necessary tool types\n"
-            if "improvement_suggestions" in evaluation_data:
-                feedback += f"Improvement Suggestions:\n{evaluation_data['improvement_suggestions']}"
-            else:
-                feedback += evaluation_data.get("feedback", "No detailed feedback available.")
-
-            return EvaluationScore(
-                score=overall_score,
-                feedback=feedback,
-                raw_response=response
-            )
-        except Exception as e:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Error evaluating tool selection: {e}",
-                raw_response=response
-            )
-
-
-class ParameterExtractionEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.PARAMETER_EXTRACTION
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: str,
-    ) -> EvaluationScore:
-        tool_uses = execution_trace.get("tool_uses", [])
-        tool_count = len(tool_uses)
-
-        if tool_count == 0:
-            return EvaluationScore(
-                score=None,
-                feedback="No tool usage detected. Cannot evaluate parameter extraction."
-            )
-
-        validation_errors = []
-        for tool_use in tool_uses:
-            if not tool_use.get("success", True) and tool_use.get("error_type") == "validation_error":
-                validation_errors.append({
-                    "tool": tool_use.get("tool", "Unknown tool"),
-                    "error": tool_use.get("result"),
-                    "args": tool_use.get("args", {})
-                })
-
-        validation_error_rate = len(validation_errors) / tool_count if tool_count > 0 else 0
-
-        param_samples = []
-        for i, tool_use in enumerate(tool_uses[:5]):
-            tool_name = tool_use.get("tool", "Unknown tool")
-            tool_args = tool_use.get("args", {})
-            success = tool_use.get("success", True) and not tool_use.get("error", False)
-            error_type = tool_use.get("error_type", "") if not success else ""
-
-            is_validation_error = error_type == "validation_error"
-
-            sample = f"Tool use #{i+1} - {tool_name}:\n"
-            sample += f"- Parameters: {json.dumps(tool_args, indent=2)}\n"
-            sample += f"- Success: {'No' if not success else 'Yes'}"
-
-            if is_validation_error:
-                sample += " (PARAMETER VALIDATION ERROR)\n"
-                sample += f"- Error: {tool_use.get('result', 'Unknown error')}"
-            elif not success:
-                sample += f" (Other error: {error_type})\n"
-
-            param_samples.append(sample)
-
-        validation_errors_info = ""
-        if validation_errors:
-            validation_errors_info = f"\nParameter validation errors detected: {len(validation_errors)} ({validation_error_rate:.1%} of tool uses)\n"
-            for i, err in enumerate(validation_errors[:3]):
-                tool_name = err.get("tool", "Unknown tool")
-                error_msg = err.get("error", "Unknown error")
-                args = err.get("args", {})
-                validation_errors_info += f"\nValidation Error #{i+1}:\n- Tool: {tool_name}\n- Args: {json.dumps(args, indent=2)}\n- Error: {error_msg}"
-
-            if len(validation_errors) > 3:
-                validation_errors_info += f"\n...and {len(validation_errors) - 3} more validation errors."
-        param_samples_text = "\n\n".join(param_samples)
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing how well an AI agent extracts and formats PARAMETER VALUES for tool calls.
-
-Your job is to evaluate ONLY whether the agent used the correct parameter VALUES, not whether the right tools were selected or how the tools were invoked.
-
-Evaluate parameter extraction based on these criteria:
-1. Accuracy (0-10): Are parameter values correctly identified from the context/task?
-2. Formatting (0-10): Are values formatted correctly for each tool's requirements?
-3. Completeness (0-10): Are all required parameter values provided, with no missing information?
-
-IMPORTANT: DO NOT evaluate:
-- Whether the right tool was chosen (that's the ToolSelectionEvaluator's job)
-- How the tools were structurally invoked (that's the ToolInvocationEvaluator's job)
-- The quality of results from tools
-
-Focus ONLY on the PARAMETER VALUES - whether they were correctly extracted from the context, properly formatted, and complete.
-
-Validation errors are important signals that parameter values weren't properly extracted or formatted.
-
-Return your evaluation as JSON with these fields:
-- scores: {"accuracy": number, "formatting": number, "completeness": number}
-- overall_score: number (average of all scores, 0-10)
-- feedback: string (focused ONLY on parameter value extraction quality)
-- improvement_suggestions: string (concrete suggestions for better parameter VALUE extraction)
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Parameter extraction examples:
-{param_samples_text}
-{validation_errors_info}
-
-Evaluate the quality of the agent's parameter extraction for this task.
-"""}
-        ]
-
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-
-            scores = evaluation_data.get("scores", {})
-            accuracy = scores.get("accuracy", 5.0)
-            formatting = scores.get("formatting", 5.0)
-            completeness = scores.get("completeness", 5.0)
-
-            overall_score = float(evaluation_data.get("overall_score", 5.0))
-
-            feedback = "Parameter Extraction Evaluation:\n"
-            feedback += f"• Accuracy: {accuracy}/10 - Correctly identifying required parameters\n"
-            feedback += f"• Formatting: {formatting}/10 - Properly formatting parameters for tools\n"
-            feedback += f"• Completeness: {completeness}/10 - Including all necessary information\n\n"
-
-            if "improvement_suggestions" in evaluation_data:
-                feedback += f"Improvement Suggestions:\n{evaluation_data['improvement_suggestions']}"
-            else:
-                feedback += evaluation_data.get("feedback", "No detailed feedback available.")
-
-            return EvaluationScore(
-                score=overall_score,
-                feedback=feedback,
-                raw_response=response
-            )
-        except Exception as e:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Error evaluating parameter extraction: {e}",
-                raw_response=response
-            )
-
-
-class ToolInvocationEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.TOOL_INVOCATION
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: str,
-    ) -> EvaluationScore:
-        tool_uses = execution_trace.get("tool_uses", [])
-        tool_errors = []
-        tool_count = len(tool_uses)
-
-        if tool_count == 0:
-            return EvaluationScore(
-                score=None,
-                feedback="No tool usage detected. Cannot evaluate tool invocation."
-            )
-
-        for tool_use in tool_uses:
-            if not tool_use.get("success", True) or tool_use.get("error", False):
-                error_info = {
-                    "tool": tool_use.get("tool", "Unknown tool"),
-                    "error": tool_use.get("result"),
-                    "error_type": tool_use.get("error_type", "unknown_error")
-                }
-                tool_errors.append(error_info)
-
-        error_rate = len(tool_errors) / tool_count if tool_count > 0 else 0
-
-        error_types = {}
-        for error in tool_errors:
-            error_type = error.get("error_type", "unknown_error")
-            if error_type not in error_types:
-                error_types[error_type] = 0
-            error_types[error_type] += 1
-
-        invocation_samples = []
-        for i, tool_use in enumerate(tool_uses[:5]):
-            tool_name = tool_use.get("tool", "Unknown tool")
-            tool_args = tool_use.get("args", {})
-            success = tool_use.get("success", True) and not tool_use.get("error", False)
-            error_type = tool_use.get("error_type", "") if not success else ""
-            error_msg = tool_use.get("result", "No error") if not success else "No error"
-
-            sample = f"Tool invocation #{i+1}:\n"
-            sample += f"- Tool: {tool_name}\n"
-            sample += f"- Parameters: {json.dumps(tool_args, indent=2)}\n"
-            sample += f"- Success: {'No' if not success else 'Yes'}\n"
-            if not success:
-                sample += f"- Error type: {error_type}\n"
-                sample += f"- Error: {error_msg}"
-            invocation_samples.append(sample)
-
-        error_type_summary = ""
-        if error_types:
-            error_type_summary = "Error type breakdown:\n"
-            for error_type, count in error_types.items():
-                error_type_summary += f"- {error_type}: {count} occurrences ({(count/tool_count):.1%})\n"
-
-        invocation_samples_text = "\n\n".join(invocation_samples)
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing how correctly an AI agent's tool invocations are STRUCTURED.
-
-Your job is to evaluate ONLY the structural and syntactical aspects of how the agent called tools, NOT which tools were selected or what parameter values were used.
-
-Evaluate the agent's tool invocation based on these criteria:
-1. Structure (0-10): Does the tool call follow the expected syntax and format?
-2. Error Handling (0-10): Does the agent handle tool errors appropriately?
-3. Invocation Patterns (0-10): Are tool calls properly sequenced, batched, or managed?
-
-Error types that indicate invocation issues:
-- execution_error: The tool was called correctly but failed during execution
-- usage_error: General errors in how the tool was used structurally
-
-IMPORTANT: DO NOT evaluate:
-- Whether the right tool was chosen (that's the ToolSelectionEvaluator's job)
-- Whether the parameter values are correct (that's the ParameterExtractionEvaluator's job)
-- The quality of results from tools
-
-Focus ONLY on HOW tools were invoked - the structure, format, and handling of the invocation process.
-
-Return your evaluation as JSON with these fields:
-- scores: {"structure": number, "error_handling": number, "invocation_patterns": number}
-- overall_score: number (average of all scores, 0-10)
-- feedback: string (focused ONLY on structural aspects of tool invocation)
-- improvement_suggestions: string (concrete suggestions for better structuring of tool calls)
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Tool invocation examples:
-{invocation_samples_text}
-
-Tool error rate: {error_rate:.2%} ({len(tool_errors)} errors out of {tool_count} invocations)
-{error_type_summary}
-
-Evaluate the quality of the agent's tool invocation structure during this task.
-"""}
-        ]
-
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-            scores = evaluation_data.get("scores", {})
-            structure = scores.get("structure", 5.0)
-            error_handling = scores.get("error_handling", 5.0)
-            invocation_patterns = scores.get("invocation_patterns", 5.0)
-
-            overall_score = float(evaluation_data.get("overall_score", 5.0))
-
-            feedback = "Tool Invocation Evaluation:\n"
-            feedback += f"• Structure: {structure}/10 - Following proper syntax and format\n"
-            feedback += f"• Error Handling: {error_handling}/10 - Appropriately handling tool errors\n"
-            feedback += f"• Invocation Patterns: {invocation_patterns}/10 - Proper sequencing and management of calls\n\n"
-
-            if "improvement_suggestions" in evaluation_data:
-                feedback += f"Improvement Suggestions:\n{evaluation_data['improvement_suggestions']}"
-            else:
-                feedback += evaluation_data.get("feedback", "No detailed feedback available.")
-
-            return EvaluationScore(
-                score=overall_score,
-                feedback=feedback,
-                raw_response=response
-            )
-        except Exception as e:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Error evaluating tool invocation: {e}",
-                raw_response=response
-            )

src/crewai/experimental/__init__.py

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

src/crewai/experimental/evaluation/__init__.py

@@ -1,51 +0,0 @@
-from crewai.experimental.evaluation.base_evaluator import (
-    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
-)
-
-from crewai.experimental.evaluation.agent_evaluator import (
-    AgentEvaluator,
-    create_default_evaluator
-)
-
-from crewai.experimental.evaluation.experiment import (
-    ExperimentRunner,
-    ExperimentResults,
-    ExperimentResult
-)
-
-__all__ = [
-    "BaseEvaluator",
-    "EvaluationScore",
-    "MetricCategory",
-    "AgentEvaluationResult",
-    "SemanticQualityEvaluator",
-    "GoalAlignmentEvaluator",
-    "ReasoningEfficiencyEvaluator",
-    "ToolSelectionEvaluator",
-    "ParameterExtractionEvaluator",
-    "ToolInvocationEvaluator",
-    "EvaluationTraceCallback",
-    "create_evaluation_callbacks",
-    "AgentEvaluator",
-    "create_default_evaluator",
-    "ExperimentRunner",
-    "ExperimentResults",
-    "ExperimentResult"
-]

src/crewai/experimental/evaluation/agent_evaluator.py

@@ -1,182 +0,0 @@
-from crewai.experimental.evaluation.base_evaluator import AgentEvaluationResult, AggregationStrategy
-from crewai.agent import Agent
-from crewai.task import Task
-from crewai.experimental.evaluation.evaluation_display import EvaluationDisplayFormatter
-
-from typing import Any, Dict
-from collections import defaultdict
-from crewai.experimental.evaluation import BaseEvaluator, create_evaluation_callbacks
-from collections.abc import Sequence
-from crewai.crew import Crew
-from crewai.utilities.events.crewai_event_bus import crewai_event_bus
-from crewai.utilities.events.utils.console_formatter import ConsoleFormatter
-from crewai.experimental.evaluation.evaluation_display import AgentAggregatedEvaluationResult
-
-class AgentEvaluator:
-    def __init__(
-        self,
-        evaluators: Sequence[BaseEvaluator] | None = None,
-        crew: Crew | None = None,
-    ):
-        self.crew: Crew | None = crew
-        self.evaluators: Sequence[BaseEvaluator] | None = evaluators
-
-        self.agent_evaluators: dict[str, Sequence[BaseEvaluator] | None] = {}
-        if crew is not None:
-            assert crew and crew.agents is not None
-            for agent in crew.agents:
-                self.agent_evaluators[str(agent.id)] = self.evaluators
-
-        self.callback = create_evaluation_callbacks()
-        self.console_formatter = ConsoleFormatter()
-        self.display_formatter = EvaluationDisplayFormatter()
-
-        self.iteration = 1
-        self.iterations_results: dict[int, dict[str, list[AgentEvaluationResult]]] = {}
-
-    def set_iteration(self, iteration: int) -> None:
-        self.iteration = iteration
-
-    def reset_iterations_results(self):
-        self.iterations_results = {}
-
-    def evaluate_current_iteration(self) -> dict[str, list[AgentEvaluationResult]]:
-        if not self.crew:
-            raise ValueError("Cannot evaluate: no crew was provided to the evaluator.")
-
-        if not self.callback:
-            raise ValueError("Cannot evaluate: no callback was set. Use set_callback() method first.")
-
-        from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
-        evaluation_results: defaultdict[str, list[AgentEvaluationResult]] = defaultdict(list)
-
-        total_evals = 0
-        for agent in self.crew.agents:
-            for task in self.crew.tasks:
-                if task.agent and task.agent.id == agent.id and self.agent_evaluators.get(str(agent.id)):
-                    total_evals += 1
-
-        with Progress(
-            SpinnerColumn(),
-            TextColumn("[bold blue]{task.description}[/bold blue]"),
-            BarColumn(),
-            TextColumn("{task.percentage:.0f}% completed"),
-            console=self.console_formatter.console
-        ) as progress:
-            eval_task = progress.add_task(f"Evaluating agents (iteration {self.iteration})...", total=total_evals)
-
-            for agent in self.crew.agents:
-                evaluator = self.agent_evaluators.get(str(agent.id))
-                if not evaluator:
-                    continue
-
-                for task in self.crew.tasks:
-
-                    if task.agent and str(task.agent.id) != str(agent.id):
-                        continue
-
-                    trace = self.callback.get_trace(str(agent.id), str(task.id))
-                    if not trace:
-                        self.console_formatter.print(f"[yellow]Warning: No trace found for agent {agent.role} on task {task.description[:30]}...[/yellow]")
-                        progress.update(eval_task, advance=1)
-                        continue
-
-                    with crewai_event_bus.scoped_handlers():
-                        result = self.evaluate(
-                            agent=agent,
-                            task=task,
-                            execution_trace=trace,
-                            final_output=task.output
-                        )
-                        evaluation_results[agent.role].append(result)
-                        progress.update(eval_task, advance=1)
-
-        self.iterations_results[self.iteration] = evaluation_results
-        return evaluation_results
-
-    def get_evaluation_results(self):
-        if self.iteration in self.iterations_results:
-            return self.iterations_results[self.iteration]
-
-        return self.evaluate_current_iteration()
-
-    def display_results_with_iterations(self):
-        self.display_formatter.display_summary_results(self.iterations_results)
-
-    def get_agent_evaluation(self, strategy: AggregationStrategy = AggregationStrategy.SIMPLE_AVERAGE, include_evaluation_feedback: bool = False) -> Dict[str, AgentAggregatedEvaluationResult]:
-        agent_results = {}
-        with crewai_event_bus.scoped_handlers():
-            task_results = self.get_evaluation_results()
-            for agent_role, results in task_results.items():
-                if not results:
-                    continue
-
-                agent_id = results[0].agent_id
-
-                aggregated_result = self.display_formatter._aggregate_agent_results(
-                    agent_id=agent_id,
-                    agent_role=agent_role,
-                    results=results,
-                    strategy=strategy
-                )
-
-                agent_results[agent_role] = aggregated_result
-
-
-            if self.iteration == max(self.iterations_results.keys()):
-                self.display_results_with_iterations()
-
-            if include_evaluation_feedback:
-                self.display_evaluation_with_feedback()
-
-        return agent_results
-
-    def display_evaluation_with_feedback(self):
-        self.display_formatter.display_evaluation_with_feedback(self.iterations_results)
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: Any
-    ) -> AgentEvaluationResult:
-        result = AgentEvaluationResult(
-            agent_id=str(agent.id),
-            task_id=str(task.id)
-        )
-        assert self.evaluators is not None
-        for evaluator in self.evaluators:
-            try:
-                score = evaluator.evaluate(
-                    agent=agent,
-                    task=task,
-                    execution_trace=execution_trace,
-                    final_output=final_output
-                )
-                result.metrics[evaluator.metric_category] = score
-            except Exception as e:
-                self.console_formatter.print(f"Error in {evaluator.metric_category.value} evaluator: {str(e)}")
-
-        return result
-
-def create_default_evaluator(crew, llm=None):
-    from crewai.experimental.evaluation import (
-        GoalAlignmentEvaluator,
-        SemanticQualityEvaluator,
-        ToolSelectionEvaluator,
-        ParameterExtractionEvaluator,
-        ToolInvocationEvaluator,
-        ReasoningEfficiencyEvaluator
-    )
-
-    evaluators = [
-        GoalAlignmentEvaluator(llm=llm),
-        SemanticQualityEvaluator(llm=llm),
-        ToolSelectionEvaluator(llm=llm),
-        ParameterExtractionEvaluator(llm=llm),
-        ToolInvocationEvaluator(llm=llm),
-        ReasoningEfficiencyEvaluator(llm=llm),
-    ]
-
-    return AgentEvaluator(evaluators=evaluators, crew=crew)

src/crewai/experimental/evaluation/base_evaluator.py

@@ -1,125 +0,0 @@
-import abc
-import enum
-from enum import Enum
-from typing import Any, Dict, List, Optional
-
-from pydantic import BaseModel, Field
-
-from crewai.agent import Agent
-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"
-    REASONING_EFFICIENCY = "reasoning_efficiency"
-    TOOL_SELECTION = "tool_selection"
-    PARAMETER_EXTRACTION = "parameter_extraction"
-    TOOL_INVOCATION = "tool_invocation"
-
-    def title(self):
-        return self.value.replace('_', ' ').title()
-
-
-class EvaluationScore(BaseModel):
-    score: float | None = Field(
-        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
-    )
-    feedback: str = Field(
-        default="",
-        description="Detailed feedback explaining the evaluation score"
-    )
-    raw_response: str | None = Field(
-        default=None,
-        description="Raw response from the evaluator (e.g., LLM)"
-    )
-
-    def __str__(self) -> str:
-        if self.score is None:
-            return f"Score: N/A - {self.feedback}"
-        return f"Score: {self.score:.1f}/10 - {self.feedback}"
-
-
-class BaseEvaluator(abc.ABC):
-    def __init__(self, llm: BaseLLM | None = None):
-        self.llm: BaseLLM | None = create_llm(llm)
-
-    @property
-    @abc.abstractmethod
-    def metric_category(self) -> MetricCategory:
-        pass
-
-    @abc.abstractmethod
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: Any,
-    ) -> EvaluationScore:
-        pass
-
-
-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"
-    )
-
-
-class AggregationStrategy(Enum):
-    SIMPLE_AVERAGE = "simple_average"  # Equal weight to all tasks
-    WEIGHTED_BY_COMPLEXITY = "weighted_by_complexity"  # Weight by task complexity
-    BEST_PERFORMANCE = "best_performance"  # Use best scores across tasks
-    WORST_PERFORMANCE = "worst_performance"  # Use worst scores across tasks
-
-
-class AgentAggregatedEvaluationResult(BaseModel):
-    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"
-    )
-    aggregation_strategy: AggregationStrategy = Field(
-        default=AggregationStrategy.SIMPLE_AVERAGE,
-        description="Strategy used for aggregation"
-    )
-    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"
-    )
-    overall_score: Optional[float] = Field(
-        default=None,
-        description="Overall score for this agent"
-    )
-
-    def __str__(self) -> str:
-        result = f"Agent Evaluation: {self.agent_role}\n"
-        result += f"Strategy: {self.aggregation_strategy.value}\n"
-        result += f"Tasks evaluated: {self.task_count}\n"
-
-        for category, score in self.metrics.items():
-            result += f"\n\n- {category.value.upper()}: {score.score}/10\n"
-
-            if score.feedback:
-                detailed_feedback = "\n  ".join(score.feedback.split('\n'))
-                result += f"  {detailed_feedback}\n"
-
-        return result

src/crewai/experimental/evaluation/evaluation_display.py

@@ -1,341 +0,0 @@
-from collections import defaultdict
-from typing import Dict, Any, List
-from rich.table import Table
-from rich.box import HEAVY_EDGE, ROUNDED
-from collections.abc import Sequence
-from crewai.experimental.evaluation.base_evaluator import AgentAggregatedEvaluationResult, AggregationStrategy, AgentEvaluationResult, MetricCategory
-from crewai.experimental.evaluation import EvaluationScore
-from crewai.utilities.events.utils.console_formatter import ConsoleFormatter
-from crewai.utilities.llm_utils import create_llm
-
-class EvaluationDisplayFormatter:
-    def __init__(self):
-        self.console_formatter = ConsoleFormatter()
-
-    def display_evaluation_with_feedback(self, iterations_results: Dict[int, Dict[str, List[Any]]]):
-        if not iterations_results:
-            self.console_formatter.print("[yellow]No evaluation results to display[/yellow]")
-            return
-
-        # Get all agent roles across all iterations
-        all_agent_roles: set[str] = set()
-        for iter_results in iterations_results.values():
-            all_agent_roles.update(iter_results.keys())
-
-        for agent_role in sorted(all_agent_roles):
-            self.console_formatter.print(f"\n[bold cyan]Agent: {agent_role}[/bold cyan]")
-
-            # Process each iteration
-            for iter_num, results in sorted(iterations_results.items()):
-                if agent_role not in results or not results[agent_role]:
-                    continue
-
-                agent_results = results[agent_role]
-                agent_id = agent_results[0].agent_id
-
-                # Aggregate results for this agent in this iteration
-                aggregated_result = self._aggregate_agent_results(
-                    agent_id=agent_id,
-                    agent_role=agent_role,
-                    results=agent_results,
-                )
-
-                # Display iteration header
-                self.console_formatter.print(f"\n[bold]Iteration {iter_num}[/bold]")
-
-                # Create table for this iteration
-                table = Table(box=ROUNDED)
-                table.add_column("Metric", style="cyan")
-                table.add_column("Score (1-10)", justify="center")
-                table.add_column("Feedback", style="green")
-
-                # Add metrics to table
-                if aggregated_result.metrics:
-                    for metric, evaluation_score in aggregated_result.metrics.items():
-                        score = evaluation_score.score
-
-                        if isinstance(score, (int, float)):
-                            if score >= 8.0:
-                                score_text = f"[green]{score:.1f}[/green]"
-                            elif score >= 6.0:
-                                score_text = f"[cyan]{score:.1f}[/cyan]"
-                            elif score >= 4.0:
-                                score_text = f"[yellow]{score:.1f}[/yellow]"
-                            else:
-                                score_text = f"[red]{score:.1f}[/red]"
-                        else:
-                            score_text = "[dim]N/A[/dim]"
-
-                        table.add_section()
-                        table.add_row(
-                            metric.title(),
-                            score_text,
-                            evaluation_score.feedback or ""
-                        )
-
-                if aggregated_result.overall_score is not None:
-                    overall_score = aggregated_result.overall_score
-                    if overall_score >= 8.0:
-                        overall_color = "green"
-                    elif overall_score >= 6.0:
-                        overall_color = "cyan"
-                    elif overall_score >= 4.0:
-                        overall_color = "yellow"
-                    else:
-                        overall_color = "red"
-
-                    table.add_section()
-                    table.add_row(
-                        "Overall Score",
-                        f"[{overall_color}]{overall_score:.1f}[/]",
-                        "Overall agent evaluation score"
-                    )
-
-                # Print the table for this iteration
-                self.console_formatter.print(table)
-
-    def display_summary_results(self, iterations_results: Dict[int, Dict[str, List[AgentAggregatedEvaluationResult]]]):
-        if not iterations_results:
-            self.console_formatter.print("[yellow]No evaluation results to display[/yellow]")
-            return
-
-        self.console_formatter.print("\n")
-
-        table = Table(title="Agent Performance Scores \n (1-10 Higher is better)", box=HEAVY_EDGE)
-
-        table.add_column("Agent/Metric", style="cyan")
-
-        for iter_num in sorted(iterations_results.keys()):
-            run_label = f"Run {iter_num}"
-            table.add_column(run_label, justify="center")
-
-        table.add_column("Avg. Total", justify="center")
-
-        all_agent_roles: set[str] = set()
-        for results in iterations_results.values():
-            all_agent_roles.update(results.keys())
-
-        for agent_role in sorted(all_agent_roles):
-            agent_scores_by_iteration = {}
-            agent_metrics_by_iteration = {}
-
-            for iter_num, results in sorted(iterations_results.items()):
-                if agent_role not in results or not results[agent_role]:
-                    continue
-
-                agent_results = results[agent_role]
-                agent_id = agent_results[0].agent_id
-
-                aggregated_result = self._aggregate_agent_results(
-                    agent_id=agent_id,
-                    agent_role=agent_role,
-                    results=agent_results,
-                    strategy=AggregationStrategy.SIMPLE_AVERAGE
-                )
-
-                valid_scores = [score.score for score in aggregated_result.metrics.values()
-                               if score.score is not None]
-                if valid_scores:
-                    avg_score = sum(valid_scores) / len(valid_scores)
-                    agent_scores_by_iteration[iter_num] = avg_score
-
-                agent_metrics_by_iteration[iter_num] = aggregated_result.metrics
-
-            if not agent_scores_by_iteration:
-                continue
-
-            avg_across_iterations = sum(agent_scores_by_iteration.values()) / len(agent_scores_by_iteration)
-
-            row = [f"[bold]{agent_role}[/bold]"]
-
-            for iter_num in sorted(iterations_results.keys()):
-                if iter_num in agent_scores_by_iteration:
-                    score = agent_scores_by_iteration[iter_num]
-                    if score >= 8.0:
-                        color = "green"
-                    elif score >= 6.0:
-                        color = "cyan"
-                    elif score >= 4.0:
-                        color = "yellow"
-                    else:
-                        color = "red"
-                    row.append(f"[bold {color}]{score:.1f}[/]")
-                else:
-                    row.append("-")
-
-            if avg_across_iterations >= 8.0:
-                color = "green"
-            elif avg_across_iterations >= 6.0:
-                color = "cyan"
-            elif avg_across_iterations >= 4.0:
-                color = "yellow"
-            else:
-                color = "red"
-            row.append(f"[bold {color}]{avg_across_iterations:.1f}[/]")
-
-            table.add_row(*row)
-
-            all_metrics: set[Any] = set()
-            for metrics in agent_metrics_by_iteration.values():
-                all_metrics.update(metrics.keys())
-
-            for metric in sorted(all_metrics, key=lambda x: x.value):
-                metric_scores = []
-
-                row = [f"  - {metric.title()}"]
-
-                for iter_num in sorted(iterations_results.keys()):
-                    if (iter_num in agent_metrics_by_iteration and
-                            metric in agent_metrics_by_iteration[iter_num]):
-                        metric_score = agent_metrics_by_iteration[iter_num][metric].score
-                        if metric_score is not None:
-                            metric_scores.append(metric_score)
-                            if metric_score >= 8.0:
-                                color = "green"
-                            elif metric_score >= 6.0:
-                                color = "cyan"
-                            elif metric_score >= 4.0:
-                                color = "yellow"
-                            else:
-                                color = "red"
-                            row.append(f"[{color}]{metric_score:.1f}[/]")
-                        else:
-                            row.append("[dim]N/A[/dim]")
-                    else:
-                        row.append("-")
-
-                if metric_scores:
-                    avg = sum(metric_scores) / len(metric_scores)
-                    if avg >= 8.0:
-                        color = "green"
-                    elif avg >= 6.0:
-                        color = "cyan"
-                    elif avg >= 4.0:
-                        color = "yellow"
-                    else:
-                        color = "red"
-                    row.append(f"[{color}]{avg:.1f}[/]")
-                else:
-                    row.append("-")
-
-                table.add_row(*row)
-
-            table.add_row(*[""] * (len(sorted(iterations_results.keys())) + 2))
-
-        self.console_formatter.print(table)
-        self.console_formatter.print("\n")
-
-    def _aggregate_agent_results(
-        self,
-        agent_id: str,
-        agent_role: str,
-        results: Sequence[AgentEvaluationResult],
-        strategy: AggregationStrategy = AggregationStrategy.SIMPLE_AVERAGE,
-    ) -> AgentAggregatedEvaluationResult:
-        metrics_by_category: dict[MetricCategory, list[EvaluationScore]] = defaultdict(list)
-
-        for result in results:
-            for metric_name, evaluation_score in result.metrics.items():
-                metrics_by_category[metric_name].append(evaluation_score)
-
-        aggregated_metrics: dict[MetricCategory, EvaluationScore] = {}
-        for category, scores in metrics_by_category.items():
-            valid_scores = [s.score for s in scores if s.score is not None]
-            avg_score = sum(valid_scores) / len(valid_scores) if valid_scores else None
-
-            feedbacks = [s.feedback for s in scores if s.feedback]
-
-            feedback_summary = None
-            if feedbacks:
-                if len(feedbacks) > 1:
-                    # Use the summarization method for multiple feedbacks
-                    feedback_summary = self._summarize_feedbacks(
-                        agent_role=agent_role,
-                        metric=category.title(),
-                        feedbacks=feedbacks,
-                        scores=[s.score for s in scores],
-                        strategy=strategy
-                    )
-                else:
-                    feedback_summary = feedbacks[0]
-
-            aggregated_metrics[category] = EvaluationScore(
-                score=avg_score,
-                feedback=feedback_summary
-            )
-
-        overall_score = None
-        if aggregated_metrics:
-            valid_scores = [m.score for m in aggregated_metrics.values() if m.score is not None]
-            if valid_scores:
-                overall_score = sum(valid_scores) / len(valid_scores)
-
-        return AgentAggregatedEvaluationResult(
-            agent_id=agent_id,
-            agent_role=agent_role,
-            metrics=aggregated_metrics,
-            overall_score=overall_score,
-            task_count=len(results),
-            aggregation_strategy=strategy
-        )
-
-    def _summarize_feedbacks(
-        self,
-        agent_role: str,
-        metric: str,
-        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)])
-
-        try:
-            llm = create_llm()
-
-            formatted_feedbacks = []
-            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}")
-
-            all_feedbacks = "\n\n" + "\n\n---\n\n".join(formatted_feedbacks)
-
-            strategy_guidance = ""
-            if strategy == AggregationStrategy.BEST_PERFORMANCE:
-                strategy_guidance = "Focus on the highest-scoring aspects and strengths demonstrated."
-            elif strategy == AggregationStrategy.WORST_PERFORMANCE:
-                strategy_guidance = "Focus on areas that need improvement and common issues across tasks."
-            else:  # Default/average strategies
-                strategy_guidance = "Provide a balanced analysis of strengths and weaknesses across all tasks."
-
-            prompt = [
-                {"role": "system", "content": f"""You are an expert evaluator creating a comprehensive summary of agent performance feedback.
-                Your job is to synthesize multiple feedback points about the same metric across different tasks.
-
-                Create a concise, insightful summary that captures the key patterns and themes from all feedback.
-                {strategy_guidance}
-
-                Your summary should be:
-                1. Specific and concrete (not vague or general)
-                2. Focused on actionable insights
-                3. Highlighting patterns across tasks
-                4. 150-250 words in length
-
-                The summary should be directly usable as final feedback for the agent's performance on this metric."""},
-                {"role": "user", "content": f"""I need a synthesized summary of the following feedback for:
-
-                Agent Role: {agent_role}
-                Metric: {metric.title()}
-
-                {all_feedbacks}
-                """}
-            ]
-            assert llm is not None
-            response = llm.call(prompt)
-
-            return response
-
-        except Exception:
-            return "Synthesized from multiple tasks: " + "\n\n".join([f"- {fb[:500]}..." for fb in feedbacks])

src/crewai/experimental/evaluation/evaluation_listener.py

@@ -1,190 +0,0 @@
-from datetime import datetime
-from typing import Any, Dict, Optional
-
-from collections.abc import Sequence
-
-from crewai.agent import Agent
-from crewai.task import Task
-from crewai.utilities.events.base_event_listener import BaseEventListener
-from crewai.utilities.events.crewai_event_bus import CrewAIEventsBus
-from crewai.utilities.events.agent_events import (
-    AgentExecutionStartedEvent,
-    AgentExecutionCompletedEvent
-)
-from crewai.utilities.events.tool_usage_events import (
-    ToolUsageFinishedEvent,
-    ToolUsageErrorEvent,
-    ToolExecutionErrorEvent,
-    ToolSelectionErrorEvent,
-    ToolValidateInputErrorEvent
-)
-from crewai.utilities.events.llm_events import (
-    LLMCallStartedEvent,
-    LLMCallCompletedEvent
-)
-
-class EvaluationTraceCallback(BaseEventListener):
-    """Event listener for collecting execution traces for evaluation.
-
-    This listener attaches to the event bus to collect detailed information
-    about the execution process, including agent steps, tool uses, knowledge
-    retrievals, and final output - all for use in agent evaluation.
-    """
-
-    _instance = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._initialized = False
-        return cls._instance
-
-    def __init__(self):
-        if not hasattr(self, "_initialized") or not self._initialized:
-            super().__init__()
-            self.traces = {}
-            self.current_agent_id = None
-            self.current_task_id = None
-            self._initialized = True
-
-    def setup_listeners(self, event_bus: CrewAIEventsBus):
-        @event_bus.on(AgentExecutionStartedEvent)
-        def on_agent_started(source, event: AgentExecutionStartedEvent):
-            self.on_agent_start(event.agent, event.task)
-
-        @event_bus.on(AgentExecutionCompletedEvent)
-        def on_agent_completed(source, event: AgentExecutionCompletedEvent):
-            self.on_agent_finish(event.agent, event.task, event.output)
-
-        @event_bus.on(ToolUsageFinishedEvent)
-        def on_tool_completed(source, event: ToolUsageFinishedEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.output, success=True)
-
-        @event_bus.on(ToolUsageErrorEvent)
-        def on_tool_usage_error(source, event: ToolUsageErrorEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.error,
-                           success=False, error_type="usage_error")
-
-        @event_bus.on(ToolExecutionErrorEvent)
-        def on_tool_execution_error(source, event: ToolExecutionErrorEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.error,
-                           success=False, error_type="execution_error")
-
-        @event_bus.on(ToolSelectionErrorEvent)
-        def on_tool_selection_error(source, event: ToolSelectionErrorEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.error,
-                           success=False, error_type="selection_error")
-
-        @event_bus.on(ToolValidateInputErrorEvent)
-        def on_tool_validate_input_error(source, event: ToolValidateInputErrorEvent):
-            self.on_tool_use(event.tool_name, event.tool_args, event.error,
-                           success=False, error_type="validation_error")
-
-        @event_bus.on(LLMCallStartedEvent)
-        def on_llm_call_started(source, event: LLMCallStartedEvent):
-            self.on_llm_call_start(event.messages, event.tools)
-
-        @event_bus.on(LLMCallCompletedEvent)
-        def on_llm_call_completed(source, event: LLMCallCompletedEvent):
-            self.on_llm_call_end(event.messages, event.response)
-
-    def on_agent_start(self, agent: Agent, task: Task):
-        self.current_agent_id = agent.id
-        self.current_task_id = task.id
-
-        trace_key = f"{agent.id}_{task.id}"
-        self.traces[trace_key] = {
-            "agent_id": agent.id,
-            "task_id": task.id,
-            "tool_uses": [],
-            "llm_calls": [],
-            "start_time": datetime.now(),
-            "final_output": None
-        }
-
-    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
-            self.traces[trace_key]["end_time"] = datetime.now()
-
-        self.current_agent_id = None
-        self.current_task_id = None
-
-    def on_tool_use(self, tool_name: str, tool_args: dict[str, Any] | str, result: Any,
-                   success: bool = True, error_type: str | None = None):
-        if not self.current_agent_id or not self.current_task_id:
-            return
-
-        trace_key = f"{self.current_agent_id}_{self.current_task_id}"
-        if trace_key in self.traces:
-            tool_use = {
-                "tool": tool_name,
-                "args": tool_args,
-                "result": result,
-                "success": success,
-                "timestamp": datetime.now()
-            }
-
-            # Add error information if applicable
-            if not success and error_type:
-                tool_use["error"] = True
-                tool_use["error_type"] = error_type
-
-            self.traces[trace_key]["tool_uses"].append(tool_use)
-
-    def on_llm_call_start(self, messages: str | Sequence[dict[str, Any]] | None, tools: Sequence[dict[str, Any]] | None = None):
-        if not self.current_agent_id or not self.current_task_id:
-            return
-
-        trace_key = f"{self.current_agent_id}_{self.current_task_id}"
-        if trace_key not in self.traces:
-            return
-
-        self.current_llm_call = {
-            "messages": messages,
-            "tools": tools,
-            "start_time": datetime.now(),
-            "response": None,
-            "end_time": None
-        }
-
-    def on_llm_call_end(self, messages: str | list[dict[str, Any]] | None, response: Any):
-        if not self.current_agent_id or not self.current_task_id:
-            return
-
-        trace_key = f"{self.current_agent_id}_{self.current_task_id}"
-        if trace_key not in self.traces:
-            return
-
-        total_tokens = 0
-        if hasattr(response, "usage") and hasattr(response.usage, "total_tokens"):
-            total_tokens = response.usage.total_tokens
-
-        current_time = datetime.now()
-        start_time = None
-        if hasattr(self, "current_llm_call") and self.current_llm_call:
-            start_time = self.current_llm_call.get("start_time")
-
-        if not start_time:
-            start_time = current_time
-        llm_call = {
-            "messages": messages,
-            "response": response,
-            "start_time": start_time,
-            "end_time": current_time,
-            "total_tokens": total_tokens
-        }
-
-        self.traces[trace_key]["llm_calls"].append(llm_call)
-
-        if hasattr(self, "current_llm_call"):
-            self.current_llm_call = {}
-
-    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)
-
-
-def create_evaluation_callbacks() -> EvaluationTraceCallback:
-    return EvaluationTraceCallback()

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

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

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

@@ -1,122 +0,0 @@
-import json
-import os
-from datetime import datetime, timezone
-from typing import Any
-from pydantic import BaseModel
-
-class ExperimentResult(BaseModel):
-    identifier: str
-    inputs: dict[str, Any]
-    score: int | dict[str, int | float]
-    expected_score: int | dict[str, int | float]
-    passed: bool
-    agent_evaluations: dict[str, Any] | None = None
-
-class ExperimentResults:
-    def __init__(self, results: list[ExperimentResult], metadata: dict[str, Any] | None = None):
-        self.results = results
-        self.metadata = metadata or {}
-        self.timestamp = datetime.now(timezone.utc)
-
-        from crewai.experimental.evaluation.experiment.result_display import ExperimentResultsDisplay
-        self.display = ExperimentResultsDisplay()
-
-    def to_json(self, filepath: str | None = None) -> dict[str, Any]:
-        data = {
-            "timestamp": self.timestamp.isoformat(),
-            "metadata": self.metadata,
-            "results": [r.model_dump(exclude={"agent_evaluations"}) for r in self.results]
-        }
-
-        if filepath:
-            with open(filepath, 'w') as f:
-                json.dump(data, f, indent=2)
-            self.display.console.print(f"[green]Results saved to {filepath}[/green]")
-
-        return data
-
-    def compare_with_baseline(self, baseline_filepath: str, save_current: bool = True, print_summary: bool = False) -> dict[str, Any]:
-        baseline_runs = []
-
-        if os.path.exists(baseline_filepath) and os.path.getsize(baseline_filepath) > 0:
-            try:
-                with open(baseline_filepath, 'r') as f:
-                    baseline_data = json.load(f)
-
-                if isinstance(baseline_data, dict) and "timestamp" in baseline_data:
-                    baseline_runs = [baseline_data]
-                elif isinstance(baseline_data, list):
-                    baseline_runs = baseline_data
-            except (json.JSONDecodeError, FileNotFoundError) as e:
-                self.display.console.print(f"[yellow]Warning: Could not load baseline file: {str(e)}[/yellow]")
-
-        if not baseline_runs:
-            if save_current:
-                current_data = self.to_json()
-                with open(baseline_filepath, 'w') as f:
-                    json.dump([current_data], f, indent=2)
-                self.display.console.print(f"[green]Saved current results as new baseline to {baseline_filepath}[/green]")
-            return {"is_baseline": True, "changes": {}}
-
-        baseline_runs.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
-        latest_run = baseline_runs[0]
-
-        comparison = self._compare_with_run(latest_run)
-
-        if print_summary:
-            self.display.comparison_summary(comparison, latest_run["timestamp"])
-
-        if save_current:
-            current_data = self.to_json()
-            baseline_runs.append(current_data)
-            with open(baseline_filepath, 'w') as f:
-                json.dump(baseline_runs, f, indent=2)
-            self.display.console.print(f"[green]Added current results to baseline file {baseline_filepath}[/green]")
-
-        return comparison
-
-    def _compare_with_run(self, baseline_run: dict[str, Any]) -> dict[str, Any]:
-        baseline_results = baseline_run.get("results", [])
-
-        baseline_lookup = {}
-        for result in baseline_results:
-            test_identifier = result.get("identifier")
-            if test_identifier:
-                baseline_lookup[test_identifier] = result
-
-        improved = []
-        regressed = []
-        unchanged = []
-        new_tests = []
-
-        for result in self.results:
-            test_identifier = result.identifier
-            if not test_identifier or test_identifier not in baseline_lookup:
-                new_tests.append(test_identifier)
-                continue
-
-            baseline_result = baseline_lookup[test_identifier]
-            baseline_passed = baseline_result.get("passed", False)
-            if result.passed and not baseline_passed:
-                improved.append(test_identifier)
-            elif not result.passed and baseline_passed:
-                regressed.append(test_identifier)
-            else:
-                unchanged.append(test_identifier)
-
-        missing_tests = []
-        current_test_identifiers = {result.identifier for result in self.results}
-        for result in baseline_results:
-            test_identifier = result.get("identifier")
-            if test_identifier and test_identifier not in current_test_identifiers:
-                missing_tests.append(test_identifier)
-
-        return {
-            "improved": improved,
-            "regressed": regressed,
-            "unchanged": unchanged,
-            "new_tests": new_tests,
-            "missing_tests": missing_tests,
-            "total_compared": len(improved) + len(regressed) + len(unchanged),
-            "baseline_timestamp": baseline_run.get("timestamp", "unknown")
-        }

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

@@ -1,70 +0,0 @@
-from typing import Dict, Any
-from rich.console import Console
-from rich.table import Table
-from rich.panel import Panel
-from crewai.experimental.evaluation.experiment.result import ExperimentResults
-
-class ExperimentResultsDisplay:
-    def __init__(self):
-        self.console = Console()
-
-    def summary(self, experiment_results: ExperimentResults):
-        total = len(experiment_results.results)
-        passed = sum(1 for r in experiment_results.results if r.passed)
-
-        table = Table(title="Experiment Summary")
-        table.add_column("Metric", style="cyan")
-        table.add_column("Value", style="green")
-
-        table.add_row("Total Test Cases", str(total))
-        table.add_row("Passed", str(passed))
-        table.add_row("Failed", str(total - passed))
-        table.add_row("Success Rate", f"{(passed / total * 100):.1f}%" if total > 0 else "N/A")
-
-        self.console.print(table)
-
-    def comparison_summary(self, comparison: Dict[str, Any], baseline_timestamp: str):
-        self.console.print(Panel(f"[bold]Comparison with baseline run from {baseline_timestamp}[/bold]",
-                                 expand=False))
-
-        table = Table(title="Results Comparison")
-        table.add_column("Metric", style="cyan")
-        table.add_column("Count", style="white")
-        table.add_column("Details", style="dim")
-
-        improved = comparison.get("improved", [])
-        if improved:
-            details = ", ".join([f"{test_identifier}" for test_identifier in improved[:3]])
-            if len(improved) > 3:
-                details += f" and {len(improved) - 3} more"
-            table.add_row("✅ Improved", str(len(improved)), details)
-        else:
-            table.add_row("✅ Improved", "0", "")
-
-        regressed = comparison.get("regressed", [])
-        if regressed:
-            details = ", ".join([f"{test_identifier}" for test_identifier in regressed[:3]])
-            if len(regressed) > 3:
-                details += f" and {len(regressed) - 3} more"
-            table.add_row("❌ Regressed", str(len(regressed)), details, style="red")
-        else:
-            table.add_row("❌ Regressed", "0", "")
-
-        unchanged = comparison.get("unchanged", [])
-        table.add_row("⏺ Unchanged", str(len(unchanged)), "")
-
-        new_tests = comparison.get("new_tests", [])
-        if new_tests:
-            details = ", ".join(new_tests[:3])
-            if len(new_tests) > 3:
-                details += f" and {len(new_tests) - 3} more"
-            table.add_row("➕ New Tests", str(len(new_tests)), details)
-
-        missing_tests = comparison.get("missing_tests", [])
-        if missing_tests:
-            details = ", ".join(missing_tests[:3])
-            if len(missing_tests) > 3:
-                details += f" and {len(missing_tests) - 3} more"
-            table.add_row("➖ Missing Tests", str(len(missing_tests)), details)
-
-        self.console.print(table)

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

@@ -1,117 +0,0 @@
-from collections import defaultdict
-from hashlib import md5
-from typing import Any
-
-from crewai import Crew
-from crewai.experimental.evaluation import AgentEvaluator, create_default_evaluator
-from crewai.experimental.evaluation.experiment.result_display import ExperimentResultsDisplay
-from crewai.experimental.evaluation.experiment.result import ExperimentResults, ExperimentResult
-from crewai.experimental.evaluation.evaluation_display import AgentAggregatedEvaluationResult
-
-class ExperimentRunner:
-    def __init__(self, dataset: list[dict[str, Any]]):
-        self.dataset = dataset or []
-        self.evaluator: AgentEvaluator | None = None
-        self.display = ExperimentResultsDisplay()
-
-    def run(self, crew: Crew, print_summary: bool = False) -> ExperimentResults:
-        self.evaluator = create_default_evaluator(crew=crew)
-
-        results = []
-
-        for test_case in self.dataset:
-            self.evaluator.reset_iterations_results()
-            result = self._run_test_case(test_case, crew)
-            results.append(result)
-
-        experiment_results = ExperimentResults(results)
-
-        if print_summary:
-            self.display.summary(experiment_results)
-
-        return experiment_results
-
-    def _run_test_case(self, test_case: dict[str, Any], crew: Crew) -> ExperimentResult:
-        inputs = test_case["inputs"]
-        expected_score = test_case["expected_score"]
-        identifier = test_case.get("identifier") or md5(str(test_case).encode(), usedforsecurity=False).hexdigest()
-
-        try:
-            self.display.console.print(f"[dim]Running crew with input: {str(inputs)[:50]}...[/dim]")
-            self.display.console.print("\n")
-            crew.kickoff(inputs=inputs)
-
-            assert self.evaluator is not None
-            agent_evaluations = self.evaluator.get_agent_evaluation()
-
-            actual_score = self._extract_scores(agent_evaluations)
-
-            passed = self._assert_scores(expected_score, actual_score)
-            return ExperimentResult(
-                identifier=identifier,
-                inputs=inputs,
-                score=actual_score,
-                expected_score=expected_score,
-                passed=passed,
-                agent_evaluations=agent_evaluations
-            )
-
-        except Exception as e:
-            self.display.console.print(f"[red]Error running test case: {str(e)}[/red]")
-            return ExperimentResult(
-                identifier=identifier,
-                inputs=inputs,
-                score=0,
-                expected_score=expected_score,
-                passed=False
-            )
-
-    def _extract_scores(self, agent_evaluations: dict[str, AgentAggregatedEvaluationResult]) -> float | dict[str,  float]:
-        all_scores: dict[str, list[float]] = defaultdict(list)
-        for evaluation in agent_evaluations.values():
-            for metric_name, score in evaluation.metrics.items():
-                if score.score is not None:
-                    all_scores[metric_name.value].append(score.score)
-
-        avg_scores = {m: sum(s)/len(s) for m, s in all_scores.items()}
-
-        if len(avg_scores) == 1:
-            return list(avg_scores.values())[0]
-
-        return avg_scores
-
-    def _assert_scores(self, expected: float | dict[str, float],
-                        actual: float | dict[str, float]) -> bool:
-        """
-        Compare expected and actual scores, and return whether the test case passed.
-
-        The rules for comparison are as follows:
-        - If both expected and actual scores are single numbers, the actual score must be >= expected.
-        - If expected is a single number and actual is a dict, compare against the average of actual values.
-        - If expected is a dict and actual is a single number, actual must be >= all expected values.
-        - If both are dicts, actual must have matching keys with values >= expected values.
-        """
-
-        if isinstance(expected, (int, float)) and isinstance(actual, (int, float)):
-            return actual >= expected
-
-        if isinstance(expected, dict) and isinstance(actual, (int, float)):
-            return all(actual >= exp_score for exp_score in expected.values())
-
-        if isinstance(expected, (int, float)) and isinstance(actual, dict):
-            if not actual:
-                return False
-            avg_score = sum(actual.values()) / len(actual)
-            return avg_score >= expected
-
-        if isinstance(expected, dict) and isinstance(actual, dict):
-            if not expected:
-                return True
-            matching_keys = set(expected.keys()) & set(actual.keys())
-            if not matching_keys:
-                return False
-
-            # All matching keys must have actual >= expected
-            return all(actual[key] >= expected[key] for key in matching_keys)
-
-        return False

src/crewai/experimental/evaluation/json_parser.py

@@ -1,30 +0,0 @@
-"""Robust JSON parsing utilities for evaluation responses."""
-
-import json
-import re
-from typing import Any
-
-
-def extract_json_from_llm_response(text: str) -> dict[str, Any]:
-    try:
-        return json.loads(text)
-    except json.JSONDecodeError:
-        pass
-
-    json_patterns = [
-        # Standard markdown code blocks with json
-        r'```json\s*([\s\S]*?)\s*```',
-        # Code blocks without language specifier
-        r'```\s*([\s\S]*?)\s*```',
-        # Inline code with JSON
-        r'`([{\\[].*[}\]])`',
-    ]
-
-    for pattern in json_patterns:
-        matches = re.findall(pattern, text, re.IGNORECASE | re.DOTALL)
-        for match in matches:
-            try:
-                return json.loads(match.strip())
-            except json.JSONDecodeError:
-                continue
-    raise ValueError("No valid JSON found in the response")

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

@@ -1,26 +0,0 @@
-from crewai.experimental.evaluation.metrics.reasoning_metrics import (
-    ReasoningEfficiencyEvaluator
-)
-
-from crewai.experimental.evaluation.metrics.tools_metrics import (
-    ToolSelectionEvaluator,
-    ParameterExtractionEvaluator,
-    ToolInvocationEvaluator
-)
-
-from crewai.experimental.evaluation.metrics.goal_metrics import (
-    GoalAlignmentEvaluator
-)
-
-from crewai.experimental.evaluation.metrics.semantic_quality_metrics import (
-    SemanticQualityEvaluator
-)
-
-__all__ = [
-    "ReasoningEfficiencyEvaluator",
-    "ToolSelectionEvaluator",
-    "ParameterExtractionEvaluator",
-    "ToolInvocationEvaluator",
-    "GoalAlignmentEvaluator",
-    "SemanticQualityEvaluator"
-]

src/crewai/experimental/evaluation/metrics/goal_metrics.py

@@ -1,66 +0,0 @@
-from typing import Any, Dict
-
-from crewai.agent import Agent
-from crewai.task import Task
-
-from crewai.experimental.evaluation.base_evaluator import BaseEvaluator, EvaluationScore, MetricCategory
-from crewai.experimental.evaluation.json_parser import extract_json_from_llm_response
-
-class GoalAlignmentEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.GOAL_ALIGNMENT
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: Any,
-    ) -> EvaluationScore:
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing how well an AI agent's output aligns with its assigned task goal.
-
-Score the agent's goal alignment on a scale from 0-10 where:
-- 0: Complete misalignment, agent did not understand or attempt the task goal
-- 5: Partial alignment, agent attempted the task but missed key requirements
-- 10: Perfect alignment, agent fully satisfied all task requirements
-
-Consider:
-1. Did the agent correctly interpret the task goal?
-2. Did the final output directly address the requirements?
-3. Did the agent focus on relevant aspects of the task?
-4. Did the agent provide all requested information or deliverables?
-
-Return your evaluation as JSON with fields 'score' (number) and 'feedback' (string).
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Agent goal: {agent.goal}
-Task description: {task.description}
-Expected output: {task.expected_output}
-
-Agent's final output:
-{final_output}
-
-Evaluate how well the agent's output aligns with the assigned task goal.
-"""}
-        ]
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data: dict[str, Any] = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-
-            return EvaluationScore(
-                score=evaluation_data.get("score", 0),
-                feedback=evaluation_data.get("feedback", response),
-                raw_response=response
-            )
-        except Exception:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Failed to parse evaluation. Raw response: {response}",
-                raw_response=response
-            )

src/crewai/experimental/evaluation/metrics/reasoning_metrics.py

@@ -1,355 +0,0 @@
-"""Agent reasoning efficiency evaluators.
-
-This module provides evaluator implementations for:
-- Reasoning efficiency
-- Loop detection
-- Thinking-to-action ratio
-"""
-
-import logging
-import re
-from enum import Enum
-from typing import Any, Dict, List, Tuple
-import numpy as np
-from collections.abc import Sequence
-
-from crewai.agent import Agent
-from crewai.task import Task
-
-from crewai.experimental.evaluation.base_evaluator import BaseEvaluator, EvaluationScore, MetricCategory
-from crewai.experimental.evaluation.json_parser import extract_json_from_llm_response
-from crewai.tasks.task_output import TaskOutput
-
-class ReasoningPatternType(Enum):
-    EFFICIENT = "efficient"  # Good reasoning flow
-    LOOP = "loop"  # Agent is stuck in a loop
-    VERBOSE = "verbose"  # Agent is unnecessarily verbose
-    INDECISIVE = "indecisive"  # Agent struggles to make decisions
-    SCATTERED = "scattered"  # Agent jumps between topics without focus
-
-
-class ReasoningEfficiencyEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.REASONING_EFFICIENCY
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: TaskOutput,
-    ) -> EvaluationScore:
-        llm_calls = execution_trace.get("llm_calls", [])
-
-        if not llm_calls or len(llm_calls) < 2:
-            return EvaluationScore(
-                score=None,
-                feedback="Insufficient LLM calls to evaluate reasoning efficiency."
-            )
-
-        total_calls = len(llm_calls)
-        total_tokens = sum(call.get("total_tokens", 0) for call in llm_calls)
-        avg_tokens_per_call = total_tokens / total_calls if total_calls > 0 else 0
-        time_intervals = []
-        has_reliable_timing = True
-        for i in range(1, len(llm_calls)):
-            start_time = llm_calls[i-1].get("end_time")
-            end_time = llm_calls[i].get("start_time")
-            if start_time and end_time and start_time != end_time:
-                try:
-                    interval = end_time - start_time
-                    time_intervals.append(interval.total_seconds() if hasattr(interval, 'total_seconds') else 0)
-                except Exception:
-                    has_reliable_timing = False
-            else:
-                has_reliable_timing = False
-
-        loop_detected, loop_details = self._detect_loops(llm_calls)
-        pattern_analysis = self._analyze_reasoning_patterns(llm_calls)
-
-        efficiency_metrics = {
-            "total_llm_calls": total_calls,
-            "total_tokens": total_tokens,
-            "avg_tokens_per_call": avg_tokens_per_call,
-            "reasoning_pattern": pattern_analysis["primary_pattern"].value,
-            "loops_detected": loop_detected,
-        }
-
-        if has_reliable_timing and time_intervals:
-            efficiency_metrics["avg_time_between_calls"] = np.mean(time_intervals)
-
-        loop_info = f"Detected {len(loop_details)} potential reasoning loops." if loop_detected else "No significant reasoning loops detected."
-
-        call_samples = self._get_call_samples(llm_calls)
-
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing the reasoning efficiency of an AI agent's thought process.
-
-Evaluate the agent's reasoning efficiency across these five key subcategories:
-
-1. Focus (0-10): How well the agent stays on topic and avoids unnecessary tangents
-2. Progression (0-10): How effectively the agent builds on previous thoughts rather than repeating or circling
-3. Decision Quality (0-10): How decisively and appropriately the agent makes decisions
-4. Conciseness (0-10): How efficiently the agent communicates without unnecessary verbosity
-5. Loop Avoidance (0-10): How well the agent avoids getting stuck in repetitive thinking patterns
-
-For each subcategory, provide a score from 0-10 where:
-- 0: Completely inefficient
-- 5: Moderately efficient
-- 10: Highly efficient
-
-The overall score should be a weighted average of these subcategories.
-
-Return your evaluation as JSON with the following structure:
-{
-    "overall_score": float,
-    "scores": {
-        "focus": float,
-        "progression": float,
-        "decision_quality": float,
-        "conciseness": float,
-        "loop_avoidance": float
-    },
-    "feedback": string (general feedback about overall reasoning efficiency),
-    "optimization_suggestions": string (concrete suggestions for improving reasoning efficiency),
-    "detected_patterns": string (describe any inefficient reasoning patterns you observe)
-}"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Reasoning efficiency metrics:
-- Total LLM calls: {efficiency_metrics["total_llm_calls"]}
-- Average tokens per call: {efficiency_metrics["avg_tokens_per_call"]:.1f}
-- Primary reasoning pattern: {efficiency_metrics["reasoning_pattern"]}
-- {loop_info}
-{"- Average time between calls: {:.2f} seconds".format(efficiency_metrics.get("avg_time_between_calls", 0)) if "avg_time_between_calls" in efficiency_metrics else ""}
-
-Sample of agent reasoning flow (chronological sequence):
-{call_samples}
-
-Agent's final output:
-{final_output.raw[:500]}... (truncated)
-
-Evaluate the reasoning efficiency of this agent based on these interaction patterns.
-Identify any inefficient reasoning patterns and provide specific suggestions for optimization.
-"""}
-        ]
-
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data = extract_json_from_llm_response(response)
-
-            scores = evaluation_data.get("scores", {})
-            focus = scores.get("focus", 5.0)
-            progression = scores.get("progression", 5.0)
-            decision_quality = scores.get("decision_quality", 5.0)
-            conciseness = scores.get("conciseness", 5.0)
-            loop_avoidance = scores.get("loop_avoidance", 5.0)
-
-            overall_score = evaluation_data.get("overall_score", evaluation_data.get("score", 5.0))
-            feedback = evaluation_data.get("feedback", "No detailed feedback provided.")
-            optimization_suggestions = evaluation_data.get("optimization_suggestions", "No specific suggestions provided.")
-
-            detailed_feedback = "Reasoning Efficiency Evaluation:\n"
-            detailed_feedback += f"• Focus: {focus}/10 - Staying on topic without tangents\n"
-            detailed_feedback += f"• Progression: {progression}/10 - Building on previous thinking\n"
-            detailed_feedback += f"• Decision Quality: {decision_quality}/10 - Making appropriate decisions\n"
-            detailed_feedback += f"• Conciseness: {conciseness}/10 - Communicating efficiently\n"
-            detailed_feedback += f"• Loop Avoidance: {loop_avoidance}/10 - Avoiding repetitive patterns\n\n"
-
-            detailed_feedback += f"Feedback:\n{feedback}\n\n"
-            detailed_feedback += f"Optimization Suggestions:\n{optimization_suggestions}"
-
-            return EvaluationScore(
-                score=float(overall_score),
-                feedback=detailed_feedback,
-                raw_response=response
-            )
-        except Exception as e:
-            logging.warning(f"Failed to parse reasoning efficiency evaluation: {e}")
-            return EvaluationScore(
-                score=None,
-                feedback=f"Failed to parse reasoning efficiency evaluation. Raw response: {response[:200]}...",
-                raw_response=response
-            )
-
-    def _detect_loops(self, llm_calls: List[Dict]) -> Tuple[bool, List[Dict]]:
-        loop_details = []
-
-        messages = []
-        for call in llm_calls:
-            content = call.get("response", "")
-            if isinstance(content, str):
-                messages.append(content)
-            elif isinstance(content, list) and len(content) > 0:
-                # Handle message list format
-                for msg in content:
-                    if isinstance(msg, dict) and "content" in msg:
-                        messages.append(msg["content"])
-
-        # Simple n-gram based similarity detection
-        # For a more robust implementation, consider using embedding-based similarity
-        for i in range(len(messages) - 2):
-            for j in range(i + 1, len(messages) - 1):
-                # Check for repeated patterns (simplistic approach)
-                # A more sophisticated approach would use semantic similarity
-                similarity = self._calculate_text_similarity(messages[i], messages[j])
-                if similarity > 0.7:  # Arbitrary threshold
-                    loop_details.append({
-                        "first_occurrence": i,
-                        "second_occurrence": j,
-                        "similarity": similarity,
-                        "snippet": messages[i][:100] + "..."
-                    })
-
-        return len(loop_details) > 0, loop_details
-
-    def _calculate_text_similarity(self, text1: str, text2: str) -> float:
-        text1 = re.sub(r'\s+', ' ', text1.lower()).strip()
-        text2 = re.sub(r'\s+', ' ', text2.lower()).strip()
-
-        # Simple Jaccard similarity on word sets
-        words1 = set(text1.split())
-        words2 = set(text2.split())
-
-        intersection = len(words1.intersection(words2))
-        union = len(words1.union(words2))
-
-        return intersection / union if union > 0 else 0.0
-
-    def _analyze_reasoning_patterns(self, llm_calls: List[Dict]) -> Dict[str, Any]:
-        call_lengths = []
-        response_times = []
-
-        for call in llm_calls:
-            content = call.get("response", "")
-            if isinstance(content, str):
-                call_lengths.append(len(content))
-            elif isinstance(content, list) and len(content) > 0:
-                # Handle message list format
-                total_length = 0
-                for msg in content:
-                    if isinstance(msg, dict) and "content" in msg:
-                        total_length += len(msg["content"])
-                call_lengths.append(total_length)
-
-            start_time = call.get("start_time")
-            end_time = call.get("end_time")
-            if start_time and end_time:
-                try:
-                    response_times.append(end_time - start_time)
-                except Exception:
-                    pass
-
-        avg_length = np.mean(call_lengths) if call_lengths else 0
-        std_length = np.std(call_lengths) if call_lengths else 0
-        length_trend = self._calculate_trend(call_lengths)
-
-        primary_pattern = ReasoningPatternType.EFFICIENT
-        details = "Agent demonstrates efficient reasoning patterns."
-
-        loop_score = self._calculate_loop_likelihood(call_lengths, response_times)
-        if loop_score > 0.7:
-            primary_pattern = ReasoningPatternType.LOOP
-            details = "Agent appears to be stuck in repetitive thinking patterns."
-        elif avg_length > 1000 and std_length / avg_length < 0.3:
-            primary_pattern = ReasoningPatternType.VERBOSE
-            details = "Agent is consistently verbose across interactions."
-        elif len(llm_calls) > 10 and length_trend > 0.5:
-            primary_pattern = ReasoningPatternType.INDECISIVE
-            details = "Agent shows signs of indecisiveness with increasing message lengths."
-        elif std_length / avg_length > 0.8:
-            primary_pattern = ReasoningPatternType.SCATTERED
-            details = "Agent shows inconsistent reasoning flow with highly variable responses."
-
-        return {
-            "primary_pattern": primary_pattern,
-            "details": details,
-            "metrics": {
-                "avg_length": avg_length,
-                "std_length": std_length,
-                "length_trend": length_trend,
-                "loop_score": loop_score
-            }
-        }
-
-    def _calculate_trend(self, values: Sequence[float | int]) -> float:
-        if not values or len(values) < 2:
-            return 0.0
-
-        try:
-            x = np.arange(len(values))
-            y = np.array(values)
-
-            # Simple linear regression
-            slope = np.polyfit(x, y, 1)[0]
-
-            # Normalize slope to -1 to 1 range
-            max_possible_slope = max(values) - min(values)
-            if max_possible_slope > 0:
-                normalized_slope = slope / max_possible_slope
-                return max(min(normalized_slope, 1.0), -1.0)
-            return 0.0
-        except Exception:
-            return 0.0
-
-    def _calculate_loop_likelihood(self, call_lengths: Sequence[float], response_times: Sequence[float]) -> float:
-        if not call_lengths or len(call_lengths) < 3:
-            return 0.0
-
-        indicators = []
-
-        if len(call_lengths) >= 4:
-            repeated_lengths = 0
-            for i in range(len(call_lengths) - 2):
-                ratio = call_lengths[i] / call_lengths[i + 2] if call_lengths[i + 2] > 0 else 0
-                if 0.85 <= ratio <= 1.15:
-                    repeated_lengths += 1
-
-            length_repetition_score = repeated_lengths / (len(call_lengths) - 2)
-            indicators.append(length_repetition_score)
-
-        if response_times and len(response_times) >= 3:
-            try:
-                std_time = np.std(response_times)
-                mean_time = np.mean(response_times)
-                if mean_time > 0:
-                    time_consistency = 1.0 - (std_time / mean_time)
-                    indicators.append(max(0, time_consistency - 0.3) * 1.5)
-            except Exception:
-                pass
-
-        return np.mean(indicators) if indicators else 0.0
-
-    def _get_call_samples(self, llm_calls: List[Dict]) -> str:
-        samples = []
-
-        if len(llm_calls) <= 6:
-            sample_indices = list(range(len(llm_calls)))
-        else:
-            sample_indices = [0, 1, len(llm_calls) // 2 - 1, len(llm_calls) // 2,
-                             len(llm_calls) - 2, len(llm_calls) - 1]
-
-        for idx in sample_indices:
-            call = llm_calls[idx]
-            content = call.get("response", "")
-
-            if isinstance(content, str):
-                sample = content
-            elif isinstance(content, list) and len(content) > 0:
-                sample_parts = []
-                for msg in content:
-                    if isinstance(msg, dict) and "content" in msg:
-                        sample_parts.append(msg["content"])
-                sample = "\n".join(sample_parts)
-            else:
-                sample = str(content)
-
-            truncated = sample[:200] + "..." if len(sample) > 200 else sample
-            samples.append(f"Call {idx + 1}:\n{truncated}\n")
-
-        return "\n".join(samples)

src/crewai/experimental/evaluation/metrics/semantic_quality_metrics.py

@@ -1,65 +0,0 @@
-from typing import Any, Dict
-
-from crewai.agent import Agent
-from crewai.task import Task
-
-from crewai.experimental.evaluation.base_evaluator import BaseEvaluator, EvaluationScore, MetricCategory
-from crewai.experimental.evaluation.json_parser import extract_json_from_llm_response
-
-class SemanticQualityEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.SEMANTIC_QUALITY
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: Any,
-    ) -> EvaluationScore:
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing the semantic quality of an AI agent's output.
-
-Score the semantic quality on a scale from 0-10 where:
-- 0: Completely incoherent, confusing, or logically flawed output
-- 5: Moderately clear and logical output with some issues
-- 10: Exceptionally clear, coherent, and logically sound output
-
-Consider:
-1. Is the output well-structured and organized?
-2. Is the reasoning logical and well-supported?
-3. Is the language clear, precise, and appropriate for the task?
-4. Are claims supported by evidence when appropriate?
-5. Is the output free from contradictions and logical fallacies?
-
-Return your evaluation as JSON with fields 'score' (number) and 'feedback' (string).
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Agent's final output:
-{final_output}
-
-Evaluate the semantic quality and reasoning of this output.
-"""}
-        ]
-
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data: dict[str, Any] = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-            return EvaluationScore(
-                score=float(evaluation_data["score"]) if evaluation_data.get("score") is not None else None,
-                feedback=evaluation_data.get("feedback", response),
-                raw_response=response
-            )
-        except Exception:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Failed to parse evaluation. Raw response: {response}",
-                raw_response=response
-            )

src/crewai/experimental/evaluation/metrics/tools_metrics.py

@@ -1,400 +0,0 @@
-import json
-from typing import Dict, Any
-
-from crewai.experimental.evaluation.base_evaluator import BaseEvaluator, EvaluationScore, MetricCategory
-from crewai.experimental.evaluation.json_parser import extract_json_from_llm_response
-from crewai.agent import Agent
-from crewai.task import Task
-
-
-class ToolSelectionEvaluator(BaseEvaluator):
-
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.TOOL_SELECTION
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: str,
-    ) -> EvaluationScore:
-        tool_uses = execution_trace.get("tool_uses", [])
-        tool_count = len(tool_uses)
-        unique_tool_types = set([tool.get("tool", "Unknown tool") for tool in tool_uses])
-
-        if tool_count == 0:
-            if not agent.tools:
-                return EvaluationScore(
-                    score=None,
-                    feedback="Agent had no tools available to use."
-                )
-            else:
-                return EvaluationScore(
-                    score=None,
-                    feedback="Agent had tools available but didn't use any."
-                )
-
-        available_tools_info = ""
-        if agent.tools:
-            for tool in agent.tools:
-                available_tools_info += f"- {tool.name}: {tool.description}\n"
-        else:
-            available_tools_info = "No tools available"
-
-        tool_types_summary = "Tools selected by the agent:\n"
-        for tool_type in sorted(unique_tool_types):
-            tool_types_summary += f"- {tool_type}\n"
-
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing if an AI agent selected the most appropriate tools for a given task.
-
-You must evaluate based on these 2 criteria:
-1. Relevance (0-10): Were the tools chosen directly aligned with the task's goals?
-2. Coverage (0-10): Did the agent select ALL appropriate tools from the AVAILABLE tools?
-
-IMPORTANT:
-- ONLY consider tools that are listed as available to the agent
-- DO NOT suggest tools that aren't in the 'Available tools' list
-- DO NOT evaluate the quality or accuracy of tool outputs/results
-- DO NOT evaluate how many times each tool was used
-- DO NOT evaluate how the agent used the parameters
-- DO NOT evaluate whether the agent interpreted the task correctly
-
-Focus ONLY on whether the correct CATEGORIES of tools were selected from what was available.
-
-Return your evaluation as JSON with these fields:
-- scores: {"relevance": number, "coverage": number}
-- overall_score: number (average of all scores, 0-10)
-- feedback: string (focused ONLY on tool selection decisions from available tools)
-- improvement_suggestions: string (ONLY suggest better selection from the AVAILABLE tools list, NOT new tools)
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Available tools for this agent:
-{available_tools_info}
-
-{tool_types_summary}
-
-Based ONLY on the task description and comparing the AVAILABLE tools with those that were selected (listed above), evaluate if the agent selected the appropriate tool types for this task.
-
-IMPORTANT:
-- ONLY evaluate selection from tools listed as available
-- DO NOT suggest new tools that aren't in the available tools list
-- DO NOT evaluate tool usage or results
-"""}
-        ]
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-
-            scores = evaluation_data.get("scores", {})
-            relevance = scores.get("relevance", 5.0)
-            coverage = scores.get("coverage", 5.0)
-            overall_score = float(evaluation_data.get("overall_score", 5.0))
-
-            feedback = "Tool Selection Evaluation:\n"
-            feedback += f"• Relevance: {relevance}/10 - Selection of appropriate tool types for the task\n"
-            feedback += f"• Coverage: {coverage}/10 - Selection of all necessary tool types\n"
-            if "improvement_suggestions" in evaluation_data:
-                feedback += f"Improvement Suggestions:\n{evaluation_data['improvement_suggestions']}"
-            else:
-                feedback += evaluation_data.get("feedback", "No detailed feedback available.")
-
-            return EvaluationScore(
-                score=overall_score,
-                feedback=feedback,
-                raw_response=response
-            )
-        except Exception as e:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Error evaluating tool selection: {e}",
-                raw_response=response
-            )
-
-
-class ParameterExtractionEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.PARAMETER_EXTRACTION
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: str,
-    ) -> EvaluationScore:
-        tool_uses = execution_trace.get("tool_uses", [])
-        tool_count = len(tool_uses)
-
-        if tool_count == 0:
-            return EvaluationScore(
-                score=None,
-                feedback="No tool usage detected. Cannot evaluate parameter extraction."
-            )
-
-        validation_errors = []
-        for tool_use in tool_uses:
-            if not tool_use.get("success", True) and tool_use.get("error_type") == "validation_error":
-                validation_errors.append({
-                    "tool": tool_use.get("tool", "Unknown tool"),
-                    "error": tool_use.get("result"),
-                    "args": tool_use.get("args", {})
-                })
-
-        validation_error_rate = len(validation_errors) / tool_count if tool_count > 0 else 0
-
-        param_samples = []
-        for i, tool_use in enumerate(tool_uses[:5]):
-            tool_name = tool_use.get("tool", "Unknown tool")
-            tool_args = tool_use.get("args", {})
-            success = tool_use.get("success", True) and not tool_use.get("error", False)
-            error_type = tool_use.get("error_type", "") if not success else ""
-
-            is_validation_error = error_type == "validation_error"
-
-            sample = f"Tool use #{i+1} - {tool_name}:\n"
-            sample += f"- Parameters: {json.dumps(tool_args, indent=2)}\n"
-            sample += f"- Success: {'No' if not success else 'Yes'}"
-
-            if is_validation_error:
-                sample += " (PARAMETER VALIDATION ERROR)\n"
-                sample += f"- Error: {tool_use.get('result', 'Unknown error')}"
-            elif not success:
-                sample += f" (Other error: {error_type})\n"
-
-            param_samples.append(sample)
-
-        validation_errors_info = ""
-        if validation_errors:
-            validation_errors_info = f"\nParameter validation errors detected: {len(validation_errors)} ({validation_error_rate:.1%} of tool uses)\n"
-            for i, err in enumerate(validation_errors[:3]):
-                tool_name = err.get("tool", "Unknown tool")
-                error_msg = err.get("error", "Unknown error")
-                args = err.get("args", {})
-                validation_errors_info += f"\nValidation Error #{i+1}:\n- Tool: {tool_name}\n- Args: {json.dumps(args, indent=2)}\n- Error: {error_msg}"
-
-            if len(validation_errors) > 3:
-                validation_errors_info += f"\n...and {len(validation_errors) - 3} more validation errors."
-        param_samples_text = "\n\n".join(param_samples)
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing how well an AI agent extracts and formats PARAMETER VALUES for tool calls.
-
-Your job is to evaluate ONLY whether the agent used the correct parameter VALUES, not whether the right tools were selected or how the tools were invoked.
-
-Evaluate parameter extraction based on these criteria:
-1. Accuracy (0-10): Are parameter values correctly identified from the context/task?
-2. Formatting (0-10): Are values formatted correctly for each tool's requirements?
-3. Completeness (0-10): Are all required parameter values provided, with no missing information?
-
-IMPORTANT: DO NOT evaluate:
-- Whether the right tool was chosen (that's the ToolSelectionEvaluator's job)
-- How the tools were structurally invoked (that's the ToolInvocationEvaluator's job)
-- The quality of results from tools
-
-Focus ONLY on the PARAMETER VALUES - whether they were correctly extracted from the context, properly formatted, and complete.
-
-Validation errors are important signals that parameter values weren't properly extracted or formatted.
-
-Return your evaluation as JSON with these fields:
-- scores: {"accuracy": number, "formatting": number, "completeness": number}
-- overall_score: number (average of all scores, 0-10)
-- feedback: string (focused ONLY on parameter value extraction quality)
-- improvement_suggestions: string (concrete suggestions for better parameter VALUE extraction)
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Parameter extraction examples:
-{param_samples_text}
-{validation_errors_info}
-
-Evaluate the quality of the agent's parameter extraction for this task.
-"""}
-        ]
-
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-
-            scores = evaluation_data.get("scores", {})
-            accuracy = scores.get("accuracy", 5.0)
-            formatting = scores.get("formatting", 5.0)
-            completeness = scores.get("completeness", 5.0)
-
-            overall_score = float(evaluation_data.get("overall_score", 5.0))
-
-            feedback = "Parameter Extraction Evaluation:\n"
-            feedback += f"• Accuracy: {accuracy}/10 - Correctly identifying required parameters\n"
-            feedback += f"• Formatting: {formatting}/10 - Properly formatting parameters for tools\n"
-            feedback += f"• Completeness: {completeness}/10 - Including all necessary information\n\n"
-
-            if "improvement_suggestions" in evaluation_data:
-                feedback += f"Improvement Suggestions:\n{evaluation_data['improvement_suggestions']}"
-            else:
-                feedback += evaluation_data.get("feedback", "No detailed feedback available.")
-
-            return EvaluationScore(
-                score=overall_score,
-                feedback=feedback,
-                raw_response=response
-            )
-        except Exception as e:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Error evaluating parameter extraction: {e}",
-                raw_response=response
-            )
-
-
-class ToolInvocationEvaluator(BaseEvaluator):
-    @property
-    def metric_category(self) -> MetricCategory:
-        return MetricCategory.TOOL_INVOCATION
-
-    def evaluate(
-        self,
-        agent: Agent,
-        task: Task,
-        execution_trace: Dict[str, Any],
-        final_output: str,
-    ) -> EvaluationScore:
-        tool_uses = execution_trace.get("tool_uses", [])
-        tool_errors = []
-        tool_count = len(tool_uses)
-
-        if tool_count == 0:
-            return EvaluationScore(
-                score=None,
-                feedback="No tool usage detected. Cannot evaluate tool invocation."
-            )
-
-        for tool_use in tool_uses:
-            if not tool_use.get("success", True) or tool_use.get("error", False):
-                error_info = {
-                    "tool": tool_use.get("tool", "Unknown tool"),
-                    "error": tool_use.get("result"),
-                    "error_type": tool_use.get("error_type", "unknown_error")
-                }
-                tool_errors.append(error_info)
-
-        error_rate = len(tool_errors) / tool_count if tool_count > 0 else 0
-
-        error_types = {}
-        for error in tool_errors:
-            error_type = error.get("error_type", "unknown_error")
-            if error_type not in error_types:
-                error_types[error_type] = 0
-            error_types[error_type] += 1
-
-        invocation_samples = []
-        for i, tool_use in enumerate(tool_uses[:5]):
-            tool_name = tool_use.get("tool", "Unknown tool")
-            tool_args = tool_use.get("args", {})
-            success = tool_use.get("success", True) and not tool_use.get("error", False)
-            error_type = tool_use.get("error_type", "") if not success else ""
-            error_msg = tool_use.get("result", "No error") if not success else "No error"
-
-            sample = f"Tool invocation #{i+1}:\n"
-            sample += f"- Tool: {tool_name}\n"
-            sample += f"- Parameters: {json.dumps(tool_args, indent=2)}\n"
-            sample += f"- Success: {'No' if not success else 'Yes'}\n"
-            if not success:
-                sample += f"- Error type: {error_type}\n"
-                sample += f"- Error: {error_msg}"
-            invocation_samples.append(sample)
-
-        error_type_summary = ""
-        if error_types:
-            error_type_summary = "Error type breakdown:\n"
-            for error_type, count in error_types.items():
-                error_type_summary += f"- {error_type}: {count} occurrences ({(count/tool_count):.1%})\n"
-
-        invocation_samples_text = "\n\n".join(invocation_samples)
-        prompt = [
-            {"role": "system", "content": """You are an expert evaluator assessing how correctly an AI agent's tool invocations are STRUCTURED.
-
-Your job is to evaluate ONLY the structural and syntactical aspects of how the agent called tools, NOT which tools were selected or what parameter values were used.
-
-Evaluate the agent's tool invocation based on these criteria:
-1. Structure (0-10): Does the tool call follow the expected syntax and format?
-2. Error Handling (0-10): Does the agent handle tool errors appropriately?
-3. Invocation Patterns (0-10): Are tool calls properly sequenced, batched, or managed?
-
-Error types that indicate invocation issues:
-- execution_error: The tool was called correctly but failed during execution
-- usage_error: General errors in how the tool was used structurally
-
-IMPORTANT: DO NOT evaluate:
-- Whether the right tool was chosen (that's the ToolSelectionEvaluator's job)
-- Whether the parameter values are correct (that's the ParameterExtractionEvaluator's job)
-- The quality of results from tools
-
-Focus ONLY on HOW tools were invoked - the structure, format, and handling of the invocation process.
-
-Return your evaluation as JSON with these fields:
-- scores: {"structure": number, "error_handling": number, "invocation_patterns": number}
-- overall_score: number (average of all scores, 0-10)
-- feedback: string (focused ONLY on structural aspects of tool invocation)
-- improvement_suggestions: string (concrete suggestions for better structuring of tool calls)
-"""},
-            {"role": "user", "content": f"""
-Agent role: {agent.role}
-Task description: {task.description}
-
-Tool invocation examples:
-{invocation_samples_text}
-
-Tool error rate: {error_rate:.2%} ({len(tool_errors)} errors out of {tool_count} invocations)
-{error_type_summary}
-
-Evaluate the quality of the agent's tool invocation structure during this task.
-"""}
-        ]
-
-        assert self.llm is not None
-        response = self.llm.call(prompt)
-
-        try:
-            evaluation_data = extract_json_from_llm_response(response)
-            assert evaluation_data is not None
-            scores = evaluation_data.get("scores", {})
-            structure = scores.get("structure", 5.0)
-            error_handling = scores.get("error_handling", 5.0)
-            invocation_patterns = scores.get("invocation_patterns", 5.0)
-
-            overall_score = float(evaluation_data.get("overall_score", 5.0))
-
-            feedback = "Tool Invocation Evaluation:\n"
-            feedback += f"• Structure: {structure}/10 - Following proper syntax and format\n"
-            feedback += f"• Error Handling: {error_handling}/10 - Appropriately handling tool errors\n"
-            feedback += f"• Invocation Patterns: {invocation_patterns}/10 - Proper sequencing and management of calls\n\n"
-
-            if "improvement_suggestions" in evaluation_data:
-                feedback += f"Improvement Suggestions:\n{evaluation_data['improvement_suggestions']}"
-            else:
-                feedback += evaluation_data.get("feedback", "No detailed feedback available.")
-
-            return EvaluationScore(
-                score=overall_score,
-                feedback=feedback,
-                raw_response=response
-            )
-        except Exception as e:
-            return EvaluationScore(
-                score=None,
-                feedback=f"Error evaluating tool invocation: {e}",
-                raw_response=response
-            )

src/crewai/lite_agent.py

@@ -28,7 +28,7 @@ from pydantic import (
     InstanceOf,
     PrivateAttr,
     model_validator,
-    field_validator
+    field_validator,
 )
 
 from crewai.agents.agent_builder.base_agent import BaseAgent
@@ -40,7 +40,7 @@ from crewai.agents.parser import (
     OutputParserException,
 )
 from crewai.flow.flow_trackable import FlowTrackable
-from crewai.llm import LLM, BaseLLM
+from crewai.llm import LLM
 from crewai.tools.base_tool import BaseTool
 from crewai.tools.structured_tool import CrewStructuredTool
 from crewai.utilities import I18N
@@ -135,7 +135,7 @@ class LiteAgent(FlowTrackable, BaseModel):
     role: str = Field(description="Role of the agent")
     goal: str = Field(description="Goal of the agent")
     backstory: str = Field(description="Backstory of the agent")
-    llm: Optional[Union[str, InstanceOf[BaseLLM], Any]] = Field(
+    llm: Optional[Union[str, InstanceOf[LLM], Any]] = Field(
         default=None, description="Language model that will run the agent"
     )
     tools: List[BaseTool] = Field(
@@ -209,8 +209,8 @@ class LiteAgent(FlowTrackable, BaseModel):
     def setup_llm(self):
         """Set up the LLM and other components after initialization."""
         self.llm = create_llm(self.llm)
-        if not isinstance(self.llm, BaseLLM):
-            raise ValueError(f"Expected LLM instance of type BaseLLM, got {type(self.llm).__name__}")
+        if not isinstance(self.llm, LLM):
+            raise ValueError("Unable to create LLM instance")
 
         # Initialize callbacks
         token_callback = TokenCalcHandler(token_cost_process=self._token_process)
@@ -232,8 +232,7 @@ class LiteAgent(FlowTrackable, BaseModel):
         elif isinstance(self.guardrail, str):
             from crewai.tasks.llm_guardrail import LLMGuardrail
 
-            if not isinstance(self.llm, BaseLLM):
-                raise TypeError(f"Guardrail requires LLM instance of type BaseLLM, got {type(self.llm).__name__}")
+            assert isinstance(self.llm, LLM)
 
             self._guardrail = LLMGuardrail(description=self.guardrail, llm=self.llm)
 
@@ -538,7 +537,6 @@ class LiteAgent(FlowTrackable, BaseModel):
                     crewai_event_bus.emit(
                         self,
                         event=LLMCallCompletedEvent(
-                            messages=self._messages,
                             response=answer,
                             call_type=LLMCallType.LLM_CALL,
                             from_agent=self,
@@ -621,4 +619,4 @@ class LiteAgent(FlowTrackable, BaseModel):
 
     def _append_message(self, text: str, role: str = "assistant") -> None:
         """Append a message to the message list with the given role."""
-        self._messages.append(format_message_for_llm(text, role=role))
+        self._messages.append(format_message_for_llm(text, role=role))

src/crewai/llm.py

@@ -508,6 +508,7 @@ class LLM(BaseLLM):
                             # Enable tool calls using streaming
                             if "tool_calls" in delta:
                                 tool_calls = delta["tool_calls"]
+
                                 if tool_calls:
                                     result = self._handle_streaming_tool_calls(
                                         tool_calls=tool_calls,
@@ -516,7 +517,6 @@ class LLM(BaseLLM):
                                         from_task=from_task,
                                         from_agent=from_agent,
                                     )
-
                                     if result is not None:
                                         chunk_content = result
 
@@ -631,7 +631,7 @@ class LLM(BaseLLM):
                 # Log token usage if available in streaming mode
                 self._handle_streaming_callbacks(callbacks, usage_info, last_chunk)
                 # Emit completion event and return response
-                self._handle_emit_call_events(response=full_response, call_type=LLMCallType.LLM_CALL, from_task=from_task, from_agent=from_agent, messages=params["messages"])
+                self._handle_emit_call_events(full_response, LLMCallType.LLM_CALL, from_task, from_agent)
                 return full_response
 
             # --- 9) Handle tool calls if present
@@ -643,7 +643,7 @@ class LLM(BaseLLM):
             self._handle_streaming_callbacks(callbacks, usage_info, last_chunk)
 
             # --- 11) Emit completion event and return response
-            self._handle_emit_call_events(response=full_response, call_type=LLMCallType.LLM_CALL, from_task=from_task, from_agent=from_agent, messages=params["messages"])
+            self._handle_emit_call_events(full_response, LLMCallType.LLM_CALL, from_task, from_agent)
             return full_response
 
         except ContextWindowExceededError as e:
@@ -655,7 +655,7 @@ class LLM(BaseLLM):
             logging.error(f"Error in streaming response: {str(e)}")
             if full_response.strip():
                 logging.warning(f"Returning partial response despite error: {str(e)}")
-                self._handle_emit_call_events(response=full_response, call_type=LLMCallType.LLM_CALL, from_task=from_task, from_agent=from_agent, messages=params["messages"])
+                self._handle_emit_call_events(full_response, LLMCallType.LLM_CALL, from_task, from_agent)
                 return full_response
 
             # Emit failed event and re-raise the exception
@@ -809,7 +809,7 @@ class LLM(BaseLLM):
 
         # --- 5) If no tool calls or no available functions, return the text response directly
         if not tool_calls or not available_functions:
-            self._handle_emit_call_events(response=text_response, call_type=LLMCallType.LLM_CALL, from_task=from_task, from_agent=from_agent, messages=params["messages"])
+            self._handle_emit_call_events(text_response, LLMCallType.LLM_CALL, from_task, from_agent)
             return text_response
 
         # --- 6) Handle tool calls if present
@@ -818,7 +818,7 @@ class LLM(BaseLLM):
             return tool_result
 
         # --- 7) If tool call handling didn't return a result, emit completion event and return text response
-        self._handle_emit_call_events(response=text_response, call_type=LLMCallType.LLM_CALL, from_task=from_task, from_agent=from_agent, messages=params["messages"])
+        self._handle_emit_call_events(text_response, LLMCallType.LLM_CALL, from_task, from_agent)
         return text_response
 
     def _handle_tool_call(
@@ -861,7 +861,6 @@ class LLM(BaseLLM):
                         tool_args=function_args,
                     ),
                 )
-
                 result = fn(**function_args)
                 crewai_event_bus.emit(
                     self,
@@ -875,7 +874,7 @@ class LLM(BaseLLM):
                 )
 
                 # --- 3.3) Emit success event
-                self._handle_emit_call_events(response=result, call_type=LLMCallType.TOOL_CALL)
+                self._handle_emit_call_events(result, LLMCallType.TOOL_CALL)
                 return result
             except Exception as e:
                 # --- 3.4) Handle execution errors
@@ -992,20 +991,17 @@ class LLM(BaseLLM):
                 logging.error(f"LiteLLM call failed: {str(e)}")
                 raise
 
-    def _handle_emit_call_events(self, response: Any, call_type: LLMCallType, from_task: Optional[Any] = None, from_agent: Optional[Any] = None, messages: str | list[dict[str, Any]] | None = None):
+    def _handle_emit_call_events(self, response: Any, call_type: LLMCallType, from_task: Optional[Any] = None, from_agent: Optional[Any] = None):
         """Handle the events for the LLM call.
 
         Args:
             response (str): The response from the LLM call.
             call_type (str): The type of call, either "tool_call" or "llm_call".
-            from_task: Optional task object
-            from_agent: Optional agent object
-            messages: Optional messages object
         """
         assert hasattr(crewai_event_bus, "emit")
         crewai_event_bus.emit(
             self,
-            event=LLMCallCompletedEvent(messages=messages, response=response, call_type=call_type, from_task=from_task, from_agent=from_agent),
+            event=LLMCallCompletedEvent(response=response, call_type=call_type, from_task=from_task, from_agent=from_agent),
         )
 
     def _format_messages_for_provider(

src/crewai/task.py

@@ -67,7 +67,6 @@ class Task(BaseModel):
         description: Descriptive text detailing task's purpose and execution.
         expected_output: Clear definition of expected task outcome.
         output_file: File path for storing task output.
-        create_directory: Whether to create the directory for output_file if it doesn't exist.
         output_json: Pydantic model for structuring JSON output.
         output_pydantic: Pydantic model for task output.
         security_config: Security configuration including fingerprinting.
@@ -116,10 +115,6 @@ class Task(BaseModel):
         description="A file path to be used to create a file output.",
         default=None,
     )
-    create_directory: Optional[bool] = Field(
-        description="Whether to create the directory for output_file if it doesn't exist.",
-        default=True,
-    )
     output: Optional[TaskOutput] = Field(
         description="Task output, it's final result after being executed", default=None
     )
@@ -758,10 +753,8 @@ Follow these guidelines:
             resolved_path = Path(self.output_file).expanduser().resolve()
             directory = resolved_path.parent
 
-            if self.create_directory and not directory.exists():
+            if not directory.exists():
                 directory.mkdir(parents=True, exist_ok=True)
-            elif not self.create_directory and not directory.exists():
-                raise RuntimeError(f"Directory {directory} does not exist and create_directory is False")
 
             with resolved_path.open("w", encoding="utf-8") as file:
                 if isinstance(result, dict):

src/crewai/tasks/llm_guardrail.py

@@ -1,9 +1,10 @@
-from typing import Any, Tuple
+from typing import Any, Optional, Tuple
 
 from pydantic import BaseModel, Field
 
 from crewai.agent import Agent, LiteAgentOutput
-from crewai.llm import BaseLLM
+from crewai.llm import LLM
+from crewai.task import Task
 from crewai.tasks.task_output import TaskOutput
 
 
@@ -31,11 +32,11 @@ class LLMGuardrail:
     def __init__(
         self,
         description: str,
-        llm: BaseLLM,
+        llm: LLM,
     ):
         self.description = description
 
-        self.llm: BaseLLM = llm
+        self.llm: LLM = llm
 
     def _validate_output(self, task_output: TaskOutput) -> LiteAgentOutput:
         agent = Agent(

src/crewai/utilities/crew/__init__.py

@@ -1 +0,0 @@
-"""Crew-specific utilities."""

src/crewai/utilities/crew/crew_context.py

@@ -1,16 +0,0 @@
-"""Context management utilities for tracking crew and task execution context using OpenTelemetry baggage."""
-
-from typing import Optional
-
-from opentelemetry import baggage
-
-from crewai.utilities.crew.models import CrewContext
-
-
-def get_crew_context() -> Optional[CrewContext]:
-    """Get the current crew context from OpenTelemetry baggage.
-
-    Returns:
-        CrewContext instance containing crew context information, or None if no context is set
-    """
-    return baggage.get_baggage("crew_context")

src/crewai/utilities/crew/models.py

@@ -1,16 +0,0 @@
-"""Models for crew-related data structures."""
-
-from typing import Optional
-
-from pydantic import BaseModel, Field
-
-
-class CrewContext(BaseModel):
-    """Model representing crew context information."""
-
-    id: Optional[str] = Field(
-        default=None, description="Unique identifier for the crew"
-    )
-    key: Optional[str] = Field(
-        default=None, description="Optional crew key/name for identification"
-    )

src/crewai/utilities/evaluators/crew_evaluator_handler.py

@@ -155,7 +155,6 @@ class CrewEvaluator:
         )
 
         console = Console()
-        console.print("\n")
         console.print(table)
 
     def evaluate(self, task_output: TaskOutput):

src/crewai/utilities/events/llm_events.py

@@ -48,8 +48,8 @@ class LLMCallStartedEvent(LLMEventBase):
     """
 
     type: str = "llm_call_started"
-    messages: Optional[Union[str, List[Dict[str, Any]]]] = None
-    tools: Optional[List[dict[str, Any]]] = None
+    messages: Union[str, List[Dict[str, Any]]]
+    tools: Optional[List[dict]] = None
     callbacks: Optional[List[Any]] = None
     available_functions: Optional[Dict[str, Any]] = None
 
@@ -58,10 +58,10 @@ class LLMCallCompletedEvent(LLMEventBase):
     """Event emitted when a LLM call completes"""
 
     type: str = "llm_call_completed"
-    messages: str | list[dict[str, Any]] | None = None
     response: Any
     call_type: LLMCallType
 
+
 class LLMCallFailedEvent(LLMEventBase):
     """Event emitted when a LLM call fails"""
 

src/crewai/utilities/events/llm_guardrail_events.py

@@ -1,4 +1,3 @@
-from inspect import getsource
 from typing import Any, Callable, Optional, Union
 
 from crewai.utilities.events.base_events import BaseEvent
@@ -17,26 +16,23 @@ class LLMGuardrailStartedEvent(BaseEvent):
     retry_count: int
 
     def __init__(self, **data):
+        from inspect import getsource
+
         from crewai.tasks.llm_guardrail import LLMGuardrail
         from crewai.tasks.hallucination_guardrail import HallucinationGuardrail
 
         super().__init__(**data)
 
-        if isinstance(self.guardrail, (LLMGuardrail, HallucinationGuardrail)):
+        if isinstance(self.guardrail, LLMGuardrail) or isinstance(
+            self.guardrail, HallucinationGuardrail
+        ):
             self.guardrail = self.guardrail.description.strip()
         elif isinstance(self.guardrail, Callable):
             self.guardrail = getsource(self.guardrail).strip()
 
 
 class LLMGuardrailCompletedEvent(BaseEvent):
-    """Event emitted when a guardrail task completes
-
-    Attributes:
-        success: Whether the guardrail validation passed
-        result: The validation result
-        error: Error message if validation failed
-        retry_count: The number of times the guardrail has been retried
-    """
+    """Event emitted when a guardrail task completes"""
 
     type: str = "llm_guardrail_completed"
     success: bool

tests/agent_test.py

@@ -1896,80 +1896,6 @@ def test_agent_with_knowledge_sources_generate_search_query():
         assert "red" in result.raw.lower()
 
 
-@pytest.mark.vcr(record_mode='none', filter_headers=["authorization"])
-def test_agent_with_knowledge_with_no_crewai_knowledge():
-    mock_knowledge = MagicMock(spec=Knowledge)
-
-    agent = Agent(
-        role="Information Agent",
-        goal="Provide information based on knowledge sources",
-        backstory="You have access to specific knowledge sources.",
-        llm=LLM(model="openrouter/openai/gpt-4o-mini",api_key=os.getenv('OPENROUTER_API_KEY')),
-        knowledge=mock_knowledge
-    )
-
-    # Create a task that requires the agent to use the knowledge
-    task = Task(
-        description="What is Vidit's favorite color?",
-        expected_output="Vidit's favorclearite color.",
-        agent=agent,
-    )
-
-    crew = Crew(agents=[agent], tasks=[task])
-    crew.kickoff()
-    mock_knowledge.query.assert_called_once()
-
-
-@pytest.mark.vcr(record_mode='none', filter_headers=["authorization"])
-def test_agent_with_only_crewai_knowledge():
-    mock_knowledge = MagicMock(spec=Knowledge)
-
-    agent = Agent(
-        role="Information Agent",
-        goal="Provide information based on knowledge sources",
-        backstory="You have access to specific knowledge sources.",
-        llm=LLM(model="openrouter/openai/gpt-4o-mini",api_key=os.getenv('OPENROUTER_API_KEY'))
-    )
-
-    # Create a task that requires the agent to use the knowledge
-    task = Task(
-        description="What is Vidit's favorite color?",
-        expected_output="Vidit's favorclearite color.",
-        agent=agent
-    )
-
-    crew = Crew(agents=[agent], tasks=[task],knowledge=mock_knowledge)
-    crew.kickoff()
-    mock_knowledge.query.assert_called_once()
-
-
-@pytest.mark.vcr(record_mode='none', filter_headers=["authorization"])
-def test_agent_knowledege_with_crewai_knowledge():
-    crew_knowledge = MagicMock(spec=Knowledge)
-    agent_knowledge = MagicMock(spec=Knowledge)
-
-
-    agent = Agent(
-        role="Information Agent",
-        goal="Provide information based on knowledge sources",
-        backstory="You have access to specific knowledge sources.",
-        llm=LLM(model="openrouter/openai/gpt-4o-mini",api_key=os.getenv('OPENROUTER_API_KEY')),
-        knowledge=agent_knowledge
-    )
-
-    # Create a task that requires the agent to use the knowledge
-    task = Task(
-        description="What is Vidit's favorite color?",
-        expected_output="Vidit's favorclearite color.",
-        agent=agent,
-    )
-
-    crew = Crew(agents=[agent],tasks=[task],knowledge=crew_knowledge)
-    crew.kickoff()
-    agent_knowledge.query.assert_called_once()
-    crew_knowledge.query.assert_called_once()
-
-
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_litellm_auth_error_handling():
     """Test that LiteLLM authentication errors are handled correctly and not retried."""

tests/cassettes/test_agent_knowledege_with_crewai_knowledge.yaml

@@ -1,150 +0,0 @@
-interactions:
-- request:
-    body: '{"model": "openai/gpt-4o-mini", "messages": [{"role": "system", "content":
-      "Your goal is to rewrite the user query so that it is optimized for retrieval
-      from a vector database. Consider how the query will be used to find relevant
-      documents, and aim to make it more specific and context-aware. \n\n Do not include
-      any other text than the rewritten query, especially any preamble or postamble
-      and only add expected output format if its relevant to the rewritten query.
-      \n\n Focus on the key words of the intended task and to retrieve the most relevant
-      information. \n\n There will be some extra context provided that might need
-      to be removed such as expected_output formats structured_outputs and other instructions."},
-      {"role": "user", "content": "The original query is: What is Vidit''s favorite
-      color?\n\nThis is the expected criteria for your final answer: Vidit''s favorclearite
-      color.\nyou MUST return the actual complete content as the final answer, not
-      a summary.."}], "stream": false, "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '1017'
-      content-type:
-      - application/json
-      host:
-      - openrouter.ai
-      http-referer:
-      - https://litellm.ai
-      user-agent:
-      - litellm/1.68.0
-      x-title:
-      - liteLLM
-    method: POST
-    uri: https://openrouter.ai/api/v1/chat/completions
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAAwAAAP//4lKAAS4AAAAA//90kE1vE0EMhv9K9V64TMrmgyadG8ceECAhhIrQarrj
-        3bidHY/GTgSK9r+jpUpaJLja78djn8ARHgPlxXK72a6X6+12szhq7Id72d2V8b58/nbzQb98gkOp
-        cuRIFR4fC+X3d3AYJVKChxTKgd8OxRYbWYycGQ7y8EidwaPbB7vuZCyJjCXDoasUjCL8S61Dtxfu
-        SOG/n5BkKFUeFD4fUnLoObPu20pBJcNDTQoccjA+UvufLedIP+Ebh5FUw0DwJ1RJBI+gymoh20wj
-        2SjPpF85sr3Rqz4cpbLRVSdJ6jUcKvUHDenM81zFeXgeTNMPB/2lRuMMM1Atlf8k9qVt1rer3WrV
-        3DZwOJw5SpWxWGvyRFnnR7ybQc4/usxvHEwspBfhbun+NreRLHDSObUL3Z7iRdxM/wh9rb/c8coy
-        Tb8BAAD//wMAqVt3JyMCAAA=
-    headers:
-      Access-Control-Allow-Origin:
-      - '*'
-      CF-RAY:
-      - 9402cb503aec46c0-BOM
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 15 May 2025 12:56:14 GMT
-      Server:
-      - cloudflare
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Accept-Encoding
-      x-clerk-auth-message:
-      - Invalid JWT form. A JWT consists of three parts separated by dots. (reason=token-invalid,
-        token-carrier=header)
-      x-clerk-auth-reason:
-      - token-invalid
-      x-clerk-auth-status:
-      - signed-out
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"model": "openai/gpt-4o-mini", "messages": [{"role": "system", "content":
-      "You are Information Agent. You have access to specific knowledge sources.\nYour
-      personal goal is: Provide information based on knowledge sources\nTo give my
-      best complete final answer to the task respond using the exact following format:\n\nThought:
-      I now can give a great answer\nFinal Answer: Your final answer must be the great
-      and the most complete as possible, it must be outcome described.\n\nI MUST use
-      these formats, my job depends on it!"}, {"role": "user", "content": "\nCurrent
-      Task: What is Vidit''s favorite color?\n\nThis is the expected criteria for
-      your final answer: Vidit''s favorclearite color.\nyou MUST return the actual
-      complete content as the final answer, not a summary.\n\nBegin! This is VERY
-      important to you, use the tools available and give your best Final Answer, your
-      job depends on it!\n\nThought:"}], "stream": false, "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '951'
-      content-type:
-      - application/json
-      host:
-      - openrouter.ai
-      http-referer:
-      - https://litellm.ai
-      user-agent:
-      - litellm/1.68.0
-      x-title:
-      - liteLLM
-    method: POST
-    uri: https://openrouter.ai/api/v1/chat/completions
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAAwAAAP//4lKAAS4AAAAA///iQjABAAAA//90kE9rG0EMxb/K8C69jNON7WJ7boFS
-        CD2ENm2g/1jGs/Ja7aw0zIydBuPvXjbBcQrtUU9P0u/pAO7g0JNMLhfzxexytli8mdy8r7c6/3Lb
-        v13eff00088fPj7AImXdc0cZDjeJ5OoaFoN2FOGgicTz6z7VyVwnAwvDQtc/KVQ4hK2vF0GHFKmy
-        CixCJl+pgzuftQhb5UAF7tsBUfuUdV3gZBejxYaFy7bN5IsKHErVBAvxlffU/qfL0tFvuMZioFJ8
-        T3AHZI0EB18Kl+qljjQqlWQkvTai9yZ4MT3vyXjTj6DGS7mnbMx3ecfio7l6rJ25447rq2I2fq+Z
-        K5mgUbPhYtZxRxewyLTZFR9PMZ4IWfon4Xj8YVEeSqVhzNBTTpkfQTapbWar6XI6bVYNLHYn/JR1
-        SLWt+oukjP9rRv7Ta8/6yqJq9fGsLFf27+m2o+o5lnFt8GFL3bO5Of5j60v/c5AXI8fjHwAAAP//
-        AwDEkP8dZgIAAA==
-    headers:
-      Access-Control-Allow-Origin:
-      - '*'
-      CF-RAY:
-      - 9402cb55c9fe46c0-BOM
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 15 May 2025 12:56:15 GMT
-      Server:
-      - cloudflare
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Accept-Encoding
-      x-clerk-auth-message:
-      - Invalid JWT form. A JWT consists of three parts separated by dots. (reason=token-invalid,
-        token-carrier=header)
-      x-clerk-auth-reason:
-      - token-invalid
-      x-clerk-auth-status:
-      - signed-out
-    status:
-      code: 200
-      message: OK
-version: 1

tests/cassettes/test_agent_with_knowledge_with_no_crewai_knowledge.yaml

@@ -1,151 +0,0 @@
-interactions:
-- request:
-    body: '{"model": "openai/gpt-4o-mini", "messages": [{"role": "system", "content":
-      "Your goal is to rewrite the user query so that it is optimized for retrieval
-      from a vector database. Consider how the query will be used to find relevant
-      documents, and aim to make it more specific and context-aware. \n\n Do not include
-      any other text than the rewritten query, especially any preamble or postamble
-      and only add expected output format if its relevant to the rewritten query.
-      \n\n Focus on the key words of the intended task and to retrieve the most relevant
-      information. \n\n There will be some extra context provided that might need
-      to be removed such as expected_output formats structured_outputs and other instructions."},
-      {"role": "user", "content": "The original query is: What is Vidit''s favorite
-      color?\n\nThis is the expected criteria for your final answer: Vidit''s favorclearite
-      color.\nyou MUST return the actual complete content as the final answer, not
-      a summary.."}], "stream": false, "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '1017'
-      content-type:
-      - application/json
-      host:
-      - openrouter.ai
-      http-referer:
-      - https://litellm.ai
-      user-agent:
-      - litellm/1.68.0
-      x-title:
-      - liteLLM
-    method: POST
-    uri: https://openrouter.ai/api/v1/chat/completions
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAAwAAAP//4lKAAS4AAAAA//90kE1vE0EMhv9K9V64TGCbNGQ7N46gIg6IXhBaTWed
-        Xbez49HYiaii/e9oqRKKBFf7/XjsE7iHx0B5db272W2uN++b3ep585k+jcmo/XqnYXvX5m/3cChV
-        jtxThceXQvnDRzhM0lOChxTKgd8NxVY3spo4Mxzk4ZGiwSOOwd5GmUoiY8lwiJWCUQ9/qW0d4igc
-        SeG/n5BkKFUeFD4fUnLYc2Ydu0pBJcNDTQoccjA+UvefLeeefsI3DhOphoHgT6iSCB5BldVCtoVG
-        slFeSO+5Z3ujV/twlMpGV1GSVDhU2h80pDPOSxPn4WUwzz8c9FmNpoVloFoq/w7cl67Z3K7b9bq5
-        beBwOGOUKlOxzuSJsi5/2C4c5xdd5lsHEwvpj7Bt3N/mricLnHRJjSGO1F/EzfyP0Nf6yx2vLPP8
-        CwAA//8DAOHu/cIiAgAA
-    headers:
-      Access-Control-Allow-Origin:
-      - '*'
-      CF-RAY:
-      - 9402c73df9d8859c-BOM
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 15 May 2025 12:53:27 GMT
-      Server:
-      - cloudflare
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Accept-Encoding
-      x-clerk-auth-message:
-      - Invalid JWT form. A JWT consists of three parts separated by dots. (reason=token-invalid,
-        token-carrier=header)
-      x-clerk-auth-reason:
-      - token-invalid
-      x-clerk-auth-status:
-      - signed-out
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"model": "openai/gpt-4o-mini", "messages": [{"role": "system", "content":
-      "You are Information Agent. You have access to specific knowledge sources.\nYour
-      personal goal is: Provide information based on knowledge sources\nTo give my
-      best complete final answer to the task respond using the exact following format:\n\nThought:
-      I now can give a great answer\nFinal Answer: Your final answer must be the great
-      and the most complete as possible, it must be outcome described.\n\nI MUST use
-      these formats, my job depends on it!"}, {"role": "user", "content": "\nCurrent
-      Task: What is Vidit''s favorite color?\n\nThis is the expected criteria for
-      your final answer: Vidit''s favorclearite color.\nyou MUST return the actual
-      complete content as the final answer, not a summary.\n\nBegin! This is VERY
-      important to you, use the tools available and give your best Final Answer, your
-      job depends on it!\n\nThought:"}], "stream": false, "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '951'
-      content-type:
-      - application/json
-      host:
-      - openrouter.ai
-      http-referer:
-      - https://litellm.ai
-      user-agent:
-      - litellm/1.68.0
-      x-title:
-      - liteLLM
-    method: POST
-    uri: https://openrouter.ai/api/v1/chat/completions
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAAwAAAP//4lKAAS4AAAAA///iQjABAAAA//90kUGPEzEMhf+K5QuXdJmlpbvkthIg
-        emFXQoIDoMpNPFNDJo6STLul6n9H09KyIDjmxc9+/rxH8Wix4zi5vpndTK+n8+Z2wo9vXj28fHff
-        vW4+PNT5j1l6/wkNpqwb8ZzR4n3ieLdAg716DmhRE0eS512qk5lOeomCBnX1jV1Fi25N9cppnwJX
-        0YgGXWaq7NH+HmvQrVUcF7Sf9xi0S1lXBW0cQjDYSpSyXmamohEtlqoJDUaqsuHlf34len5E2xjs
-        uRTqGO0eswZGi1SKlEqxjmk0Vo5j0gVE3YKjCJ1sGAi6MShQLFvOAF/iW4kU4O74tvBRvNRnBVra
-        aJbK4DRoBikQtcJWPIcdeHVDz7GyB4mQhlUQF3ZAG5JAq8BQdMiOi4GisBiHj+ZftIHA87hePeY5
-        5cjcUfYSO1hLgZLYSSvurxRXaDBzOxQKZ4gnPhK7k3A4fDVYdqVyPxLsOKcsRwxtWvoVOZo3vm3Q
-        4HCGl7L2qS6rfudYxus1I73zYS/69NZg1UrhorwYD/yHe+m5koQytnXk1uwvxc3hH12f1l8WeWI5
-        HH4CAAD//wMAhZKqO+QCAAA=
-    headers:
-      Access-Control-Allow-Origin:
-      - '*'
-      CF-RAY:
-      - 9402c7459f3f859c-BOM
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 15 May 2025 12:53:28 GMT
-      Server:
-      - cloudflare
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Accept-Encoding
-      x-clerk-auth-message:
-      - Invalid JWT form. A JWT consists of three parts separated by dots. (reason=token-invalid,
-        token-carrier=header)
-      x-clerk-auth-reason:
-      - token-invalid
-      x-clerk-auth-status:
-      - signed-out
-    status:
-      code: 200
-      message: OK
-version: 1

tests/cassettes/test_agent_with_only_crewai_knowledge.yaml

@@ -1,150 +0,0 @@
-interactions:
-- request:
-    body: '{"model": "openai/gpt-4o-mini", "messages": [{"role": "system", "content":
-      "Your goal is to rewrite the user query so that it is optimized for retrieval
-      from a vector database. Consider how the query will be used to find relevant
-      documents, and aim to make it more specific and context-aware. \n\n Do not include
-      any other text than the rewritten query, especially any preamble or postamble
-      and only add expected output format if its relevant to the rewritten query.
-      \n\n Focus on the key words of the intended task and to retrieve the most relevant
-      information. \n\n There will be some extra context provided that might need
-      to be removed such as expected_output formats structured_outputs and other instructions."},
-      {"role": "user", "content": "The original query is: What is Vidit''s favorite
-      color?\n\nThis is the expected criteria for your final answer: Vidit''s favorclearite
-      color.\nyou MUST return the actual complete content as the final answer, not
-      a summary.."}], "stream": false, "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '1017'
-      content-type:
-      - application/json
-      host:
-      - openrouter.ai
-      http-referer:
-      - https://litellm.ai
-      user-agent:
-      - litellm/1.68.0
-      x-title:
-      - liteLLM
-    method: POST
-    uri: https://openrouter.ai/api/v1/chat/completions
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAAwAAAP//4lKAAS4AAAAA//90kE1PIzEMhv8Kei97Sdnplwq5gTgAF8ShcFitRmnG
-        nTFk4ihxq11V899Xs6gFJLja78djH8ANLFqKk+lqsZpP56vpYqJhublfP1eP65v1i79Lt9fdMwxS
-        lj03lGHxkChe3cGgl4YCLCRRdPyzTTpZyKTnyDCQzQt5hYXvnJ576VMgZYkw8JmcUgP7XmvgO2FP
-        BfbXAUHalGVTYOMuBIMtRy5dnckVibAoKgkG0Snvqf5my7GhP7CVQU+luJZgD8gSCBauFC7qoo40
-        EpXiSPrEDeuPcrZ1e8msdOYlSIZBpu2uuHDEeWvi2L4NhuG3QflblPqRpaWcMv8P3Ka6ml/OLmaz
-        6rKCwe6IkbL0SWuVV4pl/MNy5Di+6DRfGqioC+/Ci8p8NtcNqeNQxlTvfEfNSVwNX4R+1J/u+GAZ
-        hn8AAAD//wMAIwJ79CICAAA=
-    headers:
-      Access-Control-Allow-Origin:
-      - '*'
-      CF-RAY:
-      - 9402c9db99ec4722-BOM
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 15 May 2025 12:55:14 GMT
-      Server:
-      - cloudflare
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Accept-Encoding
-      x-clerk-auth-message:
-      - Invalid JWT form. A JWT consists of three parts separated by dots. (reason=token-invalid,
-        token-carrier=header)
-      x-clerk-auth-reason:
-      - token-invalid
-      x-clerk-auth-status:
-      - signed-out
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"model": "openai/gpt-4o-mini", "messages": [{"role": "system", "content":
-      "You are Information Agent. You have access to specific knowledge sources.\nYour
-      personal goal is: Provide information based on knowledge sources\nTo give my
-      best complete final answer to the task respond using the exact following format:\n\nThought:
-      I now can give a great answer\nFinal Answer: Your final answer must be the great
-      and the most complete as possible, it must be outcome described.\n\nI MUST use
-      these formats, my job depends on it!"}, {"role": "user", "content": "\nCurrent
-      Task: What is Vidit''s favorite color?\n\nThis is the expected criteria for
-      your final answer: Vidit''s favorclearite color.\nyou MUST return the actual
-      complete content as the final answer, not a summary.\n\nBegin! This is VERY
-      important to you, use the tools available and give your best Final Answer, your
-      job depends on it!\n\nThought:"}], "stream": false, "stop": ["\nObservation:"]}'
-    headers:
-      accept:
-      - '*/*'
-      accept-encoding:
-      - gzip, deflate
-      connection:
-      - keep-alive
-      content-length:
-      - '951'
-      content-type:
-      - application/json
-      host:
-      - openrouter.ai
-      http-referer:
-      - https://litellm.ai
-      user-agent:
-      - litellm/1.68.0
-      x-title:
-      - liteLLM
-    method: POST
-    uri: https://openrouter.ai/api/v1/chat/completions
-  response:
-    body:
-      string: !!binary |
-        H4sIAAAAAAAAAwAAAP//4lKAAS4AAAAA///iQjABAAAA//90kN1qGzEQRl9FfNdyul4nday73ARy
-        VUpLE2jLIu+O15NoZ4QkOy1moa/R1+uTlE1wnEB7qU/zc84cwB0cepLZfHm+XMwXy/nF7II/3d7V
-        H+tOPvsS3le3d+keFjHpnjtKcPgQSa5uYDFoRwEOGkk8v+tjmZ3rbGBhWOj6ntoCh3bry1mrQwxU
-        WAUWbSJfqIM7rbVot8otZbivBwTtY9J1hpNdCBYbFs7bJpHPKnDIRSMsxBfeU/OfX5aOfsBVFgPl
-        7HuCOyBpIDj4nDkXL2WiUSkkE+mNEX00rRfT856MN/0EarzkR0rGfJNrFh/M1dPbmS/ccfnz63c2
-        G7/XxIVMq0GT4WzWYUdnsEi02WUfjiLPjCz9czCO3y3yz1xomCx6SjHxE8omNtViVV/WdbWqYLE7
-        CsSkQyxN0QeSPF2wmgyOxz3lK4uixYdTcrmyb7ubjornkKexrW+31L0UV+M/pr6ufxF51TKOfwEA
-        AP//AwBybekMaAIAAA==
-    headers:
-      Access-Control-Allow-Origin:
-      - '*'
-      CF-RAY:
-      - 9402c9e1b94a4722-BOM
-      Connection:
-      - keep-alive
-      Content-Encoding:
-      - gzip
-      Content-Type:
-      - application/json
-      Date:
-      - Thu, 15 May 2025 12:55:15 GMT
-      Server:
-      - cloudflare
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Accept-Encoding
-      x-clerk-auth-message:
-      - Invalid JWT form. A JWT consists of three parts separated by dots. (reason=token-invalid,
-        token-carrier=header)
-      x-clerk-auth-reason:
-      - token-invalid
-      x-clerk-auth-status:
-      - signed-out
-    status:
-      code: 200
-      message: OK
-version: 1

tests/cassettes/test_using_contextual_memory.yaml

@@ -1028,4 +1028,637 @@ interactions:
     status:
       code: 200
       message: OK
+- request:
+    body: '{"input": ["Example: Toy Cars(Math Example): An example used to illustrate
+      addition by counting toy cars."], "model": "text-embedding-3-small", "encoding_format":
+      "base64"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '172'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.93.0
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.93.0
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/embeddings
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1SayxKyyral+/spVqwudUIuSmauHncQkOQmYkVFBSAiKKJcEsgT590r8N9xqqpj
+        A1ExYY45xjfzP//1119/d3lTFuPf//z196sexr//x3bslo3Z3//89T//9ddff/31n7/X/+/Mss3L
+        261+V7/Tf2/W71u5/P3PX+x/H/m/J/3z199GidoTsqiXc6z1VOAqVIG3cv6hWV69X6PVmpZJIGeG
+        Ljjqn7CVmAbrIAqdxU01A72LRSRyzxx7wtqhhPiJszzR7rJmNt5ZAV4PM8KnOEjy7j4JIrCyF4+P
+        EpdSrqvADFFdWTjvOTefzfulAL6rIazT4aOuBzS0ULmMJr7QgoL5CpgMKm9HndgDjiPSFYIEMfZP
+        OAwno1nUN8dCsdNSknFE6Yk8OxrIeL0gWms30WLcLzxwGsTjhCOywwY49lAcz0ci3dCN8tTrvkC+
+        5pGHhNxXh+6GM6ivionlopLBaHwkAx33s4hzP0uatatXEdVt3xCj1M4OL/F+gQaN/eJYlUlEVVJp
+        CClH19vRvqW0FDsJkFPwwfHBvOZrEEkQfa+WQqQy7ihHglGC/Wuf4Ys1CM7KsE0L2WhF0yGVS0py
+        oEroeryzxKidrzq7SVKil+z02HH7tV9vPPiC9W0gotkVymd8/jDITjt7EpPb2M9BkDGiWdDJW+Is
+        pJzRnGPw5c2aaNv1LH4Uaig7DhLO2lBqhL1eScBdFmaCB7PIeXEXsOiY8Qou67BW5/mcfmFvqDbJ
+        09TuhcXxakj1x4P4h8sJrFZFGZC3mYTl9GFSLtYEHk7M5UrczzfL16vaTWgVpNcEjX2QC0Omzuh+
+        WjC5F3dZ5bbrgbbl8uRKh2+/lPuqQlrj73CS6cAZ7ezFwyftTJK/+TBin/2ng69Zbogf3s903a0D
+        C5P7fiDGAXMqvYmHCu3Fe0pUt4mb5dl/JQRiVE2cL0r5nKPQQq4KSmxl54Wu73bOEI+EGZvyWXMW
+        cv5WQAsvO6+6IUQXHAw8jNUr56H3lKqcF/AJTCTmNvHZ86GOfhAlyLwtBlHGQ9svmewbKD+rA1ZM
+        S+1ZculEeL9FDTkKbtmze8bjobFjPS85tJJKhtisEdTWdIKOKed8rE0THGK/JXinXMHqJHcXPtVz
+        M4nc22z47f5D1aje+BxncSRkKA8BfYk3j3OBkXOckc8QGDXEGmfd83W6PDpRwK6G02SsKT/mc4fi
+        9XQm4YteGi4x8hbSM+SwHH8UIDxHX0It4r4T/Mp6xL4+QYocU0nIkRFhv3Cur/ypJxPUCljTHftF
+        j8OgYmyBr7MmhlIi7elfSGQN55791F0HC+rNGMdHqJLwiNsDGa0DDgjX9XSIcQUNP42wW7prtIzX
+        pUZj+MxwnJ3nvH19MvunB1in7NOZ7eLpwiJa2ak9YM6huzWaIBeYV68wJTcSHrPji3VqvfFv/WbW
+        /qZwDLUJyxaL6cpZ2R5MeHcierNbnElmJRddBlIQ+0HFZhkKeYbXa14Q3YJuxJKoz6DccZjcU4tX
+        e8h5DLScviVYQrw6p/regzyJWWyH06eZX71vgdIXLZItVdgLdz5Q0PPpOcRPvAPd9LZCY9hm3pAV
+        Vr4mluyiVy1FWFmCXUMfXyzB90BqchQi2q9OkZdQTg9v4hDWiLizHWio6mFEnE6vm7Ve9jYctITB
+        UqsOdJLY6/CrP29ubZnysdYOqLspBpaWWQPC42sq8LRIKzHCdnTGvohCxN/3e6Luwj6axN2VhyZj
+        KSTop6gRQhc8gQD6/TQv1wMdd2zjofr9bDzuzfTOEtmsAZ/xikku9HrOc1a4R2f5hLDq0m+z8rZl
+        wcaQTWLVkU7XrmItxDbTizipj3tKvY8CJl/0cGCxhM5DcUzBpo/kLDSduhyrWvvVC/bG2VbpHB1r
+        KKZdgc2+zcBy1toEnZa6JGf/a0fzxTgOMHwfj7gw/TpaKj4N4TRdF2+3uz4BldYoEZIdH2PpcBnB
+        ylmhCJs2U4kVtiNY7tO0wmIZhymy2Lkn1G4qVE7XHivj0jf0W11ryKnakYSTLDcrhLOG/NNTxuab
+        6en8eo0ZtM2IJyfCmqpQHDQfPeuITgBkx0i4T6SGE2FvOObeer4eq7pAJiAM8bj30aF9YVdg+fon
+        nBifnbMeM2FA6+UjeztQv8B8QCiGfZsZHndUH9GsDG4Br91lmECzi3I2ctcSLHaKcMK9DWc9XUQI
+        4joY8TWVGUoSW4pRxIoHrLo97vly5W2U7NgYy9bAgtlJ3hBSLrniY5p+6Fjy1IfnWb7hm/UsI5Z1
+        HxY0dryHpaT9gtXOWg+qXHrf9EToJ+3TFGjrJ/gMnIvKCsZx/6sfrMv6GA2POe8gc8+xJ/ToRef7
+        JOzhYmeI6MC5OFRvEgNp0fmyfV5QJ/XDMhB764M4PTdEozJoPGwSxpy+yavrV4LbDq3v9kO0cRmi
+        +SIlEG79ceIPbaWu0hy7aML3h4f8pY7WJVBSpKSd+ace1z6L9+jRcTlWkuTcr8fqW4BPxnoeAiFW
+        eYkNBnSqtZrcinuVs6mkl8gch4mcCkmM1sOuT8CvPiNdMxoKdtKEgAF9XJjSkFO9DwxoSMwF6yA/
+        OXO2q1NEE3giR7+eAWXmHYSbXkz78VqAFbGchnbw+MayfH7Q9THbIvym1hf74Z2jvVXBBM5FffMA
+        gY9oeb3GGdLnbSHYotiZI3ctIG3TowdbpY9ojuQZ3Uu3wZ7RQad7v482BBTM0wM0bS/kO6lC4/wI
+        J053lXw9u76L4mZeiDTJFWCf/eMLbmqnYc04xPmcQlOESP5U2E1OaTQd1EpE013ksO6vej78Wf9L
+        LxN73DfNvJ40C+0m+0KM8WCp9FO8KvTJ4hrH3k7NhU/59FF4IacJ+PXSr+37uId+Ib2wN0mVQ5dA
+        meHmL4kDsmM+XgEzA7deEnLSIMlXfCID8KbrC5vp8aCucxDtkZIQQk66q0dUMOcQxU2kE3mX6f2a
+        7YIOGkRssQ5qxVnkIYnhzgtMIjfzrqfjmV1/eoCTMnacKfKqEh3tbJoIyGwqWM8uBjtkvKev6T/6
+        ueTFPRRGG06gwp+eCvqhhudK53BqVyWdH6slAn2pc4Ljx8lZVxekENajP61h6/QFp7z/3V+07HTO
+        Oae88vCxX1QiebsHXW4U+3A5uDciLY+Yst3NTOFN/sQTD5mDuiKeshDfghuRXfoB3bGuCnAOjZe3
+        yKcW0Is5a8DeGwaW4/ACptCfJzT35TgxHvNwqPpmniDN3nCi/vrs5938ShDU5hQHfoTAZL5sCEp0
+        Bn/qk9f62oMwniRsqLLvrM1L6KDspCrxwlFXl2Pd8fB65ecJNaR06Bgxys9/egxkCoeMZ3aGWjyr
+        WMn0Qz8GkfWEn8NgkKIO5Yg/1g8XbfWAPZsE6kwu3R7uT4qL9U6XoqV7LiEsq0Qj2gNe8w5HjQcv
+        k21Nk3JI1VkezhCiRz17B7dJKAld0MJNX7f1MCjnFLkGwRnusd5PnNNxxlME3EOVCfY/lkNPFxDD
+        JeODif3p86f6dkCYrPj3POVLZHGxqD7vd2zS4UNnhmXj3/2eGOWQOgM+PyDs8oeC/TG704X1Kh9d
+        u/NAwlKj/fR8P/eQDPiANY+cosUpAx6daqMmsuDmPVuxgY0YwjfE8b9DvxToqIAhnkNyexqfqNWb
+        twe7w10kzlFt+mGvzylyzmqLf/6TTufehxiHJ6JvfpAX9MVCQukOJC6LVz4+VjmEmWCwWI7rkX7q
+        r+fD2dE3/ehZh86RXIFVqIOJ89dXvshDGYuc0nE49N5BPzIsHMSb8h2w9OpzSs92wIJJYlqiLZ0T
+        rRdNHVBDrwAr4WT0lGCigOYMCU5M6+VQaY5b5FL3S4rWNnIuA2MIPp+1nARruDiCd3nwiFvKM7Fa
+        5QOGrd/8+gnB/bhS6kXPWJT6mk5sWC4REdR1ho/jwSGYvC50mXGxguzoxthIkotDX5+sgsc0Z4ja
+        M3a+SANhD6x6+UwjIzLOciwhD10tWYn3PcoqOxRyBk4yaYlSR01DCzj70Po+SmIt8xsswenMQseU
+        EiIZhxBwXsDEsObedBJbxe65LQ9AE32TCSoLjNaSry34XHGOLciXlP+m7y+YHXPxpsylzgx2gQG9
+        KX95fKsc1Tk/xB1arWHBMkFN8z2doQsco/pOQ+iV0XwKcQHceDZIsaRpPmeo78AOPSOihZMZsdLw
+        LsSxrhQSq8dvNMxn/4sU7rMjpgZPzhBbLIMiQ5Wng0tdsFzVKvnTH0XusjTLHIU+hNpFw8qWD9bm
+        tfuC/AwHIpnyiS4X6cRDrY7eHkkrU/35KRhH5xv2OJw6HUQWC9/wY5PS41tn2fIg+lonZapR0vWr
+        j2PmV6/EbASejge1q1Gav2Jsxouk8naV/tEbfKJF4iyJZbFilEAZb9+njotzD3/9jWCg3sGkf64M
+        3Po/NkxLV/uLurYwTL8nb594EMyJFTBoCAXRA7urGgmR+zVgcJjPxK1DOWfDk8qg/VBY2F/mJ1js
+        sokRXMY91t8EOOSXh2I9OW18QY14CGwWjrWUENMCb2fq6nUPeD97YT29ThERzL0P5es1IrrGXfKB
+        s/09Wtv+Q3TyYtXRfJwM8C69lrjI4KPldFmf6PDx99j9HquIIBaVENKvj8NJfvTUjzIePKNVwGrf
+        HqLJu1Ye+HZGiD3IQHX88YT9UFrEM7rCIaEnJlCraYQlZASAO13EFtzLCWPsiprKioc2hubkZVga
+        PwSQi74k8A0+Kw4YsOu/haDbEJfujciFDOga2zUDlXdHJkTpwxm9iDNQdzLKiXmtvDozM88DemY4
+        D47zMVrIua6hVgdvbNuC3VNpLp7QScqQYFlf1MU/vWOYyOURSyHe0T9++1ZLPnY9popWvSHujydN
+        l6dXq+wUsXugdFZO/HH5bv68nUFvyDY2sqesUqdQEtDinU30yhyiH3+Ck5/V3m3ze4vSmQm0BW3C
+        Se18HXI4kALsyq9KNO79yid5PRZAa8IdNrLCUNcbT7+wyqsdyerIaJZP2ddQ1V9vfJQQpWtkoQme
+        A+eFldqxGs6PMg2o3N7BkXyumxXspBh9322Lj/FSUSKvRx7SNjsSb+u3pOS/NXzqcYSzTS/4Oco6
+        8dlMdyzLp5ZSabhr8BUavUfp+RbRJbBXSG6nAAcuPVJBHT8JdM6P0BNie6cun+obbqngQy47O6CU
+        s6LNL3g3svGnSJiu1Yy6nkmIEV5uzmq2exeC880lxzRgwaqQxUMb78A6fXrqvOMfT+jn5ouoFus3
+        0xBjC4ZCeyOmL8oqN0VcCM/qV/bY8WBGgp1NLTgewpYY+91dXdzM5uFTTyJvnxUtmPvKT+Gtej0J
+        Tv1AXY23PKCTaofE6VuYr4l0H+DxeJ+wTG9CsyyRNcOimQpimZYOOHhwBvirvxN9LirZ/ATUg97B
+        6kmt+kXpcAIds1awFyaZOh8znoFBxurYNv1Hs/nNGgb7GRG5Mu1/+6lkOsQkXdKEzp+CE5HKiQ45
+        FZdXtKT6/gkvpVuRoJBzwFLTFNGWx0jwNJ50EDTHgp/rxcZadnPy9aLvGaA9w8vEcuk5n/f6nKEJ
+        oxPxOLxXF7tKn3DLE5v+js4ffqKHloDPfblz6MZD4MYTiSrEl5zylrzCk2qF2JF13LOCoqXIXSiD
+        tbAdIvIts1WcSLJseY/mw7FkC5RdTk/y428Ca7QKrMQbJjoj5upcIOsr7rwpx0fKvpq1TxMLmt5c
+        bnniDL7ZLvgiUahiEmZn3NC20VbYP3cZPhIo9ewcBSLyfFHBWNYDlV2dUwqHxuUndusvS4FkBaLg
+        bWG85eslP5wlgJE1kos2ImcRDMVH0qDcsbHl0VFgTBec5LH1HhtZmPV3w8C75wNP8MWHOpT8KsLa
+        cndY4dK4mX781CCZSOxML/rVLgYGco96xJs/oJP+jlxov78r/j0v1EkuLSji2cWXN+Ns/qsL4aa/
+        nuBS11kl9jr96hsby2w6lHoPCQnF2OHf+i+cHfiQqWKfWMnLBJxbWskhyHgdu8pSRDPDwgS6Gl9i
+        hz7naGD2VYKC9DCSjXf04+udK0A+rNibk/ZL19tezOCWVyaIzm0+3/lHhhhJjIl2Rfd8mfBuhWNk
+        GNhGnt8sPz+08ePpq8pBPy+RlcLamvqJscni9DgYW7Dx3UnYKTxYV38vgs1//3hzxN35xyr6X5Wb
+        dlVSqbx4IBo8KZaIDZTYzs/f/+FLxrKvnaWrxT96RLb+4FD/bBmgUDmXYOErUX7jt3AM3sq0CC5o
+        hsTIXRha02vL00ouLFhTxI1v4dOb8VQhBbsaFNHM4mLcaxG98VCCX2uasCPkOFoWrPpiz7EKlhlw
+        byg+By3YeNpPr/P1W2YZnG/Kkajp8dIvfXpeYfx0dSJb8LvxcUcBjJxJExc/jhHnpu4fPkTSZFTo
+        1n+qP7zYs4VB3fxrAok3j8T2+Gc/O1kE/6z/CdS6KsjrkQUXZM/ervJeDjHvWBP3PVN4IyOW6rgE
+        igT8/B0Qt4ze+UrOQYbo875gt1aDiJ6uqwYzc/SJ42dJv3DKe4byh39jfeMz3xzEFvzpi7Hx4rmr
+        QAqDz1nG8cbvu2PJlgCw/Ixd9TjmCz5/E9gkRY4di47NKs/2BNx4NYjB+cCZx9QRIXpUM3GE5pvP
+        TpW68FJQltjJy+qHw47VwGKBw8QsfunM37K3QNYeWWLK+uT80XNGTiWc2Lun2mnNjoGW27bEbHYL
+        pfo7f0JzGBMsVxIHJkE/WGDcNYeJt3eaunYVtECyizsSWM8rXZ+vyYZ1MgKiZPq1GfTXywNuJBie
+        GCb7Zv4WzxS+Qb9i6QEFSg7ytwZPjX3jGJXPnDYfVMGXauX4UljUGVQylz+ei60HiOn67OsM6Y8n
+        nRahCBrBDwoN7guFxSpBWjQvTrI/bH6U6Bu/GNuP5EPhRFOsMyJwRoZ/MEhNJED0XTioXWJE3n7j
+        uxPqkeVs840O5m0qYZW8aN71VZrCpNwNWHv1t3zmtaL7M78y7O6qrqs/71F1MnIsA4drRhw8Wdiw
+        eTQxqq+qhNfcUAzN5eXtTckGv/wGf/7ZUK+yM4dHr4R6rd1xfLjgP34J1QkBHvw9X00PRDBo/Jec
+        Nv60PKZb+ONr3iG+YvAn3zxXYhK1usgNzytlB9+T5W39+B3NYSCXPz+95SEBDGB31cDm14hXavt/
+        9/fjYQ6xrL12oGftTIFr95RJUFgzXbe8CDa/h4tw+kYLBHb568fYPiR9Q423Yvz0mRjjclLH8Giw
+        4h06OfbGva6uS3S04SSVIvnND1fjfZyglb15TxyXqZmVWYaQIO1BvOypOZPxsQpoDmTzJ+3Jmfey
+        uIdVUV+I3YZSL6wuWIFVVB72UWKCwXrOE4y4fUB+/JeOF1DBwM6WP/xmbEbRB8/YbyZaWEtPugrW
+        4Oqk7vZ81NHCuakCux4m5Fr4E9h4TCZqcUzwredODn+6rAw8ZHGHXXQ2opW3JQsVIcdufj3Jf/NP
+        6MZ+NvnIcynLK7c9rEQGEKzBWaVnKzJg9318SYFucrRMZyiBLX/jMkxE54+/Oy8Kh6WlO4L+3e5n
+        +LD3DTm5YhPRw66Z4Jyr13/zcWXZx/BSDi4JQDT3a2RxE6JcfMX+Cyx0ucqPFk278Io9x6zV5aJo
+        LcyNasa60Ksq9/pc/+2n1PdujsinfsyQm+GHhGHb97/8CG3eTLCX6aVK73wgodMq2eR4VGs6l/tD
+        ByP9PWKzMk8OPVY1i3KztoiHzm9nFVFuAP2hm9h5emrPxtquBNSoDuTa7Nb+zzz38/FXcpK4LH/7
+        Z0uDHUhDb1fcHyqtl30N7fY4kRMteGddItlG8YrP087NS4f3ccHA6Nycpy1vOlTvrxoU0NPHib3H
+        Dvd+KTO63ybBe8WfZ06XcFZQKsL9tBMiDqzqm3EP1ys747u7Hh32bPsD9AE8bZ8nKu3Lo48cds9j
+        GTRGP2Zg9GEpMRVRmz2Ixt88c+uXk7j5yYXarA+ipDjjYDt/+eWrri++5ObXa07L/Sf8M3+WCdc1
+        VCWdBoN9FGzznXu/OEVkoE93Wf/MG/nN/wIDq8yfPLNQg1/B9v9IuPGxpZoLBd4iTSKRBftm/eWz
+        H5/0XmLg8M1r10FW40dysp5MNKhkX0AtulymGXkDXV+9v0d//3YF/Ne//vrrf/12GLTdrXxtGwPG
+        chn/47+3CvyH8B9Dm71ef7YhTENWlX//8+8dCH9/+q79jP977J7le/j7n784+Gevwd9jN2av//f4
+        v7af+q9//R8AAAD//wMAY2Pk+OAgAAA=
+    headers:
+      CF-RAY:
+      - 9591a0712f5d7e30-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Wed, 02 Jul 2025 22:37:16 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=.z.gWzfdOx2KplLQsVulTLIN_dP1NkYoQBh0J7Z3aQQ-1751495836-1.0.1.1-vkNBT_fdo_LMcsRYrqaBVA1UjX_zacI35sZZ9QIEaQsqEDhubfCucS4W2LRSfg9ryDF3w3eAFJReCUvm1J8Wt3B3RkOAUpuD9k.6eTNdzP8;
+        path=/; expires=Wed, 02-Jul-25 23:07:16 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=SNQ8k7m5IaO2hSRVhrXBbeiK6insJNPHwPYz0zBe1RY-1751495836461-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-allow-origin:
+      - '*'
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-model:
+      - text-embedding-3-small
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '52'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      via:
+      - envoy-router-6795fbb876-zzrww
+      x-envoy-upstream-service-time:
+      - '56'
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '10000000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '9999977'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_56d2a2018c52fccc1c611da9d2e4e06e
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"input": ["Example: Using Fingers(Math Example): An interactive way to
+      teach addition using fingers as counting tools."], "model": "text-embedding-3-small",
+      "encoding_format": "base64"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '186'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=.z.gWzfdOx2KplLQsVulTLIN_dP1NkYoQBh0J7Z3aQQ-1751495836-1.0.1.1-vkNBT_fdo_LMcsRYrqaBVA1UjX_zacI35sZZ9QIEaQsqEDhubfCucS4W2LRSfg9ryDF3w3eAFJReCUvm1J8Wt3B3RkOAUpuD9k.6eTNdzP8;
+        _cfuvid=SNQ8k7m5IaO2hSRVhrXBbeiK6insJNPHwPYz0zBe1RY-1751495836461-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.93.0
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.93.0
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/embeddings
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1R6SROySrPm/vsVJ86WviGTVHJ2CIjIVCiD2NHRASoIDghIQdWN+9878P3idvfG
+        BZZaVmXmM2T+57/++uvvtmhul+/f//z197Mevn//j+XZNf/mf//z1//8119//fXXf/5e/7+Vt1dx
+        u17rd/Vb/nuzfl9v89///MX/95P/u+ifv/4+7q12rFMtdNkoCLF6MLQjPr2iJ6Mxv4lhdz6V440L
+        2oZt+SpE3fqj4XQ4Dw2TQT+qqlXkwaHICpdOl3elDvaT4O0W6mhqonMNt7N3widmYTZrrpIDn14I
+        Nl/tjvFW+M3AfT4fOLqah0KUXHGA+Lb7EizNpsGCioTIGXcpdvcacafkIteArnZBLg/njMj2eMxU
+        E102eHPaqBEbvEeGsnaNiEMUpR+K88qEM6oK4im9485pWg5yn1g+PivjhdFMxzVszTQfBbGMDD4V
+        LQob4e0HpZCqxcgSFEAhfWzsNaxA3zQ9jfB6SFesV3Bg8yF/TGgVqdy4mpSDyztM19SNnj1xJndW
+        T56rxlQz4bIl4U3XItHjVzdwpU2B4xntitl/3I8Aj/YzynzUMkH00QCllSd4u2NOL3yuuq2Ij01E
+        gmK4ugMeeVBtGj3IfjCdhueVoIbQFTlscPLdZSjSLDUuvY7gZtq70naURZXbPYzxHdOqmDxla0K6
+        X1d4f0oYo8/yGECNhxU53PBYsMu9qEA+8wXeSVe/kTykWDDsXBlbe83oJa5IJ3XzGh18vEhGQe3L
+        y0L1fkzIYUt3xmSbm04V/E4nW5qbPR/yjxxOh/OIz/t65XbAOxM6cDQj4eP9KAZSfWqV1ttbsOLM
+        DPHokwzq4ZyIBDe7i9EqrW6pI+/E5PYsqfs9gNLC9BB47GaZatBKsiw4lzQeucxAxtQEwgAPs3BH
+        4dwHxvy8oEzFZjyTrC620dTMxkMlTikTbMvIYCziPFjf088Igjr2k8zNJtKzWcDO+xZEwkZwU+Ao
+        9oP1jCiiTJUrWPKDxPprZtS/8Dzyg3s7ytfvnomB8+ngvsq3IyGG3dPY83TALjt+q5d3LRjE0QgH
+        0VNwGZHA5bvqSCH9ym6g1NMRUZtDHHDh7UK0c2wysRE3gborlIgYp5WEWL+9p8g+cN2oRFcWtSWy
+        TXDSTiD4yeGIr42bCPtaT/E1bC/GLPZPCs6lL7GxT7Y9f7GyUN1bISa26MzuSOm5RdvLTsDuuPYj
+        4UDfOfqEmU7Cct02gjQngUrm3gvmzT53pQRzF7TEH/bCYjTmQz5MMNhvMnJfxBVEyiqqbqdzQWw1
+        q10qhscKGDLqQAYiGNParF7woTYjucFSly/iXau6D/cbrJppbwxKMx5hXcozTi71vaBzG2TKqjRD
+        nDhRZYzqWgmgczcuDp7l0RAcoRL/3JfPd9Sd8iOvoejsxCMHpyoaz4QPVb9US5zwrcOE8RoqarHa
+        fYLX00X9tHUEUNF82eAChrqg+6GlQLYPlyTyd11MnZxk6rNYZyQS2Bu1yhY8sNm3IC7kzKDmcNRV
+        PrxsyfF2gWK2dbOD9kB9Epw4L5ptq7qoPvDNL18i4cFzOkhF8CKRPxiFpJ+QhQzgPXL4rt2GiR2C
+        Xz3BeIkP0a+HEIRLs8Wm27uGFILGq1l/I8Sfnk0zb/tAhHy9ibD92osGXV+3Ovh8tCX67XKJunbm
+        HeAgqDGelNkgkc1yUG0uGHmQ9gabPWbDyu/O40poh36OXm4HuLJkstv7h4Z/6gcO4hPdE7+TrsaS
+        /xRiKz6SdK8ZjXD+Xi/wScmLaNvog4gKB12VOCseH46r9QKXA4eqq1KTKw+biGcylUGhvBdw1vXF
+        BnPfxbCaBB2XvvxkLA5qXv3Vb7x3nIhJ4pFHJxAV7KbMQKxvigxkjTOIdbe+xszpSox09Gkw7hLf
+        YGru2tDJeI8Dp06KaXplnPqr/6dCexVTMpUxWs+fBh9uOCikoFMq5Deci/HhJfZULtY58vtswKZ3
+        ttB8+w4B1IXtkYNGL8VQaK0ITtW5AfWQiGg7mIMa4OEQrMqzW4zX54oCq/cO1o15ZPOkW+YvnvAp
+        P62LobdDR71qx4gcTXtgkzaH8i9fyfZ23jdzWZx1lHWajDdq07JJ5fmHOjthSmJGcc/TkXTwHToL
+        m1V+R/N8tCd1imslUISDUVCdBSma1VkOVD7iIwpkBHTnIjsQHcll3534HSVXzwAfsk0bMX015epL
+        yg74HKzf/ZRqR1NVtl0QcP1qV4jPTeuAmudbrK97O6Kf81zDYa9DwBDhmtmKvAAJfqvjY81yg1/w
+        VoGvtyM362qxmZ1dHnjqiSRTs9ro27GpVPl0eC/73zC+FIcQttyqwZuZyw12xVqMTlw4E89/5Mv/
+        hxeIfcnjjZhI6Mvf2BEeiaRj414QYx6n1QjVNB1I2rmvaAreawVIKefklI+S218HJVPzW7YnJy1/
+        N1/AN/MPHmEhvRbEOz881VoZmHiPy97gj5oRQzf6jBzfzGTCb//JlS9x9qoiNPuVf0OC3kzB9PLU
+        aKr92oKy3VukNJ1VTzfJ5ajan7NLEg9LLsND4KDGTp3l+x5oer+xBRxPN/ioH8yCXd46QCoHBb5W
+        D7sX/DzV1KG/XonV6iPqNrMyQJ9WJinXKyeaPK5VlHL9UHHqjXHx42Nqb3QpDlnLR6/L4+EgYZ3v
+        sRtvymhOEtNUf/np1c+q//E5NOihS8pr3RiTxI6e+vs+9632/fB1Vjnit5qMj/096SUaWBOIq0sZ
+        UNsvClasbzYc8fZInOmQ9QLajx2oaLPGtslFBbUO2AMze0XYfnzcRsKv24jaercbif58Fe1NCFtV
+        PyUc2SRMdyUQ7w/VTY4dcTjTj6hDM09lzXEXyHJ2KsRVS1vVfb4f2Cn12uV5xaqBs0oL+52kGiRV
+        +0DZZxstUCOjRq/7gyrK9M5bsl+Nu559u/Si+ofiFDw9fDLo9FImSO3rhyQvIUG0OPtH9FgbHbHr
+        4lnQck5btKoqGzvgP40x6zwe8lNYE2s4e7149l85eGe0x87bK13aV/xLFdKqwJc60JkU2EMH6R5V
+        I2ztsZ/OhypTfSHXsU7Jq2eqpAZQpZcNtvXp6xLF2Obq997wRAtjxSDP+6zBwvewv5JrNm0kO4aO
+        BmXAxmeKhJNdpepVCyMSJzu9mNtDE0J54j3sGCw1GKfbFXrMz/04zfNg0Lm1MpimaBM0dzogGj2C
+        FrlefiCmRj5LPqQmtGodYeNZXfu+ofJLtenhgf1bWhdztkeAkucTEe2sC81QZjRQ4bgTgs1pc42m
+        +HBo1T/1odu4rui/NQu4Mrkt+XpCfSkfQtU03HlkkLls8i6Rrj6VIAqYvAmML47uo+quXuugzzpv
+        iZ+dB+trohLv4ZwZ1ZkVw+lY9SQ3ndidVVXnock+JvaR8y7oTq1itTn5Pt58ah/RIfjkAGqzIdYl
+        mxumYkkG+uiOxNsYlTF3WjOCJRhKIKz8sRmbwFBgt0MtNpqH1Qjc0/aQfDiqGJvOqhmWfIN6596J
+        Ufotm9y0f4Bm0GmEXWsgiStuFNm7Nif2tch76rKGR+R6egV0o1jNjAL9guRSWPB4e+sJj1AF9Oxv
+        8WEvCQ1DNohKernEJAxf+4LhwbJBUHgNx0jTGjEhzxo+1Qhjde7rXqoddlSPPaRYH7MWMR3FL7V7
+        zUds5fePOwTbhw6Hb3wn+cIn521v8dB/4YmNLli7805ba+C4uB2RlJz7Hx6rzrhNxxW/WjU/fFWU
+        d7bCVvCE5inN1wAN0agT7aZXxUTHdwvnujXG9b4u3c9FwYCyg13hWPnUjJzju64khuDgzfcNUaMY
+        fg42HNfYUps4orf+7anHb+Zjs8xTRLhSeSHirglOWLtCI061Wr1+rk9ysDW/GLeO6YCoH2viRjD1
+        TPT3Cmxke0PSvp8Qq06lBgt+j3yZi2w6ZD4HH0OQyd7ATsGW85afTnkn+1rR+0FYqRyyO0HHG/H9
+        dmknSwF8rHwgpqd/3MlK9h4yqdIE0oABPXWFUvAbcEfxHTNj2joqKOtTEhFj3noF/cYZ//s83lc2
+        59Jc6Af0vN087IeKW8wyqi6qJWwU4q/uW1c6GfkIVbT2sVkkdjR1VU6RxBfrgE92dSTJtyyAPOH7
+        5by1gg89Yq5Xk6QTL9nvmz98bSjsBv/w7bN9lhnErr8it3Xlu7xhKMoffXxiFmGsv60eSFpVLgnQ
+        SSj6MnUzZJeFMPILn6RzIDsQfcogGBhpI/a8XgO08GtibSht7k0ix2BDuMaxGrwQC8VDDm3XPQNe
+        PG5dCmk4woI/ZOHj7veM+xx98az/6psxxR1REPpeE5x+6nM0+49PCMt9k5NmZwUjV2WEpb4TfK0N
+        V7hSTVdXL2kgrj92zbzobbV/nndYi9SLMdehraCFDxMj+7LmU7duDcg8Gjg6zAc2G9Z5hPuXC8hm
+        s8+NaYvPFCWSQbGtrR+MorFIgStPNxycklUxtFF7/O0HB1nSRXM8d7WiXactudJLj2gixJwq2akc
+        0Kx69rR7ZhnkL/cZrF+r2fhm75eGGqGyifV+1ZHg7PEAKUl1bNE37VkioQkcUzaxdo4fjFWG7IHE
+        mTFO6l0eMf2ETPjpYf0ZkX4uWdHC4+XCuMQfY0w0TVXjzmvsIPFtTG1UHVHc7gxsx23YDLuqssCN
+        eIYLNEjRdP3Mk9pU21eAIpiaSbmKPJB7fCTn0dfdKXCLG4Quz2HHuMjFJKeIoqpIxkBJ1Jb9+DY8
+        iWIEa2W8IGYDxylO6UX4+jyaBo9HngMfd0/sXNZdQ3vDqaEGWQ2krW248/d0v6mLvhn75f6WfOGQ
+        4O6CgDbbT8GmnTugBR+Cx8Z6R9Q3FQ+W+kMMLRyiMVnLEyDp1mNrQ4/9kl8i7HeDhf3tu2ck8LWL
+        +tp0wsjze7+RHmnuoJ/eWfKp+PEv8J5pGnBbfo3mg3zjkWLscuIv99nrKzmDyP/uyK4ZN2zKs/4G
+        RqnauLyvKzS/6o5H/Ce+ksOgGxHRozKE26c5EM9N+Z424sZD3WUGshVnvRCP2tNBivRdY4yzKZqm
+        QcvQKq0oPgmqYQjWJIbAe+X5Fw/N3Pq7CyreabDEMxikMuQAvpqsBcSWkfu5rFY5VK7OY4df8S7b
+        6+MNRbxSkC1p5mhUnJlXl3wdqyUfaLKeKOzDV4nd9GIZglAFCoxn3sTZ49M3cyIdONSevZHciuFq
+        PE4Ne6ji8+qQAH0ezcQrQQUvKT8Qd0Nv7qANgoWM+1kjftJajC54rqqi7eFk9fAiAeYefvWcWN+1
+        ZEzGmjxQvjYiYjwrtZkPlOSQ2uVn5JWPzr4uCo9qq1YRcW7nxBC67JXCOruFo4wVHk25MsdAz3hL
+        jNfeaaaYGIPqyZ4Z3HLv2LMv/xlAG80Vxpwps4lctgPsNg+TFFiqXTYc7AAWPkH8934o6JkPLZU6
+        sY639U12F3+CgjWOCXbBEKJx4RPK/nOT8O7hBBHbjpOoRmc7xnHKOc2iF0ERIvUdgPulBam/G0fN
+        QHmNQuY2DblvDR4EOfKI++RjV6ykwIKqOI0Lnq6b1rsUOlx5heINSvR+qQcjWHFm4TzXpYL8/J8G
+        VXS5z0NEvXvYqrCZEL6qFlewRV+rK0U84fN636CpOK8sZdEv2HC9L5uOW4WCFecWdi9EQZPg7EOY
+        49cLe4y0xR/9/vMTsH9v3Vkts0l1j0Qke3oMm3kYswvKR2IQfH8fGpZQM1X6SYzxj3/O4bACyHau
+        g03tmkfTe5/ocM1fNTHDyexZtnccILdbE0xyOrlUcWZRVXyTjMitzIhRXr4oaZGciPPhGrbEQ4Z+
+        69VTSdw//obHeSPeHLZWLx5vpQdX6ylhZ8wnl9r3Bd8fbhpglluFlFAvBiuK9tgRDk30q4/K9upR
+        Yv/02I/fMLBLcrN736Wb702BZ6KMWHu8H9FcHnyKlvqN9cuTd2c4f1K4R7DG2s45usw5fhzkb8zr
+        SFfroJizu/iATwAO3hsv25iGft3Cgvd4x51JQYRPFavPAmUjNcqyF5+5mK3D+Hsi+L7WmPDT78PG
+        DX5+QCQQ8e0AGdmV2EXZ9A/HNUdYkcIhdiluIl5pHROtFP5E3L2GXakqqKjaPJ/9m7+kyVeBfuJj
+        7MluzHrn+LHRoif+6NWpklYyLHo+ENeC0dCu8O0/+thK2LcfwrUdoAsnFti8GA+DP16FHIjidfhg
+        PDQmLnoAalGJsD7FJRqficWB8DzfiNM3FzQC71D0YY8uGC+D7U6d3g5QnkSP6LzqMTH+iBbU2TsL
+        vqHSR3RMhssf/PPPqdTTZxIA7Lf7I8bEaJt5hzY1SMePjY+r9RhNB6Xgf35/MIWvTzEy9g3RpzyY
+        OIzVnUF95aUARpWJfTX79oP29jv49Re8cvSLQcOGroYJHxM3DCqD/vRZc8I+2RRdF3U/PaF3eCC+
+        sROj6Qn1DURjOJOdEleM2q85hofivMmep5ZB449oqgvfJtY0OZHkHO823Eq8+fnN7oC+6woWPzng
+        BwTNIB3MGJWvLybO5jm5TAtlHVpWc9iviwmx1d59waY4qiNq409P/KdrKuH1KGAnurKip7x8Q1pr
+        JmRbvTFil32oIGuyfRwq5bsfZ+cSo2IK3gTfplsxfOgX/uj3bZCNDfNzSQSnNQeys1ZuwZ+FvYLo
+        YDFsFsba/SrcboRP617JZvF72uku2NAbbYq3QRb0P/2BzgfPW/oFH2MqwOOUuLbOeOc/cDSYW6sG
+        3LYp2e3LirFFn6rpiz7++MXz8SHr4NdCgF0pOTfDmFMTyISTxW/QGmGtNw9IZIeMwrZjxhcZkgeS
+        ppwC4ZP0Eetv0gt9YaVh2/Me0eyiMPzDb9Os09B3nFYDjOgh4JOiz80Qd28FKb5FyM5NP8b4wGUN
+        OuobYi/9k7aSJPl3PjgKjLsx9+1H/6P3tUU/0Vf15eH1zRE29OneE9LUjnqIb3usqWbfz4/1gYdo
+        635wsPQTvtxT8wDl7zc2v76Lhmx3tSGPv+NPH0fvtLimyuJ3Evy+nRlTExIrh0LuRnJ1txE79aEG
+        rZamI1riZwZ8sxQGTjku/lnfZWPVqevrSR1Xb+HUz5ZwtFR+3q2X/tLMehmco7rgB3G1h45+eIKy
+        hx5gnzzlhd9xIjyd6504J352p6Pmporex5+Fj+oRswQkw2s6dqMar9ZoDA+PEQTPc8nuGngN88uo
+        /eNvlMt+pewFHuwe0zCSe8jQdNeNQI3SZ0Ws1awU3eXGj/A0Nhp2X5ZRDGkWj6gbMfudZzPdej9T
+        tIkbR7r43ZKwyy/o53d5Qr+KxiZiKZye2XkEd3Vv6F1/6qCfFUr09fn868cEsOaDEzH71CiEYLJt
+        uDY39Ef/fY96bYPd5PdxteDbuH5nRxgtSHHS32r0VcuQ/voDBJtsaDo48DIs/tCoFuKAmLK7e3/8
+        9E1FDDYv/B0WfCBWxats8UtysMOKkUjeBC59T20N7lW0MT7ipp87BTxkPb7aj582NDl1MmxlWAer
+        H38sD9sJ+E96Jdvp8DXmNfAWWvg5KcBICkq/Ko9ajDOyX+8NxK82bxv49Ebw1r6/CurQ0APWhLuR
+        2/JnxBw7kUE9iO9x1SVfYzpZ+xrCdtSJmSZqP2d7BioUU0hK834tmA0iB58yMrFdiveIt5JNoG5l
+        bj32541jzIl0BoXu5iAgGf9u2P0aXEBI64IEFO0N0nrXFr3h1BHr1CVIoEIXgrSfyNL/a/oXTrVK
+        XfhBgBRvYMt+A/Trn0RRm7uMK+lDvTzBGF8L/vQ//clZVwtvVVNyqV8/QnCoqZPjWkfF5Ia8A+db
+        fxq5fvWOhtpIeTDKlR2sF//u55+hBY8wfux2rvRcNZY6cIlL9J14Lfj3/qqD2oQ3bLz2XTOI7kVG
+        NAoKbIqagGZLyM0/fjX9+SU/f27hR3jvnenPz+gAwg9HNPy6FfNHMCmMpThi4zDPjH4YnoDf6nLA
+        L/g5k8aOf3yUWEdQosk3s/zXfw0YZD0i5eIdLf1AnLnCq1j06/DD44WP2S5/9s0H5DEZ8a/e0sHZ
+        PpTjptthN+uGgn6po8BPb3nHY1qIx63GrV3ZyZZ+xIv1F+N+g+GhAbnMrxBNi58B3NbAAZclTjQ/
+        le8NFvwgGzJFSDpIXw1kGPakmM81++P/bd93nfifz4bR9TsL4e/fVMB//euvv/7Xb8Lg1V5vz2Uw
+        4Hubv//x36MC/yH9x/DKn88/YwjjkFe3v//59wTC35++fX2+//vbPm7v4e9//hL/PWvw97f95s//
+        9/m/lp/6r3/9HwAAAP//AwDb9NaU4CAAAA==
+    headers:
+      CF-RAY:
+      - 9591a071f8497e30-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Wed, 02 Jul 2025 22:37:17 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-allow-origin:
+      - '*'
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-model:
+      - text-embedding-3-small
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '85'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      via:
+      - envoy-router-79c9cd8ff5-w6hpv
+      x-envoy-upstream-service-time:
+      - '443'
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '10000000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '9999973'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_3a042b1efd09880c8484622f6bf9a343
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"input": ["Example: Using Fingers(Math Example): An interactive way to
+      teach addition using fingers as counting tools."], "model": "text-embedding-3-small",
+      "encoding_format": "base64"}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate, zstd
+      connection:
+      - keep-alive
+      content-length:
+      - '186'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=.z.gWzfdOx2KplLQsVulTLIN_dP1NkYoQBh0J7Z3aQQ-1751495836-1.0.1.1-vkNBT_fdo_LMcsRYrqaBVA1UjX_zacI35sZZ9QIEaQsqEDhubfCucS4W2LRSfg9ryDF3w3eAFJReCUvm1J8Wt3B3RkOAUpuD9k.6eTNdzP8;
+        _cfuvid=SNQ8k7m5IaO2hSRVhrXBbeiK6insJNPHwPYz0zBe1RY-1751495836461-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.93.0
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.93.0
+      x-stainless-read-timeout:
+      - '600'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/embeddings
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA1R6SROySrPm/vsVJ86WviGTVHJ2CIjIVCiD2NHRASoIDghIQdWN+9878P3idvfG
+        BZZaVmXmM2T+57/++uvvtmhul+/f//z197Mevn//j+XZNf/mf//z1//8119//fXXf/5e/7+Vt1dx
+        u17rd/Vb/nuzfl9v89///MX/95P/u+ifv/4+7q12rFMtdNkoCLF6MLQjPr2iJ6Mxv4lhdz6V440L
+        2oZt+SpE3fqj4XQ4Dw2TQT+qqlXkwaHICpdOl3elDvaT4O0W6mhqonMNt7N3widmYTZrrpIDn14I
+        Nl/tjvFW+M3AfT4fOLqah0KUXHGA+Lb7EizNpsGCioTIGXcpdvcacafkIteArnZBLg/njMj2eMxU
+        E102eHPaqBEbvEeGsnaNiEMUpR+K88qEM6oK4im9485pWg5yn1g+PivjhdFMxzVszTQfBbGMDD4V
+        LQob4e0HpZCqxcgSFEAhfWzsNaxA3zQ9jfB6SFesV3Bg8yF/TGgVqdy4mpSDyztM19SNnj1xJndW
+        T56rxlQz4bIl4U3XItHjVzdwpU2B4xntitl/3I8Aj/YzynzUMkH00QCllSd4u2NOL3yuuq2Ij01E
+        gmK4ugMeeVBtGj3IfjCdhueVoIbQFTlscPLdZSjSLDUuvY7gZtq70naURZXbPYzxHdOqmDxla0K6
+        X1d4f0oYo8/yGECNhxU53PBYsMu9qEA+8wXeSVe/kTykWDDsXBlbe83oJa5IJ3XzGh18vEhGQe3L
+        y0L1fkzIYUt3xmSbm04V/E4nW5qbPR/yjxxOh/OIz/t65XbAOxM6cDQj4eP9KAZSfWqV1ttbsOLM
+        DPHokwzq4ZyIBDe7i9EqrW6pI+/E5PYsqfs9gNLC9BB47GaZatBKsiw4lzQeucxAxtQEwgAPs3BH
+        4dwHxvy8oEzFZjyTrC620dTMxkMlTikTbMvIYCziPFjf088Igjr2k8zNJtKzWcDO+xZEwkZwU+Ao
+        9oP1jCiiTJUrWPKDxPprZtS/8Dzyg3s7ytfvnomB8+ngvsq3IyGG3dPY83TALjt+q5d3LRjE0QgH
+        0VNwGZHA5bvqSCH9ym6g1NMRUZtDHHDh7UK0c2wysRE3gborlIgYp5WEWL+9p8g+cN2oRFcWtSWy
+        TXDSTiD4yeGIr42bCPtaT/E1bC/GLPZPCs6lL7GxT7Y9f7GyUN1bISa26MzuSOm5RdvLTsDuuPYj
+        4UDfOfqEmU7Cct02gjQngUrm3gvmzT53pQRzF7TEH/bCYjTmQz5MMNhvMnJfxBVEyiqqbqdzQWw1
+        q10qhscKGDLqQAYiGNParF7woTYjucFSly/iXau6D/cbrJppbwxKMx5hXcozTi71vaBzG2TKqjRD
+        nDhRZYzqWgmgczcuDp7l0RAcoRL/3JfPd9Sd8iOvoejsxCMHpyoaz4QPVb9US5zwrcOE8RoqarHa
+        fYLX00X9tHUEUNF82eAChrqg+6GlQLYPlyTyd11MnZxk6rNYZyQS2Bu1yhY8sNm3IC7kzKDmcNRV
+        PrxsyfF2gWK2dbOD9kB9Epw4L5ptq7qoPvDNL18i4cFzOkhF8CKRPxiFpJ+QhQzgPXL4rt2GiR2C
+        Xz3BeIkP0a+HEIRLs8Wm27uGFILGq1l/I8Sfnk0zb/tAhHy9ibD92osGXV+3Ovh8tCX67XKJunbm
+        HeAgqDGelNkgkc1yUG0uGHmQ9gabPWbDyu/O40poh36OXm4HuLJkstv7h4Z/6gcO4hPdE7+TrsaS
+        /xRiKz6SdK8ZjXD+Xi/wScmLaNvog4gKB12VOCseH46r9QKXA4eqq1KTKw+biGcylUGhvBdw1vXF
+        BnPfxbCaBB2XvvxkLA5qXv3Vb7x3nIhJ4pFHJxAV7KbMQKxvigxkjTOIdbe+xszpSox09Gkw7hLf
+        YGru2tDJeI8Dp06KaXplnPqr/6dCexVTMpUxWs+fBh9uOCikoFMq5Deci/HhJfZULtY58vtswKZ3
+        ttB8+w4B1IXtkYNGL8VQaK0ITtW5AfWQiGg7mIMa4OEQrMqzW4zX54oCq/cO1o15ZPOkW+YvnvAp
+        P62LobdDR71qx4gcTXtgkzaH8i9fyfZ23jdzWZx1lHWajDdq07JJ5fmHOjthSmJGcc/TkXTwHToL
+        m1V+R/N8tCd1imslUISDUVCdBSma1VkOVD7iIwpkBHTnIjsQHcll3534HSVXzwAfsk0bMX015epL
+        yg74HKzf/ZRqR1NVtl0QcP1qV4jPTeuAmudbrK97O6Kf81zDYa9DwBDhmtmKvAAJfqvjY81yg1/w
+        VoGvtyM362qxmZ1dHnjqiSRTs9ro27GpVPl0eC/73zC+FIcQttyqwZuZyw12xVqMTlw4E89/5Mv/
+        hxeIfcnjjZhI6Mvf2BEeiaRj414QYx6n1QjVNB1I2rmvaAreawVIKefklI+S218HJVPzW7YnJy1/
+        N1/AN/MPHmEhvRbEOz881VoZmHiPy97gj5oRQzf6jBzfzGTCb//JlS9x9qoiNPuVf0OC3kzB9PLU
+        aKr92oKy3VukNJ1VTzfJ5ajan7NLEg9LLsND4KDGTp3l+x5oer+xBRxPN/ioH8yCXd46QCoHBb5W
+        D7sX/DzV1KG/XonV6iPqNrMyQJ9WJinXKyeaPK5VlHL9UHHqjXHx42Nqb3QpDlnLR6/L4+EgYZ3v
+        sRtvymhOEtNUf/np1c+q//E5NOihS8pr3RiTxI6e+vs+9632/fB1Vjnit5qMj/096SUaWBOIq0sZ
+        UNsvClasbzYc8fZInOmQ9QLajx2oaLPGtslFBbUO2AMze0XYfnzcRsKv24jaercbif58Fe1NCFtV
+        PyUc2SRMdyUQ7w/VTY4dcTjTj6hDM09lzXEXyHJ2KsRVS1vVfb4f2Cn12uV5xaqBs0oL+52kGiRV
+        +0DZZxstUCOjRq/7gyrK9M5bsl+Nu559u/Si+ofiFDw9fDLo9FImSO3rhyQvIUG0OPtH9FgbHbHr
+        4lnQck5btKoqGzvgP40x6zwe8lNYE2s4e7149l85eGe0x87bK13aV/xLFdKqwJc60JkU2EMH6R5V
+        I2ztsZ/OhypTfSHXsU7Jq2eqpAZQpZcNtvXp6xLF2Obq997wRAtjxSDP+6zBwvewv5JrNm0kO4aO
+        BmXAxmeKhJNdpepVCyMSJzu9mNtDE0J54j3sGCw1GKfbFXrMz/04zfNg0Lm1MpimaBM0dzogGj2C
+        FrlefiCmRj5LPqQmtGodYeNZXfu+ofJLtenhgf1bWhdztkeAkucTEe2sC81QZjRQ4bgTgs1pc42m
+        +HBo1T/1odu4rui/NQu4Mrkt+XpCfSkfQtU03HlkkLls8i6Rrj6VIAqYvAmML47uo+quXuugzzpv
+        iZ+dB+trohLv4ZwZ1ZkVw+lY9SQ3ndidVVXnock+JvaR8y7oTq1itTn5Pt58ah/RIfjkAGqzIdYl
+        mxumYkkG+uiOxNsYlTF3WjOCJRhKIKz8sRmbwFBgt0MtNpqH1Qjc0/aQfDiqGJvOqhmWfIN6596J
+        Ufotm9y0f4Bm0GmEXWsgiStuFNm7Nif2tch76rKGR+R6egV0o1jNjAL9guRSWPB4e+sJj1AF9Oxv
+        8WEvCQ1DNohKernEJAxf+4LhwbJBUHgNx0jTGjEhzxo+1Qhjde7rXqoddlSPPaRYH7MWMR3FL7V7
+        zUds5fePOwTbhw6Hb3wn+cIn521v8dB/4YmNLli7805ba+C4uB2RlJz7Hx6rzrhNxxW/WjU/fFWU
+        d7bCVvCE5inN1wAN0agT7aZXxUTHdwvnujXG9b4u3c9FwYCyg13hWPnUjJzju64khuDgzfcNUaMY
+        fg42HNfYUps4orf+7anHb+Zjs8xTRLhSeSHirglOWLtCI061Wr1+rk9ysDW/GLeO6YCoH2viRjD1
+        TPT3Cmxke0PSvp8Qq06lBgt+j3yZi2w6ZD4HH0OQyd7ATsGW85afTnkn+1rR+0FYqRyyO0HHG/H9
+        dmknSwF8rHwgpqd/3MlK9h4yqdIE0oABPXWFUvAbcEfxHTNj2joqKOtTEhFj3noF/cYZ//s83lc2
+        59Jc6Af0vN087IeKW8wyqi6qJWwU4q/uW1c6GfkIVbT2sVkkdjR1VU6RxBfrgE92dSTJtyyAPOH7
+        5by1gg89Yq5Xk6QTL9nvmz98bSjsBv/w7bN9lhnErr8it3Xlu7xhKMoffXxiFmGsv60eSFpVLgnQ
+        SSj6MnUzZJeFMPILn6RzIDsQfcogGBhpI/a8XgO08GtibSht7k0ix2BDuMaxGrwQC8VDDm3XPQNe
+        PG5dCmk4woI/ZOHj7veM+xx98az/6psxxR1REPpeE5x+6nM0+49PCMt9k5NmZwUjV2WEpb4TfK0N
+        V7hSTVdXL2kgrj92zbzobbV/nndYi9SLMdehraCFDxMj+7LmU7duDcg8Gjg6zAc2G9Z5hPuXC8hm
+        s8+NaYvPFCWSQbGtrR+MorFIgStPNxycklUxtFF7/O0HB1nSRXM8d7WiXactudJLj2gixJwq2akc
+        0Kx69rR7ZhnkL/cZrF+r2fhm75eGGqGyifV+1ZHg7PEAKUl1bNE37VkioQkcUzaxdo4fjFWG7IHE
+        mTFO6l0eMf2ETPjpYf0ZkX4uWdHC4+XCuMQfY0w0TVXjzmvsIPFtTG1UHVHc7gxsx23YDLuqssCN
+        eIYLNEjRdP3Mk9pU21eAIpiaSbmKPJB7fCTn0dfdKXCLG4Quz2HHuMjFJKeIoqpIxkBJ1Jb9+DY8
+        iWIEa2W8IGYDxylO6UX4+jyaBo9HngMfd0/sXNZdQ3vDqaEGWQ2krW248/d0v6mLvhn75f6WfOGQ
+        4O6CgDbbT8GmnTugBR+Cx8Z6R9Q3FQ+W+kMMLRyiMVnLEyDp1mNrQ4/9kl8i7HeDhf3tu2ck8LWL
+        +tp0wsjze7+RHmnuoJ/eWfKp+PEv8J5pGnBbfo3mg3zjkWLscuIv99nrKzmDyP/uyK4ZN2zKs/4G
+        RqnauLyvKzS/6o5H/Ce+ksOgGxHRozKE26c5EM9N+Z424sZD3WUGshVnvRCP2tNBivRdY4yzKZqm
+        QcvQKq0oPgmqYQjWJIbAe+X5Fw/N3Pq7CyreabDEMxikMuQAvpqsBcSWkfu5rFY5VK7OY4df8S7b
+        6+MNRbxSkC1p5mhUnJlXl3wdqyUfaLKeKOzDV4nd9GIZglAFCoxn3sTZ49M3cyIdONSevZHciuFq
+        PE4Ne6ji8+qQAH0ezcQrQQUvKT8Qd0Nv7qANgoWM+1kjftJajC54rqqi7eFk9fAiAeYefvWcWN+1
+        ZEzGmjxQvjYiYjwrtZkPlOSQ2uVn5JWPzr4uCo9qq1YRcW7nxBC67JXCOruFo4wVHk25MsdAz3hL
+        jNfeaaaYGIPqyZ4Z3HLv2LMv/xlAG80Vxpwps4lctgPsNg+TFFiqXTYc7AAWPkH8934o6JkPLZU6
+        sY639U12F3+CgjWOCXbBEKJx4RPK/nOT8O7hBBHbjpOoRmc7xnHKOc2iF0ERIvUdgPulBam/G0fN
+        QHmNQuY2DblvDR4EOfKI++RjV6ykwIKqOI0Lnq6b1rsUOlx5heINSvR+qQcjWHFm4TzXpYL8/J8G
+        VXS5z0NEvXvYqrCZEL6qFlewRV+rK0U84fN636CpOK8sZdEv2HC9L5uOW4WCFecWdi9EQZPg7EOY
+        49cLe4y0xR/9/vMTsH9v3Vkts0l1j0Qke3oMm3kYswvKR2IQfH8fGpZQM1X6SYzxj3/O4bACyHau
+        g03tmkfTe5/ocM1fNTHDyexZtnccILdbE0xyOrlUcWZRVXyTjMitzIhRXr4oaZGciPPhGrbEQ4Z+
+        69VTSdw//obHeSPeHLZWLx5vpQdX6ylhZ8wnl9r3Bd8fbhpglluFlFAvBiuK9tgRDk30q4/K9upR
+        Yv/02I/fMLBLcrN736Wb702BZ6KMWHu8H9FcHnyKlvqN9cuTd2c4f1K4R7DG2s45usw5fhzkb8zr
+        SFfroJizu/iATwAO3hsv25iGft3Cgvd4x51JQYRPFavPAmUjNcqyF5+5mK3D+Hsi+L7WmPDT78PG
+        DX5+QCQQ8e0AGdmV2EXZ9A/HNUdYkcIhdiluIl5pHROtFP5E3L2GXakqqKjaPJ/9m7+kyVeBfuJj
+        7MluzHrn+LHRoif+6NWpklYyLHo+ENeC0dCu8O0/+thK2LcfwrUdoAsnFti8GA+DP16FHIjidfhg
+        PDQmLnoAalGJsD7FJRqficWB8DzfiNM3FzQC71D0YY8uGC+D7U6d3g5QnkSP6LzqMTH+iBbU2TsL
+        vqHSR3RMhssf/PPPqdTTZxIA7Lf7I8bEaJt5hzY1SMePjY+r9RhNB6Xgf35/MIWvTzEy9g3RpzyY
+        OIzVnUF95aUARpWJfTX79oP29jv49Re8cvSLQcOGroYJHxM3DCqD/vRZc8I+2RRdF3U/PaF3eCC+
+        sROj6Qn1DURjOJOdEleM2q85hofivMmep5ZB449oqgvfJtY0OZHkHO823Eq8+fnN7oC+6woWPzng
+        BwTNIB3MGJWvLybO5jm5TAtlHVpWc9iviwmx1d59waY4qiNq409P/KdrKuH1KGAnurKip7x8Q1pr
+        JmRbvTFil32oIGuyfRwq5bsfZ+cSo2IK3gTfplsxfOgX/uj3bZCNDfNzSQSnNQeys1ZuwZ+FvYLo
+        YDFsFsba/SrcboRP617JZvF72uku2NAbbYq3QRb0P/2BzgfPW/oFH2MqwOOUuLbOeOc/cDSYW6sG
+        3LYp2e3LirFFn6rpiz7++MXz8SHr4NdCgF0pOTfDmFMTyISTxW/QGmGtNw9IZIeMwrZjxhcZkgeS
+        ppwC4ZP0Eetv0gt9YaVh2/Me0eyiMPzDb9Os09B3nFYDjOgh4JOiz80Qd28FKb5FyM5NP8b4wGUN
+        OuobYi/9k7aSJPl3PjgKjLsx9+1H/6P3tUU/0Vf15eH1zRE29OneE9LUjnqIb3usqWbfz4/1gYdo
+        635wsPQTvtxT8wDl7zc2v76Lhmx3tSGPv+NPH0fvtLimyuJ3Evy+nRlTExIrh0LuRnJ1txE79aEG
+        rZamI1riZwZ8sxQGTjku/lnfZWPVqevrSR1Xb+HUz5ZwtFR+3q2X/tLMehmco7rgB3G1h45+eIKy
+        hx5gnzzlhd9xIjyd6504J352p6Pmporex5+Fj+oRswQkw2s6dqMar9ZoDA+PEQTPc8nuGngN88uo
+        /eNvlMt+pewFHuwe0zCSe8jQdNeNQI3SZ0Ws1awU3eXGj/A0Nhp2X5ZRDGkWj6gbMfudZzPdej9T
+        tIkbR7r43ZKwyy/o53d5Qr+KxiZiKZye2XkEd3Vv6F1/6qCfFUr09fn868cEsOaDEzH71CiEYLJt
+        uDY39Ef/fY96bYPd5PdxteDbuH5nRxgtSHHS32r0VcuQ/voDBJtsaDo48DIs/tCoFuKAmLK7e3/8
+        9E1FDDYv/B0WfCBWxats8UtysMOKkUjeBC59T20N7lW0MT7ipp87BTxkPb7aj582NDl1MmxlWAer
+        H38sD9sJ+E96Jdvp8DXmNfAWWvg5KcBICkq/Ko9ajDOyX+8NxK82bxv49Ebw1r6/CurQ0APWhLuR
+        2/JnxBw7kUE9iO9x1SVfYzpZ+xrCdtSJmSZqP2d7BioUU0hK834tmA0iB58yMrFdiveIt5JNoG5l
+        bj32541jzIl0BoXu5iAgGf9u2P0aXEBI64IEFO0N0nrXFr3h1BHr1CVIoEIXgrSfyNL/a/oXTrVK
+        XfhBgBRvYMt+A/Trn0RRm7uMK+lDvTzBGF8L/vQ//clZVwtvVVNyqV8/QnCoqZPjWkfF5Ia8A+db
+        fxq5fvWOhtpIeTDKlR2sF//u55+hBY8wfux2rvRcNZY6cIlL9J14Lfj3/qqD2oQ3bLz2XTOI7kVG
+        NAoKbIqagGZLyM0/fjX9+SU/f27hR3jvnenPz+gAwg9HNPy6FfNHMCmMpThi4zDPjH4YnoDf6nLA
+        L/g5k8aOf3yUWEdQosk3s/zXfw0YZD0i5eIdLf1AnLnCq1j06/DD44WP2S5/9s0H5DEZ8a/e0sHZ
+        PpTjptthN+uGgn6po8BPb3nHY1qIx63GrV3ZyZZ+xIv1F+N+g+GhAbnMrxBNi58B3NbAAZclTjQ/
+        le8NFvwgGzJFSDpIXw1kGPakmM81++P/bd93nfifz4bR9TsL4e/fVMB//euvv/7Xb8Lg1V5vz2Uw
+        4Hubv//x36MC/yH9x/DKn88/YwjjkFe3v//59wTC35++fX2+//vbPm7v4e9//hL/PWvw97f95s//
+        9/m/lp/6r3/9HwAAAP//AwDb9NaU4CAAAA==
+    headers:
+      CF-RAY:
+      - 9591a4f4ec6715be-SJC
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Wed, 02 Jul 2025 22:40:22 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-allow-origin:
+      - '*'
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-model:
+      - text-embedding-3-small
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '199'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      via:
+      - envoy-router-568d6b5f7d-zm9nq
+      x-envoy-upstream-service-time:
+      - '254'
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '10000000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '9999973'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_b30caf2b5ce7746764e692bac19cadeb
+    status:
+      code: 200
+      message: OK
 version: 1

tests/cli/authentication/test_utils.py

@@ -27,7 +27,7 @@ class TestValidateToken(unittest.TestCase):
             audience="app_id_xxxx",
         )
 
-        mock_jwt.decode.assert_called_with(
+        mock_jwt.decode.assert_called_once_with(
             "aaaaa.bbbbbb.cccccc",
             "mock_signing_key",
             algorithms=["RS256"],

tests/experimental/evaluation/metrics/base_evaluation_metrics_test.py

@@ -1,28 +0,0 @@
-import pytest
-from unittest.mock import MagicMock
-from crewai.agent import Agent
-from crewai.task import Task
-
-class BaseEvaluationMetricsTest:
-    @pytest.fixture
-    def mock_agent(self):
-        agent = MagicMock(spec=Agent)
-        agent.id = "test_agent_id"
-        agent.role = "Test Agent"
-        agent.goal = "Test goal"
-        agent.tools = []
-        return agent
-
-    @pytest.fixture
-    def mock_task(self):
-        task = MagicMock(spec=Task)
-        task.description = "Test task description"
-        task.expected_output = "Test expected output"
-        return task
-
-    @pytest.fixture
-    def execution_trace(self):
-        return {
-            "thinking": ["I need to analyze this data carefully"],
-            "actions": ["Gathered information", "Analyzed data"]
-        }

tests/experimental/evaluation/metrics/test_goal_metrics.py

@@ -1,59 +0,0 @@
-from unittest.mock import patch, MagicMock
-from tests.experimental.evaluation.metrics.base_evaluation_metrics_test import BaseEvaluationMetricsTest
-
-from crewai.experimental.evaluation.base_evaluator import EvaluationScore
-from crewai.experimental.evaluation.metrics.goal_metrics import GoalAlignmentEvaluator
-from crewai.utilities.llm_utils import LLM
-
-
-class TestGoalAlignmentEvaluator(BaseEvaluationMetricsTest):
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_evaluate_success(self, mock_create_llm, mock_agent, mock_task, execution_trace):
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = """
-        {
-            "score": 8.5,
-            "feedback": "The agent correctly understood the task and produced relevant output."
-        }
-        """
-        mock_create_llm.return_value = mock_llm
-
-        evaluator = GoalAlignmentEvaluator(llm=mock_llm)
-
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="This is the final output"
-        )
-
-        assert isinstance(result, EvaluationScore)
-        assert result.score == 8.5
-        assert "correctly understood the task" in result.feedback
-
-        mock_llm.call.assert_called_once()
-        prompt = mock_llm.call.call_args[0][0]
-        assert len(prompt) >= 2
-        assert "system" in prompt[0]["role"]
-        assert "user" in prompt[1]["role"]
-        assert mock_agent.role in prompt[1]["content"]
-        assert mock_task.description in prompt[1]["content"]
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_evaluate_error_handling(self, mock_create_llm, mock_agent, mock_task, execution_trace):
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = "Invalid JSON response"
-        mock_create_llm.return_value = mock_llm
-
-        evaluator = GoalAlignmentEvaluator(llm=mock_llm)
-
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="This is the final output"
-        )
-
-        assert isinstance(result, EvaluationScore)
-        assert result.score is None
-        assert "Failed to parse" in result.feedback

tests/experimental/evaluation/metrics/test_reasoning_metrics.py

@@ -1,166 +0,0 @@
-import pytest
-from unittest.mock import patch, MagicMock
-from typing import List, Dict, Any
-
-from crewai.tasks.task_output import TaskOutput
-from crewai.experimental.evaluation.metrics.reasoning_metrics import (
-    ReasoningEfficiencyEvaluator,
-)
-from tests.experimental.evaluation.metrics.base_evaluation_metrics_test import BaseEvaluationMetricsTest
-from crewai.utilities.llm_utils import LLM
-from crewai.experimental.evaluation.base_evaluator import EvaluationScore
-
-class TestReasoningEfficiencyEvaluator(BaseEvaluationMetricsTest):
-    @pytest.fixture
-    def mock_output(self):
-        output = MagicMock(spec=TaskOutput)
-        output.raw = "This is the test output"
-        return output
-
-    @pytest.fixture
-    def llm_calls(self) -> List[Dict[str, Any]]:
-        return [
-            {
-                "prompt": "How should I approach this task?",
-                "response": "I'll first research the topic, then compile findings.",
-                "timestamp": 1626987654
-            },
-            {
-                "prompt": "What resources should I use?",
-                "response": "I'll use relevant academic papers and reliable websites.",
-                "timestamp": 1626987754
-            },
-            {
-                "prompt": "How should I structure the output?",
-                "response": "I'll organize information clearly with headings and bullet points.",
-                "timestamp": 1626987854
-            }
-        ]
-
-    def test_insufficient_llm_calls(self, mock_agent, mock_task, mock_output):
-        execution_trace = {"llm_calls": []}
-
-        evaluator = ReasoningEfficiencyEvaluator()
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output=mock_output
-        )
-
-        assert isinstance(result, EvaluationScore)
-        assert result.score is None
-        assert "Insufficient LLM calls" in result.feedback
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_successful_evaluation(self, mock_create_llm, mock_agent, mock_task, mock_output, llm_calls):
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = """
-        {
-            "scores": {
-                "focus": 8.0,
-                "progression": 7.0,
-                "decision_quality": 7.5,
-                "conciseness": 8.0,
-                "loop_avoidance": 9.0
-            },
-            "overall_score": 7.9,
-            "feedback": "The agent demonstrated good reasoning efficiency.",
-            "optimization_suggestions": "The agent could improve by being more concise."
-        }
-        """
-        mock_create_llm.return_value = mock_llm
-
-        # Setup execution trace with sufficient LLM calls
-        execution_trace = {"llm_calls": llm_calls}
-
-        # Mock the _detect_loops method to return a simple result
-        evaluator = ReasoningEfficiencyEvaluator(llm=mock_llm)
-        evaluator._detect_loops = MagicMock(return_value=(False, []))
-
-        # Evaluate
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output=mock_output
-        )
-
-        # Assertions
-        assert isinstance(result, EvaluationScore)
-        assert result.score == 7.9
-        assert "The agent demonstrated good reasoning efficiency" in result.feedback
-        assert "Reasoning Efficiency Evaluation:" in result.feedback
-        assert "• Focus: 8.0/10" in result.feedback
-
-        # Verify LLM was called
-        mock_llm.call.assert_called_once()
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_parse_error_handling(self, mock_create_llm, mock_agent, mock_task, mock_output, llm_calls):
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = "Invalid JSON response"
-        mock_create_llm.return_value = mock_llm
-
-        # Setup execution trace
-        execution_trace = {"llm_calls": llm_calls}
-
-        # Mock the _detect_loops method
-        evaluator = ReasoningEfficiencyEvaluator(llm=mock_llm)
-        evaluator._detect_loops = MagicMock(return_value=(False, []))
-
-        # Evaluate
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output=mock_output
-        )
-
-        # Assertions for error handling
-        assert isinstance(result, EvaluationScore)
-        assert result.score is None
-        assert "Failed to parse reasoning efficiency evaluation" in result.feedback
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_loop_detection(self, mock_create_llm, mock_agent, mock_task, mock_output):
-        # Setup LLM calls with a repeating pattern
-        repetitive_llm_calls = [
-            {"prompt": "How to solve?", "response": "I'll try method A", "timestamp": 1000},
-            {"prompt": "Let me try method A", "response": "It didn't work", "timestamp": 1100},
-            {"prompt": "How to solve?", "response": "I'll try method A again", "timestamp": 1200},
-            {"prompt": "Let me try method A", "response": "It didn't work", "timestamp": 1300},
-            {"prompt": "How to solve?", "response": "I'll try method A one more time", "timestamp": 1400}
-        ]
-
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = """
-        {
-            "scores": {
-                "focus": 6.0,
-                "progression": 3.0,
-                "decision_quality": 4.0,
-                "conciseness": 6.0,
-                "loop_avoidance": 2.0
-            },
-            "overall_score": 4.2,
-            "feedback": "The agent is stuck in a reasoning loop.",
-            "optimization_suggestions": "The agent should try different approaches when one fails."
-        }
-        """
-        mock_create_llm.return_value = mock_llm
-
-        execution_trace = {"llm_calls": repetitive_llm_calls}
-
-        evaluator = ReasoningEfficiencyEvaluator(llm=mock_llm)
-
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output=mock_output
-        )
-
-        assert isinstance(result, EvaluationScore)
-        assert result.score == 4.2
-        assert "• Loop Avoidance: 2.0/10" in result.feedback

tests/experimental/evaluation/metrics/test_semantic_quality_metrics.py

@@ -1,82 +0,0 @@
-from unittest.mock import patch, MagicMock
-
-from crewai.experimental.evaluation.base_evaluator import EvaluationScore
-from crewai.experimental.evaluation.metrics.semantic_quality_metrics import SemanticQualityEvaluator
-from tests.experimental.evaluation.metrics.base_evaluation_metrics_test import BaseEvaluationMetricsTest
-from crewai.utilities.llm_utils import LLM
-
-class TestSemanticQualityEvaluator(BaseEvaluationMetricsTest):
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_evaluate_success(self, mock_create_llm, mock_agent, mock_task, execution_trace):
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = """
-        {
-            "score": 8.5,
-            "feedback": "The output is clear, coherent, and logically structured."
-        }
-        """
-        mock_create_llm.return_value = mock_llm
-
-        evaluator = SemanticQualityEvaluator(llm=mock_llm)
-
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="This is a well-structured analysis of the data."
-        )
-
-        assert isinstance(result, EvaluationScore)
-        assert result.score == 8.5
-        assert "clear, coherent" in result.feedback
-
-        mock_llm.call.assert_called_once()
-        prompt = mock_llm.call.call_args[0][0]
-        assert len(prompt) >= 2
-        assert "system" in prompt[0]["role"]
-        assert "user" in prompt[1]["role"]
-        assert mock_agent.role in prompt[1]["content"]
-        assert mock_task.description in prompt[1]["content"]
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_evaluate_with_empty_output(self, mock_create_llm, mock_agent, mock_task, execution_trace):
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = """
-        {
-            "score": 2.0,
-            "feedback": "The output is empty or minimal, lacking substance."
-        }
-        """
-        mock_create_llm.return_value = mock_llm
-
-        evaluator = SemanticQualityEvaluator(llm=mock_llm)
-
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output=""
-        )
-
-        assert isinstance(result, EvaluationScore)
-        assert result.score == 2.0
-        assert "empty or minimal" in result.feedback
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_evaluate_error_handling(self, mock_create_llm, mock_agent, mock_task, execution_trace):
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = "Invalid JSON response"
-        mock_create_llm.return_value = mock_llm
-
-        evaluator = SemanticQualityEvaluator(llm=mock_llm)
-
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="This is the output."
-        )
-
-        assert isinstance(result, EvaluationScore)
-        assert result.score is None
-        assert "Failed to parse" in result.feedback

tests/experimental/evaluation/metrics/test_tools_metrics.py

@@ -1,230 +0,0 @@
-from unittest.mock import patch, MagicMock
-
-from crewai.experimental.evaluation.metrics.tools_metrics import (
-    ToolSelectionEvaluator,
-    ParameterExtractionEvaluator,
-    ToolInvocationEvaluator
-)
-from crewai.utilities.llm_utils import LLM
-from tests.experimental.evaluation.metrics.base_evaluation_metrics_test import BaseEvaluationMetricsTest
-
-class TestToolSelectionEvaluator(BaseEvaluationMetricsTest):
-    def test_no_tools_available(self, mock_task, mock_agent):
-        # Create agent with no tools
-        mock_agent.tools = []
-
-        execution_trace = {"tool_uses": []}
-
-        evaluator = ToolSelectionEvaluator()
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="Final output"
-        )
-
-        assert result.score is None
-        assert "no tools available" in result.feedback.lower()
-
-    def test_tools_available_but_none_used(self, mock_agent, mock_task):
-        mock_agent.tools = ["tool1", "tool2"]
-        execution_trace = {"tool_uses": []}
-
-        evaluator = ToolSelectionEvaluator()
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="Final output"
-        )
-
-        assert result.score is None
-        assert "had tools available but didn't use any" in result.feedback.lower()
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_successful_evaluation(self, mock_create_llm, mock_agent, mock_task):
-        # Setup mock LLM response
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = """
-        {
-            "overall_score": 8.5,
-            "feedback": "The agent made good tool selections."
-        }
-        """
-        mock_create_llm.return_value = mock_llm
-
-        # Setup execution trace with tool uses
-        execution_trace = {
-            "tool_uses": [
-                {"tool": "search_tool", "input": {"query": "test query"}, "output": "search results"},
-                {"tool": "calculator", "input": {"expression": "2+2"}, "output": "4"}
-            ]
-        }
-
-        evaluator = ToolSelectionEvaluator(llm=mock_llm)
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="Final output"
-        )
-
-        assert result.score == 8.5
-        assert "The agent made good tool selections" in result.feedback
-
-        # Verify LLM was called with correct prompt
-        mock_llm.call.assert_called_once()
-        prompt = mock_llm.call.call_args[0][0]
-        assert isinstance(prompt, list)
-        assert len(prompt) >= 2
-        assert "system" in prompt[0]["role"]
-        assert "user" in prompt[1]["role"]
-
-
-class TestParameterExtractionEvaluator(BaseEvaluationMetricsTest):
-    def test_no_tool_uses(self, mock_agent, mock_task):
-        execution_trace = {"tool_uses": []}
-
-        evaluator = ParameterExtractionEvaluator()
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="Final output"
-        )
-
-        assert result.score is None
-        assert "no tool usage" in result.feedback.lower()
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_successful_evaluation(self, mock_create_llm, mock_agent, mock_task):
-        mock_agent.tools = ["tool1", "tool2"]
-
-        # Setup mock LLM response
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = """
-        {
-            "overall_score": 9.0,
-            "feedback": "The agent extracted parameters correctly."
-        }
-        """
-        mock_create_llm.return_value = mock_llm
-
-        # Setup execution trace with tool uses
-        execution_trace = {
-            "tool_uses": [
-                {
-                    "tool": "search_tool",
-                    "input": {"query": "test query"},
-                    "output": "search results",
-                    "error": None
-                },
-                {
-                    "tool": "calculator",
-                    "input": {"expression": "2+2"},
-                    "output": "4",
-                    "error": None
-                }
-            ]
-        }
-
-        evaluator = ParameterExtractionEvaluator(llm=mock_llm)
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="Final output"
-        )
-
-        assert result.score == 9.0
-        assert "The agent extracted parameters correctly" in result.feedback
-
-
-class TestToolInvocationEvaluator(BaseEvaluationMetricsTest):
-    def test_no_tool_uses(self, mock_agent, mock_task):
-        execution_trace = {"tool_uses": []}
-
-        evaluator = ToolInvocationEvaluator()
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="Final output"
-        )
-
-        assert result.score is None
-        assert "no tool usage" in result.feedback.lower()
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_successful_evaluation(self, mock_create_llm, mock_agent, mock_task):
-        mock_agent.tools = ["tool1", "tool2"]
-        # Setup mock LLM response
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = """
-        {
-            "overall_score": 8.0,
-            "feedback": "The agent invoked tools correctly."
-        }
-        """
-        mock_create_llm.return_value = mock_llm
-
-        # Setup execution trace with tool uses
-        execution_trace = {
-            "tool_uses": [
-                {"tool": "search_tool", "input": {"query": "test query"}, "output": "search results"},
-                {"tool": "calculator", "input": {"expression": "2+2"}, "output": "4"}
-            ]
-        }
-
-        evaluator = ToolInvocationEvaluator(llm=mock_llm)
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="Final output"
-        )
-
-        assert result.score == 8.0
-        assert "The agent invoked tools correctly" in result.feedback
-
-    @patch("crewai.utilities.llm_utils.create_llm")
-    def test_evaluation_with_errors(self, mock_create_llm, mock_agent, mock_task):
-        mock_agent.tools = ["tool1", "tool2"]
-        # Setup mock LLM response
-        mock_llm = MagicMock(spec=LLM)
-        mock_llm.call.return_value = """
-        {
-            "overall_score": 5.5,
-            "feedback": "The agent had some errors in tool invocation."
-        }
-        """
-        mock_create_llm.return_value = mock_llm
-
-        # Setup execution trace with tool uses including errors
-        execution_trace = {
-            "tool_uses": [
-                {
-                    "tool": "search_tool",
-                    "input": {"query": "test query"},
-                    "output": "search results",
-                    "error": None
-                },
-                {
-                    "tool": "calculator",
-                    "input": {"expression": "2+"},
-                    "output": None,
-                    "error": "Invalid expression"
-                }
-            ]
-        }
-
-        evaluator = ToolInvocationEvaluator(llm=mock_llm)
-        result = evaluator.evaluate(
-            agent=mock_agent,
-            task=mock_task,
-            execution_trace=execution_trace,
-            final_output="Final output"
-        )
-
-        assert result.score == 5.5
-        assert "The agent had some errors in tool invocation" in result.feedback

tests/experimental/evaluation/test_agent_evaluator.py

@@ -1,95 +0,0 @@
-import pytest
-
-from crewai.agent import Agent
-from crewai.task import Task
-from crewai.crew import Crew
-from crewai.experimental.evaluation.agent_evaluator import AgentEvaluator
-from crewai.experimental.evaluation.base_evaluator import AgentEvaluationResult
-from crewai.experimental.evaluation import (
-    GoalAlignmentEvaluator,
-    SemanticQualityEvaluator,
-    ToolSelectionEvaluator,
-    ParameterExtractionEvaluator,
-    ToolInvocationEvaluator,
-    ReasoningEfficiencyEvaluator
-)
-
-from crewai.experimental.evaluation import create_default_evaluator
-class TestAgentEvaluator:
-    @pytest.fixture
-    def mock_crew(self):
-        agent = Agent(
-            role="Test Agent",
-            goal="Complete test tasks successfully",
-            backstory="An agent created for testing purposes",
-            allow_delegation=False,
-            verbose=False
-        )
-
-        task = Task(
-            description="Test task description",
-            agent=agent,
-            expected_output="Expected test output"
-        )
-
-        crew = Crew(
-            agents=[agent],
-            tasks=[task]
-        )
-        return crew
-
-    def test_set_iteration(self):
-        agent_evaluator = AgentEvaluator()
-
-        agent_evaluator.set_iteration(3)
-        assert agent_evaluator.iteration == 3
-
-    @pytest.mark.vcr(filter_headers=["authorization"])
-    def test_evaluate_current_iteration(self, mock_crew):
-        agent_evaluator = AgentEvaluator(crew=mock_crew, evaluators=[GoalAlignmentEvaluator()])
-
-        mock_crew.kickoff()
-
-        results = agent_evaluator.evaluate_current_iteration()
-
-        assert isinstance(results, dict)
-
-        agent, = mock_crew.agents
-        task, = mock_crew.tasks
-
-        assert len(mock_crew.agents) == 1
-        assert agent.role in results
-        assert len(results[agent.role]) == 1
-
-        result, = results[agent.role]
-        assert isinstance(result, AgentEvaluationResult)
-
-        assert result.agent_id == str(agent.id)
-        assert result.task_id == str(task.id)
-
-        goal_alignment, = result.metrics.values()
-        assert goal_alignment.score == 5.0
-
-        expected_feedback = "The agent's output demonstrates an understanding of the need for a comprehensive document"
-        assert expected_feedback in goal_alignment.feedback
-
-        assert goal_alignment.raw_response is not None
-        assert '"score": 5' in goal_alignment.raw_response
-
-    def test_create_default_evaluator(self, mock_crew):
-        agent_evaluator = create_default_evaluator(crew=mock_crew)
-        assert isinstance(agent_evaluator, AgentEvaluator)
-        assert agent_evaluator.crew == mock_crew
-
-        expected_types = [
-            GoalAlignmentEvaluator,
-            SemanticQualityEvaluator,
-            ToolSelectionEvaluator,
-            ParameterExtractionEvaluator,
-            ToolInvocationEvaluator,
-            ReasoningEfficiencyEvaluator
-        ]
-
-        assert len(agent_evaluator.evaluators) == len(expected_types)
-        for evaluator, expected_type in zip(agent_evaluator.evaluators, expected_types):
-            assert isinstance(evaluator, expected_type)

tests/experimental/evaluation/test_experiment_result.py

@@ -1,111 +0,0 @@
-import pytest
-from unittest.mock import MagicMock, patch
-
-from crewai.experimental.evaluation.experiment.result import ExperimentResult, ExperimentResults
-
-
-class TestExperimentResult:
-    @pytest.fixture
-    def mock_results(self):
-        return [
-            ExperimentResult(
-                identifier="test-1",
-                inputs={"query": "What is the capital of France?"},
-                score=10,
-                expected_score=7,
-                passed=True
-            ),
-            ExperimentResult(
-                identifier="test-2",
-                inputs={"query": "Who wrote Hamlet?"},
-                score={"relevance": 9, "factuality": 8},
-                expected_score={"relevance": 7, "factuality": 7},
-                passed=True,
-                agent_evaluations={"agent1": {"metrics": {"goal_alignment": {"score": 9}}}}
-            ),
-            ExperimentResult(
-                identifier="test-3",
-                inputs={"query": "Any query"},
-                score={"relevance": 9, "factuality": 8},
-                expected_score={"relevance": 7, "factuality": 7},
-                passed=False,
-                agent_evaluations={"agent1": {"metrics": {"goal_alignment": {"score": 9}}}}
-            ),
-            ExperimentResult(
-                identifier="test-4",
-                inputs={"query": "Another query"},
-                score={"relevance": 9, "factuality": 8},
-                expected_score={"relevance": 7, "factuality": 7},
-                passed=True,
-                agent_evaluations={"agent1": {"metrics": {"goal_alignment": {"score": 9}}}}
-            ),
-            ExperimentResult(
-                identifier="test-6",
-                inputs={"query": "Yet another query"},
-                score={"relevance": 9, "factuality": 8},
-                expected_score={"relevance": 7, "factuality": 7},
-                passed=True,
-                agent_evaluations={"agent1": {"metrics": {"goal_alignment": {"score": 9}}}}
-            )
-        ]
-
-    @patch('os.path.exists', return_value=True)
-    @patch('os.path.getsize', return_value=1)
-    @patch('json.load')
-    @patch('builtins.open', new_callable=MagicMock)
-    def test_experiment_results_compare_with_baseline(self, mock_open, mock_json_load, mock_path_getsize, mock_path_exists, mock_results):
-        baseline_data = {
-            "timestamp": "2023-01-01T00:00:00+00:00",
-            "results": [
-                {
-                    "identifier": "test-1",
-                    "inputs": {"query": "What is the capital of France?"},
-                    "score": 7,
-                    "expected_score": 7,
-                    "passed": False
-                },
-                {
-                    "identifier": "test-2",
-                    "inputs": {"query": "Who wrote Hamlet?"},
-                    "score": {"relevance": 8, "factuality": 7},
-                    "expected_score": {"relevance": 7, "factuality": 7},
-                    "passed": True
-                },
-                {
-                    "identifier": "test-3",
-                    "inputs": {"query": "Any query"},
-                    "score": {"relevance": 8, "factuality": 7},
-                    "expected_score": {"relevance": 7, "factuality": 7},
-                    "passed": True
-                },
-                {
-                    "identifier": "test-4",
-                    "inputs": {"query": "Another query"},
-                    "score": {"relevance": 8, "factuality": 7},
-                    "expected_score": {"relevance": 7, "factuality": 7},
-                    "passed": True
-                },
-                {
-                    "identifier": "test-5",
-                    "inputs": {"query": "Another query"},
-                    "score": {"relevance": 8, "factuality": 7},
-                    "expected_score": {"relevance": 7, "factuality": 7},
-                    "passed": True
-                }
-            ]
-        }
-
-        mock_json_load.return_value = baseline_data
-
-        results = ExperimentResults(results=mock_results)
-        results.display = MagicMock()
-
-        comparison = results.compare_with_baseline(baseline_filepath="baseline.json")
-
-        assert "baseline_timestamp" in comparison
-        assert comparison["baseline_timestamp"] == "2023-01-01T00:00:00+00:00"
-        assert comparison["improved"] == ["test-1"]
-        assert comparison["regressed"] == ["test-3"]
-        assert comparison["unchanged"] == ["test-2", "test-4"]
-        assert comparison["new_tests"] == ["test-6"]
-        assert comparison["missing_tests"] == ["test-5"]

tests/experimental/evaluation/test_experiment_runner.py

@@ -1,197 +0,0 @@
-import pytest
-from unittest.mock import MagicMock, patch
-
-from crewai.crew import Crew
-from crewai.experimental.evaluation.experiment.runner import ExperimentRunner
-from crewai.experimental.evaluation.experiment.result import ExperimentResults
-from crewai.experimental.evaluation.evaluation_display import AgentAggregatedEvaluationResult
-from crewai.experimental.evaluation.base_evaluator import MetricCategory, EvaluationScore
-
-
-class TestExperimentRunner:
-    @pytest.fixture
-    def mock_crew(self):
-        return MagicMock(llm=Crew)
-
-    @pytest.fixture
-    def mock_evaluator_results(self):
-        agent_evaluation = AgentAggregatedEvaluationResult(
-            agent_id="Test Agent",
-            agent_role="Test Agent Role",
-            metrics={
-                MetricCategory.GOAL_ALIGNMENT: EvaluationScore(
-                    score=9,
-                    feedback="Test feedback for goal alignment",
-                    raw_response="Test raw response for goal alignment"
-                ),
-                MetricCategory.REASONING_EFFICIENCY: EvaluationScore(
-                    score=None,
-                    feedback="Reasoning efficiency not applicable",
-                    raw_response="Reasoning efficiency not applicable"
-                ),
-                MetricCategory.PARAMETER_EXTRACTION: EvaluationScore(
-                    score=7,
-                    feedback="Test parameter extraction explanation",
-                    raw_response="Test raw output"
-                ),
-                MetricCategory.TOOL_SELECTION: EvaluationScore(
-                    score=8,
-                    feedback="Test tool selection explanation",
-                    raw_response="Test raw output"
-                )
-            }
-        )
-
-        return {"Test Agent": agent_evaluation}
-
-    @patch('crewai.experimental.evaluation.experiment.runner.create_default_evaluator')
-    def test_run_success(self, mock_create_evaluator, mock_crew, mock_evaluator_results):
-        dataset = [
-            {
-                "identifier": "test-case-1",
-                "inputs": {"query": "Test query 1"},
-                "expected_score": 8
-            },
-            {
-                "identifier": "test-case-2",
-                "inputs": {"query": "Test query 2"},
-                "expected_score": {"goal_alignment": 7}
-            },
-            {
-                "inputs": {"query": "Test query 3"},
-                "expected_score": {"tool_selection": 9}
-            }
-        ]
-
-        mock_evaluator = MagicMock()
-        mock_evaluator.get_agent_evaluation.return_value = mock_evaluator_results
-        mock_evaluator.reset_iterations_results = MagicMock()
-        mock_create_evaluator.return_value = mock_evaluator
-
-        runner = ExperimentRunner(dataset=dataset)
-
-        results = runner.run(crew=mock_crew)
-
-        assert isinstance(results, ExperimentResults)
-        result_1, result_2, result_3 = results.results
-        assert len(results.results) == 3
-
-        assert result_1.identifier == "test-case-1"
-        assert result_1.inputs == {"query": "Test query 1"}
-        assert result_1.expected_score == 8
-        assert result_1.passed is True
-
-        assert result_2.identifier == "test-case-2"
-        assert result_2.inputs == {"query": "Test query 2"}
-        assert isinstance(result_2.expected_score, dict)
-        assert "goal_alignment" in result_2.expected_score
-        assert result_2.passed is True
-
-        assert result_3.identifier == "c2ed49e63aa9a83af3ca382794134fd5"
-        assert result_3.inputs == {"query": "Test query 3"}
-        assert isinstance(result_3.expected_score, dict)
-        assert "tool_selection" in result_3.expected_score
-        assert result_3.passed is False
-
-        assert mock_crew.kickoff.call_count == 3
-        mock_crew.kickoff.assert_any_call(inputs={"query": "Test query 1"})
-        mock_crew.kickoff.assert_any_call(inputs={"query": "Test query 2"})
-        mock_crew.kickoff.assert_any_call(inputs={"query": "Test query 3"})
-
-        assert mock_evaluator.reset_iterations_results.call_count == 3
-        assert mock_evaluator.get_agent_evaluation.call_count == 3
-
-
-    @patch('crewai.experimental.evaluation.experiment.runner.create_default_evaluator')
-    def test_run_success_with_unknown_metric(self, mock_create_evaluator, mock_crew, mock_evaluator_results):
-        dataset = [
-            {
-                "identifier": "test-case-2",
-                "inputs": {"query": "Test query 2"},
-                "expected_score": {"goal_alignment": 7, "unknown_metric": 8}
-            }
-        ]
-
-        mock_evaluator = MagicMock()
-        mock_evaluator.get_agent_evaluation.return_value = mock_evaluator_results
-        mock_evaluator.reset_iterations_results = MagicMock()
-        mock_create_evaluator.return_value = mock_evaluator
-
-        runner = ExperimentRunner(dataset=dataset)
-
-        results = runner.run(crew=mock_crew)
-
-        result, = results.results
-
-        assert result.identifier == "test-case-2"
-        assert result.inputs == {"query": "Test query 2"}
-        assert isinstance(result.expected_score, dict)
-        assert "goal_alignment" in result.expected_score.keys()
-        assert "unknown_metric" in result.expected_score.keys()
-        assert result.passed is True
-
-    @patch('crewai.experimental.evaluation.experiment.runner.create_default_evaluator')
-    def test_run_success_with_single_metric_evaluator_and_expected_specific_metric(self, mock_create_evaluator, mock_crew, mock_evaluator_results):
-        dataset = [
-            {
-                "identifier": "test-case-2",
-                "inputs": {"query": "Test query 2"},
-                "expected_score": {"goal_alignment": 7}
-            }
-        ]
-
-        mock_evaluator = MagicMock()
-        mock_create_evaluator["Test Agent"].metrics = {
-            MetricCategory.GOAL_ALIGNMENT: EvaluationScore(
-                    score=9,
-                    feedback="Test feedback for goal alignment",
-                    raw_response="Test raw response for goal alignment"
-                )
-        }
-        mock_evaluator.get_agent_evaluation.return_value = mock_evaluator_results
-        mock_evaluator.reset_iterations_results = MagicMock()
-        mock_create_evaluator.return_value = mock_evaluator
-
-        runner = ExperimentRunner(dataset=dataset)
-
-        results = runner.run(crew=mock_crew)
-        result, = results.results
-
-        assert result.identifier == "test-case-2"
-        assert result.inputs == {"query": "Test query 2"}
-        assert isinstance(result.expected_score, dict)
-        assert "goal_alignment" in result.expected_score.keys()
-        assert result.passed is True
-
-    @patch('crewai.experimental.evaluation.experiment.runner.create_default_evaluator')
-    def test_run_success_when_expected_metric_is_not_available(self, mock_create_evaluator, mock_crew, mock_evaluator_results):
-        dataset = [
-            {
-                "identifier": "test-case-2",
-                "inputs": {"query": "Test query 2"},
-                "expected_score": {"unknown_metric": 7}
-            }
-        ]
-
-        mock_evaluator = MagicMock()
-        mock_create_evaluator["Test Agent"].metrics = {
-            MetricCategory.GOAL_ALIGNMENT: EvaluationScore(
-                score=5,
-                feedback="Test feedback for goal alignment",
-                raw_response="Test raw response for goal alignment"
-            )
-        }
-        mock_evaluator.get_agent_evaluation.return_value = mock_evaluator_results
-        mock_evaluator.reset_iterations_results = MagicMock()
-        mock_create_evaluator.return_value = mock_evaluator
-
-        runner = ExperimentRunner(dataset=dataset)
-
-        results = runner.run(crew=mock_crew)
-        result, = results.results
-
-        assert result.identifier == "test-case-2"
-        assert result.inputs == {"query": "Test query 2"}
-        assert isinstance(result.expected_score, dict)
-        assert "unknown_metric" in result.expected_score.keys()
-        assert result.passed is False

tests/llm_test.py

@@ -601,7 +601,7 @@ def test_handle_streaming_tool_calls(get_weather_tool_schema, mock_emit):
 def test_handle_streaming_tool_calls_with_error(get_weather_tool_schema, mock_emit):
     def get_weather_error(location):
         raise Exception("Error")
-
+        
     llm = LLM(model="openai/gpt-4o", stream=True)
     response = llm.call(
         messages=[
@@ -619,7 +619,7 @@ def test_handle_streaming_tool_calls_with_error(get_weather_tool_schema, mock_em
         expected_stream_chunk=9,
         expected_completed_llm_call=1,
         expected_tool_usage_started=1,
-        expected_tool_usage_error=1,
+        expected_tool_usage_error=1,    
         expected_final_chunk_result=expected_final_chunk_result,
     )
 

tests/task_test.py

@@ -1133,119 +1133,6 @@ def test_output_file_validation():
         )
 
 
-def test_create_directory_true():
-    """Test that directories are created when create_directory=True."""
-    from pathlib import Path
-    
-    output_path = "test_create_dir/output.txt"
-    
-    task = Task(
-        description="Test task",
-        expected_output="Test output",
-        output_file=output_path,
-        create_directory=True,
-    )
-    
-    resolved_path = Path(output_path).expanduser().resolve()
-    resolved_dir = resolved_path.parent
-    
-    if resolved_path.exists():
-        resolved_path.unlink()
-    if resolved_dir.exists():
-        import shutil
-        shutil.rmtree(resolved_dir)
-    
-    assert not resolved_dir.exists()
-    
-    task._save_file("test content")
-    
-    assert resolved_dir.exists()
-    assert resolved_path.exists()
-    
-    if resolved_path.exists():
-        resolved_path.unlink()
-    if resolved_dir.exists():
-        import shutil
-        shutil.rmtree(resolved_dir)
-
-
-def test_create_directory_false():
-    """Test that directories are not created when create_directory=False."""
-    from pathlib import Path
-    
-    output_path = "nonexistent_test_dir/output.txt"
-    
-    task = Task(
-        description="Test task",
-        expected_output="Test output",
-        output_file=output_path,
-        create_directory=False,
-    )
-    
-    resolved_path = Path(output_path).expanduser().resolve()
-    resolved_dir = resolved_path.parent
-    
-    if resolved_dir.exists():
-        import shutil
-        shutil.rmtree(resolved_dir)
-    
-    assert not resolved_dir.exists()
-    
-    with pytest.raises(RuntimeError, match="Directory .* does not exist and create_directory is False"):
-        task._save_file("test content")
-
-
-def test_create_directory_default():
-    """Test that create_directory defaults to True for backward compatibility."""
-    task = Task(
-        description="Test task",
-        expected_output="Test output",
-        output_file="output.txt",
-    )
-    
-    assert task.create_directory is True
-
-
-def test_create_directory_with_existing_directory():
-    """Test that create_directory=False works when directory already exists."""
-    from pathlib import Path
-    
-    output_path = "existing_test_dir/output.txt"
-    
-    resolved_path = Path(output_path).expanduser().resolve()
-    resolved_dir = resolved_path.parent
-    resolved_dir.mkdir(parents=True, exist_ok=True)
-    
-    task = Task(
-        description="Test task",
-        expected_output="Test output",
-        output_file=output_path,
-        create_directory=False,
-    )
-    
-    task._save_file("test content")
-    assert resolved_path.exists()
-    
-    if resolved_path.exists():
-        resolved_path.unlink()
-    if resolved_dir.exists():
-        import shutil
-        shutil.rmtree(resolved_dir)
-
-
-def test_github_issue_3149_reproduction():
-    """Test that reproduces the exact issue from GitHub issue #3149."""
-    task = Task(
-        description="Test task for issue reproduction",
-        expected_output="Test output",
-        output_file="test_output.txt",
-        create_directory=True,
-    )
-    
-    assert task.create_directory is True
-    assert task.output_file == "test_output.txt"
-
-
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_task_execution_times():
     researcher = Agent(

tests/test_crew_thread_safety.py

@@ -1,226 +0,0 @@
-import asyncio
-import threading
-from concurrent.futures import ThreadPoolExecutor
-from typing import Dict, Any, Callable
-from unittest.mock import patch
-
-import pytest
-
-from crewai import Agent, Crew, Task
-from crewai.utilities.crew.crew_context import get_crew_context
-
-
-@pytest.fixture
-def simple_agent_factory():
-    def create_agent(name: str) -> Agent:
-        return Agent(
-            role=f"{name} Agent",
-            goal=f"Complete {name} task",
-            backstory=f"I am agent for {name}",
-        )
-
-    return create_agent
-
-
-@pytest.fixture
-def simple_task_factory():
-    def create_task(name: str, callback: Callable = None) -> Task:
-        return Task(
-            description=f"Task for {name}", expected_output="Done", callback=callback
-        )
-
-    return create_task
-
-
-@pytest.fixture
-def crew_factory(simple_agent_factory, simple_task_factory):
-    def create_crew(name: str, task_callback: Callable = None) -> Crew:
-        agent = simple_agent_factory(name)
-        task = simple_task_factory(name, callback=task_callback)
-        task.agent = agent
-
-        return Crew(agents=[agent], tasks=[task], verbose=False)
-
-    return create_crew
-
-
-class TestCrewThreadSafety:
-    @patch("crewai.Agent.execute_task")
-    def test_parallel_crews_thread_safety(self, mock_execute_task, crew_factory):
-        mock_execute_task.return_value = "Task completed"
-        num_crews = 5
-
-        def run_crew_with_context_check(crew_id: str) -> Dict[str, Any]:
-            results = {"crew_id": crew_id, "contexts": []}
-
-            def check_context_task(output):
-                context = get_crew_context()
-                results["contexts"].append(
-                    {
-                        "stage": "task_callback",
-                        "crew_id": context.id if context else None,
-                        "crew_key": context.key if context else None,
-                        "thread": threading.current_thread().name,
-                    }
-                )
-                return output
-
-            context_before = get_crew_context()
-            results["contexts"].append(
-                {
-                    "stage": "before_kickoff",
-                    "crew_id": context_before.id if context_before else None,
-                    "thread": threading.current_thread().name,
-                }
-            )
-
-            crew = crew_factory(crew_id, task_callback=check_context_task)
-            output = crew.kickoff()
-
-            context_after = get_crew_context()
-            results["contexts"].append(
-                {
-                    "stage": "after_kickoff",
-                    "crew_id": context_after.id if context_after else None,
-                    "thread": threading.current_thread().name,
-                }
-            )
-
-            results["crew_uuid"] = str(crew.id)
-            results["output"] = output.raw
-
-            return results
-
-        with ThreadPoolExecutor(max_workers=num_crews) as executor:
-            futures = []
-            for i in range(num_crews):
-                future = executor.submit(run_crew_with_context_check, f"crew_{i}")
-                futures.append(future)
-
-            results = [f.result() for f in futures]
-
-        for result in results:
-            crew_uuid = result["crew_uuid"]
-
-            before_ctx = next(
-                ctx for ctx in result["contexts"] if ctx["stage"] == "before_kickoff"
-            )
-            assert (
-                before_ctx["crew_id"] is None
-            ), f"Context should be None before kickoff for {result['crew_id']}"
-
-            task_ctx = next(
-                ctx for ctx in result["contexts"] if ctx["stage"] == "task_callback"
-            )
-            assert (
-                task_ctx["crew_id"] == crew_uuid
-            ), f"Context mismatch during task for {result['crew_id']}"
-
-            after_ctx = next(
-                ctx for ctx in result["contexts"] if ctx["stage"] == "after_kickoff"
-            )
-            assert (
-                after_ctx["crew_id"] is None
-            ), f"Context should be None after kickoff for {result['crew_id']}"
-
-            thread_name = before_ctx["thread"]
-            assert (
-                "ThreadPoolExecutor" in thread_name
-            ), f"Should run in thread pool for {result['crew_id']}"
-
-    @pytest.mark.asyncio
-    @patch("crewai.Agent.execute_task")
-    async def test_async_crews_thread_safety(self, mock_execute_task, crew_factory):
-        mock_execute_task.return_value = "Task completed"
-        num_crews = 5
-
-        async def run_crew_async(crew_id: str) -> Dict[str, Any]:
-            task_context = {"crew_id": crew_id, "context": None}
-
-            def capture_context(output):
-                ctx = get_crew_context()
-                task_context["context"] = {
-                    "crew_id": ctx.id if ctx else None,
-                    "crew_key": ctx.key if ctx else None,
-                }
-                return output
-
-            crew = crew_factory(crew_id, task_callback=capture_context)
-            output = await crew.kickoff_async()
-
-            return {
-                "crew_id": crew_id,
-                "crew_uuid": str(crew.id),
-                "output": output.raw,
-                "task_context": task_context,
-            }
-
-        tasks = [run_crew_async(f"async_crew_{i}") for i in range(num_crews)]
-        results = await asyncio.gather(*tasks)
-
-        for result in results:
-            crew_uuid = result["crew_uuid"]
-            task_ctx = result["task_context"]["context"]
-
-            assert (
-                task_ctx is not None
-            ), f"Context should exist during task for {result['crew_id']}"
-            assert (
-                task_ctx["crew_id"] == crew_uuid
-            ), f"Context mismatch for {result['crew_id']}"
-
-    @patch("crewai.Agent.execute_task")
-    def test_concurrent_kickoff_for_each(self, mock_execute_task, crew_factory):
-        mock_execute_task.return_value = "Task completed"
-        contexts_captured = []
-
-        def capture_context(output):
-            ctx = get_crew_context()
-            contexts_captured.append(
-                {
-                    "context_id": ctx.id if ctx else None,
-                    "thread": threading.current_thread().name,
-                }
-            )
-            return output
-
-        crew = crew_factory("for_each_test", task_callback=capture_context)
-        inputs = [{"item": f"input_{i}"} for i in range(3)]
-
-        results = crew.kickoff_for_each(inputs=inputs)
-
-        assert len(results) == len(inputs)
-        assert len(contexts_captured) == len(inputs)
-
-        context_ids = [ctx["context_id"] for ctx in contexts_captured]
-        assert len(set(context_ids)) == len(
-            inputs
-        ), "Each execution should have unique context"
-
-    @patch("crewai.Agent.execute_task")
-    def test_no_context_leakage_between_crews(self, mock_execute_task, crew_factory):
-        mock_execute_task.return_value = "Task completed"
-        contexts = []
-
-        def check_context(output):
-            ctx = get_crew_context()
-            contexts.append(
-                {
-                    "context_id": ctx.id if ctx else None,
-                    "context_key": ctx.key if ctx else None,
-                }
-            )
-            return output
-
-        def run_crew(name: str):
-            crew = crew_factory(name, task_callback=check_context)
-            crew.kickoff()
-            return str(crew.id)
-
-        crew1_id = run_crew("First")
-        crew2_id = run_crew("Second")
-
-        assert len(contexts) == 2
-        assert contexts[0]["context_id"] == crew1_id
-        assert contexts[1]["context_id"] == crew2_id
-        assert contexts[0]["context_id"] != contexts[1]["context_id"]

tests/test_lite_agent.py

@@ -12,8 +12,6 @@ from crewai.tools import BaseTool
 from crewai.utilities.events import crewai_event_bus
 from crewai.utilities.events.agent_events import LiteAgentExecutionStartedEvent
 from crewai.utilities.events.tool_usage_events import ToolUsageStartedEvent
-from crewai.llms.base_llm import BaseLLM
-from unittest.mock import patch
 
 
 # A simple test tool
@@ -420,76 +418,3 @@ def test_agent_output_when_guardrail_returns_base_model():
     result = agent.kickoff(messages="Top 10 best players in the world?")
 
     assert result.pydantic == Player(name="Lionel Messi", country="Argentina")
-
-def test_lite_agent_with_custom_llm_and_guardrails():
-    """Test that CustomLLM (inheriting from BaseLLM) works with guardrails."""
-    class CustomLLM(BaseLLM):
-        def __init__(self, response: str = "Custom response"):
-            super().__init__(model="custom-model")
-            self.response = response
-            self.call_count = 0
-
-        def call(self, messages, tools=None, callbacks=None, available_functions=None, from_task=None, from_agent=None) -> str:
-            self.call_count += 1
-
-            if "valid" in str(messages) and "feedback" in str(messages):
-                return '{"valid": true, "feedback": null}'
-
-            if "Thought:" in str(messages):
-                return f"Thought: I will analyze soccer players\nFinal Answer: {self.response}"
-
-            return self.response
-
-        def supports_function_calling(self) -> bool:
-            return False
-
-        def supports_stop_words(self) -> bool:
-            return False
-
-        def get_context_window_size(self) -> int:
-            return 4096
-
-    custom_llm = CustomLLM(response="Brazilian soccer players are the best!")
-
-    agent = LiteAgent(
-        role="Sports Analyst",
-        goal="Analyze soccer players",
-        backstory="You analyze soccer players and their performance.",
-        llm=custom_llm,
-        guardrail="Only include Brazilian players"
-    )
-
-    result = agent.kickoff("Tell me about the best soccer players")
-
-    assert custom_llm.call_count > 0
-    assert "Brazilian" in result.raw
-
-    custom_llm2 = CustomLLM(response="Original response")
-
-    def test_guardrail(output):
-        return (True, "Modified by guardrail")
-
-    agent2 = LiteAgent(
-        role="Test Agent",
-        goal="Test goal",
-        backstory="Test backstory",
-        llm=custom_llm2,
-        guardrail=test_guardrail
-    )
-
-    result2 = agent2.kickoff("Test message")
-    assert result2.raw == "Modified by guardrail"
-
-
-@pytest.mark.vcr(filter_headers=["authorization"])
-def test_lite_agent_with_invalid_llm():
-    """Test that LiteAgent raises proper error when create_llm returns None."""
-    with patch('crewai.lite_agent.create_llm', return_value=None):
-        with pytest.raises(ValueError) as exc_info:
-            LiteAgent(
-                role="Test Agent",
-                goal="Test goal", 
-                backstory="Test backstory",
-                llm="invalid-model"
-            )
-        assert "Expected LLM instance of type BaseLLM" in str(exc_info.value)

tests/utilities/crew/test_crew_context.py

@@ -1,88 +0,0 @@
-import uuid
-
-import pytest
-from opentelemetry import baggage
-from opentelemetry.context import attach, detach
-
-from crewai.utilities.crew.crew_context import get_crew_context
-from crewai.utilities.crew.models import CrewContext
-
-
-def test_crew_context_creation():
-    crew_id = str(uuid.uuid4())
-    context = CrewContext(id=crew_id, key="test-crew")
-    assert context.id == crew_id
-    assert context.key == "test-crew"
-
-
-def test_get_crew_context_with_baggage():
-    crew_id = str(uuid.uuid4())
-    assert get_crew_context() is None
-
-    crew_ctx = CrewContext(id=crew_id, key="test-key")
-    ctx = baggage.set_baggage("crew_context", crew_ctx)
-    token = attach(ctx)
-
-    try:
-        context = get_crew_context()
-        assert context is not None
-        assert context.id == crew_id
-        assert context.key == "test-key"
-    finally:
-        detach(token)
-
-    assert get_crew_context() is None
-
-
-def test_get_crew_context_empty():
-    assert get_crew_context() is None
-
-
-def test_baggage_nested_contexts():
-    crew_id1 = str(uuid.uuid4())
-    crew_id2 = str(uuid.uuid4())
-
-    crew_ctx1 = CrewContext(id=crew_id1, key="outer")
-    ctx1 = baggage.set_baggage("crew_context", crew_ctx1)
-    token1 = attach(ctx1)
-
-    try:
-        outer_context = get_crew_context()
-        assert outer_context.id == crew_id1
-        assert outer_context.key == "outer"
-
-        crew_ctx2 = CrewContext(id=crew_id2, key="inner")
-        ctx2 = baggage.set_baggage("crew_context", crew_ctx2)
-        token2 = attach(ctx2)
-
-        try:
-            inner_context = get_crew_context()
-            assert inner_context.id == crew_id2
-            assert inner_context.key == "inner"
-        finally:
-            detach(token2)
-
-        restored_context = get_crew_context()
-        assert restored_context.id == crew_id1
-        assert restored_context.key == "outer"
-    finally:
-        detach(token1)
-
-    assert get_crew_context() is None
-
-
-def test_baggage_exception_handling():
-    crew_id = str(uuid.uuid4())
-
-    crew_ctx = CrewContext(id=crew_id, key="test")
-    ctx = baggage.set_baggage("crew_context", crew_ctx)
-    token = attach(ctx)
-
-    with pytest.raises(ValueError):
-        try:
-            assert get_crew_context() is not None
-            raise ValueError("Test exception")
-        finally:
-            detach(token)
-
-    assert get_crew_context() is None

uv.lock

@@ -746,10 +746,8 @@ dev = [
     { name = "pytest-asyncio" },
     { name = "pytest-randomly" },
     { name = "pytest-recording" },
-    { name = "pytest-split" },
     { name = "pytest-subprocess" },
     { name = "pytest-timeout" },
-    { name = "pytest-xdist" },
     { name = "python-dotenv" },
     { name = "ruff" },
 ]
@@ -762,7 +760,7 @@ requires-dist = [
     { name = "blinker", specifier = ">=1.9.0" },
     { name = "chromadb", specifier = ">=0.5.23" },
     { name = "click", specifier = ">=8.1.7" },
-    { name = "crewai-tools", marker = "extra == 'tools'", specifier = "~=0.51.0" },
+    { name = "crewai-tools", marker = "extra == 'tools'", specifier = "~=0.49.0" },
     { name = "docling", marker = "extra == 'docling'", specifier = ">=2.12.0" },
     { name = "instructor", specifier = ">=1.3.3" },
     { name = "json-repair", specifier = "==0.25.2" },
@@ -803,17 +801,15 @@ dev = [
     { name = "pytest-asyncio", specifier = ">=0.23.7" },
     { name = "pytest-randomly", specifier = ">=3.16.0" },
     { name = "pytest-recording", specifier = ">=0.13.2" },
-    { name = "pytest-split", specifier = ">=0.9.0" },
     { name = "pytest-subprocess", specifier = ">=1.5.2" },
     { name = "pytest-timeout", specifier = ">=2.3.1" },
-    { name = "pytest-xdist", specifier = ">=3.6.1" },
     { name = "python-dotenv", specifier = ">=1.0.0" },
     { name = "ruff", specifier = ">=0.8.2" },
 ]
 
 [[package]]
 name = "crewai-tools"
-version = "0.51.0"
+version = "0.49.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "chromadb" },
@@ -829,9 +825,9 @@ dependencies = [
     { name = "requests" },
     { name = "tiktoken" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/ef/3426aebf495a887898466d38d6b78b09317d4c102a89493699d6af5aa823/crewai_tools-0.51.0.tar.gz", hash = "sha256:a5d73f344b740b13ffef8d189d6d210da143227982edf619e4de77896e2fd017", size = 1011735, upload-time = "2025-07-09T16:39:24.179Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4b/49/9bfe6c6ef9b951289e872ea3897eaa27812fc62d711a60e1e67ffb732585/crewai_tools-0.49.0.tar.gz", hash = "sha256:fa2e3a0effb62cfc02cdad01a26eee6e9afef464b36f20f74168fed8c11c2c95", size = 938528, upload-time = "2025-07-02T20:27:46.393Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/61/ea/9931f130dae5910a1b2e9d1fc6347d991100538e1faf3ece37ec8380ec96/crewai_tools-0.51.0-py3-none-any.whl", hash = "sha256:ba67e6bed6134e374c96fe9038bce6045600ff3b5358f6a6d75ff8f316defd06", size = 633012, upload-time = "2025-07-09T16:39:22.239Z" },
+    { url = "https://files.pythonhosted.org/packages/20/3d/363fedbb6aa2534eae13e551fcdb5d54ef0ac21c76264d46c37f2ef83f92/crewai_tools-0.49.0-py3-none-any.whl", hash = "sha256:f771d8fd677cd4420409964ab8bb700af616341836051a25d534896e46e8b3c4", size = 622043, upload-time = "2025-07-02T20:27:44.869Z" },
 ]
 
 [[package]]
@@ -1196,15 +1192,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" },
 ]
 
-[[package]]
-name = "execnet"
-version = "2.1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bb/ff/b4c0dc78fbe20c3e59c0c7334de0c27eb4001a2b2017999af398bf730817/execnet-2.1.1.tar.gz", hash = "sha256:5189b52c6121c24feae288166ab41b32549c7e2348652736540b9e6e7d4e72e3", size = 166524, upload-time = "2024-04-08T09:04:19.245Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/09/2aea36ff60d16dd8879bdb2f5b3ee0ba8d08cbbdcdfe870e695ce3784385/execnet-2.1.1-py3-none-any.whl", hash = "sha256:26dee51f1b80cebd6d0ca8e74dd8745419761d3bef34163928cbebbdc4749fdc", size = 40612, upload-time = "2024-04-08T09:04:17.414Z" },
-]
-
 [[package]]
 name = "executing"
 version = "2.2.0"
@@ -3705,8 +3692,6 @@ sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3
 wheels = [
     { url = "https://files.pythonhosted.org/packages/4c/5d/45a3553a253ac8763f3561371432a90bdbe6000fbdcf1397ffe502aa206c/pillow-11.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1b9c17fd4ace828b3003dfd1e30bff24863e0eb59b535e8f80194d9cc7ecf860", size = 5316554, upload-time = "2025-07-01T09:13:39.342Z" },
     { url = "https://files.pythonhosted.org/packages/7c/c8/67c12ab069ef586a25a4a79ced553586748fad100c77c0ce59bb4983ac98/pillow-11.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:65dc69160114cdd0ca0f35cb434633c75e8e7fad4cf855177a05bf38678f73ad", size = 4686548, upload-time = "2025-07-01T09:13:41.835Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/bd/6741ebd56263390b382ae4c5de02979af7f8bd9807346d068700dd6d5cf9/pillow-11.3.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7107195ddc914f656c7fc8e4a5e1c25f32e9236ea3ea860f257b0436011fddd0", size = 5859742, upload-time = "2025-07-03T13:09:47.439Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/0b/c412a9e27e1e6a829e6ab6c2dca52dd563efbedf4c9c6aa453d9a9b77359/pillow-11.3.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc3e831b563b3114baac7ec2ee86819eb03caa1a2cef0b481a5675b59c4fe23b", size = 7633087, upload-time = "2025-07-03T13:09:51.796Z" },
     { url = "https://files.pythonhosted.org/packages/59/9d/9b7076aaf30f5dd17e5e5589b2d2f5a5d7e30ff67a171eb686e4eecc2adf/pillow-11.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f1f182ebd2303acf8c380a54f615ec883322593320a9b00438eb842c1f37ae50", size = 5963350, upload-time = "2025-07-01T09:13:43.865Z" },
     { url = "https://files.pythonhosted.org/packages/f0/16/1a6bf01fb622fb9cf5c91683823f073f053005c849b1f52ed613afcf8dae/pillow-11.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4445fa62e15936a028672fd48c4c11a66d641d2c05726c7ec1f8ba6a572036ae", size = 6631840, upload-time = "2025-07-01T09:13:46.161Z" },
     { url = "https://files.pythonhosted.org/packages/7b/e6/6ff7077077eb47fde78739e7d570bdcd7c10495666b6afcd23ab56b19a43/pillow-11.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:71f511f6b3b91dd543282477be45a033e4845a40278fa8dcdbfdb07109bf18f9", size = 6074005, upload-time = "2025-07-01T09:13:47.829Z" },
@@ -3716,8 +3701,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9f/28/4f4a0203165eefb3763939c6789ba31013a2e90adffb456610f30f613850/pillow-11.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:819931d25e57b513242859ce1876c58c59dc31587847bf74cfe06b2e0cb22d2f", size = 2422899, upload-time = "2025-07-01T09:13:57.497Z" },
     { url = "https://files.pythonhosted.org/packages/db/26/77f8ed17ca4ffd60e1dcd220a6ec6d71210ba398cfa33a13a1cd614c5613/pillow-11.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1cd110edf822773368b396281a2293aeb91c90a2db00d78ea43e7e861631b722", size = 5316531, upload-time = "2025-07-01T09:13:59.203Z" },
     { url = "https://files.pythonhosted.org/packages/cb/39/ee475903197ce709322a17a866892efb560f57900d9af2e55f86db51b0a5/pillow-11.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9c412fddd1b77a75aa904615ebaa6001f169b26fd467b4be93aded278266b288", size = 4686560, upload-time = "2025-07-01T09:14:01.101Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/90/442068a160fd179938ba55ec8c97050a612426fae5ec0a764e345839f76d/pillow-11.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1aa4de119a0ecac0a34a9c8bde33f34022e2e8f99104e47a3ca392fd60e37d", size = 5870978, upload-time = "2025-07-03T13:09:55.638Z" },
-    { url = "https://files.pythonhosted.org/packages/13/92/dcdd147ab02daf405387f0218dcf792dc6dd5b14d2573d40b4caeef01059/pillow-11.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:91da1d88226663594e3f6b4b8c3c8d85bd504117d043740a8e0ec449087cc494", size = 7641168, upload-time = "2025-07-03T13:10:00.37Z" },
     { url = "https://files.pythonhosted.org/packages/6e/db/839d6ba7fd38b51af641aa904e2960e7a5644d60ec754c046b7d2aee00e5/pillow-11.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:643f189248837533073c405ec2f0bb250ba54598cf80e8c1e043381a60632f58", size = 5973053, upload-time = "2025-07-01T09:14:04.491Z" },
     { url = "https://files.pythonhosted.org/packages/f2/2f/d7675ecae6c43e9f12aa8d58b6012683b20b6edfbdac7abcb4e6af7a3784/pillow-11.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:106064daa23a745510dabce1d84f29137a37224831d88eb4ce94bb187b1d7e5f", size = 6640273, upload-time = "2025-07-01T09:14:06.235Z" },
     { url = "https://files.pythonhosted.org/packages/45/ad/931694675ede172e15b2ff03c8144a0ddaea1d87adb72bb07655eaffb654/pillow-11.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd8ff254faf15591e724dc7c4ddb6bf4793efcbe13802a4ae3e863cd300b493e", size = 6082043, upload-time = "2025-07-01T09:14:07.978Z" },
@@ -3727,8 +3710,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c6/df/90bd886fabd544c25addd63e5ca6932c86f2b701d5da6c7839387a076b4a/pillow-11.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:30807c931ff7c095620fe04448e2c2fc673fcbb1ffe2a7da3fb39613489b1ddd", size = 2423079, upload-time = "2025-07-01T09:14:15.268Z" },
     { url = "https://files.pythonhosted.org/packages/40/fe/1bc9b3ee13f68487a99ac9529968035cca2f0a51ec36892060edcc51d06a/pillow-11.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4", size = 5278800, upload-time = "2025-07-01T09:14:17.648Z" },
     { url = "https://files.pythonhosted.org/packages/2c/32/7e2ac19b5713657384cec55f89065fb306b06af008cfd87e572035b27119/pillow-11.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69", size = 4686296, upload-time = "2025-07-01T09:14:19.828Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/1e/b9e12bbe6e4c2220effebc09ea0923a07a6da1e1f1bfbc8d7d29a01ce32b/pillow-11.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d", size = 5871726, upload-time = "2025-07-03T13:10:04.448Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/33/e9200d2bd7ba00dc3ddb78df1198a6e80d7669cce6c2bdbeb2530a74ec58/pillow-11.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6", size = 7644652, upload-time = "2025-07-03T13:10:10.391Z" },
     { url = "https://files.pythonhosted.org/packages/41/f1/6f2427a26fc683e00d985bc391bdd76d8dd4e92fac33d841127eb8fb2313/pillow-11.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7", size = 5977787, upload-time = "2025-07-01T09:14:21.63Z" },
     { url = "https://files.pythonhosted.org/packages/e4/c9/06dd4a38974e24f932ff5f98ea3c546ce3f8c995d3f0985f8e5ba48bba19/pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024", size = 6645236, upload-time = "2025-07-01T09:14:23.321Z" },
     { url = "https://files.pythonhosted.org/packages/40/e7/848f69fb79843b3d91241bad658e9c14f39a32f71a301bcd1d139416d1be/pillow-11.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809", size = 6086950, upload-time = "2025-07-01T09:14:25.237Z" },
@@ -3741,8 +3722,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/aa/86/3f758a28a6e381758545f7cdb4942e1cb79abd271bea932998fc0db93cb6/pillow-11.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7859a4cc7c9295f5838015d8cc0a9c215b77e43d07a25e460f35cf516df8626f", size = 2227443, upload-time = "2025-07-01T09:14:39.344Z" },
     { url = "https://files.pythonhosted.org/packages/01/f4/91d5b3ffa718df2f53b0dc109877993e511f4fd055d7e9508682e8aba092/pillow-11.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec1ee50470b0d050984394423d96325b744d55c701a439d2bd66089bff963d3c", size = 5278474, upload-time = "2025-07-01T09:14:41.843Z" },
     { url = "https://files.pythonhosted.org/packages/f9/0e/37d7d3eca6c879fbd9dba21268427dffda1ab00d4eb05b32923d4fbe3b12/pillow-11.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7db51d222548ccfd274e4572fdbf3e810a5e66b00608862f947b163e613b67dd", size = 4686038, upload-time = "2025-07-01T09:14:44.008Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/b0/3426e5c7f6565e752d81221af9d3676fdbb4f352317ceafd42899aaf5d8a/pillow-11.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2d6fcc902a24ac74495df63faad1884282239265c6839a0a6416d33faedfae7e", size = 5864407, upload-time = "2025-07-03T13:10:15.628Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/c1/c6c423134229f2a221ee53f838d4be9d82bab86f7e2f8e75e47b6bf6cd77/pillow-11.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0f5d8f4a08090c6d6d578351a2b91acf519a54986c055af27e7a93feae6d3f1", size = 7639094, upload-time = "2025-07-03T13:10:21.857Z" },
     { url = "https://files.pythonhosted.org/packages/ba/c9/09e6746630fe6372c67c648ff9deae52a2bc20897d51fa293571977ceb5d/pillow-11.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c37d8ba9411d6003bba9e518db0db0c58a680ab9fe5179f040b0463644bc9805", size = 5973503, upload-time = "2025-07-01T09:14:45.698Z" },
     { url = "https://files.pythonhosted.org/packages/d5/1c/a2a29649c0b1983d3ef57ee87a66487fdeb45132df66ab30dd37f7dbe162/pillow-11.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13f87d581e71d9189ab21fe0efb5a23e9f28552d5be6979e84001d3b8505abe8", size = 6642574, upload-time = "2025-07-01T09:14:47.415Z" },
     { url = "https://files.pythonhosted.org/packages/36/de/d5cc31cc4b055b6c6fd990e3e7f0f8aaf36229a2698501bcb0cdf67c7146/pillow-11.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:023f6d2d11784a465f09fd09a34b150ea4672e85fb3d05931d89f373ab14abb2", size = 6084060, upload-time = "2025-07-01T09:14:49.636Z" },
@@ -3752,8 +3731,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/17/d2/622f4547f69cd173955194b78e4d19ca4935a1b0f03a302d655c9f6aae65/pillow-11.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:1904e1264881f682f02b7f8167935cce37bc97db457f8e7849dc3a6a52b99580", size = 2423055, upload-time = "2025-07-01T09:14:58.072Z" },
     { url = "https://files.pythonhosted.org/packages/dd/80/a8a2ac21dda2e82480852978416cfacd439a4b490a501a288ecf4fe2532d/pillow-11.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4c834a3921375c48ee6b9624061076bc0a32a60b5532b322cc0ea64e639dd50e", size = 5281110, upload-time = "2025-07-01T09:14:59.79Z" },
     { url = "https://files.pythonhosted.org/packages/44/d6/b79754ca790f315918732e18f82a8146d33bcd7f4494380457ea89eb883d/pillow-11.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e05688ccef30ea69b9317a9ead994b93975104a677a36a8ed8106be9260aa6d", size = 4689547, upload-time = "2025-07-01T09:15:01.648Z" },
-    { url = "https://files.pythonhosted.org/packages/49/20/716b8717d331150cb00f7fdd78169c01e8e0c219732a78b0e59b6bdb2fd6/pillow-11.3.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1019b04af07fc0163e2810167918cb5add8d74674b6267616021ab558dc98ced", size = 5901554, upload-time = "2025-07-03T13:10:27.018Z" },
-    { url = "https://files.pythonhosted.org/packages/74/cf/a9f3a2514a65bb071075063a96f0a5cf949c2f2fce683c15ccc83b1c1cab/pillow-11.3.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f944255db153ebb2b19c51fe85dd99ef0ce494123f21b9db4877ffdfc5590c7c", size = 7669132, upload-time = "2025-07-03T13:10:33.01Z" },
     { url = "https://files.pythonhosted.org/packages/98/3c/da78805cbdbee9cb43efe8261dd7cc0b4b93f2ac79b676c03159e9db2187/pillow-11.3.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f85acb69adf2aaee8b7da124efebbdb959a104db34d3a2cb0f3793dbae422a8", size = 6005001, upload-time = "2025-07-01T09:15:03.365Z" },
     { url = "https://files.pythonhosted.org/packages/6c/fa/ce044b91faecf30e635321351bba32bab5a7e034c60187fe9698191aef4f/pillow-11.3.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f6ecbeff5005399bb48d198f098a9b4b6bdf27b8487c7f38ca16eeb070cd59", size = 6668814, upload-time = "2025-07-01T09:15:05.655Z" },
     { url = "https://files.pythonhosted.org/packages/7b/51/90f9291406d09bf93686434f9183aba27b831c10c87746ff49f127ee80cb/pillow-11.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a7bc6e6fd0395bc052f16b1a8670859964dbd7003bd0af2ff08342eb6e442cfe", size = 6113124, upload-time = "2025-07-01T09:15:07.358Z" },
@@ -3763,15 +3740,11 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f3/7e/b623008460c09a0cb38263c93b828c666493caee2eb34ff67f778b87e58c/pillow-11.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:8797edc41f3e8536ae4b10897ee2f637235c94f27404cac7297f7b607dd0716e", size = 2424803, upload-time = "2025-07-01T09:15:15.695Z" },
     { url = "https://files.pythonhosted.org/packages/6f/8b/209bd6b62ce8367f47e68a218bffac88888fdf2c9fcf1ecadc6c3ec1ebc7/pillow-11.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:3cee80663f29e3843b68199b9d6f4f54bd1d4a6b59bdd91bceefc51238bcb967", size = 5270556, upload-time = "2025-07-01T09:16:09.961Z" },
     { url = "https://files.pythonhosted.org/packages/2e/e6/231a0b76070c2cfd9e260a7a5b504fb72da0a95279410fa7afd99d9751d6/pillow-11.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b5f56c3f344f2ccaf0dd875d3e180f631dc60a51b314295a3e681fe8cf851fbe", size = 4654625, upload-time = "2025-07-01T09:16:11.913Z" },
-    { url = "https://files.pythonhosted.org/packages/13/f4/10cf94fda33cb12765f2397fc285fa6d8eb9c29de7f3185165b702fc7386/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e67d793d180c9df62f1f40aee3accca4829d3794c95098887edc18af4b8b780c", size = 4874207, upload-time = "2025-07-03T13:11:10.201Z" },
-    { url = "https://files.pythonhosted.org/packages/72/c9/583821097dc691880c92892e8e2d41fe0a5a3d6021f4963371d2f6d57250/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d000f46e2917c705e9fb93a3606ee4a819d1e3aa7a9b442f6444f07e77cf5e25", size = 6583939, upload-time = "2025-07-03T13:11:15.68Z" },
     { url = "https://files.pythonhosted.org/packages/3b/8e/5c9d410f9217b12320efc7c413e72693f48468979a013ad17fd690397b9a/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:527b37216b6ac3a12d7838dc3bd75208ec57c1c6d11ef01902266a5a0c14fc27", size = 4957166, upload-time = "2025-07-01T09:16:13.74Z" },
     { url = "https://files.pythonhosted.org/packages/62/bb/78347dbe13219991877ffb3a91bf09da8317fbfcd4b5f9140aeae020ad71/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be5463ac478b623b9dd3937afd7fb7ab3d79dd290a28e2b6df292dc75063eb8a", size = 5581482, upload-time = "2025-07-01T09:16:16.107Z" },
     { url = "https://files.pythonhosted.org/packages/d9/28/1000353d5e61498aaeaaf7f1e4b49ddb05f2c6575f9d4f9f914a3538b6e1/pillow-11.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:8dc70ca24c110503e16918a658b869019126ecfe03109b754c402daff12b3d9f", size = 6984596, upload-time = "2025-07-01T09:16:18.07Z" },
     { url = "https://files.pythonhosted.org/packages/9e/e3/6fa84033758276fb31da12e5fb66ad747ae83b93c67af17f8c6ff4cc8f34/pillow-11.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7c8ec7a017ad1bd562f93dbd8505763e688d388cde6e4a010ae1486916e713e6", size = 5270566, upload-time = "2025-07-01T09:16:19.801Z" },
     { url = "https://files.pythonhosted.org/packages/5b/ee/e8d2e1ab4892970b561e1ba96cbd59c0d28cf66737fc44abb2aec3795a4e/pillow-11.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9ab6ae226de48019caa8074894544af5b53a117ccb9d3b3dcb2871464c829438", size = 4654618, upload-time = "2025-07-01T09:16:21.818Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/6d/17f80f4e1f0761f02160fc433abd4109fa1548dcfdca46cfdadaf9efa565/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe27fb049cdcca11f11a7bfda64043c37b30e6b91f10cb5bab275806c32f6ab3", size = 4874248, upload-time = "2025-07-03T13:11:20.738Z" },
-    { url = "https://files.pythonhosted.org/packages/de/5f/c22340acd61cef960130585bbe2120e2fd8434c214802f07e8c03596b17e/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:465b9e8844e3c3519a983d58b80be3f668e2a7a5db97f2784e7079fbc9f9822c", size = 6583963, upload-time = "2025-07-03T13:11:26.283Z" },
     { url = "https://files.pythonhosted.org/packages/31/5e/03966aedfbfcbb4d5f8aa042452d3361f325b963ebbadddac05b122e47dd/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5418b53c0d59b3824d05e029669efa023bbef0f3e92e75ec8428f3799487f361", size = 4957170, upload-time = "2025-07-01T09:16:23.762Z" },
     { url = "https://files.pythonhosted.org/packages/cc/2d/e082982aacc927fc2cab48e1e731bdb1643a1406acace8bed0900a61464e/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:504b6f59505f08ae014f724b6207ff6222662aab5cc9542577fb084ed0676ac7", size = 5581505, upload-time = "2025-07-01T09:16:25.593Z" },
     { url = "https://files.pythonhosted.org/packages/34/e7/ae39f538fd6844e982063c3a5e4598b8ced43b9633baa3a85ef33af8c05c/pillow-11.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8", size = 6984598, upload-time = "2025-07-01T09:16:27.732Z" },
@@ -4388,18 +4361,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/42/c2/ce34735972cc42d912173e79f200fe66530225190c06655c5632a9d88f1e/pytest_recording-0.13.4-py3-none-any.whl", hash = "sha256:ad49a434b51b1c4f78e85b1e6b74fdcc2a0a581ca16e52c798c6ace971f7f439", size = 13723, upload-time = "2025-05-08T10:41:09.684Z" },
 ]
 
-[[package]]
-name = "pytest-split"
-version = "0.10.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/46/d7/e30ba44adf83f15aee3f636daea54efadf735769edc0f0a7d98163f61038/pytest_split-0.10.0.tar.gz", hash = "sha256:adf80ba9fef7be89500d571e705b4f963dfa05038edf35e4925817e6b34ea66f", size = 13903, upload-time = "2024-10-16T15:45:19.783Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d6/a7/cad88e9c1109a5c2a320d608daa32e5ee008ccbc766310f54b1cd6b3d69c/pytest_split-0.10.0-py3-none-any.whl", hash = "sha256:466096b086a7147bcd423c6e6c2e57fc62af1c5ea2e256b4ed50fc030fc3dddc", size = 11961, upload-time = "2024-10-16T15:45:18.289Z" },
-]
-
 [[package]]
 name = "pytest-subprocess"
 version = "1.5.3"
@@ -4424,19 +4385,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fa/b6/3127540ecdf1464a00e5a01ee60a1b09175f6913f0644ac748494d9c4b21/pytest_timeout-2.4.0-py3-none-any.whl", hash = "sha256:c42667e5cdadb151aeb5b26d114aff6bdf5a907f176a007a30b940d3d865b5c2", size = 14382, upload-time = "2025-05-05T19:44:33.502Z" },
 ]
 
-[[package]]
-name = "pytest-xdist"
-version = "3.8.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "execnet" },
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/78/b4/439b179d1ff526791eb921115fca8e44e596a13efeda518b9d845a619450/pytest_xdist-3.8.0.tar.gz", hash = "sha256:7e578125ec9bc6050861aa93f2d59f1d8d085595d6551c2c90b6f4fad8d3a9f1", size = 88069, upload-time = "2025-07-01T13:30:59.346Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ca/31/d4e37e9e550c2b92a9cbc2e4d0b7420a27224968580b5a447f420847c975/pytest_xdist-3.8.0-py3-none-any.whl", hash = "sha256:202ca578cfeb7370784a8c33d6d05bc6e13b4f25b5053c30a152269fd10f0b88", size = 46396, upload-time = "2025-07-01T13:30:56.632Z" },
-]
-
 [[package]]
 name = "python-bidi"
 version = "0.6.6"