Merge branch 'main' of github.com:crewAIInc/crewAI into lorenze/feat/plan-execute-pattern

* feat: introduce PlanningConfig for enhanced agent planning capabilities

This update adds a new PlanningConfig class to manage agent planning configurations, allowing for customizable planning behavior before task execution. The existing reasoning parameter is deprecated in favor of this new configuration, ensuring backward compatibility while enhancing the planning process. Additionally, the Agent class has been updated to utilize this new configuration, and relevant utility functions have been adjusted accordingly. Tests have been added to validate the new planning functionality and ensure proper integration with existing agent workflows.

* dropping redundancy

* fix test

* revert handle_reasoning here

* refactor: update reasoning handling in Agent class

This commit modifies the Agent class to conditionally call the handle_reasoning function based on the executor class being used. The legacy CrewAgentExecutor will continue to utilize handle_reasoning, while the new AgentExecutor will manage planning internally. Additionally, the PlanningConfig class has been referenced in the documentation to clarify its role in enabling or disabling planning. Tests have been updated to reflect these changes and ensure proper functionality.

* improve planning prompts

* matching

* refactor: remove default enabled flag from PlanningConfig in Agent class

* more cassettes

* fix test

* feat: enhance agent planning with structured todo management

This commit introduces a new planning system within the AgentExecutor class, allowing for the creation of structured todo items from planning steps. The TodoList and TodoItem models have been added to facilitate tracking of plan execution. The reasoning plan now includes a list of steps, improving the clarity and organization of agent tasks. Additionally, tests have been added to validate the new planning functionality and ensure proper integration with existing workflows.

* refactor: update planning prompt and remove deprecated methods in reasoning handler

* improve planning prompt

* improve handler

* linted

* linted

.env.test

@@ -21,6 +21,7 @@ OPENROUTER_API_KEY=fake-openrouter-key
 AWS_ACCESS_KEY_ID=fake-aws-access-key
 AWS_SECRET_ACCESS_KEY=fake-aws-secret-key
 AWS_DEFAULT_REGION=us-east-1
+AWS_REGION_NAME=us-east-1
 
 # -----------------------------------------------------------------------------
 # Azure OpenAI Configuration

.github/workflows/pr-size.yml

@@ -1,37 +0,0 @@
-name: PR Size Check
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened]
-
-jobs:
-  pr-size:
-    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    steps:
-      - uses: codelytv/pr-size-labeler@v1
-        with:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          xs_label: "size/XS"
-          xs_max_size: 25
-          s_label: "size/S"
-          s_max_size: 100
-          m_label: "size/M"
-          m_max_size: 250
-          l_label: "size/L"
-          l_max_size: 500
-          xl_label: "size/XL"
-          fail_if_xl: true
-          message_if_xl: >
-            This PR exceeds 500 lines changed and has been labeled `size/XL`.
-            PRs of this size require release manager approval to merge.
-            Please consider splitting into smaller PRs, or add a justification
-            in the PR description for why this cannot be broken up.
-          files_to_ignore: |
-            uv.lock
-            *.lock
-            lib/crewai/src/crewai/cli/templates/**
-            **/*.json
-            **/test_durations/**
-            **/cassettes/**

.github/workflows/pr-title.yml

@@ -1,38 +0,0 @@
-name: PR Title Check
-
-on:
-  pull_request:
-    types: [opened, edited, synchronize, reopened]
-
-jobs:
-  pr-title:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: amannn/action-semantic-pull-request@v5
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          types: |
-            feat
-            fix
-            refactor
-            perf
-            test
-            docs
-            chore
-            ci
-            style
-            revert
-          requireScope: false
-          subjectPattern: ^[a-z].+[^.]$
-          subjectPatternError: >
-            The PR title "{title}" does not follow conventional commit format.
-
-            Expected: <type>(<scope>): <lowercase description without trailing period>
-
-            Examples:
-              feat(memory): add lancedb storage backend
-              fix(agents): resolve deadlock in concurrent execution
-              chore(deps): bump pydantic to 2.11.9
-
-            See RELEASE_PROCESS.md for the full commit message convention.

.github/workflows/publish.yml

@@ -1,6 +1,8 @@
 name: Publish to PyPI
 
 on:
+  repository_dispatch:
+    types: [deployment-tests-passed]
   workflow_dispatch:
     inputs:
       release_tag:
@@ -18,8 +20,11 @@ jobs:
       - name: Determine release tag
         id: release
         run: |
+          # Priority: workflow_dispatch input > repository_dispatch payload > default branch
           if [ -n "${{ inputs.release_tag }}" ]; then
             echo "tag=${{ inputs.release_tag }}" >> $GITHUB_OUTPUT
+          elif [ -n "${{ github.event.client_payload.release_tag }}" ]; then
+            echo "tag=${{ github.event.client_payload.release_tag }}" >> $GITHUB_OUTPUT
           else
             echo "tag=" >> $GITHUB_OUTPUT
           fi

.github/workflows/trigger-deployment-tests.yml

@@ -0,0 +1,18 @@
+name: Trigger Deployment Tests
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  trigger:
+    name: Trigger deployment tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger deployment tests
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.CREWAI_DEPLOYMENTS_PAT }}
+          repository: ${{ secrets.CREWAI_DEPLOYMENTS_REPOSITORY }}
+          event-type: crewai-release
+          client-payload: '{"release_tag": "${{ github.event.release.tag_name }}", "release_name": "${{ github.event.release.name }}"}'

docs/en/changelog.mdx

@@ -4,106 +4,6 @@ description: "Product updates, improvements, and bug fixes for CrewAI"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="Feb 27, 2026">
-  ## v1.10.1a1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## What's Changed
-
-  ### Features
-  - Implement asynchronous invocation support in step callback methods
-  - Implement lazy loading for heavy dependencies in Memory module
-
-  ### Documentation
-  - Update changelog and version for v1.10.0
-
-  ### Refactoring
-  - Refactor step callback methods to support asynchronous invocation
-  - Refactor to implement lazy loading for heavy dependencies in Memory module
-
-  ### Bug Fixes
-  - Fix branch for release notes
-
-  ## Contributors
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="Feb 27, 2026">
-  ## v1.10.1a1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## What's Changed
-
-  ### Refactoring
-  - Refactor step callback methods to support asynchronous invocation
-  - Implement lazy loading for heavy dependencies in Memory module
-
-  ### Documentation
-  - Update changelog and version for v1.10.0
-
-  ### Bug Fixes
-  - Make branch for release notes
-
-  ## Contributors
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="Feb 26, 2026">
-  ## v1.10.0
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.0)
-
-  ## What's Changed
-
-  ### Features
-  - Enhance MCP tool resolution and related events
-  - Update lancedb version and add lance-namespace packages
-  - Enhance JSON argument parsing and validation in CrewAgentExecutor and BaseTool
-  - Migrate CLI HTTP client from requests to httpx
-  - Add versioned documentation
-  - Add yanked detection for version notes
-  - Implement user input handling in Flows
-  - Enhance HITL self-loop functionality in human feedback integration tests
-  - Add started_event_id and set in eventbus
-  - Auto update tools.specs
-
-  ### Bug Fixes
-  - Validate tool kwargs even when empty to prevent cryptic TypeError
-  - Preserve null types in tool parameter schemas for LLM
-  - Map output_pydantic/output_json to native structured output
-  - Ensure callbacks are ran/awaited if promise
-  - Capture method name in exception context
-  - Preserve enum type in router result; improve types
-  - Fix cyclic flows silently breaking when persistence ID is passed in inputs
-  - Correct CLI flag format from --skip-provider to --skip_provider
-  - Ensure OpenAI tool call stream is finalized
-  - Resolve complex schema $ref pointers in MCP tools
-  - Enforce additionalProperties=false in schemas
-  - Reject reserved script names for crew folders
-  - Resolve race condition in guardrail event emission test
-
-  ### Documentation
-  - Add litellm dependency note for non-native LLM providers
-  - Clarify NL2SQL security model and hardening guidance
-  - Add 96 missing actions across 9 integrations
-
-  ### Refactoring
-  - Refactor crew to provider
-  - Extract HITL to provider pattern
-  - Improve hook typing and registration
-
-  ## Contributors
-
-  @dependabot[bot], @github-actions[bot], @github-code-quality[bot], @greysonlalonde, @heitorado, @hobostay, @joaomdmoura, @johnvan7, @jonathansampson, @lorenzejay, @lucasgomide, @mattatcha, @mplachta, @nicoferdi96, @theCyberTech, @thiagomoretto, @vinibrsl
-
-</Update>
-
 <Update label="Jan 26, 2026">
   ## v1.9.0
 

docs/en/concepts/llms.mdx

@@ -106,15 +106,6 @@ There are different places in CrewAI code where you can specify the model to use
   </Tab>
 </Tabs>
 
-<Info>
-  CrewAI provides native SDK integrations for OpenAI, Anthropic, Google (Gemini API), Azure, and AWS Bedrock — no extra install needed beyond the provider-specific extras (e.g. `uv add "crewai[openai]"`).
-
-  All other providers are powered by **LiteLLM**. If you plan to use any of them, add it as a dependency to your project:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-</Info>
-
 ## Provider Configuration Examples
 
 CrewAI supports a multitude of LLM providers, each offering unique features, authentication methods, and model capabilities.
@@ -284,11 +275,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | Text, Image | Text |
     | `meta_llama/Llama-3.3-70B-Instruct` | 128k | 4028 | Text | Text |
     | `meta_llama/Llama-3.3-8B-Instruct` | 128k | 4028 | Text | Text |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Anthropic">
@@ -484,7 +470,7 @@ In this section, you'll find detailed examples that help you select, configure,
       To get an Express mode API key:
       - New Google Cloud users: Get an [express mode API key](https://cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey)
       - Existing Google Cloud users: Get a [Google Cloud API key bound to a service account](https://cloud.google.com/docs/authentication/api-keys)
-
+      
       For more details, see the [Vertex AI Express mode documentation](https://docs.cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey).
     </Info>
 
@@ -585,11 +571,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | gemini-1.5-flash               | 1M tokens      | Balanced multimodal model, good for most tasks                    |
     | gemini-1.5-flash-8B            | 1M tokens      | Fastest, most cost-efficient, good for high-frequency tasks       |
     | gemini-1.5-pro                 | 2M tokens      | Best performing, wide variety of reasoning tasks including logical reasoning, coding, and creative collaboration |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Azure">
@@ -671,7 +652,6 @@ In this section, you'll find detailed examples that help you select, configure,
     # Optional
     AWS_SESSION_TOKEN=<your-session-token>  # For temporary credentials
     AWS_DEFAULT_REGION=<your-region>  # Defaults to us-east-1
-    AWS_REGION_NAME=<your-region>  # Alternative configuration for backwards compatibility with LiteLLM. Defaults to us-east-1
     ```
 
     **Basic Usage:**
@@ -715,7 +695,6 @@ In this section, you'll find detailed examples that help you select, configure,
     - `AWS_SECRET_ACCESS_KEY`: AWS secret key (required)
     - `AWS_SESSION_TOKEN`: AWS session token for temporary credentials (optional)
     - `AWS_DEFAULT_REGION`: AWS region (defaults to `us-east-1`)
-    - `AWS_REGION_NAME`: AWS region (defaults to `us-east-1`). Alternative configuration for backwards compatibility with LiteLLM
 
     **Features:**
     - Native tool calling support via Converse API
@@ -785,11 +764,6 @@ In this section, you'll find detailed examples that help you select, configure,
         model="sagemaker/<my-endpoint>"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Mistral">
@@ -805,11 +779,6 @@ In this section, you'll find detailed examples that help you select, configure,
         temperature=0.7
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nvidia NIM">
@@ -896,11 +865,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | rakuten/rakutenai-7b-instruct                                     | 1,024 tokens   | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
     | rakuten/rakutenai-7b-chat                                         | 1,024 tokens   | Advanced state-of-the-art LLM with language understanding, superior reasoning, and text generation. |
     | baichuan-inc/baichuan2-13b-chat                                  | 4,096 tokens   | Support Chinese and English chat, coding, math, instruction following, solving quizzes |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Local NVIDIA NIM Deployed using WSL2">
@@ -941,11 +905,6 @@ In this section, you'll find detailed examples that help you select, configure,
 
         # ...
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Groq">
@@ -967,11 +926,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | Llama 3.1 70B/8B  | 131,072 tokens   | High-performance, large context tasks      |
     | Llama 3.2 Series  | 8,192 tokens     | General-purpose tasks                      |
     | Mixtral 8x7B      | 32,768 tokens    | Balanced performance and context           |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="IBM watsonx.ai">
@@ -994,11 +948,6 @@ In this section, you'll find detailed examples that help you select, configure,
         base_url="https://api.watsonx.ai/v1"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Ollama (Local LLMs)">
@@ -1012,11 +961,6 @@ In this section, you'll find detailed examples that help you select, configure,
         base_url="http://localhost:11434"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Fireworks AI">
@@ -1032,11 +976,6 @@ In this section, you'll find detailed examples that help you select, configure,
         temperature=0.7
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Perplexity AI">
@@ -1052,11 +991,6 @@ In this section, you'll find detailed examples that help you select, configure,
         base_url="https://api.perplexity.ai/"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Hugging Face">
@@ -1071,11 +1005,6 @@ In this section, you'll find detailed examples that help you select, configure,
         model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
     )
     ```
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="SambaNova">
@@ -1099,11 +1028,6 @@ In this section, you'll find detailed examples that help you select, configure,
     | Llama 3.2 Series   | 8,192 tokens           | General-purpose, multimodal tasks            |
     | Llama 3.3 70B      | Up to 131,072 tokens   | High-performance and output quality          |
     | Qwen2 familly      | 8,192 tokens           | High-performance and output quality          |
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Cerebras">
@@ -1129,11 +1053,6 @@ In this section, you'll find detailed examples that help you select, configure,
       - Good balance of speed and quality
       - Support for long context windows
     </Info>
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Open Router">
@@ -1156,11 +1075,6 @@ In this section, you'll find detailed examples that help you select, configure,
       - openrouter/deepseek/deepseek-r1
       - openrouter/deepseek/deepseek-chat
     </Info>
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nebius AI Studio">
@@ -1183,11 +1097,6 @@ In this section, you'll find detailed examples that help you select, configure,
       - Competitive pricing
       - Good balance of speed and quality
     </Info>
-
-    **Note:** This provider uses LiteLLM. Add it as a dependency to your project:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 </AccordionGroup>
 

docs/en/enterprise/guides/deploy-to-amp.mdx

@@ -177,11 +177,6 @@ You need to push your crew to a GitHub repository. If you haven't created a crew
       ![Set Environment Variables](/images/enterprise/set-env-variables.png)
     </Frame>
 
-    <Info>
-      Using private Python packages? You'll need to add your registry credentials here too.
-      See [Private Package Registries](/en/enterprise/guides/private-package-registry) for the required variables.
-    </Info>
-
   </Step>
 
   <Step title="Deploy Your Crew">

docs/en/enterprise/guides/prepare-for-deployment.mdx

@@ -256,12 +256,6 @@ Before deployment, ensure you have:
 1. **LLM API keys** ready (OpenAI, Anthropic, Google, etc.)
 2. **Tool API keys** if using external tools (Serper, etc.)
 
-<Info>
-  If your project depends on packages from a **private PyPI registry**, you'll also need to configure
-  registry authentication credentials as environment variables. See the
-  [Private Package Registries](/en/enterprise/guides/private-package-registry) guide for details.
-</Info>
-
 <Tip>
   Test your project locally with the same environment variables before deploying
   to catch configuration issues early.

docs/en/enterprise/guides/private-package-registry.mdx

@@ -1,263 +0,0 @@
----
-title: "Private Package Registries"
-description: "Install private Python packages from authenticated PyPI registries in CrewAI AMP"
-icon: "lock"
-mode: "wide"
----
-
-<Note>
-  This guide covers how to configure your CrewAI project to install Python packages
-  from private PyPI registries (Azure DevOps Artifacts, GitHub Packages, GitLab, AWS CodeArtifact, etc.)
-  when deploying to CrewAI AMP.
-</Note>
-
-## When You Need This
-
-If your project depends on internal or proprietary Python packages hosted on a private registry
-rather than the public PyPI, you'll need to:
-
-1. Tell UV **where** to find the package (an index URL)
-2. Tell UV **which** packages come from that index (a source mapping)
-3. Provide **credentials** so UV can authenticate during install
-
-CrewAI AMP uses [UV](https://docs.astral.sh/uv/) for dependency resolution and installation.
-UV supports authenticated private registries through `pyproject.toml` configuration combined
-with environment variables for credentials.
-
-## Step 1: Configure pyproject.toml
-
-Three pieces work together in your `pyproject.toml`:
-
-### 1a. Declare the dependency
-
-Add the private package to your `[project.dependencies]` like any other dependency:
-
-```toml
-[project]
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-```
-
-### 1b. Define the index
-
-Register your private registry as a named index under `[[tool.uv.index]]`:
-
-```toml
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-```
-
-<Info>
-  The `name` field is important — UV uses it to construct the environment variable names
-  for authentication (see [Step 2](#step-2-set-authentication-credentials) below).
-
-  Setting `explicit = true` means UV won't search this index for every package — only the
-  ones you explicitly map to it in `[tool.uv.sources]`. This avoids unnecessary queries
-  against your private registry and protects against dependency confusion attacks.
-</Info>
-
-### 1c. Map the package to the index
-
-Tell UV which packages should be resolved from your private index using `[tool.uv.sources]`:
-
-```toml
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-### Complete example
-
-```toml
-[project]
-name = "my-crew-project"
-version = "0.1.0"
-requires-python = ">=3.10,<=3.13"
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-
-[tool.crewai]
-type = "crew"
-
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-After updating `pyproject.toml`, regenerate your lock file:
-
-```bash
-uv lock
-```
-
-<Warning>
-  Always commit the updated `uv.lock` along with your `pyproject.toml` changes.
-  The lock file is required for deployment — see [Prepare for Deployment](/en/enterprise/guides/prepare-for-deployment).
-</Warning>
-
-## Step 2: Set Authentication Credentials
-
-UV authenticates against private indexes using environment variables that follow a naming convention
-based on the index name you defined in `pyproject.toml`:
-
-```
-UV_INDEX_{UPPER_NAME}_USERNAME
-UV_INDEX_{UPPER_NAME}_PASSWORD
-```
-
-Where `{UPPER_NAME}` is your index name converted to **uppercase** with **hyphens replaced by underscores**.
-
-For example, an index named `my-private-registry` uses:
-
-| Variable | Value |
-|----------|-------|
-| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | Your registry username or token name |
-| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | Your registry password or token/PAT |
-
-<Warning>
-  These environment variables **must** be added via the CrewAI AMP **Environment Variables** settings —
-  either globally or at the deployment level. They cannot be set in `.env` files or hardcoded in your project.
-
-  See [Setting Environment Variables in AMP](#setting-environment-variables-in-amp) below.
-</Warning>
-
-## Registry Provider Reference
-
-The table below shows the index URL format and credential values for common registry providers.
-Replace placeholder values with your actual organization and feed details.
-
-| Provider | Index URL | Username | Password |
-|----------|-----------|----------|----------|
-| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | Any non-empty string (e.g. `token`) | Personal Access Token (PAT) with Packaging Read scope |
-| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | GitHub username | Personal Access Token (classic) with `read:packages` scope |
-| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | Project or Personal Access Token with `read_api` scope |
-| **AWS CodeArtifact** | Use the URL from `aws codeartifact get-repository-endpoint` | `aws` | Token from `aws codeartifact get-authorization-token` |
-| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | Base64-encoded service account key |
-| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | Username or email | API key or identity token |
-| **Self-hosted (devpi, Nexus, etc.)** | Your registry's simple API URL | Registry username | Registry password |
-
-<Tip>
-  For **AWS CodeArtifact**, the authorization token expires periodically.
-  You'll need to refresh the `UV_INDEX_*_PASSWORD` value when it expires.
-  Consider automating this in your CI/CD pipeline.
-</Tip>
-
-## Setting Environment Variables in AMP
-
-Private registry credentials must be configured as environment variables in CrewAI AMP.
-You have two options:
-
-<Tabs>
-  <Tab title="Web Interface">
-    1. Log in to [CrewAI AMP](https://app.crewai.com)
-    2. Navigate to your automation
-    3. Open the **Environment Variables** tab
-    4. Add each variable (`UV_INDEX_*_USERNAME` and `UV_INDEX_*_PASSWORD`) with its value
-
-    See the [Deploy to AMP — Set Environment Variables](/en/enterprise/guides/deploy-to-amp#set-environment-variables) step for details.
-  </Tab>
-  <Tab title="CLI Deployment">
-    Add the variables to your local `.env` file before running `crewai deploy create`.
-    The CLI will securely transfer them to the platform:
-
-    ```bash
-    # .env
-    OPENAI_API_KEY=sk-...
-    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
-    ```
-
-    ```bash
-    crewai deploy create
-    ```
-  </Tab>
-</Tabs>
-
-<Warning>
-  **Never** commit credentials to your repository. Use AMP environment variables for all secrets.
-  The `.env` file should be listed in `.gitignore`.
-</Warning>
-
-To update credentials on an existing deployment, see [Update Your Crew — Environment Variables](/en/enterprise/guides/update-crew).
-
-## How It All Fits Together
-
-When CrewAI AMP builds your automation, the resolution flow works like this:
-
-<Steps>
-  <Step title="Build starts">
-    AMP pulls your repository and reads `pyproject.toml` and `uv.lock`.
-  </Step>
-  <Step title="UV resolves dependencies">
-    UV reads `[tool.uv.sources]` to determine which index each package should come from.
-  </Step>
-  <Step title="UV authenticates">
-    For each private index, UV looks up `UV_INDEX_{NAME}_USERNAME` and `UV_INDEX_{NAME}_PASSWORD`
-    from the environment variables you configured in AMP.
-  </Step>
-  <Step title="Packages install">
-    UV downloads and installs all packages — both public (from PyPI) and private (from your registry).
-  </Step>
-  <Step title="Automation runs">
-    Your crew or flow starts with all dependencies available.
-  </Step>
-</Steps>
-
-## Troubleshooting
-
-### Authentication Errors During Build
-
-**Symptom**: Build fails with `401 Unauthorized` or `403 Forbidden` when resolving a private package.
-
-**Check**:
-- The `UV_INDEX_*` environment variable names match your index name exactly (uppercased, hyphens → underscores)
-- Credentials are set in AMP environment variables, not just in a local `.env`
-- Your token/PAT has the required read permissions for the package feed
-- The token hasn't expired (especially relevant for AWS CodeArtifact)
-
-### Package Not Found
-
-**Symptom**: `No matching distribution found for my-private-package`.
-
-**Check**:
-- The index URL in `pyproject.toml` ends with `/simple/`
-- The `[tool.uv.sources]` entry maps the correct package name to the correct index name
-- The package is actually published to your private registry
-- Run `uv lock` locally with the same credentials to verify resolution works
-
-### Lock File Conflicts
-
-**Symptom**: `uv lock` fails or produces unexpected results after adding a private index.
-
-**Solution**: Set the credentials locally and regenerate:
-
-```bash
-export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
-uv lock
-```
-
-Then commit the updated `uv.lock`.
-
-## Related Guides
-
-<CardGroup cols={3}>
-  <Card title="Prepare for Deployment" icon="clipboard-check" href="/en/enterprise/guides/prepare-for-deployment">
-    Verify project structure and dependencies before deploying.
-  </Card>
-  <Card title="Deploy to AMP" icon="rocket" href="/en/enterprise/guides/deploy-to-amp">
-    Deploy your crew or flow and configure environment variables.
-  </Card>
-  <Card title="Update Your Crew" icon="arrows-rotate" href="/en/enterprise/guides/update-crew">
-    Update environment variables and push changes to a running deployment.
-  </Card>
-</CardGroup>

docs/en/learn/llm-connections.mdx

@@ -7,7 +7,7 @@ mode: "wide"
 
 ## Connect CrewAI to LLMs
 
-CrewAI connects to LLMs through native SDK integrations for the most popular providers (OpenAI, Anthropic, Google Gemini, Azure, and AWS Bedrock), and uses LiteLLM as a flexible fallback for all other providers.
+CrewAI uses LiteLLM to connect to a wide variety of Language Models (LLMs). This integration provides extensive versatility, allowing you to use models from numerous providers with a simple, unified interface.
 
 <Note>
     By default, CrewAI uses the `gpt-4o-mini` model. This is determined by the `OPENAI_MODEL_NAME` environment variable, which defaults to "gpt-4o-mini" if not set.
@@ -41,14 +41,6 @@ LiteLLM supports a wide range of providers, including but not limited to:
 
 For a complete and up-to-date list of supported providers, please refer to the [LiteLLM Providers documentation](https://docs.litellm.ai/docs/providers).
 
-<Info>
-  To use any provider not covered by a native integration, add LiteLLM as a dependency to your project:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-  Native providers (OpenAI, Anthropic, Google Gemini, Azure, AWS Bedrock) use their own SDK extras — see the [Provider Configuration Examples](/en/concepts/llms#provider-configuration-examples).
-</Info>
-
 ## Changing the LLM
 
 To use a different LLM with your CrewAI agents, you have several options:

docs/en/observability/tracing.mdx

@@ -35,7 +35,7 @@ Visit [app.crewai.com](https://app.crewai.com) and create your free account. Thi
 If you haven't already, install CrewAI with the CLI tools:
 
 ```bash
-uv add 'crewai[tools]'
+uv add crewai[tools]
 ```
 
 Then authenticate your CLI with your CrewAI AMP account:

docs/ko/changelog.mdx

@@ -4,106 +4,6 @@ description: "CrewAI의 제품 업데이트, 개선 사항 및 버그 수정"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="2026년 2월 27일">
-  ## v1.10.1a1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## 변경 사항
-
-  ### 기능
-  - 단계 콜백 메서드에서 비동기 호출 지원 구현
-  - 메모리 모듈의 무거운 의존성에 대한 지연 로딩 구현
-
-  ### 문서
-  - v1.10.0에 대한 변경 로그 및 버전 업데이트
-
-  ### 리팩토링
-  - 비동기 호출을 지원하기 위해 단계 콜백 메서드 리팩토링
-  - 메모리 모듈의 무거운 의존성에 대한 지연 로딩을 구현하기 위해 리팩토링
-
-  ### 버그 수정
-  - 릴리스 노트의 분기 수정
-
-  ## 기여자
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="2026년 2월 27일">
-  ## v1.10.1a1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## 변경 사항
-
-  ### 리팩토링
-  - 비동기 호출을 지원하기 위해 단계 콜백 메서드 리팩토링
-  - 메모리 모듈의 무거운 의존성에 대해 지연 로딩 구현
-
-  ### 문서화
-  - v1.10.0에 대한 변경 로그 및 버전 업데이트
-
-  ### 버그 수정
-  - 릴리스 노트를 위한 브랜치 생성
-
-  ## 기여자
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="2026년 2월 26일">
-  ## v1.10.0
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/1.10.0)
-
-  ## 변경 사항
-
-  ### 기능
-  - MCP 도구 해상도 및 관련 이벤트 개선
-  - lancedb 버전 업데이트 및 lance-namespace 패키지 추가
-  - CrewAgentExecutor 및 BaseTool에서 JSON 인수 파싱 및 검증 개선
-  - CLI HTTP 클라이언트를 requests에서 httpx로 마이그레이션
-  - 버전화된 문서 추가
-  - 버전 노트에 대한 yanked 감지 추가
-  - Flows에서 사용자 입력 처리 구현
-  - 인간 피드백 통합 테스트에서 HITL 자기 루프 기능 개선
-  - eventbus에 started_event_id 추가 및 설정
-  - tools.specs 자동 업데이트
-
-  ### 버그 수정
-  - 빈 경우에도 도구 kwargs를 검증하여 모호한 TypeError 방지
-  - LLM을 위한 도구 매개변수 스키마에서 null 타입 유지
-  - output_pydantic/output_json을 네이티브 구조화된 출력으로 매핑
-  - 약속이 있는 경우 콜백이 실행/대기되도록 보장
-  - 예외 컨텍스트에서 메서드 이름 캡처
-  - 라우터 결과에서 enum 타입 유지; 타입 개선
-  - 입력으로 지속성 ID가 전달될 때 조용히 깨지는 순환 흐름 수정
-  - CLI 플래그 형식을 --skip-provider에서 --skip_provider로 수정
-  - OpenAI 도구 호출 스트림이 완료되도록 보장
-  - MCP 도구에서 복잡한 스키마 $ref 포인터 해결
-  - 스키마에서 additionalProperties=false 강제 적용
-  - 크루 폴더에 대해 예약된 스크립트 이름 거부
-  - 가드레일 이벤트 방출 테스트에서 경쟁 조건 해결
-
-  ### 문서
-  - 비네이티브 LLM 공급자를 위한 litellm 종속성 노트 추가
-  - NL2SQL 보안 모델 및 강화 지침 명확화
-  - 9개 통합에서 96개의 누락된 작업 추가
-
-  ### 리팩토링
-  - crew를 provider로 리팩토링
-  - HITL을 provider 패턴으로 추출
-  - 훅 타이핑 및 등록 개선
-
-  ## 기여자
-
-  @dependabot[bot], @github-actions[bot], @github-code-quality[bot], @greysonlalonde, @heitorado, @hobostay, @joaomdmoura, @johnvan7, @jonathansampson, @lorenzejay, @lucasgomide, @mattatcha, @mplachta, @nicoferdi96, @theCyberTech, @thiagomoretto, @vinibrsl
-
-</Update>
-
 <Update label="2026년 1월 26일">
   ## v1.9.0
 

docs/ko/concepts/llms.mdx

@@ -105,15 +105,6 @@ CrewAI 코드 내에는 사용할 모델을 지정할 수 있는 여러 위치
   </Tab>
 </Tabs>
 
-<Info>
-  CrewAI는 OpenAI, Anthropic, Google (Gemini API), Azure, AWS Bedrock에 대해 네이티브 SDK 통합을 제공합니다 — 제공자별 extras(예: `uv add "crewai[openai]"`) 외에 추가 설치가 필요하지 않습니다.
-
-  그 외 모든 제공자는 **LiteLLM**을 통해 지원됩니다. 이를 사용하려면 프로젝트에 의존성으로 추가하세요:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-</Info>
-
 ## 공급자 구성 예시
 
 CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양한 LLM 공급자를 지원합니다.
@@ -223,11 +214,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | 텍스트, 이미지     | 텍스트           |
     | `meta_llama/Llama-3.3-70B-Instruct`               | 128k | 4028       | 텍스트            | 텍스트           |
     | `meta_llama/Llama-3.3-8B-Instruct`                | 128k | 4028       | 텍스트            | 텍스트           |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Anthropic">
@@ -368,11 +354,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | gemini-1.5-flash                 | 1M 토큰         | 밸런스 잡힌 멀티모달 모델, 대부분의 작업에 적합                         |
     | gemini-1.5-flash-8B              | 1M 토큰         | 가장 빠르고, 비용 효율적, 고빈도 작업에 적합                            |
     | gemini-1.5-pro                   | 2M 토큰         | 최고의 성능, 논리적 추론, 코딩, 창의적 협업 등 다양한 추론 작업에 적합   |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Azure">
@@ -458,11 +439,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         model="sagemaker/<my-endpoint>"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Mistral">
@@ -478,11 +454,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         temperature=0.7
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nvidia NIM">
@@ -569,11 +540,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | rakuten/rakutenai-7b-instruct                                          | 1,024 토큰     | 언어 이해, 추론, 텍스트 생성이 탁월한 최첨단 LLM                         |
     | rakuten/rakutenai-7b-chat                                              | 1,024 토큰     | 언어 이해, 추론, 텍스트 생성이 탁월한 최첨단 LLM                         |
     | baichuan-inc/baichuan2-13b-chat                                        | 4,096 토큰     | 중국어 및 영어 대화, 코딩, 수학, 지시 따르기, 퀴즈 풀이 지원             |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Local NVIDIA NIM Deployed using WSL2">
@@ -614,11 +580,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
 
         # ...
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Groq">
@@ -640,11 +601,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | Llama 3.1 70B/8B| 131,072 토큰      | 고성능, 대용량 문맥 작업         |
     | Llama 3.2 Series| 8,192 토큰        | 범용 작업                        |
     | Mixtral 8x7B    | 32,768 토큰       | 성능과 문맥의 균형               |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="IBM watsonx.ai">
@@ -667,11 +623,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         base_url="https://api.watsonx.ai/v1"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Ollama (Local LLMs)">
@@ -685,11 +636,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         base_url="http://localhost:11434"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Fireworks AI">
@@ -705,11 +651,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         temperature=0.7
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Perplexity AI">
@@ -725,11 +666,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         base_url="https://api.perplexity.ai/"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Hugging Face">
@@ -744,11 +680,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
         model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
     )
     ```
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="SambaNova">
@@ -772,11 +703,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
     | Llama 3.2 Series| 8,192 토큰         | 범용, 멀티모달 작업                  |
     | Llama 3.3 70B   | 최대 131,072 토큰   | 고성능, 높은 출력 품질               |
     | Qwen2 familly   | 8,192 토큰         | 고성능, 높은 출력 품질               |
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Cerebras">
@@ -802,11 +728,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
       - 속도와 품질의 우수한 밸런스
       - 긴 컨텍스트 윈도우 지원
     </Info>
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Open Router">
@@ -829,11 +750,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
       - openrouter/deepseek/deepseek-r1
       - openrouter/deepseek/deepseek-chat
     </Info>
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nebius AI Studio">
@@ -856,11 +772,6 @@ CrewAI는 고유한 기능, 인증 방법, 모델 역량을 제공하는 다양
       - 경쟁력 있는 가격
       - 속도와 품질의 우수한 밸런스
     </Info>
-
-    **참고:** 이 제공자는 LiteLLM을 사용합니다. 프로젝트에 의존성으로 추가하세요:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 </AccordionGroup>
 

docs/ko/enterprise/guides/deploy-to-amp.mdx

@@ -176,11 +176,6 @@ Crew를 GitHub 저장소에 푸시해야 합니다. 아직 Crew를 만들지 않
       ![Set Environment Variables](/images/enterprise/set-env-variables.png)
     </Frame>
 
-    <Info>
-      프라이빗 Python 패키지를 사용하시나요? 여기에 레지스트리 자격 증명도 추가해야 합니다.
-      필요한 변수는 [프라이빗 패키지 레지스트리](/ko/enterprise/guides/private-package-registry)를 참조하세요.
-    </Info>
-
   </Step>
 
   <Step title="Crew 배포하기">

docs/ko/enterprise/guides/prepare-for-deployment.mdx

@@ -256,12 +256,6 @@ Crews와 Flows 모두 `src/project_name/main.py`에 진입점이 있습니다:
 1. **LLM API 키** (OpenAI, Anthropic, Google 등)
 2. **도구 API 키** - 외부 도구를 사용하는 경우 (Serper 등)
 
-<Info>
-  프로젝트가 **프라이빗 PyPI 레지스트리**의 패키지에 의존하는 경우, 레지스트리 인증 자격 증명도
-  환경 변수로 구성해야 합니다. 자세한 내용은
-  [프라이빗 패키지 레지스트리](/ko/enterprise/guides/private-package-registry) 가이드를 참조하세요.
-</Info>
-
 <Tip>
   구성 문제를 조기에 발견하기 위해 배포 전에 동일한 환경 변수로
   로컬에서 프로젝트를 테스트하세요.

docs/ko/enterprise/guides/private-package-registry.mdx

@@ -1,261 +0,0 @@
----
-title: "프라이빗 패키지 레지스트리"
-description: "CrewAI AMP에서 인증된 PyPI 레지스트리의 프라이빗 Python 패키지 설치하기"
-icon: "lock"
-mode: "wide"
----
-
-<Note>
-  이 가이드는 CrewAI AMP에 배포할 때 프라이빗 PyPI 레지스트리(Azure DevOps Artifacts, GitHub Packages,
-  GitLab, AWS CodeArtifact 등)에서 Python 패키지를 설치하도록 CrewAI 프로젝트를 구성하는 방법을 다룹니다.
-</Note>
-
-## 이 가이드가 필요한 경우
-
-프로젝트가 공개 PyPI가 아닌 프라이빗 레지스트리에 호스팅된 내부 또는 독점 Python 패키지에
-의존하는 경우, 다음을 수행해야 합니다:
-
-1. UV에 패키지를 **어디서** 찾을지 알려줍니다 (index URL)
-2. UV에 **어떤** 패키지가 해당 index에서 오는지 알려줍니다 (source 매핑)
-3. UV가 설치 중에 인증할 수 있도록 **자격 증명**을 제공합니다
-
-CrewAI AMP는 의존성 해결 및 설치에 [UV](https://docs.astral.sh/uv/)를 사용합니다.
-UV는 `pyproject.toml` 구성과 자격 증명용 환경 변수를 결합하여 인증된 프라이빗 레지스트리를 지원합니다.
-
-## 1단계: pyproject.toml 구성
-
-`pyproject.toml`에서 세 가지 요소가 함께 작동합니다:
-
-### 1a. 의존성 선언
-
-프라이빗 패키지를 다른 의존성과 마찬가지로 `[project.dependencies]`에 추가합니다:
-
-```toml
-[project]
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-```
-
-### 1b. index 정의
-
-프라이빗 레지스트리를 `[[tool.uv.index]]` 아래에 명명된 index로 등록합니다:
-
-```toml
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-```
-
-<Info>
-  `name` 필드는 중요합니다 — UV는 이를 사용하여 인증을 위한 환경 변수 이름을
-  구성합니다 (아래 [2단계](#2단계-인증-자격-증명-설정)를 참조하세요).
-
-  `explicit = true`를 설정하면 UV가 모든 패키지에 대해 이 index를 검색하지 않습니다 —
-  `[tool.uv.sources]`에서 명시적으로 매핑한 패키지만 검색합니다. 이렇게 하면 프라이빗
-  레지스트리에 대한 불필요한 쿼리를 방지하고 의존성 혼동 공격을 차단할 수 있습니다.
-</Info>
-
-### 1c. 패키지를 index에 매핑
-
-`[tool.uv.sources]`를 사용하여 프라이빗 index에서 해결해야 할 패키지를 UV에 알려줍니다:
-
-```toml
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-### 전체 예시
-
-```toml
-[project]
-name = "my-crew-project"
-version = "0.1.0"
-requires-python = ">=3.10,<=3.13"
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-
-[tool.crewai]
-type = "crew"
-
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-`pyproject.toml`을 업데이트한 후 lock 파일을 다시 생성합니다:
-
-```bash
-uv lock
-```
-
-<Warning>
-  업데이트된 `uv.lock`을 항상 `pyproject.toml` 변경 사항과 함께 커밋하세요.
-  lock 파일은 배포에 필수입니다 — [배포 준비하기](/ko/enterprise/guides/prepare-for-deployment)를 참조하세요.
-</Warning>
-
-## 2단계: 인증 자격 증명 설정
-
-UV는 `pyproject.toml`에서 정의한 index 이름을 기반으로 한 명명 규칙을 따르는
-환경 변수를 사용하여 프라이빗 index에 인증합니다:
-
-```
-UV_INDEX_{UPPER_NAME}_USERNAME
-UV_INDEX_{UPPER_NAME}_PASSWORD
-```
-
-여기서 `{UPPER_NAME}`은 index 이름을 **대문자**로 변환하고 **하이픈을 언더스코어로 대체**한 것입니다.
-
-예를 들어, `my-private-registry`라는 이름의 index는 다음을 사용합니다:
-
-| 변수 | 값 |
-|------|-----|
-| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | 레지스트리 사용자 이름 또는 토큰 이름 |
-| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | 레지스트리 비밀번호 또는 토큰/PAT |
-
-<Warning>
-  이 환경 변수는 CrewAI AMP **환경 변수** 설정을 통해 **반드시** 추가해야 합니다 —
-  전역적으로 또는 배포 수준에서. `.env` 파일에 설정하거나 프로젝트에 하드코딩할 수 없습니다.
-
-  아래 [AMP에서 환경 변수 설정](#amp에서-환경-변수-설정)을 참조하세요.
-</Warning>
-
-## 레지스트리 제공업체 참조
-
-아래 표는 일반적인 레지스트리 제공업체의 index URL 형식과 자격 증명 값을 보여줍니다.
-자리 표시자 값을 실제 조직 및 피드 세부 정보로 대체하세요.
-
-| 제공업체 | Index URL | 사용자 이름 | 비밀번호 |
-|---------|-----------|-----------|---------|
-| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | 비어 있지 않은 임의의 문자열 (예: `token`) | Packaging Read 범위의 Personal Access Token (PAT) |
-| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | GitHub 사용자 이름 | `read:packages` 범위의 Personal Access Token (classic) |
-| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | `read_api` 범위의 Project 또는 Personal Access Token |
-| **AWS CodeArtifact** | `aws codeartifact get-repository-endpoint`의 URL 사용 | `aws` | `aws codeartifact get-authorization-token`의 토큰 |
-| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | Base64로 인코딩된 서비스 계정 키 |
-| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | 사용자 이름 또는 이메일 | API 키 또는 ID 토큰 |
-| **자체 호스팅 (devpi, Nexus 등)** | 레지스트리의 simple API URL | 레지스트리 사용자 이름 | 레지스트리 비밀번호 |
-
-<Tip>
-  **AWS CodeArtifact**의 경우 인증 토큰이 주기적으로 만료됩니다.
-  만료되면 `UV_INDEX_*_PASSWORD` 값을 갱신해야 합니다.
-  CI/CD 파이프라인에서 이를 자동화하는 것을 고려하세요.
-</Tip>
-
-## AMP에서 환경 변수 설정
-
-프라이빗 레지스트리 자격 증명은 CrewAI AMP에서 환경 변수로 구성해야 합니다.
-두 가지 옵션이 있습니다:
-
-<Tabs>
-  <Tab title="웹 인터페이스">
-    1. [CrewAI AMP](https://app.crewai.com)에 로그인합니다
-    2. 자동화로 이동합니다
-    3. **Environment Variables** 탭을 엽니다
-    4. 각 변수 (`UV_INDEX_*_USERNAME` 및 `UV_INDEX_*_PASSWORD`)에 값을 추가합니다
-
-    자세한 내용은 [AMP에 배포하기 — 환경 변수 설정하기](/ko/enterprise/guides/deploy-to-amp#환경-변수-설정하기) 단계를 참조하세요.
-  </Tab>
-  <Tab title="CLI 배포">
-    `crewai deploy create`를 실행하기 전에 로컬 `.env` 파일에 변수를 추가합니다.
-    CLI가 이를 안전하게 플랫폼으로 전송합니다:
-
-    ```bash
-    # .env
-    OPENAI_API_KEY=sk-...
-    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
-    ```
-
-    ```bash
-    crewai deploy create
-    ```
-  </Tab>
-</Tabs>
-
-<Warning>
-  자격 증명을 저장소에 **절대** 커밋하지 마세요. 모든 비밀 정보에는 AMP 환경 변수를 사용하세요.
-  `.env` 파일은 `.gitignore`에 포함되어야 합니다.
-</Warning>
-
-기존 배포의 자격 증명을 업데이트하려면 [Crew 업데이트하기 — 환경 변수](/ko/enterprise/guides/update-crew)를 참조하세요.
-
-## 전체 동작 흐름
-
-CrewAI AMP가 자동화를 빌드할 때, 해결 흐름은 다음과 같이 작동합니다:
-
-<Steps>
-  <Step title="빌드 시작">
-    AMP가 저장소를 가져오고 `pyproject.toml`과 `uv.lock`을 읽습니다.
-  </Step>
-  <Step title="UV가 의존성 해결">
-    UV가 `[tool.uv.sources]`를 읽어 각 패키지가 어떤 index에서 와야 하는지 결정합니다.
-  </Step>
-  <Step title="UV가 인증">
-    각 프라이빗 index에 대해 UV가 AMP에서 구성한 환경 변수에서
-    `UV_INDEX_{NAME}_USERNAME`과 `UV_INDEX_{NAME}_PASSWORD`를 조회합니다.
-  </Step>
-  <Step title="패키지 설치">
-    UV가 공개(PyPI) 및 프라이빗(레지스트리) 패키지를 모두 다운로드하고 설치합니다.
-  </Step>
-  <Step title="자동화 실행">
-    모든 의존성이 사용 가능한 상태에서 crew 또는 flow가 시작됩니다.
-  </Step>
-</Steps>
-
-## 문제 해결
-
-### 빌드 중 인증 오류
-
-**증상**: 프라이빗 패키지를 해결할 때 `401 Unauthorized` 또는 `403 Forbidden`으로 빌드가 실패합니다.
-
-**확인사항**:
-- `UV_INDEX_*` 환경 변수 이름이 index 이름과 정확히 일치하는지 확인합니다 (대문자, 하이픈 -> 언더스코어)
-- 자격 증명이 로컬 `.env`뿐만 아니라 AMP 환경 변수에 설정되어 있는지 확인합니다
-- 토큰/PAT에 패키지 피드에 필요한 읽기 권한이 있는지 확인합니다
-- 토큰이 만료되지 않았는지 확인합니다 (특히 AWS CodeArtifact의 경우)
-
-### 패키지를 찾을 수 없음
-
-**증상**: `No matching distribution found for my-private-package`.
-
-**확인사항**:
-- `pyproject.toml`의 index URL이 `/simple/`로 끝나는지 확인합니다
-- `[tool.uv.sources]` 항목이 올바른 패키지 이름을 올바른 index 이름에 매핑하는지 확인합니다
-- 패키지가 실제로 프라이빗 레지스트리에 게시되어 있는지 확인합니다
-- 동일한 자격 증명으로 로컬에서 `uv lock`을 실행하여 해결이 작동하는지 확인합니다
-
-### Lock 파일 충돌
-
-**증상**: 프라이빗 index를 추가한 후 `uv lock`이 실패하거나 예상치 못한 결과를 생성합니다.
-
-**해결책**: 로컬에서 자격 증명을 설정하고 다시 생성합니다:
-
-```bash
-export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
-uv lock
-```
-
-그런 다음 업데이트된 `uv.lock`을 커밋합니다.
-
-## 관련 가이드
-
-<CardGroup cols={3}>
-  <Card title="배포 준비하기" icon="clipboard-check" href="/ko/enterprise/guides/prepare-for-deployment">
-    배포 전에 프로젝트 구조와 의존성을 확인합니다.
-  </Card>
-  <Card title="AMP에 배포하기" icon="rocket" href="/ko/enterprise/guides/deploy-to-amp">
-    crew 또는 flow를 배포하고 환경 변수를 구성합니다.
-  </Card>
-  <Card title="Crew 업데이트하기" icon="arrows-rotate" href="/ko/enterprise/guides/update-crew">
-    환경 변수를 업데이트하고 실행 중인 배포에 변경 사항을 푸시합니다.
-  </Card>
-</CardGroup>

docs/ko/learn/llm-connections.mdx

@@ -7,7 +7,7 @@ mode: "wide"
 
 ## CrewAI를 LLM에 연결하기
 
-CrewAI는 가장 인기 있는 제공자(OpenAI, Anthropic, Google Gemini, Azure, AWS Bedrock)에 대해 네이티브 SDK 통합을 통해 LLM에 연결하며, 그 외 모든 제공자에 대해서는 LiteLLM을 유연한 폴백으로 사용합니다.
+CrewAI는 LiteLLM을 사용하여 다양한 언어 모델(LLM)에 연결합니다. 이 통합은 높은 다양성을 제공하여, 여러 공급자의 모델을 간단하고 통합된 인터페이스로 사용할 수 있게 해줍니다.
 
 <Note>
     기본적으로 CrewAI는 `gpt-4o-mini` 모델을 사용합니다. 이는 `OPENAI_MODEL_NAME` 환경 변수에 의해 결정되며, 설정되지 않은 경우 기본값은 "gpt-4o-mini"입니다.
@@ -41,14 +41,6 @@ LiteLLM은 다음을 포함하되 이에 국한되지 않는 다양한 프로바
 
 지원되는 프로바이더의 전체 및 최신 목록은 [LiteLLM 프로바이더 문서](https://docs.litellm.ai/docs/providers)를 참조하세요.
 
-<Info>
-  네이티브 통합에서 지원하지 않는 제공자를 사용하려면 LiteLLM을 프로젝트에 의존성으로 추가하세요:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-  네이티브 제공자(OpenAI, Anthropic, Google Gemini, Azure, AWS Bedrock)는 자체 SDK extras를 사용합니다 — [공급자 구성 예시](/ko/concepts/llms#공급자-구성-예시)를 참조하세요.
-</Info>
-
 ## LLM 변경하기
 
 CrewAI agent에서 다른 LLM을 사용하려면 여러 가지 방법이 있습니다:

docs/ko/observability/tracing.mdx

@@ -35,7 +35,7 @@ crewai login
 아직 설치하지 않았다면 CLI 도구와 함께 CrewAI를 설치하세요:
 
 ```bash
-uv add 'crewai[tools]'
+uv add crewai[tools]
 ```
 
 그런 다음 CrewAI AMP 계정으로 CLI를 인증하세요:

docs/pt-BR/changelog.mdx

@@ -4,106 +4,6 @@ description: "Atualizações de produto, melhorias e correções do CrewAI"
 icon: "clock"
 mode: "wide"
 ---
-<Update label="27 fev 2026">
-  ## v1.10.1a1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## O que Mudou
-
-  ### Funcionalidades
-  - Implementar suporte a invocação assíncrona em métodos de callback de etapas
-  - Implementar carregamento sob demanda para dependências pesadas no módulo de Memória
-
-  ### Documentação
-  - Atualizar changelog e versão para v1.10.0
-
-  ### Refatoração
-  - Refatorar métodos de callback de etapas para suportar invocação assíncrona
-  - Refatorar para implementar carregamento sob demanda para dependências pesadas no módulo de Memória
-
-  ### Correções de Bugs
-  - Corrigir branch para notas de lançamento
-
-  ## Contribuidores
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="27 fev 2026">
-  ## v1.10.1a1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.1a1)
-
-  ## O que Mudou
-
-  ### Refatoração
-  - Refatorar métodos de callback de etapas para suportar invocação assíncrona
-  - Implementar carregamento sob demanda para dependências pesadas no módulo de Memória
-
-  ### Documentação
-  - Atualizar changelog e versão para v1.10.0
-
-  ### Correções de Bugs
-  - Criar branch para notas de lançamento
-
-  ## Contribuidores
-
-  @greysonlalonde, @joaomdmoura
-
-</Update>
-
-<Update label="26 fev 2026">
-  ## v1.10.0
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/1.10.0)
-
-  ## O que Mudou
-
-  ### Recursos
-  - Aprimorar a resolução da ferramenta MCP e eventos relacionados
-  - Atualizar a versão do lancedb e adicionar pacotes lance-namespace
-  - Aprimorar a análise e validação de argumentos JSON no CrewAgentExecutor e BaseTool
-  - Migrar o cliente HTTP da CLI de requests para httpx
-  - Adicionar documentação versionada
-  - Adicionar detecção de versões removidas para notas de versão
-  - Implementar tratamento de entrada do usuário em Flows
-  - Aprimorar a funcionalidade de auto-loop HITL nos testes de integração de feedback humano
-  - Adicionar started_event_id e definir no eventbus
-  - Atualizar automaticamente tools.specs
-
-  ### Correções de Bugs
-  - Validar kwargs da ferramenta mesmo quando vazios para evitar TypeError crípticos
-  - Preservar tipos nulos nos esquemas de parâmetros da ferramenta para LLM
-  - Mapear output_pydantic/output_json para saída estruturada nativa
-  - Garantir que callbacks sejam executados/aguardados se forem promessas
-  - Capturar o nome do método no contexto da exceção
-  - Preservar tipo enum no resultado do roteador; melhorar tipos
-  - Corrigir fluxos cíclicos que quebram silenciosamente quando o ID de persistência é passado nas entradas
-  - Corrigir o formato da flag da CLI de --skip-provider para --skip_provider
-  - Garantir que o fluxo de chamada da ferramenta OpenAI seja finalizado
-  - Resolver ponteiros $ref de esquema complexos nas ferramentas MCP
-  - Impor additionalProperties=false nos esquemas
-  - Rejeitar nomes de scripts reservados para pastas de equipe
-  - Resolver condição de corrida no teste de emissão de eventos de guardrail
-
-  ### Documentação
-  - Adicionar nota de dependência litellm para provedores de LLM não nativos
-  - Esclarecer o modelo de segurança NL2SQL e orientações de fortalecimento
-  - Adicionar 96 ações ausentes em 9 integrações
-
-  ### Refatoração
-  - Refatorar crew para provider
-  - Extrair HITL para padrão de provider
-  - Melhorar tipagem e registro de hooks
-
-  ## Contribuidores
-
-  @dependabot[bot], @github-actions[bot], @github-code-quality[bot], @greysonlalonde, @heitorado, @hobostay, @joaomdmoura, @johnvan7, @jonathansampson, @lorenzejay, @lucasgomide, @mattatcha, @mplachta, @nicoferdi96, @theCyberTech, @thiagomoretto, @vinibrsl
-
-</Update>
-
 <Update label="26 jan 2026">
   ## v1.9.0
 

docs/pt-BR/concepts/llms.mdx

@@ -105,15 +105,6 @@ Existem diferentes locais no código do CrewAI onde você pode especificar o mod
   </Tab>
 </Tabs>
 
-<Info>
-  O CrewAI oferece integrações nativas via SDK para OpenAI, Anthropic, Google (Gemini API), Azure e AWS Bedrock — sem necessidade de instalação extra além dos extras específicos do provedor (ex.: `uv add "crewai[openai]"`).
-
-  Todos os outros provedores são alimentados pelo **LiteLLM**. Se você planeja usar algum deles, adicione-o como dependência ao seu projeto:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-</Info>
-
 ## Exemplos de Configuração de Provedores
 
 O CrewAI suporta uma grande variedade de provedores de LLM, cada um com recursos, métodos de autenticação e capacidades de modelo únicos.
@@ -223,11 +214,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | `meta_llama/Llama-4-Maverick-17B-128E-Instruct-FP8` | 128k | 4028 | Texto, Imagem | Texto |
     | `meta_llama/Llama-3.3-70B-Instruct` | 128k | 4028 | Texto | Texto |
     | `meta_llama/Llama-3.3-8B-Instruct` | 128k | 4028 | Texto | Texto |
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Anthropic">
@@ -368,11 +354,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | gemini-1.5-flash                 | 1M tokens          | Modelo multimodal equilibrado, bom para maioria das tarefas         |
     | gemini-1.5-flash-8B              | 1M tokens          | Mais rápido, mais eficiente em custo, adequado para tarefas de alta frequência |
     | gemini-1.5-pro                   | 2M tokens          | Melhor desempenho para uma ampla variedade de tarefas de raciocínio, incluindo lógica, codificação e colaboração criativa |
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Azure">
@@ -457,11 +438,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         model="sagemaker/<my-endpoint>"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Mistral">
@@ -477,11 +453,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         temperature=0.7
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Nvidia NIM">
@@ -568,11 +539,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | rakuten/rakutenai-7b-instruct                                            | 1.024 tokens       | LLM topo de linha, compreensão, raciocínio e geração textual.|
     | rakuten/rakutenai-7b-chat                                                | 1.024 tokens       | LLM topo de linha, compreensão, raciocínio e geração textual.|
     | baichuan-inc/baichuan2-13b-chat                                          | 4.096 tokens       | Suporte a chat em chinês/inglês, programação, matemática, seguir instruções, resolver quizzes.|
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Local NVIDIA NIM Deployed using WSL2">
@@ -613,11 +579,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
 
         # ...
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Groq">
@@ -639,11 +600,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | Llama 3.1 70B/8B  | 131.072 tokens      | Alta performance e tarefas de contexto grande|
     | Llama 3.2 Série   | 8.192 tokens        | Tarefas gerais                          |
     | Mixtral 8x7B      | 32.768 tokens       | Equilíbrio entre performance e contexto  |
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="IBM watsonx.ai">
@@ -666,11 +622,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         base_url="https://api.watsonx.ai/v1"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Ollama (LLMs Locais)">
@@ -684,11 +635,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         base_url="http://localhost:11434"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Fireworks AI">
@@ -704,11 +650,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         temperature=0.7
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Perplexity AI">
@@ -724,11 +665,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         base_url="https://api.perplexity.ai/"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Hugging Face">
@@ -743,11 +679,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
         model="huggingface/meta-llama/Meta-Llama-3.1-8B-Instruct"
     )
     ```
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="SambaNova">
@@ -771,11 +702,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
     | Llama 3.2 Série   | 8.192 tokens              | Tarefas gerais e multimodais                 |
     | Llama 3.3 70B     | Até 131.072 tokens        | Desempenho e qualidade de saída elevada      |
     | Família Qwen2     | 8.192 tokens              | Desempenho e qualidade de saída elevada      |
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Cerebras">
@@ -801,11 +727,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
       - Equilíbrio entre velocidade e qualidade
       - Suporte a longas janelas de contexto
     </Info>
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 
   <Accordion title="Open Router">
@@ -828,11 +749,6 @@ Nesta seção, você encontrará exemplos detalhados que ajudam a selecionar, co
       - openrouter/deepseek/deepseek-r1
       - openrouter/deepseek/deepseek-chat
     </Info>
-
-    **Nota:** Este provedor usa o LiteLLM. Adicione-o como dependência ao seu projeto:
-    ```bash
-    uv add 'crewai[litellm]'
-    ```
   </Accordion>
 </AccordionGroup>
 

docs/pt-BR/enterprise/guides/deploy-to-amp.mdx

@@ -176,11 +176,6 @@ Você precisa enviar seu crew para um repositório do GitHub. Caso ainda não te
       ![Definir Variáveis de Ambiente](/images/enterprise/set-env-variables.png)
     </Frame>
 
-    <Info>
-      Usando pacotes Python privados? Você também precisará adicionar suas credenciais de registro aqui.
-      Consulte [Registros de Pacotes Privados](/pt-BR/enterprise/guides/private-package-registry) para as variáveis necessárias.
-    </Info>
-
   </Step>
 
   <Step title="Implante Seu Crew">

docs/pt-BR/enterprise/guides/prepare-for-deployment.mdx

@@ -256,12 +256,6 @@ Antes da implantação, certifique-se de ter:
 1. **Chaves de API de LLM** prontas (OpenAI, Anthropic, Google, etc.)
 2. **Chaves de API de ferramentas** se estiver usando ferramentas externas (Serper, etc.)
 
-<Info>
-  Se seu projeto depende de pacotes de um **registro PyPI privado**, você também precisará configurar
-  credenciais de autenticação do registro como variáveis de ambiente. Consulte o guia
-  [Registros de Pacotes Privados](/pt-BR/enterprise/guides/private-package-registry) para mais detalhes.
-</Info>
-
 <Tip>
   Teste seu projeto localmente com as mesmas variáveis de ambiente antes de implantar
   para detectar problemas de configuração antecipadamente.

docs/pt-BR/enterprise/guides/private-package-registry.mdx

@@ -1,263 +0,0 @@
----
-title: "Registros de Pacotes Privados"
-description: "Instale pacotes Python privados de registros PyPI autenticados no CrewAI AMP"
-icon: "lock"
-mode: "wide"
----
-
-<Note>
-  Este guia aborda como configurar seu projeto CrewAI para instalar pacotes Python
-  de registros PyPI privados (Azure DevOps Artifacts, GitHub Packages, GitLab, AWS CodeArtifact, etc.)
-  ao implantar no CrewAI AMP.
-</Note>
-
-## Quando Você Precisa Disso
-
-Se seu projeto depende de pacotes Python internos ou proprietários hospedados em um registro privado
-em vez do PyPI público, você precisará:
-
-1. Informar ao UV **onde** encontrar o pacote (uma URL de index)
-2. Informar ao UV **quais** pacotes vêm desse index (um mapeamento de source)
-3. Fornecer **credenciais** para que o UV possa autenticar durante a instalação
-
-O CrewAI AMP usa [UV](https://docs.astral.sh/uv/) para resolução e instalação de dependências.
-O UV suporta registros privados autenticados por meio da configuração do `pyproject.toml` combinada
-com variáveis de ambiente para credenciais.
-
-## Passo 1: Configurar o pyproject.toml
-
-Três elementos trabalham juntos no seu `pyproject.toml`:
-
-### 1a. Declarar a dependência
-
-Adicione o pacote privado ao seu `[project.dependencies]` como qualquer outra dependência:
-
-```toml
-[project]
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-```
-
-### 1b. Definir o index
-
-Registre seu registro privado como um index nomeado em `[[tool.uv.index]]`:
-
-```toml
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-```
-
-<Info>
-  O campo `name` é importante — o UV o utiliza para construir os nomes das variáveis de ambiente
-  para autenticação (veja o [Passo 2](#passo-2-configurar-credenciais-de-autenticação) abaixo).
-
-  Definir `explicit = true` significa que o UV não consultará esse index para todos os pacotes — apenas
-  os que você mapear explicitamente em `[tool.uv.sources]`. Isso evita consultas desnecessárias
-  ao seu registro privado e protege contra ataques de confusão de dependências.
-</Info>
-
-### 1c. Mapear o pacote para o index
-
-Informe ao UV quais pacotes devem ser resolvidos a partir do seu index privado usando `[tool.uv.sources]`:
-
-```toml
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-### Exemplo completo
-
-```toml
-[project]
-name = "my-crew-project"
-version = "0.1.0"
-requires-python = ">=3.10,<=3.13"
-dependencies = [
-    "crewai[tools]>=0.100.1,<1.0.0",
-    "my-private-package>=1.2.0",
-]
-
-[tool.crewai]
-type = "crew"
-
-[[tool.uv.index]]
-name = "my-private-registry"
-url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
-explicit = true
-
-[tool.uv.sources]
-my-private-package = { index = "my-private-registry" }
-```
-
-Após atualizar o `pyproject.toml`, regenere seu arquivo lock:
-
-```bash
-uv lock
-```
-
-<Warning>
-  Sempre faça commit do `uv.lock` atualizado junto com as alterações no `pyproject.toml`.
-  O arquivo lock é obrigatório para implantação — veja [Preparar para Implantação](/pt-BR/enterprise/guides/prepare-for-deployment).
-</Warning>
-
-## Passo 2: Configurar Credenciais de Autenticação
-
-O UV autentica em indexes privados usando variáveis de ambiente que seguem uma convenção de nomenclatura
-baseada no nome do index que você definiu no `pyproject.toml`:
-
-```
-UV_INDEX_{UPPER_NAME}_USERNAME
-UV_INDEX_{UPPER_NAME}_PASSWORD
-```
-
-Onde `{UPPER_NAME}` é o nome do seu index convertido para **maiúsculas** com **hifens substituídos por underscores**.
-
-Por exemplo, um index chamado `my-private-registry` usa:
-
-| Variável | Valor |
-|----------|-------|
-| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | Seu nome de usuário ou nome do token do registro |
-| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | Sua senha ou token/PAT do registro |
-
-<Warning>
-  Essas variáveis de ambiente **devem** ser adicionadas pelas configurações de **Variáveis de Ambiente** do CrewAI AMP —
-  globalmente ou no nível da implantação. Elas não podem ser definidas em arquivos `.env` ou codificadas no seu projeto.
-
-  Veja [Configurar Variáveis de Ambiente no AMP](#configurar-variáveis-de-ambiente-no-amp) abaixo.
-</Warning>
-
-## Referência de Provedores de Registro
-
-A tabela abaixo mostra o formato da URL de index e os valores de credenciais para provedores de registro comuns.
-Substitua os valores de exemplo pelos detalhes reais da sua organização e feed.
-
-| Provedor | URL do Index | Usuário | Senha |
-|----------|-------------|---------|-------|
-| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | Qualquer string não vazia (ex: `token`) | Personal Access Token (PAT) com escopo Packaging Read |
-| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | Nome de usuário do GitHub | Personal Access Token (classic) com escopo `read:packages` |
-| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | Project ou Personal Access Token com escopo `read_api` |
-| **AWS CodeArtifact** | Use a URL de `aws codeartifact get-repository-endpoint` | `aws` | Token de `aws codeartifact get-authorization-token` |
-| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | Chave de conta de serviço codificada em Base64 |
-| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | Nome de usuário ou email | Chave API ou token de identidade |
-| **Auto-hospedado (devpi, Nexus, etc.)** | URL da API simple do seu registro | Nome de usuário do registro | Senha do registro |
-
-<Tip>
-  Para **AWS CodeArtifact**, o token de autorização expira periodicamente.
-  Você precisará atualizar o valor de `UV_INDEX_*_PASSWORD` quando ele expirar.
-  Considere automatizar isso no seu pipeline de CI/CD.
-</Tip>
-
-## Configurar Variáveis de Ambiente no AMP
-
-As credenciais do registro privado devem ser configuradas como variáveis de ambiente no CrewAI AMP.
-Você tem duas opções:
-
-<Tabs>
-  <Tab title="Interface Web">
-    1. Faça login no [CrewAI AMP](https://app.crewai.com)
-    2. Navegue até sua automação
-    3. Abra a aba **Environment Variables**
-    4. Adicione cada variável (`UV_INDEX_*_USERNAME` e `UV_INDEX_*_PASSWORD`) com seu valor
-
-    Veja o passo [Deploy para AMP — Definir Variáveis de Ambiente](/pt-BR/enterprise/guides/deploy-to-amp#definir-as-variáveis-de-ambiente) para detalhes.
-  </Tab>
-  <Tab title="Implantação via CLI">
-    Adicione as variáveis ao seu arquivo `.env` local antes de executar `crewai deploy create`.
-    A CLI as transferirá com segurança para a plataforma:
-
-    ```bash
-    # .env
-    OPENAI_API_KEY=sk-...
-    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
-    ```
-
-    ```bash
-    crewai deploy create
-    ```
-  </Tab>
-</Tabs>
-
-<Warning>
-  **Nunca** faça commit de credenciais no seu repositório. Use variáveis de ambiente do AMP para todos os segredos.
-  O arquivo `.env` deve estar listado no `.gitignore`.
-</Warning>
-
-Para atualizar credenciais em uma implantação existente, veja [Atualizar Seu Crew — Variáveis de Ambiente](/pt-BR/enterprise/guides/update-crew).
-
-## Como Tudo se Conecta
-
-Quando o CrewAI AMP faz o build da sua automação, o fluxo de resolução funciona assim:
-
-<Steps>
-  <Step title="Build inicia">
-    O AMP busca seu repositório e lê o `pyproject.toml` e o `uv.lock`.
-  </Step>
-  <Step title="UV resolve dependências">
-    O UV lê `[tool.uv.sources]` para determinar de qual index cada pacote deve vir.
-  </Step>
-  <Step title="UV autentica">
-    Para cada index privado, o UV busca `UV_INDEX_{NAME}_USERNAME` e `UV_INDEX_{NAME}_PASSWORD`
-    nas variáveis de ambiente que você configurou no AMP.
-  </Step>
-  <Step title="Pacotes são instalados">
-    O UV baixa e instala todos os pacotes — tanto públicos (do PyPI) quanto privados (do seu registro).
-  </Step>
-  <Step title="Automação executa">
-    Seu crew ou flow inicia com todas as dependências disponíveis.
-  </Step>
-</Steps>
-
-## Solução de Problemas
-
-### Erros de Autenticação Durante o Build
-
-**Sintoma**: Build falha com `401 Unauthorized` ou `403 Forbidden` ao resolver um pacote privado.
-
-**Verifique**:
-- Os nomes das variáveis de ambiente `UV_INDEX_*` correspondem exatamente ao nome do seu index (maiúsculas, hifens -> underscores)
-- As credenciais estão definidas nas variáveis de ambiente do AMP, não apenas em um `.env` local
-- Seu token/PAT tem as permissões de leitura necessárias para o feed de pacotes
-- O token não expirou (especialmente relevante para AWS CodeArtifact)
-
-### Pacote Não Encontrado
-
-**Sintoma**: `No matching distribution found for my-private-package`.
-
-**Verifique**:
-- A URL do index no `pyproject.toml` termina com `/simple/`
-- A entrada `[tool.uv.sources]` mapeia o nome correto do pacote para o nome correto do index
-- O pacote está realmente publicado no seu registro privado
-- Execute `uv lock` localmente com as mesmas credenciais para verificar se a resolução funciona
-
-### Conflitos no Arquivo Lock
-
-**Sintoma**: `uv lock` falha ou produz resultados inesperados após adicionar um index privado.
-
-**Solução**: Defina as credenciais localmente e regenere:
-
-```bash
-export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
-export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
-uv lock
-```
-
-Em seguida, faça commit do `uv.lock` atualizado.
-
-## Guias Relacionados
-
-<CardGroup cols={3}>
-  <Card title="Preparar para Implantação" icon="clipboard-check" href="/pt-BR/enterprise/guides/prepare-for-deployment">
-    Verifique a estrutura do projeto e as dependências antes de implantar.
-  </Card>
-  <Card title="Deploy para AMP" icon="rocket" href="/pt-BR/enterprise/guides/deploy-to-amp">
-    Implante seu crew ou flow e configure variáveis de ambiente.
-  </Card>
-  <Card title="Atualizar Seu Crew" icon="arrows-rotate" href="/pt-BR/enterprise/guides/update-crew">
-    Atualize variáveis de ambiente e envie alterações para uma implantação em execução.
-  </Card>
-</CardGroup>

docs/pt-BR/learn/llm-connections.mdx

@@ -7,7 +7,7 @@ mode: "wide"
 
 ## Conecte o CrewAI a LLMs
 
-O CrewAI conecta-se a LLMs por meio de integrações nativas via SDK para os provedores mais populares (OpenAI, Anthropic, Google Gemini, Azure e AWS Bedrock), e usa o LiteLLM como alternativa flexível para todos os demais provedores.
+O CrewAI utiliza o LiteLLM para conectar-se a uma grande variedade de Modelos de Linguagem (LLMs). Essa integração proporciona grande versatilidade, permitindo que você utilize modelos de inúmeros provedores por meio de uma interface simples e unificada.
 
 <Note>
     Por padrão, o CrewAI usa o modelo `gpt-4o-mini`. Isso é determinado pela variável de ambiente `OPENAI_MODEL_NAME`, que tem como padrão "gpt-4o-mini" se não for definida.
@@ -40,14 +40,6 @@ O LiteLLM oferece suporte a uma ampla gama de provedores, incluindo, mas não se
 
 Para uma lista completa e sempre atualizada dos provedores suportados, consulte a [documentação de Provedores do LiteLLM](https://docs.litellm.ai/docs/providers).
 
-<Info>
-  Para usar qualquer provedor não coberto por uma integração nativa, adicione o LiteLLM como dependência ao seu projeto:
-  ```bash
-  uv add 'crewai[litellm]'
-  ```
-  Provedores nativos (OpenAI, Anthropic, Google Gemini, Azure, AWS Bedrock) usam seus próprios extras de SDK — consulte os [Exemplos de Configuração de Provedores](/pt-BR/concepts/llms#exemplos-de-configuração-de-provedores).
-</Info>
-
 ## Alterando a LLM
 
 Para utilizar uma LLM diferente com seus agentes CrewAI, você tem várias opções:

lib/crewai-files/src/crewai_files/__init__.py

@@ -152,4 +152,4 @@ __all__ = [
     "wrap_file_source",
 ]
 
-__version__ = "1.10.1a1"
+__version__ = "1.9.3"

lib/crewai-tools/pyproject.toml

@@ -8,10 +8,12 @@ authors = [
 ]
 requires-python = ">=3.10, <3.14"
 dependencies = [
+    "lancedb~=0.5.4",
     "pytube~=15.0.0",
     "requests~=2.32.5",
     "docker~=7.1.0",
-    "crewai==1.10.1a1",
+    "crewai==1.9.3",
+    "lancedb~=0.5.4",
     "tiktoken~=0.8.0",
     "beautifulsoup4~=4.13.4",
     "python-docx~=1.2.0",

lib/crewai-tools/src/crewai_tools/__init__.py

@@ -291,4 +291,4 @@ __all__ = [
     "ZapierActionTools",
 ]
 
-__version__ = "1.10.1a1"
+__version__ = "1.9.3"

lib/crewai-tools/tool.specs.json

@@ -20117,6 +20117,18 @@
       "humanized_name": "Web Automation Tool",
       "init_params_schema": {
         "$defs": {
+          "AvailableModel": {
+            "enum": [
+              "gpt-4o",
+              "gpt-4o-mini",
+              "claude-3-5-sonnet-latest",
+              "claude-3-7-sonnet-latest",
+              "computer-use-preview",
+              "gemini-2.0-flash"
+            ],
+            "title": "AvailableModel",
+            "type": "string"
+          },
           "EnvVar": {
             "properties": {
               "default": {
@@ -20194,6 +20206,17 @@
             "default": null,
             "title": "Model Api Key"
           },
+          "model_name": {
+            "anyOf": [
+              {
+                "$ref": "#/$defs/AvailableModel"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "default": "claude-3-7-sonnet-latest"
+          },
           "project_id": {
             "anyOf": [
               {

lib/crewai/pyproject.toml

@@ -42,7 +42,7 @@ dependencies = [
     "mcp~=1.26.0",
     "uv~=0.9.13",
     "aiosqlite~=0.21.0",
-    "lancedb>=0.29.2",
+    "lancedb>=0.4.0",
 ]
 
 [project.urls]
@@ -53,7 +53,7 @@ Repository = "https://github.com/crewAIInc/crewAI"
 
 [project.optional-dependencies]
 tools = [
-    "crewai-tools==1.10.1a1",
+    "crewai-tools==1.9.3",
 ]
 embeddings = [
     "tiktoken~=0.8.0"

lib/crewai/src/crewai/__init__.py

@@ -4,12 +4,14 @@ import urllib.request
 import warnings
 
 from crewai.agent.core import Agent
+from crewai.agent.planning_config import PlanningConfig
 from crewai.crew import Crew
 from crewai.crews.crew_output import CrewOutput
 from crewai.flow.flow import Flow
 from crewai.knowledge.knowledge import Knowledge
 from crewai.llm import LLM
 from crewai.llms.base_llm import BaseLLM
+from crewai.memory.unified_memory import Memory
 from crewai.process import Process
 from crewai.task import Task
 from crewai.tasks.llm_guardrail import LLMGuardrail
@@ -40,7 +42,7 @@ def _suppress_pydantic_deprecation_warnings() -> None:
 
 _suppress_pydantic_deprecation_warnings()
 
-__version__ = "1.10.1a1"
+__version__ = "1.9.3"
 _telemetry_submitted = False
 
 
@@ -71,25 +73,6 @@ def _track_install_async() -> None:
 
 
 _track_install_async()
-
-_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
-    "Memory": ("crewai.memory.unified_memory", "Memory"),
-}
-
-
-def __getattr__(name: str) -> Any:
-    """Lazily import heavy modules (e.g. Memory → lancedb) on first access."""
-    if name in _LAZY_IMPORTS:
-        module_path, attr = _LAZY_IMPORTS[name]
-        import importlib
-
-        mod = importlib.import_module(module_path)
-        val = getattr(mod, attr)
-        globals()[name] = val
-        return val
-    raise AttributeError(f"module 'crewai' has no attribute {name!r}")
-
-
 __all__ = [
     "LLM",
     "Agent",
@@ -100,6 +83,7 @@ __all__ = [
     "Knowledge",
     "LLMGuardrail",
     "Memory",
+    "PlanningConfig",
     "Process",
     "Task",
     "TaskOutput",

lib/crewai/src/crewai/agent/core.py

@@ -8,9 +8,11 @@ import time
 from typing import (
     TYPE_CHECKING,
     Any,
+    Final,
     Literal,
     cast,
 )
+from urllib.parse import urlparse
 
 from pydantic import (
     BaseModel,
@@ -22,6 +24,7 @@ from pydantic import (
 )
 from typing_extensions import Self
 
+from crewai.agent.planning_config import PlanningConfig
 from crewai.agent.utils import (
     ahandle_knowledge_retrieval,
     apply_training_data,
@@ -59,8 +62,16 @@ from crewai.knowledge.knowledge import Knowledge
 from crewai.knowledge.source.base_knowledge_source import BaseKnowledgeSource
 from crewai.lite_agent_output import LiteAgentOutput
 from crewai.llms.base_llm import BaseLLM
-from crewai.mcp import MCPServerConfig
-from crewai.mcp.tool_resolver import MCPToolResolver
+from crewai.mcp import (
+    MCPClient,
+    MCPServerConfig,
+    MCPServerHTTP,
+    MCPServerSSE,
+    MCPServerStdio,
+)
+from crewai.mcp.transports.http import HTTPTransport
+from crewai.mcp.transports.sse import SSETransport
+from crewai.mcp.transports.stdio import StdioTransport
 from crewai.rag.embeddings.types import EmbedderConfig
 from crewai.security.fingerprint import Fingerprint
 from crewai.tools.agent_tools.agent_tools import AgentTools
@@ -101,8 +112,18 @@ if TYPE_CHECKING:
     from crewai.utilities.types import LLMMessage
 
 
+# MCP Connection timeout constants (in seconds)
+MCP_CONNECTION_TIMEOUT: Final[int] = 10
+MCP_TOOL_EXECUTION_TIMEOUT: Final[int] = 30
+MCP_DISCOVERY_TIMEOUT: Final[int] = 15
+MCP_MAX_RETRIES: Final[int] = 3
+
 _passthrough_exceptions: tuple[type[Exception], ...] = ()
 
+# Simple in-memory cache for MCP tool schemas (duration: 5 minutes)
+_mcp_schema_cache: dict[str, Any] = {}
+_cache_ttl: Final[int] = 300  # 5 minutes
+
 
 class Agent(BaseAgent):
     """Represents an agent in a system.
@@ -134,7 +155,7 @@ class Agent(BaseAgent):
     model_config = ConfigDict()
 
     _times_executed: int = PrivateAttr(default=0)
-    _mcp_resolver: MCPToolResolver | None = PrivateAttr(default=None)
+    _mcp_clients: list[Any] = PrivateAttr(default_factory=list)
     _last_messages: list[LLMMessage] = PrivateAttr(default_factory=list)
     max_execution_time: int | None = Field(
         default=None,
@@ -191,13 +212,23 @@ class Agent(BaseAgent):
         default="safe",
         description="Mode for code execution: 'safe' (using Docker) or 'unsafe' (direct execution).",
     )
-    reasoning: bool = Field(
+    planning_config: PlanningConfig | None = Field(
+        default=None,
+        description="Configuration for agent planning before task execution.",
+    )
+    planning: bool = Field(
         default=False,
         description="Whether the agent should reflect and create a plan before executing a task.",
     )
+    reasoning: bool = Field(
+        default=False,
+        description="[DEPRECATED: Use planning_config instead] Whether the agent should reflect and create a plan before executing a task.",
+        deprecated=True,
+    )
     max_reasoning_attempts: int | None = Field(
         default=None,
-        description="Maximum number of reasoning attempts before executing the task. If None, will try until ready.",
+        description="[DEPRECATED: Use planning_config.max_attempts instead] Maximum number of reasoning attempts before executing the task. If None, will try until ready.",
+        deprecated=True,
     )
     embedder: EmbedderConfig | None = Field(
         default=None,
@@ -264,8 +295,26 @@ class Agent(BaseAgent):
         if self.allow_code_execution:
             self._validate_docker_installation()
 
+        # Handle backward compatibility: convert reasoning=True to planning_config
+        if self.reasoning and self.planning_config is None:
+            import warnings
+
+            warnings.warn(
+                "The 'reasoning' parameter is deprecated. Use 'planning_config=PlanningConfig()' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            self.planning_config = PlanningConfig(
+                max_attempts=self.max_reasoning_attempts,
+            )
+
         return self
 
+    @property
+    def planning_enabled(self) -> bool:
+        """Check if planning is enabled for this agent."""
+        return self.planning_config is not None or self.planning
+
     def _setup_agent_executor(self) -> None:
         if not self.cache_handler:
             self.cache_handler = CacheHandler()
@@ -334,7 +383,11 @@ class Agent(BaseAgent):
             ValueError: If the max execution time is not a positive integer.
             RuntimeError: If the agent execution fails for other reasons.
         """
-        handle_reasoning(self, task)
+        # Only call handle_reasoning for legacy CrewAgentExecutor
+        # For AgentExecutor, planning is handled in AgentExecutor.generate_plan()
+        if self.executor_class is not AgentExecutor:
+            handle_reasoning(self, task)
+
         self._inject_date_to_task(task)
 
         if self.tools_handler:
@@ -364,10 +417,10 @@ class Agent(BaseAgent):
                 )
                 if unified_memory is not None:
                     query = task.description
-                    matches = unified_memory.recall(query, limit=5)
+                    matches = unified_memory.recall(query, limit=10)
                     if matches:
                         memory = "Relevant memories:\n" + "\n".join(
-                            m.format() for m in matches
+                            f"- {m.record.content}" for m in matches
                         )
                 if memory.strip() != "":
                     task_prompt += self.i18n.slice("memory").format(memory=memory)
@@ -572,7 +625,10 @@ class Agent(BaseAgent):
             ValueError: If the max execution time is not a positive integer.
             RuntimeError: If the agent execution fails for other reasons.
         """
-        handle_reasoning(self, task)
+        if self.executor_class is not AgentExecutor:
+            handle_reasoning(
+                self, task
+            )  # we need this till CrewAgentExecutor migrates to AgentExecutor
         self._inject_date_to_task(task)
 
         if self.tools_handler:
@@ -602,10 +658,10 @@ class Agent(BaseAgent):
                 )
                 if unified_memory is not None:
                     query = task.description
-                    matches = unified_memory.recall(query, limit=5)
+                    matches = unified_memory.recall(query, limit=10)
                     if matches:
                         memory = "Relevant memories:\n" + "\n".join(
-                            m.format() for m in matches
+                            f"- {m.record.content}" for m in matches
                         )
                 if memory.strip() != "":
                     task_prompt += self.i18n.slice("memory").format(memory=memory)
@@ -844,11 +900,7 @@ class Agent(BaseAgent):
                 respect_context_window=self.respect_context_window,
                 request_within_rpm_limit=rpm_limit_fn,
                 callbacks=[TokenCalcHandler(self._token_process)],
-                response_model=(
-                    task.response_model or task.output_pydantic or task.output_json
-                )
-                if task
-                else None,
+                response_model=task.response_model if task else None,
             )
 
     def _update_executor_parameters(
@@ -877,11 +929,7 @@ class Agent(BaseAgent):
         self.agent_executor.stop = stop_words
         self.agent_executor.tools_names = get_tool_names(tools)
         self.agent_executor.tools_description = render_text_description_and_args(tools)
-        self.agent_executor.response_model = (
-            (task.response_model or task.output_pydantic or task.output_json)
-            if task
-            else None
-        )
+        self.agent_executor.response_model = task.response_model if task else None
 
         self.agent_executor.tools_handler = self.tools_handler
         self.agent_executor.request_within_rpm_limit = rpm_limit_fn
@@ -914,17 +962,544 @@ class Agent(BaseAgent):
     def get_mcp_tools(self, mcps: list[str | MCPServerConfig]) -> list[BaseTool]:
         """Convert MCP server references/configs to CrewAI tools.
 
-        Delegates to :class:`~crewai.mcp.tool_resolver.MCPToolResolver`.
+        Supports both string references (backwards compatible) and structured
+        configuration objects (MCPServerStdio, MCPServerHTTP, MCPServerSSE).
+
+        Args:
+            mcps: List of MCP server references (strings) or configurations.
+
+        Returns:
+            List of BaseTool instances from MCP servers.
         """
-        self._cleanup_mcp_clients()
-        self._mcp_resolver = MCPToolResolver(agent=self, logger=self._logger)
-        return self._mcp_resolver.resolve(mcps)
+        all_tools = []
+        clients = []
+
+        for mcp_config in mcps:
+            if isinstance(mcp_config, str):
+                tools = self._get_mcp_tools_from_string(mcp_config)
+            else:
+                tools, client = self._get_native_mcp_tools(mcp_config)
+                if client:
+                    clients.append(client)
+
+            all_tools.extend(tools)
+
+        # Store clients for cleanup
+        self._mcp_clients.extend(clients)
+        return all_tools
 
     def _cleanup_mcp_clients(self) -> None:
         """Cleanup MCP client connections after task execution."""
-        if self._mcp_resolver is not None:
-            self._mcp_resolver.cleanup()
-            self._mcp_resolver = None
+        if not self._mcp_clients:
+            return
+
+        async def _disconnect_all() -> None:
+            for client in self._mcp_clients:
+                if client and hasattr(client, "connected") and client.connected:
+                    await client.disconnect()
+
+        try:
+            asyncio.run(_disconnect_all())
+        except Exception as e:
+            self._logger.log("error", f"Error during MCP client cleanup: {e}")
+        finally:
+            self._mcp_clients.clear()
+
+    def _get_mcp_tools_from_string(self, mcp_ref: str) -> list[BaseTool]:
+        """Get tools from legacy string-based MCP references.
+
+        This method maintains backwards compatibility with string-based
+        MCP references (https://... and crewai-amp:...).
+
+        Args:
+            mcp_ref: String reference to MCP server.
+
+        Returns:
+            List of BaseTool instances.
+        """
+        if mcp_ref.startswith("crewai-amp:"):
+            return self._get_amp_mcp_tools(mcp_ref)
+        if mcp_ref.startswith("https://"):
+            return self._get_external_mcp_tools(mcp_ref)
+        return []
+
+    def _get_external_mcp_tools(self, mcp_ref: str) -> list[BaseTool]:
+        """Get tools from external HTTPS MCP server with graceful error handling."""
+        from crewai.tools.mcp_tool_wrapper import MCPToolWrapper
+
+        # Parse server URL and optional tool name
+        if "#" in mcp_ref:
+            server_url, specific_tool = mcp_ref.split("#", 1)
+        else:
+            server_url, specific_tool = mcp_ref, None
+
+        server_params = {"url": server_url}
+        server_name = self._extract_server_name(server_url)
+
+        try:
+            # Get tool schemas with timeout and error handling
+            tool_schemas = self._get_mcp_tool_schemas(server_params)
+
+            if not tool_schemas:
+                self._logger.log(
+                    "warning", f"No tools discovered from MCP server: {server_url}"
+                )
+                return []
+
+            tools = []
+            for tool_name, schema in tool_schemas.items():
+                # Skip if specific tool requested and this isn't it
+                if specific_tool and tool_name != specific_tool:
+                    continue
+
+                try:
+                    wrapper = MCPToolWrapper(
+                        mcp_server_params=server_params,
+                        tool_name=tool_name,
+                        tool_schema=schema,
+                        server_name=server_name,
+                    )
+                    tools.append(wrapper)
+                except Exception as e:
+                    self._logger.log(
+                        "warning",
+                        f"Failed to create MCP tool wrapper for {tool_name}: {e}",
+                    )
+                    continue
+
+            if specific_tool and not tools:
+                self._logger.log(
+                    "warning",
+                    f"Specific tool '{specific_tool}' not found on MCP server: {server_url}",
+                )
+
+            return cast(list[BaseTool], tools)
+
+        except Exception as e:
+            self._logger.log(
+                "warning", f"Failed to connect to MCP server {server_url}: {e}"
+            )
+            return []
+
+    def _get_native_mcp_tools(
+        self, mcp_config: MCPServerConfig
+    ) -> tuple[list[BaseTool], Any | None]:
+        """Get tools from MCP server using structured configuration.
+
+        This method creates an MCP client based on the configuration type,
+        connects to the server, discovers tools, applies filtering, and
+        returns wrapped tools along with the client instance for cleanup.
+
+        Args:
+            mcp_config: MCP server configuration (MCPServerStdio, MCPServerHTTP, or MCPServerSSE).
+
+        Returns:
+            Tuple of (list of BaseTool instances, MCPClient instance for cleanup).
+        """
+        from crewai.tools.base_tool import BaseTool
+        from crewai.tools.mcp_native_tool import MCPNativeTool
+
+        transport: StdioTransport | HTTPTransport | SSETransport
+        if isinstance(mcp_config, MCPServerStdio):
+            transport = StdioTransport(
+                command=mcp_config.command,
+                args=mcp_config.args,
+                env=mcp_config.env,
+            )
+            server_name = f"{mcp_config.command}_{'_'.join(mcp_config.args)}"
+        elif isinstance(mcp_config, MCPServerHTTP):
+            transport = HTTPTransport(
+                url=mcp_config.url,
+                headers=mcp_config.headers,
+                streamable=mcp_config.streamable,
+            )
+            server_name = self._extract_server_name(mcp_config.url)
+        elif isinstance(mcp_config, MCPServerSSE):
+            transport = SSETransport(
+                url=mcp_config.url,
+                headers=mcp_config.headers,
+            )
+            server_name = self._extract_server_name(mcp_config.url)
+        else:
+            raise ValueError(f"Unsupported MCP server config type: {type(mcp_config)}")
+
+        client = MCPClient(
+            transport=transport,
+            cache_tools_list=mcp_config.cache_tools_list,
+        )
+
+        async def _setup_client_and_list_tools() -> list[dict[str, Any]]:
+            """Async helper to connect and list tools in same event loop."""
+
+            try:
+                if not client.connected:
+                    await client.connect()
+
+                tools_list = await client.list_tools()
+
+                try:
+                    await client.disconnect()
+                    # Small delay to allow background tasks to finish cleanup
+                    # This helps prevent "cancel scope in different task" errors
+                    # when asyncio.run() closes the event loop
+                    await asyncio.sleep(0.1)
+                except Exception as e:
+                    self._logger.log("error", f"Error during disconnect: {e}")
+
+                return tools_list
+            except Exception as e:
+                if client.connected:
+                    await client.disconnect()
+                    await asyncio.sleep(0.1)
+                raise RuntimeError(
+                    f"Error during setup client and list tools: {e}"
+                ) from e
+
+        try:
+            try:
+                asyncio.get_running_loop()
+                import concurrent.futures
+
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(
+                        asyncio.run, _setup_client_and_list_tools()
+                    )
+                    tools_list = future.result()
+            except RuntimeError:
+                try:
+                    tools_list = asyncio.run(_setup_client_and_list_tools())
+                except RuntimeError as e:
+                    error_msg = str(e).lower()
+                    if "cancel scope" in error_msg or "task" in error_msg:
+                        raise ConnectionError(
+                            "MCP connection failed due to event loop cleanup issues. "
+                            "This may be due to authentication errors or server unavailability."
+                        ) from e
+                except asyncio.CancelledError as e:
+                    raise ConnectionError(
+                        "MCP connection was cancelled. This may indicate an authentication "
+                        "error or server unavailability."
+                    ) from e
+
+            if mcp_config.tool_filter:
+                filtered_tools = []
+                for tool in tools_list:
+                    if callable(mcp_config.tool_filter):
+                        try:
+                            from crewai.mcp.filters import ToolFilterContext
+
+                            context = ToolFilterContext(
+                                agent=self,
+                                server_name=server_name,
+                                run_context=None,
+                            )
+                            if mcp_config.tool_filter(context, tool):  # type: ignore[call-arg, arg-type]
+                                filtered_tools.append(tool)
+                        except (TypeError, AttributeError):
+                            if mcp_config.tool_filter(tool):  # type: ignore[call-arg, arg-type]
+                                filtered_tools.append(tool)
+                    else:
+                        # Not callable - include tool
+                        filtered_tools.append(tool)
+                tools_list = filtered_tools
+
+            tools = []
+            for tool_def in tools_list:
+                tool_name = tool_def.get("name", "")
+                if not tool_name:
+                    continue
+
+                # Convert inputSchema to Pydantic model if present
+                args_schema = None
+                if tool_def.get("inputSchema"):
+                    args_schema = self._json_schema_to_pydantic(
+                        tool_name, tool_def["inputSchema"]
+                    )
+
+                tool_schema = {
+                    "description": tool_def.get("description", ""),
+                    "args_schema": args_schema,
+                }
+
+                try:
+                    native_tool = MCPNativeTool(
+                        mcp_client=client,
+                        tool_name=tool_name,
+                        tool_schema=tool_schema,
+                        server_name=server_name,
+                    )
+                    tools.append(native_tool)
+                except Exception as e:
+                    self._logger.log("error", f"Failed to create native MCP tool: {e}")
+                    continue
+
+            return cast(list[BaseTool], tools), client
+        except Exception as e:
+            if client.connected:
+                asyncio.run(client.disconnect())
+
+            raise RuntimeError(f"Failed to get native MCP tools: {e}") from e
+
+    def _get_amp_mcp_tools(self, amp_ref: str) -> list[BaseTool]:
+        """Get tools from CrewAI AMP MCP marketplace."""
+        # Parse: "crewai-amp:mcp-name" or "crewai-amp:mcp-name#tool_name"
+        amp_part = amp_ref.replace("crewai-amp:", "")
+        if "#" in amp_part:
+            mcp_name, specific_tool = amp_part.split("#", 1)
+        else:
+            mcp_name, specific_tool = amp_part, None
+
+        # Call AMP API to get MCP server URLs
+        mcp_servers = self._fetch_amp_mcp_servers(mcp_name)
+
+        tools = []
+        for server_config in mcp_servers:
+            server_ref = server_config["url"]
+            if specific_tool:
+                server_ref += f"#{specific_tool}"
+            server_tools = self._get_external_mcp_tools(server_ref)
+            tools.extend(server_tools)
+
+        return tools
+
+    @staticmethod
+    def _extract_server_name(server_url: str) -> str:
+        """Extract clean server name from URL for tool prefixing."""
+
+        parsed = urlparse(server_url)
+        domain = parsed.netloc.replace(".", "_")
+        path = parsed.path.replace("/", "_").strip("_")
+        return f"{domain}_{path}" if path else domain
+
+    def _get_mcp_tool_schemas(
+        self, server_params: dict[str, Any]
+    ) -> dict[str, dict[str, Any]]:
+        """Get tool schemas from MCP server for wrapper creation with caching."""
+        server_url = server_params["url"]
+
+        # Check cache first
+        cache_key = server_url
+        current_time = time.time()
+
+        if cache_key in _mcp_schema_cache:
+            cached_data, cache_time = _mcp_schema_cache[cache_key]
+            if current_time - cache_time < _cache_ttl:
+                self._logger.log(
+                    "debug", f"Using cached MCP tool schemas for {server_url}"
+                )
+                return cached_data  # type: ignore[no-any-return]
+
+        try:
+            schemas = asyncio.run(self._get_mcp_tool_schemas_async(server_params))
+
+            # Cache successful results
+            _mcp_schema_cache[cache_key] = (schemas, current_time)
+
+            return schemas
+        except Exception as e:
+            # Log warning but don't raise - this allows graceful degradation
+            self._logger.log(
+                "warning", f"Failed to get MCP tool schemas from {server_url}: {e}"
+            )
+            return {}
+
+    async def _get_mcp_tool_schemas_async(
+        self, server_params: dict[str, Any]
+    ) -> dict[str, dict[str, Any]]:
+        """Async implementation of MCP tool schema retrieval with timeouts and retries."""
+        server_url = server_params["url"]
+        return await self._retry_mcp_discovery(
+            self._discover_mcp_tools_with_timeout, server_url
+        )
+
+    async def _retry_mcp_discovery(
+        self, operation_func: Any, server_url: str
+    ) -> dict[str, dict[str, Any]]:
+        """Retry MCP discovery operation with exponential backoff, avoiding try-except in loop."""
+        last_error = None
+
+        for attempt in range(MCP_MAX_RETRIES):
+            # Execute single attempt outside try-except loop structure
+            result, error, should_retry = await self._attempt_mcp_discovery(
+                operation_func, server_url
+            )
+
+            # Success case - return immediately
+            if result is not None:
+                return result
+
+            # Non-retryable error - raise immediately
+            if not should_retry:
+                raise RuntimeError(error)
+
+            # Retryable error - continue with backoff
+            last_error = error
+            if attempt < MCP_MAX_RETRIES - 1:
+                wait_time = 2**attempt  # Exponential backoff
+                await asyncio.sleep(wait_time)
+
+        raise RuntimeError(
+            f"Failed to discover MCP tools after {MCP_MAX_RETRIES} attempts: {last_error}"
+        )
+
+    @staticmethod
+    async def _attempt_mcp_discovery(
+        operation_func: Any, server_url: str
+    ) -> tuple[dict[str, dict[str, Any]] | None, str, bool]:
+        """Attempt single MCP discovery operation and return (result, error_message, should_retry)."""
+        try:
+            result = await operation_func(server_url)
+            return result, "", False
+
+        except ImportError:
+            return (
+                None,
+                "MCP library not available. Please install with: pip install mcp",
+                False,
+            )
+
+        except asyncio.TimeoutError:
+            return (
+                None,
+                f"MCP discovery timed out after {MCP_DISCOVERY_TIMEOUT} seconds",
+                True,
+            )
+
+        except Exception as e:
+            error_str = str(e).lower()
+
+            # Classify errors as retryable or non-retryable
+            if "authentication" in error_str or "unauthorized" in error_str:
+                return None, f"Authentication failed for MCP server: {e!s}", False
+            if "connection" in error_str or "network" in error_str:
+                return None, f"Network connection failed: {e!s}", True
+            if "json" in error_str or "parsing" in error_str:
+                return None, f"Server response parsing error: {e!s}", True
+            return None, f"MCP discovery error: {e!s}", False
+
+    async def _discover_mcp_tools_with_timeout(
+        self, server_url: str
+    ) -> dict[str, dict[str, Any]]:
+        """Discover MCP tools with timeout wrapper."""
+        return await asyncio.wait_for(
+            self._discover_mcp_tools(server_url), timeout=MCP_DISCOVERY_TIMEOUT
+        )
+
+    async def _discover_mcp_tools(self, server_url: str) -> dict[str, dict[str, Any]]:
+        """Discover tools from MCP server with proper timeout handling."""
+        from mcp import ClientSession
+        from mcp.client.streamable_http import streamablehttp_client
+
+        async with streamablehttp_client(server_url) as (read, write, _):
+            async with ClientSession(read, write) as session:
+                # Initialize the connection with timeout
+                await asyncio.wait_for(
+                    session.initialize(), timeout=MCP_CONNECTION_TIMEOUT
+                )
+
+                # List available tools with timeout
+                tools_result = await asyncio.wait_for(
+                    session.list_tools(),
+                    timeout=MCP_DISCOVERY_TIMEOUT - MCP_CONNECTION_TIMEOUT,
+                )
+
+                schemas = {}
+                for tool in tools_result.tools:
+                    args_schema = None
+                    if hasattr(tool, "inputSchema") and tool.inputSchema:
+                        args_schema = self._json_schema_to_pydantic(
+                            sanitize_tool_name(tool.name), tool.inputSchema
+                        )
+
+                    schemas[sanitize_tool_name(tool.name)] = {
+                        "description": getattr(tool, "description", ""),
+                        "args_schema": args_schema,
+                    }
+                return schemas
+
+    def _json_schema_to_pydantic(
+        self, tool_name: str, json_schema: dict[str, Any]
+    ) -> type:
+        """Convert JSON Schema to Pydantic model for tool arguments.
+
+        Args:
+            tool_name: Name of the tool (used for model naming)
+            json_schema: JSON Schema dict with 'properties', 'required', etc.
+
+        Returns:
+            Pydantic BaseModel class
+        """
+        from pydantic import Field, create_model
+
+        properties = json_schema.get("properties", {})
+        required_fields = json_schema.get("required", [])
+
+        field_definitions: dict[str, Any] = {}
+
+        for field_name, field_schema in properties.items():
+            field_type = self._json_type_to_python(field_schema)
+            field_description = field_schema.get("description", "")
+
+            is_required = field_name in required_fields
+
+            if is_required:
+                field_definitions[field_name] = (
+                    field_type,
+                    Field(..., description=field_description),
+                )
+            else:
+                field_definitions[field_name] = (
+                    field_type | None,
+                    Field(default=None, description=field_description),
+                )
+
+        model_name = f"{tool_name.replace('-', '_').replace(' ', '_')}Schema"
+        return create_model(model_name, **field_definitions)  # type: ignore[no-any-return]
+
+    def _json_type_to_python(self, field_schema: dict[str, Any]) -> type:
+        """Convert JSON Schema type to Python type.
+
+        Args:
+            field_schema: JSON Schema field definition
+
+        Returns:
+            Python type
+        """
+
+        json_type = field_schema.get("type")
+
+        if "anyOf" in field_schema:
+            types: list[type] = []
+            for option in field_schema["anyOf"]:
+                if "const" in option:
+                    types.append(str)
+                else:
+                    types.append(self._json_type_to_python(option))
+            unique_types = list(set(types))
+            if len(unique_types) > 1:
+                result: Any = unique_types[0]
+                for t in unique_types[1:]:
+                    result = result | t
+                return result  # type: ignore[no-any-return]
+            return unique_types[0]
+
+        type_mapping: dict[str | None, type] = {
+            "string": str,
+            "number": float,
+            "integer": int,
+            "boolean": bool,
+            "array": list,
+            "object": dict,
+        }
+
+        return type_mapping.get(json_type, Any)
+
+    @staticmethod
+    def _fetch_amp_mcp_servers(mcp_name: str) -> list[dict[str, Any]]:
+        """Fetch MCP server configurations from CrewAI AMP API."""
+        # TODO: Implement AMP API call to "integrations/mcps" endpoint
+        # Should return list of server configs with URLs
+        return []
 
     @staticmethod
     def get_multimodal_tools() -> Sequence[BaseTool]:
@@ -1173,8 +1748,7 @@ class Agent(BaseAgent):
 
             existing_names = {sanitize_tool_name(t.name) for t in raw_tools}
             raw_tools.extend(
-                mt
-                for mt in create_memory_tools(agent_memory)
+                mt for mt in create_memory_tools(agent_memory)
                 if sanitize_tool_name(mt.name) not in existing_names
             )
 
@@ -1264,11 +1838,11 @@ class Agent(BaseAgent):
                     ),
                 )
                 start_time = time.time()
-                matches = agent_memory.recall(formatted_messages, limit=5)
+                matches = agent_memory.recall(formatted_messages, limit=10)
                 memory_block = ""
                 if matches:
                     memory_block = "Relevant memories:\n" + "\n".join(
-                        m.format() for m in matches
+                        f"- {m.record.content}" for m in matches
                     )
                 if memory_block:
                     formatted_messages += "\n\n" + self.i18n.slice("memory").format(
@@ -1399,15 +1973,14 @@ class Agent(BaseAgent):
             if isinstance(messages, str):
                 input_str = messages
             else:
-                input_str = (
-                    "\n".join(
-                        str(msg.get("content", ""))
-                        for msg in messages
-                        if msg.get("content")
-                    )
-                    or "User request"
-                )
-            raw = f"Input: {input_str}\nAgent: {self.role}\nResult: {output_text}"
+                input_str = "\n".join(
+                    str(msg.get("content", "")) for msg in messages if msg.get("content")
+                ) or "User request"
+            raw = (
+                f"Input: {input_str}\n"
+                f"Agent: {self.role}\n"
+                f"Result: {output_text}"
+            )
             extracted = agent_memory.extract_memories(raw)
             if extracted:
                 agent_memory.remember_many(extracted)

lib/crewai/src/crewai/agent/planning_config.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class PlanningConfig(BaseModel):
+    """Configuration for agent planning/reasoning before task execution.
+
+    This allows users to customize the planning behavior including prompts,
+    iteration limits, and the LLM used for planning.
+
+    Note: To disable planning, don't pass a planning_config or set planning=False
+    on the Agent. The presence of a PlanningConfig enables planning.
+
+    Attributes:
+        max_attempts: Maximum number of planning refinement attempts.
+            If None, will continue until the agent indicates readiness.
+        max_steps: Maximum number of steps in the generated plan.
+        system_prompt: Custom system prompt for planning. Uses default if None.
+        plan_prompt: Custom prompt for creating the initial plan.
+        refine_prompt: Custom prompt for refining the plan.
+        llm: LLM to use for planning. Uses agent's LLM if None.
+
+    Example:
+        ```python
+        from crewai import Agent
+        from crewai.agent.planning_config import PlanningConfig
+
+        # Simple usage
+        agent = Agent(
+            role="Researcher",
+            goal="Research topics",
+            backstory="Expert researcher",
+            planning_config=PlanningConfig(),
+        )
+
+        # Customized planning
+        agent = Agent(
+            role="Researcher",
+            goal="Research topics",
+            backstory="Expert researcher",
+            planning_config=PlanningConfig(
+                max_attempts=3,
+                max_steps=10,
+                plan_prompt="Create a focused plan for: {description}",
+                llm="gpt-4o-mini",  # Use cheaper model for planning
+            ),
+        )
+        ```
+    """
+
+    max_attempts: int | None = Field(
+        default=None,
+        description=(
+            "Maximum number of planning refinement attempts. "
+            "If None, will continue until the agent indicates readiness."
+        ),
+    )
+    max_steps: int = Field(
+        default=20,
+        description="Maximum number of steps in the generated plan.",
+        ge=1,
+    )
+    system_prompt: str | None = Field(
+        default=None,
+        description="Custom system prompt for planning. Uses default if None.",
+    )
+    plan_prompt: str | None = Field(
+        default=None,
+        description="Custom prompt for creating the initial plan.",
+    )
+    refine_prompt: str | None = Field(
+        default=None,
+        description="Custom prompt for refining the plan.",
+    )
+    llm: str | Any | None = Field(
+        default=None,
+        description="LLM to use for planning. Uses agent's LLM if None.",
+    )
+
+    model_config = {"arbitrary_types_allowed": True}

lib/crewai/src/crewai/agent/utils.py

@@ -28,13 +28,20 @@ if TYPE_CHECKING:
 
 
 def handle_reasoning(agent: Agent, task: Task) -> None:
-    """Handle the reasoning process for an agent before task execution.
+    """Handle the reasoning/planning process for an agent before task execution.
+
+    This function checks if planning is enabled for the agent and, if so,
+    creates a plan that gets appended to the task description.
+
+    Note: This function is used by CrewAgentExecutor (legacy path).
+    For AgentExecutor, planning is handled in AgentExecutor.generate_plan().
 
     Args:
         agent: The agent performing the task.
         task: The task to execute.
     """
-    if not agent.reasoning:
+    # Check if planning is enabled using the planning_enabled property
+    if not getattr(agent, "planning_enabled", False):
         return
 
     try:
@@ -43,13 +50,13 @@ def handle_reasoning(agent: Agent, task: Task) -> None:
             AgentReasoningOutput,
         )
 
-        reasoning_handler = AgentReasoning(task=task, agent=agent)
-        reasoning_output: AgentReasoningOutput = (
-            reasoning_handler.handle_agent_reasoning()
+        planning_handler = AgentReasoning(agent=agent, task=task)
+        planning_output: AgentReasoningOutput = (
+            planning_handler.handle_agent_reasoning()
         )
-        task.description += f"\n\nReasoning Plan:\n{reasoning_output.plan.plan}"
+        task.description += f"\n\nPlanning:\n{planning_output.plan.plan}"
     except Exception as e:
-        agent._logger.log("error", f"Error during reasoning process: {e!s}")
+        agent._logger.log("error", f"Error during planning: {e!s}")
 
 
 def build_task_prompt_with_schema(task: Task, task_prompt: str, i18n: I18N) -> str:

lib/crewai/src/crewai/agents/agent_builder/base_agent.py

@@ -4,8 +4,7 @@ from abc import ABC, abstractmethod
 from collections.abc import Callable
 from copy import copy as shallow_copy
 from hashlib import md5
-import re
-from typing import Any, Final, Literal
+from typing import Any, Literal
 import uuid
 
 from pydantic import (
@@ -37,11 +36,6 @@ from crewai.utilities.rpm_controller import RPMController
 from crewai.utilities.string_utils import interpolate_only
 
 
-_SLUG_RE: Final[re.Pattern[str]] = re.compile(
-    r"^(?:crewai-amp:)?[a-zA-Z0-9][a-zA-Z0-9_-]*(?:#\w+)?$"
-)
-
-
 PlatformApp = Literal[
     "asana",
     "box",
@@ -203,7 +197,7 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
     )
     mcps: list[str | MCPServerConfig] | None = Field(
         default=None,
-        description="List of MCP server references. Supports 'https://server.com/path' for external servers and bare slugs like 'notion' for connected MCP integrations. Use '#tool_name' suffix for specific tools.",
+        description="List of MCP server references. Supports 'https://server.com/path' for external servers and 'crewai-amp:mcp-name' for AMP marketplace. Use '#tool_name' suffix for specific tools.",
     )
     memory: Any = Field(
         default=None,
@@ -282,16 +276,14 @@ class BaseAgent(BaseModel, ABC, metaclass=AgentMeta):
         validated_mcps: list[str | MCPServerConfig] = []
         for mcp in mcps:
             if isinstance(mcp, str):
-                if mcp.startswith("https://"):
-                    validated_mcps.append(mcp)
-                elif _SLUG_RE.match(mcp):
+                if mcp.startswith(("https://", "crewai-amp:")):
                     validated_mcps.append(mcp)
                 else:
                     raise ValueError(
-                        f"Invalid MCP reference: {mcp!r}. "
-                        "String references must be an 'https://' URL or a valid "
-                        "slug (e.g. 'notion', 'notion#search', 'crewai-amp:notion')."
+                        f"Invalid MCP reference: {mcp}. "
+                        "String references must start with 'https://' or 'crewai-amp:'"
                     )
+
             elif isinstance(mcp, (MCPServerConfig)):
                 validated_mcps.append(mcp)
             else:

lib/crewai/src/crewai/agents/agent_builder/base_agent_executor_mixin.py

@@ -30,7 +30,7 @@ class CrewAgentExecutorMixin:
         memory = getattr(self.agent, "memory", None) or (
             getattr(self.crew, "_memory", None) if self.crew else None
         )
-        if memory is None or not self.task or getattr(memory, "_read_only", False):
+        if memory is None or not self.task:
             return
         if (
             f"Action: {sanitize_tool_name('Delegate work to coworker')}"

lib/crewai/src/crewai/agents/crew_agent_executor.py

@@ -50,7 +50,6 @@ from crewai.utilities.agent_utils import (
     handle_unknown_error,
     has_reached_max_iterations,
     is_context_length_exceeded,
-    parse_tool_call_args,
     process_llm_response,
     track_delegation_if_needed,
 )
@@ -895,9 +894,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             ToolUsageStartedEvent,
         )
 
-        args_dict, parse_error = parse_tool_call_args(func_args, func_name, call_id, original_tool)
-        if parse_error is not None:
-            return parse_error
+        if isinstance(func_args, str):
+            try:
+                args_dict = json.loads(func_args)
+            except json.JSONDecodeError:
+                args_dict = {}
+        else:
+            args_dict = func_args
 
         if original_tool is None:
             for tool in self.original_tools or []:
@@ -1259,7 +1262,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         formatted_answer, tool_result
                     )
 
-                await self._ainvoke_step_callback(formatted_answer)  # type: ignore[arg-type]
+                self._invoke_step_callback(formatted_answer)  # type: ignore[arg-type]
                 self._append_message(formatted_answer.text)  # type: ignore[union-attr]
 
             except OutputParserError as e:
@@ -1374,7 +1377,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         output=answer,
                         text=answer,
                     )
-                    await self._ainvoke_step_callback(formatted_answer)
+                    self._invoke_step_callback(formatted_answer)
                     self._append_message(answer)  # Save final answer to messages
                     self._show_logs(formatted_answer)
                     return formatted_answer
@@ -1386,7 +1389,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         output=answer,
                         text=output_json,
                     )
-                    await self._ainvoke_step_callback(formatted_answer)
+                    self._invoke_step_callback(formatted_answer)
                     self._append_message(output_json)
                     self._show_logs(formatted_answer)
                     return formatted_answer
@@ -1397,7 +1400,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                     output=str(answer),
                     text=str(answer),
                 )
-                await self._ainvoke_step_callback(formatted_answer)
+                self._invoke_step_callback(formatted_answer)
                 self._append_message(str(answer))  # Save final answer to messages
                 self._show_logs(formatted_answer)
                 return formatted_answer
@@ -1491,7 +1494,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
     def _invoke_step_callback(
         self, formatted_answer: AgentAction | AgentFinish
     ) -> None:
-        """Invoke step callback (sync context).
+        """Invoke step callback.
 
         Args:
             formatted_answer: Current agent response.
@@ -1501,19 +1504,6 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             if inspect.iscoroutine(cb_result):
                 asyncio.run(cb_result)
 
-    async def _ainvoke_step_callback(
-        self, formatted_answer: AgentAction | AgentFinish
-    ) -> None:
-        """Invoke step callback (async context).
-
-        Args:
-            formatted_answer: Current agent response.
-        """
-        if self.step_callback:
-            cb_result = self.step_callback(formatted_answer)
-            if inspect.iscoroutine(cb_result):
-                await cb_result
-
     def _append_message(
         self, text: str, role: Literal["user", "assistant", "system"] = "assistant"
     ) -> None:

lib/crewai/src/crewai/cli/constants.py

@@ -69,7 +69,7 @@ ENV_VARS: dict[str, list[dict[str, Any]]] = {
         },
         {
             "prompt": "Enter your AWS Region Name (press Enter to skip)",
-            "key_name": "AWS_DEFAULT_REGION",
+            "key_name": "AWS_REGION_NAME",
         },
     ],
     "azure": [

lib/crewai/src/crewai/cli/memory_tui.py

@@ -290,20 +290,13 @@ class MemoryTUI(App[None]):
         if self._memory is None:
             panel.update(self._init_error or "No memory loaded.")
             return
-        display_limit = 1000
         info = self._memory.info(path)
         self._last_scope_info = info
-        self._entries = self._memory.list_records(scope=path, limit=display_limit)
+        self._entries = self._memory.list_records(scope=path, limit=200)
         panel.update(_format_scope_info(info))
         panel.border_title = "Detail"
         entry_list = self.query_one("#entry-list", OptionList)
-        capped = info.record_count > display_limit
-        count_label = (
-            f"Entries (showing {display_limit} of {info.record_count} — display limit)"
-            if capped
-            else f"Entries ({len(self._entries)})"
-        )
-        entry_list.border_title = count_label
+        entry_list.border_title = f"Entries ({len(self._entries)})"
         self._populate_entry_list()
 
     def on_option_list_option_highlighted(
@@ -383,11 +376,6 @@ class MemoryTUI(App[None]):
                 return
 
             info_lines: list[str] = []
-            info_lines.append(
-                "[dim italic]Searched the full dataset"
-                + (f" within [bold]{scope}[/]" if scope else "")
-                + " using the recall flow (semantic + recency + importance).[/]\n"
-            )
             if not self._custom_embedder:
                 info_lines.append(
                     "[dim italic]Note: Using default OpenAI embedder. "

lib/crewai/src/crewai/cli/plus_api.py

@@ -190,15 +190,6 @@ class PlusAPI:
             timeout=30,
         )
 
-    def get_mcp_configs(self, slugs: list[str]) -> httpx.Response:
-        """Get MCP server configurations for the given slugs."""
-        return self._make_request(
-            "GET",
-            f"{self.INTEGRATIONS_RESOURCE}/mcp_configs",
-            params={"slugs": ",".join(slugs)},
-            timeout=30,
-        )
-
     def get_triggers(self) -> httpx.Response:
         """Get all available triggers from integrations."""
         return self._make_request("GET", f"{self.INTEGRATIONS_RESOURCE}/apps")

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

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.10.1a1"
+    "crewai[tools]==1.9.3"
 ]
 
 [project.scripts]

lib/crewai/src/crewai/cli/templates/flow/pyproject.toml

@@ -5,7 +5,7 @@ description = "{{name}} using crewAI"
 authors = [{ name = "Your Name", email = "you@example.com" }]
 requires-python = ">=3.10,<3.14"
 dependencies = [
-    "crewai[tools]==1.10.1a1"
+    "crewai[tools]==1.9.3"
 ]
 
 [project.scripts]

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

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

lib/crewai/src/crewai/events/__init__.py

@@ -63,7 +63,6 @@ from crewai.events.types.logging_events import (
     AgentLogsStartedEvent,
 )
 from crewai.events.types.mcp_events import (
-    MCPConfigFetchFailedEvent,
     MCPConnectionCompletedEvent,
     MCPConnectionFailedEvent,
     MCPConnectionStartedEvent,
@@ -166,7 +165,6 @@ __all__ = [
     "LiteAgentExecutionCompletedEvent",
     "LiteAgentExecutionErrorEvent",
     "LiteAgentExecutionStartedEvent",
-    "MCPConfigFetchFailedEvent",
     "MCPConnectionCompletedEvent",
     "MCPConnectionFailedEvent",
     "MCPConnectionStartedEvent",

lib/crewai/src/crewai/events/event_listener.py

@@ -68,7 +68,6 @@ from crewai.events.types.logging_events import (
     AgentLogsStartedEvent,
 )
 from crewai.events.types.mcp_events import (
-    MCPConfigFetchFailedEvent,
     MCPConnectionCompletedEvent,
     MCPConnectionFailedEvent,
     MCPConnectionStartedEvent,
@@ -666,16 +665,6 @@ class EventListener(BaseEventListener):
                 event.error_type,
             )
 
-        @crewai_event_bus.on(MCPConfigFetchFailedEvent)
-        def on_mcp_config_fetch_failed(
-            _: Any, event: MCPConfigFetchFailedEvent
-        ) -> None:
-            self.formatter.handle_mcp_config_fetch_failed(
-                event.slug,
-                event.error,
-                event.error_type,
-            )
-
         @crewai_event_bus.on(MCPToolExecutionStartedEvent)
         def on_mcp_tool_execution_started(
             _: Any, event: MCPToolExecutionStartedEvent

lib/crewai/src/crewai/events/event_types.py

@@ -67,7 +67,6 @@ from crewai.events.types.llm_guardrail_events import (
     LLMGuardrailStartedEvent,
 )
 from crewai.events.types.mcp_events import (
-    MCPConfigFetchFailedEvent,
     MCPConnectionCompletedEvent,
     MCPConnectionFailedEvent,
     MCPConnectionStartedEvent,
@@ -182,5 +181,4 @@ EventTypes = (
     | MCPToolExecutionStartedEvent
     | MCPToolExecutionCompletedEvent
     | MCPToolExecutionFailedEvent
-    | MCPConfigFetchFailedEvent
 )

lib/crewai/src/crewai/events/types/mcp_events.py

@@ -83,16 +83,3 @@ class MCPToolExecutionFailedEvent(MCPEvent):
     error_type: str | None = None  # "timeout", "validation", "server_error", etc.
     started_at: datetime | None = None
     failed_at: datetime | None = None
-
-
-class MCPConfigFetchFailedEvent(BaseEvent):
-    """Event emitted when fetching an AMP MCP server config fails.
-
-    This covers cases where the slug is not connected, the API call
-    failed, or native MCP resolution failed after config was fetched.
-    """
-
-    type: str = "mcp_config_fetch_failed"
-    slug: str
-    error: str
-    error_type: str | None = None  # "not_connected", "api_error", "connection_failed"

lib/crewai/src/crewai/events/types/reasoning_events.py

@@ -9,7 +9,7 @@ class ReasoningEvent(BaseEvent):
     type: str
     attempt: int = 1
     agent_role: str
-    task_id: str
+    task_id: str | None = None
     task_name: str | None = None
     from_task: Any | None = None
     agent_id: str | None = None

lib/crewai/src/crewai/events/utils/console_formatter.py

@@ -1512,34 +1512,6 @@ To enable tracing, do any one of these:
         self.print(panel)
         self.print()
 
-    def handle_mcp_config_fetch_failed(
-        self,
-        slug: str,
-        error: str = "",
-        error_type: str | None = None,
-    ) -> None:
-        """Handle MCP config fetch failed event (AMP resolution failures)."""
-        if not self.verbose:
-            return
-
-        content = Text()
-        content.append("MCP Config Fetch Failed\n\n", style="red bold")
-        content.append("Server: ", style="white")
-        content.append(f"{slug}\n", style="red")
-
-        if error_type:
-            content.append("Error Type: ", style="white")
-            content.append(f"{error_type}\n", style="red")
-
-        if error:
-            content.append("\nError: ", style="white bold")
-            error_preview = error[:500] + "..." if len(error) > 500 else error
-            content.append(f"{error_preview}\n", style="red")
-
-        panel = self.create_panel(content, "❌ MCP Config Failed", "red")
-        self.print(panel)
-        self.print()
-
     def handle_mcp_tool_execution_started(
         self,
         server_name: str,

lib/crewai/src/crewai/experimental/agent_executor.py

@@ -66,12 +66,12 @@ from crewai.utilities.agent_utils import (
     has_reached_max_iterations,
     is_context_length_exceeded,
     is_inside_event_loop,
-    parse_tool_call_args,
     process_llm_response,
     track_delegation_if_needed,
 )
 from crewai.utilities.constants import TRAINING_DATA_FILE
 from crewai.utilities.i18n import I18N, get_i18n
+from crewai.utilities.planning_types import PlanStep, TodoItem, TodoList
 from crewai.utilities.printer import Printer
 from crewai.utilities.string_utils import sanitize_tool_name
 from crewai.utilities.tool_utils import execute_tool_and_check_finality
@@ -105,6 +105,13 @@ class AgentReActState(BaseModel):
     ask_for_human_input: bool = Field(default=False)
     use_native_tools: bool = Field(default=False)
     pending_tool_calls: list[Any] = Field(default_factory=list)
+    plan: str | None = Field(default=None, description="Generated execution plan")
+    plan_ready: bool = Field(
+        default=False, description="Whether agent is ready to execute"
+    )
+    todos: TodoList = Field(
+        default_factory=TodoList, description="Todo list for tracking plan execution"
+    )
 
 
 class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
@@ -393,6 +400,67 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
         self._state.iterations = value
 
     @start()
+    def generate_plan(self) -> None:
+        """Generate execution plan if planning is enabled.
+
+        This is the entry point for the agent execution flow. If planning is
+        enabled on the agent, it generates a plan before execution begins.
+        The plan is stored in state and todos are created from the steps.
+        """
+        if not getattr(self.agent, "planning_enabled", False):
+            return
+
+        try:
+            from crewai.utilities.reasoning_handler import AgentReasoning
+
+            if self.task:
+                planning_handler = AgentReasoning(agent=self.agent, task=self.task)
+            else:
+                # For kickoff() path - use input text directly, no Task needed
+                input_text = getattr(self, "_kickoff_input", "")
+                planning_handler = AgentReasoning(
+                    agent=self.agent,
+                    description=input_text or "Complete the requested task",
+                    expected_output="Complete the task successfully",
+                )
+
+            output = planning_handler.handle_agent_reasoning()
+
+            self.state.plan = output.plan.plan
+            self.state.plan_ready = output.plan.ready
+
+            if self.state.plan_ready and output.plan.steps:
+                self._create_todos_from_plan(output.plan.steps)
+
+            # Backward compatibility: append plan to task description
+            # This can be removed in Phase 2 when plan execution is implemented
+            if self.task and self.state.plan:
+                self.task.description += f"\n\nPlanning:\n{self.state.plan}"
+
+        except Exception as e:
+            if hasattr(self.agent, "_logger"):
+                self.agent._logger.log("error", f"Error during planning: {e!s}")
+
+    def _create_todos_from_plan(self, steps: list[PlanStep]) -> None:
+        """Convert plan steps into trackable todo items.
+
+        Args:
+            steps: List of PlanStep objects from the reasoning handler.
+        """
+        todos: list[TodoItem] = []
+        for step in steps:
+            todo = TodoItem(
+                step_number=step.step_number,
+                description=step.description,
+                tool_to_use=step.tool_to_use,
+                depends_on=step.depends_on,
+                status="pending",
+            )
+            todos.append(todo)
+
+        self.state.todos = TodoList(items=todos)
+
+    @listen(generate_plan)
     def initialize_reasoning(self) -> Literal["initialized"]:
         """Initialize the reasoning flow and emit agent start logs."""
         self._show_start_logs()
@@ -849,9 +917,13 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
         call_id, func_name, func_args = info
 
         # Parse arguments
-        args_dict, parse_error = parse_tool_call_args(func_args, func_name, call_id)
-        if parse_error is not None:
-            return parse_error
+        if isinstance(func_args, str):
+            try:
+                args_dict = json.loads(func_args)
+            except json.JSONDecodeError:
+                args_dict = {}
+        else:
+            args_dict = func_args
 
         # Get agent_key for event tracking
         agent_key = getattr(self.agent, "key", "unknown") if self.agent else "unknown"
@@ -1180,6 +1252,10 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             self.state.is_finished = False
             self.state.use_native_tools = False
             self.state.pending_tool_calls = []
+            self.state.plan = None
+            self.state.plan_ready = False
+
+            self._kickoff_input = inputs.get("input", "")
 
             if "system" in self.prompt:
                 prompt = cast("SystemPromptResult", self.prompt)
@@ -1262,6 +1338,10 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             self.state.is_finished = False
             self.state.use_native_tools = False
             self.state.pending_tool_calls = []
+            self.state.plan = None
+            self.state.plan_ready = False
+
+            self._kickoff_input = inputs.get("input", "")
 
             if "system" in self.prompt:
                 prompt = cast("SystemPromptResult", self.prompt)

lib/crewai/src/crewai/flow/flow.py

@@ -16,7 +16,7 @@ from collections.abc import (
     Sequence,
     ValuesView,
 )
-from concurrent.futures import Future, ThreadPoolExecutor
+from concurrent.futures import Future
 import copy
 import enum
 import inspect
@@ -1739,12 +1739,7 @@ class Flow(Generic[T], metaclass=FlowMeta):
         async def _run_flow() -> Any:
             return await self.kickoff_async(inputs, input_files)
 
-        try:
-            asyncio.get_running_loop()
-            with ThreadPoolExecutor(max_workers=1) as pool:
-                return pool.submit(asyncio.run, _run_flow()).result()
-        except RuntimeError:
-            return asyncio.run(_run_flow())
+        return asyncio.run(_run_flow())
 
     async def kickoff_async(
         self,

lib/crewai/src/crewai/lite_agent.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Callable
+import time
 from functools import wraps
 import inspect
 import json
-import time
 from types import MethodType
 from typing import (
     TYPE_CHECKING,
@@ -49,20 +49,15 @@ from crewai.events.types.agent_events import (
     LiteAgentExecutionErrorEvent,
     LiteAgentExecutionStartedEvent,
 )
-from crewai.events.types.logging_events import AgentLogsExecutionEvent
 from crewai.events.types.memory_events import (
     MemoryRetrievalCompletedEvent,
     MemoryRetrievalFailedEvent,
     MemoryRetrievalStartedEvent,
 )
+from crewai.events.types.logging_events import AgentLogsExecutionEvent
 from crewai.flow.flow_trackable import FlowTrackable
 from crewai.hooks.llm_hooks import get_after_llm_call_hooks, get_before_llm_call_hooks
-from crewai.hooks.types import (
-    AfterLLMCallHookCallable,
-    AfterLLMCallHookType,
-    BeforeLLMCallHookCallable,
-    BeforeLLMCallHookType,
-)
+from crewai.hooks.types import AfterLLMCallHookType, BeforeLLMCallHookType
 from crewai.lite_agent_output import LiteAgentOutput
 from crewai.llm import LLM
 from crewai.llms.base_llm import BaseLLM
@@ -275,11 +270,11 @@ class LiteAgent(FlowTrackable, BaseModel):
     _guardrail: GuardrailCallable | None = PrivateAttr(default=None)
     _guardrail_retry_count: int = PrivateAttr(default=0)
     _callbacks: list[TokenCalcHandler] = PrivateAttr(default_factory=list)
-    _before_llm_call_hooks: list[BeforeLLMCallHookType | BeforeLLMCallHookCallable] = (
-        PrivateAttr(default_factory=get_before_llm_call_hooks)
+    _before_llm_call_hooks: list[BeforeLLMCallHookType] = PrivateAttr(
+        default_factory=get_before_llm_call_hooks
     )
-    _after_llm_call_hooks: list[AfterLLMCallHookType | AfterLLMCallHookCallable] = (
-        PrivateAttr(default_factory=get_after_llm_call_hooks)
+    _after_llm_call_hooks: list[AfterLLMCallHookType] = PrivateAttr(
+        default_factory=get_after_llm_call_hooks
     )
     _memory: Any = PrivateAttr(default=None)
 
@@ -445,16 +440,12 @@ class LiteAgent(FlowTrackable, BaseModel):
         return self.role
 
     @property
-    def before_llm_call_hooks(
-        self,
-    ) -> list[BeforeLLMCallHookType | BeforeLLMCallHookCallable]:
+    def before_llm_call_hooks(self) -> list[BeforeLLMCallHookType]:
         """Get the before_llm_call hooks for this agent."""
         return self._before_llm_call_hooks
 
     @property
-    def after_llm_call_hooks(
-        self,
-    ) -> list[AfterLLMCallHookType | AfterLLMCallHookCallable]:
+    def after_llm_call_hooks(self) -> list[AfterLLMCallHookType]:
         """Get the after_llm_call hooks for this agent."""
         return self._after_llm_call_hooks
 
@@ -491,12 +482,11 @@ class LiteAgent(FlowTrackable, BaseModel):
         # Inject memory tools once if memory is configured (mirrors Agent._prepare_kickoff)
         if self._memory is not None:
             from crewai.tools.memory_tools import create_memory_tools
-            from crewai.utilities.string_utils import sanitize_tool_name
+            from crewai.utilities.agent_utils import sanitize_tool_name
 
             existing_names = {sanitize_tool_name(t.name) for t in self._parsed_tools}
             memory_tools = [
-                mt
-                for mt in create_memory_tools(self._memory)
+                mt for mt in create_memory_tools(self._memory)
                 if sanitize_tool_name(mt.name) not in existing_names
             ]
             if memory_tools:
@@ -575,10 +565,9 @@ class LiteAgent(FlowTrackable, BaseModel):
             if memory_block:
                 formatted = self.i18n.slice("memory").format(memory=memory_block)
                 if self._messages and self._messages[0].get("role") == "system":
-                    existing_content = self._messages[0].get("content", "")
-                    if not isinstance(existing_content, str):
-                        existing_content = ""
-                    self._messages[0]["content"] = existing_content + "\n\n" + formatted
+                    self._messages[0]["content"] = (
+                        self._messages[0].get("content", "") + "\n\n" + formatted
+                    )
             crewai_event_bus.emit(
                 self,
                 event=MemoryRetrievalCompletedEvent(
@@ -599,12 +588,16 @@ class LiteAgent(FlowTrackable, BaseModel):
             )
 
     def _save_to_memory(self, output_text: str) -> None:
-        """Extract discrete memories from the run and remember each. No-op if _memory is None or read-only."""
-        if self._memory is None or getattr(self._memory, "_read_only", False):
+        """Extract discrete memories from the run and remember each. No-op if _memory is None."""
+        if self._memory is None:
             return
         input_str = self._get_last_user_content() or "User request"
         try:
-            raw = f"Input: {input_str}\nAgent: {self.role}\nResult: {output_text}"
+            raw = (
+                f"Input: {input_str}\n"
+                f"Agent: {self.role}\n"
+                f"Result: {output_text}"
+            )
             extracted = self._memory.extract_memories(raw)
             if extracted:
                 self._memory.remember_many(extracted, agent_role=self.role)
@@ -629,20 +622,13 @@ class LiteAgent(FlowTrackable, BaseModel):
         )
 
         # Execute the agent using invoke loop
-        active_response_format = response_format or self.response_format
-        agent_finish = self._invoke_loop(response_model=active_response_format)
+        agent_finish = self._invoke_loop()
         if self._memory is not None:
-            output_text = (
-                agent_finish.output.model_dump_json()
-                if isinstance(agent_finish.output, BaseModel)
-                else agent_finish.output
-            )
-            self._save_to_memory(output_text)
+            self._save_to_memory(agent_finish.output)
         formatted_result: BaseModel | None = None
 
-        if isinstance(agent_finish.output, BaseModel):
-            formatted_result = agent_finish.output
-        elif active_response_format:
+        active_response_format = response_format or self.response_format
+        if active_response_format:
             try:
                 model_schema = generate_model_description(active_response_format)
                 schema = json.dumps(model_schema, indent=2)
@@ -674,13 +660,8 @@ class LiteAgent(FlowTrackable, BaseModel):
             usage_metrics = self._token_process.get_summary()
 
         # Create output
-        raw_output = (
-            agent_finish.output.model_dump_json()
-            if isinstance(agent_finish.output, BaseModel)
-            else agent_finish.output
-        )
         output = LiteAgentOutput(
-            raw=raw_output,
+            raw=agent_finish.output,
             pydantic=formatted_result,
             agent_role=self.role,
             usage_metrics=usage_metrics.model_dump() if usage_metrics else None,
@@ -857,15 +838,10 @@ class LiteAgent(FlowTrackable, BaseModel):
 
         return formatted_messages
 
-    def _invoke_loop(
-        self, response_model: type[BaseModel] | None = None
-    ) -> AgentFinish:
+    def _invoke_loop(self) -> AgentFinish:
         """
         Run the agent's thought process until it reaches a conclusion or max iterations.
 
-        Args:
-            response_model: Optional Pydantic model for native structured output.
-
         Returns:
             AgentFinish: The final result of the agent execution.
         """
@@ -894,19 +870,12 @@ class LiteAgent(FlowTrackable, BaseModel):
                         printer=self._printer,
                         from_agent=self,
                         executor_context=self,
-                        response_model=response_model,
                         verbose=self.verbose,
                     )
 
                 except Exception as e:
                     raise e
 
-                if isinstance(answer, BaseModel):
-                    formatted_answer = AgentFinish(
-                        thought="", output=answer, text=answer.model_dump_json()
-                    )
-                    break
-
                 formatted_answer = process_llm_response(
                     cast(str, answer), self.use_stop_words
                 )
@@ -932,7 +901,7 @@ class LiteAgent(FlowTrackable, BaseModel):
                     )
 
                 self._append_message(formatted_answer.text, role="assistant")
-            except OutputParserError as e:
+            except OutputParserError as e:  # noqa: PERF203
                 if self.verbose:
                     self._printer.print(
                         content="Failed to parse LLM output. Retrying...",

lib/crewai/src/crewai/llm.py

@@ -427,7 +427,7 @@ class LLM(BaseLLM):
                 f"installed.\n\n"
                 f"To fix this, either:\n"
                 f"  1. Install LiteLLM for broad model support: "
-                f"uv add 'crewai[litellm]'\n"
+                f"uv add litellm\n"
                 f"or\n"
                 f"pip install litellm\n\n"
                 f"For more details, see: "

lib/crewai/src/crewai/llms/providers/bedrock/completion.py

@@ -234,7 +234,7 @@ class BedrockCompletion(BaseLLM):
         aws_access_key_id: str | None = None,
         aws_secret_access_key: str | None = None,
         aws_session_token: str | None = None,
-        region_name: str | None = None,
+        region_name: str = "us-east-1",
         temperature: float | None = None,
         max_tokens: int | None = None,
         top_p: float | None = None,
@@ -287,6 +287,15 @@ class BedrockCompletion(BaseLLM):
             **kwargs,
         )
 
+        # Initialize Bedrock client with proper configuration
+        session = Session(
+            aws_access_key_id=aws_access_key_id or os.getenv("AWS_ACCESS_KEY_ID"),
+            aws_secret_access_key=aws_secret_access_key
+            or os.getenv("AWS_SECRET_ACCESS_KEY"),
+            aws_session_token=aws_session_token or os.getenv("AWS_SESSION_TOKEN"),
+            region_name=region_name,
+        )
+
         # Configure client with timeouts and retries following AWS best practices
         config = Config(
             read_timeout=300,
@@ -297,12 +306,8 @@ class BedrockCompletion(BaseLLM):
             tcp_keepalive=True,
         )
 
-        self.region_name = (
-            region_name
-            or os.getenv("AWS_DEFAULT_REGION")
-            or os.getenv("AWS_REGION_NAME")
-            or "us-east-1"
-        )
+        self.client = session.client("bedrock-runtime", config=config)
+        self.region_name = region_name
 
         self.aws_access_key_id = aws_access_key_id or os.getenv("AWS_ACCESS_KEY_ID")
         self.aws_secret_access_key = aws_secret_access_key or os.getenv(
@@ -310,16 +315,6 @@ class BedrockCompletion(BaseLLM):
         )
         self.aws_session_token = aws_session_token or os.getenv("AWS_SESSION_TOKEN")
 
-        # Initialize Bedrock client with proper configuration
-        session = Session(
-            aws_access_key_id=self.aws_access_key_id,
-            aws_secret_access_key=self.aws_secret_access_key,
-            aws_session_token=self.aws_session_token,
-            region_name=self.region_name,
-        )
-
-        self.client = session.client("bedrock-runtime", config=config)
-
         self._async_exit_stack = AsyncExitStack() if AIOBOTOCORE_AVAILABLE else None
         self._async_client_initialized = False
 

lib/crewai/src/crewai/llms/providers/gemini/completion.py

@@ -894,7 +894,7 @@ class GeminiCompletion(BaseLLM):
         content = self._extract_text_from_response(response)
 
         effective_response_model = None if self.tools else response_model
-        if not response_model:
+        if not effective_response_model:
             content = self._apply_stop_words(content)
 
         return self._finalize_completion_response(

lib/crewai/src/crewai/mcp/__init__.py

@@ -18,7 +18,6 @@ from crewai.mcp.filters import (
     create_dynamic_tool_filter,
     create_static_tool_filter,
 )
-from crewai.mcp.tool_resolver import MCPToolResolver
 from crewai.mcp.transports.base import BaseTransport, TransportType
 
 
@@ -29,7 +28,6 @@ __all__ = [
     "MCPServerHTTP",
     "MCPServerSSE",
     "MCPServerStdio",
-    "MCPToolResolver",
     "StaticToolFilter",
     "ToolFilter",
     "ToolFilterContext",

lib/crewai/src/crewai/mcp/client.py

@@ -6,7 +6,7 @@ from contextlib import AsyncExitStack
 from datetime import datetime
 import logging
 import time
-from typing import Any, NamedTuple
+from typing import Any
 
 from typing_extensions import Self
 
@@ -34,13 +34,6 @@ from crewai.mcp.transports.stdio import StdioTransport
 from crewai.utilities.string_utils import sanitize_tool_name
 
 
-class _MCPToolResult(NamedTuple):
-    """Internal result from an MCP tool call, carrying the ``isError`` flag."""
-
-    content: str
-    is_error: bool
-
-
 # MCP Connection timeout constants (in seconds)
 MCP_CONNECTION_TIMEOUT = 30  # Increased for slow servers
 MCP_TOOL_EXECUTION_TIMEOUT = 30
@@ -427,7 +420,6 @@ class MCPClient:
         return [
             {
                 "name": sanitize_tool_name(tool.name),
-                "original_name": tool.name,
                 "description": getattr(tool, "description", ""),
                 "inputSchema": getattr(tool, "inputSchema", {}),
             }
@@ -469,46 +461,29 @@ class MCPClient:
         )
 
         try:
-            tool_result: _MCPToolResult = await self._retry_operation(
+            result = await self._retry_operation(
                 lambda: self._call_tool_impl(tool_name, cleaned_arguments),
                 timeout=self.execution_timeout,
             )
 
-            finished_at = datetime.now()
-            execution_duration_ms = (finished_at - started_at).total_seconds() * 1000
+            completed_at = datetime.now()
+            execution_duration_ms = (completed_at - started_at).total_seconds() * 1000
+            crewai_event_bus.emit(
+                self,
+                MCPToolExecutionCompletedEvent(
+                    server_name=server_name,
+                    server_url=server_url,
+                    transport_type=transport_type,
+                    tool_name=tool_name,
+                    tool_args=cleaned_arguments,
+                    result=result,
+                    started_at=started_at,
+                    completed_at=completed_at,
+                    execution_duration_ms=execution_duration_ms,
+                ),
+            )
 
-            if tool_result.is_error:
-                crewai_event_bus.emit(
-                    self,
-                    MCPToolExecutionFailedEvent(
-                        server_name=server_name,
-                        server_url=server_url,
-                        transport_type=transport_type,
-                        tool_name=tool_name,
-                        tool_args=cleaned_arguments,
-                        error=tool_result.content,
-                        error_type="tool_error",
-                        started_at=started_at,
-                        failed_at=finished_at,
-                    ),
-                )
-            else:
-                crewai_event_bus.emit(
-                    self,
-                    MCPToolExecutionCompletedEvent(
-                        server_name=server_name,
-                        server_url=server_url,
-                        transport_type=transport_type,
-                        tool_name=tool_name,
-                        tool_args=cleaned_arguments,
-                        result=tool_result.content,
-                        started_at=started_at,
-                        completed_at=finished_at,
-                        execution_duration_ms=execution_duration_ms,
-                    ),
-                )
-
-            return tool_result.content
+            return result
         except Exception as e:
             failed_at = datetime.now()
             error_type = (
@@ -589,27 +564,23 @@ class MCPClient:
 
         return cleaned
 
-    async def _call_tool_impl(
-        self, tool_name: str, arguments: dict[str, Any]
-    ) -> _MCPToolResult:
+    async def _call_tool_impl(self, tool_name: str, arguments: dict[str, Any]) -> Any:
         """Internal implementation of call_tool."""
         result = await asyncio.wait_for(
             self.session.call_tool(tool_name, arguments),
             timeout=self.execution_timeout,
         )
 
-        is_error = getattr(result, "isError", False) or False
-
         # Extract result content
         if hasattr(result, "content") and result.content:
             if isinstance(result.content, list) and len(result.content) > 0:
                 content_item = result.content[0]
                 if hasattr(content_item, "text"):
-                    return _MCPToolResult(str(content_item.text), is_error)
-                return _MCPToolResult(str(content_item), is_error)
-            return _MCPToolResult(str(result.content), is_error)
+                    return str(content_item.text)
+                return str(content_item)
+            return str(result.content)
 
-        return _MCPToolResult(str(result), is_error)
+        return str(result)
 
     async def list_prompts(self) -> list[dict[str, Any]]:
         """List available prompts from MCP server.

lib/crewai/src/crewai/mcp/tool_resolver.py

@@ -1,592 +0,0 @@
-"""MCP tool resolution for CrewAI agents.
-
-This module extracts all MCP-related tool resolution logic from the Agent class
-into a standalone MCPToolResolver. It handles three flavours of MCP reference:
-
-  1. Native configs:   MCPServerStdio / MCPServerHTTP / MCPServerSSE objects.
-  2. HTTPS URLs:       e.g. "https://mcp.example.com/api"
-  3. AMP references:   e.g. "notion" or "notion#search" (legacy "crewai-amp:" prefix also works)
-"""
-
-from __future__ import annotations
-
-import asyncio
-import time
-from typing import TYPE_CHECKING, Any, Final, cast
-from urllib.parse import urlparse
-
-from crewai.mcp.client import MCPClient
-from crewai.mcp.config import (
-    MCPServerConfig,
-    MCPServerHTTP,
-    MCPServerSSE,
-    MCPServerStdio,
-)
-from crewai.mcp.transports.http import HTTPTransport
-from crewai.mcp.transports.sse import SSETransport
-from crewai.mcp.transports.stdio import StdioTransport
-
-
-if TYPE_CHECKING:
-    from crewai.tools.base_tool import BaseTool
-    from crewai.utilities.logger import Logger
-
-MCP_CONNECTION_TIMEOUT: Final[int] = 10
-MCP_TOOL_EXECUTION_TIMEOUT: Final[int] = 30
-MCP_DISCOVERY_TIMEOUT: Final[int] = 15
-MCP_MAX_RETRIES: Final[int] = 3
-
-_mcp_schema_cache: dict[str, Any] = {}
-_cache_ttl: Final[int] = 300  # 5 minutes
-
-
-class MCPToolResolver:
-    """Resolves MCP server references / configs into CrewAI ``BaseTool`` instances.
-
-    Typical lifecycle::
-
-        resolver = MCPToolResolver(agent=my_agent, logger=my_agent._logger)
-        tools = resolver.resolve(my_agent.mcps)
-        # … agent executes tasks using *tools* …
-        resolver.cleanup()
-
-    The resolver owns the MCP client connections it creates and is responsible
-    for tearing them down via :meth:`cleanup`.
-    """
-
-    def __init__(self, agent: Any, logger: Logger) -> None:
-        self._agent = agent
-        self._logger = logger
-        self._clients: list[Any] = []
-
-    @property
-    def clients(self) -> list[Any]:
-        return list(self._clients)
-
-    def resolve(self, mcps: list[str | MCPServerConfig]) -> list[BaseTool]:
-        """Convert MCP server references/configs to CrewAI tools."""
-        all_tools: list[BaseTool] = []
-        amp_refs: list[tuple[str, str | None]] = []
-
-        for mcp_config in mcps:
-            if isinstance(mcp_config, str) and mcp_config.startswith("https://"):
-                all_tools.extend(self._resolve_external(mcp_config))
-            elif isinstance(mcp_config, str):
-                amp_refs.append(self._parse_amp_ref(mcp_config))
-            else:
-                tools, client = self._resolve_native(mcp_config)
-                all_tools.extend(tools)
-                if client:
-                    self._clients.append(client)
-
-        if amp_refs:
-            tools, clients = self._resolve_amp(amp_refs)
-            all_tools.extend(tools)
-            self._clients.extend(clients)
-
-        return all_tools
-
-    def cleanup(self) -> None:
-        """Disconnect all MCP client connections."""
-        if not self._clients:
-            return
-
-        async def _disconnect_all() -> None:
-            for client in self._clients:
-                if client and hasattr(client, "connected") and client.connected:
-                    await client.disconnect()
-
-        try:
-            asyncio.run(_disconnect_all())
-        except Exception as e:
-            self._logger.log("error", f"Error during MCP client cleanup: {e}")
-        finally:
-            self._clients.clear()
-
-    @staticmethod
-    def _parse_amp_ref(mcp_config: str) -> tuple[str, str | None]:
-        """Parse an AMP reference into *(slug, optional tool name)*.
-
-        Accepts both bare slugs (``"notion"``, ``"notion#search"``) and the
-        legacy ``"crewai-amp:notion"`` form.
-        """
-        bare = mcp_config.removeprefix("crewai-amp:")
-        slug, _, specific_tool = bare.partition("#")
-        return slug, specific_tool or None
-
-    def _resolve_amp(
-        self, amp_refs: list[tuple[str, str | None]]
-    ) -> tuple[list[BaseTool], list[Any]]:
-        """Fetch AMP configs in bulk and return their tools and clients.
-
-        Resolves each unique slug only once (single connection per server),
-        then applies per-ref tool filters to select specific tools.
-        """
-        from crewai.events.event_bus import crewai_event_bus
-        from crewai.events.types.mcp_events import MCPConfigFetchFailedEvent
-
-        unique_slugs = list(dict.fromkeys(slug for slug, _ in amp_refs))
-        amp_configs_map = self._fetch_amp_mcp_configs(unique_slugs)
-
-        all_tools: list[BaseTool] = []
-        all_clients: list[Any] = []
-
-        resolved_cache: dict[str, tuple[list[BaseTool], Any | None]] = {}
-
-        for slug in unique_slugs:
-            config_dict = amp_configs_map.get(slug)
-            if not config_dict:
-                crewai_event_bus.emit(
-                    self,
-                    MCPConfigFetchFailedEvent(
-                        slug=slug,
-                        error=f"Config for '{slug}' not found. Make sure it is connected in your account.",
-                        error_type="not_connected",
-                    ),
-                )
-                continue
-
-            mcp_server_config = self._build_mcp_config_from_dict(config_dict)
-
-            try:
-                tools, client = self._resolve_native(mcp_server_config)
-                resolved_cache[slug] = (tools, client)
-                if client:
-                    all_clients.append(client)
-            except Exception as e:
-                crewai_event_bus.emit(
-                    self,
-                    MCPConfigFetchFailedEvent(
-                        slug=slug,
-                        error=str(e),
-                        error_type="connection_failed",
-                    ),
-                )
-
-        for slug, specific_tool in amp_refs:
-            cached = resolved_cache.get(slug)
-            if not cached:
-                continue
-
-            slug_tools, _ = cached
-            if specific_tool:
-                all_tools.extend(
-                    t for t in slug_tools if t.name.endswith(f"_{specific_tool}")
-                )
-            else:
-                all_tools.extend(slug_tools)
-
-        return all_tools, all_clients
-
-    def _fetch_amp_mcp_configs(self, slugs: list[str]) -> dict[str, dict[str, Any]]:
-        """Fetch MCP server configurations via CrewAI+ API.
-
-        Sends a GET request to the CrewAI+ mcps/configs endpoint with
-        comma-separated slugs. CrewAI+ proxies the request to crewai-oauth.
-
-        API-level failures return ``{}``; individual slugs will then
-        surface as ``MCPConfigFetchFailedEvent`` in :meth:`_resolve_amp`.
-        """
-        import httpx
-
-        try:
-            from crewai_tools.tools.crewai_platform_tools.misc import (
-                get_platform_integration_token,
-            )
-
-            from crewai.cli.plus_api import PlusAPI
-
-            plus_api = PlusAPI(api_key=get_platform_integration_token())
-            response = plus_api.get_mcp_configs(slugs)
-
-            if response.status_code == 200:
-                configs: dict[str, dict[str, Any]] = response.json().get("configs", {})
-                return configs
-
-            self._logger.log(
-                "debug",
-                f"Failed to fetch MCP configs: HTTP {response.status_code}",
-            )
-            return {}
-
-        except httpx.HTTPError as e:
-            self._logger.log("debug", f"Failed to fetch MCP configs: {e}")
-            return {}
-        except Exception as e:
-            self._logger.log("debug", f"Cannot fetch AMP MCP configs: {e}")
-            return {}
-
-    def _resolve_external(self, mcp_ref: str) -> list[BaseTool]:
-        """Resolve an HTTPS MCP server URL into tools."""
-        from crewai.tools.mcp_tool_wrapper import MCPToolWrapper
-
-        if "#" in mcp_ref:
-            server_url, specific_tool = mcp_ref.split("#", 1)
-        else:
-            server_url, specific_tool = mcp_ref, None
-
-        server_params = {"url": server_url}
-        server_name = self._extract_server_name(server_url)
-
-        try:
-            tool_schemas = self._get_mcp_tool_schemas(server_params)
-
-            if not tool_schemas:
-                self._logger.log(
-                    "warning", f"No tools discovered from MCP server: {server_url}"
-                )
-                return []
-
-            tools = []
-            for tool_name, schema in tool_schemas.items():
-                if specific_tool and tool_name != specific_tool:
-                    continue
-
-                try:
-                    wrapper = MCPToolWrapper(
-                        mcp_server_params=server_params,
-                        tool_name=tool_name,
-                        tool_schema=schema,
-                        server_name=server_name,
-                    )
-                    tools.append(wrapper)
-                except Exception as e:
-                    self._logger.log(
-                        "warning",
-                        f"Failed to create MCP tool wrapper for {tool_name}: {e}",
-                    )
-                    continue
-
-            if specific_tool and not tools:
-                self._logger.log(
-                    "warning",
-                    f"Specific tool '{specific_tool}' not found on MCP server: {server_url}",
-                )
-
-            return cast(list[BaseTool], tools)
-
-        except Exception as e:
-            self._logger.log(
-                "warning", f"Failed to connect to MCP server {server_url}: {e}"
-            )
-            return []
-
-    def _resolve_native(
-        self, mcp_config: MCPServerConfig
-    ) -> tuple[list[BaseTool], Any | None]:
-        """Resolve an ``MCPServerConfig`` into tools, returning the client for cleanup."""
-        from crewai.tools.base_tool import BaseTool
-        from crewai.tools.mcp_native_tool import MCPNativeTool
-
-        transport: StdioTransport | HTTPTransport | SSETransport
-        if isinstance(mcp_config, MCPServerStdio):
-            transport = StdioTransport(
-                command=mcp_config.command,
-                args=mcp_config.args,
-                env=mcp_config.env,
-            )
-            server_name = f"{mcp_config.command}_{'_'.join(mcp_config.args)}"
-        elif isinstance(mcp_config, MCPServerHTTP):
-            transport = HTTPTransport(
-                url=mcp_config.url,
-                headers=mcp_config.headers,
-                streamable=mcp_config.streamable,
-            )
-            server_name = self._extract_server_name(mcp_config.url)
-        elif isinstance(mcp_config, MCPServerSSE):
-            transport = SSETransport(
-                url=mcp_config.url,
-                headers=mcp_config.headers,
-            )
-            server_name = self._extract_server_name(mcp_config.url)
-        else:
-            raise ValueError(f"Unsupported MCP server config type: {type(mcp_config)}")
-
-        client = MCPClient(
-            transport=transport,
-            cache_tools_list=mcp_config.cache_tools_list,
-        )
-
-        async def _setup_client_and_list_tools() -> list[dict[str, Any]]:
-            try:
-                if not client.connected:
-                    await client.connect()
-
-                tools_list = await client.list_tools()
-
-                try:
-                    await client.disconnect()
-                    await asyncio.sleep(0.1)
-                except Exception as e:
-                    self._logger.log("error", f"Error during disconnect: {e}")
-
-                return tools_list
-            except Exception as e:
-                if client.connected:
-                    await client.disconnect()
-                    await asyncio.sleep(0.1)
-                raise RuntimeError(
-                    f"Error during setup client and list tools: {e}"
-                ) from e
-
-        try:
-            try:
-                asyncio.get_running_loop()
-                import concurrent.futures
-
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(
-                        asyncio.run, _setup_client_and_list_tools()
-                    )
-                    tools_list = future.result()
-            except RuntimeError:
-                try:
-                    tools_list = asyncio.run(_setup_client_and_list_tools())
-                except RuntimeError as e:
-                    error_msg = str(e).lower()
-                    if "cancel scope" in error_msg or "task" in error_msg:
-                        raise ConnectionError(
-                            "MCP connection failed due to event loop cleanup issues. "
-                            "This may be due to authentication errors or server unavailability."
-                        ) from e
-                except asyncio.CancelledError as e:
-                    raise ConnectionError(
-                        "MCP connection was cancelled. This may indicate an authentication "
-                        "error or server unavailability."
-                    ) from e
-
-            if mcp_config.tool_filter:
-                filtered_tools = []
-                for tool in tools_list:
-                    if callable(mcp_config.tool_filter):
-                        try:
-                            from crewai.mcp.filters import ToolFilterContext
-
-                            context = ToolFilterContext(
-                                agent=self._agent,
-                                server_name=server_name,
-                                run_context=None,
-                            )
-                            if mcp_config.tool_filter(context, tool):  # type: ignore[call-arg, arg-type]
-                                filtered_tools.append(tool)
-                        except (TypeError, AttributeError):
-                            if mcp_config.tool_filter(tool):  # type: ignore[call-arg, arg-type]
-                                filtered_tools.append(tool)
-                    else:
-                        filtered_tools.append(tool)
-                tools_list = filtered_tools
-
-            tools = []
-            for tool_def in tools_list:
-                tool_name = tool_def.get("name", "")
-                original_tool_name = tool_def.get("original_name", tool_name)
-                if not tool_name:
-                    continue
-
-                args_schema = None
-                if tool_def.get("inputSchema"):
-                    args_schema = self._json_schema_to_pydantic(
-                        tool_name, tool_def["inputSchema"]
-                    )
-
-                tool_schema = {
-                    "description": tool_def.get("description", ""),
-                    "args_schema": args_schema,
-                }
-
-                try:
-                    native_tool = MCPNativeTool(
-                        mcp_client=client,
-                        tool_name=tool_name,
-                        tool_schema=tool_schema,
-                        server_name=server_name,
-                        original_tool_name=original_tool_name,
-                    )
-                    tools.append(native_tool)
-                except Exception as e:
-                    self._logger.log("error", f"Failed to create native MCP tool: {e}")
-                    continue
-
-            return cast(list[BaseTool], tools), client
-        except Exception as e:
-            if client.connected:
-                asyncio.run(client.disconnect())
-
-            raise RuntimeError(f"Failed to get native MCP tools: {e}") from e
-
-    @staticmethod
-    def _build_mcp_config_from_dict(
-        config_dict: dict[str, Any],
-    ) -> MCPServerConfig:
-        """Convert a config dict from crewai-oauth into an MCPServerConfig."""
-        config_type = config_dict.get("type", "http")
-
-        if config_type == "sse":
-            return MCPServerSSE(
-                url=config_dict["url"],
-                headers=config_dict.get("headers"),
-                cache_tools_list=config_dict.get("cache_tools_list", False),
-            )
-
-        return MCPServerHTTP(
-            url=config_dict["url"],
-            headers=config_dict.get("headers"),
-            streamable=config_dict.get("streamable", True),
-            cache_tools_list=config_dict.get("cache_tools_list", False),
-        )
-
-    @staticmethod
-    def _extract_server_name(server_url: str) -> str:
-        """Extract clean server name from URL for tool prefixing."""
-        parsed = urlparse(server_url)
-        domain = parsed.netloc.replace(".", "_")
-        path = parsed.path.replace("/", "_").strip("_")
-        return f"{domain}_{path}" if path else domain
-
-    def _get_mcp_tool_schemas(
-        self, server_params: dict[str, Any]
-    ) -> dict[str, dict[str, Any]]:
-        """Get tool schemas from MCP server with caching."""
-        server_url = server_params["url"]
-
-        cache_key = server_url
-        current_time = time.time()
-
-        if cache_key in _mcp_schema_cache:
-            cached_data, cache_time = _mcp_schema_cache[cache_key]
-            if current_time - cache_time < _cache_ttl:
-                self._logger.log(
-                    "debug", f"Using cached MCP tool schemas for {server_url}"
-                )
-                return cached_data  # type: ignore[no-any-return]
-
-        try:
-            schemas = asyncio.run(self._get_mcp_tool_schemas_async(server_params))
-            _mcp_schema_cache[cache_key] = (schemas, current_time)
-            return schemas
-        except Exception as e:
-            self._logger.log(
-                "warning", f"Failed to get MCP tool schemas from {server_url}: {e}"
-            )
-            return {}
-
-    async def _get_mcp_tool_schemas_async(
-        self, server_params: dict[str, Any]
-    ) -> dict[str, dict[str, Any]]:
-        """Async implementation of MCP tool schema retrieval."""
-        server_url = server_params["url"]
-        return await self._retry_mcp_discovery(
-            self._discover_mcp_tools_with_timeout, server_url
-        )
-
-    async def _retry_mcp_discovery(
-        self, operation_func: Any, server_url: str
-    ) -> dict[str, dict[str, Any]]:
-        """Retry MCP discovery with exponential backoff."""
-        last_error = None
-
-        for attempt in range(MCP_MAX_RETRIES):
-            result, error, should_retry = await self._attempt_mcp_discovery(
-                operation_func, server_url
-            )
-
-            if result is not None:
-                return result
-
-            if not should_retry:
-                raise RuntimeError(error)
-
-            last_error = error
-            if attempt < MCP_MAX_RETRIES - 1:
-                wait_time = 2**attempt
-                await asyncio.sleep(wait_time)
-
-        raise RuntimeError(
-            f"Failed to discover MCP tools after {MCP_MAX_RETRIES} attempts: {last_error}"
-        )
-
-    @staticmethod
-    async def _attempt_mcp_discovery(
-        operation_func: Any, server_url: str
-    ) -> tuple[dict[str, dict[str, Any]] | None, str, bool]:
-        """Attempt single MCP discovery; returns *(result, error_message, should_retry)*."""
-        try:
-            result = await operation_func(server_url)
-            return result, "", False
-
-        except ImportError:
-            return (
-                None,
-                "MCP library not available. Please install with: pip install mcp",
-                False,
-            )
-
-        except asyncio.TimeoutError:
-            return (
-                None,
-                f"MCP discovery timed out after {MCP_DISCOVERY_TIMEOUT} seconds",
-                True,
-            )
-
-        except Exception as e:
-            error_str = str(e).lower()
-
-            if "authentication" in error_str or "unauthorized" in error_str:
-                return None, f"Authentication failed for MCP server: {e!s}", False
-            if "connection" in error_str or "network" in error_str:
-                return None, f"Network connection failed: {e!s}", True
-            if "json" in error_str or "parsing" in error_str:
-                return None, f"Server response parsing error: {e!s}", True
-            return None, f"MCP discovery error: {e!s}", False
-
-    async def _discover_mcp_tools_with_timeout(
-        self, server_url: str
-    ) -> dict[str, dict[str, Any]]:
-        """Discover MCP tools with timeout wrapper."""
-        return await asyncio.wait_for(
-            self._discover_mcp_tools(server_url), timeout=MCP_DISCOVERY_TIMEOUT
-        )
-
-    async def _discover_mcp_tools(self, server_url: str) -> dict[str, dict[str, Any]]:
-        """Discover tools from an MCP server (HTTPS / streamable-HTTP path)."""
-        from mcp import ClientSession
-        from mcp.client.streamable_http import streamablehttp_client
-
-        from crewai.utilities.string_utils import sanitize_tool_name
-
-        async with streamablehttp_client(server_url) as (read, write, _):
-            async with ClientSession(read, write) as session:
-                await asyncio.wait_for(
-                    session.initialize(), timeout=MCP_CONNECTION_TIMEOUT
-                )
-
-                tools_result = await asyncio.wait_for(
-                    session.list_tools(),
-                    timeout=MCP_DISCOVERY_TIMEOUT - MCP_CONNECTION_TIMEOUT,
-                )
-
-                schemas = {}
-                for tool in tools_result.tools:
-                    args_schema = None
-                    if hasattr(tool, "inputSchema") and tool.inputSchema:
-                        args_schema = self._json_schema_to_pydantic(
-                            sanitize_tool_name(tool.name), tool.inputSchema
-                        )
-
-                    schemas[sanitize_tool_name(tool.name)] = {
-                        "description": getattr(tool, "description", ""),
-                        "args_schema": args_schema,
-                    }
-                return schemas
-
-    @staticmethod
-    def _json_schema_to_pydantic(tool_name: str, json_schema: dict[str, Any]) -> type:
-        """Convert JSON Schema to a Pydantic model for tool arguments."""
-        from crewai.utilities.pydantic_schema_utils import create_model_from_schema
-
-        model_name = f"{tool_name.replace('-', '_').replace(' ', '_')}Schema"
-        return create_model_from_schema(
-            json_schema,
-            model_name=model_name,
-            enrich_descriptions=True,
-        )

lib/crewai/src/crewai/memory/__init__.py

@@ -1,14 +1,6 @@
-"""Memory module: unified Memory with LLM analysis and pluggable storage.
-
-Heavy dependencies are lazily imported so that
-``import crewai`` does not initialise at runtime — critical for
-Celery pre-fork and similar deployment patterns.
-"""
-
-from __future__ import annotations
-
-from typing import Any
+"""Memory module: unified Memory with LLM analysis and pluggable storage."""
 
+from crewai.memory.encoding_flow import EncodingFlow
 from crewai.memory.memory_scope import MemoryScope, MemorySlice
 from crewai.memory.types import (
     MemoryMatch,
@@ -18,24 +10,7 @@ from crewai.memory.types import (
     embed_text,
     embed_texts,
 )
-
-_LAZY_IMPORTS: dict[str, tuple[str, str]] = {
-    "Memory": ("crewai.memory.unified_memory", "Memory"),
-    "EncodingFlow": ("crewai.memory.encoding_flow", "EncodingFlow"),
-}
-
-
-def __getattr__(name: str) -> Any:
-    """Lazily import Memory / EncodingFlow to avoid pulling in lancedb at import time."""
-    if name in _LAZY_IMPORTS:
-        import importlib
-
-        module_path, attr = _LAZY_IMPORTS[name]
-        mod = importlib.import_module(module_path)
-        val = getattr(mod, attr)
-        globals()[name] = val
-        return val
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+from crewai.memory.unified_memory import Memory
 
 
 __all__ = [

lib/crewai/src/crewai/memory/memory_scope.py

@@ -145,7 +145,7 @@ class MemoryScope:
 
 
 class MemorySlice:
-    """View over multiple scopes: recall searches all, remember is a no-op when read_only."""
+    """View over multiple scopes: recall searches all, remember requires explicit scope unless read_only."""
 
     def __init__(
         self,
@@ -160,7 +160,7 @@ class MemorySlice:
             memory: The underlying Memory instance.
             scopes: List of scope paths to include.
             categories: Optional category filter for recall.
-            read_only: If True, remember() is a silent no-op.
+            read_only: If True, remember() raises PermissionError.
         """
         self._memory = memory
         self._scopes = [s.rstrip("/") or "/" for s in scopes]
@@ -176,10 +176,10 @@ class MemorySlice:
         importance: float | None = None,
         source: str | None = None,
         private: bool = False,
-    ) -> MemoryRecord | None:
-        """Remember into an explicit scope. No-op when read_only=True."""
+    ) -> MemoryRecord:
+        """Remember into an explicit scope. Required when read_only=False."""
         if self._read_only:
-            return None
+            raise PermissionError("This MemorySlice is read-only")
         return self._memory.remember(
             content,
             scope=scope,

lib/crewai/src/crewai/memory/storage/lancedb_storage.py

@@ -53,7 +53,6 @@ class LanceDBStorage:
         path: str | Path | None = None,
         table_name: str = "memories",
         vector_dim: int | None = None,
-        compact_every: int = 100,
     ) -> None:
         """Initialize LanceDB storage.
 
@@ -65,10 +64,6 @@ class LanceDBStorage:
             vector_dim: Dimensionality of the embedding vector. When ``None``
                   (default), the dimension is auto-detected from the existing
                   table schema or from the first saved embedding.
-            compact_every: Number of ``save()`` calls between automatic
-                  background compactions.  Each ``save()`` creates one new
-                  fragment file; compaction merges them, keeping query
-                  performance consistent.  Set to 0 to disable.
         """
         if path is None:
             storage_dir = os.environ.get("CREWAI_STORAGE_DIR")
@@ -83,22 +78,6 @@ class LanceDBStorage:
         self._table_name = table_name
         self._db = lancedb.connect(str(self._path))
 
-        # On macOS and Linux the default per-process open-file limit is 256.
-        # A LanceDB table stores one file per fragment (one fragment per save()
-        # call by default).  With hundreds of fragments, a single full-table
-        # scan opens all of them simultaneously, exhausting the limit.
-        # Raise it proactively so scans on large tables never hit OS error 24.
-        try:
-            import resource
-            soft, hard = resource.getrlimit(resource.RLIMIT_NOFILE)
-            if soft < 4096:
-                resource.setrlimit(resource.RLIMIT_NOFILE, (min(hard, 4096), hard))
-        except Exception:  # noqa: S110
-            pass  # Windows or already at the max hard limit — safe to ignore
-
-        self._compact_every = compact_every
-        self._save_count = 0
-
         # Get or create a shared write lock for this database path.
         resolved = str(self._path.resolve())
         with LanceDBStorage._path_locks_guard:
@@ -112,11 +91,6 @@ class LanceDBStorage:
         try:
             self._table: lancedb.table.Table | None = self._db.open_table(self._table_name)
             self._vector_dim: int = self._infer_dim_from_table(self._table)
-            # Best-effort: create the scope index if it doesn't exist yet.
-            self._ensure_scope_index()
-            # Compact in the background if the table has accumulated many
-            # fragments from previous runs (each save() creates one).
-            self._compact_if_needed()
         except Exception:
             self._table = None
             self._vector_dim = vector_dim or 0  # 0 = not yet known
@@ -204,56 +178,6 @@ class LanceDBStorage:
         table.delete("id = '__schema_placeholder__'")
         return table
 
-    def _ensure_scope_index(self) -> None:
-        """Create a BTREE scalar index on the ``scope`` column if not present.
-
-        A scalar index lets LanceDB skip a full table scan when filtering by
-        scope prefix, which is the hot path for ``list_records``,
-        ``get_scope_info``, and ``list_scopes``.  The call is best-effort:
-        if the table is empty or the index already exists the exception is
-        swallowed silently.
-        """
-        if self._table is None:
-            return
-        try:
-            self._table.create_scalar_index("scope", index_type="BTREE", replace=False)
-        except Exception:  # noqa: S110
-            pass  # index already exists, table empty, or unsupported version
-
-    # ------------------------------------------------------------------
-    # Automatic background compaction
-    # ------------------------------------------------------------------
-
-    def _compact_if_needed(self) -> None:
-        """Spawn a background compaction on startup.
-
-        Called whenever an existing table is opened so that fragments
-        accumulated in previous sessions are silently merged before the
-        first query.  ``optimize()`` returns quickly when the table is
-        already compact, so the cost is negligible in the common case.
-        """
-        if self._table is None or self._compact_every <= 0:
-            return
-        self._compact_async()
-
-    def _compact_async(self) -> None:
-        """Fire-and-forget: compact the table in a daemon background thread."""
-        threading.Thread(
-            target=self._compact_safe,
-            daemon=True,
-            name="lancedb-compact",
-        ).start()
-
-    def _compact_safe(self) -> None:
-        """Run ``table.optimize()`` in a background thread, absorbing errors."""
-        try:
-            if self._table is not None:
-                self._table.optimize()
-                # Refresh the scope index so new fragments are covered.
-                self._ensure_scope_index()
-        except Exception:
-            _logger.debug("LanceDB background compaction failed", exc_info=True)
-
     def _ensure_table(self, vector_dim: int | None = None) -> lancedb.table.Table:
         """Return the table, creating it lazily if needed.
 
@@ -315,7 +239,6 @@ class LanceDBStorage:
             if r.embedding and len(r.embedding) > 0:
                 dim = len(r.embedding)
                 break
-        is_new_table = self._table is None
         with self._write_lock:
             self._ensure_table(vector_dim=dim)
             rows = [self._record_to_row(r) for r in records]
@@ -323,13 +246,6 @@ class LanceDBStorage:
                 if r["vector"] is None or len(r["vector"]) != self._vector_dim:
                     r["vector"] = [0.0] * self._vector_dim
             self._retry_write("add", rows)
-        # Create the scope index on the first save so it covers the initial dataset.
-        if is_new_table:
-            self._ensure_scope_index()
-        # Auto-compact every N saves so fragment files don't pile up.
-        self._save_count += 1
-        if self._compact_every > 0 and self._save_count % self._compact_every == 0:
-            self._compact_async()
 
     def update(self, record: MemoryRecord) -> None:
         """Update a record by ID. Preserves created_at, updates last_accessed."""
@@ -345,10 +261,6 @@ class LanceDBStorage:
     def touch_records(self, record_ids: list[str]) -> None:
         """Update last_accessed to now for the given record IDs.
 
-        Uses a single batch ``table.update()`` call instead of N
-        delete-and-re-add cycles, which is both faster and avoids
-        unnecessary write amplification.
-
         Args:
             record_ids: IDs of records to touch.
         """
@@ -356,20 +268,25 @@ class LanceDBStorage:
             return
         with self._write_lock:
             now = datetime.utcnow().isoformat()
-            safe_ids = [str(rid).replace("'", "''") for rid in record_ids]
-            ids_expr = ", ".join(f"'{rid}'" for rid in safe_ids)
-            self._retry_write(
-                "update",
-                where=f"id IN ({ids_expr})",
-                values={"last_accessed": now},
-            )
+            for rid in record_ids:
+                safe_id = str(rid).replace("'", "''")
+                rows = (
+                    self._table.search([0.0] * self._vector_dim)
+                    .where(f"id = '{safe_id}'")
+                    .limit(1)
+                    .to_list()
+                )
+                if rows:
+                    rows[0]["last_accessed"] = now
+                    self._retry_write("delete", f"id = '{safe_id}'")
+                    self._retry_write("add", [rows[0]])
 
     def get_record(self, record_id: str) -> MemoryRecord | None:
         """Return a single record by ID, or None if not found."""
         if self._table is None:
             return None
         safe_id = str(record_id).replace("'", "''")
-        rows = self._table.search().where(f"id = '{safe_id}'").limit(1).to_list()
+        rows = self._table.search([0.0] * self._vector_dim).where(f"id = '{safe_id}'").limit(1).to_list()
         if not rows:
             return None
         return self._row_to_record(rows[0])
@@ -457,31 +374,13 @@ class LanceDBStorage:
             self._retry_write("delete", where_expr)
             return before - self._table.count_rows()
 
-    def _scan_rows(
-        self,
-        scope_prefix: str | None = None,
-        limit: int = _SCAN_ROWS_LIMIT,
-        columns: list[str] | None = None,
-    ) -> list[dict[str, Any]]:
-        """Scan rows optionally filtered by scope prefix.
-
-        Uses a full table scan (no vector query) so the limit is applied after
-        the scope filter, not to ANN candidates before filtering.
-
-        Args:
-            scope_prefix: Optional scope path prefix to filter by.
-            limit: Maximum number of rows to return (applied after filtering).
-            columns: Optional list of column names to fetch.  Pass only the
-                columns you need for metadata operations to avoid reading the
-                heavy ``vector`` column unnecessarily.
-        """
+    def _scan_rows(self, scope_prefix: str | None = None, limit: int = _SCAN_ROWS_LIMIT) -> list[dict[str, Any]]:
+        """Scan rows optionally filtered by scope prefix."""
         if self._table is None:
             return []
-        q = self._table.search()
+        q = self._table.search([0.0] * self._vector_dim)
         if scope_prefix is not None and scope_prefix.strip("/"):
             q = q.where(f"scope LIKE '{scope_prefix.rstrip('/')}%'")
-        if columns is not None:
-            q = q.select(columns)
         return q.limit(limit).to_list()
 
     def list_records(
@@ -507,10 +406,7 @@ class LanceDBStorage:
         prefix = scope if scope != "/" else ""
         if prefix and not prefix.startswith("/"):
             prefix = "/" + prefix
-        rows = self._scan_rows(
-            prefix or None,
-            columns=["scope", "categories_str", "created_at"],
-        )
+        rows = self._scan_rows(prefix or None)
         if not rows:
             return ScopeInfo(
                 path=scope or "/",
@@ -557,7 +453,7 @@ class LanceDBStorage:
     def list_scopes(self, parent: str = "/") -> list[str]:
         parent = parent.rstrip("/") or ""
         prefix = (parent + "/") if parent else "/"
-        rows = self._scan_rows(prefix if prefix != "/" else None, columns=["scope"])
+        rows = self._scan_rows(prefix if prefix != "/" else None)
         children: set[str] = set()
         for row in rows:
             sc = str(row.get("scope", ""))
@@ -569,7 +465,7 @@ class LanceDBStorage:
         return sorted(children)
 
     def list_categories(self, scope_prefix: str | None = None) -> dict[str, int]:
-        rows = self._scan_rows(scope_prefix, columns=["categories_str"])
+        rows = self._scan_rows(scope_prefix)
         counts: dict[str, int] = {}
         for row in rows:
             cat_str = row.get("categories_str") or "[]"
@@ -602,21 +498,6 @@ class LanceDBStorage:
         if prefix:
             self._table.delete(f"scope >= '{prefix}' AND scope < '{prefix}/\uFFFF'")
 
-    def optimize(self) -> None:
-        """Compact the table synchronously and refresh the scope index.
-
-        Under normal usage this is called automatically in the background
-        (every ``compact_every`` saves and on startup when the table is
-        fragmented).  Call this explicitly only when you need the compaction
-        to be complete before the next operation — for example immediately
-        after a large bulk import, before a latency-sensitive recall.
-        It is a no-op if the table does not exist.
-        """
-        if self._table is None:
-            return
-        self._table.optimize()
-        self._ensure_scope_index()
-
     async def asave(self, records: list[MemoryRecord]) -> None:
         self.save(records)
 

lib/crewai/src/crewai/memory/types.py

@@ -87,22 +87,6 @@ class MemoryMatch(BaseModel):
         description="Information the system looked for but could not find.",
     )
 
-    def format(self) -> str:
-        """Format this match as a human-readable string including metadata.
-
-        Returns:
-            A multi-line string with score, content, categories, and non-empty
-            metadata fields.
-        """
-        lines = [f"- (score={self.score:.2f}) {self.record.content}"]
-        if self.record.categories:
-            lines.append(f"  categories: {', '.join(self.record.categories)}")
-        if self.record.metadata:
-            for key, value in self.record.metadata.items():
-                if value is not None:
-                    lines.append(f"  {key}: {value}")
-        return "\n".join(lines)
-
 
 class ScopeInfo(BaseModel):
     """Information about a scope in the memory hierarchy."""
@@ -307,7 +291,7 @@ def embed_text(embedder: Any, text: str) -> list[float]:
         return []
     first = result[0]
     if hasattr(first, "tolist"):
-        return list(first.tolist())
+        return first.tolist()
     if isinstance(first, list):
         return [float(x) for x in first]
     return list(first)

lib/crewai/src/crewai/memory/unified_memory.py

@@ -6,7 +6,7 @@ from concurrent.futures import Future, ThreadPoolExecutor
 from datetime import datetime
 import threading
 import time
-from typing import TYPE_CHECKING, Any, Literal
+from typing import Any, Literal
 
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.memory_events import (
@@ -21,6 +21,7 @@ from crewai.llms.base_llm import BaseLLM
 from crewai.memory.analyze import extract_memories_from_content
 from crewai.memory.recall_flow import RecallFlow
 from crewai.memory.storage.backend import StorageBackend
+from crewai.memory.storage.lancedb_storage import LanceDBStorage
 from crewai.memory.types import (
     MemoryConfig,
     MemoryMatch,
@@ -29,20 +30,13 @@ from crewai.memory.types import (
     compute_composite_score,
     embed_text,
 )
-from crewai.rag.embeddings.factory import build_embedder
-from crewai.rag.embeddings.providers.openai.types import OpenAIProviderSpec
 
 
-if TYPE_CHECKING:
-    from chromadb.utils.embedding_functions.openai_embedding_function import (
-        OpenAIEmbeddingFunction,
-    )
-
-
-def _default_embedder() -> OpenAIEmbeddingFunction:
+def _default_embedder() -> Any:
     """Build default OpenAI embedder for memory."""
-    spec: OpenAIProviderSpec = {"provider": "openai", "config": {}}
-    return build_embedder(spec)
+    from crewai.rag.embeddings.factory import build_embedder
+
+    return build_embedder({"provider": "openai", "config": {}})
 
 
 class Memory:
@@ -94,10 +88,6 @@ class Memory:
         # Queries shorter than this skip LLM analysis (saving ~1-3s).
         # Longer queries (full task descriptions) benefit from LLM distillation.
         query_analysis_threshold: int = 200,
-        # When True, all write operations (remember, remember_many) are silently
-        # skipped. Useful for sharing a read-only view of memory across agents
-        # without any of them persisting new memories.
-        read_only: bool = False,
     ) -> None:
         """Initialize Memory.
 
@@ -117,9 +107,7 @@ class Memory:
             complex_query_threshold: For complex queries, explore deeper below this confidence.
             exploration_budget: Number of LLM-driven exploration rounds during deep recall.
             query_analysis_threshold: Queries shorter than this skip LLM analysis during deep recall.
-            read_only: If True, remember() and remember_many() are silent no-ops.
         """
-        self._read_only = read_only
         self._config = MemoryConfig(
             recency_weight=recency_weight,
             semantic_weight=semantic_weight,
@@ -142,15 +130,14 @@ class Memory:
         self._llm_instance: BaseLLM | None = None if isinstance(llm, str) else llm
         self._embedder_config: Any = embedder
         self._embedder_instance: Any = (
-            embedder
-            if (embedder is not None and not isinstance(embedder, dict))
-            else None
+            embedder if (embedder is not None and not isinstance(embedder, dict)) else None
         )
 
-        if isinstance(storage, str):
-            from crewai.memory.storage.lancedb_storage import LanceDBStorage
-
-            self._storage = LanceDBStorage() if storage == "lancedb" else LanceDBStorage(path=storage)
+        # Storage is initialized eagerly (local, no API key needed).
+        if storage == "lancedb":
+            self._storage = LanceDBStorage()
+        elif isinstance(storage, str):
+            self._storage = LanceDBStorage(path=storage)
         else:
             self._storage = storage
 
@@ -173,17 +160,12 @@ class Memory:
             from crewai.llm import LLM
 
             try:
-                model_name = (
-                    self._llm_config
-                    if isinstance(self._llm_config, str)
-                    else str(self._llm_config)
-                )
-                self._llm_instance = LLM(model=model_name)
+                self._llm_instance = LLM(model=self._llm_config)
             except Exception as e:
                 raise RuntimeError(
                     f"Memory requires an LLM for analysis but initialization failed: {e}\n\n"
                     "To fix this, do one of the following:\n"
-                    "  - Set OPENAI_API_KEY for the default model (gpt-4o-mini)\n"
+                    '  - Set OPENAI_API_KEY for the default model (gpt-4o-mini)\n'
                     '  - Pass a different model: Memory(llm="anthropic/claude-3-haiku-20240307")\n'
                     '  - Pass any LLM instance: Memory(llm=LLM(model="your-model"))\n'
                     "  - To skip LLM analysis, pass all fields explicitly to remember()\n"
@@ -198,6 +180,8 @@ class Memory:
         if self._embedder_instance is None:
             try:
                 if isinstance(self._embedder_config, dict):
+                    from crewai.rag.embeddings.factory import build_embedder
+
                     self._embedder_instance = build_embedder(self._embedder_config)
                 else:
                     self._embedder_instance = _default_embedder()
@@ -333,7 +317,7 @@ class Memory:
         source: str | None = None,
         private: bool = False,
         agent_role: str | None = None,
-    ) -> MemoryRecord | None:
+    ) -> MemoryRecord:
         """Store a single item in memory (synchronous).
 
         Routes through the same serialized save pool as ``remember_many``
@@ -351,13 +335,11 @@ class Memory:
             agent_role: Optional agent role for event metadata.
 
         Returns:
-            The created MemoryRecord, or None if this memory is read-only.
+            The created MemoryRecord.
 
         Raises:
             Exception: On save failure (events emitted).
         """
-        if self._read_only:
-            return None
         _source_type = "unified_memory"
         try:
             crewai_event_bus.emit(
@@ -374,13 +356,7 @@ class Memory:
             # then immediately wait for the result.
             future = self._submit_save(
                 self._encode_batch,
-                [content],
-                scope,
-                categories,
-                metadata,
-                importance,
-                source,
-                private,
+                [content], scope, categories, metadata, importance, source, private,
             )
             records = future.result()
             record = records[0] if records else None
@@ -444,19 +420,13 @@ class Memory:
         Returns:
             Empty list (records are not available until the background save completes).
         """
-        if not contents or self._read_only:
+        if not contents:
             return []
 
         self._submit_save(
             self._background_encode_batch,
-            contents,
-            scope,
-            categories,
-            metadata,
-            importance,
-            source,
-            private,
-            agent_role,
+            contents, scope, categories, metadata,
+            importance, source, private, agent_role,
         )
         return []
 
@@ -596,13 +566,14 @@ class Memory:
                     # Privacy filter
                     if not include_private:
                         raw = [
-                            (r, s)
-                            for r, s in raw
+                            (r, s) for r, s in raw
                             if not r.private or r.source == source
                         ]
                     results = []
                     for r, s in raw:
-                        composite, reasons = compute_composite_score(r, s, self._config)
+                        composite, reasons = compute_composite_score(
+                            r, s, self._config
+                        )
                         results.append(
                             MemoryMatch(
                                 record=r,
@@ -768,9 +739,7 @@ class Memory:
             limit: Maximum number of records to return.
             offset: Number of records to skip (for pagination).
         """
-        return self._storage.list_records(
-            scope_prefix=scope, limit=limit, offset=offset
-        )
+        return self._storage.list_records(scope_prefix=scope, limit=limit, offset=offset)
 
     def info(self, path: str = "/") -> ScopeInfo:
         """Return scope info for path."""
@@ -812,7 +781,7 @@ class Memory:
         importance: float | None = None,
         source: str | None = None,
         private: bool = False,
-    ) -> MemoryRecord | None:
+    ) -> MemoryRecord:
         """Async remember: delegates to sync for now."""
         return self.remember(
             content,

lib/crewai/src/crewai/rag/embeddings/factory.py

@@ -216,10 +216,6 @@ def build_embedder_from_dict(
 def build_embedder_from_dict(spec: ONNXProviderSpec) -> ONNXMiniLM_L6_V2: ...
 
 
-@overload
-def build_embedder_from_dict(spec: dict[str, Any]) -> EmbeddingFunction[Any]: ...
-
-
 def build_embedder_from_dict(spec):  # type: ignore[no-untyped-def]
     """Build an embedding function instance from a dictionary specification.
 
@@ -345,10 +341,6 @@ def build_embedder(spec: Text2VecProviderSpec) -> Text2VecEmbeddingFunction: ...
 def build_embedder(spec: ONNXProviderSpec) -> ONNXMiniLM_L6_V2: ...
 
 
-@overload
-def build_embedder(spec: dict[str, Any]) -> EmbeddingFunction[Any]: ...
-
-
 def build_embedder(spec):  # type: ignore[no-untyped-def]
     """Build an embedding function from either a provider spec or a provider instance.
 

lib/crewai/src/crewai/task.py

@@ -586,29 +586,16 @@ class Task(BaseModel):
 
             self._post_agent_execution(agent)
 
-            if isinstance(result, BaseModel):
-                raw = result.model_dump_json()
-                if self.output_pydantic:
-                    pydantic_output = result
-                    json_output = None
-                elif self.output_json:
-                    pydantic_output = None
-                    json_output = result.model_dump()
-                else:
-                    pydantic_output = None
-                    json_output = None
-            elif not self._guardrails and not self._guardrail:
-                raw = result
+            if not self._guardrails and not self._guardrail:
                 pydantic_output, json_output = self._export_output(result)
             else:
-                raw = result
                 pydantic_output, json_output = None, None
 
             task_output = TaskOutput(
                 name=self.name or self.description,
                 description=self.description,
                 expected_output=self.expected_output,
-                raw=raw,
+                raw=result,
                 pydantic=pydantic_output,
                 json_dict=json_output,
                 agent=agent.role,
@@ -700,29 +687,16 @@ class Task(BaseModel):
 
             self._post_agent_execution(agent)
 
-            if isinstance(result, BaseModel):
-                raw = result.model_dump_json()
-                if self.output_pydantic:
-                    pydantic_output = result
-                    json_output = None
-                elif self.output_json:
-                    pydantic_output = None
-                    json_output = result.model_dump()
-                else:
-                    pydantic_output = None
-                    json_output = None
-            elif not self._guardrails and not self._guardrail:
-                raw = result
+            if not self._guardrails and not self._guardrail:
                 pydantic_output, json_output = self._export_output(result)
             else:
-                raw = result
                 pydantic_output, json_output = None, None
 
             task_output = TaskOutput(
                 name=self.name or self.description,
                 description=self.description,
                 expected_output=self.expected_output,
-                raw=raw,
+                raw=result,
                 pydantic=pydantic_output,
                 json_dict=json_output,
                 agent=agent.role,

lib/crewai/src/crewai/tools/base_tool.py

@@ -150,38 +150,14 @@ class BaseTool(BaseModel, ABC):
 
         super().model_post_init(__context)
 
-    def _validate_kwargs(self, kwargs: dict[str, Any]) -> dict[str, Any]:
-        """Validate keyword arguments against args_schema if present.
-
-        Args:
-            kwargs: The keyword arguments to validate.
-
-        Returns:
-            Validated (and possibly coerced) keyword arguments.
-
-        Raises:
-            ValueError: If validation against args_schema fails.
-        """
-        if self.args_schema is not None and self.args_schema.model_fields:
-            try:
-                validated = self.args_schema.model_validate(kwargs)
-                return validated.model_dump()
-            except Exception as e:
-                raise ValueError(
-                    f"Tool '{self.name}' arguments validation failed: {e}"
-                ) from e
-        return kwargs
-
     def run(
         self,
         *args: Any,
         **kwargs: Any,
     ) -> Any:
-        if not args:
-            kwargs = self._validate_kwargs(kwargs)
-
         result = self._run(*args, **kwargs)
 
+        # If _run is async, we safely run it
         if asyncio.iscoroutine(result):
             result = asyncio.run(result)
 
@@ -203,8 +179,6 @@ class BaseTool(BaseModel, ABC):
         Returns:
             The result of the tool execution.
         """
-        if not args:
-            kwargs = self._validate_kwargs(kwargs)
         result = await self._arun(*args, **kwargs)
         self.current_usage_count += 1
         return result
@@ -357,9 +331,6 @@ class Tool(BaseTool, Generic[P, R]):
         Returns:
             The result of the tool execution.
         """
-        if not args:
-            kwargs = self._validate_kwargs(kwargs)  # type: ignore[assignment]
-
         result = self.func(*args, **kwargs)
 
         if asyncio.iscoroutine(result):
@@ -390,8 +361,6 @@ class Tool(BaseTool, Generic[P, R]):
         Returns:
             The result of the tool execution.
         """
-        if not args:
-            kwargs = self._validate_kwargs(kwargs)  # type: ignore[assignment]
         result = await self._arun(*args, **kwargs)
         self.current_usage_count += 1
         return result

lib/crewai/src/crewai/tools/mcp_native_tool.py

@@ -27,16 +27,14 @@ class MCPNativeTool(BaseTool):
         tool_name: str,
         tool_schema: dict[str, Any],
         server_name: str,
-        original_tool_name: str | None = None,
     ) -> None:
         """Initialize native MCP tool.
 
         Args:
             mcp_client: MCPClient instance with active session.
-            tool_name: Name of the tool (may be prefixed).
+            tool_name: Original name of the tool on the MCP server.
             tool_schema: Schema information for the tool.
             server_name: Name of the MCP server for prefixing.
-            original_tool_name: Original name of the tool on the MCP server.
         """
         # Create tool name with server prefix to avoid conflicts
         prefixed_name = f"{server_name}_{tool_name}"
@@ -59,7 +57,7 @@ class MCPNativeTool(BaseTool):
 
         # Set instance attributes after super().__init__
         self._mcp_client = mcp_client
-        self._original_tool_name = original_tool_name or tool_name
+        self._original_tool_name = tool_name
         self._server_name = server_name
         # self._logger = logging.getLogger(__name__)
 

lib/crewai/src/crewai/tools/memory_tools.py

@@ -20,6 +20,14 @@ class RecallMemorySchema(BaseModel):
             "or multiple items to search for several things at once."
         ),
     )
+    scope: str | None = Field(
+        default=None,
+        description="Optional scope to narrow the search (e.g. /project/alpha)",
+    )
+    depth: str = Field(
+        default="shallow",
+        description="'shallow' for fast vector search, 'deep' for LLM-analyzed retrieval",
+    )
 
 
 class RecallMemoryTool(BaseTool):
@@ -33,27 +41,32 @@ class RecallMemoryTool(BaseTool):
     def _run(
         self,
         queries: list[str] | str,
+        scope: str | None = None,
+        depth: str = "shallow",
         **kwargs: Any,
     ) -> str:
         """Search memory for relevant information.
 
         Args:
             queries: One or more search queries (string or list of strings).
+            scope: Optional scope prefix to narrow the search.
+            depth: "shallow" for fast vector search, "deep" for LLM-analyzed retrieval.
 
         Returns:
             Formatted string of matching memories, or a message if none found.
         """
         if isinstance(queries, str):
             queries = [queries]
+        actual_depth = depth if depth in ("shallow", "deep") else "shallow"
 
         all_lines: list[str] = []
         seen_ids: set[str] = set()
         for query in queries:
-            matches = self.memory.recall(query)
+            matches = self.memory.recall(query, scope=scope, limit=5, depth=actual_depth)
             for m in matches:
                 if m.record.id not in seen_ids:
                     seen_ids.add(m.record.id)
-                    all_lines.append(m.format())
+                    all_lines.append(f"- (score={m.score:.2f}) {m.record.content}")
 
         if not all_lines:
             return "No relevant memories found."
@@ -104,28 +117,20 @@ class RememberTool(BaseTool):
 def create_memory_tools(memory: Any) -> list[BaseTool]:
     """Create Recall and Remember tools for the given memory instance.
 
-    When memory is read-only (``_read_only=True``), only the RecallMemoryTool
-    is returned — the RememberTool is omitted so agents are never offered a
-    save capability they cannot use.
-
     Args:
         memory: A Memory, MemoryScope, or MemorySlice instance.
 
     Returns:
-        List containing a RecallMemoryTool and, if not read-only, a RememberTool.
+        List containing a RecallMemoryTool and a RememberTool.
     """
     i18n = get_i18n()
-    tools: list[BaseTool] = [
+    return [
         RecallMemoryTool(
             memory=memory,
             description=i18n.tools("recall_memory"),
         ),
+        RememberTool(
+            memory=memory,
+            description=i18n.tools("save_to_memory"),
+        ),
     ]
-    if not getattr(memory, "_read_only", False):
-        tools.append(
-            RememberTool(
-                memory=memory,
-                description=i18n.tools("save_to_memory"),
-            )
-        )
-    return tools

lib/crewai/src/crewai/translations/en.json

@@ -74,9 +74,14 @@
     "consolidation_user": "New content to consider storing:\n{new_content}\n\nExisting similar memories:\n{records_summary}\n\nReturn the consolidation plan as structured output."
   },
   "reasoning": {
-    "initial_plan": "You are {role}, a professional with the following background: {backstory}\n\nYour primary goal is: {goal}\n\nAs {role}, you are creating a strategic plan for a task that requires your expertise and unique perspective.",
-    "refine_plan": "You are {role}, a professional with the following background: {backstory}\n\nYour primary goal is: {goal}\n\nAs {role}, you are refining a strategic plan for a task that requires your expertise and unique perspective.",
-    "create_plan_prompt": "You are {role} with this background: {backstory}\n\nYour primary goal is: {goal}\n\nYou have been assigned the following task:\n{description}\n\nExpected output:\n{expected_output}\n\nAvailable tools: {tools}\n\nBefore executing this task, create a detailed plan that leverages your expertise as {role} and outlines:\n1. Your understanding of the task from your professional perspective\n2. The key steps you'll take to complete it, drawing on your background and skills\n3. How you'll approach any challenges that might arise, considering your expertise\n4. How you'll strategically use the available tools based on your experience, exactly what tools to use and how to use them\n5. The expected outcome and how it aligns with your goal\n\nAfter creating your plan, assess whether you feel ready to execute the task or if you could do better.\nConclude with one of these statements:\n- \"READY: I am ready to execute the task.\"\n- \"NOT READY: I need to refine my plan because [specific reason].\"",
-    "refine_plan_prompt": "You are {role} with this background: {backstory}\n\nYour primary goal is: {goal}\n\nYou created the following plan for this task:\n{current_plan}\n\nHowever, you indicated that you're not ready to execute the task yet.\n\nPlease refine your plan further, drawing on your expertise as {role} to address any gaps or uncertainties. As you refine your plan, be specific about which available tools you will use, how you will use them, and why they are the best choices for each step. Clearly outline your tool usage strategy as part of your improved plan.\n\nAfter refining your plan, assess whether you feel ready to execute the task.\nConclude with one of these statements:\n- \"READY: I am ready to execute the task.\"\n- \"NOT READY: I need to refine my plan further because [specific reason].\""
+    "initial_plan": "You are {role}. Create a focused execution plan using only the essential steps needed.",
+    "refine_plan": "You are {role}. Refine your plan to address the specific gap while keeping it minimal.",
+    "create_plan_prompt": "You are {role}.\n\nTask: {description}\n\nExpected output: {expected_output}\n\nAvailable tools: {tools}\n\nCreate a focused plan with ONLY the essential steps needed. Most tasks require just 2-5 steps. Do NOT pad with unnecessary steps like \"review\", \"verify\", \"document\", or \"finalize\" unless explicitly required.\n\nFor each step, specify the action and which tool to use (if any).\n\nConclude with:\n- \"READY: I am ready to execute the task.\"\n- \"NOT READY: I need to refine my plan because [specific reason].\"",
+    "refine_plan_prompt": "Your plan:\n{current_plan}\n\nYou indicated you're not ready. Address the specific gap while keeping the plan minimal.\n\nConclude with READY or NOT READY."
+  },
+  "planning": {
+    "system_prompt": "You are a strategic planning assistant. Create minimal, effective execution plans. Prefer fewer steps over more.",
+    "create_plan_prompt": "Create a focused execution plan for the following task:\n\n## Task\n{description}\n\n## Expected Output\n{expected_output}\n\n## Available Tools\n{tools}\n\n## Planning Principles\nFocus on WHAT needs to be accomplished, not HOW. Group related actions into logical units. Fewer steps = better. Most tasks need 3-6 steps. Hard limit: {max_steps} steps.\n\n## Step Types (only these are valid):\n1. **Tool Step**: Uses a tool to gather information or take action\n2. **Output Step**: Synthesizes prior results into the final deliverable (usually the last step)\n\n## Rules:\n- Each step must either USE A TOOL or PRODUCE THE FINAL OUTPUT\n- Combine related tool calls: \"Research A, B, and C\" = ONE step, not three\n- Combine all synthesis into ONE final output step\n- NO standalone \"thinking\" steps (review, verify, confirm, refine, analyze) - these happen naturally between steps\n\nFor each step: State the action, specify the tool (if any), and note dependencies.\n\nAfter your plan, state READY or NOT READY.",
+    "refine_plan_prompt": "Your previous plan:\n{current_plan}\n\nYou indicated you weren't ready. Refine your plan to address the specific gap.\n\nKeep the plan minimal - only add steps that directly address the issue.\n\nConclude with READY or NOT READY as before."
   }
 }

lib/crewai/src/crewai/utilities/agent_utils.py

@@ -168,9 +168,7 @@ def convert_tools_to_openai_schema(
         parameters: dict[str, Any] = {}
         if hasattr(tool, "args_schema") and tool.args_schema is not None:
             try:
-                schema_output = generate_model_description(
-                    tool.args_schema, strip_null_types=False
-                )
+                schema_output = generate_model_description(tool.args_schema)
                 parameters = schema_output.get("json_schema", {}).get("schema", {})
                 # Remove title and description from schema root as they're redundant
                 parameters.pop("title", None)
@@ -1148,36 +1146,6 @@ def extract_tool_call_info(
     return None
 
 
-def parse_tool_call_args(
-    func_args: dict[str, Any] | str,
-    func_name: str,
-    call_id: str,
-    original_tool: Any = None,
-) -> tuple[dict[str, Any], None] | tuple[None, dict[str, Any]]:
-    """Parse tool call arguments from a JSON string or dict.
-
-    Returns:
-        ``(args_dict, None)`` on success, or ``(None, error_result)`` on
-        JSON parse failure where ``error_result`` is a ready-to-return dict
-        with the same shape as ``_execute_single_native_tool_call`` return values.
-    """
-    if isinstance(func_args, str):
-        try:
-            return json.loads(func_args), None
-        except json.JSONDecodeError as e:
-            return None, {
-                "call_id": call_id,
-                "func_name": func_name,
-                "result": (
-                    f"Error: Failed to parse tool arguments as JSON: {e}. "
-                    f"Please provide valid JSON arguments for the '{func_name}' tool."
-                ),
-                "from_cache": False,
-                "original_tool": original_tool,
-            }
-    return func_args, None
-
-
 def _setup_before_llm_call_hooks(
     executor_context: CrewAgentExecutor | AgentExecutor | LiteAgent | None,
     printer: Printer,

lib/crewai/src/crewai/utilities/llm_utils.py

@@ -69,7 +69,7 @@ def create_llm(
 UNACCEPTED_ATTRIBUTES: Final[list[str]] = [
     "AWS_ACCESS_KEY_ID",
     "AWS_SECRET_ACCESS_KEY",
-    "AWS_DEFAULT_REGION",
+    "AWS_REGION_NAME",
 ]
 
 
@@ -146,7 +146,7 @@ def _llm_via_environment_or_fallback() -> LLM | None:
     unaccepted_attributes = [
         "AWS_ACCESS_KEY_ID",
         "AWS_SECRET_ACCESS_KEY",
-        "AWS_DEFAULT_REGION",
+        "AWS_REGION_NAME",
     ]
     set_provider = model_name.partition("/")[0] if "/" in model_name else "openai"
 

lib/crewai/src/crewai/utilities/planning_types.py

@@ -0,0 +1,103 @@
+"""Types for agent planning and todo tracking."""
+
+from __future__ import annotations
+
+from typing import Literal
+from uuid import uuid4
+
+from pydantic import BaseModel, Field
+
+
+# Todo status type
+TodoStatus = Literal["pending", "running", "completed"]
+
+
+class PlanStep(BaseModel):
+    """A single step in the reasoning plan."""
+
+    step_number: int = Field(description="Step number (1-based)")
+    description: str = Field(description="What to do in this step")
+    tool_to_use: str | None = Field(
+        default=None, description="Tool to use for this step, if any"
+    )
+    depends_on: list[int] = Field(
+        default_factory=list, description="Step numbers this step depends on"
+    )
+
+
+class TodoItem(BaseModel):
+    """A single todo item representing a step in the execution plan."""
+
+    id: str = Field(default_factory=lambda: str(uuid4()))
+    step_number: int = Field(description="Order of this step in the plan (1-based)")
+    description: str = Field(description="What needs to be done")
+    tool_to_use: str | None = Field(
+        default=None, description="Tool to use for this step, if any"
+    )
+    status: TodoStatus = Field(default="pending", description="Current status")
+    depends_on: list[int] = Field(
+        default_factory=list, description="Step numbers this depends on"
+    )
+    result: str | None = Field(
+        default=None, description="Result after completion, if any"
+    )
+
+
+class TodoList(BaseModel):
+    """Collection of todos for tracking plan execution."""
+
+    items: list[TodoItem] = Field(default_factory=list)
+
+    @property
+    def current_todo(self) -> TodoItem | None:
+        """Get the currently running todo item."""
+        for item in self.items:
+            if item.status == "running":
+                return item
+        return None
+
+    @property
+    def next_pending(self) -> TodoItem | None:
+        """Get the next pending todo item."""
+        for item in self.items:
+            if item.status == "pending":
+                return item
+        return None
+
+    @property
+    def is_complete(self) -> bool:
+        """Check if all todos are completed."""
+        return len(self.items) > 0 and all(
+            item.status == "completed" for item in self.items
+        )
+
+    @property
+    def pending_count(self) -> int:
+        """Count of pending todos."""
+        return sum(1 for item in self.items if item.status == "pending")
+
+    @property
+    def completed_count(self) -> int:
+        """Count of completed todos."""
+        return sum(1 for item in self.items if item.status == "completed")
+
+    def get_by_step_number(self, step_number: int) -> TodoItem | None:
+        """Get a todo by its step number."""
+        for item in self.items:
+            if item.step_number == step_number:
+                return item
+        return None
+
+    def mark_running(self, step_number: int) -> None:
+        """Mark a todo as running by step number."""
+        item = self.get_by_step_number(step_number)
+        if item:
+            item.status = "running"
+
+    def mark_completed(self, step_number: int, result: str | None = None) -> None:
+        """Mark a todo as completed by step number."""
+        item = self.get_by_step_number(step_number)
+        if item:
+            item.status = "completed"
+            if result:
+                item.result = result

lib/crewai/src/crewai/utilities/pydantic_schema_utils.py

@@ -417,11 +417,7 @@ def strip_null_from_types(schema: dict[str, Any]) -> dict[str, Any]:
     return schema
 
 
-def generate_model_description(
-    model: type[BaseModel],
-    *,
-    strip_null_types: bool = True,
-) -> ModelDescription:
+def generate_model_description(model: type[BaseModel]) -> ModelDescription:
     """Generate JSON schema description of a Pydantic model.
 
     This function takes a Pydantic model class and returns its JSON schema,
@@ -430,9 +426,6 @@ def generate_model_description(
 
     Args:
         model: A Pydantic model class.
-        strip_null_types: When ``True`` (default), remove ``null`` from
-            ``anyOf`` / ``type`` arrays.  Set to ``False`` to allow sending ``null`` for
-            optional fields.
 
     Returns:
         A ModelDescription with JSON schema representation of the model.
@@ -449,9 +442,7 @@ def generate_model_description(
     json_schema = fix_discriminator_mappings(json_schema)
     json_schema = convert_oneof_to_anyof(json_schema)
     json_schema = ensure_all_properties_required(json_schema)
-
-    if strip_null_types:
-        json_schema = strip_null_from_types(json_schema)
+    json_schema = strip_null_from_types(json_schema)
 
     return {
         "type": "json_schema",
@@ -491,66 +482,10 @@ FORMAT_TYPE_MAP: dict[str, type[Any]] = {
 }
 
 
-def build_rich_field_description(prop_schema: dict[str, Any]) -> str:
-    """Build a comprehensive field description including constraints.
-
-    Embeds format, enum, pattern, min/max, and example constraints into the
-    description text so that LLMs can understand tool parameter requirements
-    without inspecting the raw JSON Schema.
-
-    Args:
-        prop_schema: Property schema with description and constraints.
-
-    Returns:
-        Enhanced description with format, enum, and other constraints.
-    """
-    parts: list[str] = []
-
-    description = prop_schema.get("description", "")
-    if description:
-        parts.append(description)
-
-    format_type = prop_schema.get("format")
-    if format_type:
-        parts.append(f"Format: {format_type}")
-
-    enum_values = prop_schema.get("enum")
-    if enum_values:
-        enum_str = ", ".join(repr(v) for v in enum_values)
-        parts.append(f"Allowed values: [{enum_str}]")
-
-    pattern = prop_schema.get("pattern")
-    if pattern:
-        parts.append(f"Pattern: {pattern}")
-
-    minimum = prop_schema.get("minimum")
-    maximum = prop_schema.get("maximum")
-    if minimum is not None:
-        parts.append(f"Minimum: {minimum}")
-    if maximum is not None:
-        parts.append(f"Maximum: {maximum}")
-
-    min_length = prop_schema.get("minLength")
-    max_length = prop_schema.get("maxLength")
-    if min_length is not None:
-        parts.append(f"Min length: {min_length}")
-    if max_length is not None:
-        parts.append(f"Max length: {max_length}")
-
-    examples = prop_schema.get("examples")
-    if examples:
-        examples_str = ", ".join(repr(e) for e in examples[:3])
-        parts.append(f"Examples: {examples_str}")
-
-    return ". ".join(parts) if parts else ""
-
-
 def create_model_from_schema(  # type: ignore[no-any-unimported]
     json_schema: dict[str, Any],
     *,
     root_schema: dict[str, Any] | None = None,
-    model_name: str | None = None,
-    enrich_descriptions: bool = False,
     __config__: ConfigDict | None = None,
     __base__: type[BaseModel] | None = None,
     __module__: str = __name__,
@@ -568,13 +503,6 @@ def create_model_from_schema(  # type: ignore[no-any-unimported]
         json_schema: A dictionary representing the JSON schema.
         root_schema: The root schema containing $defs. If not provided, the
             current schema is treated as the root schema.
-        model_name: Override for the model name. If not provided, the schema
-            ``title`` field is used, falling back to ``"DynamicModel"``.
-        enrich_descriptions: When True, augment field descriptions with
-            constraint info (format, enum, pattern, min/max, examples) via
-            :func:`build_rich_field_description`.  Useful for LLM-facing tool
-            schemas where constraints in the description help the model
-            understand parameter requirements.
         __config__: Pydantic configuration for the generated model.
         __base__: Base class for the generated model. Defaults to BaseModel.
         __module__: Module name for the generated model class.
@@ -611,14 +539,10 @@ def create_model_from_schema(  # type: ignore[no-any-unimported]
         if "title" not in json_schema and "title" in (root_schema or {}):
             json_schema["title"] = (root_schema or {}).get("title")
 
-    effective_name = model_name or json_schema.get("title") or "DynamicModel"
+    model_name = json_schema.get("title") or "DynamicModel"
     field_definitions = {
         name: _json_schema_to_pydantic_field(
-            name,
-            prop,
-            json_schema.get("required", []),
-            effective_root,
-            enrich_descriptions=enrich_descriptions,
+            name, prop, json_schema.get("required", []), effective_root
         )
         for name, prop in (json_schema.get("properties", {}) or {}).items()
     }
@@ -626,7 +550,7 @@ def create_model_from_schema(  # type: ignore[no-any-unimported]
     effective_config = __config__ or ConfigDict(extra="forbid")
 
     return create_model_base(
-        effective_name,
+        model_name,
         __config__=effective_config,
         __base__=__base__,
         __module__=__module__,
@@ -641,8 +565,6 @@ def _json_schema_to_pydantic_field(
     json_schema: dict[str, Any],
     required: list[str],
     root_schema: dict[str, Any],
-    *,
-    enrich_descriptions: bool = False,
 ) -> Any:
     """Convert a JSON schema property to a Pydantic field definition.
 
@@ -651,29 +573,20 @@ def _json_schema_to_pydantic_field(
         json_schema: The JSON schema for this field.
         required: List of required field names.
         root_schema: The root schema for resolving $ref.
-        enrich_descriptions: When True, embed constraints in the description.
 
     Returns:
         A tuple of (type, Field) for use with create_model.
     """
-    type_ = _json_schema_to_pydantic_type(
-        json_schema, root_schema, name_=name.title(), enrich_descriptions=enrich_descriptions
-    )
+    type_ = _json_schema_to_pydantic_type(json_schema, root_schema, name_=name.title())
+    description = json_schema.get("description")
+    examples = json_schema.get("examples")
     is_required = name in required
 
     field_params: dict[str, Any] = {}
     schema_extra: dict[str, Any] = {}
 
-    if enrich_descriptions:
-        rich_desc = build_rich_field_description(json_schema)
-        if rich_desc:
-            field_params["description"] = rich_desc
-    else:
-        description = json_schema.get("description")
-        if description:
-            field_params["description"] = description
-
-    examples = json_schema.get("examples")
+    if description:
+        field_params["description"] = description
     if examples:
         schema_extra["examples"] = examples
 
@@ -789,7 +702,6 @@ def _json_schema_to_pydantic_type(
     root_schema: dict[str, Any],
     *,
     name_: str | None = None,
-    enrich_descriptions: bool = False,
 ) -> Any:
     """Convert a JSON schema to a Python/Pydantic type.
 
@@ -797,7 +709,6 @@ def _json_schema_to_pydantic_type(
         json_schema: The JSON schema to convert.
         root_schema: The root schema for resolving $ref.
         name_: Optional name for nested models.
-        enrich_descriptions: Propagated to nested model creation.
 
     Returns:
         A Python type corresponding to the JSON schema.
@@ -805,9 +716,7 @@ def _json_schema_to_pydantic_type(
     ref = json_schema.get("$ref")
     if ref:
         ref_schema = _resolve_ref(ref, root_schema)
-        return _json_schema_to_pydantic_type(
-            ref_schema, root_schema, name_=name_, enrich_descriptions=enrich_descriptions
-        )
+        return _json_schema_to_pydantic_type(ref_schema, root_schema, name_=name_)
 
     enum_values = json_schema.get("enum")
     if enum_values:
@@ -822,10 +731,7 @@ def _json_schema_to_pydantic_type(
     if any_of_schemas:
         any_of_types = [
             _json_schema_to_pydantic_type(
-                schema,
-                root_schema,
-                name_=f"{name_ or 'Union'}Option{i}",
-                enrich_descriptions=enrich_descriptions,
+                schema, root_schema, name_=f"{name_ or 'Union'}Option{i}"
             )
             for i, schema in enumerate(any_of_schemas)
         ]
@@ -835,14 +741,10 @@ def _json_schema_to_pydantic_type(
     if all_of_schemas:
         if len(all_of_schemas) == 1:
             return _json_schema_to_pydantic_type(
-                all_of_schemas[0], root_schema, name_=name_,
-                enrich_descriptions=enrich_descriptions,
+                all_of_schemas[0], root_schema, name_=name_
             )
         merged = _merge_all_of_schemas(all_of_schemas, root_schema)
-        return _json_schema_to_pydantic_type(
-            merged, root_schema, name_=name_,
-            enrich_descriptions=enrich_descriptions,
-        )
+        return _json_schema_to_pydantic_type(merged, root_schema, name_=name_)
 
     type_ = json_schema.get("type")
 
@@ -858,8 +760,7 @@ def _json_schema_to_pydantic_type(
         items_schema = json_schema.get("items")
         if items_schema:
             item_type = _json_schema_to_pydantic_type(
-                items_schema, root_schema, name_=name_,
-                enrich_descriptions=enrich_descriptions,
+                items_schema, root_schema, name_=name_
             )
             return list[item_type]  # type: ignore[valid-type]
         return list
@@ -869,10 +770,7 @@ def _json_schema_to_pydantic_type(
             json_schema_ = json_schema.copy()
             if json_schema_.get("title") is None:
                 json_schema_["title"] = name_ or "DynamicModel"
-            return create_model_from_schema(
-                json_schema_, root_schema=root_schema,
-                enrich_descriptions=enrich_descriptions,
-            )
+            return create_model_from_schema(json_schema_, root_schema=root_schema)
         return dict
     if type_ == "null":
         return None

lib/crewai/src/crewai/utilities/reasoning_handler.py

@@ -1,10 +1,13 @@
+"""Handles planning/reasoning for agents before task execution."""
+
+from __future__ import annotations
+
 import json
 import logging
-from typing import Any, Final, Literal, cast
+from typing import TYPE_CHECKING, Any, Final, Literal, cast
 
 from pydantic import BaseModel, Field
 
-from crewai.agent import Agent
 from crewai.events.event_bus import crewai_event_bus
 from crewai.events.types.reasoning_events import (
     AgentReasoningCompletedEvent,
@@ -12,14 +15,30 @@ from crewai.events.types.reasoning_events import (
     AgentReasoningStartedEvent,
 )
 from crewai.llm import LLM
-from crewai.task import Task
+from crewai.utilities.llm_utils import create_llm
+from crewai.utilities.planning_types import PlanStep
 from crewai.utilities.string_utils import sanitize_tool_name
 
 
+if TYPE_CHECKING:
+    from crewai.agent import Agent
+    from crewai.agent.planning_config import PlanningConfig
+    from crewai.task import Task
+
+
+if TYPE_CHECKING:
+    from crewai.agent import Agent
+    from crewai.agent.planning_config import PlanningConfig
+    from crewai.task import Task
+
+
 class ReasoningPlan(BaseModel):
     """Model representing a reasoning plan for a task."""
 
     plan: str = Field(description="The detailed reasoning plan for the task.")
+    steps: list[PlanStep] = Field(
+        default_factory=list, description="Structured steps to execute"
+    )
     ready: bool = Field(description="Whether the agent is ready to execute the task.")
 
 
@@ -29,24 +48,63 @@ class AgentReasoningOutput(BaseModel):
     plan: ReasoningPlan = Field(description="The reasoning plan for the task.")
 
 
+# Aliases for backward compatibility
+PlanningPlan = ReasoningPlan
+AgentPlanningOutput = AgentReasoningOutput
+
+
 FUNCTION_SCHEMA: Final[dict[str, Any]] = {
     "type": "function",
     "function": {
         "name": "create_reasoning_plan",
-        "description": "Create or refine a reasoning plan for a task",
+        "description": "Create or refine a reasoning plan for a task with structured steps",
         "parameters": {
             "type": "object",
             "properties": {
                 "plan": {
                     "type": "string",
-                    "description": "The detailed reasoning plan for the task.",
+                    "description": "A brief summary of the overall plan.",
+                },
+                "steps": {
+                    "type": "array",
+                    "description": "List of discrete steps to execute the plan",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "step_number": {
+                                "type": "integer",
+                                "description": "Step number (1-based)",
+                            },
+                            "description": {
+                                "type": "string",
+                                "description": "What to do in this step",
+                            },
+                            "tool_to_use": {
+                                "type": ["string", "null"],
+                                "description": "Tool to use for this step, or null if no tool needed",
+                            },
+                            "depends_on": {
+                                "type": "array",
+                                "items": {"type": "integer"},
+                                "description": "Step numbers this step depends on (empty array if none)",
+                            },
+                        },
+                        "required": [
+                            "step_number",
+                            "description",
+                            "tool_to_use",
+                            "depends_on",
+                        ],
+                        "additionalProperties": False,
+                    },
                 },
                 "ready": {
                     "type": "boolean",
                     "description": "Whether the agent is ready to execute the task.",
                 },
             },
-            "required": ["plan", "ready"],
+            "required": ["plan", "steps", "ready"],
+            "additionalProperties": False,
         },
     },
 }
@@ -54,41 +112,101 @@ FUNCTION_SCHEMA: Final[dict[str, Any]] = {
 
 class AgentReasoning:
     """
-    Handles the agent reasoning process, enabling an agent to reflect and create a plan
-    before executing a task.
+    Handles the agent planning/reasoning process, enabling an agent to reflect
+    and create a plan before executing a task.
 
     Attributes:
-        task: The task for which the agent is reasoning.
-        agent: The agent performing the reasoning.
-        llm: The language model used for reasoning.
+        task: The task for which the agent is planning (optional).
+        agent: The agent performing the planning.
+        config: The planning configuration.
+        llm: The language model used for planning.
         logger: Logger for logging events and errors.
+        description: Task description or input text for planning.
+        expected_output: Expected output description.
     """
 
-    def __init__(self, task: Task, agent: Agent) -> None:
-        """Initialize the AgentReasoning with a task and an agent.
+    def __init__(
+        self,
+        agent: Agent,
+        task: Task | None = None,
+        *,
+        description: str | None = None,
+        expected_output: str | None = None,
+    ) -> None:
+        """Initialize the AgentReasoning with an agent and optional task.
 
         Args:
-            task: The task for which the agent is reasoning.
-            agent: The agent performing the reasoning.
+            agent: The agent performing the planning.
+            task: The task for which the agent is planning (optional).
+            description: Task description or input text (used if task is None).
+            expected_output: Expected output (used if task is None).
         """
-        self.task = task
         self.agent = agent
-        self.llm = cast(LLM, agent.llm)
+        self.task = task
+        # Use task attributes if available, otherwise use provided values
+        self._description = description or (
+            task.description if task else "Complete the requested task"
+        )
+        self._expected_output = expected_output or (
+            task.expected_output if task else "Complete the task successfully"
+        )
+        self.config = self._get_planning_config()
+        self.llm = self._resolve_llm()
         self.logger = logging.getLogger(__name__)
 
-    def handle_agent_reasoning(self) -> AgentReasoningOutput:
-        """Public method for the reasoning process that creates and refines a plan for the task until the agent is ready to execute it.
+    @property
+    def description(self) -> str:
+        """Get the task/input description."""
+        return self._description
+
+    @property
+    def expected_output(self) -> str:
+        """Get the expected output."""
+        return self._expected_output
+
+    def _get_planning_config(self) -> PlanningConfig:
+        """Get the planning configuration from the agent.
 
         Returns:
-            AgentReasoningOutput: The output of the agent reasoning process.
+            The planning configuration, using defaults if not set.
         """
-        # Emit a reasoning started event (attempt 1)
+        from crewai.agent.planning_config import PlanningConfig
+
+        if self.agent.planning_config is not None:
+            return self.agent.planning_config
+        # Fallback for backward compatibility
+        return PlanningConfig(
+            max_attempts=getattr(self.agent, "max_reasoning_attempts", None),
+        )
+
+    def _resolve_llm(self) -> LLM:
+        """Resolve which LLM to use for planning.
+
+        Returns:
+            The LLM to use - either from config or the agent's LLM.
+        """
+        if self.config.llm is not None:
+            if isinstance(self.config.llm, LLM):
+                return self.config.llm
+            return create_llm(self.config.llm)
+        return cast(LLM, self.agent.llm)
+
+    def handle_agent_reasoning(self) -> AgentReasoningOutput:
+        """Public method for the planning process that creates and refines a plan
+        for the task until the agent is ready to execute it.
+
+        Returns:
+            AgentReasoningOutput: The output of the agent planning process.
+        """
+        task_id = str(self.task.id) if self.task else "kickoff"
+
+        # Emit a planning started event (attempt 1)
         try:
             crewai_event_bus.emit(
                 self.agent,
                 AgentReasoningStartedEvent(
                     agent_role=self.agent.role,
-                    task_id=str(self.task.id),
+                    task_id=task_id,
                     attempt=1,
                     from_task=self.task,
                 ),
@@ -98,13 +216,13 @@ class AgentReasoning:
             pass
 
         try:
-            output = self.__handle_agent_reasoning()
+            output = self._execute_planning()
 
             crewai_event_bus.emit(
                 self.agent,
                 AgentReasoningCompletedEvent(
                     agent_role=self.agent.role,
-                    task_id=str(self.task.id),
+                    task_id=task_id,
                     plan=output.plan.plan,
                     ready=output.plan.ready,
                     attempt=1,
@@ -115,71 +233,77 @@ class AgentReasoning:
 
             return output
         except Exception as e:
-            # Emit reasoning failed event
+            # Emit planning failed event
             try:
                 crewai_event_bus.emit(
                     self.agent,
                     AgentReasoningFailedEvent(
                         agent_role=self.agent.role,
-                        task_id=str(self.task.id),
+                        task_id=task_id,
                         error=str(e),
                         attempt=1,
                         from_task=self.task,
                         from_agent=self.agent,
                     ),
                 )
-            except Exception as e:
-                logging.error(f"Error emitting reasoning failed event: {e}")
+            except Exception as event_error:
+                logging.error(f"Error emitting planning failed event: {event_error}")
 
             raise
 
-    def __handle_agent_reasoning(self) -> AgentReasoningOutput:
-        """Private method that handles the agent reasoning process.
+    def _execute_planning(self) -> AgentReasoningOutput:
+        """Execute the planning process.
 
         Returns:
-            The output of the agent reasoning process.
+            The output of the agent planning process.
         """
-        plan, ready = self.__create_initial_plan()
+        plan, steps, ready = self._create_initial_plan()
+        plan, steps, ready = self._refine_plan_if_needed(plan, steps, ready)
 
-        plan, ready = self.__refine_plan_if_needed(plan, ready)
-
-        reasoning_plan = ReasoningPlan(plan=plan, ready=ready)
+        reasoning_plan = ReasoningPlan(plan=plan, steps=steps, ready=ready)
         return AgentReasoningOutput(plan=reasoning_plan)
 
-    def __create_initial_plan(self) -> tuple[str, bool]:
-        """Creates the initial reasoning plan for the task.
+    def _create_initial_plan(self) -> tuple[str, list[PlanStep], bool]:
+        """Creates the initial plan for the task.
 
         Returns:
-            The initial plan and whether the agent is ready to execute the task.
+            A tuple of the plan summary, list of steps, and whether the agent is ready.
         """
-        reasoning_prompt = self.__create_reasoning_prompt()
+        planning_prompt = self._create_planning_prompt()
+        planning_prompt = self._create_planning_prompt()
 
         if self.llm.supports_function_calling():
-            plan, ready = self.__call_with_function(reasoning_prompt, "initial_plan")
-            return plan, ready
-        response = _call_llm_with_reasoning_prompt(
-            llm=self.llm,
-            prompt=reasoning_prompt,
-            task=self.task,
-            reasoning_agent=self.agent,
-            backstory=self.__get_agent_backstory(),
-            plan_type="initial_plan",
+            plan, steps, ready = self._call_with_function(
+                planning_prompt, "create_plan"
+            )
+            return plan, steps, ready
+
+        response = self._call_llm_with_prompt(
+            prompt=planning_prompt,
+            plan_type="create_plan",
         )
 
-        return self.__parse_reasoning_response(str(response))
+        plan, ready = self._parse_planning_response(str(response))
+        return plan, [], ready  # No structured steps from text parsing
 
-    def __refine_plan_if_needed(self, plan: str, ready: bool) -> tuple[str, bool]:
-        """Refines the reasoning plan if the agent is not ready to execute the task.
+    def _refine_plan_if_needed(
+        self, plan: str, steps: list[PlanStep], ready: bool
+    ) -> tuple[str, list[PlanStep], bool]:
+        """Refines the plan if the agent is not ready to execute the task.
 
         Args:
-            plan: The current reasoning plan.
+            plan: The current plan.
+            steps: The current list of steps.
             ready: Whether the agent is ready to execute the task.
 
         Returns:
-            The refined plan and whether the agent is ready to execute the task.
+            The refined plan, steps, and whether the agent is ready to execute.
         """
+
         attempt = 1
-        max_attempts = self.agent.max_reasoning_attempts
+        max_attempts = self.config.max_attempts
+        task_id = str(self.task.id) if self.task else "kickoff"
+        current_attempt = attempt + 1
 
         while not ready and (max_attempts is None or attempt < max_attempts):
             # Emit event for each refinement attempt
@@ -188,62 +312,82 @@ class AgentReasoning:
                     self.agent,
                     AgentReasoningStartedEvent(
                         agent_role=self.agent.role,
-                        task_id=str(self.task.id),
-                        attempt=attempt + 1,
+                        task_id=task_id,
+                        attempt=current_attempt,
                         from_task=self.task,
                     ),
                 )
             except Exception:  # noqa: S110
                 pass
 
-            refine_prompt = self.__create_refine_prompt(plan)
+            refine_prompt = self._create_refine_prompt(plan)
+            refine_prompt = self._create_refine_prompt(plan)
 
             if self.llm.supports_function_calling():
-                plan, ready = self.__call_with_function(refine_prompt, "refine_plan")
+                plan, steps, ready = self._call_with_function(
+                    refine_prompt, "refine_plan"
+                )
             else:
-                response = _call_llm_with_reasoning_prompt(
-                    llm=self.llm,
+                response = self._call_llm_with_prompt(
                     prompt=refine_prompt,
-                    task=self.task,
-                    reasoning_agent=self.agent,
-                    backstory=self.__get_agent_backstory(),
                     plan_type="refine_plan",
                 )
-                plan, ready = self.__parse_reasoning_response(str(response))
+                plan, ready = self._parse_planning_response(str(response))
+                steps = []  # No structured steps from text parsing
+
+            # Emit completed event for this refinement attempt
+            try:
+                crewai_event_bus.emit(
+                    self.agent,
+                    AgentReasoningCompletedEvent(
+                        agent_role=self.agent.role,
+                        task_id=task_id,
+                        plan=plan,
+                        ready=ready,
+                        attempt=current_attempt,
+                        from_task=self.task,
+                        from_agent=self.agent,
+                    ),
+                )
+            except Exception:  # noqa: S110
+                pass
 
             attempt += 1
 
             if max_attempts is not None and attempt >= max_attempts:
                 self.logger.warning(
-                    f"Agent reasoning reached maximum attempts ({max_attempts}) without being ready. Proceeding with current plan."
+                    f"Agent planning reached maximum attempts ({max_attempts}) "
+                    "without being ready. Proceeding with current plan."
                 )
                 break
 
-        return plan, ready
+        return plan, steps, ready
 
-    def __call_with_function(self, prompt: str, prompt_type: str) -> tuple[str, bool]:
-        """Calls the LLM with function calling to get a reasoning plan.
+    def _call_with_function(
+        self, prompt: str, plan_type: Literal["create_plan", "refine_plan"]
+    ) -> tuple[str, list[PlanStep], bool]:
+        """Calls the LLM with function calling to get a plan.
 
         Args:
             prompt: The prompt to send to the LLM.
-            prompt_type: The type of prompt (initial_plan or refine_plan).
+            plan_type: The type of plan being created.
 
         Returns:
-            A tuple containing the plan and whether the agent is ready.
+            A tuple containing the plan summary, list of steps, and whether the agent is ready.
         """
-        self.logger.debug(f"Using function calling for {prompt_type} reasoning")
+        self.logger.debug(f"Using function calling for {plan_type} planning")
 
         try:
-            system_prompt = self.agent.i18n.retrieve("reasoning", prompt_type).format(
-                role=self.agent.role,
-                goal=self.agent.goal,
-                backstory=self.__get_agent_backstory(),
-            )
+            system_prompt = self._get_system_prompt()
 
             # Prepare a simple callable that just returns the tool arguments as JSON
-            def _create_reasoning_plan(plan: str, ready: bool = True) -> str:
-                """Return the reasoning plan result in JSON string form."""
-                return json.dumps({"plan": plan, "ready": ready})
+            def _create_reasoning_plan(
+                plan: str,
+                steps: list[dict[str, Any]] | None = None,
+                ready: bool = True,
+            ) -> str:
+                """Return the planning result in JSON string form."""
+                return json.dumps({"plan": plan, "steps": steps or [], "ready": ready})
 
             response = self.llm.call(
                 [
@@ -255,19 +399,33 @@ class AgentReasoning:
                 from_task=self.task,
                 from_agent=self.agent,
             )
-
-            self.logger.debug(f"Function calling response: {response[:100]}...")
-
             try:
                 result = json.loads(response)
                 if "plan" in result and "ready" in result:
-                    return result["plan"], result["ready"]
+                    # Parse steps from the response
+                    steps: list[PlanStep] = []
+                    raw_steps = result.get("steps", [])
+                    try:
+                        for step_data in raw_steps:
+                            step = PlanStep(
+                                step_number=step_data.get("step_number", 0),
+                                description=step_data.get("description", ""),
+                                tool_to_use=step_data.get("tool_to_use"),
+                                depends_on=step_data.get("depends_on", []),
+                            )
+                            steps.append(step)
+                    except Exception as step_error:
+                        self.logger.warning(
+                            f"Failed to parse step: {step_data}, error: {step_error}"
+                        )
+                    return result["plan"], steps, result["ready"]
             except (json.JSONDecodeError, KeyError):
                 pass
 
             response_str = str(response)
             return (
                 response_str,
+                [],
                 "READY: I am ready to execute the task." in response_str,
             )
 
@@ -277,13 +435,7 @@ class AgentReasoning:
             )
 
             try:
-                system_prompt = self.agent.i18n.retrieve(
-                    "reasoning", prompt_type
-                ).format(
-                    role=self.agent.role,
-                    goal=self.agent.goal,
-                    backstory=self.__get_agent_backstory(),
-                )
+                system_prompt = self._get_system_prompt()
 
                 fallback_response = self.llm.call(
                     [
@@ -297,78 +449,165 @@ class AgentReasoning:
                 fallback_str = str(fallback_response)
                 return (
                     fallback_str,
+                    [],
                     "READY: I am ready to execute the task." in fallback_str,
                 )
             except Exception as inner_e:
                 self.logger.error(f"Error during fallback text parsing: {inner_e!s}")
                 return (
                     "Failed to generate a plan due to an error.",
+                    [],
                     True,
                 )  # Default to ready to avoid getting stuck
 
-    def __get_agent_backstory(self) -> str:
-        """
-        Safely gets the agent's backstory, providing a default if not available.
+    def _call_llm_with_prompt(
+        self,
+        prompt: str,
+        plan_type: Literal["create_plan", "refine_plan"],
+    ) -> str:
+        """Calls the LLM with the planning prompt.
+
+        Args:
+            prompt: The prompt to send to the LLM.
+            plan_type: The type of plan being created.
 
         Returns:
-            str: The agent's backstory or a default value.
+            The LLM response.
+        """
+        system_prompt = self._get_system_prompt()
+
+        response = self.llm.call(
+            [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt},
+            ],
+            from_task=self.task,
+            from_agent=self.agent,
+        )
+        return str(response)
+
+    def _get_system_prompt(self) -> str:
+        """Get the system prompt for planning.
+
+        Returns:
+            The system prompt, either custom or from i18n.
+        """
+        if self.config.system_prompt is not None:
+            return self.config.system_prompt
+
+        # Try new "planning" section first, fall back to "reasoning" for compatibility
+        try:
+            return self.agent.i18n.retrieve("planning", "system_prompt")
+        except (KeyError, AttributeError):
+            # Fallback to reasoning section for backward compatibility
+            return self.agent.i18n.retrieve("reasoning", "initial_plan").format(
+                role=self.agent.role,
+                goal=self.agent.goal,
+                backstory=self._get_agent_backstory(),
+            )
+
+    def _get_agent_backstory(self) -> str:
+        """Safely gets the agent's backstory, providing a default if not available.
+
+        Returns:
+            The agent's backstory or a default value.
         """
         return getattr(self.agent, "backstory", "No backstory provided")
 
-    def __create_reasoning_prompt(self) -> str:
-        """
-        Creates a prompt for the agent to reason about the task.
+    def _create_planning_prompt(self) -> str:
+        """Creates a prompt for the agent to plan the task.
 
         Returns:
-            str: The reasoning prompt.
+            The planning prompt.
         """
-        available_tools = self.__format_available_tools()
+        available_tools = self._format_available_tools()
 
-        return self.agent.i18n.retrieve("reasoning", "create_plan_prompt").format(
-            role=self.agent.role,
-            goal=self.agent.goal,
-            backstory=self.__get_agent_backstory(),
-            description=self.task.description,
-            expected_output=self.task.expected_output,
-            tools=available_tools,
-        )
+        # Use custom prompt if provided
+        if self.config.plan_prompt is not None:
+            return self.config.plan_prompt.format(
+                role=self.agent.role,
+                goal=self.agent.goal,
+                backstory=self._get_agent_backstory(),
+                description=self.description,
+                expected_output=self.expected_output,
+                tools=available_tools,
+                max_steps=self.config.max_steps,
+            )
 
-    def __format_available_tools(self) -> str:
-        """
-        Formats the available tools for inclusion in the prompt.
+        # Try new "planning" section first
+        try:
+            return self.agent.i18n.retrieve("planning", "create_plan_prompt").format(
+                description=self.description,
+                expected_output=self.expected_output,
+                tools=available_tools,
+                max_steps=self.config.max_steps,
+            )
+        except (KeyError, AttributeError):
+            # Fallback to reasoning section for backward compatibility
+            return self.agent.i18n.retrieve("reasoning", "create_plan_prompt").format(
+                role=self.agent.role,
+                goal=self.agent.goal,
+                backstory=self._get_agent_backstory(),
+                description=self.description,
+                expected_output=self.expected_output,
+                tools=available_tools,
+            )
+
+    def _format_available_tools(self) -> str:
+        """Formats the available tools for inclusion in the prompt.
 
         Returns:
-            str: Comma-separated list of tool names.
+            Comma-separated list of tool names.
         """
         try:
-            return ", ".join(
-                [sanitize_tool_name(tool.name) for tool in (self.task.tools or [])]
-            )
+            # Try task tools first, then agent tools
+            tools = []
+            if self.task:
+                tools = self.task.tools or []
+            if not tools:
+                tools = getattr(self.agent, "tools", []) or []
+            if not tools:
+                return "No tools available"
+            return ", ".join([sanitize_tool_name(tool.name) for tool in tools])
         except (AttributeError, TypeError):
             return "No tools available"
 
-    def __create_refine_prompt(self, current_plan: str) -> str:
-        """
-        Creates a prompt for the agent to refine its reasoning plan.
+    def _create_refine_prompt(self, current_plan: str) -> str:
+        """Creates a prompt for the agent to refine its plan.
 
         Args:
-            current_plan: The current reasoning plan.
+            current_plan: The current plan.
 
         Returns:
-            str: The refine prompt.
+            The refine prompt.
         """
-        return self.agent.i18n.retrieve("reasoning", "refine_plan_prompt").format(
-            role=self.agent.role,
-            goal=self.agent.goal,
-            backstory=self.__get_agent_backstory(),
-            current_plan=current_plan,
-        )
+        # Use custom prompt if provided
+        if self.config.refine_prompt is not None:
+            return self.config.refine_prompt.format(
+                role=self.agent.role,
+                goal=self.agent.goal,
+                backstory=self._get_agent_backstory(),
+                current_plan=current_plan,
+                max_steps=self.config.max_steps,
+            )
+
+        # Try new "planning" section first
+        try:
+            return self.agent.i18n.retrieve("planning", "refine_plan_prompt").format(
+                current_plan=current_plan,
+            )
+        except (KeyError, AttributeError):
+            # Fallback to reasoning section for backward compatibility
+            return self.agent.i18n.retrieve("reasoning", "refine_plan_prompt").format(
+                role=self.agent.role,
+                goal=self.agent.goal,
+                backstory=self._get_agent_backstory(),
+                current_plan=current_plan,
+            )
 
     @staticmethod
-    def __parse_reasoning_response(response: str) -> tuple[str, bool]:
-        """
-        Parses the reasoning response to extract the plan and whether
-        the agent is ready to execute the task.
+    def _parse_planning_response(response: str) -> tuple[str, bool]:
+        """Parses the planning response to extract the plan and readiness.
 
         Args:
             response: The LLM response.
@@ -380,25 +619,13 @@ class AgentReasoning:
             return "No plan was generated.", False
 
         plan = response
-        ready = False
-
-        if "READY: I am ready to execute the task." in response:
-            ready = True
+        ready = "READY: I am ready to execute the task." in response
 
         return plan, ready
 
-    def _handle_agent_reasoning(self) -> AgentReasoningOutput:
-        """
-        Deprecated method for backward compatibility.
-        Use handle_agent_reasoning() instead.
 
-        Returns:
-            AgentReasoningOutput: The output of the agent reasoning process.
-        """
-        self.logger.warning(
-            "The _handle_agent_reasoning method is deprecated. Use handle_agent_reasoning instead."
-        )
-        return self.handle_agent_reasoning()
+# Alias for backward compatibility
+AgentPlanning = AgentReasoning
 
 
 def _call_llm_with_reasoning_prompt(
@@ -409,7 +636,9 @@ def _call_llm_with_reasoning_prompt(
     backstory: str,
     plan_type: Literal["initial_plan", "refine_plan"],
 ) -> str:
-    """Calls the LLM with the reasoning prompt.
+    """Deprecated: Calls the LLM with the reasoning prompt.
+
+    This function is kept for backward compatibility.
 
     Args:
         llm: The language model to use.
@@ -417,7 +646,7 @@ def _call_llm_with_reasoning_prompt(
         task: The task for which the agent is reasoning.
         reasoning_agent: The agent performing the reasoning.
         backstory: The agent's backstory.
-        plan_type: The type of plan being created ("initial_plan" or "refine_plan").
+        plan_type: The type of plan being created.
 
     Returns:
         The LLM response.

lib/crewai/tests/agents/test_agent.py

@@ -1456,7 +1456,7 @@ def test_agent_execute_task_with_tool():
     )
 
     result = agent.execute_task(task)
-    assert "you should always think about what to do" in result
+    assert "test query" in result
 
 
 @pytest.mark.vcr()
@@ -1475,9 +1475,9 @@ def test_agent_execute_task_with_custom_llm():
     )
 
     result = agent.execute_task(task)
-    assert "In circuits they thrive" in result
-    assert "Artificial minds awake" in result
-    assert "Future's coded drive" in result
+    assert "Artificial minds" in result
+    assert "Code and circuits" in result
+    assert "Future undefined" in result
 
 
 @pytest.mark.vcr()

lib/crewai/tests/agents/test_agent_executor.py

@@ -26,6 +26,18 @@ class TestAgentReActState:
         assert state.current_answer is None
         assert state.is_finished is False
         assert state.ask_for_human_input is False
+        # Planning state fields
+        assert state.plan is None
+        assert state.plan_ready is False
+
+    def test_state_with_plan(self):
+        """Test AgentReActState initialization with planning fields."""
+        state = AgentReActState(
+            plan="Step 1: Do X\nStep 2: Do Y",
+            plan_ready=True,
+        )
+        assert state.plan == "Step 1: Do X\nStep 2: Do Y"
+        assert state.plan_ready is True
 
     def test_state_with_values(self):
         """Test AgentReActState initialization with values."""
@@ -636,3 +648,249 @@ class TestNativeToolExecution:
         tool_messages = [m for m in executor.state.messages if m.get("role") == "tool"]
         assert len(tool_messages) == 1
         assert tool_messages[0]["tool_call_id"] == "call_1"
+
+
+class TestAgentExecutorPlanning:
+    """Test planning functionality in AgentExecutor with real agent kickoff."""
+
+    @pytest.mark.vcr()
+    def test_agent_kickoff_with_planning_stores_plan_in_state(self):
+        """Test that Agent.kickoff() with planning enabled stores plan in executor state."""
+        from crewai import Agent, PlanningConfig
+        from crewai.llm import LLM
+
+        llm = LLM("gpt-4o-mini")
+
+        agent = Agent(
+            role="Math Assistant",
+            goal="Help solve simple math problems",
+            backstory="A helpful assistant that solves math problems step by step",
+            llm=llm,
+            planning_config=PlanningConfig(max_attempts=1),
+            verbose=False,
+        )
+
+        # Execute kickoff with a simple task
+        result = agent.kickoff("What is 2 + 2?")
+
+        # Verify result
+        assert result is not None
+        assert "4" in str(result)
+
+    @pytest.mark.vcr()
+    def test_agent_kickoff_without_planning_skips_plan_generation(self):
+        """Test that Agent.kickoff() without planning skips planning phase."""
+        from crewai import Agent
+        from crewai.llm import LLM
+
+        llm = LLM("gpt-4o-mini")
+
+        agent = Agent(
+            role="Math Assistant",
+            goal="Help solve simple math problems",
+            backstory="A helpful assistant",
+            llm=llm,
+            # No planning_config = no planning
+            verbose=False,
+        )
+
+        # Execute kickoff
+        result = agent.kickoff("What is 3 + 3?")
+
+        # Verify we get a result
+        assert result is not None
+        assert "6" in str(result)
+
+    @pytest.mark.vcr()
+    def test_planning_disabled_skips_planning(self):
+        """Test that planning=False skips planning."""
+        from crewai import Agent
+        from crewai.llm import LLM
+
+        llm = LLM("gpt-4o-mini")
+
+        agent = Agent(
+            role="Math Assistant",
+            goal="Help solve simple math problems",
+            backstory="A helpful assistant",
+            llm=llm,
+            planning=False,  # Explicitly disable planning
+            verbose=False,
+        )
+
+        result = agent.kickoff("What is 5 + 5?")
+
+        # Should still complete successfully
+        assert result is not None
+        assert "10" in str(result)
+
+    def test_backward_compat_reasoning_true_enables_planning(self):
+        """Test that reasoning=True (deprecated) still enables planning."""
+        import warnings
+        from crewai import Agent
+        from crewai.llm import LLM
+
+        llm = LLM("gpt-4o-mini")
+
+        with warnings.catch_warnings(record=True):
+            warnings.simplefilter("always")
+            agent = Agent(
+                role="Test Agent",
+                goal="Complete tasks",
+                backstory="A helpful agent",
+                llm=llm,
+                reasoning=True,  # Deprecated but should still work
+                verbose=False,
+            )
+
+        # Should have planning_config created from reasoning=True
+        assert agent.planning_config is not None
+        assert agent.planning_enabled is True
+
+    @pytest.mark.vcr()
+    def test_executor_state_contains_plan_after_planning(self):
+        """Test that executor state contains plan after planning phase."""
+        from crewai import Agent, PlanningConfig
+        from crewai.llm import LLM
+        from crewai.experimental.agent_executor import AgentExecutor
+
+        llm = LLM("gpt-4o-mini")
+
+        agent = Agent(
+            role="Math Assistant",
+            goal="Help solve simple math problems",
+            backstory="A helpful assistant that solves math problems step by step",
+            llm=llm,
+            planning_config=PlanningConfig(max_attempts=1),
+            verbose=False,
+        )
+
+        # Track executor for inspection
+        executor_ref = [None]
+        original_invoke = AgentExecutor.invoke
+
+        def capture_executor(self, inputs):
+            executor_ref[0] = self
+            return original_invoke(self, inputs)
+
+        with patch.object(AgentExecutor, "invoke", capture_executor):
+            result = agent.kickoff("What is 7 + 7?")
+
+        # Verify result
+        assert result is not None
+
+        # If we captured an executor, check its state
+        if executor_ref[0] is not None:
+            # After planning, state should have plan info
+            assert hasattr(executor_ref[0].state, "plan")
+            assert hasattr(executor_ref[0].state, "plan_ready")
+
+    @pytest.mark.vcr()
+    def test_planning_creates_minimal_steps_for_multi_step_task(self):
+        """Test that planning creates only necessary steps for a multi-step task.
+
+        This task requires exactly 3 dependent steps:
+        1. Identify the first 3 prime numbers (2, 3, 5)
+        2. Sum them (2 + 3 + 5 = 10)
+        3. Multiply by 2 (10 * 2 = 20)
+
+        The plan should reflect these dependencies without unnecessary padding.
+        """
+        from crewai import Agent, PlanningConfig
+        from crewai.llm import LLM
+        from crewai.experimental.agent_executor import AgentExecutor
+
+        llm = LLM("gpt-4o-mini")
+
+        agent = Agent(
+            role="Math Tutor",
+            goal="Solve multi-step math problems accurately",
+            backstory="An expert math tutor who breaks down problems step by step",
+            llm=llm,
+            planning_config=PlanningConfig(max_attempts=1, max_steps=10),
+            verbose=False,
+        )
+
+        # Track the plan that gets generated
+        captured_plan = [None]
+        original_invoke = AgentExecutor.invoke
+
+        def capture_plan(self, inputs):
+            result = original_invoke(self, inputs)
+            captured_plan[0] = self.state.plan
+            return result
+
+        with patch.object(AgentExecutor, "invoke", capture_plan):
+            result = agent.kickoff(
+                "Calculate the sum of the first 3 prime numbers, then multiply that result by 2. "
+                "Show your work for each step."
+            )
+
+        # Verify result contains the correct answer (20)
+        assert result is not None
+        assert "20" in str(result)
+
+        # Verify a plan was generated
+        assert captured_plan[0] is not None
+
+        # The plan should be concise - this task needs ~3 steps, not 10+
+        plan_text = captured_plan[0]
+        # Count steps by looking for numbered items or bullet points
+        import re
+
+        step_pattern = r"^\s*\d+[\.\):]|\n\s*-\s+"
+        steps = re.findall(step_pattern, plan_text, re.MULTILINE)
+        # Plan should have roughly 3-5 steps, not fill up to max_steps
+        assert len(steps) <= 6, f"Plan has too many steps ({len(steps)}): {plan_text}"
+
+    @pytest.mark.vcr()
+    def test_planning_handles_sequential_dependency_task(self):
+        """Test planning for a task where step N depends on step N-1.
+
+        Task: Convert 100 Celsius to Fahrenheit, then round to nearest 10.
+        Step 1: Apply formula (C * 9/5 + 32) = 212
+        Step 2: Round 212 to nearest 10 = 210
+
+        This tests that the planner recognizes sequential dependencies.
+        """
+        from crewai import Agent, PlanningConfig
+        from crewai.llm import LLM
+        from crewai.experimental.agent_executor import AgentExecutor
+
+        llm = LLM("gpt-4o-mini")
+
+        agent = Agent(
+            role="Unit Converter",
+            goal="Accurately convert between units and apply transformations",
+            backstory="A precise unit conversion specialist",
+            llm=llm,
+            planning_config=PlanningConfig(max_attempts=1, max_steps=10),
+            verbose=False,
+        )
+
+        captured_plan = [None]
+        original_invoke = AgentExecutor.invoke
+
+        def capture_plan(self, inputs):
+            result = original_invoke(self, inputs)
+            captured_plan[0] = self.state.plan
+            return result
+
+        with patch.object(AgentExecutor, "invoke", capture_plan):
+            result = agent.kickoff(
+                "Convert 100 degrees Celsius to Fahrenheit, then round the result to the nearest 10."
+            )
+
+        assert result is not None
+        # 100C = 212F, rounded to nearest 10 = 210
+        assert "210" in str(result) or "212" in str(result)
+
+        # Plan should exist and be minimal (2-3 steps for this task)
+        assert captured_plan[0] is not None
+        plan_text = captured_plan[0]
+
+        import re
+
+        step_pattern = r"^\s*\d+[\.\):]|\n\s*-\s+"
+        steps = re.findall(step_pattern, plan_text, re.MULTILINE)
+        assert len(steps) <= 5, f"Plan should be minimal ({len(steps)} steps): {plan_text}"

lib/crewai/tests/agents/test_agent_reasoning.py

@@ -1,240 +1,345 @@
-"""Tests for reasoning in agents."""
+"""Tests for planning/reasoning in agents."""
 
-import json
+import warnings
 
 import pytest
 
-from crewai import Agent, Task
+from crewai import Agent, PlanningConfig, Task
 from crewai.llm import LLM
 
 
-@pytest.fixture
-def mock_llm_responses():
-    """Fixture for mock LLM responses."""
-    return {
-        "ready": "I'll solve this simple math problem.\n\nREADY: I am ready to execute the task.\n\n",
-        "not_ready": "I need to think about derivatives.\n\nNOT READY: I need to refine my plan because I'm not sure about the derivative rules.",
-        "ready_after_refine": "I'll use the power rule for derivatives where d/dx(x^n) = n*x^(n-1).\n\nREADY: I am ready to execute the task.",
-        "execution": "4",
-    }
+# =============================================================================
+# Tests for PlanningConfig configuration (no LLM calls needed)
+# =============================================================================
 
 
-def test_agent_with_reasoning(mock_llm_responses):
-    """Test agent with reasoning."""
-    llm = LLM("gpt-3.5-turbo")
+def test_planning_config_default_values():
+    """Test PlanningConfig default values."""
+    config = PlanningConfig()
+
+    assert config.max_attempts is None
+    assert config.max_steps == 20
+    assert config.system_prompt is None
+    assert config.plan_prompt is None
+    assert config.refine_prompt is None
+    assert config.llm is None
+
+
+def test_planning_config_custom_values():
+    """Test PlanningConfig with custom values."""
+    config = PlanningConfig(
+        max_attempts=5,
+        max_steps=15,
+        system_prompt="Custom system",
+        plan_prompt="Custom plan: {description}",
+        refine_prompt="Custom refine: {current_plan}",
+        llm="gpt-4",
+    )
+
+    assert config.max_attempts == 5
+    assert config.max_steps == 15
+    assert config.system_prompt == "Custom system"
+    assert config.plan_prompt == "Custom plan: {description}"
+    assert config.refine_prompt == "Custom refine: {current_plan}"
+    assert config.llm == "gpt-4"
+
+
+def test_agent_with_planning_config_custom_prompts():
+    """Test agent with PlanningConfig using custom prompts."""
+    llm = LLM("gpt-4o-mini")
+
+    custom_system_prompt = "You are a specialized planner."
+    custom_plan_prompt = "Plan this task: {description}"
+
+    agent = Agent(
+        role="Test Agent",
+        goal="To test custom prompts",
+        backstory="I am a test agent.",
+        llm=llm,
+        planning_config=PlanningConfig(
+            system_prompt=custom_system_prompt,
+            plan_prompt=custom_plan_prompt,
+            max_steps=10,
+        ),
+        verbose=False,
+    )
+
+    # Just test that the agent is created properly
+    assert agent.planning_config is not None
+    assert agent.planning_config.system_prompt == custom_system_prompt
+    assert agent.planning_config.plan_prompt == custom_plan_prompt
+    assert agent.planning_config.max_steps == 10
+
+
+def test_agent_with_planning_config_disabled():
+    """Test agent with PlanningConfig disabled."""
+    llm = LLM("gpt-4o-mini")
+
+    agent = Agent(
+        role="Test Agent",
+        goal="To test disabled planning",
+        backstory="I am a test agent.",
+        llm=llm,
+        planning=False,
+        verbose=False,
+    )
+
+    # Planning should be disabled
+    assert agent.planning_enabled is False
+
+
+def test_planning_enabled_property():
+    """Test the planning_enabled property on Agent."""
+    llm = LLM("gpt-4o-mini")
+
+    # With planning_config enabled
+    agent_with_planning = Agent(
+        role="Test Agent",
+        goal="Test",
+        backstory="Test",
+        llm=llm,
+        planning=True,
+    )
+    assert agent_with_planning.planning_enabled is True
+
+    # With planning_config disabled
+    agent_disabled = Agent(
+        role="Test Agent",
+        goal="Test",
+        backstory="Test",
+        llm=llm,
+        planning=False,
+    )
+    assert agent_disabled.planning_enabled is False
+
+    # Without planning_config
+    agent_no_planning = Agent(
+        role="Test Agent",
+        goal="Test",
+        backstory="Test",
+        llm=llm,
+    )
+    assert agent_no_planning.planning_enabled is False
+
+
+# =============================================================================
+# Tests for backward compatibility with reasoning=True (no LLM calls)
+# =============================================================================
+
+
+def test_agent_with_reasoning_backward_compat():
+    """Test agent with reasoning=True (backward compatibility)."""
+    llm = LLM("gpt-4o-mini")
+
+    # This should emit a deprecation warning
+    with warnings.catch_warnings(record=True):
+        warnings.simplefilter("always")
+        agent = Agent(
+            role="Test Agent",
+            goal="To test the reasoning feature",
+            backstory="I am a test agent created to verify the reasoning feature works correctly.",
+            llm=llm,
+            reasoning=True,
+            verbose=False,
+        )
+
+    # Should have created a PlanningConfig internally
+    assert agent.planning_config is not None
+    assert agent.planning_enabled is True
+
+
+def test_agent_with_reasoning_and_max_attempts_backward_compat():
+    """Test agent with reasoning=True and max_reasoning_attempts (backward compatibility)."""
+    llm = LLM("gpt-4o-mini")
 
     agent = Agent(
         role="Test Agent",
         goal="To test the reasoning feature",
-        backstory="I am a test agent created to verify the reasoning feature works correctly.",
+        backstory="I am a test agent.",
         llm=llm,
         reasoning=True,
-        verbose=True,
+        max_reasoning_attempts=5,
+        verbose=False,
     )
 
-    task = Task(
-        description="Simple math task: What's 2+2?",
-        expected_output="The answer should be a number.",
-        agent=agent,
-    )
-
-    agent.llm.call = lambda messages, *args, **kwargs: (
-        mock_llm_responses["ready"]
-        if any("create a detailed plan" in msg.get("content", "") for msg in messages)
-        else mock_llm_responses["execution"]
-    )
-
-    result = agent.execute_task(task)
-
-    assert result == mock_llm_responses["execution"]
-    assert "Reasoning Plan:" in task.description
+    # Should have created a PlanningConfig with max_attempts
+    assert agent.planning_config is not None
+    assert agent.planning_config.max_attempts == 5
 
 
-def test_agent_with_reasoning_not_ready_initially(mock_llm_responses):
-    """Test agent with reasoning that requires refinement."""
-    llm = LLM("gpt-3.5-turbo")
+# =============================================================================
+# Tests for Agent.kickoff() with planning (uses AgentExecutor)
+# =============================================================================
+
+
+@pytest.mark.vcr()
+def test_agent_kickoff_with_planning():
+    """Test Agent.kickoff() with planning enabled generates a plan."""
+    llm = LLM("gpt-4o-mini")
 
     agent = Agent(
-        role="Test Agent",
-        goal="To test the reasoning feature",
-        backstory="I am a test agent created to verify the reasoning feature works correctly.",
+        role="Math Assistant",
+        goal="Help solve math problems step by step",
+        backstory="A helpful math tutor",
         llm=llm,
-        reasoning=True,
-        max_reasoning_attempts=2,
-        verbose=True,
+        planning_config=PlanningConfig(max_attempts=1),
+        verbose=False,
     )
 
-    task = Task(
-        description="Complex math task: What's the derivative of x²?",
-        expected_output="The answer should be a mathematical expression.",
-        agent=agent,
-    )
+    result = agent.kickoff("What is 15 + 27?")
 
-    call_count = [0]
-
-    def mock_llm_call(messages, *args, **kwargs):
-        if any(
-            "create a detailed plan" in msg.get("content", "") for msg in messages
-        ) or any("refine your plan" in msg.get("content", "") for msg in messages):
-            call_count[0] += 1
-            if call_count[0] == 1:
-                return mock_llm_responses["not_ready"]
-            return mock_llm_responses["ready_after_refine"]
-        return "2x"
-
-    agent.llm.call = mock_llm_call
-
-    result = agent.execute_task(task)
-
-    assert result == "2x"
-    assert call_count[0] == 2  # Should have made 2 reasoning calls
-    assert "Reasoning Plan:" in task.description
+    assert result is not None
+    assert "42" in str(result)
 
 
-def test_agent_with_reasoning_max_attempts_reached():
-    """Test agent with reasoning that reaches max attempts without being ready."""
-    llm = LLM("gpt-3.5-turbo")
+@pytest.mark.vcr()
+def test_agent_kickoff_without_planning():
+    """Test Agent.kickoff() without planning skips plan generation."""
+    llm = LLM("gpt-4o-mini")
 
     agent = Agent(
-        role="Test Agent",
-        goal="To test the reasoning feature",
-        backstory="I am a test agent created to verify the reasoning feature works correctly.",
+        role="Math Assistant",
+        goal="Help solve math problems",
+        backstory="A helpful assistant",
         llm=llm,
-        reasoning=True,
-        max_reasoning_attempts=2,
-        verbose=True,
+        # No planning_config = no planning
+        verbose=False,
     )
 
-    task = Task(
-        description="Complex math task: Solve the Riemann hypothesis.",
-        expected_output="A proof or disproof of the hypothesis.",
-        agent=agent,
-    )
+    result = agent.kickoff("What is 8 * 7?")
 
-    call_count = [0]
-
-    def mock_llm_call(messages, *args, **kwargs):
-        if any(
-            "create a detailed plan" in msg.get("content", "") for msg in messages
-        ) or any("refine your plan" in msg.get("content", "") for msg in messages):
-            call_count[0] += 1
-            return f"Attempt {call_count[0]}: I need more time to think.\n\nNOT READY: I need to refine my plan further."
-        return "This is an unsolved problem in mathematics."
-
-    agent.llm.call = mock_llm_call
-
-    result = agent.execute_task(task)
-
-    assert result == "This is an unsolved problem in mathematics."
-    assert (
-        call_count[0] == 2
-    )  # Should have made exactly 2 reasoning calls (max_attempts)
-    assert "Reasoning Plan:" in task.description
+    assert result is not None
+    assert "56" in str(result)
 
 
-def test_agent_reasoning_error_handling():
-    """Test error handling during the reasoning process."""
-    llm = LLM("gpt-3.5-turbo")
+@pytest.mark.vcr()
+def test_agent_kickoff_with_planning_disabled():
+    """Test Agent.kickoff() with planning explicitly disabled via planning=False."""
+    llm = LLM("gpt-4o-mini")
 
     agent = Agent(
-        role="Test Agent",
-        goal="To test the reasoning feature",
-        backstory="I am a test agent created to verify the reasoning feature works correctly.",
+        role="Math Assistant",
+        goal="Help solve math problems",
+        backstory="A helpful assistant",
         llm=llm,
-        reasoning=True,
+        planning=False,  # Explicitly disable planning
+        verbose=False,
     )
 
-    task = Task(
-        description="Task that will cause an error",
-        expected_output="Output that will never be generated",
-        agent=agent,
-    )
+    result = agent.kickoff("What is 100 / 4?")
 
-    call_count = [0]
-
-    def mock_llm_call_error(*args, **kwargs):
-        call_count[0] += 1
-        if call_count[0] <= 2:  # First calls are for reasoning
-            raise Exception("LLM error during reasoning")
-        return "Fallback execution result"  # Return a value for task execution
-
-    agent.llm.call = mock_llm_call_error
-
-    result = agent.execute_task(task)
-
-    assert result == "Fallback execution result"
-    assert call_count[0] > 2  # Ensure we called the mock multiple times
+    assert result is not None
+    assert "25" in str(result)
 
 
-@pytest.mark.skip(reason="Test requires updates for native tool calling changes")
-def test_agent_with_function_calling():
-    """Test agent with reasoning using function calling."""
-    llm = LLM("gpt-3.5-turbo")
+@pytest.mark.vcr()
+def test_agent_kickoff_multi_step_task_with_planning():
+    """Test Agent.kickoff() with a multi-step task that benefits from planning."""
+    llm = LLM("gpt-4o-mini")
 
     agent = Agent(
-        role="Test Agent",
-        goal="To test the reasoning feature",
-        backstory="I am a test agent created to verify the reasoning feature works correctly.",
+        role="Math Tutor",
+        goal="Solve multi-step math problems",
+        backstory="An expert tutor who explains step by step",
         llm=llm,
-        reasoning=True,
-        verbose=True,
+        planning_config=PlanningConfig(max_attempts=1, max_steps=5),
+        verbose=False,
     )
 
-    task = Task(
-        description="Simple math task: What's 2+2?",
-        expected_output="The answer should be a number.",
-        agent=agent,
+    # Task requires: find primes, sum them, then double
+    result = agent.kickoff(
+        "Find the first 3 prime numbers, add them together, then multiply by 2."
     )
 
-    agent.llm.supports_function_calling = lambda: True
-
-    def mock_function_call(messages, *args, **kwargs):
-        if "tools" in kwargs:
-            return json.dumps(
-                {"plan": "I'll solve this simple math problem: 2+2=4.", "ready": True}
-            )
-        return "4"
-
-    agent.llm.call = mock_function_call
-
-    result = agent.execute_task(task)
-
-    assert result == "4"
-    assert "Reasoning Plan:" in task.description
-    assert "I'll solve this simple math problem: 2+2=4." in task.description
+    assert result is not None
+    # First 3 primes: 2, 3, 5 -> sum = 10 -> doubled = 20
+    assert "20" in str(result)
 
 
-@pytest.mark.skip(reason="Test requires updates for native tool calling changes")
-def test_agent_with_function_calling_fallback():
-    """Test agent with reasoning using function calling that falls back to text parsing."""
-    llm = LLM("gpt-3.5-turbo")
+# =============================================================================
+# Tests for Agent.execute_task() with planning (uses CrewAgentExecutor)
+# These test the legacy path via handle_reasoning()
+# =============================================================================
+
+
+@pytest.mark.vcr()
+def test_agent_execute_task_with_planning():
+    """Test Agent.execute_task() with planning via CrewAgentExecutor."""
+    llm = LLM("gpt-4o-mini")
 
     agent = Agent(
-        role="Test Agent",
-        goal="To test the reasoning feature",
-        backstory="I am a test agent created to verify the reasoning feature works correctly.",
+        role="Math Assistant",
+        goal="Help solve math problems",
+        backstory="A helpful math tutor",
         llm=llm,
-        reasoning=True,
-        verbose=True,
+        planning_config=PlanningConfig(max_attempts=1),
+        verbose=False,
     )
 
     task = Task(
-        description="Simple math task: What's 2+2?",
-        expected_output="The answer should be a number.",
+        description="What is 9 + 11?",
+        expected_output="A number",
         agent=agent,
     )
 
-    agent.llm.supports_function_calling = lambda: True
+    result = agent.execute_task(task)
 
-    def mock_function_call(messages, *args, **kwargs):
-        if "tools" in kwargs:
-            return "Invalid JSON that will trigger fallback. READY: I am ready to execute the task."
-        return "4"
+    assert result is not None
+    assert "20" in str(result)
+    # Planning should be appended to task description
+    assert "Planning:" in task.description
 
-    agent.llm.call = mock_function_call
+
+@pytest.mark.vcr()
+def test_agent_execute_task_without_planning():
+    """Test Agent.execute_task() without planning."""
+    llm = LLM("gpt-4o-mini")
+
+    agent = Agent(
+        role="Math Assistant",
+        goal="Help solve math problems",
+        backstory="A helpful assistant",
+        llm=llm,
+        verbose=False,
+    )
+
+    task = Task(
+        description="What is 12 * 3?",
+        expected_output="A number",
+        agent=agent,
+    )
 
     result = agent.execute_task(task)
 
-    assert result == "4"
-    assert "Reasoning Plan:" in task.description
-    assert "Invalid JSON that will trigger fallback" in task.description
+    assert result is not None
+    assert "36" in str(result)
+    # No planning should be added
+    assert "Planning:" not in task.description
+
+
+@pytest.mark.vcr()
+def test_agent_execute_task_with_planning_refine():
+    """Test Agent.execute_task() with planning that requires refinement."""
+    llm = LLM("gpt-4o-mini")
+
+    agent = Agent(
+        role="Math Tutor",
+        goal="Solve complex math problems step by step",
+        backstory="An expert tutor",
+        llm=llm,
+        planning_config=PlanningConfig(max_attempts=2),
+        verbose=False,
+    )
+
+    task = Task(
+        description="Calculate the area of a circle with radius 5 (use pi = 3.14)",
+        expected_output="The area as a number",
+        agent=agent,
+    )
+
+    result = agent.execute_task(task)
+
+    assert result is not None
+    # Area = pi * r^2 = 3.14 * 25 = 78.5
+    assert "78" in str(result) or "79" in str(result)
+    assert "Planning:" in task.description

lib/crewai/tests/agents/test_lite_agent.py

@@ -659,7 +659,7 @@ def test_agent_kickoff_with_platform_tools(mock_get, mock_post):
 
 
 @patch.dict("os.environ", {"EXA_API_KEY": "test_exa_key"})
-@patch("crewai.agent.Agent.get_mcp_tools")
+@patch("crewai.agent.Agent._get_external_mcp_tools")
 @pytest.mark.vcr()
 def test_agent_kickoff_with_mcp_tools(mock_get_mcp_tools):
     """Test that Agent.kickoff() properly integrates MCP tools with LiteAgent"""
@@ -691,7 +691,7 @@ def test_agent_kickoff_with_mcp_tools(mock_get_mcp_tools):
     assert result.raw is not None
 
     # Verify MCP tools were retrieved
-    mock_get_mcp_tools.assert_called_once_with(["https://mcp.exa.ai/mcp?api_key=test_exa_key&profile=research"])
+    mock_get_mcp_tools.assert_called_once_with("https://mcp.exa.ai/mcp?api_key=test_exa_key&profile=research")
 
 
 # ============================================================================
@@ -1136,7 +1136,6 @@ def test_lite_agent_memory_instance_recall_and_save_called():
         successful_requests=1,
     )
     mock_memory = Mock()
-    mock_memory._read_only = False
     mock_memory.recall.return_value = []
     mock_memory.extract_memories.return_value = ["Fact one.", "Fact two."]
 

lib/crewai/tests/agents/test_native_tool_calling.py

@@ -11,7 +11,7 @@ import os
 import threading
 import time
 from collections import Counter
-from unittest.mock import Mock, patch
+from unittest.mock import patch
 
 import pytest
 from pydantic import BaseModel, Field
@@ -1129,150 +1129,3 @@ class TestMaxUsageCountWithNativeToolCalling:
         # Verify the requested calls occurred while keeping usage bounded.
         assert tool.current_usage_count >= 2
         assert tool.current_usage_count <= tool.max_usage_count
-
-
-# =============================================================================
-# JSON Parse Error Handling Tests
-# =============================================================================
-
-
-class TestNativeToolCallingJsonParseError:
-    """Tests that malformed JSON tool arguments produce clear errors
-    instead of silently dropping all arguments."""
-
-    def _make_executor(self, tools: list[BaseTool]) -> "CrewAgentExecutor":
-        """Create a minimal CrewAgentExecutor with mocked dependencies."""
-        from crewai.agents.crew_agent_executor import CrewAgentExecutor
-        from crewai.tools.base_tool import to_langchain
-
-        structured_tools = to_langchain(tools)
-        mock_agent = Mock()
-        mock_agent.key = "test_agent"
-        mock_agent.role = "tester"
-        mock_agent.verbose = False
-        mock_agent.fingerprint = None
-        mock_agent.tools_results = []
-
-        mock_task = Mock()
-        mock_task.name = "test"
-        mock_task.description = "test"
-        mock_task.id = "test-id"
-
-        executor = object.__new__(CrewAgentExecutor)
-        executor.agent = mock_agent
-        executor.task = mock_task
-        executor.crew = Mock()
-        executor.tools = structured_tools
-        executor.original_tools = tools
-        executor.tools_handler = None
-        executor._printer = Mock()
-        executor.messages = []
-
-        return executor
-
-    def test_malformed_json_returns_parse_error(self) -> None:
-        """Malformed JSON args must return a descriptive error, not silently become {}."""
-
-        class CodeTool(BaseTool):
-            name: str = "execute_code"
-            description: str = "Run code"
-
-            def _run(self, code: str) -> str:
-                return f"ran: {code}"
-
-        tool = CodeTool()
-        executor = self._make_executor([tool])
-
-        from crewai.utilities.agent_utils import convert_tools_to_openai_schema
-        _, available_functions = convert_tools_to_openai_schema([tool])
-
-        malformed_json = '{"code": "print("hello")"}'
-
-        result = executor._execute_single_native_tool_call(
-            call_id="call_123",
-            func_name="execute_code",
-            func_args=malformed_json,
-            available_functions=available_functions,
-        )
-
-        assert "Failed to parse tool arguments as JSON" in result["result"]
-        assert tool.current_usage_count == 0
-
-    def test_valid_json_still_executes_normally(self) -> None:
-        """Valid JSON args should execute the tool as before."""
-
-        class CodeTool(BaseTool):
-            name: str = "execute_code"
-            description: str = "Run code"
-
-            def _run(self, code: str) -> str:
-                return f"ran: {code}"
-
-        tool = CodeTool()
-        executor = self._make_executor([tool])
-
-        from crewai.utilities.agent_utils import convert_tools_to_openai_schema
-        _, available_functions = convert_tools_to_openai_schema([tool])
-
-        valid_json = '{"code": "print(1)"}'
-
-        result = executor._execute_single_native_tool_call(
-            call_id="call_456",
-            func_name="execute_code",
-            func_args=valid_json,
-            available_functions=available_functions,
-        )
-
-        assert result["result"] == "ran: print(1)"
-
-    def test_dict_args_bypass_json_parsing(self) -> None:
-        """When func_args is already a dict, no JSON parsing occurs."""
-
-        class CodeTool(BaseTool):
-            name: str = "execute_code"
-            description: str = "Run code"
-
-            def _run(self, code: str) -> str:
-                return f"ran: {code}"
-
-        tool = CodeTool()
-        executor = self._make_executor([tool])
-
-        from crewai.utilities.agent_utils import convert_tools_to_openai_schema
-        _, available_functions = convert_tools_to_openai_schema([tool])
-
-        result = executor._execute_single_native_tool_call(
-            call_id="call_789",
-            func_name="execute_code",
-            func_args={"code": "x = 42"},
-            available_functions=available_functions,
-        )
-
-        assert result["result"] == "ran: x = 42"
-
-    def test_schema_validation_catches_missing_args_on_native_path(self) -> None:
-        """The native function calling path should now enforce args_schema,
-        catching missing required fields before _run is called."""
-
-        class StrictTool(BaseTool):
-            name: str = "strict_tool"
-            description: str = "A tool with required args"
-
-            def _run(self, code: str, language: str) -> str:
-                return f"{language}: {code}"
-
-        tool = StrictTool()
-        executor = self._make_executor([tool])
-
-        from crewai.utilities.agent_utils import convert_tools_to_openai_schema
-        _, available_functions = convert_tools_to_openai_schema([tool])
-
-        result = executor._execute_single_native_tool_call(
-            call_id="call_schema",
-            func_name="strict_tool",
-            func_args={"code": "print(1)"},
-            available_functions=available_functions,
-        )
-
-        assert "Error" in result["result"]
-        assert "validation failed" in result["result"].lower() or "missing" in result["result"].lower()

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_agent_kickoff_with_planning_stores_plan_in_state.yaml

@@ -0,0 +1,234 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
+      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
+      a focused execution plan for the following task:\n\n## Task\nWhat is 2 + 2?\n\n##
+      Expected Output\nComplete the task successfully\n\n## Available Tools\nNo tools
+      available\n\n## Instructions\nCreate ONLY the essential steps needed to complete
+      this task. Use the MINIMUM number of steps required - do NOT pad your plan with
+      unnecessary steps. Most tasks need only 2-5 steps.\n\nFor each step:\n- State
+      the specific action to take\n- Specify which tool to use (if any)\n\nDo NOT
+      include:\n- Setup or preparation steps that are obvious\n- Verification steps
+      unless critical\n- Documentation or cleanup steps unless explicitly required\n-
+      Generic steps like \"review results\" or \"finalize output\"\n\nAfter your plan,
+      state:\n- \"READY: I am ready to execute the task.\" if the plan is complete\n-
+      \"NOT READY: I need to refine my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
+      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
+      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
+      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1541'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTTAh68P65LybtqkwNI3p2HXcRv\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078147,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. **Action:**
+        Perform the addition operation.  \\n   **Tool:** None (manually calculate).\\n\\n2.
+        **Action:** State the result.  \\n   **Tool:** None (manually output).\\n\\nREADY:
+        I am ready to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 281,\n    \"completion_tokens\":
+        56,\n    \"total_tokens\": 337,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:28 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '1165'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      assistant that solves math problems step by step\nYour personal goal is: Help
+      solve simple math problems"},{"role":"user","content":"\nCurrent Task: What
+      is 2 + 2?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '299'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTVB9mdtq1YZrUVf1aSb6dVVQ8G\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078149,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"To solve the problem of 2 + 2, we simply
+        perform the addition:\\n\\n1. Start with the first number: 2\\n2. Add the
+        second number: + 2\\n3. Combine the two: 2 + 2 = 4\\n\\nTherefore, the answer
+        is 4.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n
+        \     \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n
+        \ \"usage\": {\n    \"prompt_tokens\": 54,\n    \"completion_tokens\": 62,\n
+        \   \"total_tokens\": 116,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:30 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '1300'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_agent_kickoff_without_planning_skips_plan_generation.yaml

@@ -0,0 +1,108 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      assistant\nYour personal goal is: Help solve simple math problems"},{"role":"user","content":"\nCurrent
+      Task: What is 3 + 3?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '260'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTTFxQ75llVmJv0ee902FIjXE8p\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078147,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"3 + 3 equals 6.\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        47,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 55,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:27 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '401'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_executor_state_contains_plan_after_planning.yaml

@@ -0,0 +1,230 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
+      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
+      a focused execution plan for the following task:\n\n## Task\nWhat is 7 + 7?\n\n##
+      Expected Output\nComplete the task successfully\n\n## Available Tools\nNo tools
+      available\n\n## Instructions\nCreate ONLY the essential steps needed to complete
+      this task. Use the MINIMUM number of steps required - do NOT pad your plan with
+      unnecessary steps. Most tasks need only 2-5 steps.\n\nFor each step:\n- State
+      the specific action to take\n- Specify which tool to use (if any)\n\nDo NOT
+      include:\n- Setup or preparation steps that are obvious\n- Verification steps
+      unless critical\n- Documentation or cleanup steps unless explicitly required\n-
+      Generic steps like \"review results\" or \"finalize output\"\n\nAfter your plan,
+      state:\n- \"READY: I am ready to execute the task.\" if the plan is complete\n-
+      \"NOT READY: I need to refine my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
+      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
+      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
+      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1541'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTdqlxwWowSdLncBERFrCgxTvVj\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078157,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. Calculate
+        the sum of 7 and 7.\\n   \\nREADY: I am ready to execute the task.\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        281,\n    \"completion_tokens\": 28,\n    \"total_tokens\": 309,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:38 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '709'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      assistant that solves math problems step by step\nYour personal goal is: Help
+      solve simple math problems"},{"role":"user","content":"\nCurrent Task: What
+      is 7 + 7?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '299'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTeB6Miecallw9SjSfLAXPjX2XD\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078158,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"To find the sum of 7 and 7, you simply
+        add the two numbers together:\\n\\n7 + 7 = 14\\n\\nSo, the answer is 14.\",\n
+        \       \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\":
+        null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        54,\n    \"completion_tokens\": 35,\n    \"total_tokens\": 89,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:38 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '733'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_planning_config_disabled_skips_planning.yaml

@@ -0,0 +1,108 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      assistant\nYour personal goal is: Help solve simple math problems"},{"role":"user","content":"\nCurrent
+      Task: What is 5 + 5?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '260'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTf8T2iADffpPCJBZhntLlaoaSy\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078159,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"5 + 5 equals 10.\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        47,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 55,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:40 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '515'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_planning_creates_minimal_steps_for_multi_step_task.yaml

@@ -0,0 +1,247 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
+      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
+      a focused execution plan for the following task:\n\n## Task\nCalculate the sum
+      of the first 3 prime numbers, then multiply that result by 2. Show your work
+      for each step.\n\n## Expected Output\nComplete the task successfully\n\n## Available
+      Tools\nNo tools available\n\n## Instructions\nCreate ONLY the essential steps
+      needed to complete this task. Use the MINIMUM number of steps required - do
+      NOT pad your plan with unnecessary steps. Most tasks need only 2-5 steps.\n\nFor
+      each step:\n- State the specific action to take\n- Specify which tool to use
+      (if any)\n\nDo NOT include:\n- Setup or preparation steps that are obvious\n-
+      Verification steps unless critical\n- Documentation or cleanup steps unless
+      explicitly required\n- Generic steps like \"review results\" or \"finalize output\"\n\nAfter
+      your plan, state:\n- \"READY: I am ready to execute the task.\" if the plan
+      is complete\n- \"NOT READY: I need to refine my plan because [reason].\" if
+      you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
+      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
+      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
+      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1636'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTWa7FxCHkHwHF25AYXXeJDBOuY\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078150,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. Identify
+        the first 3 prime numbers: 2, 3, and 5.\\n2. Calculate the sum: \\\\(2 + 3
+        + 5 = 10\\\\).\\n3. Multiply the sum by 2: \\\\(10 \\\\times 2 = 20\\\\).\\n\\nREADY:
+        I am ready to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 299,\n    \"completion_tokens\":
+        74,\n    \"total_tokens\": 373,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:32 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '1716'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Tutor. An expert
+      math tutor who breaks down problems step by step\nYour personal goal is: Solve
+      multi-step math problems accurately"},{"role":"user","content":"\nCurrent Task:
+      Calculate the sum of the first 3 prime numbers, then multiply that result by
+      2. Show your work for each step.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '400'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTYJgCZf2oY7wiPMZmN4QEQhHb5\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078152,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"To solve the problem, let's break it
+        down into two main steps: \\n\\n1. Calculate the sum of the first 3 prime
+        numbers.\\n2. Multiply the result of that sum by 2.\\n\\n### Step 1: Identify
+        the first 3 prime numbers\\nPrime numbers are natural numbers greater than
+        1 that have no positive divisors other than 1 and themselves. \\n\\nThe first
+        three prime numbers are:\\n- 2\\n- 3\\n- 5\\n\\n### Step 2: Calculate the
+        sum of the first 3 prime numbers\\nNow, we add these prime numbers together:\\n\\n\\\\[\\n2
+        + 3 + 5\\n\\\\]\\n\\nCalculating this step-by-step:\\n- First, add 2 and 3:\\n
+        \ \\\\[\\n  2 + 3 = 5\\n  \\\\]\\n  \\n- Next, add this result to 5:\\n  \\\\[\\n
+        \ 5 + 5 = 10\\n  \\\\]\\n\\nSo, the sum of the first 3 prime numbers is \\\\(10\\\\).\\n\\n###
+        Step 3: Multiply the sum by 2\\nNext, we take the sum we calculated and multiply
+        it by 2:\\n\\n\\\\[\\n10 \\\\times 2\\n\\\\]\\n\\nCalculating this:\\n\\\\[\\n10
+        \\\\times 2 = 20\\n\\\\]\\n\\n### Final Answer\\nThus, the final result obtained
+        after performing all the steps is:\\n\\n\\\\[\\n\\\\boxed{20}\\n\\\\]\",\n
+        \       \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\":
+        null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        74,\n    \"completion_tokens\": 288,\n    \"total_tokens\": 362,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:37 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '4751'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_planning_disabled_skips_planning.yaml

@@ -0,0 +1,108 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      assistant\nYour personal goal is: Help solve simple math problems"},{"role":"user","content":"\nCurrent
+      Task: What is 5 + 5?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '260'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yXGD5IrieoUDSK5hDmJyA2gJtDc\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078382,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"5 + 5 equals 10.\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        47,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 55,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:26:23 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '363'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/TestAgentExecutorPlanning.test_planning_handles_sequential_dependency_task.yaml

@@ -0,0 +1,242 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
+      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
+      a focused execution plan for the following task:\n\n## Task\nConvert 100 degrees
+      Celsius to Fahrenheit, then round the result to the nearest 10.\n\n## Expected
+      Output\nComplete the task successfully\n\n## Available Tools\nNo tools available\n\n##
+      Instructions\nCreate ONLY the essential steps needed to complete this task.
+      Use the MINIMUM number of steps required - do NOT pad your plan with unnecessary
+      steps. Most tasks need only 2-5 steps.\n\nFor each step:\n- State the specific
+      action to take\n- Specify which tool to use (if any)\n\nDo NOT include:\n- Setup
+      or preparation steps that are obvious\n- Verification steps unless critical\n-
+      Documentation or cleanup steps unless explicitly required\n- Generic steps like
+      \"review results\" or \"finalize output\"\n\nAfter your plan, state:\n- \"READY:
+      I am ready to execute the task.\" if the plan is complete\n- \"NOT READY: I
+      need to refine my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
+      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
+      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
+      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1610'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTN8fHOefyzzhvdUOHjxdFDR2HW\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078141,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. Convert 100
+        degrees Celsius to Fahrenheit using the formula: \\\\( F = C \\\\times \\\\frac{9}{5}
+        + 32 \\\\).\\n2. Round the Fahrenheit result to the nearest 10.\\n\\nREADY:
+        I am ready to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 291,\n    \"completion_tokens\":
+        58,\n    \"total_tokens\": 349,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:22 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '1089'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Unit Converter. A precise
+      unit conversion specialist\nYour personal goal is: Accurately convert between
+      units and apply transformations"},{"role":"user","content":"\nCurrent Task:
+      Convert 100 degrees Celsius to Fahrenheit, then round the result to the nearest
+      10.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '373'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTPQewXDyPdYHI4dHPH7YGHcRge\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078143,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"To convert degrees Celsius to Fahrenheit,
+        you can use the formula:\\n\\n\\\\[ F = \\\\left( C \\\\times \\\\frac{9}{5}
+        \\\\right) + 32 \\\\]\\n\\nPlugging in 100 degrees Celsius:\\n\\n\\\\[ F =
+        \\\\left( 100 \\\\times \\\\frac{9}{5} \\\\right) + 32 \\\\]\\n\\nCalculating
+        that step-by-step:\\n\\n1. Multiply 100 by 9: \\n   \\\\[ 100 \\\\times 9
+        = 900 \\\\]\\n\\n2. Divide by 5:\\n   \\\\[ 900 \\\\div 5 = 180 \\\\]\\n\\n3.
+        Add 32:\\n   \\\\[ 180 + 32 = 212 \\\\]\\n\\nSo, 100 degrees Celsius is equal
+        to 212 degrees Fahrenheit.\\n\\nNow, rounding 212 to the nearest 10:\\n\\nThe
+        nearest multiple of 10 to 212 is 210.\\n\\nTherefore, the final result is
+        **210 degrees Fahrenheit**.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 63,\n    \"completion_tokens\":
+        191,\n    \"total_tokens\": 254,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:26 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '3736'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/test_agent_execute_task_basic.yaml

@@ -1,6 +1,10 @@
 interactions:
 - request:
-    body: '{"messages":[{"role":"system","content":"You are test role. 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: Calculate 2 + 2\n\nThis is the expected criteria for your final answer: The result of the calculation\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"}'
+    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
+      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Calculate
+      2 + 2\n\nThis is the expected criteria for your final answer: The result of
+      the calculation\nyou MUST return the actual complete content as the final answer,
+      not a summary.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -13,7 +17,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '797'
+      - '396'
       content-type:
       - application/json
       host:
@@ -35,13 +39,23 @@ interactions:
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.12.10
+      - 3.13.3
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-CjDsYJQa2tIYBbNloukSWecpsTvdK\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764894146,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"I now can give a great answer  \\nFinal Answer: The result of the calculation 2 + 2 is 4.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 161,\n    \"completion_tokens\": 25,\n    \"total_tokens\": 186,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": \"fp_11f3029f6b\"\
-        \n}\n"
+      string: "{\n  \"id\": \"chatcmpl-D5DTjYe6n92Rjo4Ox6NiZpAAdBLF0\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770135823,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"The result of the calculation 2 + 2
+        is 4.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n
+        \     \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n
+        \ \"usage\": {\n    \"prompt_tokens\": 75,\n    \"completion_tokens\": 14,\n
+        \   \"total_tokens\": 89,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -50,7 +64,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Fri, 05 Dec 2025 00:22:27 GMT
+      - Tue, 03 Feb 2026 16:23:43 GMT
       Server:
       - cloudflare
       Set-Cookie:
@@ -70,13 +84,11 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '516'
+      - '636'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
-      x-envoy-upstream-service-time:
-      - '529'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_context.yaml

@@ -1,6 +1,12 @@
 interactions:
 - request:
-    body: '{"messages":[{"role":"system","content":"You are test role. 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: Summarize the given context in one sentence\n\nThis is the expected criteria for your final answer: A one-sentence summary\nyou MUST return the actual complete content as the final answer, not a summary.\n\nThis is the context you''re working with:\nThe quick brown fox jumps over the lazy dog. This sentence contains every letter of the alphabet.\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-3.5-turbo"}'
+    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
+      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Summarize
+      the given context in one sentence\n\nThis is the expected criteria for your
+      final answer: A one-sentence summary\nyou MUST return the actual complete content
+      as the final answer, not a summary.\n\nThis is the context you''re working with:\nThe
+      quick brown fox jumps over the lazy dog. This sentence contains every letter
+      of the alphabet.\n\nProvide your complete response:"}],"model":"gpt-3.5-turbo"}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -13,7 +19,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '963'
+      - '562'
       content-type:
       - application/json
       host:
@@ -35,13 +41,23 @@ interactions:
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.12.10
+      - 3.13.3
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-CjDtsaX0LJ0dzZz02KwKeRGYgazv1\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764894228,\n  \"model\": \"gpt-3.5-turbo-0125\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"I now can give a great answer\\n\\nFinal Answer: The quick brown fox jumps over the lazy dog. This sentence contains every letter of the alphabet.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 191,\n    \"completion_tokens\": 30,\n    \"total_tokens\": 221,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\"\
-        : \"default\",\n  \"system_fingerprint\": null\n}\n"
+      string: "{\n  \"id\": \"chatcmpl-D5DTn6yIQ7HpIn5j5Bsbag1efzXPa\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770135827,\n  \"model\": \"gpt-3.5-turbo-0125\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"The quick brown fox jumps over the
+        lazy dog. This sentence contains every letter of the alphabet.\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        105,\n    \"completion_tokens\": 19,\n    \"total_tokens\": 124,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": null\n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -50,7 +66,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Fri, 05 Dec 2025 00:23:49 GMT
+      - Tue, 03 Feb 2026 16:23:48 GMT
       Server:
       - cloudflare
       Set-Cookie:
@@ -70,13 +86,11 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '506'
+      - '606'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
-      x-envoy-upstream-service-time:
-      - '559'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_custom_llm.yaml

@@ -1,6 +1,10 @@
 interactions:
 - request:
-    body: '{"messages":[{"role":"system","content":"You are test role. 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: Write a haiku about AI\n\nThis is the expected criteria for your final answer: A haiku (3 lines, 5-7-5 syllable pattern) about AI\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-3.5-turbo","max_tokens":50,"temperature":0.7}'
+    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
+      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Write
+      a haiku about AI\n\nThis is the expected criteria for your final answer: A haiku
+      (3 lines, 5-7-5 syllable pattern) about AI\nyou MUST return the actual complete
+      content as the final answer, not a summary.\n\nProvide your complete response:"}],"model":"gpt-3.5-turbo","max_tokens":50,"temperature":0.7}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -13,7 +17,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '861'
+      - '460'
       content-type:
       - application/json
       host:
@@ -35,13 +39,23 @@ interactions:
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.12.10
+      - 3.13.3
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-CjDqr2BmEXQ08QzZKslTZJZ5vV9lo\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764894041,\n  \"model\": \"gpt-3.5-turbo-0125\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"I now can give a great answer\\n\\nFinal Answer:  \\nIn circuits they thrive,  \\nArtificial minds awake,  \\nFuture's coded drive.\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 174,\n    \"completion_tokens\": 29,\n    \"total_tokens\": 203,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\"\
-        ,\n  \"system_fingerprint\": null\n}\n"
+      string: "{\n  \"id\": \"chatcmpl-D5DTgAqxaC8RmEvikXK0UDaxmVmf9\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770135820,\n  \"model\": \"gpt-3.5-turbo-0125\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"Artificial minds,\\nCode and circuits
+        intertwine,\\nFuture undefined.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 88,\n    \"completion_tokens\":
+        13,\n    \"total_tokens\": 101,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": null\n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -50,7 +64,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Fri, 05 Dec 2025 00:20:41 GMT
+      - Tue, 03 Feb 2026 16:23:40 GMT
       Server:
       - cloudflare
       Set-Cookie:
@@ -70,13 +84,11 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '434'
+      - '277'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
-      x-envoy-upstream-service-time:
-      - '456'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_planning.yaml

@@ -0,0 +1,231 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
+      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
+      a focused execution plan for the following task:\n\n## Task\nWhat is 9 + 11?\n\n##
+      Expected Output\nA number\n\n## Available Tools\nNo tools available\n\n## Instructions\nCreate
+      ONLY the essential steps needed to complete this task. Use the MINIMUM number
+      of steps required - do NOT pad your plan with unnecessary steps. Most tasks
+      need only 2-5 steps.\n\nFor each step:\n- State the specific action to take\n-
+      Specify which tool to use (if any)\n\nDo NOT include:\n- Setup or preparation
+      steps that are obvious\n- Verification steps unless critical\n- Documentation
+      or cleanup steps unless explicitly required\n- Generic steps like \"review results\"
+      or \"finalize output\"\n\nAfter your plan, state:\n- \"READY: I am ready to
+      execute the task.\" if the plan is complete\n- \"NOT READY: I need to refine
+      my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
+      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
+      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
+      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1520'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yVACNTzZcghQRwt5kFYQ4HAvbgI\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078252,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"## Execution Plan\\n1. Calculate the
+        sum of 9 and 11.\\n   \\nREADY: I am ready to execute the task.\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        279,\n    \"completion_tokens\": 28,\n    \"total_tokens\": 307,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:24:13 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '951'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      math tutor\nYour personal goal is: Help solve math problems"},{"role":"user","content":"\nCurrent
+      Task: What is 9 + 11?\n\nPlanning:\n## Execution Plan\n1. Calculate the sum
+      of 9 and 11.\n   \nREADY: I am ready to execute the task.\n\nThis is the expected
+      criteria for your final answer: A number\nyou MUST return the actual complete
+      content as the final answer, not a summary.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '513'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yVBdTCKSdfcJYlIOX9BbzrObgFI\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078253,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"9 + 11 = 20\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        105,\n    \"completion_tokens\": 7,\n    \"total_tokens\": 112,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:24:13 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '477'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_planning_refine.yaml

@@ -0,0 +1,243 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
+      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
+      a focused execution plan for the following task:\n\n## Task\nCalculate the area
+      of a circle with radius 5 (use pi = 3.14)\n\n## Expected Output\nThe area as
+      a number\n\n## Available Tools\nNo tools available\n\n## Instructions\nCreate
+      ONLY the essential steps needed to complete this task. Use the MINIMUM number
+      of steps required - do NOT pad your plan with unnecessary steps. Most tasks
+      need only 2-5 steps.\n\nFor each step:\n- State the specific action to take\n-
+      Specify which tool to use (if any)\n\nDo NOT include:\n- Setup or preparation
+      steps that are obvious\n- Verification steps unless critical\n- Documentation
+      or cleanup steps unless explicitly required\n- Generic steps like \"review results\"
+      or \"finalize output\"\n\nAfter your plan, state:\n- \"READY: I am ready to
+      execute the task.\" if the plan is complete\n- \"NOT READY: I need to refine
+      my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
+      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
+      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
+      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1577'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yVCdA1csIzfoHSQvxkfrA4gDn4z\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078254,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"## Execution Plan\\n1. Multiply the
+        radius (5) by itself (5) to get the square of the radius.\\n2. Multiply the
+        squared radius by pi (3.14) to calculate the area.\\n\\nREADY: I am ready
+        to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 293,\n    \"completion_tokens\":
+        54,\n    \"total_tokens\": 347,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:24:15 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '845'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Tutor. An expert
+      tutor\nYour personal goal is: Solve complex math problems step by step"},{"role":"user","content":"\nCurrent
+      Task: Calculate the area of a circle with radius 5 (use pi = 3.14)\n\nPlanning:\n##
+      Execution Plan\n1. Multiply the radius (5) by itself (5) to get the square of
+      the radius.\n2. Multiply the squared radius by pi (3.14) to calculate the area.\n\nREADY:
+      I am ready to execute the task.\n\nThis is the expected criteria for your final
+      answer: The area as a number\nyou MUST return the actual complete content as
+      the final answer, not a summary.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '682'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yVDh2U2xx3qeYHcDQvbetOmVCxb\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078255,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"To calculate the area of a circle with
+        a radius of 5, we will follow the steps outlined in the execution plan.\\n\\n1.
+        **Square the radius**:\\n   \\\\[\\n   5 \\\\times 5 = 25\\n   \\\\]\\n\\n2.
+        **Multiply the squared radius by pi (using \\\\(\\\\pi \\\\approx 3.14\\\\))**:\\n
+        \  \\\\[\\n   \\\\text{Area} = \\\\pi \\\\times (\\\\text{radius})^2 = 3.14
+        \\\\times 25\\n   \\\\]\\n\\n   Now, let's perform the multiplication:\\n
+        \  \\\\[\\n   3.14 \\\\times 25 = 78.5\\n   \\\\]\\n\\nThus, the area of the
+        circle is \\\\( \\\\boxed{78.5} \\\\).\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 147,\n    \"completion_tokens\":
+        155,\n    \"total_tokens\": 302,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:24:18 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '2228'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/test_agent_execute_task_with_tool.yaml

@@ -1,7 +1,11 @@
 interactions:
 - request:
-    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour personal goal is: test goal\nYou ONLY have access to the following tools, and should NEVER make up tools that are not listed here:\n\nTool Name: dummy_tool\nTool Arguments: {''query'': {''description'': None, ''type'': ''str''}}\nTool Description: Useful for when you need to get a dummy result for a query.\n\nIMPORTANT: Use the following format in your response:\n\n```\nThought: you should always think about what to do\nAction: the action to take, only one name of [dummy_tool], just the name, exactly as it''s written.\nAction Input: the input to the action, just a simple JSON object, enclosed in curly braces, using \" to wrap keys and values.\nObservation: the result of the action\n```\n\nOnce all necessary information is gathered, return the following format:\n\n```\nThought: I now know the final answer\nFinal Answer: the final answer to the original input question\n```"},{"role":"user","content":"\nCurrent
-      Task: Use the dummy tool to get a result for ''test query''\n\nThis is the expected criteria for your final answer: The result from the dummy tool\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-3.5-turbo"}'
+    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
+      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Use
+      the dummy tool to get a result for ''test query''\n\nThis is the expected criteria
+      for your final answer: The result from the dummy tool\nyou MUST return the actual
+      complete content as the final answer, not a summary."}],"model":"gpt-3.5-turbo","tool_choice":"auto","tools":[{"type":"function","function":{"name":"dummy_tool","description":"Useful
+      for when you need to get a dummy result for a query.","strict":true,"parameters":{"properties":{"query":{"title":"Query","type":"string"}},"required":["query"],"type":"object","additionalProperties":false}}}]}'
     headers:
       User-Agent:
       - X-USER-AGENT-XXX
@@ -14,7 +18,7 @@ interactions:
       connection:
       - keep-alive
       content-length:
-      - '1381'
+      - '712'
       content-type:
       - application/json
       host:
@@ -36,12 +40,26 @@ interactions:
       x-stainless-runtime:
       - CPython
       x-stainless-runtime-version:
-      - 3.12.10
+      - 3.13.3
     method: POST
     uri: https://api.openai.com/v1/chat/completions
   response:
     body:
-      string: "{\n  \"id\": \"chatcmpl-CjDrE1Z8bFQjjxI2vDPPKgtOTm28p\",\n  \"object\": \"chat.completion\",\n  \"created\": 1764894064,\n  \"model\": \"gpt-3.5-turbo-0125\",\n  \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\": \"assistant\",\n        \"content\": \"you should always think about what to do\",\n        \"refusal\": null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 289,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 297,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\": {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\": 0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\": \"default\",\n  \"system_fingerprint\": null\n}\n"
+      string: "{\n  \"id\": \"chatcmpl-D5DTlUmKYee1DaS5AqnaUCZ6B14xV\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770135825,\n  \"model\": \"gpt-3.5-turbo-0125\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": null,\n        \"tool_calls\": [\n          {\n
+        \           \"id\": \"call_tBCgelchfQjXXJrrM15MxqGJ\",\n            \"type\":
+        \"function\",\n            \"function\": {\n              \"name\": \"dummy_tool\",\n
+        \             \"arguments\": \"{\\\"query\\\":\\\"test query\\\"}\"\n            }\n
+        \         }\n        ],\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"tool_calls\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 122,\n    \"completion_tokens\":
+        16,\n    \"total_tokens\": 138,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": null\n}\n"
     headers:
       CF-RAY:
       - CF-RAY-XXX
@@ -50,7 +68,7 @@ interactions:
       Content-Type:
       - application/json
       Date:
-      - Fri, 05 Dec 2025 00:21:05 GMT
+      - Tue, 03 Feb 2026 16:23:46 GMT
       Server:
       - cloudflare
       Set-Cookie:
@@ -70,13 +88,124 @@ interactions:
       openai-organization:
       - OPENAI-ORG-XXX
       openai-processing-ms:
-      - '379'
+      - '694'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are test role. test backstory\nYour
+      personal goal is: test goal"},{"role":"user","content":"\nCurrent Task: Use
+      the dummy tool to get a result for ''test query''\n\nThis is the expected criteria
+      for your final answer: The result from the dummy tool\nyou MUST return the actual
+      complete content as the final answer, not a summary."},{"role":"assistant","content":null,"tool_calls":[{"id":"call_tBCgelchfQjXXJrrM15MxqGJ","type":"function","function":{"name":"dummy_tool","arguments":"{\"query\":\"test
+      query\"}"}}]},{"role":"tool","tool_call_id":"call_tBCgelchfQjXXJrrM15MxqGJ","name":"dummy_tool","content":"Dummy
+      result for: test query"},{"role":"user","content":"Analyze the tool result.
+      If requirements are met, provide the Final Answer. Otherwise, call the next
+      tool. Deliver only the answer without meta-commentary."}],"model":"gpt-3.5-turbo","tool_choice":"auto","tools":[{"type":"function","function":{"name":"dummy_tool","description":"Useful
+      for when you need to get a dummy result for a query.","strict":true,"parameters":{"properties":{"query":{"title":"Query","type":"string"}},"required":["query"],"type":"object","additionalProperties":false}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1202'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D5DTmxZJI2Ee7fHNc9dYtQkD7sIY2\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770135826,\n  \"model\": \"gpt-3.5-turbo-0125\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"Dummy result for: test query\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        188,\n    \"completion_tokens\": 7,\n    \"total_tokens\": 195,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": null\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 16:23:47 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '416'
       openai-project:
       - OPENAI-PROJECT-XXX
       openai-version:
       - '2020-10-01'
-      x-envoy-upstream-service-time:
-      - '399'
       x-openai-proxy-wasm:
       - v0.1
       x-ratelimit-limit-requests:

lib/crewai/tests/cassettes/agents/test_agent_execute_task_without_planning.yaml

@@ -0,0 +1,110 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      assistant\nYour personal goal is: Help solve math problems"},{"role":"user","content":"\nCurrent
+      Task: What is 12 * 3?\n\nThis is the expected criteria for your final answer:
+      A number\nyou MUST return the actual complete content as the final answer, not
+      a summary.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '400'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yVCw0CGLFmcVvniplwCCt8avtRb\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078254,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"12 * 3 = 36\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        75,\n    \"completion_tokens\": 7,\n    \"total_tokens\": 82,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:24:14 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '331'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/test_agent_kickoff_multi_step_task_with_planning.yaml

@@ -0,0 +1,243 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
+      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
+      a focused execution plan for the following task:\n\n## Task\nFind the first
+      3 prime numbers, add them together, then multiply by 2.\n\n## Expected Output\nComplete
+      the task successfully\n\n## Available Tools\nNo tools available\n\n## Instructions\nCreate
+      ONLY the essential steps needed to complete this task. Use the MINIMUM number
+      of steps required - do NOT pad your plan with unnecessary steps. Most tasks
+      need only 2-5 steps.\n\nFor each step:\n- State the specific action to take\n-
+      Specify which tool to use (if any)\n\nDo NOT include:\n- Setup or preparation
+      steps that are obvious\n- Verification steps unless critical\n- Documentation
+      or cleanup steps unless explicitly required\n- Generic steps like \"review results\"
+      or \"finalize output\"\n\nAfter your plan, state:\n- \"READY: I am ready to
+      execute the task.\" if the plan is complete\n- \"NOT READY: I need to refine
+      my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
+      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
+      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
+      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1597'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yU0MD5GfSUjRW0R4cBmFJ6Hcjbi\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078180,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"### Execution Plan\\n1. Identify the
+        first 3 prime numbers: 2, 3, and 5.\\n2. Add the prime numbers together: 2
+        + 3 + 5 = 10.\\n3. Multiply the sum by 2: 10 * 2 = 20.\\n\\nREADY: I am ready
+        to execute the task.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 291,\n    \"completion_tokens\":
+        73,\n    \"total_tokens\": 364,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:23:02 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '1253'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Tutor. An expert
+      tutor who explains step by step\nYour personal goal is: Solve multi-step math
+      problems"},{"role":"user","content":"\nCurrent Task: Find the first 3 prime
+      numbers, add them together, then multiply by 2.\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '333'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yU2qY6Xqpkz2D5yVAwagQzuPpen\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078182,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"To solve the problem, let\u2019s go
+        through each step methodically.\\n\\n1. **Identify the first three prime numbers**:\\n
+        \  - **Prime numbers** are numbers greater than 1 that have no positive divisors
+        other than 1 and themselves.\\n   - The first three prime numbers are:\\n
+        \    - 2\\n     - 3\\n     - 5\\n\\n2. **Add these prime numbers together**:\\n
+        \  - We add them together:\\n     \\\\[\\n     2 + 3 + 5\\n     \\\\]\\n   -
+        Performing the addition step-by-step:\\n     - First, add 2 and 3:\\n       \\\\[\\n
+        \      2 + 3 = 5\\n       \\\\]\\n     - Then add 5 to this result:\\n       \\\\[\\n
+        \      5 + 5 = 10\\n       \\\\]\\n   - So, the sum of the first three prime
+        numbers is **10**.\\n\\n3. **Multiply the sum by 2**:\\n   - Now we multiply
+        the result by 2:\\n     \\\\[\\n     10 \\\\times 2 = 20\\n     \\\\]\\n  \\nTherefore,
+        the final answer is **20**.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 62,\n    \"completion_tokens\":
+        236,\n    \"total_tokens\": 298,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:23:06 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '3846'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/test_agent_kickoff_with_planning.yaml

@@ -0,0 +1,238 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are a strategic planning assistant.
+      Create minimal, effective execution plans. Prefer fewer steps over more."},{"role":"user","content":"Create
+      a focused execution plan for the following task:\n\n## Task\nWhat is 15 + 27?\n\n##
+      Expected Output\nComplete the task successfully\n\n## Available Tools\nNo tools
+      available\n\n## Instructions\nCreate ONLY the essential steps needed to complete
+      this task. Use the MINIMUM number of steps required - do NOT pad your plan with
+      unnecessary steps. Most tasks need only 2-5 steps.\n\nFor each step:\n- State
+      the specific action to take\n- Specify which tool to use (if any)\n\nDo NOT
+      include:\n- Setup or preparation steps that are obvious\n- Verification steps
+      unless critical\n- Documentation or cleanup steps unless explicitly required\n-
+      Generic steps like \"review results\" or \"finalize output\"\n\nAfter your plan,
+      state:\n- \"READY: I am ready to execute the task.\" if the plan is complete\n-
+      \"NOT READY: I need to refine my plan because [reason].\" if you need more thinking"}],"model":"gpt-4o-mini","tool_choice":"auto","tools":[{"type":"function","function":{"name":"create_reasoning_plan","description":"Create
+      or refine a reasoning plan for a task","strict":true,"parameters":{"type":"object","properties":{"plan":{"type":"string","description":"The
+      detailed reasoning plan for the task."},"ready":{"type":"boolean","description":"Whether
+      the agent is ready to execute the task."}},"required":["plan","ready"],"additionalProperties":false}}}]}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '1543'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTrm3GkzDX47DIcce9uA3iF8kFE\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078171,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"## Execution Plan\\n\\n1. Calculate
+        the sum of 15 and 27.\\n\\nREADY: I am ready to execute the task.\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        281,\n    \"completion_tokens\": 27,\n    \"total_tokens\": 308,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:51 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '691'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      math tutor\nYour personal goal is: Help solve math problems step by step"},{"role":"user","content":"\nCurrent
+      Task: What is 15 + 27?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '269'
+      content-type:
+      - application/json
+      cookie:
+      - COOKIE-XXX
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTrUOvExA9fTFDwYxvG4xEgRP6L\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078171,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"To solve the problem \\\\( 15 + 27
+        \\\\), we can follow these steps:\\n\\n1. **Align the numbers**: Write them
+        one on top of the other, aligned by their rightmost digits:\\n\\n   ```\\n
+        \     15\\n   + 27\\n   ```\\n\\n2. **Add the units place**: Start from the
+        rightmost digits (units place):\\n   - \\\\( 5 + 7 = 12 \\\\)\\n   - Write
+        down 2 and carry over 1.\\n\\n3. **Add the tens place**: Now, move to the
+        next column (tens place):\\n   - \\\\( 1 + 2 + 1 \\\\) (the 1 is from the
+        carry) \\\\( = 4 \\\\)\\n\\n4. **Combine the results**: Now, combine the results
+        from the tens and units places:\\n   - The result in the tens place is 4 and
+        in the units place is 2, giving us \\\\( 42 \\\\).\\n\\nTherefore, \\\\( 15
+        + 27 = 42 \\\\).\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 50,\n    \"completion_tokens\":
+        209,\n    \"total_tokens\": 259,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:55 GMT
+      Server:
+      - cloudflare
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '3263'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/test_agent_kickoff_with_planning_disabled.yaml

@@ -0,0 +1,110 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      assistant\nYour personal goal is: Help solve math problems"},{"role":"user","content":"\nCurrent
+      Task: What is 100 / 4?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '255'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yU6mFapBLuCx4fJtYBup52dwwrs\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078186,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"To solve the problem 100 divided by
+        4, you can perform the division as follows:\\n\\n100 \xF7 4 = 25\\n\\nSo,
+        the answer is 25.\",\n        \"refusal\": null,\n        \"annotations\":
+        []\n      },\n      \"logprobs\": null,\n      \"finish_reason\": \"stop\"\n
+        \   }\n  ],\n  \"usage\": {\n    \"prompt_tokens\": 46,\n    \"completion_tokens\":
+        36,\n    \"total_tokens\": 82,\n    \"prompt_tokens_details\": {\n      \"cached_tokens\":
+        0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:23:07 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '1098'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/agents/test_agent_kickoff_without_planning.yaml

@@ -0,0 +1,108 @@
+interactions:
+- request:
+    body: '{"messages":[{"role":"system","content":"You are Math Assistant. A helpful
+      assistant\nYour personal goal is: Help solve math problems"},{"role":"user","content":"\nCurrent
+      Task: What is 8 * 7?\n\nProvide your complete response:"}],"model":"gpt-4o-mini"}'
+    headers:
+      User-Agent:
+      - X-USER-AGENT-XXX
+      accept:
+      - application/json
+      accept-encoding:
+      - ACCEPT-ENCODING-XXX
+      authorization:
+      - AUTHORIZATION-XXX
+      connection:
+      - keep-alive
+      content-length:
+      - '253'
+      content-type:
+      - application/json
+      host:
+      - api.openai.com
+      x-stainless-arch:
+      - X-STAINLESS-ARCH-XXX
+      x-stainless-async:
+      - 'false'
+      x-stainless-lang:
+      - python
+      x-stainless-os:
+      - X-STAINLESS-OS-XXX
+      x-stainless-package-version:
+      - 1.83.0
+      x-stainless-read-timeout:
+      - X-STAINLESS-READ-TIMEOUT-XXX
+      x-stainless-retry-count:
+      - '0'
+      x-stainless-runtime:
+      - CPython
+      x-stainless-runtime-version:
+      - 3.13.3
+    method: POST
+    uri: https://api.openai.com/v1/chat/completions
+  response:
+    body:
+      string: "{\n  \"id\": \"chatcmpl-D4yTqLFhGtfq2CyS2aPPhiZL4GjtQ\",\n  \"object\":
+        \"chat.completion\",\n  \"created\": 1770078170,\n  \"model\": \"gpt-4o-mini-2024-07-18\",\n
+        \ \"choices\": [\n    {\n      \"index\": 0,\n      \"message\": {\n        \"role\":
+        \"assistant\",\n        \"content\": \"8 * 7 equals 56.\",\n        \"refusal\":
+        null,\n        \"annotations\": []\n      },\n      \"logprobs\": null,\n
+        \     \"finish_reason\": \"stop\"\n    }\n  ],\n  \"usage\": {\n    \"prompt_tokens\":
+        46,\n    \"completion_tokens\": 8,\n    \"total_tokens\": 54,\n    \"prompt_tokens_details\":
+        {\n      \"cached_tokens\": 0,\n      \"audio_tokens\": 0\n    },\n    \"completion_tokens_details\":
+        {\n      \"reasoning_tokens\": 0,\n      \"audio_tokens\": 0,\n      \"accepted_prediction_tokens\":
+        0,\n      \"rejected_prediction_tokens\": 0\n    }\n  },\n  \"service_tier\":
+        \"default\",\n  \"system_fingerprint\": \"fp_1590f93f9d\"\n}\n"
+    headers:
+      CF-RAY:
+      - CF-RAY-XXX
+      Connection:
+      - keep-alive
+      Content-Type:
+      - application/json
+      Date:
+      - Tue, 03 Feb 2026 00:22:50 GMT
+      Server:
+      - cloudflare
+      Set-Cookie:
+      - SET-COOKIE-XXX
+      Strict-Transport-Security:
+      - STS-XXX
+      Transfer-Encoding:
+      - chunked
+      X-Content-Type-Options:
+      - X-CONTENT-TYPE-XXX
+      access-control-expose-headers:
+      - ACCESS-CONTROL-XXX
+      alt-svc:
+      - h3=":443"; ma=86400
+      cf-cache-status:
+      - DYNAMIC
+      openai-organization:
+      - OPENAI-ORG-XXX
+      openai-processing-ms:
+      - '443'
+      openai-project:
+      - OPENAI-PROJECT-XXX
+      openai-version:
+      - '2020-10-01'
+      x-openai-proxy-wasm:
+      - v0.1
+      x-ratelimit-limit-requests:
+      - X-RATELIMIT-LIMIT-REQUESTS-XXX
+      x-ratelimit-limit-tokens:
+      - X-RATELIMIT-LIMIT-TOKENS-XXX
+      x-ratelimit-remaining-requests:
+      - X-RATELIMIT-REMAINING-REQUESTS-XXX
+      x-ratelimit-remaining-tokens:
+      - X-RATELIMIT-REMAINING-TOKENS-XXX
+      x-ratelimit-reset-requests:
+      - X-RATELIMIT-RESET-REQUESTS-XXX
+      x-ratelimit-reset-tokens:
+      - X-RATELIMIT-RESET-TOKENS-XXX
+      x-request-id:
+      - X-REQUEST-ID-XXX
+    status:
+      code: 200
+      message: OK
+version: 1

lib/crewai/tests/cassettes/llms/google/test_gemini_crew_structured_output_with_tools.yaml

@@ -1,197 +0,0 @@
-interactions:
-- request:
-    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: Calculate 15 + 27 using
-      your add_numbers tool. Report the result.\n\nThis is the expected criteria for
-      your final answer: A structured calculation result\nyou MUST return the actual
-      complete content as the final answer, not a summary.\nFormat your final answer
-      according to the following OpenAPI schema: {\n  \"properties\": {\n    \"operation\":
-      {\n      \"description\": \"The mathematical operation performed\",\n      \"title\":
-      \"Operation\",\n      \"type\": \"string\"\n    },\n    \"result\": {\n      \"description\":
-      \"The result of the calculation\",\n      \"title\": \"Result\",\n      \"type\":
-      \"integer\"\n    },\n    \"explanation\": {\n      \"description\": \"Brief
-      explanation of the calculation\",\n      \"title\": \"Explanation\",\n      \"type\":
-      \"string\"\n    }\n  },\n  \"required\": [\n    \"operation\",\n    \"result\",\n    \"explanation\"\n  ],\n  \"title\":
-      \"CalculationResult\",\n  \"type\": \"object\",\n  \"additionalProperties\":
-      false\n}\n\nIMPORTANT: Preserve the original content exactly as-is. Do NOT rewrite,
-      paraphrase, or modify the meaning of the content. Only structure it to match
-      the schema format.\n\nDo not include the OpenAPI schema in the final output.
-      Ensure the final output does not include any code block markers like ```json
-      or ```python."}], "role": "user"}], "systemInstruction": {"parts": [{"text":
-      "You are Calculator. You are a calculator assistant that uses tools to compute
-      results.\nYour personal goal is: Perform calculations using available tools"}],
-      "role": "user"}, "tools": [{"functionDeclarations": [{"description": "Add two
-      numbers together and return the sum.", "name": "add_numbers", "parameters_json_schema":
-      {"properties": {"a": {"title": "A", "type": "integer"}, "b": {"title": "B",
-      "type": "integer"}}, "required": ["a", "b"], "type": "object", "additionalProperties":
-      false}}, {"description": "Use this tool to provide your final structured response.
-      Call this tool when you have gathered all necessary information and are ready
-      to provide the final answer in the required format.", "name": "structured_output",
-      "parameters_json_schema": {"properties": {"operation": {"description": "The
-      mathematical operation performed", "title": "Operation", "type": "string"},
-      "result": {"description": "The result of the calculation", "title": "Result",
-      "type": "integer"}, "explanation": {"description": "Brief explanation of the
-      calculation", "title": "Explanation", "type": "string"}}, "required": ["operation",
-      "result", "explanation"], "title": "CalculationResult", "type": "object", "additionalProperties":
-      false, "propertyOrdering": ["operation", "result", "explanation"]}}]}], "generationConfig":
-      {"stopSequences": ["\nObservation:"]}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '2763'
-      content-type:
-      - application/json
-      host:
-      - generativelanguage.googleapis.com
-      x-goog-api-client:
-      - google-genai-sdk/1.49.0 gl-python/3.13.12
-      x-goog-api-key:
-      - X-GOOG-API-KEY-XXX
-    method: POST
-    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-001:generateContent
-  response:
-    body:
-      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
-        [\n          {\n            \"functionCall\": {\n              \"name\": \"add_numbers\",\n
-        \             \"args\": {\n                \"a\": 15,\n                \"b\":
-        27\n              }\n            }\n          }\n        ],\n        \"role\":
-        \"model\"\n      },\n      \"finishReason\": \"STOP\",\n      \"avgLogprobs\":
-        4.3579145442760951e-06\n    }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\":
-        377,\n    \"candidatesTokenCount\": 7,\n    \"totalTokenCount\": 384,\n    \"promptTokensDetails\":
-        [\n      {\n        \"modality\": \"TEXT\",\n        \"tokenCount\": 377\n
-        \     }\n    ],\n    \"candidatesTokensDetails\": [\n      {\n        \"modality\":
-        \"TEXT\",\n        \"tokenCount\": 7\n      }\n    ]\n  },\n  \"modelVersion\":
-        \"gemini-2.0-flash-001\",\n  \"responseId\": \"vVefaYDSOouXjMcPicLCsQY\"\n}\n"
-    headers:
-      Alt-Svc:
-      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
-      Content-Type:
-      - application/json; charset=UTF-8
-      Date:
-      - Wed, 25 Feb 2026 20:12:46 GMT
-      Server:
-      - scaffolding on HTTPServer2
-      Server-Timing:
-      - gfet4t7; dur=718
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Origin
-      - X-Origin
-      - Referer
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      X-Frame-Options:
-      - X-FRAME-OPTIONS-XXX
-      X-XSS-Protection:
-      - '0'
-    status:
-      code: 200
-      message: OK
-- request:
-    body: '{"contents": [{"parts": [{"text": "\nCurrent Task: Calculate 15 + 27 using
-      your add_numbers tool. Report the result.\n\nThis is the expected criteria for
-      your final answer: A structured calculation result\nyou MUST return the actual
-      complete content as the final answer, not a summary.\nFormat your final answer
-      according to the following OpenAPI schema: {\n  \"properties\": {\n    \"operation\":
-      {\n      \"description\": \"The mathematical operation performed\",\n      \"title\":
-      \"Operation\",\n      \"type\": \"string\"\n    },\n    \"result\": {\n      \"description\":
-      \"The result of the calculation\",\n      \"title\": \"Result\",\n      \"type\":
-      \"integer\"\n    },\n    \"explanation\": {\n      \"description\": \"Brief
-      explanation of the calculation\",\n      \"title\": \"Explanation\",\n      \"type\":
-      \"string\"\n    }\n  },\n  \"required\": [\n    \"operation\",\n    \"result\",\n    \"explanation\"\n  ],\n  \"title\":
-      \"CalculationResult\",\n  \"type\": \"object\",\n  \"additionalProperties\":
-      false\n}\n\nIMPORTANT: Preserve the original content exactly as-is. Do NOT rewrite,
-      paraphrase, or modify the meaning of the content. Only structure it to match
-      the schema format.\n\nDo not include the OpenAPI schema in the final output.
-      Ensure the final output does not include any code block markers like ```json
-      or ```python."}], "role": "user"}, {"parts": [{"functionCall": {"args": {"a":
-      15, "b": 27}, "name": "add_numbers"}}], "role": "model"}, {"parts": [{"functionResponse":
-      {"name": "add_numbers", "response": {"result": 42}}}], "role": "user"}, {"parts":
-      [{"text": "Analyze the tool result. If requirements are met, provide the Final
-      Answer. Otherwise, call the next tool. Deliver only the answer without meta-commentary."}],
-      "role": "user"}], "systemInstruction": {"parts": [{"text": "You are Calculator.
-      You are a calculator assistant that uses tools to compute results.\nYour personal
-      goal is: Perform calculations using available tools"}], "role": "user"}, "tools":
-      [{"functionDeclarations": [{"description": "Add two numbers together and return
-      the sum.", "name": "add_numbers", "parameters_json_schema": {"properties": {"a":
-      {"title": "A", "type": "integer"}, "b": {"title": "B", "type": "integer"}},
-      "required": ["a", "b"], "type": "object", "additionalProperties": false}}, {"description":
-      "Use this tool to provide your final structured response. Call this tool when
-      you have gathered all necessary information and are ready to provide the final
-      answer in the required format.", "name": "structured_output", "parameters_json_schema":
-      {"properties": {"operation": {"description": "The mathematical operation performed",
-      "title": "Operation", "type": "string"}, "result": {"description": "The result
-      of the calculation", "title": "Result", "type": "integer"}, "explanation": {"description":
-      "Brief explanation of the calculation", "title": "Explanation", "type": "string"}},
-      "required": ["operation", "result", "explanation"], "title": "CalculationResult",
-      "type": "object", "additionalProperties": false, "propertyOrdering": ["operation",
-      "result", "explanation"]}}]}], "generationConfig": {"stopSequences": ["\nObservation:"]}}'
-    headers:
-      User-Agent:
-      - X-USER-AGENT-XXX
-      accept:
-      - '*/*'
-      accept-encoding:
-      - ACCEPT-ENCODING-XXX
-      connection:
-      - keep-alive
-      content-length:
-      - '3166'
-      content-type:
-      - application/json
-      host:
-      - generativelanguage.googleapis.com
-      x-goog-api-client:
-      - google-genai-sdk/1.49.0 gl-python/3.13.12
-      x-goog-api-key:
-      - X-GOOG-API-KEY-XXX
-    method: POST
-    uri: https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-001:generateContent
-  response:
-    body:
-      string: "{\n  \"candidates\": [\n    {\n      \"content\": {\n        \"parts\":
-        [\n          {\n            \"functionCall\": {\n              \"name\": \"structured_output\",\n
-        \             \"args\": {\n                \"result\": 42,\n                \"explanation\":
-        \"15 + 27 = 42\",\n                \"operation\": \"addition\"\n              }\n
-        \           }\n          }\n        ],\n        \"role\": \"model\"\n      },\n
-        \     \"finishReason\": \"STOP\",\n      \"avgLogprobs\": -0.07498827245500353\n
-        \   }\n  ],\n  \"usageMetadata\": {\n    \"promptTokenCount\": 421,\n    \"candidatesTokenCount\":
-        18,\n    \"totalTokenCount\": 439,\n    \"promptTokensDetails\": [\n      {\n
-        \       \"modality\": \"TEXT\",\n        \"tokenCount\": 421\n      }\n    ],\n
-        \   \"candidatesTokensDetails\": [\n      {\n        \"modality\": \"TEXT\",\n
-        \       \"tokenCount\": 18\n      }\n    ]\n  },\n  \"modelVersion\": \"gemini-2.0-flash-001\",\n
-        \ \"responseId\": \"vlefac7bJb6TjMcPzYWh0Ag\"\n}\n"
-    headers:
-      Alt-Svc:
-      - h3=":443"; ma=2592000,h3-29=":443"; ma=2592000
-      Content-Type:
-      - application/json; charset=UTF-8
-      Date:
-      - Wed, 25 Feb 2026 20:12:47 GMT
-      Server:
-      - scaffolding on HTTPServer2
-      Server-Timing:
-      - gfet4t7; dur=774
-      Transfer-Encoding:
-      - chunked
-      Vary:
-      - Origin
-      - X-Origin
-      - Referer
-      X-Content-Type-Options:
-      - X-CONTENT-TYPE-XXX
-      X-Frame-Options:
-      - X-FRAME-OPTIONS-XXX
-      X-XSS-Protection:
-      - '0'
-    status:
-      code: 200
-      message: OK
-version: 1