Merge branch 'main' into lg-isolate-platform-integration-token

Improve the platform integration context manager to handle None/falsy tokens gracefully by returning nullcontext

.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/build-uv-cache.yml

@@ -25,12 +25,24 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
-      - name: Install uv and populate cache
+      - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
           version: "0.8.4"
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
+          enable-cache: false
 
-      - name: Install dependencies
-        run: uv sync --all-groups --all-extras --frozen --no-install-project
+      - name: Install dependencies and populate cache
+        run: |
+          echo "Building global UV cache for Python ${{ matrix.python-version }}..."
+          uv sync --all-groups --all-extras --no-install-project
+          echo "Cache populated successfully"
+
+      - name: Save uv caches
+        uses: actions/cache/save@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}

.github/workflows/linter.yml

@@ -18,15 +18,27 @@ jobs:
       - name: Fetch Target Branch
         run: git fetch origin $TARGET_BRANCH --depth=1
 
+      - name: Restore global uv cache
+        id: cache-restore
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py3.11-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            uv-main-py3.11-
+
       - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
           version: "0.8.4"
           python-version: "3.11"
-          enable-cache: true
+          enable-cache: false
 
       - name: Install dependencies
-        run: uv sync --all-groups --all-extras --frozen --no-install-project
+        run: uv sync --all-groups --all-extras --no-install-project
 
       - name: Get Changed Python Files
         id: changed-files
@@ -45,3 +57,13 @@ jobs:
            | grep -v 'src/crewai/cli/templates/' \
            | grep -v '/tests/' \
            | xargs -I{} uv run ruff check "{}"
+
+      - name: Save uv caches
+        if: steps.cache-restore.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py3.11-${{ hashFiles('uv.lock') }}

.github/workflows/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/tests.yml

@@ -1,42 +1,47 @@
 name: Run Tests
 
-on:
-  pull_request:
-  push:
-    branches: [main]
+on: [pull_request]
 
 permissions:
   contents: read
 
-concurrency:
-  group: tests-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
 jobs:
   tests:
-    name: tests (${{ matrix.python-version }}, ${{ matrix.group }}/4)
+    name: tests (${{ matrix.python-version }})
     runs-on: ubuntu-latest
-    timeout-minutes: 10
+    timeout-minutes: 15
     strategy:
       fail-fast: true
       matrix:
         python-version: ['3.10', '3.11', '3.12', '3.13']
-        group: [1, 2, 3, 4]
+        group: [1, 2, 3, 4, 5, 6, 7, 8]
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
         with:
-          fetch-depth: 0
+          fetch-depth: 0  # Fetch all history for proper diff
+
+      - name: Restore global uv cache
+        id: cache-restore
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            uv-main-py${{ matrix.python-version }}-
 
       - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
           version: "0.8.4"
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
+          enable-cache: false
 
       - name: Install the project
-        run: uv sync --all-groups --all-extras --frozen
+        run: uv sync --all-groups --all-extras
 
       - name: Restore test durations
         uses: actions/cache/restore@v4
@@ -44,56 +49,52 @@ jobs:
           path: .test_durations_py*
           key: test-durations-py${{ matrix.python-version }}
 
-      - name: Run tests (group ${{ matrix.group }} of 4)
+      - name: Run tests (group ${{ matrix.group }} of 8)
         run: |
           PYTHON_VERSION_SAFE=$(echo "${{ matrix.python-version }}" | tr '.' '_')
           DURATION_FILE="../../.test_durations_py${PYTHON_VERSION_SAFE}"
 
+          # Temporarily always skip cached durations to fix test splitting
+          # When durations don't match, pytest-split runs duplicate tests instead of splitting
+          echo "Using even test splitting (duration cache disabled until fix merged)"
           DURATIONS_ARG=""
-          if [ -f "$DURATION_FILE" ]; then
-            if git diff "origin/${{ github.base_ref }}...HEAD" --name-only 2>/dev/null | grep -q "^lib/.*/tests/.*\.py$"; then
-              echo "::notice::Test files changed — using even splitting"
-            else
-              echo "::notice::Using cached test durations for optimal splitting"
-              DURATIONS_ARG="--durations-path=${DURATION_FILE}"
-            fi
-          else
-            echo "::notice::No cached durations — using even splitting"
-          fi
 
-          cd lib/crewai && uv run --frozen pytest \
+          # Original logic (disabled temporarily):
+          # if [ ! -f "$DURATION_FILE" ]; then
+          #   echo "No cached durations found, tests will be split evenly"
+          #   DURATIONS_ARG=""
+          # elif git diff origin/${{ github.base_ref }}...HEAD --name-only 2>/dev/null | grep -q "^tests/.*\.py$"; then
+          #   echo "Test files have changed, skipping cached durations to avoid mismatches"
+          #   DURATIONS_ARG=""
+          # else
+          #   echo "No test changes detected, using cached test durations for optimal splitting"
+          #   DURATIONS_ARG="--durations-path=${DURATION_FILE}"
+          # fi
+
+          cd lib/crewai && uv run pytest \
             -vv \
-            --splits 4 \
+            --splits 8 \
             --group ${{ matrix.group }} \
             $DURATIONS_ARG \
-            --splitting-algorithm least_duration \
             --durations=10 \
             --maxfail=3
 
-      - name: Run tool tests (group ${{ matrix.group }} of 4)
+      - name: Run tool tests (group ${{ matrix.group }} of 8)
         run: |
-          cd lib/crewai-tools && uv run --frozen pytest \
+          cd lib/crewai-tools && uv run pytest \
             -vv \
-            --splits 4 \
+            --splits 8 \
             --group ${{ matrix.group }} \
             --durations=10 \
             --maxfail=3
 
-  # Gate jobs matching required status checks in branch protection
-  tests-gate:
-    name: tests (${{ matrix.python-version }})
-    needs: [tests]
-    if: always()
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ['3.10', '3.11', '3.12', '3.13']
-    steps:
-      - name: Check test results
-        run: |
-          if [ "${{ needs.tests.result }}" = "success" ]; then
-            echo "All tests passed"
-          else
-            echo "Tests failed: ${{ needs.tests.result }}"
-            exit 1
-          fi
+
+      - name: Save uv caches
+        if: steps.cache-restore.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}

.github/workflows/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 }}"}'

.github/workflows/type-checker.yml

@@ -20,15 +20,27 @@ jobs:
         with:
           fetch-depth: 0 # Fetch all history for proper diff
 
+      - name: Restore global uv cache
+        id: cache-restore
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            uv-main-py${{ matrix.python-version }}-
+
       - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
           version: "0.8.4"
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
+          enable-cache: false
 
       - name: Install dependencies
-        run: uv sync --all-groups --all-extras --frozen
+        run: uv sync --all-groups --all-extras
 
       - name: Get changed Python files
         id: changed-files
@@ -62,6 +74,16 @@ jobs:
         if: steps.changed-files.outputs.has_changes == 'false'
         run: echo "No Python files in src/ were modified - skipping type checks"
 
+      - name: Save uv caches
+        if: steps.cache-restore.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
+
   # Summary job to provide single status for branch protection
   type-checker:
     name: type-checker
@@ -72,8 +94,8 @@ jobs:
       - name: Check matrix results
         run: |
           if [ "${{ needs.type-checker-matrix.result }}" == "success" ] || [ "${{ needs.type-checker-matrix.result }}" == "skipped" ]; then
-            echo "All type checks passed"
+            echo "✅ All type checks passed"
           else
-            echo "Type checks failed"
+            echo "❌ Type checks failed"
             exit 1
           fi

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

@@ -5,9 +5,7 @@ on:
     branches:
       - main
     paths:
-      - 'lib/crewai/tests/**/*.py'
-      - 'lib/crewai-tools/tests/**/*.py'
-      - 'lib/crewai-files/tests/**/*.py'
+      - 'tests/**/*.py'
   workflow_dispatch:
 
 permissions:
@@ -22,25 +20,37 @@ jobs:
     env:
       OPENAI_API_KEY: fake-api-key
       PYTHONUNBUFFERED: 1
-
+    
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Restore global uv cache
+        id: cache-restore
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            uv-main-py${{ matrix.python-version }}-
+
       - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
           version: "0.8.4"
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
+          enable-cache: false
 
       - name: Install the project
-        run: uv sync --all-groups --all-extras --frozen
+        run: uv sync --all-groups --all-extras
 
       - name: Run all tests and store durations
         run: |
           PYTHON_VERSION_SAFE=$(echo "${{ matrix.python-version }}" | tr '.' '_')
-          uv run --frozen pytest --store-durations --durations-path=.test_durations_py${PYTHON_VERSION_SAFE} -n auto
+          uv run pytest --store-durations --durations-path=.test_durations_py${PYTHON_VERSION_SAFE} -n auto
         continue-on-error: true
 
       - name: Save durations to cache
@@ -49,3 +59,13 @@ jobs:
         with:
           path: .test_durations_py*
           key: test-durations-py${{ matrix.python-version }}
+
+      - name: Save uv caches
+        if: steps.cache-restore.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}

docs/en/concepts/llms.mdx

@@ -470,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>
 
@@ -652,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:**
@@ -696,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

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/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/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>

lib/crewai-tools/src/crewai_tools/tools/crewai_platform_tools/misc.py

@@ -1,5 +1,7 @@
 import os
 
+from crewai.context import get_platform_integration_token as _get_context_token
+
 
 def get_platform_api_base_url() -> str:
     """Get the platform API base URL from environment or use default."""
@@ -8,10 +10,16 @@ def get_platform_api_base_url() -> str:
 
 
 def get_platform_integration_token() -> str:
-    """Get the platform API base URL from environment or use default."""
-    token = os.getenv("CREWAI_PLATFORM_INTEGRATION_TOKEN") or ""
+    """Get the platform integration token from the context.
+    Fallback to the environment variable if no token has been set in the context.
+
+    Raises:
+        ValueError: If no token has been set in the context.
+    """
+    token = _get_context_token() or os.getenv("CREWAI_PLATFORM_INTEGRATION_TOKEN")
     if not token:
         raise ValueError(
-            "No platform integration token found, please set the CREWAI_PLATFORM_INTEGRATION_TOKEN environment variable"
+            "No platform integration token found. "
+            "Set it via platform_integration_context() or set_platform_integration_token()."
         )
-    return token  # TODO: Use context manager to get token
+    return token

lib/crewai-tools/tests/test_platform_tools_misc.py

@@ -0,0 +1,56 @@
+"""Tests for platform tools misc functionality."""
+
+import os
+from unittest.mock import patch
+
+import pytest
+from crewai.context import platform_integration_context, set_platform_integration_token, reset_platform_integration_token
+from crewai_tools.tools.crewai_platform_tools.misc import (
+    get_platform_integration_token,
+)
+
+
+
+class TestTokenRetrievalWithFallback:
+    """Test token retrieval logic with environment fallback."""
+
+    @pytest.fixture
+    def clean_context(self):
+        token = set_platform_integration_token(None)
+        env_backup = os.environ.pop("CREWAI_PLATFORM_INTEGRATION_TOKEN", None)
+        yield
+        reset_platform_integration_token(token)
+        if env_backup is not None:
+            os.environ["CREWAI_PLATFORM_INTEGRATION_TOKEN"] = env_backup
+        else:
+            os.environ.pop("CREWAI_PLATFORM_INTEGRATION_TOKEN", None)
+
+    def test_context_token_takes_precedence(self, clean_context):
+        """Test that context token takes precedence over environment variable."""
+        context_token = "context-token"
+        env_token = "env-token"
+
+        with patch.dict(os.environ, {"CREWAI_PLATFORM_INTEGRATION_TOKEN": env_token}):
+            with platform_integration_context(context_token):
+                token = get_platform_integration_token()
+                assert token == context_token
+
+    def test_environment_fallback_when_no_context(self, clean_context):
+        """Test fallback to environment variable when no context token."""
+        env_token = "env-fallback-token"
+
+        with patch.dict(os.environ, {"CREWAI_PLATFORM_INTEGRATION_TOKEN": env_token}):
+            token = get_platform_integration_token()
+            assert token == env_token
+
+    @pytest.mark.parametrize("empty_value", ["", None])
+    def test_missing_token_raises_error(self, clean_context, empty_value):
+        """Test that missing tokens raise appropriate errors."""
+        env_dict = {"CREWAI_PLATFORM_INTEGRATION_TOKEN": empty_value} if empty_value is not None else {}
+
+        with patch.dict(os.environ, env_dict, clear=True):
+            with pytest.raises(ValueError) as exc_info:
+                get_platform_integration_token()
+
+            assert "No platform integration token found" in str(exc_info.value)
+            assert "platform_integration_context()" in str(exc_info.value)

lib/crewai-tools/tool.specs.json

@@ -20117,18 +20117,6 @@
       "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": {
@@ -20206,17 +20194,6 @@
             "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

@@ -38,7 +38,6 @@ dependencies = [
     "json5~=0.10.0",
     "portalocker~=2.7.0",
     "pydantic-settings~=2.10.1",
-    "httpx~=0.28.1",
     "mcp~=1.26.0",
     "uv~=0.9.13",
     "aiosqlite~=0.21.0",

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

@@ -6,10 +6,8 @@ and memory management.
 
 from __future__ import annotations
 
-import asyncio
 from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor, as_completed
-import inspect
 import logging
 from typing import TYPE_CHECKING, Any, Literal, cast
 
@@ -50,7 +48,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,
 )
@@ -739,9 +736,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 ] = []
                 for call_id, func_name, func_args in parsed_calls:
                     original_tool = original_tools_by_name.get(func_name)
-                    execution_plan.append(
-                        (call_id, func_name, func_args, original_tool)
-                    )
+                    execution_plan.append((call_id, func_name, func_args, original_tool))
 
                 self._append_assistant_tool_calls_message(
                     [
@@ -751,9 +746,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                 )
 
                 max_workers = min(8, len(execution_plan))
-                ordered_results: list[dict[str, Any] | None] = [None] * len(
-                    execution_plan
-                )
+                ordered_results: list[dict[str, Any] | None] = [None] * len(execution_plan)
                 with ThreadPoolExecutor(max_workers=max_workers) as pool:
                     futures = {
                         pool.submit(
@@ -810,7 +803,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             return tool_finish
 
         reasoning_prompt = self._i18n.slice("post_tool_reasoning")
-        reasoning_message = {
+        reasoning_message: LLMMessage = {
             "role": "user",
             "content": reasoning_prompt,
         }
@@ -895,9 +888,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 []:
@@ -911,9 +908,9 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
         elif (
             should_execute
             and original_tool
-            and (max_count := getattr(original_tool, "max_usage_count", None))
-            is not None
-            and getattr(original_tool, "current_usage_count", 0) >= max_count
+            and getattr(original_tool, "max_usage_count", None) is not None
+            and getattr(original_tool, "current_usage_count", 0)
+            >= original_tool.max_usage_count
         ):
             max_usage_reached = True
 
@@ -992,17 +989,13 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
                         and hasattr(original_tool, "cache_function")
                         and callable(original_tool.cache_function)
                     ):
-                        should_cache = original_tool.cache_function(
-                            args_dict, raw_result
-                        )
+                        should_cache = original_tool.cache_function(args_dict, raw_result)
                     if should_cache:
                         self.tools_handler.cache.add(
                             tool=func_name, input=input_str, output=raw_result
                         )
 
-                result = (
-                    str(raw_result) if not isinstance(raw_result, str) else raw_result
-                )
+                result = str(raw_result) if not isinstance(raw_result, str) else raw_result
             except Exception as e:
                 result = f"Error executing tool: {e}"
                 if self.task:
@@ -1497,9 +1490,7 @@ class CrewAgentExecutor(CrewAgentExecutorMixin):
             formatted_answer: Current agent response.
         """
         if self.step_callback:
-            cb_result = self.step_callback(formatted_answer)
-            if inspect.iscoroutine(cb_result):
-                asyncio.run(cb_result)
+            self.step_callback(formatted_answer)
 
     def _append_message(
         self, text: str, role: Literal["user", "assistant", "system"] = "assistant"

lib/crewai/src/crewai/cli/authentication/main.py

@@ -2,8 +2,8 @@ import time
 from typing import TYPE_CHECKING, Any, TypeVar, cast
 import webbrowser
 
-import httpx
 from pydantic import BaseModel, Field
+import requests
 from rich.console import Console
 
 from crewai.cli.authentication.utils import validate_jwt_token
@@ -98,7 +98,7 @@ class AuthenticationCommand:
             "scope": " ".join(self.oauth2_provider.get_oauth_scopes()),
             "audience": self.oauth2_provider.get_audience(),
         }
-        response = httpx.post(
+        response = requests.post(
             url=self.oauth2_provider.get_authorize_url(),
             data=device_code_payload,
             timeout=20,
@@ -130,7 +130,7 @@ class AuthenticationCommand:
 
         attempts = 0
         while True and attempts < 10:
-            response = httpx.post(
+            response = requests.post(
                 self.oauth2_provider.get_token_url(), data=token_payload, timeout=30
             )
             token_data = response.json()
@@ -149,7 +149,7 @@ class AuthenticationCommand:
                 return
 
             if token_data["error"] not in ("authorization_pending", "slow_down"):
-                raise httpx.HTTPError(
+                raise requests.HTTPError(
                     token_data.get("error_description") or token_data.get("error")
                 )
 

lib/crewai/src/crewai/cli/command.py

@@ -1,6 +1,5 @@
-import json
-
-import httpx
+import requests
+from requests.exceptions import JSONDecodeError
 from rich.console import Console
 
 from crewai.cli.authentication.token import get_auth_token
@@ -31,16 +30,16 @@ class PlusAPIMixin:
             console.print("Run 'crewai login' to sign up/login.", style="bold green")
             raise SystemExit from None
 
-    def _validate_response(self, response: httpx.Response) -> None:
+    def _validate_response(self, response: requests.Response) -> None:
         """
         Handle and display error messages from API responses.
 
         Args:
-            response (httpx.Response): The response from the Plus API
+            response (requests.Response): The response from the Plus API
         """
         try:
             json_response = response.json()
-        except (json.JSONDecodeError, ValueError):
+        except (JSONDecodeError, ValueError):
             console.print(
                 "Failed to parse response from Enterprise API failed. Details:",
                 style="bold red",
@@ -63,7 +62,7 @@ class PlusAPIMixin:
                     )
             raise SystemExit
 
-        if not response.is_success:
+        if not response.ok:
             console.print(
                 "Request to Enterprise API failed. Details:", style="bold red"
             )

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/enterprise/main.py

@@ -1,7 +1,7 @@
-import json
 from typing import Any, cast
 
-import httpx
+import requests
+from requests.exceptions import JSONDecodeError, RequestException
 from rich.console import Console
 
 from crewai.cli.authentication.main import Oauth2Settings, ProviderFactory
@@ -47,12 +47,12 @@ class EnterpriseConfigureCommand(BaseCommand):
                 "User-Agent": f"CrewAI-CLI/{get_crewai_version()}",
                 "X-Crewai-Version": get_crewai_version(),
             }
-            response = httpx.get(oauth_endpoint, timeout=30, headers=headers)
+            response = requests.get(oauth_endpoint, timeout=30, headers=headers)
             response.raise_for_status()
 
             try:
                 oauth_config = response.json()
-            except json.JSONDecodeError as e:
+            except JSONDecodeError as e:
                 raise ValueError(f"Invalid JSON response from {oauth_endpoint}") from e
 
             self._validate_oauth_config(oauth_config)
@@ -62,7 +62,7 @@ class EnterpriseConfigureCommand(BaseCommand):
             )
             return cast(dict[str, Any], oauth_config)
 
-        except httpx.HTTPError as e:
+        except RequestException as e:
             raise ValueError(f"Failed to connect to enterprise URL: {e!s}") from e
         except Exception as e:
             raise ValueError(f"Error fetching OAuth2 configuration: {e!s}") from e

lib/crewai/src/crewai/cli/organization/main.py

@@ -1,4 +1,4 @@
-from httpx import HTTPStatusError
+from requests import HTTPError
 from rich.console import Console
 from rich.table import Table
 
@@ -10,11 +10,11 @@ console = Console()
 
 
 class OrganizationCommand(BaseCommand, PlusAPIMixin):
-    def __init__(self) -> None:
+    def __init__(self):
         BaseCommand.__init__(self)
         PlusAPIMixin.__init__(self, telemetry=self._telemetry)
 
-    def list(self) -> None:
+    def list(self):
         try:
             response = self.plus_api_client.get_organizations()
             response.raise_for_status()
@@ -33,7 +33,7 @@ class OrganizationCommand(BaseCommand, PlusAPIMixin):
                 table.add_row(org["name"], org["uuid"])
 
             console.print(table)
-        except HTTPStatusError as e:
+        except HTTPError as e:
             if e.response.status_code == 401:
                 console.print(
                     "You are not logged in to any organization. Use 'crewai login' to login.",
@@ -50,7 +50,7 @@ class OrganizationCommand(BaseCommand, PlusAPIMixin):
             )
             raise SystemExit(1) from e
 
-    def switch(self, org_id: str) -> None:
+    def switch(self, org_id):
         try:
             response = self.plus_api_client.get_organizations()
             response.raise_for_status()
@@ -72,7 +72,7 @@ class OrganizationCommand(BaseCommand, PlusAPIMixin):
                 f"Successfully switched to {org['name']} ({org['uuid']})",
                 style="bold green",
             )
-        except HTTPStatusError as e:
+        except HTTPError as e:
             if e.response.status_code == 401:
                 console.print(
                     "You are not logged in to any organization. Use 'crewai login' to login.",
@@ -87,7 +87,7 @@ class OrganizationCommand(BaseCommand, PlusAPIMixin):
             console.print(f"Failed to switch organization: {e!s}", style="bold red")
             raise SystemExit(1) from e
 
-    def current(self) -> None:
+    def current(self):
         settings = Settings()
         if settings.org_uuid:
             console.print(

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

@@ -3,6 +3,7 @@ from typing import Any
 from urllib.parse import urljoin
 
 import httpx
+import requests
 
 from crewai.cli.config import Settings
 from crewai.cli.constants import DEFAULT_CREWAI_ENTERPRISE_URL
@@ -42,16 +43,16 @@ class PlusAPI:
 
     def _make_request(
         self, method: str, endpoint: str, **kwargs: Any
-    ) -> httpx.Response:
+    ) -> requests.Response:
         url = urljoin(self.base_url, endpoint)
-        verify = kwargs.pop("verify", True)
-        with httpx.Client(trust_env=False, verify=verify) as client:
-            return client.request(method, url, headers=self.headers, **kwargs)
+        session = requests.Session()
+        session.trust_env = False
+        return session.request(method, url, headers=self.headers, **kwargs)
 
-    def login_to_tool_repository(self) -> httpx.Response:
+    def login_to_tool_repository(self) -> requests.Response:
         return self._make_request("POST", f"{self.TOOLS_RESOURCE}/login")
 
-    def get_tool(self, handle: str) -> httpx.Response:
+    def get_tool(self, handle: str) -> requests.Response:
         return self._make_request("GET", f"{self.TOOLS_RESOURCE}/{handle}")
 
     async def get_agent(self, handle: str) -> httpx.Response:
@@ -67,7 +68,7 @@ class PlusAPI:
         description: str | None,
         encoded_file: str,
         available_exports: list[dict[str, Any]] | None = None,
-    ) -> httpx.Response:
+    ) -> requests.Response:
         params = {
             "handle": handle,
             "public": is_public,
@@ -78,52 +79,54 @@ class PlusAPI:
         }
         return self._make_request("POST", f"{self.TOOLS_RESOURCE}", json=params)
 
-    def deploy_by_name(self, project_name: str) -> httpx.Response:
+    def deploy_by_name(self, project_name: str) -> requests.Response:
         return self._make_request(
             "POST", f"{self.CREWS_RESOURCE}/by-name/{project_name}/deploy"
         )
 
-    def deploy_by_uuid(self, uuid: str) -> httpx.Response:
+    def deploy_by_uuid(self, uuid: str) -> requests.Response:
         return self._make_request("POST", f"{self.CREWS_RESOURCE}/{uuid}/deploy")
 
-    def crew_status_by_name(self, project_name: str) -> httpx.Response:
+    def crew_status_by_name(self, project_name: str) -> requests.Response:
         return self._make_request(
             "GET", f"{self.CREWS_RESOURCE}/by-name/{project_name}/status"
         )
 
-    def crew_status_by_uuid(self, uuid: str) -> httpx.Response:
+    def crew_status_by_uuid(self, uuid: str) -> requests.Response:
         return self._make_request("GET", f"{self.CREWS_RESOURCE}/{uuid}/status")
 
     def crew_by_name(
         self, project_name: str, log_type: str = "deployment"
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "GET", f"{self.CREWS_RESOURCE}/by-name/{project_name}/logs/{log_type}"
         )
 
-    def crew_by_uuid(self, uuid: str, log_type: str = "deployment") -> httpx.Response:
+    def crew_by_uuid(
+        self, uuid: str, log_type: str = "deployment"
+    ) -> requests.Response:
         return self._make_request(
             "GET", f"{self.CREWS_RESOURCE}/{uuid}/logs/{log_type}"
         )
 
-    def delete_crew_by_name(self, project_name: str) -> httpx.Response:
+    def delete_crew_by_name(self, project_name: str) -> requests.Response:
         return self._make_request(
             "DELETE", f"{self.CREWS_RESOURCE}/by-name/{project_name}"
         )
 
-    def delete_crew_by_uuid(self, uuid: str) -> httpx.Response:
+    def delete_crew_by_uuid(self, uuid: str) -> requests.Response:
         return self._make_request("DELETE", f"{self.CREWS_RESOURCE}/{uuid}")
 
-    def list_crews(self) -> httpx.Response:
+    def list_crews(self) -> requests.Response:
         return self._make_request("GET", self.CREWS_RESOURCE)
 
-    def create_crew(self, payload: dict[str, Any]) -> httpx.Response:
+    def create_crew(self, payload: dict[str, Any]) -> requests.Response:
         return self._make_request("POST", self.CREWS_RESOURCE, json=payload)
 
-    def get_organizations(self) -> httpx.Response:
+    def get_organizations(self) -> requests.Response:
         return self._make_request("GET", self.ORGANIZATIONS_RESOURCE)
 
-    def initialize_trace_batch(self, payload: dict[str, Any]) -> httpx.Response:
+    def initialize_trace_batch(self, payload: dict[str, Any]) -> requests.Response:
         return self._make_request(
             "POST",
             f"{self.TRACING_RESOURCE}/batches",
@@ -133,7 +136,7 @@ class PlusAPI:
 
     def initialize_ephemeral_trace_batch(
         self, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "POST",
             f"{self.EPHEMERAL_TRACING_RESOURCE}/batches",
@@ -142,7 +145,7 @@ class PlusAPI:
 
     def send_trace_events(
         self, trace_batch_id: str, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "POST",
             f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}/events",
@@ -152,7 +155,7 @@ class PlusAPI:
 
     def send_ephemeral_trace_events(
         self, trace_batch_id: str, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "POST",
             f"{self.EPHEMERAL_TRACING_RESOURCE}/batches/{trace_batch_id}/events",
@@ -162,7 +165,7 @@ class PlusAPI:
 
     def finalize_trace_batch(
         self, trace_batch_id: str, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "PATCH",
             f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
@@ -172,7 +175,7 @@ class PlusAPI:
 
     def finalize_ephemeral_trace_batch(
         self, trace_batch_id: str, payload: dict[str, Any]
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "PATCH",
             f"{self.EPHEMERAL_TRACING_RESOURCE}/batches/{trace_batch_id}/finalize",
@@ -182,7 +185,7 @@ class PlusAPI:
 
     def mark_trace_batch_as_failed(
         self, trace_batch_id: str, error_message: str
-    ) -> httpx.Response:
+    ) -> requests.Response:
         return self._make_request(
             "PATCH",
             f"{self.TRACING_RESOURCE}/batches/{trace_batch_id}",
@@ -190,11 +193,13 @@ class PlusAPI:
             timeout=30,
         )
 
-    def get_triggers(self) -> httpx.Response:
+    def get_triggers(self) -> requests.Response:
         """Get all available triggers from integrations."""
         return self._make_request("GET", f"{self.INTEGRATIONS_RESOURCE}/apps")
 
-    def get_trigger_payload(self, app_slug: str, trigger_slug: str) -> httpx.Response:
+    def get_trigger_payload(
+        self, app_slug: str, trigger_slug: str
+    ) -> requests.Response:
         """Get sample payload for a specific trigger."""
         return self._make_request(
             "GET", f"{self.INTEGRATIONS_RESOURCE}/{app_slug}/{trigger_slug}/payload"

lib/crewai/src/crewai/cli/provider.py

@@ -8,7 +8,7 @@ from typing import Any
 
 import certifi
 import click
-import httpx
+import requests
 
 from crewai.cli.constants import JSON_URL, MODELS, PROVIDERS
 
@@ -165,20 +165,20 @@ def fetch_provider_data(cache_file: Path) -> dict[str, Any] | None:
     ssl_config = os.environ["SSL_CERT_FILE"] = certifi.where()
 
     try:
-        with httpx.stream("GET", JSON_URL, timeout=60, verify=ssl_config) as response:
-            response.raise_for_status()
-            data = download_data(response)
-            with open(cache_file, "w") as f:
-                json.dump(data, f)
-            return data
-    except httpx.HTTPError as e:
+        response = requests.get(JSON_URL, stream=True, timeout=60, verify=ssl_config)
+        response.raise_for_status()
+        data = download_data(response)
+        with open(cache_file, "w") as f:
+            json.dump(data, f)
+        return data
+    except requests.RequestException as e:
         click.secho(f"Error fetching provider data: {e}", fg="red")
     except json.JSONDecodeError:
         click.secho("Error parsing provider data. Invalid JSON format.", fg="red")
     return None
 
 
-def download_data(response: httpx.Response) -> dict[str, Any]:
+def download_data(response: requests.Response) -> dict[str, Any]:
     """Downloads data from a given HTTP response and returns the JSON content.
 
     Args:
@@ -194,7 +194,7 @@ def download_data(response: httpx.Response) -> dict[str, Any]:
     with click.progressbar(
         length=total_size, label="Downloading", show_pos=True
     ) as bar:
-        for chunk in response.iter_bytes(block_size):
+        for chunk in response.iter_content(block_size):
             if chunk:
                 data_chunks.append(chunk)
                 bar.update(len(chunk))

lib/crewai/src/crewai/context.py

@@ -1,7 +1,6 @@
 from collections.abc import Generator
-from contextlib import contextmanager
+from contextlib import AbstractContextManager, contextmanager, nullcontext
 import contextvars
-import os
 from typing import Any
 
 
@@ -10,40 +9,50 @@ _platform_integration_token: contextvars.ContextVar[str | None] = (
 )
 
 
-def set_platform_integration_token(integration_token: str) -> None:
+def set_platform_integration_token(integration_token: str) -> contextvars.Token[str | None]:
     """Set the platform integration token in the current context.
 
     Args:
         integration_token: The integration token to set.
     """
-    _platform_integration_token.set(integration_token)
+    return _platform_integration_token.set(integration_token)
+
+
+def reset_platform_integration_token(token: contextvars.Token[str | None]) -> None:
+    """Reset the platform integration token to its previous value."""
+    _platform_integration_token.reset(token)
 
 
 def get_platform_integration_token() -> str | None:
-    """Get the platform integration token from the current context or environment.
-
+    """Get the platform integration token from the current context.
     Returns:
         The integration token if set, otherwise None.
     """
-    token = _platform_integration_token.get()
-    if token is None:
-        token = os.getenv("CREWAI_PLATFORM_INTEGRATION_TOKEN")
-    return token
+    return _platform_integration_token.get()
 
 
-@contextmanager
-def platform_context(integration_token: str) -> Generator[None, Any, None]:
+def platform_integration_context(integration_token: str | None) -> AbstractContextManager[None]:
     """Context manager to temporarily set the platform integration token.
 
     Args:
       integration_token: The integration token to set within the context.
-    """
-    token = _platform_integration_token.set(integration_token)
-    try:
-        yield
-    finally:
-        _platform_integration_token.reset(token)
+                        If None or falsy, returns nullcontext (no-op).
 
+    Returns:
+        A context manager that either sets the token or does nothing.
+    """
+    if not integration_token:
+        return nullcontext()
+
+    @contextmanager
+    def _token_context() -> Generator[None, Any, None]:
+        token = set_platform_integration_token(integration_token)
+        try:
+            yield
+        finally:
+            reset_platform_integration_token(token)
+
+    return _token_context()
 
 _current_task_id: contextvars.ContextVar[str | None] = contextvars.ContextVar(
     "current_task_id", default=None

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

@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-import asyncio
 from collections.abc import Callable, Coroutine
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
-import inspect
 import json
 import threading
 from typing import TYPE_CHECKING, Any, Literal, cast
@@ -66,7 +64,6 @@ 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,
 )
@@ -781,7 +778,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             from_cache = cast(bool, execution_result["from_cache"])
             original_tool = execution_result["original_tool"]
 
-            tool_message = {
+            tool_message: LLMMessage = {
                 "role": "tool",
                 "tool_call_id": call_id,
                 "name": func_name,
@@ -849,9 +846,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"
@@ -1357,9 +1358,7 @@ class AgentExecutor(Flow[AgentReActState], CrewAgentExecutorMixin):
             formatted_answer: Current agent response.
         """
         if self.step_callback:
-            cb_result = self.step_callback(formatted_answer)
-            if inspect.iscoroutine(cb_result):
-                asyncio.run(cb_result)
+            self.step_callback(formatted_answer)
 
     def _append_message_to_state(
         self, text: str, role: Literal["user", "assistant", "system"] = "assistant"

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/task.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 from concurrent.futures import Future
 from copy import copy as shallow_copy
 import datetime
@@ -625,15 +624,11 @@ class Task(BaseModel):
             self.end_time = datetime.datetime.now()
 
             if self.callback:
-                cb_result = self.callback(self.output)
-                if inspect.isawaitable(cb_result):
-                    await cb_result
+                self.callback(self.output)
 
             crew = self.agent.crew  # type: ignore[union-attr]
             if crew and crew.task_callback and crew.task_callback != self.callback:
-                cb_result = crew.task_callback(self.output)
-                if inspect.isawaitable(cb_result):
-                    await cb_result
+                crew.task_callback(self.output)
 
             if self.output_file:
                 content = (
@@ -727,15 +722,11 @@ class Task(BaseModel):
             self.end_time = datetime.datetime.now()
 
             if self.callback:
-                cb_result = self.callback(self.output)
-                if inspect.iscoroutine(cb_result):
-                    asyncio.run(cb_result)
+                self.callback(self.output)
 
             crew = self.agent.crew  # type: ignore[union-attr]
             if crew and crew.task_callback and crew.task_callback != self.callback:
-                cb_result = crew.task_callback(self.output)
-                if inspect.iscoroutine(cb_result):
-                    asyncio.run(cb_result)
+                crew.task_callback(self.output)
 
             if self.output_file:
                 content = (

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

@@ -18,7 +18,6 @@ from pydantic import (
     BaseModel as PydanticBaseModel,
     ConfigDict,
     Field,
-    ValidationError,
     create_model,
     field_validator,
 )
@@ -151,37 +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 kwargs and 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:
-        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,7 +179,6 @@ class BaseTool(BaseModel, ABC):
         Returns:
             The result of the tool execution.
         """
-        kwargs = self._validate_kwargs(kwargs)
         result = await self._arun(*args, **kwargs)
         self.current_usage_count += 1
         return result
@@ -356,8 +331,6 @@ class Tool(BaseTool, Generic[P, R]):
         Returns:
             The result of the tool execution.
         """
-        kwargs = self._validate_kwargs(kwargs)
-
         result = self.func(*args, **kwargs)
 
         if asyncio.iscoroutine(result):
@@ -388,7 +361,6 @@ class Tool(BaseTool, Generic[P, R]):
         Returns:
             The result of the tool execution.
         """
-        kwargs = self._validate_kwargs(kwargs)
         result = await self._arun(*args, **kwargs)
         self.current_usage_count += 1
         return result

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

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Callable, Sequence
 import concurrent.futures
-import inspect
 import json
 import re
 from typing import TYPE_CHECKING, Any, Final, Literal, TypedDict
@@ -502,9 +501,7 @@ def handle_agent_action_core(
         - TODO: Remove messages parameter and its usage.
     """
     if step_callback:
-        cb_result = step_callback(tool_result)
-        if inspect.iscoroutine(cb_result):
-            asyncio.run(cb_result)
+        step_callback(tool_result)
 
     formatted_answer.text += f"\nObservation: {tool_result.result}"
     formatted_answer.result = tool_result.result
@@ -1146,36 +1143,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/tests/agents/test_async_agent_executor.py

@@ -2,7 +2,7 @@
 
 import asyncio
 from typing import Any
-from unittest.mock import AsyncMock, MagicMock, Mock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
@@ -291,46 +291,6 @@ class TestAsyncAgentExecutor:
         assert max_concurrent > 1, f"Expected concurrent execution, max concurrent was {max_concurrent}"
 
 
-class TestInvokeStepCallback:
-    """Tests for _invoke_step_callback with sync and async callbacks."""
-
-    def test_invoke_step_callback_with_sync_callback(
-        self, executor: CrewAgentExecutor
-    ) -> None:
-        """Test that a sync step callback is called normally."""
-        callback = Mock()
-        executor.step_callback = callback
-        answer = AgentFinish(thought="thinking", output="test", text="final")
-
-        executor._invoke_step_callback(answer)
-
-        callback.assert_called_once_with(answer)
-
-    def test_invoke_step_callback_with_async_callback(
-        self, executor: CrewAgentExecutor
-    ) -> None:
-        """Test that an async step callback is awaited via asyncio.run."""
-        async_callback = AsyncMock()
-        executor.step_callback = async_callback
-        answer = AgentFinish(thought="thinking", output="test", text="final")
-
-        with patch("crewai.agents.crew_agent_executor.asyncio.run") as mock_run:
-            executor._invoke_step_callback(answer)
-
-            async_callback.assert_called_once_with(answer)
-            mock_run.assert_called_once()
-
-    def test_invoke_step_callback_with_none(
-        self, executor: CrewAgentExecutor
-    ) -> None:
-        """Test that no error is raised when step_callback is None."""
-        executor.step_callback = None
-        answer = AgentFinish(thought="thinking", output="test", text="final")
-
-        # Should not raise
-        executor._invoke_step_callback(answer)
-
-
 class TestAsyncLLMResponseHelper:
     """Tests for aget_llm_response helper function."""
 

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/cli/authentication/test_auth_main.py

@@ -2,7 +2,7 @@ from datetime import datetime, timedelta
 from unittest.mock import MagicMock, call, patch
 
 import pytest
-import httpx
+import requests
 from crewai.cli.authentication.main import AuthenticationCommand
 from crewai.cli.constants import (
     CREWAI_ENTERPRISE_DEFAULT_OAUTH2_AUDIENCE,
@@ -220,7 +220,7 @@ class TestAuthenticationCommand:
         ]
         mock_console_print.assert_has_calls(expected_calls)
 
-    @patch("crewai.cli.authentication.main.httpx.post")
+    @patch("requests.post")
     def test_get_device_code(self, mock_post):
         mock_response = MagicMock()
         mock_response.json.return_value = {
@@ -256,7 +256,7 @@ class TestAuthenticationCommand:
             "verification_uri_complete": "https://example.com/auth",
         }
 
-    @patch("crewai.cli.authentication.main.httpx.post")
+    @patch("requests.post")
     @patch("crewai.cli.authentication.main.console.print")
     def test_poll_for_token_success(self, mock_console_print, mock_post):
         mock_response_success = MagicMock()
@@ -305,7 +305,7 @@ class TestAuthenticationCommand:
             ]
             mock_console_print.assert_has_calls(expected_calls)
 
-    @patch("crewai.cli.authentication.main.httpx.post")
+    @patch("requests.post")
     @patch("crewai.cli.authentication.main.console.print")
     def test_poll_for_token_timeout(self, mock_console_print, mock_post):
         mock_response_pending = MagicMock()
@@ -324,7 +324,7 @@ class TestAuthenticationCommand:
             "Timeout: Failed to get the token. Please try again.", style="bold red"
         )
 
-    @patch("crewai.cli.authentication.main.httpx.post")
+    @patch("requests.post")
     def test_poll_for_token_error(self, mock_post):
         """Test the method to poll for token (error path)."""
         # Setup mock to return error
@@ -338,5 +338,5 @@ class TestAuthenticationCommand:
 
         device_code_data = {"device_code": "test_device_code", "interval": 1}
 
-        with pytest.raises(httpx.HTTPError):
+        with pytest.raises(requests.HTTPError):
             self.auth_command._poll_for_token(device_code_data)

lib/crewai/tests/cli/deploy/test_deploy_main.py

@@ -4,11 +4,10 @@ from io import StringIO
 from unittest.mock import MagicMock, Mock, patch
 
 import pytest
-import json
-
-import httpx
+import requests
 from crewai.cli.deploy.main import DeployCommand
 from crewai.cli.utils import parse_toml
+from requests.exceptions import JSONDecodeError
 
 
 class TestDeployCommand(unittest.TestCase):
@@ -38,18 +37,18 @@ class TestDeployCommand(unittest.TestCase):
             DeployCommand()
 
     def test_validate_response_successful_response(self):
-        mock_response = Mock(spec=httpx.Response)
+        mock_response = Mock(spec=requests.Response)
         mock_response.json.return_value = {"message": "Success"}
         mock_response.status_code = 200
-        mock_response.is_success = True
+        mock_response.ok = True
 
         with patch("sys.stdout", new=StringIO()) as fake_out:
             self.deploy_command._validate_response(mock_response)
             assert fake_out.getvalue() == ""
 
     def test_validate_response_json_decode_error(self):
-        mock_response = Mock(spec=httpx.Response)
-        mock_response.json.side_effect = json.JSONDecodeError("Decode error", "", 0)
+        mock_response = Mock(spec=requests.Response)
+        mock_response.json.side_effect = JSONDecodeError("Decode error", "", 0)
         mock_response.status_code = 500
         mock_response.content = b"Invalid JSON"
 
@@ -65,13 +64,13 @@ class TestDeployCommand(unittest.TestCase):
             assert "Response:\nInvalid JSON" in output
 
     def test_validate_response_422_error(self):
-        mock_response = Mock(spec=httpx.Response)
+        mock_response = Mock(spec=requests.Response)
         mock_response.json.return_value = {
             "field1": ["Error message 1"],
             "field2": ["Error message 2"],
         }
         mock_response.status_code = 422
-        mock_response.is_success = False
+        mock_response.ok = False
 
         with patch("sys.stdout", new=StringIO()) as fake_out:
             with pytest.raises(SystemExit):
@@ -85,10 +84,10 @@ class TestDeployCommand(unittest.TestCase):
             assert "Field2 Error message 2" in output
 
     def test_validate_response_other_error(self):
-        mock_response = Mock(spec=httpx.Response)
+        mock_response = Mock(spec=requests.Response)
         mock_response.json.return_value = {"error": "Something went wrong"}
         mock_response.status_code = 500
-        mock_response.is_success = False
+        mock_response.ok = False
 
         with patch("sys.stdout", new=StringIO()) as fake_out:
             with pytest.raises(SystemExit):

lib/crewai/tests/cli/enterprise/test_main.py

@@ -3,9 +3,8 @@ import unittest
 from pathlib import Path
 from unittest.mock import Mock, patch
 
-import json
-
-import httpx
+import requests
+from requests.exceptions import JSONDecodeError
 
 from crewai.cli.enterprise.main import EnterpriseConfigureCommand
 from crewai.cli.settings.main import SettingsCommand
@@ -26,7 +25,7 @@ class TestEnterpriseConfigureCommand(unittest.TestCase):
     def tearDown(self):
         shutil.rmtree(self.test_dir)
 
-    @patch('crewai.cli.enterprise.main.httpx.get')
+    @patch('crewai.cli.enterprise.main.requests.get')
     @patch('crewai.cli.enterprise.main.get_crewai_version')
     def test_successful_configuration(self, mock_get_version, mock_requests_get):
         mock_get_version.return_value = "1.0.0"
@@ -74,23 +73,19 @@ class TestEnterpriseConfigureCommand(unittest.TestCase):
             self.assertEqual(call_args[0], key)
             self.assertEqual(call_args[1], value)
 
-    @patch('crewai.cli.enterprise.main.httpx.get')
+    @patch('crewai.cli.enterprise.main.requests.get')
     @patch('crewai.cli.enterprise.main.get_crewai_version')
     def test_http_error_handling(self, mock_get_version, mock_requests_get):
         mock_get_version.return_value = "1.0.0"
 
         mock_response = Mock()
-        mock_response.raise_for_status.side_effect = httpx.HTTPStatusError(
-            "404 Not Found",
-            request=httpx.Request("GET", "http://test"),
-            response=httpx.Response(404),
-        )
+        mock_response.raise_for_status.side_effect = requests.HTTPError("404 Not Found")
         mock_requests_get.return_value = mock_response
 
         with self.assertRaises(SystemExit):
             self.enterprise_command.configure("https://enterprise.example.com")
 
-    @patch('crewai.cli.enterprise.main.httpx.get')
+    @patch('crewai.cli.enterprise.main.requests.get')
     @patch('crewai.cli.enterprise.main.get_crewai_version')
     def test_invalid_json_response(self, mock_get_version, mock_requests_get):
         mock_get_version.return_value = "1.0.0"
@@ -98,13 +93,13 @@ class TestEnterpriseConfigureCommand(unittest.TestCase):
         mock_response = Mock()
         mock_response.status_code = 200
         mock_response.raise_for_status.return_value = None
-        mock_response.json.side_effect = json.JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
         mock_requests_get.return_value = mock_response
 
         with self.assertRaises(SystemExit):
             self.enterprise_command.configure("https://enterprise.example.com")
 
-    @patch('crewai.cli.enterprise.main.httpx.get')
+    @patch('crewai.cli.enterprise.main.requests.get')
     @patch('crewai.cli.enterprise.main.get_crewai_version')
     def test_missing_required_fields(self, mock_get_version, mock_requests_get):
         mock_get_version.return_value = "1.0.0"
@@ -120,7 +115,7 @@ class TestEnterpriseConfigureCommand(unittest.TestCase):
         with self.assertRaises(SystemExit):
             self.enterprise_command.configure("https://enterprise.example.com")
 
-    @patch('crewai.cli.enterprise.main.httpx.get')
+    @patch('crewai.cli.enterprise.main.requests.get')
     @patch('crewai.cli.enterprise.main.get_crewai_version')
     def test_settings_update_error(self, mock_get_version, mock_requests_get):
         mock_get_version.return_value = "1.0.0"

lib/crewai/tests/cli/organization/test_main.py

@@ -3,7 +3,7 @@ from unittest.mock import MagicMock, patch, call
 
 import pytest
 from click.testing import CliRunner
-import httpx
+import requests
 
 from crewai.cli.organization.main import OrganizationCommand
 from crewai.cli.cli import org_list, switch, current
@@ -115,7 +115,7 @@ class TestOrganizationCommand(unittest.TestCase):
     def test_list_organizations_api_error(self, mock_console):
         self.org_command.plus_api_client = MagicMock()
         self.org_command.plus_api_client.get_organizations.side_effect = (
-            httpx.HTTPError("API Error")
+            requests.exceptions.RequestException("API Error")
         )
 
         with pytest.raises(SystemExit):
@@ -201,10 +201,8 @@ class TestOrganizationCommand(unittest.TestCase):
     @patch("crewai.cli.organization.main.console")
     def test_list_organizations_unauthorized(self, mock_console):
         mock_response = MagicMock()
-        mock_http_error = httpx.HTTPStatusError(
-            "401 Client Error: Unauthorized",
-            request=httpx.Request("GET", "http://test"),
-            response=httpx.Response(401),
+        mock_http_error = requests.exceptions.HTTPError(
+            "401 Client Error: Unauthorized", response=MagicMock(status_code=401)
         )
 
         mock_response.raise_for_status.side_effect = mock_http_error
@@ -221,10 +219,8 @@ class TestOrganizationCommand(unittest.TestCase):
     @patch("crewai.cli.organization.main.console")
     def test_switch_organization_unauthorized(self, mock_console):
         mock_response = MagicMock()
-        mock_http_error = httpx.HTTPStatusError(
-            "401 Client Error: Unauthorized",
-            request=httpx.Request("GET", "http://test"),
-            response=httpx.Response(401),
+        mock_http_error = requests.exceptions.HTTPError(
+            "401 Client Error: Unauthorized", response=MagicMock(status_code=401)
         )
 
         mock_response.raise_for_status.side_effect = mock_http_error

lib/crewai/tests/cli/test_plus_api.py

@@ -33,9 +33,9 @@ class TestPlusAPI(unittest.TestCase):
         self.assertEqual(response, mock_response)
 
     def assert_request_with_org_id(
-        self, mock_client_instance, method: str, endpoint: str, **kwargs
+        self, mock_make_request, method: str, endpoint: str, **kwargs
     ):
-        mock_client_instance.request.assert_called_once_with(
+        mock_make_request.assert_called_once_with(
             method,
             f"{os.getenv('CREWAI_PLUS_URL')}{endpoint}",
             headers={
@@ -49,25 +49,24 @@ class TestPlusAPI(unittest.TestCase):
         )
 
     @patch("crewai.cli.plus_api.Settings")
-    @patch("crewai.cli.plus_api.httpx.Client")
+    @patch("requests.Session.request")
     def test_login_to_tool_repository_with_org_uuid(
-        self, mock_client_class, mock_settings_class
+        self, mock_make_request, mock_settings_class
     ):
         mock_settings = MagicMock()
         mock_settings.org_uuid = self.org_uuid
         mock_settings.enterprise_base_url = os.getenv('CREWAI_PLUS_URL')
         mock_settings_class.return_value = mock_settings
+        # re-initialize Client
         self.api = PlusAPI(self.api_key)
 
-        mock_client_instance = MagicMock()
         mock_response = MagicMock()
-        mock_client_instance.request.return_value = mock_response
-        mock_client_class.return_value.__enter__.return_value = mock_client_instance
+        mock_make_request.return_value = mock_response
 
         response = self.api.login_to_tool_repository()
 
         self.assert_request_with_org_id(
-            mock_client_instance, "POST", "/crewai_plus/api/v1/tools/login"
+            mock_make_request, "POST", "/crewai_plus/api/v1/tools/login"
         )
         self.assertEqual(response, mock_response)
 
@@ -83,23 +82,23 @@ class TestPlusAPI(unittest.TestCase):
         self.assertEqual(response, mock_response)
 
     @patch("crewai.cli.plus_api.Settings")
-    @patch("crewai.cli.plus_api.httpx.Client")
-    def test_get_tool_with_org_uuid(self, mock_client_class, mock_settings_class):
+    @patch("requests.Session.request")
+    def test_get_tool_with_org_uuid(self, mock_make_request, mock_settings_class):
         mock_settings = MagicMock()
         mock_settings.org_uuid = self.org_uuid
         mock_settings.enterprise_base_url = os.getenv('CREWAI_PLUS_URL')
         mock_settings_class.return_value = mock_settings
+        # re-initialize Client
         self.api = PlusAPI(self.api_key)
 
-        mock_client_instance = MagicMock()
+        # Set up mock response
         mock_response = MagicMock()
-        mock_client_instance.request.return_value = mock_response
-        mock_client_class.return_value.__enter__.return_value = mock_client_instance
+        mock_make_request.return_value = mock_response
 
         response = self.api.get_tool("test_tool_handle")
 
         self.assert_request_with_org_id(
-            mock_client_instance, "GET", "/crewai_plus/api/v1/tools/test_tool_handle"
+            mock_make_request, "GET", "/crewai_plus/api/v1/tools/test_tool_handle"
         )
         self.assertEqual(response, mock_response)
 
@@ -131,18 +130,18 @@ class TestPlusAPI(unittest.TestCase):
         self.assertEqual(response, mock_response)
 
     @patch("crewai.cli.plus_api.Settings")
-    @patch("crewai.cli.plus_api.httpx.Client")
-    def test_publish_tool_with_org_uuid(self, mock_client_class, mock_settings_class):
+    @patch("requests.Session.request")
+    def test_publish_tool_with_org_uuid(self, mock_make_request, mock_settings_class):
         mock_settings = MagicMock()
         mock_settings.org_uuid = self.org_uuid
         mock_settings.enterprise_base_url = os.getenv('CREWAI_PLUS_URL')
         mock_settings_class.return_value = mock_settings
+        # re-initialize Client
         self.api = PlusAPI(self.api_key)
 
-        mock_client_instance = MagicMock()
+        # Set up mock response
         mock_response = MagicMock()
-        mock_client_instance.request.return_value = mock_response
-        mock_client_class.return_value.__enter__.return_value = mock_client_instance
+        mock_make_request.return_value = mock_response
 
         handle = "test_tool_handle"
         public = True
@@ -154,6 +153,7 @@ class TestPlusAPI(unittest.TestCase):
             handle, public, version, description, encoded_file
         )
 
+        # Expected params including organization_uuid
         expected_params = {
             "handle": handle,
             "public": public,
@@ -164,7 +164,7 @@ class TestPlusAPI(unittest.TestCase):
         }
 
         self.assert_request_with_org_id(
-            mock_client_instance, "POST", "/crewai_plus/api/v1/tools", json=expected_params
+            mock_make_request, "POST", "/crewai_plus/api/v1/tools", json=expected_params
         )
         self.assertEqual(response, mock_response)
 
@@ -195,19 +195,20 @@ class TestPlusAPI(unittest.TestCase):
         )
         self.assertEqual(response, mock_response)
 
-    @patch("crewai.cli.plus_api.httpx.Client")
-    def test_make_request(self, mock_client_class):
-        mock_client_instance = MagicMock()
+    @patch("crewai.cli.plus_api.requests.Session")
+    def test_make_request(self, mock_session):
         mock_response = MagicMock()
-        mock_client_instance.request.return_value = mock_response
-        mock_client_class.return_value.__enter__.return_value = mock_client_instance
+
+        mock_session_instance = mock_session.return_value
+        mock_session_instance.request.return_value = mock_response
 
         response = self.api._make_request("GET", "test_endpoint")
 
-        mock_client_class.assert_called_once_with(trust_env=False, verify=True)
-        mock_client_instance.request.assert_called_once_with(
+        mock_session.assert_called_once()
+        mock_session_instance.request.assert_called_once_with(
             "GET", f"{self.api.base_url}/test_endpoint", headers=self.api.headers
         )
+        mock_session_instance.trust_env = False
         self.assertEqual(response, mock_response)
 
     @patch("crewai.cli.plus_api.PlusAPI._make_request")

lib/crewai/tests/cli/tools/test_main.py

@@ -351,7 +351,7 @@ def test_publish_api_error(
     mock_response = MagicMock()
     mock_response.status_code = 500
     mock_response.json.return_value = {"error": "Internal Server Error"}
-    mock_response.is_success = False
+    mock_response.ok = False
     mock_publish.return_value = mock_response
 
     with raises(SystemExit):

lib/crewai/tests/cli/triggers/test_main.py

@@ -3,7 +3,7 @@ import subprocess
 import unittest
 from unittest.mock import Mock, patch
 
-import httpx
+import requests
 from crewai.cli.triggers.main import TriggersCommand
 
 
@@ -21,7 +21,7 @@ class TestTriggersCommand(unittest.TestCase):
 
     @patch("crewai.cli.triggers.main.console.print")
     def test_list_triggers_success(self, mock_console_print):
-        mock_response = Mock(spec=httpx.Response)
+        mock_response = Mock(spec=requests.Response)
         mock_response.status_code = 200
         mock_response.ok = True
         mock_response.json.return_value = {
@@ -50,7 +50,7 @@ class TestTriggersCommand(unittest.TestCase):
 
     @patch("crewai.cli.triggers.main.console.print")
     def test_list_triggers_no_apps(self, mock_console_print):
-        mock_response = Mock(spec=httpx.Response)
+        mock_response = Mock(spec=requests.Response)
         mock_response.status_code = 200
         mock_response.ok = True
         mock_response.json.return_value = {"apps": []}
@@ -81,7 +81,7 @@ class TestTriggersCommand(unittest.TestCase):
     @patch("crewai.cli.triggers.main.console.print")
     @patch.object(TriggersCommand, "_run_crew_with_payload")
     def test_execute_with_trigger_success(self, mock_run_crew, mock_console_print):
-        mock_response = Mock(spec=httpx.Response)
+        mock_response = Mock(spec=requests.Response)
         mock_response.status_code = 200
         mock_response.ok = True
         mock_response.json.return_value = {
@@ -99,7 +99,7 @@ class TestTriggersCommand(unittest.TestCase):
 
     @patch("crewai.cli.triggers.main.console.print")
     def test_execute_with_trigger_not_found(self, mock_console_print):
-        mock_response = Mock(spec=httpx.Response)
+        mock_response = Mock(spec=requests.Response)
         mock_response.status_code = 404
         mock_response.json.return_value = {"error": "Trigger not found"}
         self.mock_client.get_trigger_payload.return_value = mock_response
@@ -159,7 +159,7 @@ class TestTriggersCommand(unittest.TestCase):
 
     @patch("crewai.cli.triggers.main.console.print")
     def test_execute_with_trigger_with_default_error_message(self, mock_console_print):
-        mock_response = Mock(spec=httpx.Response)
+        mock_response = Mock(spec=requests.Response)
         mock_response.status_code = 404
         mock_response.json.return_value = {}
         self.mock_client.get_trigger_payload.return_value = mock_response

lib/crewai/tests/llms/bedrock/test_bedrock.py

@@ -437,36 +437,17 @@ def test_bedrock_aws_credentials_configuration():
     """
     Test that AWS credentials configuration works properly
     """
-    aws_access_key_id = "test-access-key"
-    aws_secret_access_key = "test-secret-key"
-    aws_region_name = "us-east-1"
-
-
     # Test with environment variables
     with patch.dict(os.environ, {
-        "AWS_ACCESS_KEY_ID": aws_access_key_id,
-        "AWS_SECRET_ACCESS_KEY": aws_secret_access_key,
-        "AWS_DEFAULT_REGION": aws_region_name
+        "AWS_ACCESS_KEY_ID": "test-access-key",
+        "AWS_SECRET_ACCESS_KEY": "test-secret-key",
+        "AWS_DEFAULT_REGION": "us-east-1"
     }):
         llm = LLM(model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0")
 
         from crewai.llms.providers.bedrock.completion import BedrockCompletion
         assert isinstance(llm, BedrockCompletion)
-        assert llm.region_name == aws_region_name
-        assert llm.aws_access_key_id == aws_access_key_id
-        assert llm.aws_secret_access_key == aws_secret_access_key
-
-      # Test with litellm environment variables
-    with patch.dict(os.environ, {
-        "AWS_ACCESS_KEY_ID": aws_access_key_id,
-        "AWS_SECRET_ACCESS_KEY": aws_secret_access_key,
-        "AWS_REGION_NAME": aws_region_name
-    }):
-        llm = LLM(model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0")
-
-        from crewai.llms.providers.bedrock.completion import BedrockCompletion
-        assert isinstance(llm, BedrockCompletion)
-        assert llm.region_name == aws_region_name
+        assert llm.region_name == "us-east-1"
 
     # Test with explicit credentials
     llm_explicit = LLM(

lib/crewai/tests/test_context.py

@@ -7,215 +7,139 @@ import pytest
 from crewai.context import (
     _platform_integration_token,
     get_platform_integration_token,
-    platform_context,
+    platform_integration_context,
+    reset_platform_integration_token,
     set_platform_integration_token,
 )
 
 
-class TestPlatformIntegrationToken:
-    def setup_method(self):
-        _platform_integration_token.set(None)
+@pytest.fixture
+def clean_context():
+    """Fixture to ensure clean context state for each test."""
+    _platform_integration_token.set(None)
+    yield
+    _platform_integration_token.set(None)
 
-    def teardown_method(self):
-        _platform_integration_token.set(None)
 
-    @patch.dict(os.environ, {}, clear=True)
-    def test_set_platform_integration_token(self):
+class TestContextVariableCore:
+    """Test core context variable functionality (set/get/reset)."""
+
+    def test_set_and_get_token(self, clean_context):
+        """Test basic token setting and retrieval."""
         test_token = "test-token-123"
 
         assert get_platform_integration_token() is None
 
-        set_platform_integration_token(test_token)
-
+        context_token = set_platform_integration_token(test_token)
         assert get_platform_integration_token() == test_token
+        assert context_token is not None
 
-    def test_get_platform_integration_token_from_context_var(self):
-        test_token = "context-var-token"
-
-        _platform_integration_token.set(test_token)
-
-        assert get_platform_integration_token() == test_token
-
-    @patch.dict(os.environ, {"CREWAI_PLATFORM_INTEGRATION_TOKEN": "env-token-456"})
-    def test_get_platform_integration_token_from_env_var(self):
-        assert _platform_integration_token.get() is None
-
-        assert get_platform_integration_token() == "env-token-456"
-
-    @patch.dict(os.environ, {"CREWAI_PLATFORM_INTEGRATION_TOKEN": "env-token"})
-    def test_context_var_takes_precedence_over_env_var(self):
-        context_token = "context-token"
-
-        set_platform_integration_token(context_token)
-
-        assert get_platform_integration_token() == context_token
-
-    @patch.dict(os.environ, {}, clear=True)
-    def test_get_platform_integration_token_returns_none_when_not_set(self):
-        assert _platform_integration_token.get() is None
-
-        assert get_platform_integration_token() is None
-
-    @patch.dict(os.environ, {}, clear=True)
-    def test_platform_context_manager_basic_usage(self):
-        test_token = "context-manager-token"
-
-        assert get_platform_integration_token() is None
-
-        with platform_context(test_token):
-            assert get_platform_integration_token() == test_token
-
-        assert get_platform_integration_token() is None
-
-    @patch.dict(os.environ, {}, clear=True)
-    def test_platform_context_manager_nested_contexts(self):
-        """Test nested platform_context context managers."""
-        outer_token = "outer-token"
-        inner_token = "inner-token"
-
-        assert get_platform_integration_token() is None
-
-        with platform_context(outer_token):
-            assert get_platform_integration_token() == outer_token
-
-            with platform_context(inner_token):
-                assert get_platform_integration_token() == inner_token
-
-            assert get_platform_integration_token() == outer_token
-
-        assert get_platform_integration_token() is None
-
-    def test_platform_context_manager_preserves_existing_token(self):
-        """Test that platform_context preserves existing token when exiting."""
-        initial_token = "initial-token"
-        context_token = "context-token"
-
-        set_platform_integration_token(initial_token)
-        assert get_platform_integration_token() == initial_token
-
-        with platform_context(context_token):
-            assert get_platform_integration_token() == context_token
-
-        assert get_platform_integration_token() == initial_token
-
-    def test_platform_context_manager_exception_handling(self):
-        """Test that platform_context properly resets token even when exception occurs."""
-        initial_token = "initial-token"
-        context_token = "context-token"
-
-        set_platform_integration_token(initial_token)
-
-        with pytest.raises(ValueError):
-            with platform_context(context_token):
-                assert get_platform_integration_token() == context_token
-                raise ValueError("Test exception")
-
-        assert get_platform_integration_token() == initial_token
-
-    @patch.dict(os.environ, {}, clear=True)
-    def test_platform_context_manager_with_none_initial_state(self):
-        """Test platform_context when initial state is None."""
-        context_token = "context-token"
-
-        assert get_platform_integration_token() is None
-
-        with pytest.raises(RuntimeError):
-            with platform_context(context_token):
-                assert get_platform_integration_token() == context_token
-                raise RuntimeError("Test exception")
-
-        assert get_platform_integration_token() is None
-
-    @patch.dict(os.environ, {"CREWAI_PLATFORM_INTEGRATION_TOKEN": "env-backup"})
-    def test_platform_context_with_env_fallback(self):
-        """Test platform_context interaction with environment variable fallback."""
-        context_token = "context-token"
-
-        assert get_platform_integration_token() == "env-backup"
-
-        with platform_context(context_token):
-            assert get_platform_integration_token() == context_token
-
-        assert get_platform_integration_token() == "env-backup"
-
-    @patch.dict(os.environ, {}, clear=True)
-    def test_multiple_sequential_context_managers(self):
-        """Test multiple sequential uses of platform_context."""
+    def test_reset_token_restores_previous_state(self, clean_context):
+        """Test that reset properly restores previous context state."""
         token1 = "token-1"
         token2 = "token-2"
-        token3 = "token-3"
 
-        with platform_context(token1):
-            assert get_platform_integration_token() == token1
+        context_token1 = set_platform_integration_token(token1)
+        assert get_platform_integration_token() == token1
+
+        context_token2 = set_platform_integration_token(token2)
+        assert get_platform_integration_token() == token2
+
+        reset_platform_integration_token(context_token2)
+        assert get_platform_integration_token() == token1
+
+        reset_platform_integration_token(context_token1)
+        assert get_platform_integration_token() is None
+
+    def test_nested_token_management(self, clean_context):
+        """Test proper token management with deeply nested contexts."""
+        tokens = ["token-1", "token-2", "token-3"]
+        context_tokens = []
+
+        for token in tokens:
+            context_tokens.append(set_platform_integration_token(token))
+            assert get_platform_integration_token() == token
+
+        for i in range(len(tokens) - 1, 0, -1):
+            reset_platform_integration_token(context_tokens[i])
+            assert get_platform_integration_token() == tokens[i - 1]
+
+        reset_platform_integration_token(context_tokens[0])
+        assert get_platform_integration_token() is None
+
+    @patch.dict(os.environ, {"CREWAI_PLATFORM_INTEGRATION_TOKEN": "env-token"})
+    def test_context_module_ignores_environment_variables(self, clean_context):
+        """Test that context module only returns context values, not env vars."""
+        # Context module should not read environment variables
+        assert get_platform_integration_token() is None
+
+        # Only context variable should be returned
+        set_platform_integration_token("context-token")
+        assert get_platform_integration_token() == "context-token"
+
+
+class TestPlatformIntegrationContext:
+    """Test platform integration context manager behavior."""
+
+    def test_basic_context_manager_usage(self, clean_context):
+        """Test basic context manager functionality."""
+        test_token = "context-token"
 
         assert get_platform_integration_token() is None
 
-        with platform_context(token2):
-            assert get_platform_integration_token() == token2
-
-        assert get_platform_integration_token() is None
-
-        with platform_context(token3):
-            assert get_platform_integration_token() == token3
-
-        assert get_platform_integration_token() is None
-
-    def test_empty_string_token(self):
-        empty_token = ""
-
-        set_platform_integration_token(empty_token)
-        assert get_platform_integration_token() == ""
-
-        with platform_context(empty_token):
-            assert get_platform_integration_token() == ""
-
-    def test_special_characters_in_token(self):
-        special_token = "token-with-!@#$%^&*()_+-={}[]|\\:;\"'<>?,./"
-
-        set_platform_integration_token(special_token)
-        assert get_platform_integration_token() == special_token
-
-        with platform_context(special_token):
-            assert get_platform_integration_token() == special_token
-
-    def test_very_long_token(self):
-        long_token = "a" * 10000
-
-        set_platform_integration_token(long_token)
-        assert get_platform_integration_token() == long_token
-
-        with platform_context(long_token):
-            assert get_platform_integration_token() == long_token
-
-    @patch.dict(os.environ, {"CREWAI_PLATFORM_INTEGRATION_TOKEN": ""})
-    def test_empty_env_var(self):
-        assert _platform_integration_token.get() is None
-        assert get_platform_integration_token() == ""
-
-    @patch("crewai.context.os.getenv")
-    def test_env_var_access_error_handling(self, mock_getenv):
-        mock_getenv.side_effect = OSError("Environment access error")
-
-        with pytest.raises(OSError):
-            get_platform_integration_token()
-
-    @patch.dict(os.environ, {}, clear=True)
-    def test_context_var_isolation_between_tests(self):
-        """Test that context variable changes don't leak between test methods."""
-        test_token = "isolation-test-token"
-
-        assert get_platform_integration_token() is None
-
-        set_platform_integration_token(test_token)
-        assert get_platform_integration_token() == test_token
-
-    def test_context_manager_return_value(self):
-        """Test that platform_context can be used in with statement with return value."""
-        test_token = "return-value-token"
-
-        with platform_context(test_token):
+        with platform_integration_context(test_token):
             assert get_platform_integration_token() == test_token
 
-        with platform_context(test_token) as ctx:
-            assert ctx is None
-            assert get_platform_integration_token() == test_token
+        assert get_platform_integration_token() is None
+
+    @pytest.mark.parametrize("falsy_value", [None, "", False, 0])
+    def test_falsy_values_return_nullcontext(self, clean_context, falsy_value):
+        """Test that falsy values return nullcontext (no-op)."""
+        # Set initial token to verify nullcontext doesn't affect it
+        initial_token = "initial-token"
+        initial_context_token = set_platform_integration_token(initial_token)
+
+        try:
+            with platform_integration_context(falsy_value):
+                # Should preserve existing context (nullcontext behavior)
+                assert get_platform_integration_token() == initial_token
+
+            # Should still have initial token after nullcontext
+            assert get_platform_integration_token() == initial_token
+        finally:
+            reset_platform_integration_token(initial_context_token)
+
+    @pytest.mark.parametrize("truthy_value", ["token", "123", " ", "0"])
+    def test_truthy_values_create_context(self, clean_context, truthy_value):
+        """Test that truthy values create proper context."""
+        with platform_integration_context(truthy_value):
+            assert get_platform_integration_token() == truthy_value
+
+        # Should be cleaned up
+        assert get_platform_integration_token() is None
+
+    def test_context_preserves_existing_token(self, clean_context):
+        """Test that context manager preserves existing token when exiting."""
+        existing_token = "existing-token"
+        context_token = "context-token"
+
+        existing_context_token = set_platform_integration_token(existing_token)
+
+        try:
+            with platform_integration_context(context_token):
+                assert get_platform_integration_token() == context_token
+
+            assert get_platform_integration_token() == existing_token
+        finally:
+            reset_platform_integration_token(existing_context_token)
+
+    def test_context_manager_return_type(self, clean_context):
+        """Test that context manager returns proper types for both cases."""
+        # Both should be usable as context managers
+        valid_ctx = platform_integration_context("token")
+        none_ctx = platform_integration_context(None)
+
+        assert hasattr(valid_ctx, '__enter__')
+        assert hasattr(valid_ctx, '__exit__')
+        assert hasattr(none_ctx, '__enter__')
+        assert hasattr(none_ctx, '__exit__')

lib/crewai/tests/tools/test_base_tool.py

@@ -3,8 +3,6 @@ from typing import Callable
 from unittest.mock import patch
 
 import pytest
-from pydantic import BaseModel, Field
-
 from crewai.agent import Agent
 from crewai.crew import Crew
 from crewai.task import Task
@@ -232,204 +230,3 @@ def test_max_usage_count_is_respected():
     crew.kickoff()
     assert tool.max_usage_count == 5
     assert tool.current_usage_count == 5
-
-
-# =============================================================================
-# Schema Validation in run() Tests
-# =============================================================================
-
-
-class CodeExecutorInput(BaseModel):
-    code: str = Field(description="The code to execute")
-    language: str = Field(default="python", description="Programming language")
-
-
-class CodeExecutorTool(BaseTool):
-    name: str = "code_executor"
-    description: str = "Execute code snippets"
-    args_schema: type[BaseModel] = CodeExecutorInput
-
-    def _run(self, code: str, language: str = "python") -> str:
-        return f"Executed {language}: {code}"
-
-
-class TestBaseToolRunValidation:
-    """Tests for args_schema validation in BaseTool.run()."""
-
-    def test_run_with_valid_kwargs_passes_validation(self) -> None:
-        """Valid keyword arguments should pass schema validation and execute."""
-        t = CodeExecutorTool()
-        result = t.run(code="print('hello')")
-        assert result == "Executed python: print('hello')"
-
-    def test_run_with_all_kwargs_passes_validation(self) -> None:
-        """All keyword arguments including optional ones should pass."""
-        t = CodeExecutorTool()
-        result = t.run(code="console.log('hi')", language="javascript")
-        assert result == "Executed javascript: console.log('hi')"
-
-    def test_run_with_missing_required_kwarg_raises(self) -> None:
-        """Missing required kwargs should raise ValueError from schema validation."""
-        t = CodeExecutorTool()
-        with pytest.raises(ValueError, match="validation failed"):
-            t.run(language="python")
-
-    def test_run_with_wrong_field_name_raises(self) -> None:
-        """Kwargs not matching any schema field should trigger validation error
-        for missing required fields."""
-        t = CodeExecutorTool()
-        with pytest.raises(ValueError, match="validation failed"):
-            t.run(wrong_arg="value")
-
-    def test_run_with_positional_args_skips_validation(self) -> None:
-        """Positional-arg calls should bypass schema validation (backwards compat)."""
-        class SimpleTool(BaseTool):
-            name: str = "simple"
-            description: str = "A simple tool"
-
-            def _run(self, question: str) -> str:
-                return question
-
-        t = SimpleTool()
-        result = t.run("What is life?")
-        assert result == "What is life?"
-
-    def test_run_strips_extra_kwargs_from_llm(self) -> None:
-        """Extra kwargs not in the schema should be silently stripped,
-        preventing unexpected-keyword crashes in _run."""
-        t = CodeExecutorTool()
-        result = t.run(code="1+1", extra_hallucinated_field="junk")
-        assert result == "Executed python: 1+1"
-
-    def test_run_increments_usage_after_validation(self) -> None:
-        """Usage count should still increment after validated execution."""
-        t = CodeExecutorTool()
-        assert t.current_usage_count == 0
-        t.run(code="x = 1")
-        assert t.current_usage_count == 1
-
-    def test_run_does_not_increment_usage_on_validation_error(self) -> None:
-        """Usage count should NOT increment when validation fails."""
-        t = CodeExecutorTool()
-        assert t.current_usage_count == 0
-        with pytest.raises(ValueError):
-            t.run(wrong="bad")
-        assert t.current_usage_count == 0
-
-
-class TestToolDecoratorRunValidation:
-    """Tests for args_schema validation in Tool.run() (decorator-based tools)."""
-
-    def test_decorator_tool_run_validates_kwargs(self) -> None:
-        """Decorator-created tools should also validate kwargs against schema."""
-        @tool("execute_code")
-        def execute_code(code: str, language: str = "python") -> str:
-            """Execute a code snippet."""
-            return f"Executed {language}: {code}"
-
-        result = execute_code.run(code="x = 1")
-        assert result == "Executed python: x = 1"
-
-    def test_decorator_tool_run_rejects_missing_required(self) -> None:
-        """Decorator tools should reject missing required args via validation."""
-        @tool("execute_code")
-        def execute_code(code: str) -> str:
-            """Execute a code snippet."""
-            return f"Executed: {code}"
-
-        with pytest.raises(ValueError, match="validation failed"):
-            execute_code.run(wrong_arg="value")
-
-    def test_decorator_tool_positional_args_still_work(self) -> None:
-        """Positional args to decorator tools should bypass validation."""
-        @tool("greet")
-        def greet(name: str) -> str:
-            """Greet someone."""
-            return f"Hello, {name}!"
-
-        result = greet.run("World")
-        assert result == "Hello, World!"
-
-
-# =============================================================================
-# Async arun() Schema Validation Tests
-# =============================================================================
-
-
-class AsyncCodeExecutorTool(BaseTool):
-    name: str = "async_code_executor"
-    description: str = "Execute code snippets asynchronously"
-    args_schema: type[BaseModel] = CodeExecutorInput
-
-    async def _arun(self, code: str, language: str = "python") -> str:
-        return f"Async executed {language}: {code}"
-
-    def _run(self, code: str, language: str = "python") -> str:
-        return f"Executed {language}: {code}"
-
-
-class TestBaseToolArunValidation:
-    """Tests for args_schema validation in BaseTool.arun()."""
-
-    @pytest.mark.asyncio
-    async def test_arun_with_valid_kwargs_passes_validation(self) -> None:
-        """Valid keyword arguments should pass schema validation in arun."""
-        t = AsyncCodeExecutorTool()
-        result = await t.arun(code="print('hello')")
-        assert result == "Async executed python: print('hello')"
-
-    @pytest.mark.asyncio
-    async def test_arun_with_missing_required_kwarg_raises(self) -> None:
-        """Missing required kwargs should raise ValueError in arun."""
-        t = AsyncCodeExecutorTool()
-        with pytest.raises(ValueError, match="validation failed"):
-            await t.arun(language="python")
-
-    @pytest.mark.asyncio
-    async def test_arun_with_wrong_field_name_raises(self) -> None:
-        """Kwargs not matching schema fields should trigger validation error in arun."""
-        t = AsyncCodeExecutorTool()
-        with pytest.raises(ValueError, match="validation failed"):
-            await t.arun(wrong_arg="value")
-
-    @pytest.mark.asyncio
-    async def test_arun_strips_extra_kwargs(self) -> None:
-        """Extra kwargs not in the schema should be stripped in arun."""
-        t = AsyncCodeExecutorTool()
-        result = await t.arun(code="1+1", extra_field="junk")
-        assert result == "Async executed python: 1+1"
-
-    @pytest.mark.asyncio
-    async def test_arun_does_not_increment_usage_on_validation_error(self) -> None:
-        """Usage count should NOT increment when arun validation fails."""
-        t = AsyncCodeExecutorTool()
-        assert t.current_usage_count == 0
-        with pytest.raises(ValueError):
-            await t.arun(wrong="bad")
-        assert t.current_usage_count == 0
-
-
-class TestToolDecoratorArunValidation:
-    """Tests for args_schema validation in Tool.arun() (decorator-based async tools)."""
-
-    @pytest.mark.asyncio
-    async def test_async_decorator_tool_arun_validates_kwargs(self) -> None:
-        """Async decorator tools should validate kwargs in arun."""
-        @tool("async_execute")
-        async def async_execute(code: str, language: str = "python") -> str:
-            """Execute code asynchronously."""
-            return f"Async {language}: {code}"
-
-        result = await async_execute.arun(code="x = 1")
-        assert result == "Async python: x = 1"
-
-    @pytest.mark.asyncio
-    async def test_async_decorator_tool_arun_rejects_missing_required(self) -> None:
-        """Async decorator tools should reject missing required args in arun."""
-        @tool("async_execute")
-        async def async_execute(code: str) -> str:
-            """Execute code asynchronously."""
-            return f"Async: {code}"
-
-        with pytest.raises(ValueError, match="validation failed"):
-            await async_execute.arun(wrong_arg="value")

lib/crewai/tests/utilities/test_agent_utils.py

@@ -17,7 +17,6 @@ from crewai.utilities.agent_utils import (
     _format_messages_for_summary,
     _split_messages_into_chunks,
     convert_tools_to_openai_schema,
-    parse_tool_call_args,
     summarize_messages,
 )
 
@@ -923,56 +922,3 @@ class TestParallelSummarizationVCR:
         assert summary_msg["role"] == "user"
         assert "files" in summary_msg
         assert "report.pdf" in summary_msg["files"]
-
-
-class TestParseToolCallArgs:
-    """Unit tests for parse_tool_call_args."""
-
-    def test_valid_json_string_returns_dict(self) -> None:
-        args_dict, error = parse_tool_call_args('{"code": "print(1)"}', "run_code", "call_1")
-        assert error is None
-        assert args_dict == {"code": "print(1)"}
-
-    def test_malformed_json_returns_error_dict(self) -> None:
-        args_dict, error = parse_tool_call_args('{"code": "print("hi")"}', "run_code", "call_1")
-        assert args_dict is None
-        assert error is not None
-        assert error["call_id"] == "call_1"
-        assert error["func_name"] == "run_code"
-        assert error["from_cache"] is False
-        assert "Failed to parse tool arguments as JSON" in error["result"]
-        assert "run_code" in error["result"]
-
-    def test_malformed_json_preserves_original_tool(self) -> None:
-        mock_tool = object()
-        _, error = parse_tool_call_args("{bad}", "my_tool", "call_2", original_tool=mock_tool)
-        assert error is not None
-        assert error["original_tool"] is mock_tool
-
-    def test_malformed_json_original_tool_defaults_to_none(self) -> None:
-        _, error = parse_tool_call_args("{bad}", "my_tool", "call_3")
-        assert error is not None
-        assert error["original_tool"] is None
-
-    def test_dict_input_returned_directly(self) -> None:
-        func_args = {"code": "x = 42"}
-        args_dict, error = parse_tool_call_args(func_args, "run_code", "call_4")
-        assert error is None
-        assert args_dict == {"code": "x = 42"}
-
-    def test_empty_dict_input_returned_directly(self) -> None:
-        args_dict, error = parse_tool_call_args({}, "run_code", "call_5")
-        assert error is None
-        assert args_dict == {}
-
-    def test_valid_json_with_nested_values(self) -> None:
-        args_dict, error = parse_tool_call_args(
-            '{"query": "hello", "options": {"limit": 10}}', "search", "call_6"
-        )
-        assert error is None
-        assert args_dict == {"query": "hello", "options": {"limit": 10}}
-
-    def test_error_result_has_correct_keys(self) -> None:
-        _, error = parse_tool_call_args("{bad json}", "tool", "call_7")
-        assert error is not None
-        assert set(error.keys()) == {"call_id", "func_name", "result", "from_cache", "original_tool"}

lib/crewai/tests/utilities/test_llm_utils.py

@@ -81,7 +81,7 @@ def test_create_llm_from_env_with_unaccepted_attributes() -> None:
             "OPENAI_API_KEY": "fake-key",
             "AWS_ACCESS_KEY_ID": "fake-access-key",
             "AWS_SECRET_ACCESS_KEY": "fake-secret-key",
-            "AWS_DEFAULT_REGION": "us-west-2",
+            "AWS_REGION_NAME": "us-west-2",
         },
     ):
         llm = create_llm(llm_value=None)
@@ -89,7 +89,7 @@ def test_create_llm_from_env_with_unaccepted_attributes() -> None:
         assert llm.model == "gpt-3.5-turbo"
         assert not hasattr(llm, "AWS_ACCESS_KEY_ID")
         assert not hasattr(llm, "AWS_SECRET_ACCESS_KEY")
-        assert not hasattr(llm, "AWS_DEFAULT_REGION")
+        assert not hasattr(llm, "AWS_REGION_NAME")
 
 
 def test_create_llm_with_partial_attributes() -> None:

lib/devtools/src/crewai_devtools/cli.py

@@ -14,7 +14,7 @@ from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.prompt import Confirm
 
-from crewai_devtools.prompts import RELEASE_NOTES_PROMPT, TRANSLATE_RELEASE_NOTES_PROMPT
+from crewai_devtools.prompts import RELEASE_NOTES_PROMPT
 
 
 load_dotenv()
@@ -191,248 +191,6 @@ def update_pyproject_dependencies(file_path: Path, new_version: str) -> bool:
     return False
 
 
-def add_docs_version(docs_json_path: Path, version: str) -> bool:
-    """Add a new version to the Mintlify docs.json versioning config.
-
-    Copies the current default version's tabs into a new version entry,
-    sets the new version as default, and marks the previous default as
-    non-default. Operates on all languages.
-
-    Args:
-        docs_json_path: Path to docs/docs.json.
-        version: Version string (e.g., "1.10.0").
-
-    Returns:
-        True if docs.json was updated, False otherwise.
-    """
-    import json
-
-    if not docs_json_path.exists():
-        return False
-
-    data = json.loads(docs_json_path.read_text())
-    version_label = f"v{version}"
-    updated = False
-
-    for lang in data.get("navigation", {}).get("languages", []):
-        versions = lang.get("versions", [])
-        if not versions:
-            continue
-
-        # Skip if this version already exists for this language
-        if any(v.get("version") == version_label for v in versions):
-            continue
-
-        # Find the current default and copy its tabs
-        default_version = next(
-            (v for v in versions if v.get("default")),
-            versions[0],
-        )
-
-        new_version = {
-            "version": version_label,
-            "default": True,
-            "tabs": default_version.get("tabs", []),
-        }
-
-        # Remove default flag from old default
-        default_version.pop("default", None)
-
-        # Insert new version at the beginning
-        versions.insert(0, new_version)
-        updated = True
-
-    if not updated:
-        return False
-
-    docs_json_path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n")
-    return True
-
-
-_PT_BR_MONTHS = {
-    1: "jan",
-    2: "fev",
-    3: "mar",
-    4: "abr",
-    5: "mai",
-    6: "jun",
-    7: "jul",
-    8: "ago",
-    9: "set",
-    10: "out",
-    11: "nov",
-    12: "dez",
-}
-
-_CHANGELOG_LOCALES: dict[str, dict[str, str]] = {
-    "en": {
-        "link_text": "View release on GitHub",
-        "language_name": "English",
-    },
-    "pt-BR": {
-        "link_text": "Ver release no GitHub",
-        "language_name": "Brazilian Portuguese",
-    },
-    "ko": {
-        "link_text": "GitHub 릴리스 보기",
-        "language_name": "Korean",
-    },
-}
-
-
-def translate_release_notes(
-    release_notes: str,
-    lang: str,
-    client: OpenAI,
-) -> str:
-    """Translate release notes into the target language using OpenAI.
-
-    Args:
-        release_notes: English release notes markdown.
-        lang: Language code (e.g., "pt-BR", "ko").
-        client: OpenAI client instance.
-
-    Returns:
-        Translated release notes, or original on failure.
-    """
-    locale_cfg = _CHANGELOG_LOCALES.get(lang)
-    if not locale_cfg:
-        return release_notes
-
-    language_name = locale_cfg["language_name"]
-    prompt = TRANSLATE_RELEASE_NOTES_PROMPT.substitute(
-        language=language_name,
-        release_notes=release_notes,
-    )
-
-    try:
-        response = client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=[
-                {
-                    "role": "system",
-                    "content": f"You are a professional translator. Translate technical documentation into {language_name}.",
-                },
-                {"role": "user", "content": prompt},
-            ],
-            temperature=0.3,
-        )
-        return response.choices[0].message.content or release_notes
-    except Exception as e:
-        console.print(
-            f"[yellow]Warning:[/yellow] Could not translate to {language_name}: {e}"
-        )
-        return release_notes
-
-
-def _format_changelog_date(lang: str) -> str:
-    """Format today's date for a changelog entry in the given language."""
-    from datetime import datetime
-
-    now = datetime.now()
-    if lang == "ko":
-        return f"{now.year}년 {now.month}월 {now.day}일"
-    if lang == "pt-BR":
-        return f"{now.day:02d} {_PT_BR_MONTHS[now.month]} {now.year}"
-    return now.strftime("%b %d, %Y")
-
-
-def update_changelog(
-    changelog_path: Path,
-    version: str,
-    release_notes: str,
-    lang: str = "en",
-) -> bool:
-    """Prepend a new release entry to a docs changelog file.
-
-    Args:
-        changelog_path: Path to the changelog.mdx file.
-        version: Version string (e.g., "1.9.3").
-        release_notes: Markdown release notes content.
-        lang: Language code for localized date/link text.
-
-    Returns:
-        True if changelog was updated, False otherwise.
-    """
-    if not changelog_path.exists():
-        return False
-
-    locale_cfg = _CHANGELOG_LOCALES.get(lang, _CHANGELOG_LOCALES["en"])
-    date_label = _format_changelog_date(lang)
-    link_text = locale_cfg["link_text"]
-
-    # Indent each non-empty line with 2 spaces to match <Update> block format
-    indented_lines = []
-    for line in release_notes.splitlines():
-        if line.strip():
-            indented_lines.append(f"  {line}")
-        else:
-            indented_lines.append("")
-    indented_notes = "\n".join(indented_lines)
-
-    entry = (
-        f'<Update label="{date_label}">\n'
-        f"  ## v{version}\n"
-        f"\n"
-        f"  [{link_text}]"
-        f"(https://github.com/crewAIInc/crewAI/releases/tag/{version})\n"
-        f"\n"
-        f"{indented_notes}\n"
-        f"\n"
-        f"</Update>"
-    )
-
-    content = changelog_path.read_text()
-
-    # Insert after the frontmatter closing ---
-    parts = content.split("---", 2)
-    if len(parts) >= 3:
-        new_content = (
-            parts[0]
-            + "---"
-            + parts[1]
-            + "---\n"
-            + entry
-            + "\n\n"
-            + parts[2].lstrip("\n")
-        )
-    else:
-        new_content = entry + "\n\n" + content
-
-    changelog_path.write_text(new_content)
-    return True
-
-
-def update_template_dependencies(templates_dir: Path, new_version: str) -> list[Path]:
-    """Update crewai dependency versions in CLI template pyproject.toml files.
-
-    Handles both pinned (==) and minimum (>=) version specifiers,
-    as well as extras like [tools].
-
-    Args:
-        templates_dir: Path to the CLI templates directory.
-        new_version: New version string.
-
-    Returns:
-        List of paths that were updated.
-    """
-    import re
-
-    updated = []
-    for pyproject in templates_dir.rglob("pyproject.toml"):
-        content = pyproject.read_text()
-        new_content = re.sub(
-            r'"crewai(\[tools\])?(==|>=)[^"]*"',
-            lambda m: f'"crewai{(m.group(1) or "")!s}=={new_version}"',
-            content,
-        )
-        if new_content != content:
-            pyproject.write_text(new_content)
-            updated.append(pyproject)
-
-    return updated
-
-
 def find_version_files(base_path: Path) -> list[Path]:
     """Find all __init__.py files that contain __version__.
 
@@ -636,22 +394,6 @@ def bump(version: str, dry_run: bool, no_push: bool, no_commit: bool) -> None:
                 "[yellow]Warning:[/yellow] No __version__ attributes found to update"
             )
 
-        # Update CLI template pyproject.toml files
-        templates_dir = lib_dir / "crewai" / "src" / "crewai" / "cli" / "templates"
-        if templates_dir.exists():
-            if dry_run:
-                for tpl in templates_dir.rglob("pyproject.toml"):
-                    console.print(
-                        f"[dim][DRY RUN][/dim] Would update template: {tpl.relative_to(cwd)}"
-                    )
-            else:
-                tpl_updated = update_template_dependencies(templates_dir, version)
-                for tpl in tpl_updated:
-                    console.print(
-                        f"[green]✓[/green] Updated template: {tpl.relative_to(cwd)}"
-                    )
-                    updated_files.append(tpl)
-
         if not dry_run:
             console.print("\nSyncing workspace...")
             run_command(["uv", "sync"])
@@ -833,9 +575,9 @@ def tag(dry_run: bool, no_edit: bool) -> None:
 
             github_contributors = get_github_contributors(commit_range)
 
-            openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-
             if commits.strip():
+                client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
                 contributors_section = ""
                 if github_contributors:
                     contributors_section = f"\n\n## Contributors\n\n{', '.join([f'@{u}' for u in github_contributors])}"
@@ -846,7 +588,7 @@ def tag(dry_run: bool, no_edit: bool) -> None:
                     contributors_section=contributors_section,
                 )
 
-                response = openai_client.chat.completions.create(
+                response = client.chat.completions.create(
                     model="gpt-4o-mini",
                     messages=[
                         {
@@ -901,77 +643,6 @@ def tag(dry_run: bool, no_edit: bool) -> None:
                 "\n[green]✓[/green] Using generated release notes without editing"
             )
 
-        is_prerelease = any(
-            indicator in version.lower()
-            for indicator in ["a", "b", "rc", "alpha", "beta", "dev"]
-        )
-
-        # Update docs: changelogs + version switcher
-        docs_json_path = cwd / "docs" / "docs.json"
-        changelog_langs = ["en", "pt-BR", "ko"]
-        if not dry_run:
-            docs_files_staged = []
-
-            for lang in changelog_langs:
-                cl_path = cwd / "docs" / lang / "changelog.mdx"
-                if lang == "en":
-                    notes_for_lang = release_notes
-                else:
-                    console.print(f"[dim]Translating release notes to {lang}...[/dim]")
-                    notes_for_lang = translate_release_notes(
-                        release_notes, lang, openai_client
-                    )
-                if update_changelog(cl_path, version, notes_for_lang, lang=lang):
-                    console.print(
-                        f"[green]✓[/green] Updated {cl_path.relative_to(cwd)}"
-                    )
-                    docs_files_staged.append(str(cl_path))
-                else:
-                    console.print(
-                        f"[yellow]Warning:[/yellow] Changelog not found at {cl_path.relative_to(cwd)}"
-                    )
-
-            if not is_prerelease:
-                if add_docs_version(docs_json_path, version):
-                    console.print(
-                        f"[green]✓[/green] Added v{version} to docs version switcher"
-                    )
-                    docs_files_staged.append(str(docs_json_path))
-                else:
-                    console.print(
-                        f"[yellow]Warning:[/yellow] docs.json not found at {docs_json_path.relative_to(cwd)}"
-                    )
-
-            if docs_files_staged:
-                for f in docs_files_staged:
-                    run_command(["git", "add", f])
-                run_command(
-                    [
-                        "git",
-                        "commit",
-                        "-m",
-                        f"docs: update changelog and version for v{version}",
-                    ]
-                )
-                console.print("[green]✓[/green] Committed docs updates")
-                run_command(["git", "push"])
-                console.print("[green]✓[/green] Pushed docs updates")
-        else:
-            for lang in changelog_langs:
-                cl_path = cwd / "docs" / lang / "changelog.mdx"
-                translated = " (translated)" if lang != "en" else ""
-                console.print(
-                    f"[dim][DRY RUN][/dim] Would update {cl_path.relative_to(cwd)}{translated}"
-                )
-            if not is_prerelease:
-                console.print(
-                    f"[dim][DRY RUN][/dim] Would add v{version} to docs version switcher"
-                )
-            else:
-                console.print(
-                    "[dim][DRY RUN][/dim] Skipping docs version (pre-release)"
-                )
-
         if not dry_run:
             with console.status(f"[cyan]Creating tag {tag_name}..."):
                 try:
@@ -989,6 +660,11 @@ def tag(dry_run: bool, no_edit: bool) -> None:
                     sys.exit(1)
             console.print(f"[green]✓[/green] Pushed tag {tag_name}")
 
+            is_prerelease = any(
+                indicator in version.lower()
+                for indicator in ["a", "b", "rc", "alpha", "beta", "dev"]
+            )
+
             with console.status("[cyan]Creating GitHub Release..."):
                 try:
                     gh_cmd = [

lib/devtools/src/crewai_devtools/prompts.py

@@ -43,18 +43,3 @@ Instructions:
 
 Keep it professional and clear."""
 )
-
-
-TRANSLATE_RELEASE_NOTES_PROMPT = Template(
-    """Translate the following release notes into $language.
-
-$release_notes
-
-Instructions:
-- Translate all section headers and descriptions naturally
-- Keep markdown formatting (##, ###, -, etc.) exactly as-is
-- Keep all proper nouns, code identifiers, class names, and technical terms unchanged
-  (e.g. "CrewAI", "LiteAgent", "ChromaDB", "MCP", "@username")
-- Keep the ## Contributors section and GitHub usernames unchanged
-- Do not add or remove any content, only translate"""
-)

uv.lock

@@ -1096,7 +1096,6 @@ dependencies = [
     { name = "appdirs" },
     { name = "chromadb" },
     { name = "click" },
-    { name = "httpx" },
     { name = "instructor" },
     { name = "json-repair" },
     { name = "json5" },
@@ -1196,7 +1195,6 @@ requires-dist = [
     { name = "crewai-tools", marker = "extra == 'tools'", editable = "lib/crewai-tools" },
     { name = "docling", marker = "extra == 'docling'", specifier = "~=2.63.0" },
     { name = "google-genai", marker = "extra == 'google-genai'", specifier = "~=1.49.0" },
-    { name = "httpx", specifier = "~=0.28.1" },
     { name = "httpx-auth", marker = "extra == 'a2a'", specifier = "~=0.23.1" },
     { name = "httpx-sse", marker = "extra == 'a2a'", specifier = "~=0.4.0" },
     { name = "ibm-watsonx-ai", marker = "extra == 'watson'", specifier = "~=1.3.39" },
@@ -1471,48 +1469,48 @@ provides-extras = ["apify", "beautifulsoup4", "bedrock", "browserbase", "composi
 
 [[package]]
 name = "cryptography"
-version = "46.0.5"
+version = "46.0.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/19/f748958276519adf6a0c1e79e7b8860b4830dda55ccdf29f2719b5fc499c/cryptography-46.0.4.tar.gz", hash = "sha256:bfd019f60f8abc2ed1b9be4ddc21cfef059c841d86d710bb69909a688cbb8f59", size = 749301, upload-time = "2026-01-28T00:24:37.379Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/81/b0bb27f2ba931a65409c6b8a8b358a7f03c0e46eceacddff55f7c84b1f3b/cryptography-46.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad", size = 7176289, upload-time = "2026-02-10T19:17:08.274Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" },
-    { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" },
-    { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" },
-    { url = "https://files.pythonhosted.org/packages/22/29/c2e812ebc38c57b40e7c583895e73c8c5adb4d1e4a0cc4c5a4fdab2b1acc/cryptography-46.0.5-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d", size = 4947993, upload-time = "2026-02-10T19:17:15.618Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" },
-    { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/36/45e76c68d7311432741faf1fbf7fac8a196a0a735ca21f504c75d37e2558/cryptography-46.0.5-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0", size = 4912181, upload-time = "2026-02-10T19:17:21.825Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/ed/325d2a490c5e94038cdb0117da9397ece1f11201f425c4e9c57fe5b9f08b/cryptography-46.0.5-cp311-abi3-win32.whl", hash = "sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48", size = 3028230, upload-time = "2026-02-10T19:17:30.518Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/5a/ac0f49e48063ab4255d9e3b79f5def51697fce1a95ea1370f03dc9db76f6/cryptography-46.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4", size = 3480909, upload-time = "2026-02-10T19:17:32.083Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/fa/a66aa722105ad6a458bebd64086ca2b72cdd361fed31763d20390f6f1389/cryptography-46.0.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31", size = 7170514, upload-time = "2026-02-10T19:17:56.267Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/7c/c4f45e0eeff9b91e3f12dbd0e165fcf2a38847288fcfd889deea99fb7b6d/cryptography-46.0.5-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76", size = 4939143, upload-time = "2026-02-10T19:18:03.964Z" },
-    { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" },
-    { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" },
-    { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" },
-    { url = "https://files.pythonhosted.org/packages/33/45/726809d1176959f4a896b86907b98ff4391a8aa29c0aaaf9450a8a10630e/cryptography-46.0.5-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d", size = 4901539, upload-time = "2026-02-10T19:18:11.263Z" },
-    { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" },
-    { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" },
-    { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" },
-    { url = "https://files.pythonhosted.org/packages/45/2d/9c5f2926cb5300a8eefc3f4f0b3f3df39db7f7ce40c8365444c49363cbda/cryptography-46.0.5-cp38-abi3-win32.whl", hash = "sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72", size = 3010220, upload-time = "2026-02-10T19:18:17.361Z" },
-    { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/dd/2d9fdb07cebdf3d51179730afb7d5e576153c6744c3ff8fded23030c204e/cryptography-46.0.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:3b4995dc971c9fb83c25aa44cf45f02ba86f71ee600d81091c2f0cbae116b06c", size = 3476964, upload-time = "2026-02-10T19:18:20.687Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/6f/6cc6cc9955caa6eaf83660b0da2b077c7fe8ff9950a3c5e45d605038d439/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bc84e875994c3b445871ea7181d424588171efec3e185dced958dad9e001950a", size = 4218321, upload-time = "2026-02-10T19:18:22.349Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/5d/c4da701939eeee699566a6c1367427ab91a8b7088cc2328c09dbee940415/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:2ae6971afd6246710480e3f15824ed3029a60fc16991db250034efd0b9fb4356", size = 4381786, upload-time = "2026-02-10T19:18:24.529Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/97/a538654732974a94ff96c1db621fa464f455c02d4bb7d2652f4edc21d600/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d861ee9e76ace6cf36a6a89b959ec08e7bc2493ee39d07ffe5acb23ef46d27da", size = 4217990, upload-time = "2026-02-10T19:18:25.957Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/11/7e500d2dd3ba891197b9efd2da5454b74336d64a7cc419aa7327ab74e5f6/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:2b7a67c9cd56372f3249b39699f2ad479f6991e62ea15800973b956f4b73e257", size = 4381252, upload-time = "2026-02-10T19:18:27.496Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/58/6b3d24e6b9bc474a2dcdee65dfd1f008867015408a271562e4b690561a4d/cryptography-46.0.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8456928655f856c6e1533ff59d5be76578a7157224dbd9ce6872f25055ab9ab7", size = 3407605, upload-time = "2026-02-10T19:18:29.233Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/99/157aae7949a5f30d51fcb1a9851e8ebd5c74bf99b5285d8bb4b8b9ee641e/cryptography-46.0.4-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:281526e865ed4166009e235afadf3a4c4cba6056f99336a99efba65336fd5485", size = 7173686, upload-time = "2026-01-28T00:23:07.515Z" },
+    { url = "https://files.pythonhosted.org/packages/87/91/874b8910903159043b5c6a123b7e79c4559ddd1896e38967567942635778/cryptography-46.0.4-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5f14fba5bf6f4390d7ff8f086c566454bff0411f6d8aa7af79c88b6f9267aecc", size = 4275871, upload-time = "2026-01-28T00:23:09.439Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/35/690e809be77896111f5b195ede56e4b4ed0435b428c2f2b6d35046fbb5e8/cryptography-46.0.4-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:47bcd19517e6389132f76e2d5303ded6cf3f78903da2158a671be8de024f4cd0", size = 4423124, upload-time = "2026-01-28T00:23:11.529Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/5b/a26407d4f79d61ca4bebaa9213feafdd8806dc69d3d290ce24996d3cfe43/cryptography-46.0.4-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:01df4f50f314fbe7009f54046e908d1754f19d0c6d3070df1e6268c5a4af09fa", size = 4277090, upload-time = "2026-01-28T00:23:13.123Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/d8/4bb7aec442a9049827aa34cee1aa83803e528fa55da9a9d45d01d1bb933e/cryptography-46.0.4-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:5aa3e463596b0087b3da0dbe2b2487e9fc261d25da85754e30e3b40637d61f81", size = 4947652, upload-time = "2026-01-28T00:23:14.554Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/08/f83e2e0814248b844265802d081f2fac2f1cbe6cd258e72ba14ff006823a/cryptography-46.0.4-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0a9ad24359fee86f131836a9ac3bffc9329e956624a2d379b613f8f8abaf5255", size = 4455157, upload-time = "2026-01-28T00:23:16.443Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/05/19d849cf4096448779d2dcc9bb27d097457dac36f7273ffa875a93b5884c/cryptography-46.0.4-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:dc1272e25ef673efe72f2096e92ae39dea1a1a450dd44918b15351f72c5a168e", size = 3981078, upload-time = "2026-01-28T00:23:17.838Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/89/f7bac81d66ba7cde867a743ea5b37537b32b5c633c473002b26a226f703f/cryptography-46.0.4-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:de0f5f4ec8711ebc555f54735d4c673fc34b65c44283895f1a08c2b49d2fd99c", size = 4276213, upload-time = "2026-01-28T00:23:19.257Z" },
+    { url = "https://files.pythonhosted.org/packages/da/9f/7133e41f24edd827020ad21b068736e792bc68eecf66d93c924ad4719fb3/cryptography-46.0.4-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:eeeb2e33d8dbcccc34d64651f00a98cb41b2dc69cef866771a5717e6734dfa32", size = 4912190, upload-time = "2026-01-28T00:23:21.244Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/f7/6d43cbaddf6f65b24816e4af187d211f0bc536a29961f69faedc48501d8e/cryptography-46.0.4-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:3d425eacbc9aceafd2cb429e42f4e5d5633c6f873f5e567077043ef1b9bbf616", size = 4454641, upload-time = "2026-01-28T00:23:22.866Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/4f/ebd0473ad656a0ac912a16bd07db0f5d85184924e14fc88feecae2492834/cryptography-46.0.4-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:91627ebf691d1ea3976a031b61fb7bac1ccd745afa03602275dda443e11c8de0", size = 4405159, upload-time = "2026-01-28T00:23:25.278Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/f7/7923886f32dc47e27adeff8246e976d77258fd2aa3efdd1754e4e323bf49/cryptography-46.0.4-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2d08bc22efd73e8854b0b7caff402d735b354862f1145d7be3b9c0f740fef6a0", size = 4666059, upload-time = "2026-01-28T00:23:26.766Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/a7/0fca0fd3591dffc297278a61813d7f661a14243dd60f499a7a5b48acb52a/cryptography-46.0.4-cp311-abi3-win32.whl", hash = "sha256:82a62483daf20b8134f6e92898da70d04d0ef9a75829d732ea1018678185f4f5", size = 3026378, upload-time = "2026-01-28T00:23:28.317Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/12/652c84b6f9873f0909374864a57b003686c642ea48c84d6c7e2c515e6da5/cryptography-46.0.4-cp311-abi3-win_amd64.whl", hash = "sha256:6225d3ebe26a55dbc8ead5ad1265c0403552a63336499564675b29eb3184c09b", size = 3478614, upload-time = "2026-01-28T00:23:30.275Z" },
+    { url = "https://files.pythonhosted.org/packages/56/f7/f648fdbb61d0d45902d3f374217451385edc7e7768d1b03ff1d0e5ffc17b/cryptography-46.0.4-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:a9556ba711f7c23f77b151d5798f3ac44a13455cc68db7697a1096e6d0563cab", size = 7169583, upload-time = "2026-01-28T00:23:56.558Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cc/8f3224cbb2a928de7298d6ed4790f5ebc48114e02bdc9559196bfb12435d/cryptography-46.0.4-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8bf75b0259e87fa70bddc0b8b4078b76e7fd512fd9afae6c1193bcf440a4dbef", size = 4275419, upload-time = "2026-01-28T00:23:58.364Z" },
+    { url = "https://files.pythonhosted.org/packages/17/43/4a18faa7a872d00e4264855134ba82d23546c850a70ff209e04ee200e76f/cryptography-46.0.4-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3c268a3490df22270955966ba236d6bc4a8f9b6e4ffddb78aac535f1a5ea471d", size = 4419058, upload-time = "2026-01-28T00:23:59.867Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/64/6651969409821d791ba12346a124f55e1b76f66a819254ae840a965d4b9c/cryptography-46.0.4-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:812815182f6a0c1d49a37893a303b44eaac827d7f0d582cecfc81b6427f22973", size = 4278151, upload-time = "2026-01-28T00:24:01.731Z" },
+    { url = "https://files.pythonhosted.org/packages/20/0b/a7fce65ee08c3c02f7a8310cc090a732344066b990ac63a9dfd0a655d321/cryptography-46.0.4-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:a90e43e3ef65e6dcf969dfe3bb40cbf5aef0d523dff95bfa24256be172a845f4", size = 4939441, upload-time = "2026-01-28T00:24:03.175Z" },
+    { url = "https://files.pythonhosted.org/packages/db/a7/20c5701e2cd3e1dfd7a19d2290c522a5f435dd30957d431dcb531d0f1413/cryptography-46.0.4-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a05177ff6296644ef2876fce50518dffb5bcdf903c85250974fc8bc85d54c0af", size = 4451617, upload-time = "2026-01-28T00:24:05.403Z" },
+    { url = "https://files.pythonhosted.org/packages/00/dc/3e16030ea9aa47b63af6524c354933b4fb0e352257c792c4deeb0edae367/cryptography-46.0.4-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:daa392191f626d50f1b136c9b4cf08af69ca8279d110ea24f5c2700054d2e263", size = 3977774, upload-time = "2026-01-28T00:24:06.851Z" },
+    { url = "https://files.pythonhosted.org/packages/42/c8/ad93f14118252717b465880368721c963975ac4b941b7ef88f3c56bf2897/cryptography-46.0.4-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e07ea39c5b048e085f15923511d8121e4a9dc45cee4e3b970ca4f0d338f23095", size = 4277008, upload-time = "2026-01-28T00:24:08.926Z" },
+    { url = "https://files.pythonhosted.org/packages/00/cf/89c99698151c00a4631fbfcfcf459d308213ac29e321b0ff44ceeeac82f1/cryptography-46.0.4-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:d5a45ddc256f492ce42a4e35879c5e5528c09cd9ad12420828c972951d8e016b", size = 4903339, upload-time = "2026-01-28T00:24:12.009Z" },
+    { url = "https://files.pythonhosted.org/packages/03/c3/c90a2cb358de4ac9309b26acf49b2a100957e1ff5cc1e98e6c4996576710/cryptography-46.0.4-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:6bb5157bf6a350e5b28aee23beb2d84ae6f5be390b2f8ee7ea179cda077e1019", size = 4451216, upload-time = "2026-01-28T00:24:13.975Z" },
+    { url = "https://files.pythonhosted.org/packages/96/2c/8d7f4171388a10208671e181ca43cdc0e596d8259ebacbbcfbd16de593da/cryptography-46.0.4-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:dd5aba870a2c40f87a3af043e0dee7d9eb02d4aff88a797b48f2b43eff8c3ab4", size = 4404299, upload-time = "2026-01-28T00:24:16.169Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/23/cbb2036e450980f65c6e0a173b73a56ff3bccd8998965dea5cc9ddd424a5/cryptography-46.0.4-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:93d8291da8d71024379ab2cb0b5c57915300155ad42e07f76bea6ad838d7e59b", size = 4664837, upload-time = "2026-01-28T00:24:17.629Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/21/f7433d18fe6d5845329cbdc597e30caf983229c7a245bcf54afecc555938/cryptography-46.0.4-cp38-abi3-win32.whl", hash = "sha256:0563655cb3c6d05fb2afe693340bc050c30f9f34e15763361cf08e94749401fc", size = 3009779, upload-time = "2026-01-28T00:24:20.198Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/6a/bd2e7caa2facffedf172a45c1a02e551e6d7d4828658c9a245516a598d94/cryptography-46.0.4-cp38-abi3-win_amd64.whl", hash = "sha256:fa0900b9ef9c49728887d1576fd8d9e7e3ea872fa9b25ef9b64888adc434e976", size = 3466633, upload-time = "2026-01-28T00:24:21.851Z" },
+    { url = "https://files.pythonhosted.org/packages/59/e0/f9c6c53e1f2a1c2507f00f2faba00f01d2f334b35b0fbfe5286715da2184/cryptography-46.0.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:766330cce7416c92b5e90c3bb71b1b79521760cdcfc3a6a1a182d4c9fab23d2b", size = 3476316, upload-time = "2026-01-28T00:24:24.144Z" },
+    { url = "https://files.pythonhosted.org/packages/27/7a/f8d2d13227a9a1a9fe9c7442b057efecffa41f1e3c51d8622f26b9edbe8f/cryptography-46.0.4-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c236a44acfb610e70f6b3e1c3ca20ff24459659231ef2f8c48e879e2d32b73da", size = 4216693, upload-time = "2026-01-28T00:24:25.758Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/de/3787054e8f7972658370198753835d9d680f6cd4a39df9f877b57f0dd69c/cryptography-46.0.4-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:8a15fb869670efa8f83cbffbc8753c1abf236883225aed74cd179b720ac9ec80", size = 4382765, upload-time = "2026-01-28T00:24:27.577Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/5f/60e0afb019973ba6a0b322e86b3d61edf487a4f5597618a430a2a15f2d22/cryptography-46.0.4-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:fdc3daab53b212472f1524d070735b2f0c214239df131903bae1d598016fa822", size = 4216066, upload-time = "2026-01-28T00:24:29.056Z" },
+    { url = "https://files.pythonhosted.org/packages/81/8e/bf4a0de294f147fee66f879d9bae6f8e8d61515558e3d12785dd90eca0be/cryptography-46.0.4-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:44cc0675b27cadb71bdbb96099cca1fa051cd11d2ade09e5cd3a2edb929ed947", size = 4382025, upload-time = "2026-01-28T00:24:30.681Z" },
+    { url = "https://files.pythonhosted.org/packages/79/f4/9ceb90cfd6a3847069b0b0b353fd3075dc69b49defc70182d8af0c4ca390/cryptography-46.0.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:be8c01a7d5a55f9a47d1888162b76c8f49d62b234d88f0ff91a9fbebe32ffbc3", size = 3406043, upload-time = "2026-01-28T00:24:32.236Z" },
 ]
 
 [[package]]
@@ -4195,7 +4193,7 @@ wheels = [
 
 [[package]]
 name = "nltk"
-version = "3.9.3"
+version = "3.9.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
@@ -4203,9 +4201,9 @@ dependencies = [
     { name = "regex" },
     { name = "tqdm" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e1/8f/915e1c12df07c70ed779d18ab83d065718a926e70d3ea33eb0cd66ffb7c0/nltk-3.9.3.tar.gz", hash = "sha256:cb5945d6424a98d694c2b9a0264519fab4363711065a46aa0ae7a2195b92e71f", size = 2923673, upload-time = "2026-02-24T12:05:53.833Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/76/3a5e4312c19a028770f86fd7c058cf9f4ec4321c6cf7526bab998a5b683c/nltk-3.9.2.tar.gz", hash = "sha256:0f409e9b069ca4177c1903c3e843eef90c7e92992fa4931ae607da6de49e1419", size = 2887629, upload-time = "2025-10-01T07:19:23.764Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/7e/9af5a710a1236e4772de8dfcc6af942a561327bb9f42b5b4a24d0cf100fd/nltk-3.9.3-py3-none-any.whl", hash = "sha256:60b3db6e9995b3dd976b1f0fa7dec22069b2677e759c28eb69b62ddd44870522", size = 1525385, upload-time = "2026-02-24T12:05:46.54Z" },
+    { url = "https://files.pythonhosted.org/packages/60/90/81ac364ef94209c100e12579629dc92bf7a709a84af32f8c551b02c07e94/nltk-3.9.2-py3-none-any.whl", hash = "sha256:1e209d2b3009110635ed9709a67a1a3e33a10f799490fa71cf4bec218c11c88a", size = 1513404, upload-time = "2025-10-01T07:19:21.648Z" },
 ]
 
 [[package]]