Merge branch 'main' into lg-guardrail-llm

It is used internally and should not be recommended for building tools intended for Agent consumption

docs/concepts/agents.mdx

@@ -255,7 +255,11 @@ custom_agent = Agent(
 - `response_template`: Formats agent responses
 
 <Note>
-When using custom templates, you can use variables like `{role}`, `{goal}`, and `{input}` in your templates. These will be automatically populated during execution.
+When using custom templates, ensure that both `system_template` and `prompt_template` are defined. The `response_template` is optional but recommended for consistent output formatting.
+</Note>  
+
+<Note>
+When using custom templates, you can use variables like `{role}`, `{goal}`, and `{backstory}` in your templates. These will be automatically populated during execution.
 </Note>
 
 ## Agent Tools

docs/concepts/tasks.mdx

@@ -322,6 +322,10 @@ 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")`
 
+### TaskGuardrail
+
+The `TaskGuardrail` class offers a robust mechanism for validating task outputs
+
 ### Error Handling Best Practices
 
 1. **Structured Error Responses**:
@@ -750,6 +754,8 @@ Task guardrails provide a powerful way to validate, transform, or filter task ou
 
 ### Basic Usage
 
+#### Define your own logic to validate
+
 ```python Code
 from typing import Tuple, Union
 from crewai import Task
@@ -769,6 +775,57 @@ task = Task(
 )
 ```
 
+#### 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=TaskGuardrail(
+        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.

docs/concepts/tools.mdx

@@ -190,48 +190,6 @@ def my_tool(question: str) -> str:
     return "Result from your custom tool"
 ```
 
-### Structured Tools
-
-The `StructuredTool` class wraps functions as tools, providing flexibility and validation while reducing boilerplate. It supports custom schemas and dynamic logic for seamless integration of complex functionalities.
-
-#### Example:
-Using `StructuredTool.from_function`, you can wrap a function that interacts with an external API or system, providing a structured interface. This enables robust validation and consistent execution, making it easier to integrate complex functionalities into your applications as demonstrated in the following example:
-
-```python
-from crewai.tools.structured_tool import CrewStructuredTool
-from pydantic import BaseModel
-
-# Define the schema for the tool's input using Pydantic
-class APICallInput(BaseModel):
-    endpoint: str
-    parameters: dict
-
-# Wrapper function to execute the API call
-def tool_wrapper(*args, **kwargs):
-    # Here, you would typically call the API using the parameters
-    # For demonstration, we'll return a placeholder string
-    return f"Call the API at {kwargs['endpoint']} with parameters {kwargs['parameters']}"
-
-# Create and return the structured tool
-def create_structured_tool():
-    return CrewStructuredTool.from_function(
-        name='Wrapper API',
-        description="A tool to wrap API calls with structured input.",
-        args_schema=APICallInput,
-        func=tool_wrapper,
-    )
-
-# Example usage
-structured_tool = create_structured_tool()
-
-# Execute the tool with structured input
-result = structured_tool._run(**{
-    "endpoint": "https://example.com/api",
-    "parameters": {"key1": "value1", "key2": "value2"}
-})
-print(result)  # Output: Call the API at https://example.com/api with parameters {'key1': 'value1', 'key2': 'value2'}
-```
-
 ### Custom Caching Mechanism
 
 <Tip>

docs/docs.json

@@ -180,6 +180,42 @@
           }
         ]
       },
+      {
+        "tab": "Enterprise",
+        "groups": [
+          {
+            "group": "Getting Started",
+            "pages": [
+              "enterprise/introduction"
+            ]
+          },
+          {
+            "group": "How-To Guides",
+            "pages": [
+              "enterprise/guides/build-crew",
+              "enterprise/guides/deploy-crew",
+              "enterprise/guides/kickoff-crew",
+              "enterprise/guides/update-crew",
+              "enterprise/guides/use-crew-api",
+              "enterprise/guides/enable-crew-studio"
+            ]
+          },
+          {
+            "group": "Features",
+            "pages": [
+              "enterprise/features/tool-repository",
+              "enterprise/features/webhook-streaming",
+              "enterprise/features/traces"
+            ]
+          },
+          {
+            "group": "Resources",
+            "pages": [
+              "enterprise/resources/frequently-asked-questions"
+            ]
+          }
+        ]
+      },
       {
         "tab": "Examples",
         "groups": [

docs/enterprise/features/tool-repository.mdx

@@ -0,0 +1,106 @@
+---
+title: Tool Repository
+description: "Using the Tool Repository to manage your tools"
+icon: "toolbox"
+---
+
+## Overview
+
+The Tool Repository is a package manager for CrewAI tools. It allows users to publish, install, and manage tools that integrate with CrewAI crews and flows.
+
+Tools can be:
+
+- **Private**: accessible only within your organization (default)
+- **Public**: accessible to all CrewAI users if published with the `--public` flag
+
+The repository is not a version control system. Use Git to track code changes and enable collaboration.
+
+## Prerequisites
+
+Before using the Tool Repository, ensure you have:
+
+- A [CrewAI Enterprise](https://app.crewai.com) account
+- [CrewAI CLI](https://docs.crewai.com/concepts/cli#cli) installed
+- [Git](https://git-scm.com) installed and configured
+- Access permissions to publish or install tools in your CrewAI Enterprise organization
+
+## Installing Tools
+
+To install a tool:
+
+```bash
+crewai tool install <tool-name>
+```
+
+This installs the tool and adds it to `pyproject.toml`.
+
+## Creating and Publishing Tools
+
+To create a new tool project:
+
+```bash
+crewai tool create <tool-name>
+```
+
+This generates a scaffolded tool project locally.
+
+After making changes, initialize a Git repository and commit the code:
+
+```bash
+git init
+git add .
+git commit -m "Initial version"
+```
+
+To publish the tool:
+
+```bash
+crewai tool publish
+```
+
+By default, tools are published as private. To make a tool public:
+
+```bash
+crewai tool publish --public
+```
+
+For more details on how to build tools, see [Creating your own tools](https://docs.crewai.com/concepts/tools#creating-your-own-tools).
+
+## Updating Tools
+
+To update a published tool:
+
+1. Modify the tool locally
+2. Update the version in `pyproject.toml` (e.g., from `0.1.0` to `0.1.1`)
+3. Commit the changes and publish
+
+```bash
+git commit -m "Update version to 0.1.1"
+crewai tool publish
+```
+
+## Deleting Tools
+
+To delete a tool:
+
+1. Go to [CrewAI Enterprise](https://app.crewai.com)
+2. Navigate to **Tools**
+3. Select the tool
+4. Click **Delete**
+
+<Warning>
+Deletion is permanent. Deleted tools cannot be restored or re-installed.
+</Warning>
+
+## Security Checks
+
+Every published version undergoes automated security checks, and are only available to install after they pass. 
+
+You can check the security check status of a tool at:
+
+`CrewAI Enterprise > Tools > Your Tool > Versions`
+
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with API integration or troubleshooting.
+</Card>

docs/enterprise/features/traces.mdx

@@ -0,0 +1,146 @@
+---
+title: Traces
+description: "Using Traces to monitor your Crews"
+icon: "timeline"
+---
+
+## Overview
+
+Traces provide comprehensive visibility into your crew executions, helping you monitor performance, debug issues, and optimize your AI agent workflows.
+
+## What are Traces?
+
+Traces in CrewAI Enterprise are detailed execution records that capture every aspect of your crew's operation, from initial inputs to final outputs. They record:
+
+- Agent thoughts and reasoning
+- Task execution details
+- Tool usage and outputs
+- Token consumption metrics
+- Execution times
+- Cost estimates
+
+<Frame>
+  ![Traces Overview](/images/enterprise/traces-overview.png)
+</Frame>
+
+## Accessing Traces
+
+<Steps>
+  <Step title="Navigate to the Traces Tab">
+    Once in your CrewAI Enterprise dashboard, click on the **Traces** to view all execution records.
+  </Step>
+  
+  <Step title="Select an Execution">
+    You'll see a list of all crew executions, sorted by date. Click on any execution to view its detailed trace.
+  </Step>
+</Steps>
+
+## Understanding the Trace Interface
+
+The trace interface is divided into several sections, each providing different insights into your crew's execution:
+
+### 1. Execution Summary
+
+The top section displays high-level metrics about the execution:
+
+- **Total Tokens**: Number of tokens consumed across all tasks
+- **Prompt Tokens**: Tokens used in prompts to the LLM
+- **Completion Tokens**: Tokens generated in LLM responses
+- **Requests**: Number of API calls made
+- **Execution Time**: Total duration of the crew run
+- **Estimated Cost**: Approximate cost based on token usage
+
+<Frame>
+  ![Execution Summary](/images/enterprise/trace-summary.png)
+</Frame>
+
+### 2. Tasks & Agents
+
+This section shows all tasks and agents that were part of the crew execution:
+
+- Task name and agent assignment
+- Agents and LLMs used for each task
+- Status (completed/failed)
+- Individual execution time of the task
+
+<Frame>
+  ![Task List](/images/enterprise/trace-tasks.png)
+</Frame>
+
+### 3. Final Output
+
+Displays the final result produced by the crew after all tasks are completed.
+
+<Frame>
+  ![Final Output](/images/enterprise/final-output.png)
+</Frame>
+
+### 4. Execution Timeline
+
+A visual representation of when each task started and ended, helping you identify bottlenecks or parallel execution patterns.
+
+<Frame>
+  ![Execution Timeline](/images/enterprise/trace-timeline.png)
+</Frame>
+
+### 5. Detailed Task View
+
+When you click on a specific task in the timeline or task list, you'll see:
+
+<Frame>
+  ![Detailed Task View](/images/enterprise/trace-detailed-task.png)
+</Frame>
+
+- **Task Key**: Unique identifier for the task
+- **Task ID**: Technical identifier in the system
+- **Status**: Current state (completed/running/failed)
+- **Agent**: Which agent performed the task
+- **LLM**: Language model used for this task
+- **Start/End Time**: When the task began and completed
+- **Execution Time**: Duration of this specific task
+- **Task Description**: What the agent was instructed to do
+- **Expected Output**: What output format was requested
+- **Input**: Any input provided to this task from previous tasks
+- **Output**: The actual result produced by the agent
+
+
+## Using Traces for Debugging
+
+Traces are invaluable for troubleshooting issues with your crews:
+
+<Steps>
+  <Step title="Identify Failure Points">
+    When a crew execution doesn't produce the expected results, examine the trace to find where things went wrong. Look for:
+    
+    - Failed tasks
+    - Unexpected agent decisions
+    - Tool usage errors
+    - Misinterpreted instructions
+
+    <Frame>
+      ![Failure Points](/images/enterprise/failure.png)
+    </Frame>
+  </Step>
+  
+  <Step title="Optimize Performance">
+    Use execution metrics to identify performance bottlenecks:
+    
+    - Tasks that took longer than expected
+    - Excessive token usage
+    - Redundant tool operations
+    - Unnecessary API calls
+  </Step>
+  
+  <Step title="Improve Cost Efficiency">
+    Analyze token usage and cost estimates to optimize your crew's efficiency:
+    
+    - Consider using smaller models for simpler tasks
+    - Refine prompts to be more concise
+    - Cache frequently accessed information
+    - Structure tasks to minimize redundant operations
+  </Step>
+</Steps>
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with trace analysis or any other CrewAI Enterprise features.
+</Card>

docs/enterprise/features/webhook-streaming.mdx

@@ -0,0 +1,82 @@
+---
+title: Webhook Streaming
+description: "Using Webhook Streaming to stream events to your webhook"
+icon: "webhook"
+---
+
+## Overview
+
+Enterprise Event Streaming lets you receive real-time webhook updates about your crews and flows deployed to 
+CrewAI Enterprise, such as model calls, tool usage, and flow steps.
+
+## Usage
+
+When using the Kickoff API, include a `webhooks` object to your request, for example:
+
+```json
+{
+  "inputs": {"foo": "bar"},
+  "webhooks": {
+    "events": ["crew_kickoff_started", "llm_call_started"],
+    "url": "https://your.endpoint/webhook",
+    "realtime": false,
+    "authentication": {
+      "strategy": "bearer",
+      "token": "my-secret-token"
+    }
+  }
+}
+```
+
+If `realtime` is set to `true`, each event is delivered individually and immediately, at the cost of crew/flow performance.
+
+## Webhook Format
+
+Each webhook sends a list of events:
+
+```json
+{
+  "events": [
+    {
+      "id": "event-id",
+      "execution_id": "crew-run-id",
+      "timestamp": "2025-02-16T10:58:44.965Z",
+      "type": "llm_call_started",
+      "data": {
+        "model": "gpt-4",
+        "messages": [
+          {"role": "system", "content": "You are an assistant."},
+          {"role": "user", "content": "Summarize this article."}
+        ]
+      }
+    }
+  ]
+}
+```
+
+The `data` object structure varies by event type. Refer to the [event list](https://github.com/crewAIInc/crewAI/tree/main/src/crewai/utilities/events) on GitHub.
+
+As requests are sent over HTTP, the order of events can't be guaranteed. If you need ordering, use the `timestamp` field.
+
+## Supported Events
+
+CrewAI supports both system events and custom events in Enterprise Event Streaming. These events are sent to your configured webhook endpoint during crew and flow execution.
+
+- `crew_kickoff_started`
+- `crew_step_started`
+- `crew_step_completed`
+- `crew_execution_completed`
+- `llm_call_started`
+- `llm_call_completed`
+- `tool_usage_started`
+- `tool_usage_completed`
+- `crew_test_failed`
+- *...and others*
+
+Event names match the internal event bus. See [GitHub source](https://github.com/crewAIInc/crewAI/tree/main/src/crewai/utilities/events) for the full list.
+
+You can emit your own custom events, and they will be delivered through the webhook stream alongside system events.
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with webhook integration or troubleshooting.
+</Card>

docs/enterprise/guides/build-crew.mdx

@@ -0,0 +1,43 @@
+---
+title: "Build Crew"
+description: "A Crew is a group of agents that work together to complete a task."
+icon: "people-arrows"
+---
+
+<Tip>
+[CrewAI Enterprise](https://app.crewai.com) streamlines the process of **creating**, **deploying**, and **managing** your AI agents in production environments.
+</Tip>
+
+## Getting Started
+
+<iframe 
+    width="100%"
+    height="400"
+    src="https://www.youtube.com/embed/d1Yp8eeknDk?si=tIxnTRI5UlyCp3z_" 
+    title="Building Crews with CrewAI CLI" 
+    frameborder="0"
+    style={{ borderRadius: '10px' }}
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowfullscreen
+></iframe>
+
+### Installation and Setup
+
+<Card title="Follow Standard Installation" icon="wrench" href="/installation">
+  Follow our standard installation guide to set up CrewAI CLI and create your first project.
+</Card>
+
+### Building Your Crew
+
+<Card title="Quickstart Tutorial" icon="rocket" href="/quickstart">
+  Follow our quickstart guide to create your first agent crew using YAML configuration.
+</Card>
+
+## Support and Resources
+
+For Enterprise-specific support or questions, contact our dedicated support team at [support@crewai.com](mailto:support@crewai.com).
+
+
+<Card title="Schedule a Demo" icon="calendar" href="mailto:support@crewai.com">
+  Book time with our team to learn more about Enterprise features and how they can benefit your organization.
+</Card>

docs/enterprise/guides/deploy-crew.mdx

@@ -0,0 +1,216 @@
+---
+title: "Deploy Crew"
+description: "Deploy your local CrewAI project to the Enterprise platform"
+icon: "cloud-arrow-up"
+---
+
+## Option 1: CLI Deployment
+
+<Tip>
+This video tutorial walks you through the process of deploying your locally developed CrewAI project to the CrewAI Enterprise platform, 
+transforming it into a production-ready API endpoint.
+</Tip>
+
+<iframe 
+    width="100%"
+    height="400"
+    src="https://www.youtube.com/embed/3EqSV-CYDZA" 
+    title="Deploying a Crew to CrewAI Enterprise" 
+    frameborder="0"
+    style={{ borderRadius: '10px' }}
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+    allowfullscreen
+></iframe>
+
+## Prerequisites
+
+Before starting the deployment process, make sure you have:
+
+- A CrewAI project built locally ([follow our quickstart guide](/quickstart) if you haven't created one yet)
+- Your code pushed to a GitHub repository
+- The latest version of the CrewAI CLI installed (`uv tool install crewai`)
+
+<Note>
+For a quick reference project, you can clone our example repository at [github.com/tonykipkemboi/crewai-latest-ai-development](https://github.com/tonykipkemboi/crewai-latest-ai-development).
+</Note>
+
+
+
+### Step 1: Authenticate with the Enterprise Platform
+
+First, you need to authenticate your CLI with the CrewAI Enterprise platform:
+
+```bash
+# If you already have a CrewAI Enterprise account
+crewai login
+
+# If you're creating a new account
+crewai signup
+```
+
+When you run either command, the CLI will:
+1. Display a URL and a unique device code
+2. Open your browser to the authentication page
+3. Prompt you to confirm the device
+4. Complete the authentication process
+
+Upon successful authentication, you'll see a confirmation message in your terminal!
+
+### Step 2: Create a Deployment
+
+From your project directory, run:
+
+```bash
+crewai deploy create
+```
+
+This command will:
+1. Detect your GitHub repository information
+2. Identify environment variables in your local `.env` file
+3. Securely transfer these variables to the Enterprise platform
+4. Create a new deployment with a unique identifier
+
+On successful creation, you'll see a message like:
+```shell
+Deployment created successfully!
+Name: your_project_name
+Deployment ID: 01234567-89ab-cdef-0123-456789abcdef
+Current Status: Deploy Enqueued
+```
+
+### Step 3: Monitor Deployment Progress
+
+Track the deployment status with:
+
+```bash
+crewai deploy status
+```
+
+For detailed logs of the build process:
+
+```bash
+crewai deploy logs
+```
+
+<Tip>
+The first deployment typically takes 10-15 minutes as it builds the container images. Subsequent deployments are much faster.
+</Tip>
+
+### Additional CLI Commands
+
+The CrewAI CLI offers several commands to manage your deployments:
+
+```bash
+# List all your deployments
+crewai deploy list
+
+# Get the status of your deployment
+crewai deploy status
+
+# View the logs of your deployment
+crewai deploy logs
+
+# Push updates after code changes
+crewai deploy push
+
+# Remove a deployment
+crewai deploy remove <deployment_id>
+```
+
+## Option 2: Deploy Directly via Web Interface
+
+You can also deploy your crews directly through the CrewAI Enterprise web interface by connecting your GitHub account. This approach doesn't require using the CLI on your local machine.
+
+### Step 1: Pushing to GitHub
+
+First, you need to push your crew to a GitHub repository. If you haven't created a crew yet, you can [follow this tutorial](/quickstart).
+
+### Step 2: Connecting GitHub to CrewAI Enterprise
+
+1. Log in to [CrewAI Enterprise](https://app.crewai.com)
+2. Click on the button "Connect GitHub" 
+
+<Frame>
+  ![Connect GitHub Button](/images/enterprise/connect-github.png)
+</Frame>
+
+### Step 3: Select the Repository
+
+After connecting your GitHub account, you'll be able to select which repository to deploy:
+
+<Frame>
+  ![Select Repository](/images/enterprise/select-repo.png)
+</Frame>
+
+### Step 4: Set Environment Variables
+
+Before deploying, you'll need to set up your environment variables to connect to your LLM provider or other services:
+
+1. You can add variables individually or in bulk
+2. Enter your environment variables in `KEY=VALUE` format (one per line)
+
+<Frame>
+  ![Set Environment Variables](/images/enterprise/set-env-variables.png)
+</Frame>
+
+### Step 5: Deploy Your Crew
+
+1. Click the "Deploy" button to start the deployment process
+2. You can monitor the progress through the progress bar
+3. The first deployment typically takes around 10-15 minutes; subsequent deployments will be faster
+
+<Frame>
+  ![Deploy Progress](/images/enterprise/deploy-progress.png)
+</Frame>
+
+Once deployment is complete, you'll see:
+- Your crew's unique URL
+- A Bearer token to protect your crew API
+- A "Delete" button if you need to remove the deployment
+
+### Interact with Your Deployed Crew
+
+Once deployment is complete, you can access your crew through:
+
+1. **REST API**: The platform generates a unique HTTPS endpoint with these key routes:
+   - `/inputs`: Lists the required input parameters
+   - `/kickoff`: Initiates an execution with provided inputs
+   - `/status/{kickoff_id}`: Checks the execution status
+
+2. **Web Interface**: Visit [app.crewai.com](https://app.crewai.com) to access:
+   - **Status tab**: View deployment information, API endpoint details, and authentication token
+   - **Run tab**: Visual representation of your crew's structure
+   - **Executions tab**: History of all executions
+   - **Metrics tab**: Performance analytics
+   - **Traces tab**: Detailed execution insights
+
+### Trigger an Execution
+
+From the Enterprise dashboard, you can:
+
+1. Click on your crew's name to open its details
+2. Select "Trigger Crew" from the management interface
+3. Enter the required inputs in the modal that appears
+4. Monitor progress as the execution moves through the pipeline
+
+## Monitoring and Analytics
+
+The Enterprise platform provides comprehensive observability features:
+
+- **Execution Management**: Track active and completed runs
+- **Traces**: Detailed breakdowns of each execution
+- **Metrics**: Token usage, execution times, and costs
+- **Timeline View**: Visual representation of task sequences
+
+## Advanced Features
+
+The Enterprise platform also offers:
+
+- **Environment Variables Management**: Securely store and manage API keys
+- **LLM Connections**: Configure integrations with various LLM providers
+- **Custom Tools Repository**: Create, share, and install tools
+- **Crew Studio**: Build crews through a chat interface without writing code
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with deployment issues or questions about the Enterprise platform.
+</Card>

docs/enterprise/guides/enable-crew-studio.mdx

@@ -0,0 +1,166 @@
+---
+title: "Enable Crew Studio"
+description: "Enabling Crew Studio on CrewAI Enterprise"
+icon: "comments"
+---
+
+<Tip>
+Crew Studio is a powerful **no-code/low-code** tool that allows you to quickly scaffold or build Crews through a conversational interface. 
+</Tip>
+
+## What is Crew Studio?
+
+Crew Studio is an innovative way to create AI agent crews without writing code. 
+
+<Frame>
+  ![Crew Studio Interface](/images/enterprise/crew-studio-interface.png)
+</Frame>
+
+With Crew Studio, you can:
+
+- Chat with the Crew Assistant to describe your problem
+- Automatically generate agents and tasks
+- Select appropriate tools
+- Configure necessary inputs
+- Generate downloadable code for customization
+- Deploy directly to the CrewAI Enterprise platform
+
+## Configuration Steps
+
+Before you can start using Crew Studio, you need to configure your LLM connections:
+
+<Steps>
+  <Step title="Set Up LLM Connection">
+    Go to the **LLM Connections** tab in your CrewAI Enterprise dashboard and create a new LLM connection.
+
+    <Note>
+      Feel free to use any LLM provider you want that is supported by CrewAI.
+    </Note>
+    
+    Configure your LLM connection:
+    
+    - Enter a `Connection Name` (e.g., `OpenAI`)
+    - Select your model provider: `openai` or `azure`
+    - Select models you'd like to use in your Studio-generated Crews
+      - We recommend at least `gpt-4o`, `o1-mini`, and `gpt-4o-mini`
+    - Add your API key as an environment variable:
+      - For OpenAI: Add `OPENAI_API_KEY` with your API key
+      - For Azure OpenAI: Refer to [this article](https://blog.crewai.com/configuring-azure-openai-with-crewai-a-comprehensive-guide/) for configuration details
+    - Click `Add Connection` to save your configuration
+    
+    <Frame>
+      ![LLM Connection Configuration](/images/enterprise/llm-connection-config.png)
+    </Frame>
+  </Step>
+  
+  <Step title="Verify Connection Added">
+    Once you complete the setup, you'll see your new connection added to the list of available connections.
+    
+    <Frame>
+      ![Connection Added](/images/enterprise/connection-added.png)
+    </Frame>
+  </Step>
+  
+  <Step title="Configure LLM Defaults">
+    In the main menu, go to **Settings → Defaults** and configure the LLM Defaults settings:
+    
+    - Select default models for agents and other components
+    - Set default configurations for Crew Studio
+    
+    Click `Save Settings` to apply your changes.
+    
+    <Frame>
+      ![LLM Defaults Configuration](/images/enterprise/llm-defaults.png)
+    </Frame>
+  </Step>
+</Steps>
+
+## Using Crew Studio
+
+Now that you've configured your LLM connection and default settings, you're ready to start using Crew Studio!
+
+<Steps>
+  <Step title="Access Studio">
+    Navigate to the **Studio** section in your CrewAI Enterprise dashboard.
+  </Step>
+  
+  <Step title="Start a Conversation">
+    Start a conversation with the Crew Assistant by describing the problem you want to solve:
+    
+    ```md
+    I need a crew that can research the latest AI developments and create a summary report.
+    ```
+    
+    The Crew Assistant will ask clarifying questions to better understand your requirements.
+  </Step>
+  
+  <Step title="Review Generated Crew">
+    Review the generated crew configuration, including:
+    
+    - Agents and their roles
+    - Tasks to be performed
+    - Required inputs
+    - Tools to be used
+    
+    This is your opportunity to refine the configuration before proceeding.
+  </Step>
+  
+  <Step title="Deploy or Download">
+    Once you're satisfied with the configuration, you can:
+    
+    - Download the generated code for local customization
+    - Deploy the crew directly to the CrewAI Enterprise platform
+    - Modify the configuration and regenerate the crew
+  </Step>
+  
+  <Step title="Test Your Crew">
+    After deployment, test your crew with sample inputs to ensure it performs as expected.
+  </Step>
+</Steps>
+
+<Tip>
+For best results, provide clear, detailed descriptions of what you want your crew to accomplish. Include specific inputs and expected outputs in your description.
+</Tip>
+
+## Example Workflow
+
+Here's a typical workflow for creating a crew with Crew Studio:
+
+<Steps>
+  <Step title="Describe Your Problem">
+    Start by describing your problem:
+    
+    ```md
+    I need a crew that can analyze financial news and provide investment recommendations
+    ```
+  </Step>
+  
+  <Step title="Answer Questions">
+    Respond to clarifying questions from the Crew Assistant to refine your requirements.
+  </Step>
+  
+  <Step title="Review the Plan">
+    Review the generated crew plan, which might include:
+    
+    - A Research Agent to gather financial news
+    - An Analysis Agent to interpret the data
+    - A Recommendations Agent to provide investment advice
+  </Step>
+  
+  <Step title="Approve or Modify">
+    Approve the plan or request changes if necessary.
+  </Step>
+  
+  <Step title="Download or Deploy">
+    Download the code for customization or deploy directly to the platform.
+  </Step>
+  
+  <Step title="Test and Refine">
+    Test your crew with sample inputs and refine as needed.
+  </Step>
+</Steps>
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with Crew Studio or any other CrewAI Enterprise features.
+</Card>
+

docs/enterprise/guides/kickoff-crew.mdx

@@ -0,0 +1,186 @@
+---
+title: "Kickoff Crew"
+description: "Kickoff a Crew on CrewAI Enterprise"
+icon: "flag-checkered"
+---
+
+# Kickoff a Crew on CrewAI Enterprise
+
+Once you've deployed your crew to the CrewAI Enterprise platform, you can kickoff executions through the web interface or the API. This guide covers both approaches.
+
+## Method 1: Using the Web Interface
+
+### Step 1: Navigate to Your Deployed Crew
+
+1. Log in to [CrewAI Enterprise](https://app.crewai.com)
+2. Click on the crew name from your projects list
+3. You'll be taken to the crew's detail page
+
+<Frame>
+  ![Crew Dashboard](/images/enterprise/crew-dashboard.png)
+</Frame>
+
+### Step 2: Initiate Execution
+
+From your crew's detail page, you have two options to kickoff an execution:
+
+#### Option A: Quick Kickoff
+
+1. Click the `Kickoff` link in the Test Endpoints section
+2. Enter the required input parameters for your crew in the JSON editor
+3. Click the `Send Request` button
+
+<Frame>
+  ![Kickoff Endpoint](/images/enterprise/kickoff-endpoint.png)
+</Frame>
+
+#### Option B: Using the Visual Interface
+
+1. Click the `Run` tab in the crew detail page
+2. Enter the required inputs in the form fields
+3. Click the `Run Crew` button
+
+<Frame>
+  ![Run Crew](/images/enterprise/run-crew.png)
+</Frame>
+
+### Step 3: Monitor Execution Progress
+
+After initiating the execution:
+
+1. You'll receive a response containing a `kickoff_id` - **copy this ID**
+2. This ID is essential for tracking your execution
+
+<Frame>
+  ![Copy Task ID](/images/enterprise/copy-task-id.png)
+</Frame>
+
+### Step 4: Check Execution Status
+
+To monitor the progress of your execution:
+
+1. Click the "Status" endpoint in the Test Endpoints section
+2. Paste the `kickoff_id` into the designated field
+3. Click the "Get Status" button
+
+<Frame>
+  ![Get Status](/images/enterprise/get-status.png)
+</Frame>
+
+The status response will show:
+- Current execution state (`running`, `completed`, etc.)
+- Details about which tasks are in progress
+- Any outputs produced so far
+
+### Step 5: View Final Results
+
+Once execution is complete:
+
+1. The status will change to `completed`
+2. You can view the full execution results and outputs
+3. For a more detailed view, check the `Executions` tab in the crew detail page
+
+## Method 2: Using the API
+
+You can also kickoff crews programmatically using the CrewAI Enterprise REST API.
+
+### Authentication
+
+All API requests require a bearer token for authentication:
+
+```bash
+curl -H "Authorization: Bearer YOUR_CREW_TOKEN" https://your-crew-url.crewai.com
+```
+
+Your bearer token is available on the Status tab of your crew's detail page.
+
+### Checking Crew Health
+
+Before executing operations, you can verify that your crew is running properly:
+
+```bash
+curl -H "Authorization: Bearer YOUR_CREW_TOKEN" https://your-crew-url.crewai.com
+```
+
+A successful response will return a message indicating the crew is operational:
+
+```
+Healthy%
+```
+
+### Step 1: Retrieve Required Inputs
+
+First, determine what inputs your crew requires:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/inputs
+```
+
+The response will be a JSON object containing an array of required input parameters, for example:
+
+```json
+{"inputs":["topic","current_year"]}
+```
+
+This example shows that this particular crew requires two inputs: `topic` and `current_year`.
+
+### Step 2: Kickoff Execution
+
+Initiate execution by providing the required inputs:
+
+```bash
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  -d '{"inputs": {"topic": "AI Agent Frameworks", "current_year": "2025"}}' \
+  https://your-crew-url.crewai.com/kickoff
+```
+
+The response will include a `kickoff_id` that you'll need for tracking:
+
+```json
+{"kickoff_id":"abcd1234-5678-90ef-ghij-klmnopqrstuv"}
+```
+
+### Step 3: Check Execution Status
+
+Monitor the execution progress using the kickoff_id:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/status/abcd1234-5678-90ef-ghij-klmnopqrstuv
+```
+
+## Handling Executions
+
+### Long-Running Executions
+
+For executions that may take a long time:
+
+1. Consider implementing a polling mechanism to check status periodically
+2. Use webhooks (if available) for notification when execution completes
+3. Implement error handling for potential timeouts
+
+### Execution Context
+
+The execution context includes:
+
+- Inputs provided at kickoff
+- Environment variables configured during deployment
+- Any state maintained between tasks
+
+### Debugging Failed Executions
+
+If an execution fails:
+
+1. Check the "Executions" tab for detailed logs
+2. Review the "Traces" tab for step-by-step execution details
+3. Look for LLM responses and tool usage in the trace details
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with execution issues or questions about the Enterprise platform.
+</Card>
+

docs/enterprise/guides/update-crew.mdx

@@ -0,0 +1,89 @@
+---
+title: "Update Crew"
+description: "Updating a Crew on CrewAI Enterprise"
+icon: "pencil"
+---
+
+<Note>
+After deploying your crew to CrewAI Enterprise, you may need to make updates to the code, security settings, or configuration. 
+This guide explains how to perform these common update operations.
+</Note>
+
+## Why Update Your Crew?
+
+CrewAI won't automatically pick up GitHub updates by default, so you'll need to manually trigger updates, unless you checked the `Auto-update` option when deploying your crew.
+
+There are several reasons you might want to update your crew deployment:
+- You want to update the code with a latest commit you pushed to GitHub
+- You want to reset the bearer token for security reasons
+- You want to update environment variables
+
+## 1. Updating Your Crew Code for a Latest Commit
+
+When you've pushed new commits to your GitHub repository and want to update your deployment:
+
+1. Navigate to your crew in the CrewAI Enterprise platform
+2. Click on the `Re-deploy` button on your crew details page
+
+<Frame>
+  ![Re-deploy Button](/images/enterprise/redeploy-button.png)
+</Frame>
+
+This will trigger an update that you can track using the progress bar. The system will pull the latest code from your repository and rebuild your deployment.
+
+## 2. Resetting Bearer Token
+
+If you need to generate a new bearer token (for example, if you suspect the current token might have been compromised):
+
+1. Navigate to your crew in the CrewAI Enterprise platform
+2. Find the `Bearer Token` section
+3. Click the `Reset` button next to your current token
+
+<Frame>
+  ![Reset Token](/images/enterprise/reset-token.png)
+</Frame>
+
+<Warning>
+Resetting your bearer token will invalidate the previous token immediately. Make sure to update any applications or scripts that are using the old token.
+</Warning>
+
+## 3. Updating Environment Variables
+
+To update the environment variables for your crew:
+
+1. First access the deployment page by clicking on your crew's name
+
+<Frame>
+  ![Environment Variables Button](/images/enterprise/env-vars-button.png)
+</Frame>
+
+2. Locate the `Environment Variables` section (you will need to click the `Settings` icon to access it)
+3. Edit the existing variables or add new ones in the fields provided
+4. Click the `Update` button next to each variable you modify
+
+<Frame>
+  ![Update Environment Variables](/images/enterprise/update-env-vars.png)
+</Frame>
+
+5. Finally, click the `Update Deployment` button at the bottom of the page to apply the changes
+
+<Note>
+Updating environment variables will trigger a new deployment, but this will only update the environment configuration and not the code itself.
+</Note>
+
+## After Updating
+
+After performing any update:
+
+1. The system will rebuild and redeploy your crew
+2. You can monitor the deployment progress in real-time
+3. Once complete, test your crew to ensure the changes are working as expected
+
+<Tip>
+If you encounter any issues after updating, you can view deployment logs in the platform or contact support for assistance.
+</Tip>
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with updating your crew or troubleshooting deployment issues.
+</Card>
+

docs/enterprise/guides/use-crew-api.mdx

@@ -0,0 +1,319 @@
+---
+title: "Trigger Deployed Crew API"
+description: "Using your deployed crew's API on CrewAI Enterprise"
+icon: "arrow-up-right-from-square"
+---
+
+Once you have deployed your crew to CrewAI Enterprise, it automatically becomes available as a REST API. This guide explains how to interact with your crew programmatically.
+
+## API Basics
+
+Your deployed crew exposes several endpoints that allow you to:
+1. Discover required inputs
+2. Start crew executions
+3. Monitor execution status
+4. Receive results
+
+### Authentication
+
+All API requests require a bearer token for authentication, which is generated when you deploy your crew:
+
+```bash
+curl -H "Authorization: Bearer YOUR_CREW_TOKEN" https://your-crew-url.crewai.com/...
+```
+
+<Tip>
+You can find your bearer token in the Status tab of your crew's detail page in the CrewAI Enterprise dashboard.
+</Tip>
+
+<Frame>
+  ![Bearer Token](/images/enterprise/bearer-token.png)
+</Frame>
+
+## Available Endpoints
+
+Your crew API provides three main endpoints:
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/inputs` | GET | Lists all required inputs for crew execution |
+| `/kickoff` | POST | Starts a crew execution with provided inputs |
+| `/status/{kickoff_id}` | GET | Retrieves the status and results of an execution |
+
+## GET /inputs
+
+The inputs endpoint allows you to discover what parameters your crew requires:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/inputs
+```
+
+### Response
+
+```json
+{
+  "inputs": ["budget", "interests", "duration", "age"]
+}
+```
+
+This response indicates that your crew expects four input parameters: `budget`, `interests`, `duration`, and `age`.
+
+## POST /kickoff
+
+The kickoff endpoint starts a new crew execution:
+
+```bash
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  -d '{
+    "inputs": {
+      "budget": "1000 USD",
+      "interests": "games, tech, ai, relaxing hikes, amazing food",
+      "duration": "7 days",
+      "age": "35"
+    }
+  }' \
+  https://your-crew-url.crewai.com/kickoff
+```
+
+### Request Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `inputs` | Object | Yes | Key-value pairs of all required inputs |
+| `meta` | Object | No | Additional metadata to pass to the crew |
+| `taskWebhookUrl` | String | No | Callback URL executed after each task |
+| `stepWebhookUrl` | String | No | Callback URL executed after each agent thought |
+| `crewWebhookUrl` | String | No | Callback URL executed when the crew finishes |
+
+### Example with Webhooks
+
+```json
+{
+  "inputs": {
+    "budget": "1000 USD",
+    "interests": "games, tech, ai, relaxing hikes, amazing food",
+    "duration": "7 days",
+    "age": "35"
+  },
+  "meta": {
+    "requestId": "user-request-12345",
+    "source": "mobile-app"
+  },
+  "taskWebhookUrl": "https://your-server.com/webhooks/task",
+  "stepWebhookUrl": "https://your-server.com/webhooks/step",
+  "crewWebhookUrl": "https://your-server.com/webhooks/crew"
+}
+```
+
+### Response
+
+```json
+{
+  "kickoff_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+}
+```
+
+The `kickoff_id` is used to track and retrieve the execution results.
+
+## GET /status/{kickoff_id}
+
+The status endpoint allows you to check the progress and results of a crew execution:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/status/abcd1234-5678-90ef-ghij-klmnopqrstuv
+```
+
+### Response Structure
+
+The response structure will vary depending on the execution state:
+
+#### In Progress
+
+```json
+{
+  "status": "running",
+  "current_task": "research_task",
+  "progress": {
+    "completed_tasks": 0,
+    "total_tasks": 2
+  }
+}
+```
+
+#### Completed
+
+```json
+{
+  "status": "completed",
+  "result": {
+    "output": "Comprehensive travel itinerary...",
+    "tasks": [
+      {
+        "task_id": "research_task",
+        "output": "Research findings...",
+        "agent": "Researcher",
+        "execution_time": 45.2
+      },
+      {
+        "task_id": "planning_task",
+        "output": "7-day itinerary plan...",
+        "agent": "Trip Planner",
+        "execution_time": 62.8
+      }
+    ]
+  },
+  "execution_time": 108.5
+}
+```
+
+## Webhook Integration
+
+When you provide webhook URLs in your kickoff request, the system will make POST requests to those URLs at specific points in the execution:
+
+### taskWebhookUrl
+
+Called when each task completes:
+
+```json
+{
+  "kickoff_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+  "task_id": "research_task",
+  "status": "completed",
+  "output": "Research findings...",
+  "agent": "Researcher",
+  "execution_time": 45.2
+}
+```
+
+### stepWebhookUrl
+
+Called after each agent thought or action:
+
+```json
+{
+  "kickoff_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+  "task_id": "research_task",
+  "agent": "Researcher",
+  "step_type": "thought",
+  "content": "I should first search for popular destinations that match these interests..."
+}
+```
+
+### crewWebhookUrl
+
+Called when the entire crew execution completes:
+
+```json
+{
+  "kickoff_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+  "status": "completed",
+  "result": {
+    "output": "Comprehensive travel itinerary...",
+    "tasks": [
+      {
+        "task_id": "research_task",
+        "output": "Research findings...",
+        "agent": "Researcher",
+        "execution_time": 45.2
+      },
+      {
+        "task_id": "planning_task",
+        "output": "7-day itinerary plan...",
+        "agent": "Trip Planner",
+        "execution_time": 62.8
+      }
+    ]
+  },
+  "execution_time": 108.5,
+  "meta": {
+    "requestId": "user-request-12345",
+    "source": "mobile-app"
+  }
+}
+```
+
+## Best Practices
+
+### Handling Long-Running Executions
+
+Crew executions can take anywhere from seconds to minutes depending on their complexity. Consider these approaches:
+
+1. **Webhooks (Recommended)**: Set up webhook endpoints to receive notifications when the execution completes
+2. **Polling**: Implement a polling mechanism with exponential backoff
+3. **Client-Side Timeout**: Set appropriate timeouts for your API requests
+
+### Error Handling
+
+The API may return various error codes:
+
+| Code | Description | Recommended Action |
+|------|-------------|-------------------|
+| 401 | Unauthorized | Check your bearer token |
+| 404 | Not Found | Verify your crew URL and kickoff_id |
+| 422 | Validation Error | Ensure all required inputs are provided |
+| 500 | Server Error | Contact support with the error details |
+
+### Sample Code
+
+Here's a complete Python example for interacting with your crew API:
+
+```python
+import requests
+import time
+
+# Configuration
+CREW_URL = "https://your-crew-url.crewai.com"
+BEARER_TOKEN = "your-crew-token"
+HEADERS = {
+    "Authorization": f"Bearer {BEARER_TOKEN}",
+    "Content-Type": "application/json"
+}
+
+# 1. Get required inputs
+response = requests.get(f"{CREW_URL}/inputs", headers=HEADERS)
+required_inputs = response.json()["inputs"]
+print(f"Required inputs: {required_inputs}")
+
+# 2. Start crew execution
+payload = {
+    "inputs": {
+        "budget": "1000 USD",
+        "interests": "games, tech, ai, relaxing hikes, amazing food",
+        "duration": "7 days",
+        "age": "35"
+    }
+}
+
+response = requests.post(f"{CREW_URL}/kickoff", headers=HEADERS, json=payload)
+kickoff_id = response.json()["kickoff_id"]
+print(f"Execution started with ID: {kickoff_id}")
+
+# 3. Poll for results
+MAX_RETRIES = 30
+POLL_INTERVAL = 10  # seconds
+for i in range(MAX_RETRIES):
+    print(f"Checking status (attempt {i+1}/{MAX_RETRIES})...")
+    response = requests.get(f"{CREW_URL}/status/{kickoff_id}", headers=HEADERS)
+    data = response.json()
+    
+    if data["status"] == "completed":
+        print("Execution completed!")
+        print(f"Result: {data['result']['output']}")
+        break
+    elif data["status"] == "error":
+        print(f"Execution failed: {data.get('error', 'Unknown error')}")
+        break
+    else:
+        print(f"Status: {data['status']}, waiting {POLL_INTERVAL} seconds...")
+        time.sleep(POLL_INTERVAL)
+```
+
+<Card title="Need Help?" icon="headset" href="mailto:support@crewai.com">
+  Contact our support team for assistance with API integration or troubleshooting.
+</Card>

docs/enterprise/introduction.mdx

@@ -0,0 +1,67 @@
+---
+title: "CrewAI Enterprise"
+description: "Deploy, monitor, and scale your AI agent workflows"
+icon: "globe"
+---
+
+## Introduction
+
+CrewAI Enterprise provides a platform for deploying, monitoring, and scaling your crews and agents in a production environment.
+
+CrewAI Enterprise extends the power of the open-source framework with features designed for production deployments, collaboration, and scalability. Deploy your crews to a managed infrastructure and monitor their execution in real-time.
+
+## Key Features
+
+<CardGroup cols={2}>
+  <Card title="Crew Deployments" icon="rocket">
+    Deploy your crews to a managed infrastructure with a few clicks
+  </Card>
+  <Card title="API Access" icon="code">
+    Access your deployed crews via REST API for integration with existing systems
+  </Card>
+  <Card title="Observability" icon="chart-line">
+    Monitor your crews with detailed execution traces and logs
+  </Card>
+  <Card title="Tool Repository" icon="toolbox">
+    Publish and install tools to enhance your crews' capabilities
+  </Card>
+  <Card title="Webhook Streaming" icon="webhook">
+    Stream real-time events and updates to your systems
+  </Card>
+  <Card title="Crew Studio" icon="paintbrush">
+    Create and customize crews using a no-code/low-code interface
+  </Card>
+</CardGroup>
+
+## Deployment Options
+
+<CardGroup cols={3}>
+  <Card title="GitHub Integration" icon="github">
+    Connect directly to your GitHub repositories to deploy code
+  </Card>
+  <Card title="Crew Studio" icon="palette">
+    Deploy crews created through the no-code Crew Studio interface
+  </Card>
+  <Card title="CLI Deployment" icon="terminal">
+    Use the CrewAI CLI for more advanced deployment workflows
+  </Card>
+</CardGroup>
+
+## Getting Started
+
+<Steps>
+  <Step title="Sign up for an account">
+    Create your account at [app.crewai.com](https://app.crewai.com)
+  </Step>
+  <Step title="Create your first crew">
+    Use code or Crew Studio to create your crew
+  </Step>
+  <Step title="Deploy your crew">
+    Deploy your crew to the Enterprise platform
+  </Step>
+  <Step title="Access your crew">
+    Integrate with your crew via the generated API endpoints
+  </Step>
+</Steps>
+
+For detailed instructions, check out our [deployment guide](/enterprise/guides/deploy-crew) or click the button below to get started.

docs/enterprise/resources/frequently-asked-questions.mdx

@@ -0,0 +1,181 @@
+---
+title: FAQs
+description: "Frequently asked questions about CrewAI Enterprise"
+icon: "code"
+---
+
+<AccordionGroup>
+    <Accordion title="How is task execution handled in the hierarchical process?">
+        In the hierarchical process, a manager agent is automatically created and coordinates the workflow, delegating tasks and validating outcomes for
+        streamlined and effective execution. The manager agent utilizes tools to facilitate task delegation and execution by agents under the manager's guidance.
+        The manager LLM is crucial for the hierarchical process and must be set up correctly for proper function.
+    </Accordion>
+
+    <Accordion title="Where can I get the latest CrewAI documentation?">
+        The most up-to-date documentation for CrewAI is available on our official documentation website; https://docs.crewai.com/
+        <Card href="https://docs.crewai.com/" icon="books">CrewAI Docs</Card>
+    </Accordion>
+
+    <Accordion title="What are the key differences between Hierarchical and Sequential Processes in CrewAI?">
+        #### Hierarchical Process:
+        Tasks are delegated and executed based on a structured chain of command.
+        A manager language model (`manager_llm`) must be specified for the manager agent.
+        Manager agent oversees task execution, planning, delegation, and validation.
+        Tasks are not pre-assigned; the manager allocates tasks to agents based on their capabilities.
+
+        #### Sequential Process:
+        Tasks are executed one after another, ensuring tasks are completed in an orderly progression.
+        Output of one task serves as context for the next.
+        Task execution follows the predefined order in the task list.
+
+        #### Which Process is Better Suited for Complex Projects?
+
+        The hierarchical process is better suited for complex projects because it allows for:
+
+        - **Dynamic task allocation and delegation**: Manager agent can assign tasks based on agent capabilities, allowing for efficient resource utilization.
+        - **Structured validation and oversight**: Manager agent reviews task outputs and ensures task completion, increasing reliability and accuracy.
+        - **Complex task management**: Assigning tools at the agent level allows for precise control over tool availability, facilitating the execution of intricate tasks.
+    </Accordion>
+
+    <Accordion title="What are the benefits of using memory in the CrewAI framework?">
+        - **Adaptive Learning**: Crews become more efficient over time, adapting to new information and refining their approach to tasks.
+        - **Enhanced Personalization**: Memory enables agents to remember user preferences and historical interactions, leading to personalized experiences.
+        - **Improved Problem Solving**: Access to a rich memory store aids agents in making more informed decisions, drawing on past learnings and contextual insights.
+    </Accordion>
+
+    <Accordion title="What is the purpose of setting a maximum RPM limit for an agent?">
+        Setting a maximum RPM limit for an agent prevents the agent from making too many requests to external services, which can help to avoid rate limits and improve performance.
+    </Accordion>
+
+    <Accordion title="What role does human input play in the execution of tasks within a CrewAI crew?">
+        It allows agents to request additional information or clarification when necessary.
+        This feature is crucial in complex decision-making processes or when agents require more details to complete a task effectively.
+
+        To integrate human input into agent execution, set the `human_input` flag in the task definition. When enabled, the agent prompts the user for input before delivering its final answer. 
+        This input can provide extra context, clarify ambiguities, or validate the agent's output.
+    </Accordion>
+
+    <Accordion title="What advanced customization options are available for tailoring and enhancing agent behavior and capabilities in CrewAI?">
+        CrewAI provides a range of advanced customization options to tailor and enhance agent behavior and capabilities:
+        
+        - **Language Model Customization**: Agents can be customized with specific language models (`llm`) and function-calling language models (`function_calling_llm`), offering advanced control over their processing and decision-making abilities.
+
+        - **Performance and Debugging Settings**: Adjust an agent's performance and monitor its operations for efficient task execution.
+
+        - **Verbose Mode**: Enables detailed logging of an agent's actions, useful for debugging and optimization.
+
+        - **RPM Limit**: Sets the maximum number of requests per minute (`max_rpm`).
+
+        - **Maximum Iterations for Task Execution**: The `max_iter` attribute allows users to define the maximum number of iterations an agent can perform for a single task, preventing infinite loops or excessively long executions.
+
+        - **Delegation and Autonomy**: Control an agent's ability to delegate or ask questions, tailoring its autonomy and collaborative dynamics within the CrewAI framework. By default, the `allow_delegation` attribute is set to True, enabling agents to seek assistance or delegate tasks as needed. This default behavior promotes collaborative problem-solving and efficiency within the CrewAI ecosystem. If needed, delegation can be disabled to suit specific operational requirements.
+
+        - **Human Input in Agent Execution**: Human input is critical in several agent execution scenarios, allowing agents to request additional information or clarification when necessary. This feature is especially useful in complex decision-making processes or when agents require more details to complete a task effectively.
+    </Accordion>
+
+    <Accordion title="In what scenarios is human input particularly useful in agent execution?">
+        Human input is particularly useful in agent execution when:
+        - **Agents require additional information or clarification**: When agents encounter ambiguity or incomplete data, human input can provide the necessary context to complete the task effectively.
+        - **Agents need to make complex or sensitive decisions**: Human input can assist agents in ethical or nuanced decision-making, ensuring responsible and informed outcomes.
+        - **Oversight and validation of agent output**: Human input can help validate the results generated by agents, ensuring accuracy and preventing any misinterpretation or errors.
+        - **Customizing agent behavior**: Human input can provide feedback on agent responses, allowing users to refine the agent's behavior and responses over time.
+        - **Identifying and resolving errors or limitations**: Human input can help identify and address any errors or limitations in the agent's capabilities, enabling continuous improvement and optimization.
+    </Accordion>
+
+    <Accordion title="What are the different types of memory that are available in crewAI?">
+        The different types of memory available in CrewAI are:
+        - `short-term memory`
+        - `long-term memory`
+        - `entity memory`
+        - `contextual memory`
+
+        Learn more about the different types of memory here:
+        <Card href="https://docs.crewai.com/concepts/memory" icon="brain">CrewAI Memory</Card>
+    </Accordion>
+
+    <Accordion title="How can I create custom tools for my CrewAI agents?">
+        You can create custom tools by subclassing the `BaseTool` class provided by CrewAI or by using the tool decorator. Subclassing involves defining a new class that inherits from `BaseTool`, specifying the name, description, and the `_run` method for operational logic. The tool decorator allows you to create a `Tool` object directly with the required attributes and a functional logic.
+        Click here for more details:
+        <Card href="https://docs.crewai.com/how-to/create-custom-tools" icon="code">CrewAI Tools</Card>
+    </Accordion>
+
+    <Accordion title="How do I use Output Pydantic in a Task?">
+        To use Output Pydantic in a task, you need to define the expected output of the task as a Pydantic model. Here's an example:
+        <Steps>
+            <Step title="Define a Pydantic model">
+                First, you need to define a Pydantic model. For instance, let's create a simple model for a user:
+
+                ```python
+                from pydantic import BaseModel
+
+                class User(BaseModel):
+                    name: str
+                    age: int
+                ```
+            </Step>
+
+            <Step title="Then, when creating a task, specify the expected output as this Pydantic model:">
+
+                ```python
+                from crewai import Task, Crew, Agent
+
+                # Import the User model
+                from my_models import User
+
+                # Create a task with Output Pydantic
+                task = Task(
+                    description="Create a user with the provided name and age",
+                    expected_output=User,  # This is the Pydantic model
+                    agent=agent,
+                    tools=[tool1, tool2]
+                )
+                ```
+            </Step>
+
+            <Step title="In your agent, make sure to set the output_pydantic attribute to the Pydantic model you're using:">
+
+                ```python
+                from crewai import Agent
+
+                # Import the User model
+                from my_models import User
+
+                # Create an agent with Output Pydantic
+                agent = Agent(
+                    role='User Creator',
+                    goal='Create users',
+                    backstory='I am skilled in creating user accounts',
+                    tools=[tool1, tool2],
+                    output_pydantic=User
+                )
+                ```
+            </Step>
+
+            <Step title="When executing the crew, the output of the task will be a User object:">
+
+                ```python
+                from crewai import Crew
+
+                # Create a crew with the agent and task
+                crew = Crew(agents=[agent], tasks=[task])
+
+                # Kick off the crew
+                result = crew.kickoff()
+
+                # The output of the task will be a User object
+                print(result.tasks[0].output)
+                ``` 
+            </Step>
+        </Steps>
+        Here's a tutorial on how to consistently get structured outputs from your agents:
+            <Frame>
+                <iframe 
+                height="400"
+                width="100%"
+                src="https://www.youtube.com/embed/dNpKQk5uxHw" 
+                title="YouTube video player" frameborder="0" 
+                allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" 
+                allowfullscreen></iframe>
+            </Frame>
+    </Accordion>
+</AccordionGroup>

docs/tools/codeinterpretertool.mdx

@@ -8,11 +8,29 @@ icon: code-simple
 
 ## Description
 
-The `CodeInterpreterTool` enables CrewAI agents to execute Python 3 code that they generate autonomously. The code is run in a secure, isolated Docker container, ensuring safety regardless of the content. This functionality is particularly valuable as it allows agents to create code, execute it, obtain the results, and utilize that information to inform subsequent decisions and actions.
+The `CodeInterpreterTool` enables CrewAI agents to execute Python 3 code that they generate autonomously. This functionality is particularly valuable as it allows agents to create code, execute it, obtain the results, and utilize that information to inform subsequent decisions and actions.
 
-## Requirements
+There are several ways to use this tool:
+
+### Docker Container (Recommended)
+
+This is the primary option. The code runs in a secure, isolated Docker container, ensuring safety regardless of its content.
+Make sure Docker is installed and running on your system. If you don’t have it, you can install it from [here](https://docs.docker.com/get-docker/).
+
+### Sandbox environment
+
+If Docker is unavailable — either not installed or not accessible for any reason — the code will be executed in a restricted Python environment - called sandbox.
+This environment is very limited, with strict restrictions on many modules and built-in functions.
+
+### Unsafe Execution
+
+**NOT RECOMMENDED FOR PRODUCTION** 
+This mode allows execution of any Python code, including dangerous calls to `sys, os..` and similar modules. [Check out](/tools/codeinterpretertool#enabling-unsafe-mode) how to enable this mode
+
+## Logging
+
+The `CodeInterpreterTool` logs the selected execution strategy to STDOUT
 
-- Docker must be installed and running on your system. If you don't have it, you can install it from [here](https://docs.docker.com/get-docker/).
 
 ## Installation
 
@@ -74,18 +92,32 @@ programmer_agent = Agent(
 )
 ```
 
+### Enabling `unsafe_mode`
+
+```python Code
+from crewai_tools import CodeInterpreterTool
+
+code = """
+import os
+os.system("ls -la")
+"""
+
+CodeInterpreterTool(unsafe_mode=True).run(code=code)
+```
+
 ## Parameters
 
 The `CodeInterpreterTool` accepts the following parameters during initialization:
 
 - **user_dockerfile_path**: Optional. Path to a custom Dockerfile to use for the code interpreter container.
 - **user_docker_base_url**: Optional. URL to the Docker daemon to use for running the container.
-- **unsafe_mode**: Optional. Whether to run code directly on the host machine instead of in a Docker container. Default is `False`. Use with caution!
+- **unsafe_mode**: Optional. Whether to run code directly on the host machine instead of in a Docker container or sandbox. Default is `False`. Use with caution!
+- **default_image_tag**: Optional. Default Docker image tag. Default is `code-interpreter:latest`
 
 When using the tool with an agent, the agent will need to provide:
 
 - **code**: Required. The Python 3 code to execute.
-- **libraries_used**: Required. A list of libraries used in the code that need to be installed.
+- **libraries_used**: Optional. A list of libraries used in the code that need to be installed. Default is `[]`
 
 ## Agent Integration Example
 
@@ -152,7 +184,7 @@ class CodeInterpreterTool(BaseTool):
         if self.unsafe_mode:
             return self.run_code_unsafe(code, libraries_used)
         else:
-            return self.run_code_in_docker(code, libraries_used)
+            return self.run_code_safety(code, libraries_used)
 ```
 
 The tool performs the following steps:
@@ -168,8 +200,9 @@ The tool performs the following steps:
 By default, the `CodeInterpreterTool` runs code in an isolated Docker container, which provides a layer of security. However, there are still some security considerations to keep in mind:
 
 1. The Docker container has access to the current working directory, so sensitive files could potentially be accessed.
-2. The `unsafe_mode` parameter allows code to be executed directly on the host machine, which should only be used in trusted environments.
-3. Be cautious when allowing agents to install arbitrary libraries, as they could potentially include malicious code.
+2. If the Docker container is unavailable and the code needs to run safely, it will be executed in a sandbox environment. For security reasons, installing arbitrary libraries is not allowed
+3. The `unsafe_mode` parameter allows code to be executed directly on the host machine, which should only be used in trusted environments.
+4. Be cautious when allowing agents to install arbitrary libraries, as they could potentially include malicious code.
 
 ## Conclusion
 

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crewai"
-version = "0.114.0"
+version = "0.117.1"
 description = "Cutting-edge framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks."
 readme = "README.md"
 requires-python = ">=3.10,<3.13"
@@ -11,7 +11,7 @@ dependencies = [
     # Core Dependencies
     "pydantic>=2.4.2",
     "openai>=1.13.3",
-    "litellm==1.60.2",
+    "litellm==1.67.1",
     "instructor>=1.3.3",
     # Text Processing
     "pdfplumber>=0.11.4",
@@ -45,7 +45,7 @@ Documentation = "https://docs.crewai.com"
 Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
-tools = ["crewai-tools~=0.40.1"]
+tools = ["crewai-tools~=0.42.2"]
 embeddings = [
     "tiktoken~=0.7.0"
 ]
@@ -60,7 +60,7 @@ pandas = [
 openpyxl = [
     "openpyxl>=3.1.5",
 ]
-mem0 = ["mem0ai>=0.1.29"]
+mem0 = ["mem0ai>=0.1.94"]
 docling = [
     "docling>=2.12.0",
 ]

src/crewai/__init__.py

@@ -17,7 +17,7 @@ warnings.filterwarnings(
     category=UserWarning,
     module="pydantic.main",
 )
-__version__ = "0.114.0"
+__version__ = "0.117.1"
 __all__ = [
     "Agent",
     "Crew",

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

@@ -0,0 +1 @@
+"""LangGraph adapter for crewAI."""

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

@@ -0,0 +1 @@
+"""OpenAI agent adapters for crewAI."""

src/crewai/cli/constants.py

@@ -122,7 +122,16 @@ PROVIDERS = [
 ]
 
 MODELS = {
-    "openai": ["gpt-4", "gpt-4o", "gpt-4o-mini", "o1-mini", "o1-preview"],
+    "openai": [
+        "gpt-4",
+        "gpt-4.1",
+        "gpt-4.1-mini-2025-04-14",
+        "gpt-4.1-nano-2025-04-14",
+        "gpt-4o",
+        "gpt-4o-mini",
+        "o1-mini",
+        "o1-preview",
+    ],
     "anthropic": [
         "claude-3-5-sonnet-20240620",
         "claude-3-sonnet-20240229",
@@ -132,8 +141,17 @@ MODELS = {
     "gemini": [
         "gemini/gemini-1.5-flash",
         "gemini/gemini-1.5-pro",
+        "gemini/gemini-2.0-flash-lite-001",
+        "gemini/gemini-2.0-flash-001",
+        "gemini/gemini-2.0-flash-thinking-exp-01-21",
+        "gemini/gemini-2.5-flash-preview-04-17",
+        "gemini/gemini-2.5-pro-exp-03-25",
         "gemini/gemini-gemma-2-9b-it",
         "gemini/gemini-gemma-2-27b-it",
+        "gemini/gemma-3-1b-it",
+        "gemini/gemma-3-4b-it",
+        "gemini/gemma-3-12b-it",
+        "gemini/gemma-3-27b-it",
     ],
     "nvidia_nim": [
         "nvidia_nim/nvidia/mistral-nemo-minitron-8b-8k-instruct",

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.13"
 dependencies = [
-    "crewai[tools]>=0.114.0,<1.0.0"
+    "crewai[tools]>=0.117.1,<1.0.0"
 ]
 
 [project.scripts]

src/crewai/cli/templates/flow/crews/poem_crew/__init__.py

@@ -0,0 +1 @@
+"""Poem crew template."""

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.13"
 dependencies = [
-    "crewai[tools]>=0.114.0,<1.0.0",
+    "crewai[tools]>=0.117.1,<1.0.0",
 ]
 
 [project.scripts]

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

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

src/crewai/knowledge/utils/__init__.py

@@ -0,0 +1 @@
+"""Knowledge utilities for crewAI."""

src/crewai/llm.py

@@ -37,6 +37,7 @@ with warnings.catch_warnings():
     warnings.simplefilter("ignore", UserWarning)
     import litellm
     from litellm import Choices
+    from litellm.exceptions import ContextWindowExceededError
     from litellm.litellm_core_utils.get_supported_openai_params import (
         get_supported_openai_params,
     )
@@ -64,7 +65,7 @@ class FilteredStream:
             if (
                 "Give Feedback / Get Help: https://github.com/BerriAI/litellm/issues/new"
                 in s
-                or "LiteLLM.Info: If you need to debug this error, use `litellm.set_verbose=True`"
+                or "LiteLLM.Info: If you need to debug this error, use `litellm._turn_on_debug()`"
                 in s
             ):
                 return 0
@@ -81,14 +82,26 @@ LLM_CONTEXT_WINDOW_SIZES = {
     "gpt-4o": 128000,
     "gpt-4o-mini": 128000,
     "gpt-4-turbo": 128000,
+    "gpt-4.1": 1047576,  # Based on official docs
+    "gpt-4.1-mini-2025-04-14": 1047576,
+    "gpt-4.1-nano-2025-04-14": 1047576,
     "o1-preview": 128000,
     "o1-mini": 128000,
     "o3-mini": 200000,  # Based on official o3-mini specifications
     # gemini
     "gemini-2.0-flash": 1048576,
+    "gemini-2.0-flash-thinking-exp-01-21": 32768,
+    "gemini-2.0-flash-lite-001": 1048576,
+    "gemini-2.0-flash-001": 1048576,
+    "gemini-2.5-flash-preview-04-17": 1048576,
+    "gemini-2.5-pro-exp-03-25": 1048576,
     "gemini-1.5-pro": 2097152,
     "gemini-1.5-flash": 1048576,
     "gemini-1.5-flash-8b": 1048576,
+    "gemini/gemma-3-1b-it": 32000,
+    "gemini/gemma-3-4b-it": 128000,
+    "gemini/gemma-3-12b-it": 128000,
+    "gemini/gemma-3-27b-it": 128000,
     # deepseek
     "deepseek-chat": 128000,
     # groq
@@ -470,6 +483,7 @@ class LLM(BaseLLM):
                     full_response += chunk_content
 
                     # Emit the chunk event
+                    assert hasattr(crewai_event_bus, "emit")
                     crewai_event_bus.emit(
                         self,
                         event=LLMStreamChunkEvent(chunk=chunk_content),
@@ -585,6 +599,11 @@ class LLM(BaseLLM):
             self._handle_emit_call_events(full_response, LLMCallType.LLM_CALL)
             return full_response
 
+        except ContextWindowExceededError as e:
+            # Catch context window errors from litellm and convert them to our own exception type.
+            # This exception is handled by CrewAgentExecutor._invoke_loop() which can then
+            # decide whether to summarize the content or abort based on the respect_context_window flag.
+            raise LLMContextLengthExceededException(str(e))
         except Exception as e:
             logging.error(f"Error in streaming response: {str(e)}")
             if full_response.strip():
@@ -593,6 +612,7 @@ class LLM(BaseLLM):
                 return full_response
 
             # Emit failed event and re-raise the exception
+            assert hasattr(crewai_event_bus, "emit")
             crewai_event_bus.emit(
                 self,
                 event=LLMCallFailedEvent(error=str(e)),
@@ -615,7 +635,7 @@ class LLM(BaseLLM):
                 current_tool_accumulator.function.arguments += (
                     tool_call.function.arguments
                 )
-
+            assert hasattr(crewai_event_bus, "emit")
             crewai_event_bus.emit(
                 self,
                 event=LLMStreamChunkEvent(
@@ -699,7 +719,16 @@ class LLM(BaseLLM):
             str: The response text
         """
         # --- 1) Make the completion call
-        response = litellm.completion(**params)
+        try:
+            # Attempt to make the completion call, but catch context window errors
+            # and convert them to our own exception type for consistent handling
+            # across the codebase. This allows CrewAgentExecutor to handle context
+            # length issues appropriately.
+            response = litellm.completion(**params)
+        except ContextWindowExceededError as e:
+            # Convert litellm's context window error to our own exception type
+            # for consistent handling in the rest of the codebase
+            raise LLMContextLengthExceededException(str(e))
 
         # --- 2) Extract response message and content
         response_message = cast(Choices, cast(ModelResponse, response).choices)[
@@ -779,6 +808,7 @@ class LLM(BaseLLM):
                     function_name, lambda: None
                 )  # Ensure fn is always a callable
                 logging.error(f"Error executing function '{function_name}': {e}")
+                assert hasattr(crewai_event_bus, "emit")
                 crewai_event_bus.emit(
                     self,
                     event=LLMCallFailedEvent(error=f"Tool execution error: {str(e)}"),
@@ -816,6 +846,7 @@ class LLM(BaseLLM):
             LLMContextLengthExceededException: If input exceeds model's context limit
         """
         # --- 1) Emit call started event
+        assert hasattr(crewai_event_bus, "emit")
         crewai_event_bus.emit(
             self,
             event=LLMCallStartedEvent(
@@ -858,15 +889,18 @@ class LLM(BaseLLM):
                         params, callbacks, available_functions
                     )
 
+            except LLMContextLengthExceededException:
+                # Re-raise LLMContextLengthExceededException as it should be handled
+                # by the CrewAgentExecutor._invoke_loop method, which can then decide
+                # whether to summarize the content or abort based on the respect_context_window flag
+                raise
             except Exception as e:
+                assert hasattr(crewai_event_bus, "emit")
                 crewai_event_bus.emit(
                     self,
                     event=LLMCallFailedEvent(error=str(e)),
                 )
-                if not LLMContextLengthExceededException(
-                    str(e)
-                )._is_context_limit_error(str(e)):
-                    logging.error(f"LiteLLM call failed: {str(e)}")
+                logging.error(f"LiteLLM call failed: {str(e)}")
                 raise
 
     def _handle_emit_call_events(self, response: Any, call_type: LLMCallType):
@@ -876,6 +910,7 @@ class LLM(BaseLLM):
             response (str): The response from the LLM call.
             call_type (str): The type of call, either "tool_call" or "llm_call".
         """
+        assert hasattr(crewai_event_bus, "emit")
         crewai_event_bus.emit(
             self,
             event=LLMCallCompletedEvent(response=response, call_type=call_type),

src/crewai/llms/__init__.py

@@ -0,0 +1 @@
+"""LLM implementations for crewAI."""

src/crewai/llms/third_party/__init__.py

@@ -0,0 +1 @@
+"""Third-party LLM implementations for crewAI."""

src/crewai/memory/storage/__init__.py

@@ -0,0 +1 @@
+"""Memory storage implementations for crewAI."""

src/crewai/memory/storage/mem0_storage.py

@@ -88,7 +88,9 @@ class Mem0Storage(Storage):
             }
 
         if params:
-            self.memory.add(value, **params | {"output_format": "v1.1"})
+            if isinstance(self.memory, MemoryClient):
+                params["output_format"] = "v1.1"
+            self.memory.add(value, **params)
 
     def search(
         self,
@@ -96,7 +98,7 @@ class Mem0Storage(Storage):
         limit: int = 3,
         score_threshold: float = 0.35,
     ) -> List[Any]:
-        params = {"query": query, "limit": limit}
+        params = {"query": query, "limit": limit, "output_format": "v1.1"}
         if user_id := self._get_user_id():
             params["user_id"] = user_id
 
@@ -116,8 +118,11 @@ class Mem0Storage(Storage):
 
         # Discard the filters for now since we create the filters
         # automatically when the crew is created.
+        if isinstance(self.memory, Memory):
+            del params["metadata"], params["output_format"]
+            
         results = self.memory.search(**params)
-        return [r for r in results if r["score"] >= score_threshold]
+        return [r for r in results["results"] if r["score"] >= score_threshold]
 
     def _get_user_id(self) -> str:
         return self._get_config().get("user_id", "")

src/crewai/project/crew_base.py

@@ -8,8 +8,6 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-logging.basicConfig(level=logging.WARNING)
-
 T = TypeVar("T", bound=type)
 
 """Base decorator for creating crew classes with configuration and function management."""
@@ -248,6 +246,9 @@ def CrewBase(cls: T) -> T:
                     callback_functions[callback]() for callback in callbacks
                 ]
 
+            if guardrail := task_info.get("guardrail"):
+                self.tasks_config[task_name]["guardrail"] = guardrail
+
     # Include base class (qual)name in the wrapper class (qual)name.
     WrappedClass.__name__ = CrewBase.__name__ + "(" + cls.__name__ + ")"
     WrappedClass.__qualname__ = CrewBase.__qualname__ + "(" + cls.__name__ + ")"

src/crewai/task.py

@@ -140,9 +140,9 @@ class Task(BaseModel):
         default=None,
     )
     processed_by_agents: Set[str] = Field(default_factory=set)
-    guardrail: Optional[Callable[[TaskOutput], Tuple[bool, Any]]] = Field(
+    guardrail: Optional[Union[Callable[[TaskOutput], Tuple[bool, Any]], str]] = Field(
         default=None,
-        description="Function to validate task output before proceeding to next task",
+        description="Function or string description of a guardrail to validate task output before proceeding to next task",
     )
     max_retries: int = Field(
         default=3, description="Maximum number of retries when guardrail fails"
@@ -157,8 +157,12 @@ class Task(BaseModel):
 
     @field_validator("guardrail")
     @classmethod
-    def validate_guardrail_function(cls, v: Optional[Callable]) -> Optional[Callable]:
-        """Validate that the guardrail function has the correct signature and behavior.
+    def validate_guardrail_function(
+        cls, v: Optional[str | Callable]
+    ) -> Optional[str | Callable]:
+        """
+        If v is a callable, validate that the guardrail function has the correct signature and behavior.
+        If v is a string, return it as is.
 
         While type hints provide static checking, this validator ensures runtime safety by:
         1. Verifying the function accepts exactly one parameter (the TaskOutput)
@@ -171,16 +175,16 @@ class Task(BaseModel):
         - Clear error messages help users debug guardrail implementation issues
 
         Args:
-            v: The guardrail function to validate
+            v: The guardrail function to validate or a string describing the guardrail task
 
         Returns:
-            The validated guardrail function
+            The validated guardrail function or a string describing the guardrail task
 
         Raises:
             ValueError: If the function signature is invalid or return annotation
                        doesn't match Tuple[bool, Any]
         """
-        if v is not None:
+        if v is not None and callable(v):
             sig = inspect.signature(v)
             positional_args = [
                 param
@@ -211,6 +215,7 @@ class Task(BaseModel):
                     )
         return v
 
+    _guardrail: Optional[Callable] = PrivateAttr(default=None)
     _original_description: Optional[str] = PrivateAttr(default=None)
     _original_expected_output: Optional[str] = PrivateAttr(default=None)
     _original_output_file: Optional[str] = PrivateAttr(default=None)
@@ -231,6 +236,20 @@ class Task(BaseModel):
                 )
         return self
 
+    @model_validator(mode="after")
+    def ensure_guardrail_is_callable(self) -> "Task":
+        if callable(self.guardrail):
+            self._guardrail = self.guardrail
+        elif isinstance(self.guardrail, str):
+            from crewai.tasks.task_guardrail import TaskGuardrail
+
+            assert self.agent is not None
+            self._guardrail = TaskGuardrail(
+                description=self.guardrail, llm=self.agent.llm
+            )
+
+        return self
+
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -407,10 +426,8 @@ class Task(BaseModel):
                 output_format=self._get_output_format(),
             )
 
-            if self.guardrail:
-                guardrail_result = GuardrailResult.from_tuple(
-                    self.guardrail(task_output)
-                )
+            if self._guardrail:
+                guardrail_result = self._process_guardrail(task_output)
                 if not guardrail_result.success:
                     if self.retry_count >= self.max_retries:
                         raise Exception(
@@ -464,13 +481,46 @@ class Task(BaseModel):
                     )
                 )
                 self._save_file(content)
-            crewai_event_bus.emit(self, TaskCompletedEvent(output=task_output, task=self))
+            crewai_event_bus.emit(
+                self, TaskCompletedEvent(output=task_output, task=self)
+            )
             return task_output
         except Exception as e:
             self.end_time = datetime.datetime.now()
             crewai_event_bus.emit(self, TaskFailedEvent(error=str(e), task=self))
             raise e  # Re-raise the exception after emitting the event
 
+    def _process_guardrail(self, task_output: TaskOutput) -> GuardrailResult:
+        assert self._guardrail is not None
+
+        from crewai.utilities.events import (
+            TaskGuardrailCompletedEvent,
+            TaskGuardrailStartedEvent,
+        )
+        from crewai.utilities.events.crewai_event_bus import crewai_event_bus
+
+        result = self._guardrail(task_output)
+
+        crewai_event_bus.emit(
+            self,
+            TaskGuardrailStartedEvent(
+                guardrail=self._guardrail, retry_count=self.retry_count
+            ),
+        )
+
+        guardrail_result = GuardrailResult.from_tuple(result)
+
+        crewai_event_bus.emit(
+            self,
+            TaskGuardrailCompletedEvent(
+                success=guardrail_result.success,
+                result=guardrail_result.result,
+                error=guardrail_result.error,
+                retry_count=self.retry_count,
+            ),
+        )
+        return guardrail_result
+
     def prompt(self) -> str:
         """Prompt the task.
 

src/crewai/tasks/task_guardrail.py

@@ -0,0 +1,92 @@
+from typing import Any, Optional, Tuple
+
+from pydantic import BaseModel, Field
+
+from crewai.agent import Agent, LiteAgentOutput
+from crewai.llm import LLM
+from crewai.task import Task
+from crewai.tasks.task_output import TaskOutput
+
+
+class TaskGuardrailResult(BaseModel):
+    valid: bool = Field(
+        description="Whether the task output complies with the guardrail"
+    )
+    feedback: str | None = Field(
+        description="A feedback about the task output if it is not valid",
+        default=None,
+    )
+
+
+class TaskGuardrail:
+    """It validates the output of another task using an LLM.
+
+    This class is used to validate the output from a Task based on specified criteria.
+    It uses an LLM to validate the output and provides a feedback if the output is not valid.
+
+    Args:
+        description (str): The description of the validation criteria.
+        llm (LLM, optional): The language model to use for code generation.
+    """
+
+    def __init__(
+        self,
+        description: str,
+        llm: LLM,
+    ):
+        self.description = description
+
+        self.llm: LLM = llm
+
+    def _validate_output(self, task_output: TaskOutput) -> LiteAgentOutput:
+        agent = Agent(
+            role="Guardrail Agent",
+            goal="Validate the output of the task",
+            backstory="You are a expert at validating the output of a task. By providing effective feedback if the output is not valid.",
+            llm=self.llm,
+        )
+
+        query = f"""
+        Ensure the following task result complies with the given guardrail.
+
+        Task result:
+        {task_output.raw}
+
+        Guardrail:
+        {self.description}
+        
+        Your task:
+        - Confirm if the Task result complies with the guardrail.
+        - If not, provide clear feedback explaining what is wrong (e.g., by how much it violates the rule, or what specific part fails).
+        - Focus only on identifying issues — do not propose corrections.
+        - If the Task result complies with the guardrail, saying that is valid
+        """
+
+        result = agent.kickoff(query, response_format=TaskGuardrailResult)
+
+        return result
+
+    def __call__(self, task_output: TaskOutput) -> Tuple[bool, Any]:
+        """Validates the output of a task based on specified criteria.
+
+        Args:
+            task_output (TaskOutput): The output to be validated.
+
+        Returns:
+            Tuple[bool, Any]: A tuple containing:
+                - bool: True if validation passed, False otherwise
+                - Any: The validation result or error message
+        """
+
+        try:
+            result = self._validate_output(task_output)
+            assert isinstance(
+                result.pydantic, TaskGuardrailResult
+            ), "The guardrail result is not a valid pydantic model"
+
+            if result.pydantic.valid:
+                return True, task_output.raw
+            else:
+                return False, result.pydantic.feedback
+        except Exception as e:
+            return False, f"Error while validating the task output: {str(e)}"

src/crewai/tools/agent_tools/__init__.py

@@ -0,0 +1 @@
+"""Agent tools for crewAI."""

src/crewai/utilities/evaluators/__init__.py

@@ -0,0 +1 @@
+"""Evaluators for crewAI."""

src/crewai/utilities/events/__init__.py

@@ -9,6 +9,10 @@ from .crew_events import (
     CrewTestCompletedEvent,
     CrewTestFailedEvent,
 )
+from .task_guardrail_events import (
+    TaskGuardrailCompletedEvent,
+    TaskGuardrailStartedEvent,
+)
 from .agent_events import (
     AgentExecutionStartedEvent,
     AgentExecutionCompletedEvent,

src/crewai/utilities/events/event_types.py

@@ -34,6 +34,10 @@ from .task_events import (
     TaskFailedEvent,
     TaskStartedEvent,
 )
+from .task_guardrail_events import (
+    TaskGuardrailCompletedEvent,
+    TaskGuardrailStartedEvent,
+)
 from .tool_usage_events import (
     ToolUsageErrorEvent,
     ToolUsageFinishedEvent,
@@ -68,4 +72,6 @@ EventTypes = Union[
     LLMCallCompletedEvent,
     LLMCallFailedEvent,
     LLMStreamChunkEvent,
+    TaskGuardrailStartedEvent,
+    TaskGuardrailCompletedEvent,
 ]

src/crewai/utilities/events/task_guardrail_events.py

@@ -0,0 +1,38 @@
+from typing import Any, Callable, Optional, Union
+
+from crewai.utilities.events.base_events import BaseEvent
+
+
+class TaskGuardrailStartedEvent(BaseEvent):
+    """Event emitted when a guardrail task starts
+
+    Attributes:
+        guardrail: The guardrail callable or TaskGuardrail instance
+        retry_count: The number of times the guardrail has been retried
+    """
+
+    type: str = "task_guardrail_started"
+    guardrail: Union[str, Callable]
+    retry_count: int
+
+    def __init__(self, **data):
+        from inspect import getsource
+
+        from crewai.tasks.task_guardrail import TaskGuardrail
+
+        super().__init__(**data)
+
+        if isinstance(self.guardrail, TaskGuardrail):
+            self.guardrail = self.guardrail.description.strip()
+        elif isinstance(self.guardrail, Callable):
+            self.guardrail = getsource(self.guardrail).strip()
+
+
+class TaskGuardrailCompletedEvent(BaseEvent):
+    """Event emitted when a guardrail task completes"""
+
+    type: str = "task_guardrail_completed"
+    success: bool
+    result: Any
+    error: Optional[str] = None
+    retry_count: int

src/crewai/utilities/events/utils/__init__.py

@@ -0,0 +1 @@
+"""Event utilities for crewAI."""

src/crewai/utilities/exceptions/__init__.py

@@ -0,0 +1 @@
+"""Exceptions for crewAI."""

src/crewai/utilities/prompts.py

@@ -54,10 +54,12 @@ class Prompts(BaseModel):
         response_template=None,
     ) -> str:
         """Constructs a prompt string from specified components."""
-        if not system_template and not prompt_template:
+        if not system_template or not prompt_template:
+            # If any of the required templates are missing, fall back to the default format
             prompt_parts = [self.i18n.slice(component) for component in components]
             prompt = "".join(prompt_parts)
         else:
+            # All templates are provided, use them
             prompt_parts = [
                 self.i18n.slice(component)
                 for component in components
@@ -67,8 +69,12 @@ class Prompts(BaseModel):
             prompt = prompt_template.replace(
                 "{{ .Prompt }}", "".join(self.i18n.slice("task"))
             )
-            response = response_template.split("{{ .Response }}")[0]
-            prompt = f"{system}\n{prompt}\n{response}"
+            # Handle missing response_template
+            if response_template:
+                response = response_template.split("{{ .Response }}")[0]
+                prompt = f"{system}\n{prompt}\n{response}"
+            else:
+                prompt = f"{system}\n{prompt}"
 
         prompt = (
             prompt.replace("{goal}", self.agent.goal)

tests/agent_test.py

@@ -72,9 +72,54 @@ def test_agent_creation():
     assert agent.role == "test role"
     assert agent.goal == "test goal"
     assert agent.backstory == "test backstory"
-    assert agent.tools == []
+
+def test_agent_with_only_system_template():
+    """Test that an agent with only system_template works without errors."""
+    agent = Agent(
+        role="Test Role",
+        goal="Test Goal",
+        backstory="Test Backstory",
+        allow_delegation=False,
+        system_template="You are a test agent...",
+        # prompt_template is intentionally missing
+    )
+
+    assert agent.role == "Test Role"
+    assert agent.goal == "Test Goal"
+    assert agent.backstory == "Test Backstory"
+
+def test_agent_with_only_prompt_template():
+    """Test that an agent with only system_template works without errors."""
+    agent = Agent(
+        role="Test Role",
+        goal="Test Goal",
+        backstory="Test Backstory",
+        allow_delegation=False,
+        prompt_template="You are a test agent...",
+        # prompt_template is intentionally missing
+    )
+
+    assert agent.role == "Test Role"
+    assert agent.goal == "Test Goal"
+    assert agent.backstory == "Test Backstory"
 
 
+def test_agent_with_missing_response_template():
+    """Test that an agent with system_template and prompt_template but no response_template works without errors."""
+    agent = Agent(
+        role="Test Role",
+        goal="Test Goal",
+        backstory="Test Backstory",
+        allow_delegation=False,
+        system_template="You are a test agent...",
+        prompt_template="This is a test prompt...",
+        # response_template is intentionally missing
+    )
+
+    assert agent.role == "Test Role"
+    assert agent.goal == "Test Goal"
+    assert agent.backstory == "Test Backstory"
+    
 def test_agent_default_values():
     agent = Agent(role="test role", goal="test goal", backstory="test backstory")
     assert agent.llm.model == "gpt-4o-mini"

tests/agents/agent_adapters/__init__.py

@@ -0,0 +1 @@
+"""Tests for agent adapters."""

tests/agents/agent_builder/__init__.py

@@ -0,0 +1 @@
+"""Tests for agent builder."""

tests/cassettes/test_gemini_models[gemini-gemini-2.0-flash-001].yaml

@@ -0,0 +1,59 @@
+interactions:
+- request:
+    body: '{"contents": [{"role": "user", "parts": [{"text": "What is the capital
+      of France?"}]}], "generationConfig": {"stop_sequences": []}}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '131'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      user-agent:
+      - litellm/1.60.2
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-001:generateContent
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAC/62RTU+EMBCG7/0VTY9kIQUT1vXqx0njRokxUQ8jDNAILaFdoyH8dwssbNGrTdo0
+        807nnT7TEUpZCjITGRjU7IK+2Ail3XgOmpIGpbHCHLLBBlpzyp1W59xtisGv4RFLSqQpNMJARVVO
+        b1qQKVKhqeftoRXa84JXyZy3/XJ/25wcW1XhUK5WGVZzej8nsFxIocsHBK3kkPaY3O/ZosJncauK
+        plXvQ9M+D3gUxiE/tzs6i+JtyHdkth5N2UFDgXdowFKB5e/Mlqgbk6gPlJfqMFLZTi4Ow5W8O8pG
+        WQArJYw3f4rqK2spKhetQ93+HSphvkes188Jc/iYVU8zH+Jg/N3hP3nt1l7kOJVpUE/YajFNpMDa
+        zsiPAu7nFejS5zxkpCc/6so6tIECAAA=
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 22 Apr 2025 14:25:05 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=1219
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gemini_models[gemini-gemini-2.0-flash-lite-001].yaml

@@ -0,0 +1,59 @@
+interactions:
+- request:
+    body: '{"contents": [{"role": "user", "parts": [{"text": "What is the capital
+      of France?"}]}], "generationConfig": {"stop_sequences": []}}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '131'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      user-agent:
+      - litellm/1.60.2
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-lite-001:generateContent
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAC/61RTU+EMBC98yuanhdSiMjq1Y+Txo0SY6J7GGGARmhJ2zUawn+3wMIWvdpDM5n3
+        Zt7Mm84jhGYgcp6DQU0vyavNENKN/4BJYVAYC8wpm2xBmRN3ep0TW4rBr6GIphWSDFpuoCayILcK
+        RIaEa7IDxXXwJqhT1y/xfnNSU7LGoVUjc6xnej8TaMEF19UjgpZioD2lDzu6oPBZ3smyVfJ9GNhn
+        AQuTMIpjFl/EZyxKwuTcm6VHUXrQUOI9GrCOwLI3tS2a1qTyA8WVPIyOJJOK498K3h5hI+3yKySM
+        N3+a6msryWvXVsdxuzvU3HyPlt68pNTxx6xmmv3xHBt/T/hPWtu1lne8ynSoZ1SaTxcpsbE38qOA
+        +UUNuvJtd/QZC6nXez+t5iqFggIAAA==
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 22 Apr 2025 14:25:06 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=1090
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gemini_models[gemini-gemini-2.0-flash-thinking-exp-01-21].yaml

@@ -0,0 +1,58 @@
+interactions:
+- request:
+    body: '{"contents": [{"role": "user", "parts": [{"text": "What is the capital
+      of France?"}]}], "generationConfig": {"stop_sequences": []}}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '131'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      user-agent:
+      - litellm/1.60.2
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-thinking-exp-01-21:generateContent
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAC/22QQWuEMBCF7/6KkKNsFt1DKb2221vp0koplD0M66jDxkSSWbCI/71Rq+vS5pCE
+        eW9meF8XCSFPYHLKgdHLB/EVKkJ04z1o1jAaDsJcCsUGHF+90+lW/2BhbIcmmVUoTtAQgxa2EM8O
+        zAkFeRHHB3Dk43grV5398j9urvuc1TgMq22Oerb3s0EWZMhXbwjemsH2nr0e5KKSybEN5SSaF4yj
+        5cVDiS/IEJLDkk82ztYNZ/aM5tFexuT306wVp39ltiHkjZLebf4M9U9hJek1vhXZkBA08feIbv+Z
+        yRUFvlk6UxjfY/TLY0L0gc7TxKLEOtBRu22iCg2+UlyROZMpFbaNSlK1S2XURz/Fy1P+CAIAAA==
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 22 Apr 2025 14:25:04 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=764
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gemini_models[gemini-gemini-2.5-flash-preview-04-17].yaml

@@ -0,0 +1,59 @@
+interactions:
+- request:
+    body: '{"contents": [{"role": "user", "parts": [{"text": "What is the capital
+      of France?"}]}], "generationConfig": {"stop_sequences": []}}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '131'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      user-agent:
+      - litellm/1.60.2
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-04-17:generateContent
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAC/2WQT0+EMBDF7/0UTY9k2ewaDerVPzfjRokxMR4mMEBjaUk76BrCd7fAslvcHppm
+        5s2bvl/HOBcZ6FzmQOjELf/wFc678R56RhNq8o255IsNWDppp9MFby8h3A9DIq2QZ9BIAsVNwR8t
+        6Ay5dDyKdmCli6K1CCb74/tzddpnjcLBrDY5qlnezwJRSC1d9YLgjB5kr+nzThy7Uue49+UNmxeM
+        1qJ1UOITEvjkcMwnGmvqhlLzhfrOtGPy68kr4LRoJzeHPhmfcjmZrM5c3b3fKVXIL0DrI4KS9Duy
+        e3hPRYCBFtYzBhbQElSZtqzo3we37IBrIviG1skJVYm1hxdfrK/iQoGr4sbit8SfeHMZbxPBevYH
+        O2bXiSICAAA=
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 22 Apr 2025 14:25:28 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=20971
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gemini_models[gemini-gemini-2.5-pro-exp-03-25].yaml

@@ -0,0 +1,59 @@
+interactions:
+- request:
+    body: '{"contents": [{"role": "user", "parts": [{"text": "What is the capital
+      of France?"}]}], "generationConfig": {"stop_sequences": []}}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '131'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      user-agent:
+      - litellm/1.60.2
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-pro-exp-03-25:generateContent
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAC/12QT2uEMBDF7/kUIUepi2tZaHttu7fSpZVSKD0MOquhmkgygkX87o26cWM9SJj3
+        5s/7DYxzkYMqZAGEVjzwL1fhfJj/k6YVoSIn+JIrtmDo6l2+IXg7C2E/NYmsQp5DKwlqrs/8aEDl
+        yKXlUXQCI20U7UTQOa7v75vrPqNrnIY1usDa20dvEGeppK3eEKxWk+09ez2JVZWqwN6VE+YXzKNF
+        Z6HEFyRwyWHNJ1qjm5Yy/YPqUXdz8rtlVsBpI++T5GIg7WL+03xzMNc+ua2yDgkGcF1IqCX9zvSe
+        PzMRgKDNWR4EC3gJqnRXVrQ98T5lF2ALww80Vi6wSmwcvjjdHWJ3Yox9Gye3cXoQbGR/TedYqx4C
+        AAA=
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 22 Apr 2025 14:25:30 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=2418
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gemma3[gemini-gemma-3-12b-it].yaml

@@ -0,0 +1,59 @@
+interactions:
+- request:
+    body: '{"contents": [{"role": "user", "parts": [{"text": "What is the capital
+      of France?"}]}], "generationConfig": {"stop_sequences": []}}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '131'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      user-agent:
+      - litellm/1.60.2
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemma-3-12b-it:generateContent
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAC/2WRTWvDMAyG7/kVwpdBSEvX7jB23QfsMFa2MAZbD2qipGaOFWwFWkr/+5ykaVPq
+        gGP0SvLrR/sIQGVoc52jkFcP8BMiAPtubzW2QlaCMIRCsEYn59x+7UfnkCK0bYtUuiHIsNaCBriA
+        F4c2I9Ae4niJTvs4nv7a/nuVGw9oPIOEIoOuJC+QadmBtkNlsAoIpeF1aJgFZ+SgYAfBUQIF+o1m
+        m0CJXhxbrnZJV5E1RhpHUzUyeTidV8n5aY4Ntb4rzskM6YchQRXaar/5IPRs27TP9H2pTqq2OW1D
+        eBYNF3StVeOxpDcSDJDxhFLVjqtaUv4j+8hNB/m+7zUayYW8mB914QD0QrqbJVdd/VO4U5vxqEZT
+        DE9EE+h2Y3r+TtUIg1yYGjB0/1V0BNIz+iLndQ+jpKrCyWJyO19PtKjoEP0DlZtdIF8CAAA=
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 22 Apr 2025 14:25:39 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=3835
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gemma3[gemini-gemma-3-1b-it].yaml

@@ -0,0 +1,60 @@
+interactions:
+- request:
+    body: '{"contents": [{"role": "user", "parts": [{"text": "What is the capital
+      of France?"}]}], "generationConfig": {"stop_sequences": []}}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '131'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      user-agent:
+      - litellm/1.60.2
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemma-3-1b-it:generateContent
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAC/2VRy07DQAy85yusPUZtBSoIxJWHxAFRQYSQKAc3cVqL7DrKuqKlqsRv8Ht8CZuk
+        aVOxh314xuP1eBMBmBRdxhkqeXMFbyECsGn2GhOn5DQAXSgES6z0wG3XpncPFKVVnWSSBUGKJSsW
+        IDncVehSAvYQxxOs2MfxCKZu6u719/vHA0Iq1ooDyz6UTqlUDi9doELDr1M1aMbiinXcSQ9gtlTg
+        VqOGJc855VAztAZWvMInZ1SsoaJU5o6/KANxNDK9X2/39/fBoddKCqobsRLyO/q2I5icHfvFE6EX
+        V9Oek8eJ2aPsMlqF8EnUFWikzdLjnB5IMbiOe29NWYktNZEPcteybFy/bLV6MzqCxxc7XCXYcASd
+        nQ/+qfqbUJOL/ux6Yw0tYsG6buZ2+5qYng169KnOhuZ8j3aGtB69UOW5NWNO1uJwPDydDVlNtI3+
+        AD6XWQdvAgAA
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 22 Apr 2025 14:25:32 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=1535
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gemma3[gemini-gemma-3-27b-it].yaml

@@ -0,0 +1,60 @@
+interactions:
+- request:
+    body: '{"contents": [{"role": "user", "parts": [{"text": "What is the capital
+      of France?"}]}], "generationConfig": {"stop_sequences": []}}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '131'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      user-agent:
+      - litellm/1.60.2
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemma-3-27b-it:generateContent
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAC/2VRXUvDMBR976+45EUo3RDnUHwTnSA4HFpEcHuI7e16aZqU5NZNxv67abtuHTbQ
+        hHPu5zm7AEAkUqeUSkYn7uDLIwC79t9wRjNq9kQPebCSlk+x3bcbvH0I47ZJEnGOkMiKWCowGTxZ
+        qRMEchCGC2nJheEYlnqpn/nCQaHNRkNmLJDvSwkoP1kpbeFAUYHAvtiMsgwVxGaDNmqRF1P/WIR5
+        7bAuI/ApLXxvE0gRYkumrHL0hIMNKtXcxA4y6XIyOoKkJkcau8ykVlxbHDczNUcM1tof36voJIY1
+        CptNS5Oi6sP3fYDISJPL31A6o5uw9/h1IY4s6RS3Hr4M+gZtaVE7ucY5svS2yKP4orJ+F45NgfrB
+        1K0tt12tgYln9PX0wLPxFpxR00n0r6p79D1JDc0d+O5XlIr4tzV29hmLgQx8NlQvQ3uvgoMgnUYf
+        aB11YqyxLOVoMrq6+R4Ri2Af/AEDrXcbkQIAAA==
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 22 Apr 2025 14:25:41 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=2447
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gemma3[gemini-gemma-3-4b-it].yaml

@@ -0,0 +1,60 @@
+interactions:
+- request:
+    body: '{"contents": [{"role": "user", "parts": [{"text": "What is the capital
+      of France?"}]}], "generationConfig": {"stop_sequences": []}}'
+    headers:
+      accept:
+      - '*/*'
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '131'
+      content-type:
+      - application/json
+      host:
+      - generativelanguage.googleapis.com
+      user-agent:
+      - litellm/1.60.2
+    method: POST
+    uri: https://generativelanguage.googleapis.com/v1beta/models/gemma-3-4b-it:generateContent
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAC/2WRzUrDQBDH73mKYY+lLUKLiBcPfoAHsWhQwXqYJtNk6WYn7E6woRQ8+wR68t18
+        Ah/BbWraFPeQXeb/z3z8ZhUBqARtqlMU8uoUnkMEYNV8NxpbIStBaEMhWKKTvXd7Vp13sAgtNz+p
+        OCdIsNSCBngOVw5tQqA99HoTdNr3ekOY2qm9lu+3Tw8ImeFZ8CahKDmYs4NQrA9z9Llm24cMvTi2
+        XNQQ2oakMlI5GsLP18d7k+mRK5NCzRUYvSAQhoXl12CuJdc2g4IdAc64Emg6OFOdzte790t/P69j
+        Q5thCk7JtPZ1a1BzbbXP7wg9243tPr6dqJ2qbUrLED6K2gJNalV5zOiGBAN53PFVpeOilJgXZM+5
+        asifbHN19nQgj1pdOFA+kMbH/X9Z/UWoqU13f53VhhHRaKmb3V0+xaqDQQ6aajE090v0B2TL6IGc
+        11sYGRUFDkaD8WygRUXr6BcxmBLccwIAAA==
+    headers:
+      Alt-Svc:
+      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json; charset=UTF-8
+      Date:
+      - Tue, 22 Apr 2025 14:25:35 GMT
+      Server:
+      - scaffolding on HTTPServer2
+      Server-Timing:
+      - gfet4t7; dur=2349
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Origin
+      - X-Origin
+      - Referer
+      X-Content-Type-Options:
+      - nosniff
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-XSS-Protection:
+      - '0'
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gpt_4_1[gpt-4.1-mini-2025-04-14].yaml

@@ -0,0 +1,101 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "user", "content": "What is the capital of France?"}],
+      "model": "gpt-4.1-mini-2025-04-14", "stop": []}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '125'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.11.12
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jJJPb9swDMXv/hSCznEQe+7S5LgAGzDs0P3paSgMRqJtZrIkSPTQoch3
+        H2Snsbt1wC4+8MdHv0fxKRNCkpZ7IVUHrHpv8nd3t4eIH77w4ePX+/b+8XP56bTdHE7dgb2Sq6Rw
+        xxMqflatleu9QSZnJ6wCAmOaWmyrmzflrqrejqB3Gk2StZ7zal3kPVnKy015k2+qvKgu8s6Rwij3
+        4nsmhBBP4zcZtRof5V5sVs+VHmOEFuX+2iSEDM6kioQYKTJYlqsZKmcZ7ej9W4dCgScGI1wj3gew
+        CgVFcQeB4nqpCtgMEZJ1OxizAGCtY0jRR78PF3K+OjSu9cEd4x9S2ZCl2NUBITqb3ER2Xo70nAnx
+        MG5ieBFO+uB6zzW7Hzj+rqimcXJ+gBneXhg7BjOXy3L1yrBaIwOZuFikVKA61LNy3joMmtwCZIvI
+        f3t5bfYUm2z7P+NnoBR6Rl37gJrUy7xzW8B0nf9qu654NCwjhp+ksGbCkJ5BYwODmU5Gxl+Rsa8b
+        si0GH2i6m8bX291xuztiVTQyO2e/AQAA//8DAP7WRo9GAwAA
+    headers:
+      CF-RAY:
+      - 93458dcf6d0ef53b-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 22 Apr 2025 13:44:07 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '1391'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999989'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_74408ec81f430b6e9795cf5332262b8d
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gpt_4_1[gpt-4.1-nano-2025-04-14].yaml

@@ -0,0 +1,101 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "user", "content": "What is the capital of France?"}],
+      "model": "gpt-4.1-nano-2025-04-14", "stop": []}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '125'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.11.12
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jJJPb9swDMXv/hSCznEQuwrq5bgNBbZTh7aHYigMRqJtbbKkSXT/oMh3
+        L2Snsdt1wC4+8MdHv0fxOWOMa8V3jMsOSPbe5J8vqy/D96K/+PPjSn/Fh5szMewfb/eiar/d8lVS
+        uP0vlPSqWkvXe4OknZ2wDAiEaWpxLrZn5SchqhH0TqFJstZTLtZFbsG6vNyU23wj8kIc5Z3TEiPf
+        sZ8ZY4w9j99k1Cp85Du2Wb1WeowRWuS7UxNjPDiTKhxi1JHAEl/NUDpLaEfv1x0yCV4TGOYadhHA
+        SmQ6sksIOq6XqoDNECFZt4MxCwDWOoIUffR7dySHk0PjWh/cPr6T8kZbHbs6IERnk5tIzvORHjLG
+        7sZNDG/CcR9c76km9xvH3xViGsfnB5hhdWTkCMxcLsvVB8NqhQTaxMUiuQTZoZqV89ZhUNotQLaI
+        /LeXj2ZPsbVt/2f8DKRET6hqH1Bp+Tbv3BYwXee/2k4rHg3ziOFeS6xJY0jPoLCBwUwnw+NTJOzr
+        RtsWgw96upvG14gKq2ajxJZnh+wFAAD//wMATWCJPkYDAAA=
+    headers:
+      CF-RAY:
+      - 93458dd9aebff53b-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 22 Apr 2025 13:44:08 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '134'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999990'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_0ba738662e063fb55ea01793aafdcecc
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_gpt_4_1[gpt-4.1].yaml

@@ -0,0 +1,101 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "user", "content": "What is the capital of France?"}],
+      "model": "gpt-4.1", "stop": []}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '109'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.11.12
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAA4xSwYrbMBC9+yvEHEMcHMeh3dx2SwttoYTSW1nMRB7b2pUlIY27XZb8e5GdxM5u
+        C734MG/e83tP85IIAaqCnQDZIsvO6fRu//6Db26fnvTtx8/5t7v95rmT3y1+pc0XDcvIsIcHknxm
+        raTtnCZW1oyw9IRMUXX9rthu8pui2A5AZyvSkdY4TovVOs2zfJtmRbouTszWKkkBduJnIoQQL8M3
+        ejQV/YadyJbnSUchYEOwuywJAd7qOAEMQQVGw7CcQGkNkxls/2hJSHSKUQtbi08ejSShglgs9uhV
+        WCxWc6anug8YnZte6xmAxljGmHzwfH9CjheX2jbO20N4RYVaGRXa0hMGa6KjwNbBgB4TIe6HNvqr
+        gOC87RyXbB9p+N26GOVg6n8GnpoCtox6mudn0pVaWRGj0mHWJkiULVUTc6oe+0rZGZDMMr818zft
+        Mbcyzf/IT4CU5Jiq0nmqlLwOPK15itf5r7VLx4NhCOR/KUklK/LxHSqqsdfj3UB4DkxdWSvTkHde
+        jcdTuxJllh2yLMskJMfkDwAAAP//AwC4aq9JRgMAAA==
+    headers:
+      CF-RAY:
+      - 93458dcc1b9df53b-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 22 Apr 2025 13:44:06 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '296'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '10000'
+      x-ratelimit-limit-tokens:
+      - '30000000'
+      x-ratelimit-remaining-requests:
+      - '9999'
+      x-ratelimit-remaining-tokens:
+      - '29999989'
+      x-ratelimit-reset-requests:
+      - 6ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_7b4e1628a0608e9547e71e7857a29b58
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_guardrail_emits_events.yaml

@@ -0,0 +1,713 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are Test Agent. Test Backstory\nYour
+      personal goal is: Test Goal\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: Gather information
+      about available books on the First World War\n\nThis is the expected criteria
+      for your final answer: A list of available books on the First World War\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:"}], "model": "gpt-4o-mini", "stop":
+      ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '903'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFbbbhs3EH33Vwz2pUAgGXbqxInenJtzgZs0dmKgdWHMcmd3J+ZytkOu
+        ZLUI0N/o7/VLCpK7kpwL2hfL0pDDM2fOXP7cAyi4KhZQmBaD6Xo7f/Ke3rz75G+ffXz04celD+ef
+        yifL8hc5P/145opZvCHlJzJhurVvpOstBZbRbJQwUPR6eHz04PH9xw+Oj5Ohk4psvNb0YX4k844d
+        z+8f3D+aHxzPDx+Nt1thQ75YwK97AAB/pr8Rp6votljAwWz6pSPvsaFisTkEUKjY+EuB3rMP6EIx
+        2xqNuEAuQX8FTlZg0EHDSwKEJsIGdH5FCnDlXrBDCyfp+wJekhKwBwTLPoDU4CRgaQlKkRsP4iC0
+        BC9YfYBLUVvBJeoMyEV6IhjXwBKVZfDQk/qeTOAleUBXxasd+cWVu3KH+3Dv3lVxYi38PDCFyfMl
+        +UDq4IWKC1cFlGt4rmxaOENlhPfUof4+0L17MIcTcLIkCxX1bEJ8OXqg256UyRnyEf8paYcOvNiK
+        ST1Ug8aTG+zwagYtN63lpt34aEVVNN0PSs60sEKtUWk/Yr+fsV98TUQG/FpaB2+IGnQjzkiOUkvO
+        xyTIknTJtEruW4q+Z4AO7fqPCICDB4ODJz+DDj+JQokh2Pg1kmjEefp9SAEmOD+OVI4wPrhKHC0g
+        wjsPouvpmdOU+ZSuw8eHRxAkfj7KmE/3X+/DGa1JJ2pRFWPqoGWf3IQWA5gI3meiXWCliKe2bAKs
+        OLSAUIsZklBuaA20JBdy8mtuBh0hH20ZPB1c4vlkaAY/ZvwJaomKcLkPF4Npu4lHB2iMRe6ogpXo
+        DVQUkO0m8/kxS1jFn4Y+hjgSPOkPCNWuwQdssj6MdCWGGVDXt+j5j8lZRYY9SwYXXZJm7A8y9lOR
+        qlxTfCKK+KLFEfx7KUkDnCouyW9wD0FKlkaxbycmsQ+RkC9E+7XmoFbpACcJ/3CnsGaAVlyTyY+e
+        gqLzHNtUhNaLD/MYvuU6i/dhhn8Zz78dFJ6gufETUZdo7QI+skkJj5Q9ozqqht2OVp7hkis4D5Fv
+        L9vcRAV79pPe6tRZ1oR6R+gyBMsu0lzKiLljywE1pkUxUMPbfgFeDMu8F8uBDVpIve02+Eyib7Gn
+        fFCGYKTLQR7v6GtS/QJO4GlKNrwcFT3C+mYRv6NACi9RQ4rvomWfeiD0KkuuIsKxLuflep7/i/KU
+        wYUZDKkRxjxJJKFi1Cmo8UzivNRJbiuMiR0VHGSbr0fbUGK3CgLPXZUkd4nqc5mfdKQce/zZROTz
+        rZ7Y7Ta7saVWK9QKzvbhqdT1Tn3RbW8l1r24VJSTY3ZLsUvqyCUtbJJZsTdD7vrfSyJ3PZqQa+dx
+        DubtkjT5uJA+puU8K/ufv/728IzxPzJzoqEdFJ53Pa3HZlXHc+0Ou9+oopVyCOSiB3TbyJZiBxeI
+        ojLrmlJCEBRX01jJTOQ2sTtcUkCHB9+dBTGwn2gFr6wdMiXVJLyx5YpW4uCpqPJ2VMRhZ9fAO7eS
+        7JLceyWfGyqYVsWJlSZVRXtX0XmiGEPecxzetSho7mHxCFoLJZqbRmVwVY4kCTwN/R2Bx0lOIbll
+        5+OEzDndDAd/p5elt/OedMshNxDPjeM6Uj32tq+Z2t/dXZTqwWPcn9xg7Y4BXVxFYj7S1vTbaPm8
+        2ZOsNL1K6b+4WtTs2LfXSujFxZ3IB+mLZP28B/Bb2seGOytW0at0fbgOckPpucPjcR8rtmvg1nqU
+        Nz+AIkhAuzU8PJoMdxxe57nld1a6wqBpqdpe3e5/OFQsO4a9nbC/hvMt3zl0ds3/cb81GEN9oOq6
+        V6pyJXzrmFJck793bENzAlz4uPkYug5MGlNRUY2Dzctr4dc+UHdds2tIe+W8wdb9dVWiwYcHVX1Q
+        7H3e+xcAAP//AwDV5F0jzwsAAA==
+    headers:
+      CF-RAY:
+      - 937ec970ab837df5-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 29 Apr 2025 12:26:28 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=lSQwOucDEe7UVr7Rj6WZvsTkBkgGT9q7hgVX9AzK42s-1745929588-1.0.1.1-6m0TeDAKI0Hgbl6.GmWHMBMkIpmnfhOu3jQKfjmcvWLHqWUWoE1O4xa9VCtZYXv6_9poUVQq_oCNtzy8eL1XDc8_J3aRMOG3LCvOyvqCawk;
+        path=/; expires=Tue, 29-Apr-25 12:56:28 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=TeUS2y0sO.6zigvKZd5.0zRS7sujoYCd9.wMQJboxxo-1745929588265-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '10782'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999808'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_cbf6ad64d8b470c6d9eff91852f85e1c
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are Guardrail Agent. You
+      are a expert at validating the output of a task. By providing effective feedback
+      if the output is not valid.\nYour personal goal is: Validate the output of the
+      task\n\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!\nIMPORTANT:
+      Your final answer MUST contain all the information requested in the following
+      format: {\n  \"valid\": bool,\n  \"feedback\": str | None\n}\n\nIMPORTANT: Ensure
+      the final output does not include any code block markers like ```json or ```python."},
+      {"role": "user", "content": "\n        Ensure the following task result complies
+      with the given guardrail.\n\n        Task result:\n        Here is a list of
+      notable books on the First World War, encompassing various perspectives and
+      themes:\n\n1. **\"All Quiet on the Western Front\" by Erich Maria Remarque**
+      - A novel depicting the experiences of German soldiers during World War I, highlighting
+      the horrors of trench warfare.\n\n2. **\"The First World War\" by John Keegan**
+      - A comprehensive overview of the war, analyzing its causes, major battles,
+      and consequences.\n\n3. **\"A World Undone: The Story of the Great War, 1914
+      to 1918\" by G.J. Meyer** - A narrative history that covers the entire conflict
+      with a focus on key events and figures.\n\n4. **\"The Guns of August\" by Barbara
+      W. Tuchman** - An acclaimed work detailing the events leading up to the war
+      and the early stages of combat, emphasizing the decisions of leaders.\n\n5.
+      **\"Goodbye to All That\" by Robert Graves** - An autobiography that captures
+      the experience of trench warfare from a soldier''s perspective, along with the
+      transition to post-war life.\n\n6. **\"With Our Backs to the Wall: Victory and
+      Defeat in 1918\" by David Stevenson** - An analysis of the final year of the
+      war, outlining both the military strategies and the socio-political contexts
+      that shaped the outcome.\n\n7. **\"The Great War: A Combat History of the First
+      World War\" by Peter Hart** - This book provides a battle-by-battle account,
+      using personal diaries and accounts to bring the war''s events to life.\n\n8.
+      **\"The War to End All Wars: The American Military Experience in World War I\"
+      by Edward M. Coffman** - An exploration of American involvement in the war,
+      discussing military strategies and impacts.\n\n9. **\"Over the Top: A Soldier\u2019s
+      Diary of the First World War\" by Arthur Empey** - A firsthand account of trench
+      warfare written by an American volunteer, offering a raw depiction of combat
+      experiences.\n\n10. **\"The First World War: A New Illustrated History\" by
+      Gordon Corrigan** - A richly illustrated book that presents a chronological
+      history of the war, accessible for readers of all backgrounds.\n\nThis list
+      provides a variety of insights and narratives that capture the complexity and
+      significance of the First World War.\n\n        Guardrail:\n        Ensure the
+      authors are from Italy\n        \n        Your task:\n        - Confirm if the
+      Task result complies with the guardrail.\n        - If not, provide clear feedback
+      explaining what is wrong (e.g., by how much it violates the rule, or what specific
+      part fails).\n        - Focus only on identifying issues \u2014 do not propose
+      corrections.\n        - If the Task result complies with the guardrail, saying
+      that is valid\n        "}], "model": "gpt-4o-mini", "stop": ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '3636'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFPJbhsxDL37Kwidx4HjOrDjW4qiRZBb4m6oA4OWODNqNNREouwYgf+9
+        0HhNF6CXEYaPyyP5+NoDUNaoKShdo+imdf3393SH+qv9/vLlefXw0MZw/222nn1No9sPQRU5wi9/
+        kpZD1IX2TetIrOcdrAOhUM56OR5dXQ+vryaTDmi8IZfDqlb6I99vLNv+cDAc9Qfj/uVkH117qymq
+        KfzoAQC8dt/Mkw29qCkMioOloRixIjU9OgGo4F22KIzRRkEWVZxA7VmIO+qz2qeqlincAvs1aGSo
+        7IoAocr8ATmuKQDM+aNldHDT/U/hdc4Ac7VCZ81cTaFEF6nYGUsis0T9lO1zNasJBOMTBIrJCRhP
+        EdgLdAPbwNpKDVITVAmDCWgdLEljigTsmcCXHepsFDKASWofImAgKINv4FbQbS7gxrkj1hDnNWTv
+        g5exZUmBOFdNLMFSLMCydslYruAThQZ5U3SVPt/t34ebApANeKkpxALWtdU1rKx3KBQ7n0DPyQbK
+        FUHqPK8DhxQFltTRs8gXczXn7fkOApUpYtYBJ+fOAGT2grmBbvuPe2R73LfzVRv8Mv4WqkrLNtaL
+        QBg9591G8a3q0G0P4LHTVXojFdUG37SyEP9EXbnxaK8rdZLzGTreg+IF3ck+uTwAb/ItDAlaF8+U
+        qTTqmswp9CRjTMb6M6B31vWfbP6We9e55ep/0p8ArakVMos2kLH6bccnt0D52v/ldpxyR1hFCiur
+        aSGWQt6EoRKT292gipso1CxKyxWFNtjdIZbtYvDuejgZDgfXA9Xb9n4BAAD//wMAG/c/OJYEAAA=
+    headers:
+      CF-RAY:
+      - 937ec9b72e717e0f-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 29 Apr 2025 12:26:30 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=2Kv7JW0NnxXgvGH0KQnR1VcNF47nEYxhEB4bYlFvRfA-1745929590-1.0.1.1-gmQvNlZR_WoNPIkf.07YchEy.a13FU2sP7wZropzue.84PKf6DVY_clzo6DqmBOk8PtKtM3gV952vhWHuE0ygk7096hW9jQTST91FDi30Jc;
+        path=/; expires=Tue, 29-Apr-25 12:56:30 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=HHxY6s22oZkfAHAh8HGGIeDkKOuavigZ5DkKL6.WyGc-1745929590485-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '1744'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999140'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_74247d0bd52dcebe834bd1cdb4b38470
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are Test Agent. Test Backstory\nYour
+      personal goal is: Test Goal\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: Gather information
+      about available books on the First World War\n\nThis is the expected criteria
+      for your final answer: A list of available books on the First World War\nyou
+      MUST return the actual complete content as the final answer, not a summary.\n\nThis
+      is the context you''re working with:\n### Previous attempt failed validation:
+      The task result does not comply with the guardrail because none of the listed
+      authors are from Italy. All authors mentioned are from different countries,
+      including Germany, the UK, the USA, and others, which violates the requirement
+      that authors must be Italian.\n\n\n### Previous result:\nHere is a list of notable
+      books on the First World War, encompassing various perspectives and themes:\n\n1.
+      **\"All Quiet on the Western Front\" by Erich Maria Remarque** - A novel depicting
+      the experiences of German soldiers during World War I, highlighting the horrors
+      of trench warfare.\n\n2. **\"The First World War\" by John Keegan** - A comprehensive
+      overview of the war, analyzing its causes, major battles, and consequences.\n\n3.
+      **\"A World Undone: The Story of the Great War, 1914 to 1918\" by G.J. Meyer**
+      - A narrative history that covers the entire conflict with a focus on key events
+      and figures.\n\n4. **\"The Guns of August\" by Barbara W. Tuchman** - An acclaimed
+      work detailing the events leading up to the war and the early stages of combat,
+      emphasizing the decisions of leaders.\n\n5. **\"Goodbye to All That\" by Robert
+      Graves** - An autobiography that captures the experience of trench warfare from
+      a soldier''s perspective, along with the transition to post-war life.\n\n6.
+      **\"With Our Backs to the Wall: Victory and Defeat in 1918\" by David Stevenson**
+      - An analysis of the final year of the war, outlining both the military strategies
+      and the socio-political contexts that shaped the outcome.\n\n7. **\"The Great
+      War: A Combat History of the First World War\" by Peter Hart** - This book provides
+      a battle-by-battle account, using personal diaries and accounts to bring the
+      war''s events to life.\n\n8. **\"The War to End All Wars: The American Military
+      Experience in World War I\" by Edward M. Coffman** - An exploration of American
+      involvement in the war, discussing military strategies and impacts.\n\n9. **\"Over
+      the Top: A Soldier\u2019s Diary of the First World War\" by Arthur Empey** -
+      A firsthand account of trench warfare written by an American volunteer, offering
+      a raw depiction of combat experiences.\n\n10. **\"The First World War: A New
+      Illustrated History\" by Gordon Corrigan** - A richly illustrated book that
+      presents a chronological history of the war, accessible for readers of all backgrounds.\n\nThis
+      list provides a variety of insights and narratives that capture the complexity
+      and significance of the First World War.\n\n\nTry again, making sure to address
+      the validation error.\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:"}],
+      "model": "gpt-4o-mini", "stop": ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '3509'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=2Kv7JW0NnxXgvGH0KQnR1VcNF47nEYxhEB4bYlFvRfA-1745929590-1.0.1.1-gmQvNlZR_WoNPIkf.07YchEy.a13FU2sP7wZropzue.84PKf6DVY_clzo6DqmBOk8PtKtM3gV952vhWHuE0ygk7096hW9jQTST91FDi30Jc;
+        _cfuvid=HHxY6s22oZkfAHAh8HGGIeDkKOuavigZ5DkKL6.WyGc-1745929590485-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFZtbtxGEv2vUxT4ZwFjRtAocmTpn7yBHCW24cTGGkFkCDXdRbLsZhVT
+        3ZzxKDCw19gb5B65yZ5k0U3OhxUF2D8zIJtdXa/eq9f1+xFAxb66hMq1mFzXh/nzn+lHt/rl5Q+v
+        vVu8ufrB/xTf6Q3+/Ozdx9BXs7xDlx/Jpe2uY6ddHyixyrjsjDBRjro4P3t6cXrx9OKkLHTqKeRt
+        TZ/mZzrvWHh+enJ6Nj85ny+eTbtbZUexuoRfjwAAfi+/OU/x9Lm6hBKrvOkoRmyoutx9BFCZhvym
+        whg5JpRUzfaLTiWRlNRvQHQNDgUaXhEgNDltQIlrMoBbuWbBAFfl+RK+JyPgCAiBYwKtQTThMhAs
+        VT9FUIHUElyzxQTv1YKH92iwNk6JBJYbuEkYGAVwSK1anAGLU+vVMLE0sEJjHSL0ZLEnl3hFEVB8
+        DttRvLyVW1kcw5Mnt9VNgI4VRDuCP/8AoRgH0dsqn/JdDgPX+uQJzOEKBuHfBgJBy8esCFgSWVqz
+        5DPzWZpRxqTG03ktlyeHAWp0KQIudUgFHXd9eaP1AcSbjH0LLqpjSpvjnO3pmO1LhGYgMwRPDKIx
+        Wf4T4THjVyVjXGGTI2jJ4RWaU3iDoWMyLljetRxLraE3XbHP2YKnhBzIAzqngxRecqL0uSdjEkcl
+        2X12wTNZBD9Yxv8IYzOo1Q0xr46UskGniVeYBT5WKCYbmiZQLDC/GWG+HUIgSIbOEXgKAeGFoXiC
+        FwX9CPYtWcMKbxOybDlqDPuWHYiuKEBqMcEykPgIaIljYpfxGMXIKrDm1B5ytKc2KXjq2Y1cBa4p
+        Y99h5lGhyUhcO9YlP78osn+PVsCcTZz9o+gER2HghOeNcYcTHHil4hkDjbhe8BCp7wm+I3g5JOY4
+        gcvmYNSSxJyirshWTOsRJX3ugxrFkkdD2mvgVEA5HCLFGXT4UQ2WmFLIj7n4QaWZJ7IOqK5pUmMO
+        sEbbKnFTvlzSRsUXWE93UvyKk1yTa+MhTFJ8gxoU/okpoQ339/hAeNT1LUa+nzI2arh0z9gWD7ti
+        F3sGLTdt4KZNW9FFboRrdihpi27b6w+1G7QUhFecJTwJcOK0YPt2wkYpZY/yDMOodEyTJ1yFbJTi
+        TeH6GJ4bNyiJdgSFkO1GpZxWosRD38LtcYdds86dMjZifoV7K8n5sSTuMNGhmW0d0ggzyyM4p90S
+        U4FxPsK4ur8fzLio1Vgc4aFL3EQhadqtI9DEy2fsWCZW9uV7tPOnLqhNJUHIux7reDeENBjNoFPD
+        QLMdObFFIw8OOzT0+SDATnNRTLUfCXn2F99jeIUp0UTHtaG4LDPzLDzRcOi6PNJReqTWEHSdvW6j
+        gzQ7QB3Kf//9nwgfdTChDaTWdGjaPTla11ToYolZehl60rFE2dB2ZPVx41oN2pTDDyzeqdSB3UjP
+        xQhqcbF4Ol9cLJ4dw8tHDe5KvBHC62xJW2wxx0cLG1irfRpxoWDYbDspJsNEzfYGSuRa2WWEfoXi
+        qCNJMbdg0A35wwu1Vsu98veeXgAsTnaXZ8NqopOprTgVjxvT/1eWnNznu+eQHYf9eAVIM7kWbjum
+        qKmMCrnixeYiBMLSF9uCiz9wqdkk2PxBq9kLaZOF1ZMf3asQKzhxxJ4k8XSnFjMqE8jOU7I2DKX5
+        Su/TkAHrVkclgOcVWTwYBcZa96a1DqVnH8qkG0LiGh0l8l+5UrFhatDx/hp5WPLDqcuoHiLmyU+G
+        EA4WUPIQVS7WPO99mFa+7Ca8oE1vuowPtlY1C8f2zgijSp7mYtK+KqtfjgA+lEly+Go4rHrTrk93
+        ST9ROe58cTbGq/YD7H717OJ8Wk2aMOwXFqeLxeyRiHfjLBIPptHKoWvJ7/fuR1ccPOvBwtEB7r/m
+        81jsETtL8/+E3y84R30if9cb+dFnHvvMKE/4f/fZrs4l4SrmO93RXWKyzIWnGocwzt1V3MRE3V3N
+        0pD1xuPwXfd3fokOvz3x9Ul19OXofwAAAP//AwDXPLUkigwAAA==
+    headers:
+      CF-RAY:
+      - 937ec9c4b8307e0f-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 29 Apr 2025 12:26:41 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '10386'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999169'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_7e9c58909cf39af106866bae0c0cf7e1
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are Guardrail Agent. You
+      are a expert at validating the output of a task. By providing effective feedback
+      if the output is not valid.\nYour personal goal is: Validate the output of the
+      task\n\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!\nIMPORTANT:
+      Your final answer MUST contain all the information requested in the following
+      format: {\n  \"valid\": bool,\n  \"feedback\": str | None\n}\n\nIMPORTANT: Ensure
+      the final output does not include any code block markers like ```json or ```python."},
+      {"role": "user", "content": "\n        Ensure the following task result complies
+      with the given guardrail.\n\n        Task result:\n        Here is a list of
+      notable books on the First World War written by Italian authors, incorporating
+      various perspectives and themes:\n\n1. **\"Il mio nome \u00e8 nessuno\" by Dario
+      Fo** - A unique narrative intertwining personal stories and historical facts
+      about the impacts of World War I on Italian society.\n\n2. **\"La guerra dei
+      nostri nonni\" by Mario avagliano and Marco Palmieri** - This book provides
+      a detailed account of the experiences of Italian soldiers during the First World
+      War, focusing on their motivations and struggles.\n\n3. **\"Sulle tracce della
+      Grande Guerra\" by Sergio Staino** - A graphic novel that blends artistic expression
+      with historical narrative to depict the life of soldiers in the trenches of
+      the Great War.\n\n4. **\"L''intera storia della Prima Guerra Mondiale\" by Giuseppe
+      De Lutiis** - A comprehensive overview that explores the geopolitical causes,
+      major battles, and long-term effects of the war on Italy and beyond.\n\n5. **\"La
+      Grande Guerra in Friuli\" by Paolo Cattaruzza** - This book emphasizes the regional
+      impact of World War I in Friuli, highlighting the significant battles and the
+      experiences of local civilians and soldiers.\n\n6. **\"Lettere di un soldato\"
+      by Alessandro F. Brigante** - A collection of letters written by a soldier during
+      the war, providing a personal and intimate perspective on the realities of combat.\n\n7.
+      **\"Azzurri in trincea\" by Mario Isnenghi** - The book examines the experience
+      of Italian soldiers in the front lines, focusing on their culture, morale, and
+      the shared camaraderie among troops.\n\n8. **\"La guerra di Matteo\" by Franco
+      Cardini** - A historical fiction that follows a young Italian man\u2019s journey
+      through the war, offering insights into the emotional and psychological impacts
+      of conflict.\n\n9. **\"1915-1918. La Grande Guerra\" by Andrea Nativi** - A
+      scholarly work that analyzes the strategies and technological advancements employed
+      by Italian forces during the First World War.\n\n10. **\"Il giorno della vittoria\"
+      by Vincenzo Pardini** - A captivating exploration of the final offensives leading
+      to the end of the war, examining how they shaped Italy\u2019s national identity.\n\nThis
+      list highlights a range of Italian authors who offer diverse narratives and
+      profound insights into the multifaceted experiences and legacies of the First
+      World War.\n\n        Guardrail:\n        Ensure the authors are from Italy\n        \n        Your
+      task:\n        - Confirm if the Task result complies with the guardrail.\n        -
+      If not, provide clear feedback explaining what is wrong (e.g., by how much it
+      violates the rule, or what specific part fails).\n        - Focus only on identifying
+      issues \u2014 do not propose corrections.\n        - If the Task result complies
+      with the guardrail, saying that is valid\n        "}], "model": "gpt-4o-mini",
+      "stop": ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '3829'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=2Kv7JW0NnxXgvGH0KQnR1VcNF47nEYxhEB4bYlFvRfA-1745929590-1.0.1.1-gmQvNlZR_WoNPIkf.07YchEy.a13FU2sP7wZropzue.84PKf6DVY_clzo6DqmBOk8PtKtM3gV952vhWHuE0ygk7096hW9jQTST91FDi30Jc;
+        _cfuvid=HHxY6s22oZkfAHAh8HGGIeDkKOuavigZ5DkKL6.WyGc-1745929590485-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jJJNb9swDIbv/hWEzvHgeFmT+NYNKFbstGLADnNhKBJtq5EpQZLTFUH+
+        +yDHiZ19ALsYMB++FF+SxwSAKckKYKLlQXRWpx+f8Av5dXj8vH16kG+f9j6Xuxf5vf56nx3YIirM
+        7gVFuKjeCdNZjUEZOmPhkAeMVZfr1Ydtvr3LlgPojEQdZY0N6cqknSKV5lm+SrN1utyM6tYogZ4V
+        8CMBADgO39gnSfzJCsgWl0iH3vMGWXFNAmDO6Bhh3HvlA6fAFhMUhgLS0Pq31vRNGwp4BDKvIDhB
+        ow4IHJrYP3Dyr+gASnpQxDXcD/8FHEsCKNmBayVLVkBwPS7OsRpR7rjYxzD1Wpd0mj/usO491yOc
+        AU5kAo8DHGw/j+R0NapNY53Z+d+krFakfFs55N5QNOWDsWygpwTgeRhofzMjZp3pbKiC2ePw3Ppu
+        HCib9jjRfDPCYALXM9XmAm7qVRIDV9rPVsIEFy3KSTrtj/dSmRlIZq7/7OZvtc/OFTX/U34CQqAN
+        KCvrUCpx63hKcxjP/F9p1ykPDTOP7qAEVkGhi5uQWPNen4+P+TcfsKtqRQ0669T5AmtbZe+3+SbP
+        s23GklPyCwAA//8DANS97/6PAwAA
+    headers:
+      CF-RAY:
+      - 937eca0769737e0f-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 29 Apr 2025 12:26:42 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '924'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999094'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_242f5797b2a0bf5867b01ab6027921fa
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are Test Agent. Test Backstory\nYour
+      personal goal is: Test Goal\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: Test task\n\nThis
+      is the expected criteria for your final answer: Output\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:"}], "model": "gpt-4o-mini", "stop": ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '807'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=2Kv7JW0NnxXgvGH0KQnR1VcNF47nEYxhEB4bYlFvRfA-1745929590-1.0.1.1-gmQvNlZR_WoNPIkf.07YchEy.a13FU2sP7wZropzue.84PKf6DVY_clzo6DqmBOk8PtKtM3gV952vhWHuE0ygk7096hW9jQTST91FDi30Jc;
+        _cfuvid=HHxY6s22oZkfAHAh8HGGIeDkKOuavigZ5DkKL6.WyGc-1745929590485-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFNNTxsxEL3nV4x8TqIQICm5tYeqiAMSqoSqFq0ce3Z3wOvZ2rMbAuK/
+        V/YGNrQcell5583He+Pn5wmAIqs2oEytxTStm325wSuOVw+if3wz14Iu7tZP29vLm+vb05Wapgre
+        3qOR16q54aZ1KMR+gE1ALZi6nqzPzi+WF6vFMgMNW3SprGpldsazhjzNlovl2Wyxnp18OlTXTAaj
+        2sDPCQDAc/4mnt7io9rAYvoaaTBGXaHavCUBqMAuRZSOkaJoL2o6goa9oM/UL8HzDoz2UFGPoKFK
+        tEH7uMMA8Mt/Ja8dfM7/G/heI5guBPQCouMDkO/Z9RihDdyTJV+BBqk5cFfVoL0Fi6LJoYWAsWUf
+        EbY6ogX2IDUCPrZoBC2YQIKBNDTo0xbRzuESduQctAFjnpimD2tOhywCdiQ1dwKxaxod6Il8NQX0
+        sQuJjNRaAHsMe9AxTQKKYLjHgBaEoUEc+gb83VHANDwCliUaoR7dfp41cyeGG3ylk6QiGKcDyT6r
+        TLQC1uhjWiP5kkOjk4yBQdm5kpyLedRgnJTHZQ6kTc6PLyhg2UWdTOI7544A7T1L7putcXdAXt7M
+        4LhqA2/jX6WqJE+xLgLqyD5dfBRuVUZfJgB32XTdOx+pNnDTSiH8gHncyfnp0E+NXh/R1foACot2
+        Y3y5PFj1fb9i8EU8sq0y2tRox9LR47qzxEfA5Ej1v2w+6j0oJ1/9T/sRMAZbQVu0AS2Z94rHtID3
+        2cQfp71tORNWEUNPBgshDOkmLJa6c8MDVXEfBZuiJF9haAMNr7RsC7vVRq8WtlyoycvkDwAAAP//
+        AwC4yvtmswQAAA==
+    headers:
+      CF-RAY:
+      - 937eca0f18177e0f-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 29 Apr 2025 12:26:44 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '1988'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999832'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_99b127ab59c932c0b46dbecc738df8ba
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_guardrail_when_an_error_occurs.yaml

@@ -0,0 +1,288 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are Test Agent. Test Backstory\nYour
+      personal goal is: Test Goal\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: Gather information
+      about available books on the First World War\n\nThis is the expected criteria
+      for your final answer: A list of available books on the First World War\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:"}], "model": "gpt-4o-mini", "stop":
+      ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '903'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFdhb9w2Ev3uXzHQlwCBbewmThzvN1+Q2G3PQM+X1mjPhTFLjqSpKY46
+        pHazV+S/H0hK2t00Be6LYZEi9d68x8fZP08AKrbVCirTYjRd787+cU/3P7+9tfTPq+1PTffDtr7+
+        tf759+HG9tdSnaYVsv6dTJxWnRvpekeRxZdpo4SR0q7Ly4s3V68Xi+VlnujEkkvLmj6eXchZx57P
+        Xi1eXZwtLs+W78bVrbChUK3gPycAAH/mvwmnt/S5WsHidBrpKARsqFrNLwFUKi6NVBgCh4g+Vqf7
+        SSM+ks/QvwMvWzDooeENAUKTYAP6sCUFePQf2aOD6/y8gltSAg6AkOgqteRDWuc4RJAacIPscO0I
+        1iLPAcRDbAk+soYID6LOwgPq6tE/+uU5vHz5WH1qCf7tiPotumfSsIJb2cKHQaUneCAfIUpaA+xh
+        ebW8eKxgvYP3rXKI0rek8N6hPr98mcACwKeWQ/44WHIbCsA+SgZRBPoMNZooGiC2GMGRhXFehrhW
+        wufEIz1vUU9B6pqUfQPsAzdtPNivF8eRDTpAbyGIYXRgdx47NiFtQqhuB68WsQVDPg66G3mdJ/6v
+        Cv/rsSw/eSueVpDrEUV3E4ybLMhDApP4J7TLq+W7Uoeb8+/P4Y52pHMB8tOLAPS5xyKOR1WM6T8j
+        G8rMCchH1kwSthxbQKjFDFmxtcQWOnYcUXcQomKkhilknmltO3To0wdImbyhAOTtoGQTpCDOcvpK
+        etvwhh2jD4COnwvx1yNx5+BfA1OcTPJAIZJ6+KjiY6H3Qdm0cIfKCPfUof4x0Ez0GnrhxqOP4GVD
+        rghqsI+DUiGpFNhliAW74tDhAfAM+IY00Zlx2yELPrsVvjuFNQayE1AcYiupxLI9qkJmd7G39Veu
+        L5S+l9bDD0QN+plJeYReZcM21RksReTkzVmGNvl974pszpowDsfuTPJhjI7C6YFyp7N0yQDoHHDX
+        o8mlb5ysk4frGlkLhzeFw42IXe8oOS6J9anFUZZ7WZNGuFHcUDg+eThEWbM0in27AyUjg4/huGyH
+        xsHEdiz9VPm/Hj6EnjSIH8+a0fHgpdGeTPb2KI4RXzs2ce/WXkI8Sz4nxUzvbaH3HiOGqClE8sla
+        TalzI8k+stfsDj/DLYbIvtnTnQbAtCqejRs9RxtKjB2hTdCHPm+1N9OMq8TDrFaR/ID/i5Q1HFOq
+        7NUqELNdDVPk0XWXe9eljySp4IO3ZOFHQjPGyr2gHePjYiKmDSpFuENzx84deHIeSXI5mU7UcegV
+        U+bHo1RNF4zyeojfTtcsLnV9i4H/OzG2ZDiw+AAdWkroUglzkBiVEA6z893fHrIVXMP7chMT3JYz
+        M3ON7OGGXTLvsWvNtGI6ZRGfKYCOAGKrMjTtQW7Grw6iSgccAxgcQjFPesI6pmyJ7SkMofh4y5ZA
+        0TeUNggy6BQcV4VTcWJi9guhlmDM5LKchcqPODi4xe7Ai12Jb5qv3J43EtHBLu0idbk7jq1XPGZp
+        gyFialxSTKDbZUkSfie+OXPF50B1TSbO+28TqAx8uSjIk/FuRQON9WbTIjm4E+0HbWQGO5a8ZWeV
+        /IswpTc5Vzw2Bx1Cm/abrHYUHF9nRctN61IGTqNr8RbWFLdEHtBzh65kQr69AmDHNsSSGS1KEeED
+        mnZUNsw9TEqhAIPnPwY6jJyyXb6iyuENgGsZ4rdanlPo8HmE1sEG3ZC7JKXRAlCLAvqdeEodBmm6
+        DG1qemJiPqmZ+EseHp16ftjXKdVDwNRb+sG5gwn0XorEuaP8bZz5MveQTppeZR2+WlrV7Dm0T0oY
+        xKd+MTVdVZ79cgLwW+5Vh6P2s+pVuj4+RXmm/Lnl5dirVvsWeT/75vXFOBsTw/3E5WKaONrwaSz1
+        QbtbGTQt2f3SfW+Mg2U5mDg5oP1XON/au1Bn3/w/2+8njKE+kn3qlSybY8r715TST4i/e20ucwZc
+        BdING3qKTJqksFTj4EpjX4VdiNQ91ewb0l65dPd1/2TXaPDtwtaL6uTLyf8AAAD//wMA10Lu/OsM
+        AAA=
+    headers:
+      CF-RAY:
+      - 937ed42dee2e621f-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 29 Apr 2025 12:33:48 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=mLRCnpdB3n_6medIZWHnUu8MNRGZsD6riaRhN47PK74-1745930028-1.0.1.1-M2lDM1_V9hNCK0MZrBnFalF3lndC3JkS8zhDOGww_LmOrgdpU9fZLpNZUmyinCQOnlCjDjDYJUECM82ffT1anqBiO1NoDeNp91EPKiK7s.8;
+        path=/; expires=Tue, 29-Apr-25 13:03:48 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=eTrj_ZhCx2XuylS5vYROwUlPrJBwOyrbS2Ki.msl45E-1745930028010-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '10856'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999807'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_bc2d62d8325b2bdd3e98544a66389132
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are Guardrail Agent. You
+      are a expert at validating the output of a task. By providing effective feedback
+      if the output is not valid.\nYour personal goal is: Validate the output of the
+      task\n\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!\nIMPORTANT:
+      Your final answer MUST contain all the information requested in the following
+      format: {\n  \"valid\": bool,\n  \"feedback\": str | None\n}\n\nIMPORTANT: Ensure
+      the final output does not include any code block markers like ```json or ```python."},
+      {"role": "user", "content": "\n        Ensure the following task result complies
+      with the given guardrail.\n\n        Task result:\n        Here is a comprehensive
+      list of available books on the First World War:\n\n1. **\"The Sleepwalkers:
+      How Europe Went to War in 1914\" by Christopher Clark**  \n   This book delves
+      into the complex factors that led to the outbreak of the war, offering insights
+      into the political and social dynamics of early 20th century Europe.\n\n2. **\"A
+      World Undone: The Story of the Great War, 1914 to 1918\" by G.J. Meyer**  \n   Meyer''s
+      expansive narrative covers the entire war with a focus on both military strategies
+      and the human experiences endured by soldiers and civilians alike.\n\n3. **\"All
+      Quiet on the Western Front\" by Erich Maria Remarque**  \n   A poignant novel
+      that captures the resilience and trauma experienced by German soldiers during
+      World War I, based on the author''s own experiences.\n\n4. **\"The First World
+      War\" by John Keegan**  \n   Keegan provides a detailed military history of
+      the war, featuring insights on battles, strategies, and the overall impact on
+      global affairs.\n\n5. **\"Goodbye to All That\" by Robert Graves**  \n   This
+      autobiography recounts the author''s experiences as a soldier during the war,
+      offering a personal and critical perspective on the conflicts and the post-war
+      era.\n\n6. **\"Catastrophe 1914: Europe Goes to War\" by Max Hastings**  \n   Hastings
+      chronicles the events leading up to World War I and the early battles, detailing
+      the war''s initial impact on European societies.\n\n7. **\"The War That Ended
+      Peace: The Road to 1914\" by Margaret MacMillan**  \n   MacMillan explores the
+      political and historical factors that contributed to the outbreak of war, emphasizing
+      the decisions made by leaders across Europe.\n\n8. **\"The First World War:
+      A Complete History\" by Martin Gilbert**  \n   This complete history takes readers
+      through the entirety of the war, from its causes to its aftermath, using a wide
+      range of sources.\n\n9. **\"1914: The Year the World Ended\" by Paul Ham**  \n   Ham
+      focuses on the pivotal year of 1914 and the early war''s devastation, analyzing
+      its long-lasting effects on the world.\n\n10. **\"War Horse\" by Michael Morpurgo**  \n    This
+      children''s novel tells the story of a horse and his experiences during the
+      war, highlighting the bond between animals and humans amidst the chaos.\n\nEach
+      of these books offers unique perspectives and rich details about the First World
+      War, making them valuable resources for anyone interested in this pivotal period
+      in history.\n\n        Guardrail:\n        Ensure the authors are from Italy\n        \n        Your
+      task:\n        - Confirm if the Task result complies with the guardrail.\n        -
+      If not, provide clear feedback explaining what is wrong (e.g., by how much it
+      violates the rule, or what specific part fails).\n        - Focus only on identifying
+      issues \u2014 do not propose corrections.\n        - If the Task result complies
+      with the guardrail, saying that is valid\n        "}], "model": "gpt-4o-mini",
+      "stop": ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '3917'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=mLRCnpdB3n_6medIZWHnUu8MNRGZsD6riaRhN47PK74-1745930028-1.0.1.1-M2lDM1_V9hNCK0MZrBnFalF3lndC3JkS8zhDOGww_LmOrgdpU9fZLpNZUmyinCQOnlCjDjDYJUECM82ffT1anqBiO1NoDeNp91EPKiK7s.8;
+        _cfuvid=eTrj_ZhCx2XuylS5vYROwUlPrJBwOyrbS2Ki.msl45E-1745930028010-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFPLbtswELz7KxY8y4HsJHWsW9wiQVq0hzx6aBUIa3IlMaFIlVw5NQL/
+        e0Epiew+gF4EamZnuC8+TwCEViIDIWtk2bRmurqm29X1+/PNzYfL06+fFV8svz2sttuF+XHzUSRR
+        4dYPJPlVdSRd0xpi7exAS0/IFF1ni5PT5XE6m896onGKTJRVLU9P3LTRVk/n6fxkmi6ms7MXde20
+        pCAy+D4BAHjuvzFPq+inyCBNXpGGQsCKRPYWBCC8MxERGIIOjJZFMpLSWSbbp35bu66qOYMrsO4J
+        JFqo9IYAoYr5A9rwRB4gtxfaooHz/j+D59wC5GKDRqtcZFCiCZQMYEmk1igfI56LL84SuBK4JsCO
+        a+cDGB2YFGjbo4zhETyFzjCgJyi9a+CK0WyP4NyYA2VDNraY1BjpuCYP0nWWvaaQQOhkDRjgknyD
+        dpv0BnefEkCrhvPNUS5yu9vviaeyCxjnYjtj9gi01jHGS/tp3L8wu7f+G1e13q3Db1JRaqtDXXjC
+        4GzsdWDXip7dTQDu+zl3B6MTrXdNywW7R+qvWywXg58Y12tk370sgWDHaEb87PRVdeBXKGLUJuxt
+        ipAoa1KjdFwr7JR2e8Rkr+o/s/mb91C5ttX/2I+ElNQyqaL1pLQ8rHgM8xRf37/C3rrcJywC+Y2W
+        VLAmHyehqMTODG9ChG1gaopS24p86/XwMMq2SI+X87P5PF2mYrKb/AIAAP//AwD77a3iJgQAAA==
+    headers:
+      CF-RAY:
+      - 937ed6bd68faa435-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 29 Apr 2025 12:35:23 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '1138'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999072'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_2ba1be014a5974ba354aff564e26516a
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cassettes/test_task_guardrail_process_output.yaml

@@ -0,0 +1,250 @@
+interactions:
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are Guardrail Agent. You
+      are a expert at validating the output of a task. By providing effective feedback
+      if the output is not valid.\nYour personal goal is: Validate the output of the
+      task\n\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!\nIMPORTANT:
+      Your final answer MUST contain all the information requested in the following
+      format: {\n  \"valid\": bool,\n  \"feedback\": str | None\n}\n\nIMPORTANT: Ensure
+      the final output does not include any code block markers like ```json or ```python."},
+      {"role": "user", "content": "\n        Ensure the following task result complies
+      with the given guardrail.\n\n        Task result:\n        \n        Lorem Ipsum
+      is simply dummy text of the printing and typesetting industry. Lorem Ipsum has
+      been the industry''s standard dummy text ever\n        \n\n        Guardrail:\n        Ensure
+      the result has less than 10 words\n        \n        Your task:\n        - Confirm
+      if the Task result complies with the guardrail.\n        - If not, provide clear
+      feedback explaining what is wrong (e.g., by how much it violates the rule, or
+      what specific part fails).\n        - Focus only on identifying issues \u2014
+      do not propose corrections.\n        - If the Task result complies with the
+      guardrail, saying that is valid\n        "}], "model": "gpt-4o-mini", "stop":
+      ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '1629'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jFPLbtswELz7KxY824GkxLGtW4KiQB+XBmkRtAqENbmSmFAkQVJ2UsP/
+        HlByLKdNgV4IcGdnOPvgbgLApGA5MN5g4K1Vs+ub718rm324+5z+/CLt1dXD5fU3s1jd3Wx//GbT
+        yDDrB+LhlXXGTWsVBWn0AHNHGCiqpouL+XKVZum8B1ojSEVabcPswsxaqeUsS7KLWbKYpcsDuzGS
+        k2c5/JoAAOz6M/rUgp5YDsn0NdKS91gTy49JAMwZFSMMvZc+oA5sOoLc6EC6t37bmK5uQg6fQJst
+        cNRQyw0BQh39A2q/JQdQ6I9So4Kr/p7DrtAABdugkqJgOVSoPE2HYEUk1sgfY7xgtw1BQP8Ijnyn
+        AsTHUWoP6SVsjRN+CvTEiYTUNYSGoO7QCYdSgZKtDGAqqCiaCA1qSJOBBetnOAicFazQ+9MCHVWd
+        x9hk3Sl1AqDWJmAcUt/a+wOyPzZTmdo6s/Z/UFkltfRN6Qi90bFxPhjLenQ/Abjvh9a9mQOzzrQ2
+        lME8Uv/ceTIf9Ni4KyM6Tw9gMAHVCWt+OX1HrxQUUCp/MnbGkTckRuq4I9gJaU6AyUnVf7t5T3uo
+        XOr6f+RHgHOygURpHQnJ31Y8pjmKX+lfaccu94aZJ7eRnMogycVJCKqwU8OCM//sA7VlJXVNzjo5
+        bHlly+R8lS2zLFklbLKfvAAAAP//AwCHe/Jh8wMAAA==
+    headers:
+      CF-RAY:
+      - 937b20ddf9607def-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 29 Apr 2025 01:46:56 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - __cf_bm=nHa2kVJI_yO1RIsmZcEednJ1e9UVy1liv_sjBNtSj7Q-1745891216-1.0.1.1-jUH9kFawVBjnbq8sIL2.MQx.p7JvBZWUhqlkNKRlStWSgQxT0eZMPcgq9TCQoJAjuyNwhqfpK4HuX6x5n8UbQgAb6JrWJEG823e6GpGROEA;
+        path=/; expires=Tue, 29-Apr-25 02:16:56 GMT; domain=.api.openai.com; HttpOnly;
+        Secure; SameSite=None
+      - _cfuvid=gg2UeahMCOOR8YhitRtzDwENMOnTOuQdyTMVJVHG0Mg-1745891216085-0.0.1.1-604800000;
+        path=/; domain=.api.openai.com; HttpOnly; Secure; SameSite=None
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '896'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999631'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_859221ed1aedb26cc9d335004ccf183e
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages": [{"role": "system", "content": "You are Guardrail Agent. You
+      are a expert at validating the output of a task. By providing effective feedback
+      if the output is not valid.\nYour personal goal is: Validate the output of the
+      task\n\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!\nIMPORTANT:
+      Your final answer MUST contain all the information requested in the following
+      format: {\n  \"valid\": bool,\n  \"feedback\": str | None\n}\n\nIMPORTANT: Ensure
+      the final output does not include any code block markers like ```json or ```python."},
+      {"role": "user", "content": "\n        Ensure the following task result complies
+      with the given guardrail.\n\n        Task result:\n        \n        Lorem Ipsum
+      is simply dummy text of the printing and typesetting industry. Lorem Ipsum has
+      been the industry''s standard dummy text ever\n        \n\n        Guardrail:\n        Ensure
+      the result has less than 500 words\n        \n        Your task:\n        -
+      Confirm if the Task result complies with the guardrail.\n        - If not, provide
+      clear feedback explaining what is wrong (e.g., by how much it violates the rule,
+      or what specific part fails).\n        - Focus only on identifying issues \u2014
+      do not propose corrections.\n        - If the Task result complies with the
+      guardrail, saying that is valid\n        "}], "model": "gpt-4o-mini", "stop":
+      ["\nObservation:"]}'
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '1630'
+      content-type:
+      - application/json
+      cookie:
+      - __cf_bm=nHa2kVJI_yO1RIsmZcEednJ1e9UVy1liv_sjBNtSj7Q-1745891216-1.0.1.1-jUH9kFawVBjnbq8sIL2.MQx.p7JvBZWUhqlkNKRlStWSgQxT0eZMPcgq9TCQoJAjuyNwhqfpK4HuX6x5n8UbQgAb6JrWJEG823e6GpGROEA;
+        _cfuvid=gg2UeahMCOOR8YhitRtzDwENMOnTOuQdyTMVJVHG0Mg-1745891216085-0.0.1.1-604800000
+      host:
+      - api.openai.com
+      user-agent:
+      - OpenAI/Python 1.68.2
+      x-stainless-arch:
+      - arm64
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - MacOS
+      x-stainless-package-version:
+      - 1.68.2
+      x-stainless-raw-response:
+      - 'true'
+      x-stainless-read-timeout:
+      - '600.0'
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.12.9
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: !!binary |
+        H4sIAAAAAAAAAwAAAP//jJJNb9swDIbv/hWEzvHgfHRpfesOG3opsGE7LYXBSLStRZY0iU43BPnv
+        g5wPu10H7GLAfPhSfEkeMgChlShByBZZdt7kH758e1wzbnfbO6o/f1osV3T/+BO7UNNDIWZJ4bY/
+        SPJF9U66zhti7ewJy0DIlKrO16ub27v5srgZQOcUmSRrPOcrl3fa6nxRLFZ5sc7nt2d167SkKEr4
+        ngEAHIZv6tMq+iVKKGaXSEcxYkOivCYBiOBMigiMUUdGy2I2Qukskx1a/9q6vmm5hAew7hkkWmj0
+        ngChSf0D2vhMAWBjP2qLBu6H/xIOGwuwEXs0Wm1ECRx6mp1iNZHaotylsO2N2djj9PFAdR/RnOEE
+        oLWOMQ1wsP10JserUeMaH9w2vpKKWlsd2yoQRmeTqcjOi4EeM4CnYaD9ixkJH1znuWK3o+G583KG
+        4Vz2ONLF7RmyYzQT1XI5e6NepYhRmzhZiZAoW1KjdNwf9kq7Ccgmrv/u5q3aJ+faNv9TfgRSkmdS
+        lQ+ktHzpeEwLlM78X2nXKQ8Ni0hhryVVrCmkTSiqsTen4xPxd2TqqlrbhoIP+nSBta/SueD7QtWF
+        yI7ZHwAAAP//AwAiLXhqjwMAAA==
+    headers:
+      CF-RAY:
+      - 937b2311ee091b1b-GRU
+      Connection:
+      - keep-alive
+      Content-Encoding:
+      - gzip
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 29 Apr 2025 01:48:26 GMT
+      Server:
+      - cloudflare
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - nosniff
+      access-control-expose-headers:
+      - X-Request-ID
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - crewai-iuxna1
+      openai-processing-ms:
+      - '610'
+      openai-version:
+      - '2020-10-01'
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      x-ratelimit-limit-requests:
+      - '30000'
+      x-ratelimit-limit-tokens:
+      - '150000000'
+      x-ratelimit-remaining-requests:
+      - '29999'
+      x-ratelimit-remaining-tokens:
+      - '149999631'
+      x-ratelimit-reset-requests:
+      - 2ms
+      x-ratelimit-reset-tokens:
+      - 0s
+      x-request-id:
+      - req_c136835c16be6bc1e4d820f239c4b620
+    status:
+      code: 200
+      message: OK
+version: 1

tests/cli/deploy/__init__.py

@@ -0,0 +1 @@
+"""Tests for CLI deploy."""

tests/config/tasks.yaml

@@ -6,6 +6,7 @@ research_task:
   expected_output: >
     A list with 10 bullet points of the most relevant information about {topic}
   agent: researcher
+  guardrail: ensure each bullet contains its source
 
 reporting_task:
   description: >

tests/llm_test.py

@@ -256,6 +256,52 @@ def test_validate_call_params_no_response_format():
     llm._validate_call_params()
 
 
+@pytest.mark.vcr(filter_headers=["authorization"], filter_query_parameters=["key"])
+@pytest.mark.parametrize(
+    "model",
+    [
+        "gemini/gemini-2.0-flash-thinking-exp-01-21",
+        "gemini/gemini-2.0-flash-001",
+        "gemini/gemini-2.0-flash-lite-001",
+        "gemini/gemini-2.5-flash-preview-04-17",
+        "gemini/gemini-2.5-pro-exp-03-25",
+    ],
+)
+def test_gemini_models(model):
+    llm = LLM(model=model)
+    result = llm.call("What is the capital of France?")
+    assert isinstance(result, str)
+    assert "Paris" in result
+
+
+@pytest.mark.vcr(filter_headers=["authorization"], filter_query_parameters=["key"])
+@pytest.mark.parametrize(
+    "model",
+    [
+        "gemini/gemma-3-1b-it",
+        "gemini/gemma-3-4b-it",
+        "gemini/gemma-3-12b-it",
+        "gemini/gemma-3-27b-it",
+    ],
+)
+def test_gemma3(model):
+    llm = LLM(model=model)
+    result = llm.call("What is the capital of France?")
+    assert isinstance(result, str)
+    assert "Paris" in result
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+@pytest.mark.parametrize(
+    "model", ["gpt-4.1", "gpt-4.1-mini-2025-04-14", "gpt-4.1-nano-2025-04-14"]
+)
+def test_gpt_4_1(model):
+    llm = LLM(model=model)
+    result = llm.call("What is the capital of France?")
+    assert isinstance(result, str)
+    assert "Paris" in result
+
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_o3_mini_reasoning_effort_high():
     llm = LLM(
@@ -327,6 +373,45 @@ def get_weather_tool_schema():
         },
     }
 
+def test_context_window_exceeded_error_handling():
+    """Test that litellm.ContextWindowExceededError is converted to LLMContextLengthExceededException."""
+    from litellm.exceptions import ContextWindowExceededError
+
+    from crewai.utilities.exceptions.context_window_exceeding_exception import (
+        LLMContextLengthExceededException,
+    )
+
+    llm = LLM(model="gpt-4")
+
+    # Test non-streaming response
+    with patch("litellm.completion") as mock_completion:
+        mock_completion.side_effect = ContextWindowExceededError(
+            "This model's maximum context length is 8192 tokens. However, your messages resulted in 10000 tokens.",
+            model="gpt-4",
+            llm_provider="openai"
+        )
+
+        with pytest.raises(LLMContextLengthExceededException) as excinfo:
+            llm.call("This is a test message")
+
+        assert "context length exceeded" in str(excinfo.value).lower()
+        assert "8192 tokens" in str(excinfo.value)
+
+    # Test streaming response
+    llm = LLM(model="gpt-4", stream=True)
+    with patch("litellm.completion") as mock_completion:
+        mock_completion.side_effect = ContextWindowExceededError(
+            "This model's maximum context length is 8192 tokens. However, your messages resulted in 10000 tokens.",
+            model="gpt-4",
+            llm_provider="openai"
+        )
+
+        with pytest.raises(LLMContextLengthExceededException) as excinfo:
+            llm.call("This is a test message")
+
+        assert "context length exceeded" in str(excinfo.value).lower()
+        assert "8192 tokens" in str(excinfo.value)
+
 
 @pytest.mark.vcr(filter_headers=["authorization"])
 @pytest.fixture

tests/memory/__init__.py

@@ -0,0 +1 @@
+"""Tests for memory."""

tests/memory/user_memory_test.py

@@ -1,4 +1,3 @@
-
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -65,4 +64,4 @@ def test_save_and_search(user_memory):
     with patch.object(UserMemory, 'search', return_value=expected_result) as mock_search:
         find = UserMemory.search("test value", score_threshold=0.01)[0]
         mock_search.assert_called_once_with("test value", score_threshold=0.01)
-        assert find == expected_result[0]
+        assert find == expected_result[0]

tests/project_test.py

@@ -1,4 +1,5 @@
 from typing import List
+from unittest.mock import patch
 
 import pytest
 
@@ -142,6 +143,15 @@ def test_agent_function_calling_llm():
     ), "agent's function_calling_llm is incorrect"
 
 
+def test_task_guardrail():
+    crew = InternalCrew()
+    research_task = crew.research_task()
+    assert research_task.guardrail == "ensure each bullet contains its source"
+
+    reporting_task = crew.reporting_task()
+    assert reporting_task.guardrail is None
+
+
 @pytest.mark.vcr(filter_headers=["authorization"])
 def test_before_kickoff_modification():
     crew = InternalCrew()

tests/storage/__init__.py

@@ -0,0 +1 @@
+"""Tests for storage."""

tests/storage/test_mem0_storage.py

@@ -15,6 +15,7 @@ from crewai.task import Task
 class MockCrew:
     def __init__(self, memory_config):
         self.memory_config = memory_config
+        self.agents = [MagicMock(role="Test Agent")]
 
 
 @pytest.fixture
@@ -107,11 +108,13 @@ def mem0_storage_with_memory_client_using_config_from_crew(mock_mem0_memory_clie
 
 
 @pytest.fixture
-def mem0_storage_with_memory_client_using_explictly_config(mock_mem0_memory_client):
+def mem0_storage_with_memory_client_using_explictly_config(mock_mem0_memory_client, mock_mem0_memory):
     """Fixture to create a Mem0Storage instance with mocked dependencies"""
 
-    # We need to patch the MemoryClient before it's instantiated
-    with patch.object(MemoryClient, "__new__", return_value=mock_mem0_memory_client):
+    # We need to patch both MemoryClient and Memory to prevent actual initialization
+    with patch.object(MemoryClient, "__new__", return_value=mock_mem0_memory_client), \
+         patch.object(Memory, "__new__", return_value=mock_mem0_memory):
+
         crew = MockCrew(
             memory_config={
                 "provider": "mem0",
@@ -155,3 +158,82 @@ def test_mem0_storage_with_explict_config(
         mem0_storage_with_memory_client_using_explictly_config.memory_config
         == expected_config
     )
+
+
+def test_save_method_with_memory_oss(mem0_storage_with_mocked_config):
+    """Test save method for different memory types"""
+    mem0_storage, _, _ = mem0_storage_with_mocked_config
+    mem0_storage.memory.add = MagicMock()
+    
+    # Test short_term memory type (already set in fixture)
+    test_value = "This is a test memory"
+    test_metadata = {"key": "value"}
+    
+    mem0_storage.save(test_value, test_metadata)
+    
+    mem0_storage.memory.add.assert_called_once_with(
+        test_value,
+        agent_id="Test_Agent",
+        infer=False,
+        metadata={"type": "short_term", "key": "value"},
+    )
+
+
+def test_save_method_with_memory_client(mem0_storage_with_memory_client_using_config_from_crew):
+    """Test save method for different memory types"""
+    mem0_storage = mem0_storage_with_memory_client_using_config_from_crew
+    mem0_storage.memory.add = MagicMock()
+    
+    # Test short_term memory type (already set in fixture)
+    test_value = "This is a test memory"
+    test_metadata = {"key": "value"}
+    
+    mem0_storage.save(test_value, test_metadata)
+    
+    mem0_storage.memory.add.assert_called_once_with(
+        test_value,
+        agent_id="Test_Agent",
+        infer=False,
+        metadata={"type": "short_term", "key": "value"},
+        output_format="v1.1"
+    )
+
+
+def test_search_method_with_memory_oss(mem0_storage_with_mocked_config):
+    """Test search method for different memory types"""
+    mem0_storage, _, _ = mem0_storage_with_mocked_config
+    mock_results = {"results": [{"score": 0.9, "content": "Result 1"}, {"score": 0.4, "content": "Result 2"}]}
+    mem0_storage.memory.search = MagicMock(return_value=mock_results)
+
+    results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
+
+    mem0_storage.memory.search.assert_called_once_with(
+        query="test query", 
+        limit=5, 
+        agent_id="Test_Agent",
+        user_id="test_user"
+    )
+
+    assert len(results) == 1
+    assert results[0]["content"] == "Result 1"
+
+
+def test_search_method_with_memory_client(mem0_storage_with_memory_client_using_config_from_crew):
+    """Test search method for different memory types"""
+    mem0_storage = mem0_storage_with_memory_client_using_config_from_crew
+    mock_results = {"results": [{"score": 0.9, "content": "Result 1"}, {"score": 0.4, "content": "Result 2"}]}
+    mem0_storage.memory.search = MagicMock(return_value=mock_results)
+
+    results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
+
+    mem0_storage.memory.search.assert_called_once_with(
+        query="test query", 
+        limit=5, 
+        agent_id="Test_Agent", 
+        metadata={"type": "short_term"},
+        user_id="test_user",
+        output_format='v1.1'
+    )
+
+    assert len(results) == 1
+    assert results[0]["content"] == "Result 1"

tests/test_task_guardrails.py

@@ -1,11 +1,16 @@
-"""Tests for task guardrails functionality."""
-
-from unittest.mock import Mock
+from unittest.mock import ANY, Mock, patch
 
 import pytest
 
-from crewai.task import Task
+from crewai import Agent, Task
+from crewai.llm import LLM
+from crewai.tasks.task_guardrail import TaskGuardrail
 from crewai.tasks.task_output import TaskOutput
+from crewai.utilities.events import (
+    TaskGuardrailCompletedEvent,
+    TaskGuardrailStartedEvent,
+)
+from crewai.utilities.events.crewai_event_bus import crewai_event_bus
 
 
 def test_task_without_guardrail():
@@ -22,7 +27,7 @@ def test_task_without_guardrail():
     assert result.raw == "test result"
 
 
-def test_task_with_successful_guardrail():
+def test_task_with_successful_guardrail_func():
     """Test that successful guardrail validation passes transformed result."""
 
     def guardrail(result: TaskOutput):
@@ -127,3 +132,138 @@ def test_guardrail_error_in_context():
 
     assert "Task failed guardrail validation" in str(exc_info.value)
     assert "Expected JSON, got string" in str(exc_info.value)
+
+
+@pytest.fixture
+def sample_agent():
+    return Agent(role="Test Agent", goal="Test Goal", backstory="Test Backstory")
+
+
+@pytest.fixture
+def task_output():
+    return TaskOutput(
+        raw="""
+        Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever
+        """,
+        description="Test task",
+        expected_output="Output",
+        agent="Test Agent",
+    )
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_task_guardrail_process_output(task_output):
+    guardrail = TaskGuardrail(
+        description="Ensure the result has less than 10 words", llm=LLM(model="gpt-4o")
+    )
+
+    result = guardrail(task_output)
+    assert result[0] is False
+
+    assert "exceeding the guardrail limit of fewer than" in result[1].lower()
+
+    guardrail = TaskGuardrail(
+        description="Ensure the result has less than 500 words", llm=LLM(model="gpt-4o")
+    )
+
+    result = guardrail(task_output)
+    assert result[0] is True
+    assert result[1] == task_output.raw
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_guardrail_emits_events(sample_agent):
+    started_guardrail = []
+    completed_guardrail = []
+
+    with crewai_event_bus.scoped_handlers():
+
+        @crewai_event_bus.on(TaskGuardrailStartedEvent)
+        def handle_guardrail_started(source, event):
+            started_guardrail.append(
+                {"guardrail": event.guardrail, "retry_count": event.retry_count}
+            )
+
+        @crewai_event_bus.on(TaskGuardrailCompletedEvent)
+        def handle_guardrail_completed(source, event):
+            completed_guardrail.append(
+                {
+                    "success": event.success,
+                    "result": event.result,
+                    "error": event.error,
+                    "retry_count": event.retry_count,
+                }
+            )
+
+        task = Task(
+            description="Gather information about available books on the First World War",
+            agent=sample_agent,
+            expected_output="A list of available books on the First World War",
+            guardrail="Ensure the authors are from Italy",
+        )
+
+        result = task.execute_sync(agent=sample_agent)
+
+        def custom_guardrail(result: TaskOutput):
+            return (True, "good result from callable function")
+
+        task = Task(
+            description="Test task",
+            expected_output="Output",
+            guardrail=custom_guardrail,
+        )
+
+        task.execute_sync(agent=sample_agent)
+
+        expected_started_events = [
+            {"guardrail": "Ensure the authors are from Italy", "retry_count": 0},
+            {"guardrail": "Ensure the authors are from Italy", "retry_count": 1},
+            {
+                "guardrail": """def custom_guardrail(result: TaskOutput):
+            return (True, "good result from callable function")""",
+                "retry_count": 0,
+            },
+        ]
+
+        expected_completed_events = [
+            {
+                "success": False,
+                "result": None,
+                "error": "The task result does not comply with the guardrail because none of "
+                "the listed authors are from Italy. All authors mentioned are from "
+                "different countries, including Germany, the UK, the USA, and others, "
+                "which violates the requirement that authors must be Italian.",
+                "retry_count": 0,
+            },
+            {"success": True, "result": result.raw, "error": None, "retry_count": 1},
+            {
+                "success": True,
+                "result": "good result from callable function",
+                "error": None,
+                "retry_count": 0,
+            },
+        ]
+        assert started_guardrail == expected_started_events
+        assert completed_guardrail == expected_completed_events
+
+
+@pytest.mark.vcr(filter_headers=["authorization"])
+def test_guardrail_when_an_error_occurs(sample_agent, task_output):
+    with (
+        patch(
+            "crewai.Agent.kickoff",
+            side_effect=Exception("Unexpected error"),
+        ),
+        pytest.raises(
+            Exception,
+            match="Error while validating the task output: Unexpected error",
+        ),
+    ):
+        task = Task(
+            description="Gather information about available books on the First World War",
+            agent=sample_agent,
+            expected_output="A list of available books on the First World War",
+            guardrail="Ensure the authors are from Italy",
+            max_retries=0,
+        )
+        task.execute_sync(agent=sample_agent)

tests/tools/__init__.py

@@ -0,0 +1 @@
+"""Tests for tools."""

tests/utilities/__init__.py

@@ -0,0 +1 @@
+"""Tests for utilities."""